From 86448527bc44e2c74457cab663ef47a3ee4670e7 Mon Sep 17 00:00:00 2001 From: Hugh Sorby Date: Tue, 16 Jun 2026 21:56:28 +1200 Subject: [PATCH 01/11] Add tests for missing *AsString methods. --- tests/CMakeLists.txt | 1 + tests/as_string/as_string.cpp | 237 ++++++++++++++++++++++++++++++++++ tests/as_string/tests.cmake | 18 +++ 3 files changed, 256 insertions(+) create mode 100644 tests/as_string/as_string.cpp create mode 100644 tests/as_string/tests.cmake diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index b2b96add1..9fd4dd4bd 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -29,6 +29,7 @@ mark_as_advanced(gtest_force_shared_crt) # header files _HDRS. include(analyser/tests.cmake) include(annotator/tests.cmake) +include(as_string/tests.cmake) include(clone/tests.cmake) include(component/tests.cmake) include(connection/tests.cmake) diff --git a/tests/as_string/as_string.cpp b/tests/as_string/as_string.cpp new file mode 100644 index 000000000..9ffd367bc --- /dev/null +++ b/tests/as_string/as_string.cpp @@ -0,0 +1,237 @@ +/* +Copyright libCellML Contributors + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include "gtest/gtest.h" + +#include + +TEST(AsString, issueLevel) +{ + EXPECT_EQ("error", libcellml::Issue::levelAsString(libcellml::Issue::Level::ERROR)); + EXPECT_EQ("message", libcellml::Issue::levelAsString(libcellml::Issue::Level::MESSAGE)); + EXPECT_EQ("warning", libcellml::Issue::levelAsString(libcellml::Issue::Level::WARNING)); +} + +TEST(AsString, issueReferenceRule) +{ + EXPECT_EQ("", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNDEFINED)); + EXPECT_EQ("xml", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::XML)); + EXPECT_EQ("xml_unexpected_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::XML_UNEXPECTED_ELEMENT)); + EXPECT_EQ("xml_unexpected_character", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::XML_UNEXPECTED_CHARACTER)); + EXPECT_EQ("xml_unexpected_namespace", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::XML_UNEXPECTED_NAMESPACE)); + EXPECT_EQ("xml_attribute_has_namespace", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::XML_ATTRIBUTE_HAS_NAMESPACE)); + EXPECT_EQ("xml_id_attribute", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::XML_ID_ATTRIBUTE)); + EXPECT_EQ("model_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MODEL_ELEMENT)); + EXPECT_EQ("model_name", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MODEL_NAME)); + EXPECT_EQ("model_name_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MODEL_NAME_VALUE)); + EXPECT_EQ("model_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MODEL_CHILD)); + EXPECT_EQ("model_more_than_one_encapsulation", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION)); + EXPECT_EQ("import_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_ELEMENT)); + EXPECT_EQ("import_href", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_HREF)); + EXPECT_EQ("import_href_locator", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_HREF_LOCATOR)); + EXPECT_EQ("import_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_CHILD)); + EXPECT_EQ("import_equivalent_infoset", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_EQUIVALENT_INFOSET)); + EXPECT_EQ("import_units_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_UNITS_ELEMENT)); + EXPECT_EQ("import_component_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_ELEMENT)); + EXPECT_EQ("import_component_name", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_NAME)); + EXPECT_EQ("import_component_name_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_NAME_VALUE)); + EXPECT_EQ("import_component_name_unique", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_NAME_UNIQUE)); + EXPECT_EQ("import_component_component_reference", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_COMPONENT_REFERENCE)); + EXPECT_EQ("import_component_component_reference_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_COMPONENT_REFERENCE_VALUE)); + EXPECT_EQ("import_component_component_reference_target", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_COMPONENT_REFERENCE_TARGET)); + EXPECT_EQ("units_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNITS_ELEMENT)); + EXPECT_EQ("units_name", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNITS_NAME)); + EXPECT_EQ("units_name_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNITS_NAME_VALUE)); + EXPECT_EQ("units_standard", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNITS_STANDARD)); + EXPECT_EQ("units_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNITS_CHILD)); + EXPECT_EQ("unit_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNIT_ELEMENT)); + EXPECT_EQ("unit_units", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNIT_UNITS)); + EXPECT_EQ("unit_units_reference", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNIT_UNITS_REFERENCE)); + EXPECT_EQ("unit_units_circular_reference", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNIT_UNITS_CIRCULAR_REFERENCE)); + EXPECT_EQ("unit_attribute_optional", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNIT_ATTRIBUTE_OPTIONAL)); + EXPECT_EQ("unit_attribute_prefix_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNIT_ATTRIBUTE_PREFIX_VALUE)); + EXPECT_EQ("unit_attribute_multiplier_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNIT_ATTRIBUTE_MULTIPLIER_VALUE)); + EXPECT_EQ("unit_attribute_exponent_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNIT_ATTRIBUTE_EXPONENT_VALUE)); + EXPECT_EQ("component_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::COMPONENT_ELEMENT)); + EXPECT_EQ("component_name", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::COMPONENT_NAME)); + EXPECT_EQ("component_name_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::COMPONENT_NAME_VALUE)); + EXPECT_EQ("component_name_unique", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::COMPONENT_NAME_UNIQUE)); + EXPECT_EQ("component_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::COMPONENT_CHILD)); + EXPECT_EQ("variable_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::VARIABLE_ELEMENT)); + EXPECT_EQ("variable_attribute_required", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::VARIABLE_ATTRIBUTE_REQUIRED)); + EXPECT_EQ("variable_name_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::VARIABLE_NAME_VALUE)); + EXPECT_EQ("variable_name_unique", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::VARIABLE_NAME_UNIQUE)); + EXPECT_EQ("variable_units_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::VARIABLE_UNITS_VALUE)); + EXPECT_EQ("variable_attribute_optional", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::VARIABLE_ATTRIBUTE_OPTIONAL)); + EXPECT_EQ("variable_interface_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::VARIABLE_INTERFACE_VALUE)); + EXPECT_EQ("variable_initial_value_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::VARIABLE_INITIAL_VALUE_VALUE)); + EXPECT_EQ("reset_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::RESET_ELEMENT)); + EXPECT_EQ("reset_attribute_required", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::RESET_ATTRIBUTE_REQUIRED)); + EXPECT_EQ("reset_variable_reference", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::RESET_VARIABLE_REFERENCE)); + EXPECT_EQ("reset_test_variable_reference", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE)); + EXPECT_EQ("reset_order_value", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::RESET_ORDER_VALUE)); + EXPECT_EQ("reset_order_unique", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::RESET_ORDER_UNIQUE)); + EXPECT_EQ("reset_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::RESET_CHILD)); + EXPECT_EQ("reset_reset_value_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::RESET_RESET_VALUE_CHILD)); + EXPECT_EQ("reset_test_value_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::RESET_TEST_VALUE_CHILD)); + EXPECT_EQ("test_value_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::TEST_VALUE_ELEMENT)); + EXPECT_EQ("test_value_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::TEST_VALUE_CHILD)); + EXPECT_EQ("reset_value_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::RESET_VALUE_ELEMENT)); + EXPECT_EQ("reset_value_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::RESET_VALUE_CHILD)); + EXPECT_EQ("math_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MATH_ELEMENT)); + EXPECT_EQ("math_mathml", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MATH_MATHML)); + EXPECT_EQ("math_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MATH_CHILD)); + EXPECT_EQ("math_ci_variable_reference", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MATH_CI_VARIABLE_REFERENCE)); + EXPECT_EQ("math_cn_units_attribute", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MATH_CN_UNITS_ATTRIBUTE)); + EXPECT_EQ("math_cn_units_attribute_reference", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MATH_CN_UNITS_ATTRIBUTE_REFERENCE)); + EXPECT_EQ("math_cn_base10", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MATH_CN_BASE10)); + EXPECT_EQ("math_cn_format", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MATH_CN_FORMAT)); + EXPECT_EQ("encapsulation_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ENCAPSULATION_ELEMENT)); + EXPECT_EQ("encapsulation_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ENCAPSULATION_CHILD)); + EXPECT_EQ("component_ref_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::COMPONENT_REF_ELEMENT)); + EXPECT_EQ("component_ref_component_attribute", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE)); + EXPECT_EQ("component_ref_component_attribute_reference", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE_REFERENCE)); + EXPECT_EQ("component_ref_component_attribute_unique", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE_UNIQUE)); + EXPECT_EQ("component_ref_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::COMPONENT_REF_CHILD)); + EXPECT_EQ("connection_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::CONNECTION_ELEMENT)); + EXPECT_EQ("connection_component1_attribute", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::CONNECTION_COMPONENT1_ATTRIBUTE)); + EXPECT_EQ("connection_component1_attribute_reference", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::CONNECTION_COMPONENT1_ATTRIBUTE_REFERENCE)); + EXPECT_EQ("connection_component2_attribute", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::CONNECTION_COMPONENT2_ATTRIBUTE)); + EXPECT_EQ("connection_component2_attribute_reference", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::CONNECTION_COMPONENT2_ATTRIBUTE_REFERENCE)); + EXPECT_EQ("connection_exclude_self", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::CONNECTION_EXCLUDE_SELF)); + EXPECT_EQ("connection_unique", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::CONNECTION_UNIQUE)); + EXPECT_EQ("connection_child", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::CONNECTION_CHILD)); + EXPECT_EQ("map_variables_element", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MAP_VARIABLES_ELEMENT)); + EXPECT_EQ("map_variables_variable1_attribute", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1_ATTRIBUTE)); + EXPECT_EQ("map_variables_variable1_attribute_reference", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1_ATTRIBUTE_REFERENCE)); + EXPECT_EQ("map_variables_variable2_attribute", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2_ATTRIBUTE)); + EXPECT_EQ("map_variables_variable2_attribute_reference", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2_ATTRIBUTE_REFERENCE)); + EXPECT_EQ("map_variables_unique", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::MAP_VARIABLES_UNIQUE)); + EXPECT_EQ("data_repr_identifier_at_least_one_alphanum", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM)); + EXPECT_EQ("data_repr_identifier_begin_euro_num", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM)); + EXPECT_EQ("data_repr_identifier_latin_alphanum", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM)); + EXPECT_EQ("invalid_argument", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::INVALID_ARGUMENT)); + EXPECT_EQ("importer_error_importing_units", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORTER_ERROR_IMPORTING_UNITS)); + EXPECT_EQ("importer_missing_file", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORTER_MISSING_FILE)); + EXPECT_EQ("importer_missing_component", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORTER_MISSING_COMPONENT)); + EXPECT_EQ("importer_missing_units", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORTER_MISSING_UNITS)); + EXPECT_EQ("importer_null_model", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORTER_NULL_MODEL)); + EXPECT_EQ("importer_undefined_model", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORTER_UNDEFINED_MODEL)); + EXPECT_EQ("importer_unresolved_imports", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::IMPORTER_UNRESOLVED_IMPORTS)); + EXPECT_EQ("analyser_equation_not_equality_statement", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_EQUATION_NOT_EQUALITY_STATEMENT)); + EXPECT_EQ("analyser_units", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_UNITS)); + EXPECT_EQ("analyser_unlinked_units", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_UNLINKED_UNITS)); + EXPECT_EQ("analyser_variable_initialised_more_than_once", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE)); + EXPECT_EQ("analyser_variable_initialised_using_algebraic_variable", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE)); + EXPECT_EQ("analyser_variable_initialised_using_variable_with_different_units", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS)); + EXPECT_EQ("analyser_voi_initialised", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_VOI_INITIALISED)); + EXPECT_EQ("analyser_voi_several", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_VOI_SEVERAL)); + EXPECT_EQ("analyser_ode_not_first_order", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_ODE_NOT_FIRST_ORDER)); + EXPECT_EQ("analyser_variable_unused", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNUSED)); + EXPECT_EQ("analyser_state_not_initialised", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_STATE_NOT_INITIALISED)); + EXPECT_EQ("analyser_state_rate_as_algebraic_variable", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE)); + EXPECT_EQ("analyser_variable_underconstrained", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNDERCONSTRAINED)); + EXPECT_EQ("analyser_variable_overconstrained", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED)); + EXPECT_EQ("analyser_external_variable_different_model", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_DIFFERENT_MODEL)); + EXPECT_EQ("analyser_external_variable_voi", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_VOI)); + EXPECT_EQ("analyser_external_variable_use_primary_variable", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_USE_PRIMARY_VARIABLE)); + EXPECT_EQ("annotator_id_not_found", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANNOTATOR_ID_NOT_FOUND)); + EXPECT_EQ("annotator_id_not_unique", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANNOTATOR_ID_NOT_UNIQUE)); + EXPECT_EQ("annotator_no_model", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANNOTATOR_NO_MODEL)); + EXPECT_EQ("annotator_inconsistent_type", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANNOTATOR_INCONSISTENT_TYPE)); + EXPECT_EQ("annotator_null_model", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::ANNOTATOR_NULL_MODEL)); + EXPECT_EQ("generator_null_model", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::GENERATOR_NULL_MODEL)); + EXPECT_EQ("generator_null_variable", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::GENERATOR_NULL_VARIABLE)); + EXPECT_EQ("generator_voi_variable_always_tracked", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::GENERATOR_VOI_VARIABLE_ALWAYS_TRACKED)); + EXPECT_EQ("generator_voi_variable_not_untrackable", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::GENERATOR_VOI_VARIABLE_NOT_UNTRACKABLE)); + EXPECT_EQ("generator_state_variable_always_tracked", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::GENERATOR_STATE_VARIABLE_ALWAYS_TRACKED)); + EXPECT_EQ("generator_state_variable_not_untrackable", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::GENERATOR_STATE_VARIABLE_NOT_UNTRACKABLE)); + EXPECT_EQ("generator_external_variable_always_tracked", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::GENERATOR_EXTERNAL_VARIABLE_ALWAYS_TRACKED)); + EXPECT_EQ("generator_external_variable_not_untrackable", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::GENERATOR_EXTERNAL_VARIABLE_NOT_UNTRACKABLE)); + EXPECT_EQ("generator_nla_based_variable_always_tracked", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_ALWAYS_TRACKED)); + EXPECT_EQ("generator_nla_based_variable_not_untrackable", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE)); + EXPECT_EQ("generator_externally_needed_variable_always_tracked", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_ALWAYS_TRACKED)); + EXPECT_EQ("generator_externally_needed_variable_not_untrackable", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE)); + EXPECT_EQ("unspecified", libcellml::Issue::referenceRuleAsString(libcellml::Issue::ReferenceRule::UNSPECIFIED)); +} + +TEST(AsString, unitsPrefix) +{ + EXPECT_EQ("atto", libcellml::Units::prefixAsString(libcellml::Units::Prefix::ATTO)); + EXPECT_EQ("centi", libcellml::Units::prefixAsString(libcellml::Units::Prefix::CENTI)); + EXPECT_EQ("deca", libcellml::Units::prefixAsString(libcellml::Units::Prefix::DECA)); + EXPECT_EQ("deci", libcellml::Units::prefixAsString(libcellml::Units::Prefix::DECI)); + EXPECT_EQ("exa", libcellml::Units::prefixAsString(libcellml::Units::Prefix::EXA)); + EXPECT_EQ("femto", libcellml::Units::prefixAsString(libcellml::Units::Prefix::FEMTO)); + EXPECT_EQ("giga", libcellml::Units::prefixAsString(libcellml::Units::Prefix::GIGA)); + EXPECT_EQ("hecto", libcellml::Units::prefixAsString(libcellml::Units::Prefix::HECTO)); + EXPECT_EQ("kilo", libcellml::Units::prefixAsString(libcellml::Units::Prefix::KILO)); + EXPECT_EQ("mega", libcellml::Units::prefixAsString(libcellml::Units::Prefix::MEGA)); + EXPECT_EQ("micro", libcellml::Units::prefixAsString(libcellml::Units::Prefix::MICRO)); + EXPECT_EQ("milli", libcellml::Units::prefixAsString(libcellml::Units::Prefix::MILLI)); + EXPECT_EQ("nano", libcellml::Units::prefixAsString(libcellml::Units::Prefix::NANO)); + EXPECT_EQ("peta", libcellml::Units::prefixAsString(libcellml::Units::Prefix::PETA)); + EXPECT_EQ("pico", libcellml::Units::prefixAsString(libcellml::Units::Prefix::PICO)); + EXPECT_EQ("tera", libcellml::Units::prefixAsString(libcellml::Units::Prefix::TERA)); + EXPECT_EQ("yocto", libcellml::Units::prefixAsString(libcellml::Units::Prefix::YOCTO)); + EXPECT_EQ("yotta", libcellml::Units::prefixAsString(libcellml::Units::Prefix::YOTTA)); + EXPECT_EQ("zepto", libcellml::Units::prefixAsString(libcellml::Units::Prefix::ZEPTO)); + EXPECT_EQ("zetta", libcellml::Units::prefixAsString(libcellml::Units::Prefix::ZETTA)); +} + +TEST(AsString, unitsStandardUnit) +{ + EXPECT_EQ("ampere", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::AMPERE)); + EXPECT_EQ("becquerel", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::BECQUEREL)); + EXPECT_EQ("candela", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::CANDELA)); + EXPECT_EQ("dimensionless", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::DIMENSIONLESS)); + EXPECT_EQ("kelvin", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::KELVIN)); + EXPECT_EQ("kilogram", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::KILOGRAM)); + EXPECT_EQ("metre", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::METRE)); + EXPECT_EQ("mole", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::MOLE)); + EXPECT_EQ("second", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::SECOND)); + EXPECT_EQ("coulomb", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::COULOMB)); + EXPECT_EQ("farad", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::FARAD)); + EXPECT_EQ("gram", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::GRAM)); + EXPECT_EQ("gray", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::GRAY)); + EXPECT_EQ("henry", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::HENRY)); + EXPECT_EQ("hertz", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::HERTZ)); + EXPECT_EQ("joule", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::JOULE)); + EXPECT_EQ("katal", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::KATAL)); + EXPECT_EQ("litre", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::LITRE)); + EXPECT_EQ("lumen", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::LUMEN)); + EXPECT_EQ("lux", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::LUX)); + EXPECT_EQ("radian", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::RADIAN)); + EXPECT_EQ("newton", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::NEWTON)); + EXPECT_EQ("ohm", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::OHM)); + EXPECT_EQ("pascal", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::PASCAL)); + EXPECT_EQ("siemens", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::SIEMENS)); + EXPECT_EQ("sievert", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::SIEVERT)); + EXPECT_EQ("steradian", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::STERADIAN)); + EXPECT_EQ("tesla", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::TESLA)); + EXPECT_EQ("volt", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::VOLT)); + EXPECT_EQ("watt", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::WATT)); + EXPECT_EQ("weber", libcellml::Units::standardUnitAsString(libcellml::Units::StandardUnit::WEBER)); +} + +TEST(AsString, variableInterfaceType) +{ + EXPECT_EQ("none", libcellml::Variable::interfaceTypeAsString(libcellml::Variable::InterfaceType::NONE)); + EXPECT_EQ("public", libcellml::Variable::interfaceTypeAsString(libcellml::Variable::InterfaceType::PUBLIC)); + EXPECT_EQ("private", libcellml::Variable::interfaceTypeAsString(libcellml::Variable::InterfaceType::PRIVATE)); + EXPECT_EQ("public_and_private", libcellml::Variable::interfaceTypeAsString(libcellml::Variable::InterfaceType::PUBLIC_AND_PRIVATE)); +} + diff --git a/tests/as_string/tests.cmake b/tests/as_string/tests.cmake new file mode 100644 index 000000000..49a6447c4 --- /dev/null +++ b/tests/as_string/tests.cmake @@ -0,0 +1,18 @@ + +# Set the test name, 'test_' will be prepended to the +# name set here +set(CURRENT_TEST as_string) +# Set a category name to enable running commands like: +# ctest -R +# which will run the tests matching this category-label. +# Can be left empty (or just not set) +set(${CURRENT_TEST}_CATEGORY misc) +list(APPEND LIBCELLML_TESTS ${CURRENT_TEST}) +# Using absolute path relative to this file +set(${CURRENT_TEST}_SRCS + ${CMAKE_CURRENT_LIST_DIR}/as_string.cpp +) +set(${CURRENT_TEST}_HDRS +) + + From 91771de94dd5924a975473cbd2fb5a9f5c4b7fe7 Mon Sep 17 00:00:00 2001 From: Hugh Sorby Date: Tue, 16 Jun 2026 21:57:06 +1200 Subject: [PATCH 02/11] Implement missing *AsString methods. Fix missing and erroneus enum mappings. --- src/api/libcellml/issue.h | 22 +++++++++++++++++++ src/api/libcellml/units.h | 24 +++++++++++++++++++++ src/api/libcellml/variable.h | 12 +++++++++++ src/issue.cpp | 42 +++++++++++++++++++++++++++++++++++- src/units.cpp | 10 +++++++++ src/variable.cpp | 7 ++++++ 6 files changed, 116 insertions(+), 1 deletion(-) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 51d5bf41f..f6c7a5cdf 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -60,6 +60,17 @@ class LIBCELLML_EXPORT Issue MESSAGE }; + /** + * @brief Get the string version of a @ref Level. + * + * Return the string version of a @ref Level. + * + * @param level The level for which we want the string version. + * + * @return The string version of the @ref Level. + */ + static std::string levelAsString(Level level); + /** * @brief The issue Reference enum class. * @@ -231,6 +242,17 @@ class LIBCELLML_EXPORT Issue UNSPECIFIED }; + /** + * @brief Get the string version of a @ref ReferenceRule. + * + * Return the string version of a @ref ReferenceRule. + * + * @param rule The refererence rule for which we want the string version. + * + * @return The string version of the @ref ReferenceRule. + */ + static std::string referenceRuleAsString(ReferenceRule rule); + /** * @brief Get the description for this issue. * diff --git a/src/api/libcellml/units.h b/src/api/libcellml/units.h index 35f7b21b9..a61f3ba31 100644 --- a/src/api/libcellml/units.h +++ b/src/api/libcellml/units.h @@ -107,6 +107,18 @@ class LIBCELLML_EXPORT Units: public NamedEntity, public ImportedEntity YOCTO }; + /** + * @brief Get the string version of a @ref Prefix. + * + * Return the string version of a @ref Prefix. + * + * @param prefix The prefix for which we want the string version. + * + * @return The string version of the @ref Prefix. + */ + + static std::string prefixAsString(Prefix prefix); + /** * @brief The Standard Unit enum class. * @@ -151,6 +163,18 @@ class LIBCELLML_EXPORT Units: public NamedEntity, public ImportedEntity WEBER /**< Derived SI unit weber. */ }; + /** + * @brief Get the string version of a @ref StandardUnit. + * + * Return the string version of a @ref StandardUnit. + * + * @param unit The unit for which we want the string version. + * + * @return The string version of the @ref StandardUnit. + */ + + static std::string standardUnitAsString(StandardUnit unit); + /** * @brief Test to determine if Units is a base unit. * diff --git a/src/api/libcellml/variable.h b/src/api/libcellml/variable.h index 2d9e6292d..06d9fdb2c 100644 --- a/src/api/libcellml/variable.h +++ b/src/api/libcellml/variable.h @@ -82,6 +82,18 @@ class LIBCELLML_EXPORT Variable: public NamedEntity PUBLIC_AND_PRIVATE }; + /** + * @brief Get the string version of a @ref InterfaceType. + * + * Return the string version of a @ref InterfaceType. + * + * @param type The type for which we want the string version. + * + * @return The string version of the @ref InterfaceType. + */ + + static std::string interfaceTypeAsString(InterfaceType type); + /** * @brief Add each argument variable to the other's equivalent variable set. * diff --git a/src/issue.cpp b/src/issue.cpp index da64bd978..8a835ea22 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -71,6 +71,22 @@ AnyCellmlElementPtr Issue::item() const return mPimpl->mItem; } +/** + * @brief Map Level to their string versions. + * + * An internal map used to convert a Issue::Level into its string version. + */ +static const std::map levelToString = { + {Issue::Level::ERROR, "error"}, + {Issue::Level::MESSAGE, "message"}, + {Issue::Level::WARNING, "warning"} +}; + +std::string Issue::levelAsString(Level level) +{ + return levelToString.at(level); +} + /** * @brief Map ReferenceRules to their section titles. * @@ -176,7 +192,7 @@ static const std::map> ruleToInfo {Issue::ReferenceRule::MAP_VARIABLES_ELEMENT, {"MAP_VARIABLES_ELEMENT", "2.16", baseSpecificationUrl, "specB16"}}, {Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1_ATTRIBUTE, {"MAP_VARIABLES_VARIABLE1_ATTRIBUTE", "2.16.1", baseSpecificationUrl, "specB16"}}, {Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1_ATTRIBUTE_REFERENCE, {"MAP_VARIABLES_VARIABLE1_ATTRIBUTE_REFERENCE", "2.16.1.1", baseSpecificationUrl, "specB16"}}, - {Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2_ATTRIBUTE, {"MAP_VARIABLES_VARIABLE2", "2.16.2", baseSpecificationUrl, "specB16"}}, + {Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2_ATTRIBUTE, {"MAP_VARIABLES_VARIABLE2_ATTRIBUTE", "2.16.2", baseSpecificationUrl, "specB16"}}, {Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2_ATTRIBUTE_REFERENCE, {"MAP_VARIABLES_VARIABLE2_ATTRIBUTE_REFERENCE", "2.16.2.1", baseSpecificationUrl, "specB16"}}, {Issue::ReferenceRule::MAP_VARIABLES_UNIQUE, {"MAP_VARIABLES_UNIQUE", "2.16.3", baseSpecificationUrl, "specB16"}}, @@ -223,8 +239,32 @@ static const std::map> ruleToInfo {Issue::ReferenceRule::ANNOTATOR_INCONSISTENT_TYPE, {"ANNOTATOR_INCONSISTENT_TYPE", "", docsUrl, ""}}, {Issue::ReferenceRule::ANNOTATOR_NULL_MODEL, {"ANNOTATOR_NULL_MODEL", "", docsUrl, ""}}, + // Generator issues: + {Issue::ReferenceRule::GENERATOR_NULL_MODEL, {"GENERATOR_NULL_MODEL", "", docsUrl, ""}}, + {Issue::ReferenceRule::GENERATOR_NULL_VARIABLE, {"GENERATOR_NULL_VARIABLE", "", docsUrl, ""}}, + {Issue::ReferenceRule::GENERATOR_VOI_VARIABLE_ALWAYS_TRACKED, {"GENERATOR_VOI_VARIABLE_ALWAYS_TRACKED", "", docsUrl, ""}}, + {Issue::ReferenceRule::GENERATOR_VOI_VARIABLE_NOT_UNTRACKABLE, {"GENERATOR_VOI_VARIABLE_NOT_UNTRACKABLE", "", docsUrl, ""}}, + {Issue::ReferenceRule::GENERATOR_STATE_VARIABLE_ALWAYS_TRACKED, {"GENERATOR_STATE_VARIABLE_ALWAYS_TRACKED", "", docsUrl, ""}}, + {Issue::ReferenceRule::GENERATOR_STATE_VARIABLE_NOT_UNTRACKABLE, {"GENERATOR_STATE_VARIABLE_NOT_UNTRACKABLE", "", docsUrl, ""}}, + {Issue::ReferenceRule::GENERATOR_EXTERNAL_VARIABLE_ALWAYS_TRACKED, {"GENERATOR_EXTERNAL_VARIABLE_ALWAYS_TRACKED", "", docsUrl, ""}}, + {Issue::ReferenceRule::GENERATOR_EXTERNAL_VARIABLE_NOT_UNTRACKABLE, {"GENERATOR_EXTERNAL_VARIABLE_NOT_UNTRACKABLE", "", docsUrl, ""}}, + {Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_ALWAYS_TRACKED, {"GENERATOR_NLA_BASED_VARIABLE_ALWAYS_TRACKED", "", docsUrl, ""}}, + {Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE, {"GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE", "", docsUrl, ""}}, + {Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_ALWAYS_TRACKED, {"GENERATOR_EXTERNALLY_NEEDED_VARIABLE_ALWAYS_TRACKED", "", docsUrl, ""}}, + {Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE, {"GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE", "", docsUrl, ""}}, + + // Placeholder: + {Issue::ReferenceRule::UNSPECIFIED, {"UNSPECIFIED", "", "", ""}} + }; +std::string Issue::referenceRuleAsString(ReferenceRule rule) +{ + std::string data = ruleToInformation.at(rule)[0]; + std::transform(data.begin(), data.end(), data.begin(), [](unsigned char c){ return std::tolower(c); }); + return data; +} + std::string Issue::referenceHeading() const { return ruleToInformation.at(referenceRule())[1]; diff --git a/src/units.cpp b/src/units.cpp index 2cddc0811..d4a1e3b03 100644 --- a/src/units.cpp +++ b/src/units.cpp @@ -90,6 +90,16 @@ static const std::map standardUnitToStri {Units::StandardUnit::WATT, "watt"}, {Units::StandardUnit::WEBER, "weber"}}; +std::string Units::prefixAsString(Units::Prefix prefix) +{ + return prefixToString.at(prefix); +} + +std::string Units::standardUnitAsString(Units::StandardUnit standardUnit) +{ + return standardUnitToString.at(standardUnit); +} + std::vector::const_iterator Units::UnitsImpl::findUnit(const std::string &reference) const { return std::find_if(mUnitDefinitions.begin(), mUnitDefinitions.end(), diff --git a/src/variable.cpp b/src/variable.cpp index 5644b6321..8e7e678c2 100644 --- a/src/variable.cpp +++ b/src/variable.cpp @@ -28,6 +28,13 @@ limitations under the License. namespace libcellml { + +std::string Variable::interfaceTypeAsString(Variable::InterfaceType type) +{ + return interfaceTypeToString.at(type); +} + + std::vector::const_iterator Variable::VariableImpl::findEquivalentVariable(const VariablePtr &equivalentVariable) const { return std::find_if(mEquivalentVariables.begin(), mEquivalentVariables.end(), From 389ff0ffb1f1ec3dfc61e0b7cf9a443c71f1fb39 Mon Sep 17 00:00:00 2001 From: Hugh Sorby Date: Wed, 17 Jun 2026 10:28:01 +1200 Subject: [PATCH 03/11] Declare issue as string methods? --- src/api/libcellml/issue.h | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 51d5bf41f..f6c7a5cdf 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -60,6 +60,17 @@ class LIBCELLML_EXPORT Issue MESSAGE }; + /** + * @brief Get the string version of a @ref Level. + * + * Return the string version of a @ref Level. + * + * @param level The level for which we want the string version. + * + * @return The string version of the @ref Level. + */ + static std::string levelAsString(Level level); + /** * @brief The issue Reference enum class. * @@ -231,6 +242,17 @@ class LIBCELLML_EXPORT Issue UNSPECIFIED }; + /** + * @brief Get the string version of a @ref ReferenceRule. + * + * Return the string version of a @ref ReferenceRule. + * + * @param rule The refererence rule for which we want the string version. + * + * @return The string version of the @ref ReferenceRule. + */ + static std::string referenceRuleAsString(ReferenceRule rule); + /** * @brief Get the description for this issue. * From 44dd5b8ab7e1c6f5a001934981294e0e26abf5d0 Mon Sep 17 00:00:00 2001 From: Hugh Sorby Date: Wed, 17 Jun 2026 10:28:59 +1200 Subject: [PATCH 04/11] Fix refererence typo in issue.h. --- src/api/libcellml/issue.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index f6c7a5cdf..aa26b3698 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -247,7 +247,7 @@ class LIBCELLML_EXPORT Issue * * Return the string version of a @ref ReferenceRule. * - * @param rule The refererence rule for which we want the string version. + * @param rule The reference rule for which we want the string version. * * @return The string version of the @ref ReferenceRule. */ From a6aa189c6cf8893796bd3857ef5d8c29b8e18ccb Mon Sep 17 00:00:00 2001 From: Hugh Sorby Date: Wed, 17 Jun 2026 11:18:40 +1200 Subject: [PATCH 05/11] Add documentation for as string functions to Python bindings. --- src/bindings/interface/issue.i | 6 ++++++ src/bindings/interface/units.i | 6 ++++++ src/bindings/interface/variable.i | 3 +++ 3 files changed, 15 insertions(+) diff --git a/src/bindings/interface/issue.i b/src/bindings/interface/issue.i index 3f5c423c3..de7ec3b40 100644 --- a/src/bindings/interface/issue.i +++ b/src/bindings/interface/issue.i @@ -31,6 +31,12 @@ Level::ERROR will be returned."; "Returns the CellML 2.0 Specification heading associated with the :class:`ReferenceRule` for this issue (empty string if not set)."; +%feature("docstring") libcellml::Issue::referenceRuleAsString +"Get the string version of a :class:`ReferenceRule`."; + +%feature("docstring") libcellml::Issue::levelAsString +"Get the string version of a :class:`Level`."; + %{ #include "libcellml/issue.h" %} diff --git a/src/bindings/interface/units.i b/src/bindings/interface/units.i index 6756dd2a3..cbf1f00ef 100644 --- a/src/bindings/interface/units.i +++ b/src/bindings/interface/units.i @@ -113,6 +113,12 @@ extract the units with the given `name`."; %feature("docstring") libcellml::Units::unitAttributeMultiplier "Get the multiplier from the unit attribute."; +%feature("docstring") libcellml::Units::prefixAsString +"Get the string version of a :class:`Prefix`."; + +%feature("docstring") libcellml::Units::standardUnitAsString +"Get the string version of a :class:`StandardUnit`."; + #if defined(SWIGPYTHON) // Treat negative size_t as invalid index (instead of unknown method) %extend libcellml::Units { diff --git a/src/bindings/interface/variable.i b/src/bindings/interface/variable.i index 4bf571a3f..3822f7f08 100644 --- a/src/bindings/interface/variable.i +++ b/src/bindings/interface/variable.i @@ -99,6 +99,9 @@ not equivalent the connection identifier is not set."; %feature("docstring") libcellml::Variable::clone "Create a copy of this variable."; +%feature("docstring") libcellml::Variable::interfaceTypeAsString +"Get the string version of a :class:`InterfaceType`."; + #if defined(SWIGPYTHON) // Treat negative size_t as invalid index (instead of unknown method) %extend libcellml::Variable { From 5d187e8e5dff532e59d46547ce4f474f748187e2 Mon Sep 17 00:00:00 2001 From: Hugh Sorby Date: Wed, 17 Jun 2026 11:19:10 +1200 Subject: [PATCH 06/11] Fix compilation error for referencerule enum check. --- cmake/environmentchecks.cmake | 2 +- src/bindings/interface/types.i | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cmake/environmentchecks.cmake b/cmake/environmentchecks.cmake index 21ba618b5..c431d81eb 100644 --- a/cmake/environmentchecks.cmake +++ b/cmake/environmentchecks.cmake @@ -55,7 +55,7 @@ else () find_program(INSTALL_NAME_TOOL_EXE NAMES ${PREFERRED_INSTALL_NAME_TOOL_NAMES} install_name_tool) if(Python_Interpreter_FOUND) - if(NOT DEFINED TEST_COVERAGE_RESULT) + if(NOT DEFINED TEST_COVERAGE_RESULT OR NOT TEST_COVERAGE_RESULT EQUAL 0) set(TEST_COVERAGE_RESULT -1 CACHE INTERNAL "Result of testing for Python coverage.") message(STATUS "Performing Test HAVE_COVERAGE") get_filename_component(PYTHON_DIR ${Python_EXECUTABLE} DIRECTORY) diff --git a/src/bindings/interface/types.i b/src/bindings/interface/types.i index fe08900b5..732aae2d0 100644 --- a/src/bindings/interface/types.i +++ b/src/bindings/interface/types.i @@ -194,7 +194,7 @@ Provides support for shared pointers declared in types.h. if (!SWIG_IsOK(ecode)) { %argument_fail(ecode, "$type", $symname, $argnum); } else { - if (val < %static_cast($type::UNDEFINED, int) || %static_cast($type::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION, int) < val) { + if (val < %static_cast($type::UNDEFINED, int) || %static_cast($type::UNSPECIFIED, int) < val) { %argument_fail(ecode, "$type is not a valid value for the enumeration.", $symname, $argnum); } $1 = %static_cast(val, $basetype); From e48388e528070b2fb69cad57e72ea33a9335002b Mon Sep 17 00:00:00 2001 From: Hugh Sorby Date: Wed, 17 Jun 2026 11:33:11 +1200 Subject: [PATCH 07/11] Fix detection of exclude-until-coverage-plugin. --- cmake/environmentchecks.cmake | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/cmake/environmentchecks.cmake b/cmake/environmentchecks.cmake index c431d81eb..1b37d487f 100644 --- a/cmake/environmentchecks.cmake +++ b/cmake/environmentchecks.cmake @@ -55,13 +55,15 @@ else () find_program(INSTALL_NAME_TOOL_EXE NAMES ${PREFERRED_INSTALL_NAME_TOOL_NAMES} install_name_tool) if(Python_Interpreter_FOUND) - if(NOT DEFINED TEST_COVERAGE_RESULT OR NOT TEST_COVERAGE_RESULT EQUAL 0) - set(TEST_COVERAGE_RESULT -1 CACHE INTERNAL "Result of testing for Python coverage.") + if(NOT DEFINED TEST_COVERAGE_RESULT OR NOT TEST_COVERAGE_RESULT STREQUAL "0") + set(TEST_COVERAGE_RESULT "-1" CACHE INTERNAL "Result of testing for Python coverage.") message(STATUS "Performing Test HAVE_COVERAGE") get_filename_component(PYTHON_DIR ${Python_EXECUTABLE} DIRECTORY) execute_process(COMMAND ${Python_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/python_package_check.py exclude-until-coverage-plugin RESULT_VARIABLE TEST_COVERAGE_RESULT OUTPUT_QUIET ERROR_QUIET) - if(TEST_COVERAGE_RESULT EQUAL 0) + # Update TEST_COVERATE_RESULT with test outcome. + set(TEST_COVERAGE_RESULT ${TEST_COVERAGE_RESULT} CACHE INTERNAL "Result of testing for Python coverage." FORCE) + if(TEST_COVERAGE_RESULT STREQUAL "0") set(HAVE_COVERAGE TRUE) message(STATUS "Performing Test HAVE_COVERAGE - Success") else() From 95be2e5de3a20d732ff4f4f569c91e2cc88a40dc Mon Sep 17 00:00:00 2001 From: Hugh Sorby Date: Wed, 17 Jun 2026 11:46:44 +1200 Subject: [PATCH 08/11] Update Javascript bindings. --- src/bindings/javascript/issue.cpp | 237 ++++++++++++++------------- src/bindings/javascript/units.cpp | 2 + src/bindings/javascript/variable.cpp | 1 + 3 files changed, 129 insertions(+), 111 deletions(-) diff --git a/src/bindings/javascript/issue.cpp b/src/bindings/javascript/issue.cpp index b21279ee3..f34e773db 100644 --- a/src/bindings/javascript/issue.cpp +++ b/src/bindings/javascript/issue.cpp @@ -30,139 +30,152 @@ EMSCRIPTEN_BINDINGS(libcellml_issue) { ; enum_("Issue.ReferenceRule") - .value("ANALYSER_EQUATION_NOT_EQUALITY_STATEMENT", libcellml::Issue::ReferenceRule::ANALYSER_EQUATION_NOT_EQUALITY_STATEMENT) - .value("ANALYSER_EXTERNAL_VARIABLE_DIFFERENT_MODEL", libcellml::Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_DIFFERENT_MODEL) - .value("ANALYSER_EXTERNAL_VARIABLE_USE_PRIMARY_VARIABLE", libcellml::Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_USE_PRIMARY_VARIABLE) - .value("ANALYSER_EXTERNAL_VARIABLE_VOI", libcellml::Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_VOI) - .value("ANALYSER_ODE_NOT_FIRST_ORDER", libcellml::Issue::ReferenceRule::ANALYSER_ODE_NOT_FIRST_ORDER) - .value("ANALYSER_STATE_NOT_INITIALISED", libcellml::Issue::ReferenceRule::ANALYSER_STATE_NOT_INITIALISED) - .value("ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE", libcellml::Issue::ReferenceRule::ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE) - .value("ANALYSER_UNITS", libcellml::Issue::ReferenceRule::ANALYSER_UNITS) - .value("ANALYSER_UNLINKED_UNITS", libcellml::Issue::ReferenceRule::ANALYSER_UNLINKED_UNITS) - .value("ANALYSER_VARIABLE_UNDERCONSTRAINED", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNDERCONSTRAINED) - .value("ANALYSER_VARIABLE_OVERCONSTRAINED", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED) - .value("ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE) - .value("ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE) - .value("ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS) - .value("ANALYSER_VARIABLE_UNUSED", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNUSED) - .value("ANALYSER_VOI_INITIALISED", libcellml::Issue::ReferenceRule::ANALYSER_VOI_INITIALISED) - .value("ANALYSER_VOI_SEVERAL", libcellml::Issue::ReferenceRule::ANALYSER_VOI_SEVERAL) - .value("ANNOTATOR_ID_NOT_FOUND", libcellml::Issue::ReferenceRule::ANNOTATOR_ID_NOT_FOUND) - .value("ANNOTATOR_ID_NOT_UNIQUE", libcellml::Issue::ReferenceRule::ANNOTATOR_ID_NOT_UNIQUE) - .value("ANNOTATOR_INCONSISTENT_TYPE", libcellml::Issue::ReferenceRule::ANNOTATOR_INCONSISTENT_TYPE) - .value("ANNOTATOR_NO_MODEL", libcellml::Issue::ReferenceRule::ANNOTATOR_NO_MODEL) - .value("ANNOTATOR_NULL_MODEL", libcellml::Issue::ReferenceRule::ANNOTATOR_NULL_MODEL) - .value("COMPONENT_CHILD", libcellml::Issue::ReferenceRule::COMPONENT_CHILD) + .value("UNDEFINED", libcellml::Issue::ReferenceRule::UNDEFINED) + .value("XML", libcellml::Issue::ReferenceRule::XML) + .value("XML_UNEXPECTED_ELEMENT", libcellml::Issue::ReferenceRule::XML_UNEXPECTED_ELEMENT) + .value("XML_UNEXPECTED_CHARACTER", libcellml::Issue::ReferenceRule::XML_UNEXPECTED_CHARACTER) + .value("XML_UNEXPECTED_NAMESPACE", libcellml::Issue::ReferenceRule::XML_UNEXPECTED_NAMESPACE) + .value("XML_ATTRIBUTE_HAS_NAMESPACE", libcellml::Issue::ReferenceRule::XML_ATTRIBUTE_HAS_NAMESPACE) + .value("XML_ID_ATTRIBUTE", libcellml::Issue::ReferenceRule::XML_ID_ATTRIBUTE) + .value("MODEL_ELEMENT", libcellml::Issue::ReferenceRule::MODEL_ELEMENT) + .value("MODEL_NAME", libcellml::Issue::ReferenceRule::MODEL_NAME) + .value("MODEL_NAME_VALUE", libcellml::Issue::ReferenceRule::MODEL_NAME_VALUE) + .value("MODEL_CHILD", libcellml::Issue::ReferenceRule::MODEL_CHILD) + .value("MODEL_MORE_THAN_ONE_ENCAPSULATION", libcellml::Issue::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION) + .value("IMPORT_ELEMENT", libcellml::Issue::ReferenceRule::IMPORT_ELEMENT) + .value("IMPORT_HREF", libcellml::Issue::ReferenceRule::IMPORT_HREF) + .value("IMPORT_HREF_LOCATOR", libcellml::Issue::ReferenceRule::IMPORT_HREF_LOCATOR) + .value("IMPORT_CHILD", libcellml::Issue::ReferenceRule::IMPORT_CHILD) + .value("IMPORT_EQUIVALENT_INFOSET", libcellml::Issue::ReferenceRule::IMPORT_EQUIVALENT_INFOSET) + .value("IMPORT_UNITS_ELEMENT", libcellml::Issue::ReferenceRule::IMPORT_UNITS_ELEMENT) + .value("IMPORT_UNITS_NAME", libcellml::Issue::ReferenceRule::IMPORT_UNITS_NAME) + .value("IMPORT_UNITS_NAME_VALUE", libcellml::Issue::ReferenceRule::IMPORT_UNITS_NAME_VALUE) + .value("IMPORT_UNITS_NAME_UNIQUE", libcellml::Issue::ReferenceRule::IMPORT_UNITS_NAME_UNIQUE) + .value("IMPORT_UNITS_UNITS_REFERENCE", libcellml::Issue::ReferenceRule::IMPORT_UNITS_UNITS_REFERENCE) + .value("IMPORT_UNITS_UNITS_REFERENCE_VALUE", libcellml::Issue::ReferenceRule::IMPORT_UNITS_UNITS_REFERENCE_VALUE) + .value("IMPORT_UNITS_UNITS_REFERENCE_VALUE_TARGET", libcellml::Issue::ReferenceRule::IMPORT_UNITS_UNITS_REFERENCE_VALUE_TARGET) + .value("IMPORT_COMPONENT_ELEMENT", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_ELEMENT) + .value("IMPORT_COMPONENT_NAME", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_NAME) + .value("IMPORT_COMPONENT_NAME_VALUE", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_NAME_VALUE) + .value("IMPORT_COMPONENT_NAME_UNIQUE", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_NAME_UNIQUE) + .value("IMPORT_COMPONENT_COMPONENT_REFERENCE", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_COMPONENT_REFERENCE) + .value("IMPORT_COMPONENT_COMPONENT_REFERENCE_VALUE", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_COMPONENT_REFERENCE_VALUE) + .value("IMPORT_COMPONENT_COMPONENT_REFERENCE_TARGET", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_COMPONENT_REFERENCE_TARGET) + .value("UNITS_ELEMENT", libcellml::Issue::ReferenceRule::UNITS_ELEMENT) + .value("UNITS_NAME", libcellml::Issue::ReferenceRule::UNITS_NAME) + .value("UNITS_NAME_VALUE", libcellml::Issue::ReferenceRule::UNITS_NAME_VALUE) + .value("UNITS_NAME_UNIQUE", libcellml::Issue::ReferenceRule::UNITS_NAME_UNIQUE) + .value("UNITS_STANDARD", libcellml::Issue::ReferenceRule::UNITS_STANDARD) + .value("UNITS_CHILD", libcellml::Issue::ReferenceRule::UNITS_CHILD) + .value("UNIT_ELEMENT", libcellml::Issue::ReferenceRule::UNIT_ELEMENT) + .value("UNIT_UNITS", libcellml::Issue::ReferenceRule::UNIT_UNITS) + .value("UNIT_UNITS_REFERENCE", libcellml::Issue::ReferenceRule::UNIT_UNITS_REFERENCE) + .value("UNIT_UNITS_CIRCULAR_REFERENCE", libcellml::Issue::ReferenceRule::UNIT_UNITS_CIRCULAR_REFERENCE) + .value("UNIT_ATTRIBUTE_OPTIONAL", libcellml::Issue::ReferenceRule::UNIT_ATTRIBUTE_OPTIONAL) + .value("UNIT_ATTRIBUTE_PREFIX_VALUE", libcellml::Issue::ReferenceRule::UNIT_ATTRIBUTE_PREFIX_VALUE) + .value("UNIT_ATTRIBUTE_MULTIPLIER_VALUE", libcellml::Issue::ReferenceRule::UNIT_ATTRIBUTE_MULTIPLIER_VALUE) + .value("UNIT_ATTRIBUTE_EXPONENT_VALUE", libcellml::Issue::ReferenceRule::UNIT_ATTRIBUTE_EXPONENT_VALUE) .value("COMPONENT_ELEMENT", libcellml::Issue::ReferenceRule::COMPONENT_ELEMENT) .value("COMPONENT_NAME", libcellml::Issue::ReferenceRule::COMPONENT_NAME) - .value("COMPONENT_NAME_UNIQUE", libcellml::Issue::ReferenceRule::COMPONENT_NAME_UNIQUE) .value("COMPONENT_NAME_VALUE", libcellml::Issue::ReferenceRule::COMPONENT_NAME_VALUE) - .value("COMPONENT_REF_CHILD", libcellml::Issue::ReferenceRule::COMPONENT_REF_CHILD) + .value("COMPONENT_NAME_UNIQUE", libcellml::Issue::ReferenceRule::COMPONENT_NAME_UNIQUE) + .value("COMPONENT_CHILD", libcellml::Issue::ReferenceRule::COMPONENT_CHILD) + .value("VARIABLE_ELEMENT", libcellml::Issue::ReferenceRule::VARIABLE_ELEMENT) + .value("VARIABLE_ATTRIBUTE_REQUIRED", libcellml::Issue::ReferenceRule::VARIABLE_ATTRIBUTE_REQUIRED) + .value("VARIABLE_NAME_VALUE", libcellml::Issue::ReferenceRule::VARIABLE_NAME_VALUE) + .value("VARIABLE_NAME_UNIQUE", libcellml::Issue::ReferenceRule::VARIABLE_NAME_UNIQUE) + .value("VARIABLE_UNITS_VALUE", libcellml::Issue::ReferenceRule::VARIABLE_UNITS_VALUE) + .value("VARIABLE_ATTRIBUTE_OPTIONAL", libcellml::Issue::ReferenceRule::VARIABLE_ATTRIBUTE_OPTIONAL) + .value("VARIABLE_INTERFACE_VALUE", libcellml::Issue::ReferenceRule::VARIABLE_INTERFACE_VALUE) + .value("VARIABLE_INITIAL_VALUE_VALUE", libcellml::Issue::ReferenceRule::VARIABLE_INITIAL_VALUE_VALUE) + .value("RESET_ELEMENT", libcellml::Issue::ReferenceRule::RESET_ELEMENT) + .value("RESET_ATTRIBUTE_REQUIRED", libcellml::Issue::ReferenceRule::RESET_ATTRIBUTE_REQUIRED) + .value("RESET_VARIABLE_REFERENCE", libcellml::Issue::ReferenceRule::RESET_VARIABLE_REFERENCE) + .value("RESET_TEST_VARIABLE_REFERENCE", libcellml::Issue::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE) + .value("RESET_ORDER_VALUE", libcellml::Issue::ReferenceRule::RESET_ORDER_VALUE) + .value("RESET_ORDER_UNIQUE", libcellml::Issue::ReferenceRule::RESET_ORDER_UNIQUE) + .value("RESET_CHILD", libcellml::Issue::ReferenceRule::RESET_CHILD) + .value("RESET_RESET_VALUE_CHILD", libcellml::Issue::ReferenceRule::RESET_RESET_VALUE_CHILD) + .value("RESET_TEST_VALUE_CHILD", libcellml::Issue::ReferenceRule::RESET_TEST_VALUE_CHILD) + .value("TEST_VALUE_ELEMENT", libcellml::Issue::ReferenceRule::TEST_VALUE_ELEMENT) + .value("TEST_VALUE_CHILD", libcellml::Issue::ReferenceRule::TEST_VALUE_CHILD) + .value("RESET_VALUE_ELEMENT", libcellml::Issue::ReferenceRule::RESET_VALUE_ELEMENT) + .value("RESET_VALUE_CHILD", libcellml::Issue::ReferenceRule::RESET_VALUE_CHILD) + .value("MATH_ELEMENT", libcellml::Issue::ReferenceRule::MATH_ELEMENT) + .value("MATH_MATHML", libcellml::Issue::ReferenceRule::MATH_MATHML) + .value("MATH_CHILD", libcellml::Issue::ReferenceRule::MATH_CHILD) + .value("MATH_CI_VARIABLE_REFERENCE", libcellml::Issue::ReferenceRule::MATH_CI_VARIABLE_REFERENCE) + .value("MATH_CN_UNITS_ATTRIBUTE", libcellml::Issue::ReferenceRule::MATH_CN_UNITS_ATTRIBUTE) + .value("MATH_CN_UNITS_ATTRIBUTE_REFERENCE", libcellml::Issue::ReferenceRule::MATH_CN_UNITS_ATTRIBUTE_REFERENCE) + .value("MATH_CN_BASE10", libcellml::Issue::ReferenceRule::MATH_CN_BASE10) + .value("MATH_CN_FORMAT", libcellml::Issue::ReferenceRule::MATH_CN_FORMAT) + .value("ENCAPSULATION_ELEMENT", libcellml::Issue::ReferenceRule::ENCAPSULATION_ELEMENT) + .value("ENCAPSULATION_CHILD", libcellml::Issue::ReferenceRule::ENCAPSULATION_CHILD) + .value("COMPONENT_REF_ELEMENT", libcellml::Issue::ReferenceRule::COMPONENT_REF_ELEMENT) .value("COMPONENT_REF_COMPONENT_ATTRIBUTE", libcellml::Issue::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE) .value("COMPONENT_REF_COMPONENT_ATTRIBUTE_REFERENCE", libcellml::Issue::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE_REFERENCE) .value("COMPONENT_REF_COMPONENT_ATTRIBUTE_UNIQUE", libcellml::Issue::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE_UNIQUE) - .value("COMPONENT_REF_ELEMENT", libcellml::Issue::ReferenceRule::COMPONENT_REF_ELEMENT) - .value("CONNECTION_CHILD", libcellml::Issue::ReferenceRule::CONNECTION_CHILD) + .value("COMPONENT_REF_CHILD", libcellml::Issue::ReferenceRule::COMPONENT_REF_CHILD) + .value("CONNECTION_ELEMENT", libcellml::Issue::ReferenceRule::CONNECTION_ELEMENT) .value("CONNECTION_COMPONENT1_ATTRIBUTE", libcellml::Issue::ReferenceRule::CONNECTION_COMPONENT1_ATTRIBUTE) .value("CONNECTION_COMPONENT1_ATTRIBUTE_REFERENCE", libcellml::Issue::ReferenceRule::CONNECTION_COMPONENT1_ATTRIBUTE_REFERENCE) .value("CONNECTION_COMPONENT2_ATTRIBUTE", libcellml::Issue::ReferenceRule::CONNECTION_COMPONENT2_ATTRIBUTE) .value("CONNECTION_COMPONENT2_ATTRIBUTE_REFERENCE", libcellml::Issue::ReferenceRule::CONNECTION_COMPONENT2_ATTRIBUTE_REFERENCE) - .value("CONNECTION_ELEMENT", libcellml::Issue::ReferenceRule::CONNECTION_ELEMENT) .value("CONNECTION_EXCLUDE_SELF", libcellml::Issue::ReferenceRule::CONNECTION_EXCLUDE_SELF) .value("CONNECTION_UNIQUE", libcellml::Issue::ReferenceRule::CONNECTION_UNIQUE) + .value("CONNECTION_CHILD", libcellml::Issue::ReferenceRule::CONNECTION_CHILD) + .value("MAP_VARIABLES_ELEMENT", libcellml::Issue::ReferenceRule::MAP_VARIABLES_ELEMENT) + .value("MAP_VARIABLES_VARIABLE1_ATTRIBUTE", libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1_ATTRIBUTE) + .value("MAP_VARIABLES_VARIABLE1_ATTRIBUTE_REFERENCE", libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1_ATTRIBUTE_REFERENCE) + .value("MAP_VARIABLES_VARIABLE2_ATTRIBUTE", libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2_ATTRIBUTE) + .value("MAP_VARIABLES_VARIABLE2_ATTRIBUTE_REFERENCE", libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2_ATTRIBUTE_REFERENCE) + .value("MAP_VARIABLES_UNIQUE", libcellml::Issue::ReferenceRule::MAP_VARIABLES_UNIQUE) .value("DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM", libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM) .value("DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM", libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM) .value("DATA_REPR_IDENTIFIER_LATIN_ALPHANUM", libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM) - .value("ENCAPSULATION_CHILD", libcellml::Issue::ReferenceRule::ENCAPSULATION_CHILD) - .value("ENCAPSULATION_ELEMENT", libcellml::Issue::ReferenceRule::ENCAPSULATION_ELEMENT) + .value("INVALID_ARGUMENT", libcellml::Issue::ReferenceRule::INVALID_ARGUMENT) .value("IMPORTER_ERROR_IMPORTING_UNITS", libcellml::Issue::ReferenceRule::IMPORTER_ERROR_IMPORTING_UNITS) - .value("IMPORTER_MISSING_COMPONENT", libcellml::Issue::ReferenceRule::IMPORTER_MISSING_COMPONENT) .value("IMPORTER_MISSING_FILE", libcellml::Issue::ReferenceRule::IMPORTER_MISSING_FILE) + .value("IMPORTER_MISSING_COMPONENT", libcellml::Issue::ReferenceRule::IMPORTER_MISSING_COMPONENT) .value("IMPORTER_MISSING_UNITS", libcellml::Issue::ReferenceRule::IMPORTER_MISSING_UNITS) .value("IMPORTER_NULL_MODEL", libcellml::Issue::ReferenceRule::IMPORTER_NULL_MODEL) .value("IMPORTER_UNDEFINED_MODEL", libcellml::Issue::ReferenceRule::IMPORTER_UNDEFINED_MODEL) .value("IMPORTER_UNRESOLVED_IMPORTS", libcellml::Issue::ReferenceRule::IMPORTER_UNRESOLVED_IMPORTS) - .value("IMPORT_CHILD", libcellml::Issue::ReferenceRule::IMPORT_CHILD) - .value("IMPORT_COMPONENT_COMPONENT_REFERENCE", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_COMPONENT_REFERENCE) - .value("IMPORT_COMPONENT_COMPONENT_REFERENCE_TARGET", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_COMPONENT_REFERENCE_TARGET) - .value("IMPORT_COMPONENT_COMPONENT_REFERENCE_VALUE", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_COMPONENT_REFERENCE_VALUE) - .value("IMPORT_COMPONENT_ELEMENT", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_ELEMENT) - .value("IMPORT_COMPONENT_NAME", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_NAME) - .value("IMPORT_COMPONENT_NAME_UNIQUE", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_NAME_UNIQUE) - .value("IMPORT_COMPONENT_NAME_VALUE", libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_NAME_VALUE) - .value("IMPORT_ELEMENT", libcellml::Issue::ReferenceRule::IMPORT_ELEMENT) - .value("IMPORT_EQUIVALENT_INFOSET", libcellml::Issue::ReferenceRule::IMPORT_EQUIVALENT_INFOSET) - .value("IMPORT_HREF", libcellml::Issue::ReferenceRule::IMPORT_HREF) - .value("IMPORT_HREF_LOCATOR", libcellml::Issue::ReferenceRule::IMPORT_HREF_LOCATOR) - .value("IMPORT_UNITS_ELEMENT", libcellml::Issue::ReferenceRule::IMPORT_UNITS_ELEMENT) - .value("IMPORT_UNITS_NAME", libcellml::Issue::ReferenceRule::IMPORT_UNITS_NAME) - .value("IMPORT_UNITS_NAME_UNIQUE", libcellml::Issue::ReferenceRule::IMPORT_UNITS_NAME_UNIQUE) - .value("IMPORT_UNITS_NAME_VALUE", libcellml::Issue::ReferenceRule::IMPORT_UNITS_NAME_VALUE) - .value("IMPORT_UNITS_UNITS_REFERENCE", libcellml::Issue::ReferenceRule::IMPORT_UNITS_UNITS_REFERENCE) - .value("IMPORT_UNITS_UNITS_REFERENCE_VALUE", libcellml::Issue::ReferenceRule::IMPORT_UNITS_UNITS_REFERENCE_VALUE) - .value("IMPORT_UNITS_UNITS_REFERENCE_VALUE_TARGET", libcellml::Issue::ReferenceRule::IMPORT_UNITS_UNITS_REFERENCE_VALUE_TARGET) - .value("INVALID_ARGUMENT", libcellml::Issue::ReferenceRule::INVALID_ARGUMENT) - .value("MAP_VARIABLES_ELEMENT", libcellml::Issue::ReferenceRule::MAP_VARIABLES_ELEMENT) - .value("MAP_VARIABLES_UNIQUE", libcellml::Issue::ReferenceRule::MAP_VARIABLES_UNIQUE) - .value("MAP_VARIABLES_VARIABLE1_ATTRIBUTE", libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1_ATTRIBUTE) - .value("MAP_VARIABLES_VARIABLE1_ATTRIBUTE_REFERENCE", libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1_ATTRIBUTE_REFERENCE) - .value("MAP_VARIABLES_VARIABLE2_ATTRIBUTE", libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2_ATTRIBUTE) - .value("MAP_VARIABLES_VARIABLE2_ATTRIBUTE_REFERENCE", libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2_ATTRIBUTE_REFERENCE) - .value("MATH_CHILD", libcellml::Issue::ReferenceRule::MATH_CHILD) - .value("MATH_CI_VARIABLE_REFERENCE", libcellml::Issue::ReferenceRule::MATH_CI_VARIABLE_REFERENCE) - .value("MATH_CN_BASE10", libcellml::Issue::ReferenceRule::MATH_CN_BASE10) - .value("MATH_CN_FORMAT", libcellml::Issue::ReferenceRule::MATH_CN_FORMAT) - .value("MATH_CN_UNITS_ATTRIBUTE", libcellml::Issue::ReferenceRule::MATH_CN_UNITS_ATTRIBUTE) - .value("MATH_CN_UNITS_ATTRIBUTE_REFERENCE", libcellml::Issue::ReferenceRule::MATH_CN_UNITS_ATTRIBUTE_REFERENCE) - .value("MATH_ELEMENT", libcellml::Issue::ReferenceRule::MATH_ELEMENT) - .value("MATH_MATHML", libcellml::Issue::ReferenceRule::MATH_MATHML) - .value("MODEL_CHILD", libcellml::Issue::ReferenceRule::MODEL_CHILD) - .value("MODEL_ELEMENT", libcellml::Issue::ReferenceRule::MODEL_ELEMENT) - .value("MODEL_MORE_THAN_ONE_ENCAPSULATION", libcellml::Issue::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION) - .value("MODEL_NAME", libcellml::Issue::ReferenceRule::MODEL_NAME) - .value("MODEL_NAME_VALUE", libcellml::Issue::ReferenceRule::MODEL_NAME_VALUE) - .value("RESET_ATTRIBUTE_REQUIRED", libcellml::Issue::ReferenceRule::RESET_ATTRIBUTE_REQUIRED) - .value("RESET_CHILD", libcellml::Issue::ReferenceRule::RESET_CHILD) - .value("RESET_ELEMENT", libcellml::Issue::ReferenceRule::RESET_ELEMENT) - .value("RESET_ORDER_UNIQUE", libcellml::Issue::ReferenceRule::RESET_ORDER_UNIQUE) - .value("RESET_ORDER_VALUE", libcellml::Issue::ReferenceRule::RESET_ORDER_VALUE) - .value("RESET_RESET_VALUE_CHILD", libcellml::Issue::ReferenceRule::RESET_RESET_VALUE_CHILD) - .value("RESET_TEST_VALUE_CHILD", libcellml::Issue::ReferenceRule::RESET_TEST_VALUE_CHILD) - .value("RESET_TEST_VARIABLE_REFERENCE", libcellml::Issue::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE) - .value("RESET_VALUE_CHILD", libcellml::Issue::ReferenceRule::RESET_VALUE_CHILD) - .value("RESET_VALUE_ELEMENT", libcellml::Issue::ReferenceRule::RESET_VALUE_ELEMENT) - .value("RESET_VARIABLE_REFERENCE", libcellml::Issue::ReferenceRule::RESET_VARIABLE_REFERENCE) - .value("TEST_VALUE_CHILD", libcellml::Issue::ReferenceRule::TEST_VALUE_CHILD) - .value("TEST_VALUE_ELEMENT", libcellml::Issue::ReferenceRule::TEST_VALUE_ELEMENT) - .value("UNDEFINED", libcellml::Issue::ReferenceRule::UNDEFINED) - .value("UNITS_CHILD", libcellml::Issue::ReferenceRule::UNITS_CHILD) - .value("UNITS_ELEMENT", libcellml::Issue::ReferenceRule::UNITS_ELEMENT) - .value("UNITS_NAME", libcellml::Issue::ReferenceRule::UNITS_NAME) - .value("UNITS_NAME_UNIQUE", libcellml::Issue::ReferenceRule::UNITS_NAME_UNIQUE) - .value("UNITS_NAME_VALUE", libcellml::Issue::ReferenceRule::UNITS_NAME_VALUE) - .value("UNITS_STANDARD", libcellml::Issue::ReferenceRule::UNITS_STANDARD) - .value("UNIT_ATTRIBUTE_EXPONENT_VALUE", libcellml::Issue::ReferenceRule::UNIT_ATTRIBUTE_EXPONENT_VALUE) - .value("UNIT_ATTRIBUTE_MULTIPLIER_VALUE", libcellml::Issue::ReferenceRule::UNIT_ATTRIBUTE_MULTIPLIER_VALUE) - .value("UNIT_ATTRIBUTE_OPTIONAL", libcellml::Issue::ReferenceRule::UNIT_ATTRIBUTE_OPTIONAL) - .value("UNIT_ATTRIBUTE_PREFIX_VALUE", libcellml::Issue::ReferenceRule::UNIT_ATTRIBUTE_PREFIX_VALUE) - .value("UNIT_ELEMENT", libcellml::Issue::ReferenceRule::UNIT_ELEMENT) - .value("UNIT_UNITS", libcellml::Issue::ReferenceRule::UNIT_UNITS) - .value("UNIT_UNITS_CIRCULAR_REFERENCE", libcellml::Issue::ReferenceRule::UNIT_UNITS_CIRCULAR_REFERENCE) - .value("UNIT_UNITS_REFERENCE", libcellml::Issue::ReferenceRule::UNIT_UNITS_REFERENCE) + .value("ANALYSER_EQUATION_NOT_EQUALITY_STATEMENT", libcellml::Issue::ReferenceRule::ANALYSER_EQUATION_NOT_EQUALITY_STATEMENT) + .value("ANALYSER_UNITS", libcellml::Issue::ReferenceRule::ANALYSER_UNITS) + .value("ANALYSER_UNLINKED_UNITS", libcellml::Issue::ReferenceRule::ANALYSER_UNLINKED_UNITS) + .value("ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE) + .value("ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_ALGEBRAIC_VARIABLE) + .value("ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_INITIALISED_USING_VARIABLE_WITH_DIFFERENT_UNITS) + .value("ANALYSER_VOI_INITIALISED", libcellml::Issue::ReferenceRule::ANALYSER_VOI_INITIALISED) + .value("ANALYSER_VOI_SEVERAL", libcellml::Issue::ReferenceRule::ANALYSER_VOI_SEVERAL) + .value("ANALYSER_ODE_NOT_FIRST_ORDER", libcellml::Issue::ReferenceRule::ANALYSER_ODE_NOT_FIRST_ORDER) + .value("ANALYSER_VARIABLE_UNUSED", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNUSED) + .value("ANALYSER_STATE_NOT_INITIALISED", libcellml::Issue::ReferenceRule::ANALYSER_STATE_NOT_INITIALISED) + .value("ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE", libcellml::Issue::ReferenceRule::ANALYSER_STATE_RATE_AS_ALGEBRAIC_VARIABLE) + .value("ANALYSER_VARIABLE_UNDERCONSTRAINED", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_UNDERCONSTRAINED) + .value("ANALYSER_VARIABLE_OVERCONSTRAINED", libcellml::Issue::ReferenceRule::ANALYSER_VARIABLE_OVERCONSTRAINED) + .value("ANALYSER_EXTERNAL_VARIABLE_DIFFERENT_MODEL", libcellml::Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_DIFFERENT_MODEL) + .value("ANALYSER_EXTERNAL_VARIABLE_VOI", libcellml::Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_VOI) + .value("ANALYSER_EXTERNAL_VARIABLE_USE_PRIMARY_VARIABLE", libcellml::Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_USE_PRIMARY_VARIABLE) + .value("ANNOTATOR_ID_NOT_FOUND", libcellml::Issue::ReferenceRule::ANNOTATOR_ID_NOT_FOUND) + .value("ANNOTATOR_ID_NOT_UNIQUE", libcellml::Issue::ReferenceRule::ANNOTATOR_ID_NOT_UNIQUE) + .value("ANNOTATOR_NO_MODEL", libcellml::Issue::ReferenceRule::ANNOTATOR_NO_MODEL) + .value("ANNOTATOR_INCONSISTENT_TYPE", libcellml::Issue::ReferenceRule::ANNOTATOR_INCONSISTENT_TYPE) + .value("ANNOTATOR_NULL_MODEL", libcellml::Issue::ReferenceRule::ANNOTATOR_NULL_MODEL) + .value("GENERATOR_NULL_MODEL", libcellml::Issue::ReferenceRule::GENERATOR_NULL_MODEL) + .value("GENERATOR_NULL_VARIABLE", libcellml::Issue::ReferenceRule::GENERATOR_NULL_VARIABLE) + .value("GENERATOR_VOI_VARIABLE_ALWAYS_TRACKED", libcellml::Issue::ReferenceRule::GENERATOR_VOI_VARIABLE_ALWAYS_TRACKED) + .value("GENERATOR_VOI_VARIABLE_NOT_UNTRACKABLE", libcellml::Issue::ReferenceRule::GENERATOR_VOI_VARIABLE_NOT_UNTRACKABLE) + .value("GENERATOR_STATE_VARIABLE_ALWAYS_TRACKED", libcellml::Issue::ReferenceRule::GENERATOR_STATE_VARIABLE_ALWAYS_TRACKED) + .value("GENERATOR_STATE_VARIABLE_NOT_UNTRACKABLE", libcellml::Issue::ReferenceRule::GENERATOR_STATE_VARIABLE_NOT_UNTRACKABLE) + .value("GENERATOR_EXTERNAL_VARIABLE_ALWAYS_TRACKED", libcellml::Issue::ReferenceRule::GENERATOR_EXTERNAL_VARIABLE_ALWAYS_TRACKED) + .value("GENERATOR_EXTERNAL_VARIABLE_NOT_UNTRACKABLE", libcellml::Issue::ReferenceRule::GENERATOR_EXTERNAL_VARIABLE_NOT_UNTRACKABLE) + .value("GENERATOR_NLA_BASED_VARIABLE_ALWAYS_TRACKED", libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_ALWAYS_TRACKED) + .value("GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE", libcellml::Issue::ReferenceRule::GENERATOR_NLA_BASED_VARIABLE_NOT_UNTRACKABLE) + .value("GENERATOR_EXTERNALLY_NEEDED_VARIABLE_ALWAYS_TRACKED", libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_ALWAYS_TRACKED) + .value("GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE", libcellml::Issue::ReferenceRule::GENERATOR_EXTERNALLY_NEEDED_VARIABLE_NOT_UNTRACKABLE) .value("UNSPECIFIED", libcellml::Issue::ReferenceRule::UNSPECIFIED) - .value("VARIABLE_ATTRIBUTE_OPTIONAL", libcellml::Issue::ReferenceRule::VARIABLE_ATTRIBUTE_OPTIONAL) - .value("VARIABLE_ATTRIBUTE_REQUIRED", libcellml::Issue::ReferenceRule::VARIABLE_ATTRIBUTE_REQUIRED) - .value("VARIABLE_ELEMENT", libcellml::Issue::ReferenceRule::VARIABLE_ELEMENT) - .value("VARIABLE_INITIAL_VALUE_VALUE", libcellml::Issue::ReferenceRule::VARIABLE_INITIAL_VALUE_VALUE) - .value("VARIABLE_INTERFACE_VALUE", libcellml::Issue::ReferenceRule::VARIABLE_INTERFACE_VALUE) - .value("VARIABLE_NAME_UNIQUE", libcellml::Issue::ReferenceRule::VARIABLE_NAME_UNIQUE) - .value("VARIABLE_NAME_VALUE", libcellml::Issue::ReferenceRule::VARIABLE_NAME_VALUE) - .value("VARIABLE_UNITS_VALUE", libcellml::Issue::ReferenceRule::VARIABLE_UNITS_VALUE) - .value("XML_ID_ATTRIBUTE", libcellml::Issue::ReferenceRule::XML_ID_ATTRIBUTE) - .value("XML_UNEXPECTED_CHARACTER", libcellml::Issue::ReferenceRule::XML_UNEXPECTED_CHARACTER) - .value("XML_UNEXPECTED_ELEMENT", libcellml::Issue::ReferenceRule::XML_UNEXPECTED_ELEMENT) - .value("XML_UNEXPECTED_NAMESPACE", libcellml::Issue::ReferenceRule::XML_UNEXPECTED_NAMESPACE) - .value("XML_ATTRIBUTE_HAS_NAMESPACE", libcellml::Issue::ReferenceRule::XML_ATTRIBUTE_HAS_NAMESPACE) ; class_("Issue") @@ -173,6 +186,8 @@ EMSCRIPTEN_BINDINGS(libcellml_issue) { .function("item", &libcellml::Issue::item) .function("url", &libcellml::Issue::url) .function("referenceHeading", &libcellml::Issue::referenceHeading) + .class_function("levelAsString", &libcellml::Issue::levelAsString) + .class_function("referenceRuleAsString", &libcellml::Issue::referenceRuleAsString) ; EM_ASM( diff --git a/src/bindings/javascript/units.cpp b/src/bindings/javascript/units.cpp index 36855a24d..8de52172e 100644 --- a/src/bindings/javascript/units.cpp +++ b/src/bindings/javascript/units.cpp @@ -123,6 +123,8 @@ EMSCRIPTEN_BINDINGS(libcellml_units) { .class_function("scalingFactor", &libcellml::Units::scalingFactor) .class_function("compatible", &libcellml::Units::compatible) .class_function("equivalent", &libcellml::Units::equivalent) + .class_function("prefixAsString", &libcellml::Units::prefixAsString) + .class_function("standardUnitAsString", &libcellml::Units::standardUnitAsString) ; diff --git a/src/bindings/javascript/variable.cpp b/src/bindings/javascript/variable.cpp index 5573215c5..0f20f7d97 100644 --- a/src/bindings/javascript/variable.cpp +++ b/src/bindings/javascript/variable.cpp @@ -60,6 +60,7 @@ EMSCRIPTEN_BINDINGS(libcellml_variable) { .class_function("removeEquivalence", &libcellml::Variable::removeEquivalence) .class_function("setEquivalenceConnectionId", &libcellml::Variable::setEquivalenceConnectionId) .class_function("setEquivalenceMappingId", &libcellml::Variable::setEquivalenceMappingId) + .class_function("interfaceTypeAsString", &libcellml::Variable::interfaceTypeAsString) ; EM_ASM( From c11d9d0371a2b4a4a8af83dcabaf3a2706ca4163 Mon Sep 17 00:00:00 2001 From: Hugh Sorby Date: Wed, 17 Jun 2026 12:37:44 +1200 Subject: [PATCH 09/11] Fix code-formatting issues. --- src/issue.cpp | 5 ++--- src/variable.cpp | 2 -- tests/as_string/as_string.cpp | 1 - 3 files changed, 2 insertions(+), 6 deletions(-) diff --git a/src/issue.cpp b/src/issue.cpp index 8a835ea22..c03601677 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -79,8 +79,7 @@ AnyCellmlElementPtr Issue::item() const static const std::map levelToString = { {Issue::Level::ERROR, "error"}, {Issue::Level::MESSAGE, "message"}, - {Issue::Level::WARNING, "warning"} -}; + {Issue::Level::WARNING, "warning"}}; std::string Issue::levelAsString(Level level) { @@ -261,7 +260,7 @@ static const std::map> ruleToInfo std::string Issue::referenceRuleAsString(ReferenceRule rule) { std::string data = ruleToInformation.at(rule)[0]; - std::transform(data.begin(), data.end(), data.begin(), [](unsigned char c){ return std::tolower(c); }); + std::transform(data.begin(), data.end(), data.begin(), [](unsigned char c) { return std::tolower(c); }); return data; } diff --git a/src/variable.cpp b/src/variable.cpp index 8e7e678c2..dc9b4005a 100644 --- a/src/variable.cpp +++ b/src/variable.cpp @@ -28,13 +28,11 @@ limitations under the License. namespace libcellml { - std::string Variable::interfaceTypeAsString(Variable::InterfaceType type) { return interfaceTypeToString.at(type); } - std::vector::const_iterator Variable::VariableImpl::findEquivalentVariable(const VariablePtr &equivalentVariable) const { return std::find_if(mEquivalentVariables.begin(), mEquivalentVariables.end(), diff --git a/tests/as_string/as_string.cpp b/tests/as_string/as_string.cpp index 9ffd367bc..8b316a6bd 100644 --- a/tests/as_string/as_string.cpp +++ b/tests/as_string/as_string.cpp @@ -234,4 +234,3 @@ TEST(AsString, variableInterfaceType) EXPECT_EQ("private", libcellml::Variable::interfaceTypeAsString(libcellml::Variable::InterfaceType::PRIVATE)); EXPECT_EQ("public_and_private", libcellml::Variable::interfaceTypeAsString(libcellml::Variable::InterfaceType::PUBLIC_AND_PRIVATE)); } - From d98ce37354a9cbc941dfccb045bb5171395b31cb Mon Sep 17 00:00:00 2001 From: Hugh Sorby Date: Thu, 18 Jun 2026 00:08:41 +1200 Subject: [PATCH 10/11] Add Python tests for new API as string methods. --- tests/bindings/python/test_issue.py | 10 ++++++++++ tests/bindings/python/test_units.py | 9 +++++++++ tests/bindings/python/test_variable.py | 7 +++++++ 3 files changed, 26 insertions(+) diff --git a/tests/bindings/python/test_issue.py b/tests/bindings/python/test_issue.py index 940cba285..9af86a388 100644 --- a/tests/bindings/python/test_issue.py +++ b/tests/bindings/python/test_issue.py @@ -159,6 +159,16 @@ def test_reference_rule_enum(self): self.assertIsInstance(Issue.ReferenceRule.XML_UNEXPECTED_NAMESPACE, int) self.assertIsInstance(Issue.ReferenceRule.XML_ATTRIBUTE_HAS_NAMESPACE, int) + def test_issue_as_string(self): + from libcellml import Issue + from libcellml.issue import Issue_levelAsString, Issue_referenceRuleAsString + + self.assertEqual("message", Issue.levelAsString(Issue.Level.MESSAGE)) + self.assertEqual("warning", Issue_levelAsString(Issue.Level.WARNING)) + + self.assertEqual("unit_attribute_exponent_value", Issue.referenceRuleAsString(Issue.ReferenceRule.UNIT_ATTRIBUTE_EXPONENT_VALUE)) + self.assertEqual("xml_unexpected_element", Issue_referenceRuleAsString(Issue.ReferenceRule.XML_UNEXPECTED_ELEMENT)) + def test_coverage(self): from libcellml import Issue from libcellml import Parser diff --git a/tests/bindings/python/test_units.py b/tests/bindings/python/test_units.py index b942a8536..c648ea098 100644 --- a/tests/bindings/python/test_units.py +++ b/tests/bindings/python/test_units.py @@ -354,6 +354,15 @@ def test_is_defined(self): self.assertTrue(u.isDefined()) + def test_units_as_string(self): + from libcellml import Units + from libcellml.units import Units_prefixAsString, Units_standardUnitAsString + + self.assertEqual("yotta", Units.prefixAsString(Units.Prefix.YOTTA)) + self.assertEqual("deci", Units_prefixAsString(Units.Prefix.DECI)) + + self.assertEqual("ampere", Units.standardUnitAsString(Units.StandardUnit.AMPERE)) + self.assertEqual("lumen", Units_standardUnitAsString(Units.StandardUnit.LUMEN)) if __name__ == '__main__': unittest.main() diff --git a/tests/bindings/python/test_variable.py b/tests/bindings/python/test_variable.py index a68af2916..da53e4eb6 100644 --- a/tests/bindings/python/test_variable.py +++ b/tests/bindings/python/test_variable.py @@ -339,6 +339,13 @@ def test_interface_type(self): v.setInterfaceType(Variable.InterfaceType.PUBLIC_AND_PRIVATE) self.assertEqual(v.interfaceType(), 'public_and_private') + def test_interface_type_as_string(self): + from libcellml import Variable + from libcellml.variable import Variable_interfaceTypeAsString + + self.assertEqual("none", Variable.interfaceTypeAsString(Variable.InterfaceType.NONE)) + self.assertEqual("private", Variable_interfaceTypeAsString(Variable.InterfaceType.PRIVATE)) + def test_minimum_interface_type(self): from libcellml import Variable From c1df34a19909198f90ce0d4e9f5b728492d9424c Mon Sep 17 00:00:00 2001 From: Hugh Sorby Date: Thu, 18 Jun 2026 00:19:34 +1200 Subject: [PATCH 11/11] Add Javascript tests for new API as string methods. --- tests/bindings/javascript/issue.test.js | 13 +++++++++++++ tests/bindings/javascript/units.test.js | 4 ++++ tests/bindings/javascript/variable.test.js | 3 +++ 3 files changed, 20 insertions(+) diff --git a/tests/bindings/javascript/issue.test.js b/tests/bindings/javascript/issue.test.js index 845a2b84e..088d75fcd 100644 --- a/tests/bindings/javascript/issue.test.js +++ b/tests/bindings/javascript/issue.test.js @@ -13,3 +13,16 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ + +const loadLibCellML = require('libcellml.js/libcellml.common') +let libcellml = null + +describe("Variable tests", () => { + beforeAll(async () => { + libcellml = await loadLibCellML() + }) + test('Checking issue as string', () => { + expect(libcellml.Issue.levelAsString(libcellml.Issue.Level.ERROR)).toBe("error") + expect(libcellml.Issue.referenceRuleAsString(libcellml.Issue.ReferenceRule.ANALYSER_VARIABLE_INITIALISED_MORE_THAN_ONCE)).toBe("analyser_variable_initialised_more_than_once") + }) +}) diff --git a/tests/bindings/javascript/units.test.js b/tests/bindings/javascript/units.test.js index 881fa1f1c..7ea4a7827 100644 --- a/tests/bindings/javascript/units.test.js +++ b/tests/bindings/javascript/units.test.js @@ -288,4 +288,8 @@ describe("Units tests", () => { expect(libcellml.Units.equivalent(u1, u2)).toBe(false) }) + test('Checking Units as string.', () => { + expect(libcellml.Units.standardUnitAsString(libcellml.Units.StandardUnit.FARAD)).toBe("farad") + expect(libcellml.Units.prefixAsString(libcellml.Units.Prefix.MICRO)).toBe("micro") + }) }) diff --git a/tests/bindings/javascript/variable.test.js b/tests/bindings/javascript/variable.test.js index a3d863b0d..ecdf8c80c 100644 --- a/tests/bindings/javascript/variable.test.js +++ b/tests/bindings/javascript/variable.test.js @@ -155,4 +155,7 @@ describe("Variable tests", () => { v1.delete() v2.delete() }) + test('Checking variable interface type as string', () => { + expect(libcellml.Variable.interfaceTypeAsString(libcellml.Variable.InterfaceType.PUBLIC_AND_PRIVATE)).toBe("public_and_private") + }) })