From 830e4f5427ad9c1ec867a02e7274184c88e4f035 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 15 Jan 2020 11:21:52 +0100 Subject: [PATCH 01/88] Renamed error to issue (except libXml2 stuff) --- src/CMakeLists.txt | 4 +- src/api/libcellml/error.h | 368 ------------------------ src/api/libcellml/issue.h | 368 ++++++++++++++++++++++++ src/api/libcellml/logger.h | 34 +-- src/api/libcellml/module/libcellml | 2 +- src/api/libcellml/types.h | 4 +- src/api/libcellml/units.h | 6 +- src/api/libcellml/validator.h | 2 +- src/bindings/interface/error.i | 110 ------- src/bindings/interface/issue.i | 110 +++++++ src/bindings/interface/logger.i | 14 +- src/bindings/interface/types.i | 8 +- src/bindings/python/CMakeLists.txt | 2 +- src/bindings/python/__init__.py | 4 +- src/generator.cpp | 54 ++-- src/{error.cpp => issue.cpp} | 150 +++++----- src/logger.cpp | 12 +- src/parser.cpp | 342 +++++++++++----------- src/validator.cpp | 258 ++++++++--------- tests/bindings/python/test_error.py | 146 +++++----- tests/bindings/python/test_generator.py | 12 +- tests/bindings/python/test_parser.py | 10 +- tests/bindings/python/test_printer.py | 10 +- tests/bindings/python/test_validator.py | 10 +- tests/clone/clone.cpp | 2 +- tests/component/encapsulation.cpp | 2 +- tests/connection/connection.cpp | 10 +- tests/coverage/coverage.cpp | 4 +- tests/error/error.cpp | 42 +-- tests/generator/generator.cpp | 132 ++++----- tests/isolated/generator.cpp | 8 +- tests/parser/file_parser.cpp | 12 +- tests/parser/libxml_user.cpp | 2 +- tests/parser/parser.cpp | 168 +++++------ tests/printer/printer.cpp | 2 +- tests/resolve_imports/file_parser.cpp | 14 +- tests/test_utils.cpp | 46 +-- tests/test_utils.h | 26 +- tests/units/units.cpp | 4 +- tests/validator/validator.cpp | 84 +++--- tests/variable/variable.cpp | 2 +- 41 files changed, 1299 insertions(+), 1301 deletions(-) delete mode 100644 src/api/libcellml/error.h create mode 100644 src/api/libcellml/issue.h delete mode 100644 src/bindings/interface/error.i create mode 100644 src/bindings/interface/issue.i rename src/{error.cpp => issue.cpp} (64%) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index a9633cbf3..5514d3750 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -49,11 +49,11 @@ set(SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/componententity.cpp ${CMAKE_CURRENT_SOURCE_DIR}/debug.cpp ${CMAKE_CURRENT_SOURCE_DIR}/entity.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/error.cpp ${CMAKE_CURRENT_SOURCE_DIR}/generator.cpp ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofile.cpp ${CMAKE_CURRENT_SOURCE_DIR}/importedentity.cpp ${CMAKE_CURRENT_SOURCE_DIR}/importsource.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/issue.cpp ${CMAKE_CURRENT_SOURCE_DIR}/logger.cpp ${CMAKE_CURRENT_SOURCE_DIR}/model.cpp ${CMAKE_CURRENT_SOURCE_DIR}/namedentity.cpp @@ -77,11 +77,11 @@ set(GIT_API_HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/componententity.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/entity.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/enumerations.h - ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/error.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/generator.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/generatorprofile.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/importedentity.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/importsource.h + ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/issue.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/logger.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/model.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/namedentity.h diff --git a/src/api/libcellml/error.h b/src/api/libcellml/error.h deleted file mode 100644 index c789d431b..000000000 --- a/src/api/libcellml/error.h +++ /dev/null @@ -1,368 +0,0 @@ -/* -Copyright 2016 University of Auckland - -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. -*/ - -#pragma once - -#include "libcellml/exportdefinitions.h" -#include "libcellml/specificationrules.h" -#include "libcellml/types.h" - -#include - -namespace libcellml { - -/** - * @brief The Error class - * - * Base class for errors used with logger derived classes. - */ -class LIBCELLML_EXPORT Error -{ -public: - virtual ~Error(); /**< Destructor */ - Error(const Error &rhs) = delete; /**< Copy constructor */ - Error(Error &&rhs) noexcept = delete; /**< Move constructor */ - Error &operator=(Error rhs) = delete; /**< Assignment operator */ - - /** - * @brief Create an @c Error object. - * - * Factory method to create an @c Error. Can create a - * blank error with:: - * - * ErrorPtr error = libcellml::Error::create(); - * - * or an error with one of the following types as a parameter:: - * - * - libcellml::ComponentPtr - * - libcellml::ImportSourcePtr - * - libcellml::ModelPtr - * - libcellml::ResetPtr - * - libcellml::UnitsPtr - * - libcellml::VariablePtr - * - * @return A smart pointer to an @c Error object. - */ - static ErrorPtr create() noexcept; - - /** - * @overload - */ - static ErrorPtr create(const ComponentPtr &component) noexcept; - - /** - * @overload - */ - static ErrorPtr create(const ImportSourcePtr &importSource) noexcept; - - /** - * @overload - */ - static ErrorPtr create(const ModelPtr &model) noexcept; - - /** - * @overload - */ - static ErrorPtr create(const ResetPtr &reset) noexcept; - - /** - * @overload - */ - static ErrorPtr create(const UnitsPtr &units) noexcept; - - /** - * @overload - */ - static ErrorPtr create(const VariablePtr &variable) noexcept; - - /** - * @brief The error Kind enum class. - * - * Enum to describe the kind of error a given error is. - */ - enum class Kind - { - COMPONENT, - CONNECTION, - ENCAPSULATION, - IMPORT, - MATHML, - MODEL, - RESET, - UNDEFINED, - UNITS, - VARIABLE, - XML, - GENERATOR - }; - - /** - * @brief Set the description for this error. - * - * Set the @c std::string @p description for why this error was raised. - * - * @param description The @c std::string error description to set. - */ - void setDescription(const std::string &description); - - /** - * @brief Get the description for this error. - * - * Get the @c std::string description for why this error was raised. - * - * @return The @c std::string description of the error. - */ - std::string description() const; - - /** - * @brief Set the kind of this error. - * - * Set the @p kind of this error from the options available in - * @c Error::Kind. - * - * @param kind The @c Error::Kind to set. - */ - void setKind(Kind kind); - - /** - * @brief Get the kind of this error. - * - * Get the @c kind of this error. If no kind has been set for - * this error, will return Kind::UNDEFINED. - * - * @return The @c Error::Kind set for this error. - */ - Kind kind() const; - - /** - * @brief Check whether the kind of this error matches the argument kind. - * - * Return @c true if the @p kind matches the the @c Error::Kind for this - * error and @c false otherwise. - * - * @return @c true if the @p kind matches the the @c Error::Kind for this - * error and @c false otherwise. - */ - bool isKind(Kind kind) const; - - /** - * @brief Set the @c enum SpecificationRule of this error. - * - * Set the @p rule of this error from the options available in - * the @c SpecificationRule @c enum. - * - * @param rule The @c SpecificationRule to set. - */ - void setRule(SpecificationRule rule); - - /** - * @brief Get the @c enum SpecificationRule of this error. - * - * Get the @c enum @c SpecificationRule value @p rule of this error. If - * no rule has been set for this error, will return SpecificationRule::UNDEFINED. - * - * @return The @c SpecificationRule for this error. - */ - SpecificationRule rule() const; - - /** - * @brief Get the @c std::string heading associated with the @c enum SpecificationRule for this error. - * - * Get the @c std::string CellML 2.0 Specification heading associated with the @c enum SpecificationRule - * for this error. If no rule has been set for this error, will return an empty string. - * - * @return The @c std::string referencing the CellML 2.0 Specification heading relevant to this error. - */ - std::string specificationHeading() const; - - /** - * @brief Set the component for this component error. - * - * Set the @p component that this component error is relevant to. - * - * @param component A pointer to the component that this component error is relevant to. - */ - void setComponent(const ComponentPtr &component); - - /** - * @brief Get the component for this error. - * - * Get the component that this error is relevant to. - * - * @return A pointer to the component that this error was raised on. If no - * component has been set for this error, return a @c nullptr. - */ - ComponentPtr component() const; - - /** - * @brief Set the @p import source for this error. - * - * Set the @c ImportSourcePtr @p importSource object that this error is - * relevant to. - * - * @param importSource A pointer to the import source that this error is - * relevant to. - */ - void setImportSource(const ImportSourcePtr &importSource); - - /** - * @brief Get the import source for this error. - * - * Get the @c ImportSourcePtr import source for this error. - * - * @return A pointer to the import source this error was raised on. If no - * import source has been set for this error, return a @c nullptr. - */ - ImportSourcePtr importSource() const; - - /** - * @brief Set the @p model for this error. - * - * Set the @p model that this error is relevant to. - * - * @param model A pointer to the model that this error is relevant to. - */ - void setModel(const ModelPtr &model); - - /** - * @brief Get the model for this error. - * - * Get the model that this error is relevant to. - * - * @return A pointer to the model that this error was raised on. - * If no model has been set for this error, return a @c nullptr. - */ - ModelPtr model() const; - - /** - * @brief Set the units for this error. - * - * Set the @p units that this error is relevant to. - * - * @param units A pointer to the units this error is relevant to. - */ - void setUnits(const UnitsPtr &units); - - /** - * @brief Get the units for this error. - * - * Get the units that this error is relevant to. - * - * @return A pointer to the units that this error was raised on. - * If no units has been set for this error, return a @c nullptr. - */ - UnitsPtr units() const; - - /** - * @brief Set the variable for this error. - * - * Set the @p variable that this error is relevant to. - * - * @param variable A pointer to the variable this error is relevant to. - */ - void setVariable(const VariablePtr &variable); - - /** - * @brief Get the variable for this error. - * - * Get the variable that this error is relevant to. - * - * @return A pointer to the variable this variable error was raised on. - * If no variable has been set for this error, return a @c nullptr. - */ - VariablePtr variable() const; - - /** - * @brief Set the reset for this error. - * - * Set the @p reset that this error is relevant to. - * - * @param reset A pointer to the reset this error is relevant to. - */ - void setReset(const ResetPtr &reset); - - /** - * @brief Get the reset for this error. - * - * Get the reset that this error is relevant to. - * - * @return A pointer to the reset this reset error was raised on. - * If no reset has been set for this error, return a @c nullptr. - */ - ResetPtr reset() const; - -private: - Error(); /**< Constructor */ - - /** - * @brief Constructs an Error for the component. - * - * Convenience constructor for creating an error for the component. - * - * @param component The component the error references. - */ - explicit Error(const ComponentPtr &component); - - /** - * @brief Constructs an Error for the import source. - * - * Convenience constructor for creating an error for the import source. - * - * @param importSource The import source the error references. - */ - explicit Error(const ImportSourcePtr &importSource); - - /** - * @brief Constructs an Error for the model. - * - * Convenience constructor for creating an error for the model. - * - * @param model The model the error references. - */ - explicit Error(const ModelPtr &model); - - /** - * @brief Constructs an Error for the reset. - * - * Convenience constructor for creating an error for the reset. - * - * @param reset The reset the error references. - */ - explicit Error(const ResetPtr &reset); - - /** - * @brief Constructs an Error for the units. - * - * Convenience constructor for creating an error for the units. - * - * @param units The units the error references. - */ - explicit Error(const UnitsPtr &units); - - /** - * @brief Constructs an Error for the variable. - * - * Convenience constructor for creating an error for the variable. - * - * @param variable The variable the error references. - */ - explicit Error(const VariablePtr &variable); - - struct ErrorImpl; /**< Forward declaration for pImpl idiom. */ - ErrorImpl *mPimpl; /**< Private member to implementation pointer */ -}; - -} // namespace libcellml diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h new file mode 100644 index 000000000..1ab24e815 --- /dev/null +++ b/src/api/libcellml/issue.h @@ -0,0 +1,368 @@ +/* +Copyright 2016 University of Auckland + +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. +*/ + +#pragma once + +#include "libcellml/exportdefinitions.h" +#include "libcellml/specificationrules.h" +#include "libcellml/types.h" + +#include + +namespace libcellml { + +/** + * @brief The Issue class + * + * Base class for issues used with logger derived classes. + */ +class LIBCELLML_EXPORT Issue +{ +public: + virtual ~Issue(); /**< Destructor */ + Issue(const Issue &rhs) = delete; /**< Copy constructor */ + Issue(Issue &&rhs) noexcept = delete; /**< Move constructor */ + Issue &operator=(Issue rhs) = delete; /**< Assignment operator */ + + /** + * @brief Create an @c Issue object. + * + * Factory method to create an @c Issue. Can create a + * blank issue with:: + * + * IssuePtr issue = libcellml::Issue::create(); + * + * or an issue with one of the following types as a parameter:: + * + * - libcellml::ComponentPtr + * - libcellml::ImportSourcePtr + * - libcellml::ModelPtr + * - libcellml::ResetPtr + * - libcellml::UnitsPtr + * - libcellml::VariablePtr + * + * @return A smart pointer to an @c Issue object. + */ + static IssuePtr create() noexcept; + + /** + * @overload + */ + static IssuePtr create(const ComponentPtr &component) noexcept; + + /** + * @overload + */ + static IssuePtr create(const ImportSourcePtr &importSource) noexcept; + + /** + * @overload + */ + static IssuePtr create(const ModelPtr &model) noexcept; + + /** + * @overload + */ + static IssuePtr create(const ResetPtr &reset) noexcept; + + /** + * @overload + */ + static IssuePtr create(const UnitsPtr &units) noexcept; + + /** + * @overload + */ + static IssuePtr create(const VariablePtr &variable) noexcept; + + /** + * @brief The issue Kind enum class. + * + * Enum to describe the kind of issue a given issue is. + */ + enum class Kind + { + COMPONENT, + CONNECTION, + ENCAPSULATION, + IMPORT, + MATHML, + MODEL, + RESET, + UNDEFINED, + UNITS, + VARIABLE, + XML, + GENERATOR + }; + + /** + * @brief Set the description for this issue. + * + * Set the @c std::string @p description for why this issue was raised. + * + * @param description The @c std::string issue description to set. + */ + void setDescription(const std::string &description); + + /** + * @brief Get the description for this issue. + * + * Get the @c std::string description for why this issue was raised. + * + * @return The @c std::string description of the issue. + */ + std::string description() const; + + /** + * @brief Set the kind of this issue. + * + * Set the @p kind of this issue from the options available in + * @c Issue::Kind. + * + * @param kind The @c Issue::Kind to set. + */ + void setKind(Kind kind); + + /** + * @brief Get the kind of this issue. + * + * Get the @c kind of this issue. If no kind has been set for + * this issue, will return Kind::UNDEFINED. + * + * @return The @c Issue::Kind set for this issue. + */ + Kind kind() const; + + /** + * @brief Check whether the kind of this issue matches the argument kind. + * + * Return @c true if the @p kind matches the the @c Issue::Kind for this + * issue and @c false otherwise. + * + * @return @c true if the @p kind matches the the @c Issue::Kind for this + * issue and @c false otherwise. + */ + bool isKind(Kind kind) const; + + /** + * @brief Set the @c enum SpecificationRule of this issue. + * + * Set the @p rule of this issue from the options available in + * the @c SpecificationRule @c enum. + * + * @param rule The @c SpecificationRule to set. + */ + void setRule(SpecificationRule rule); + + /** + * @brief Get the @c enum SpecificationRule of this issue. + * + * Get the @c enum @c SpecificationRule value @p rule of this issue. If + * no rule has been set for this issue, will return SpecificationRule::UNDEFINED. + * + * @return The @c SpecificationRule for this issue. + */ + SpecificationRule rule() const; + + /** + * @brief Get the @c std::string heading associated with the @c enum SpecificationRule for this issue. + * + * Get the @c std::string CellML 2.0 Specification heading associated with the @c enum SpecificationRule + * for this issue. If no rule has been set for this issue, will return an empty string. + * + * @return The @c std::string referencing the CellML 2.0 Specification heading relevant to this issue. + */ + std::string specificationHeading() const; + + /** + * @brief Set the component for this component issue. + * + * Set the @p component that this component issue is relevant to. + * + * @param component A pointer to the component that this component issue is relevant to. + */ + void setComponent(const ComponentPtr &component); + + /** + * @brief Get the component for this issue. + * + * Get the component that this issue is relevant to. + * + * @return A pointer to the component that this issue was raised on. If no + * component has been set for this issue, return a @c nullptr. + */ + ComponentPtr component() const; + + /** + * @brief Set the @p import source for this issue. + * + * Set the @c ImportSourcePtr @p importSource object that this issue is + * relevant to. + * + * @param importSource A pointer to the import source that this issue is + * relevant to. + */ + void setImportSource(const ImportSourcePtr &importSource); + + /** + * @brief Get the import source for this issue. + * + * Get the @c ImportSourcePtr import source for this issue. + * + * @return A pointer to the import source this issue was raised on. If no + * import source has been set for this issue, return a @c nullptr. + */ + ImportSourcePtr importSource() const; + + /** + * @brief Set the @p model for this issue. + * + * Set the @p model that this issue is relevant to. + * + * @param model A pointer to the model that this issue is relevant to. + */ + void setModel(const ModelPtr &model); + + /** + * @brief Get the model for this issue. + * + * Get the model that this issue is relevant to. + * + * @return A pointer to the model that this issue was raised on. + * If no model has been set for this issue, return a @c nullptr. + */ + ModelPtr model() const; + + /** + * @brief Set the units for this issue. + * + * Set the @p units that this issue is relevant to. + * + * @param units A pointer to the units this issue is relevant to. + */ + void setUnits(const UnitsPtr &units); + + /** + * @brief Get the units for this issue. + * + * Get the units that this issue is relevant to. + * + * @return A pointer to the units that this issue was raised on. + * If no units has been set for this issue, return a @c nullptr. + */ + UnitsPtr units() const; + + /** + * @brief Set the variable for this issue. + * + * Set the @p variable that this issue is relevant to. + * + * @param variable A pointer to the variable this issue is relevant to. + */ + void setVariable(const VariablePtr &variable); + + /** + * @brief Get the variable for this issue. + * + * Get the variable that this issue is relevant to. + * + * @return A pointer to the variable this variable issue was raised on. + * If no variable has been set for this issue, return a @c nullptr. + */ + VariablePtr variable() const; + + /** + * @brief Set the reset for this issue. + * + * Set the @p reset that this issue is relevant to. + * + * @param reset A pointer to the reset this issue is relevant to. + */ + void setReset(const ResetPtr &reset); + + /** + * @brief Get the reset for this issue. + * + * Get the reset that this issue is relevant to. + * + * @return A pointer to the reset this reset issue was raised on. + * If no reset has been set for this issue, return a @c nullptr. + */ + ResetPtr reset() const; + +private: + Issue(); /**< Constructor */ + + /** + * @brief Constructs an Issue for the component. + * + * Convenience constructor for creating an issue for the component. + * + * @param component The component the issue references. + */ + explicit Issue(const ComponentPtr &component); + + /** + * @brief Constructs an Issue for the import source. + * + * Convenience constructor for creating an issue for the import source. + * + * @param importSource The import source the issue references. + */ + explicit Issue(const ImportSourcePtr &importSource); + + /** + * @brief Constructs an Issue for the model. + * + * Convenience constructor for creating an issue for the model. + * + * @param model The model the issue references. + */ + explicit Issue(const ModelPtr &model); + + /** + * @brief Constructs an Issue for the reset. + * + * Convenience constructor for creating an issue for the reset. + * + * @param reset The reset the issue references. + */ + explicit Issue(const ResetPtr &reset); + + /** + * @brief Constructs an Issue for the units. + * + * Convenience constructor for creating an issue for the units. + * + * @param units The units the issue references. + */ + explicit Issue(const UnitsPtr &units); + + /** + * @brief Constructs an Issue for the variable. + * + * Convenience constructor for creating an issue for the variable. + * + * @param variable The variable the issue references. + */ + explicit Issue(const VariablePtr &variable); + + struct IssueImpl; /**< Forward declaration for pImpl idiom. */ + IssueImpl *mPimpl; /**< Private member to implementation pointer */ +}; + +} // namespace libcellml diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index bdbf8e286..7fa3eace5 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -16,8 +16,8 @@ limitations under the License. #pragma once -#include "libcellml/error.h" #include "libcellml/exportdefinitions.h" +#include "libcellml/issue.h" #include "libcellml/types.h" #include @@ -38,42 +38,42 @@ class LIBCELLML_EXPORT Logger Logger &operator=(Logger rhs) = delete; /**< Assignment operator */ /** - * @brief Clear the errors from the logger. + * @brief Clear the issues from the logger. * - * Clear the errors from the logger. + * Clear the issues from the logger. */ void removeAllErrors(); /** - * @brief Add an error to the logger. + * @brief Add an issue to the logger. * - * Adds the argument @p error to this logger. + * Adds the argument @p issue to this logger. * - * @param error The @c ErrorPtr to add. + * @param issue The @c IssuePtr to add. */ - void addError(const ErrorPtr &error); + void addIssue(const IssuePtr &issue); /** - * @brief Get the number of errors. + * @brief Get the number of issues. * - * Return the number of errors currently stored in the logger. + * Return the number of issues currently stored in the logger. * - * @return The number of errors. + * @return The number of issues. */ - size_t errorCount() const; + size_t issueCount() const; /** - * @brief Get error at the specified @p index. + * @brief Get issue at the specified @p index. * - * Returns an error at the @p index. If the @p index + * Returns an issue at the @p index. If the @p index * is not valid a @c nullptr is returned, the valid range for the @p index - * is [0, \#errors). + * is [0, \#issues). * - * @param index The index of the error to return. + * @param index The index of the issue to return. * - * @return A reference to the error at the given index on success, @c nullptr otherwise. + * @return A reference to the issue at the given index on success, @c nullptr otherwise. */ - ErrorPtr error(size_t index) const; + IssuePtr issue(size_t index) const; protected: Logger(); /**< Constructor */ diff --git a/src/api/libcellml/module/libcellml b/src/api/libcellml/module/libcellml index d2b657167..730dce633 100644 --- a/src/api/libcellml/module/libcellml +++ b/src/api/libcellml/module/libcellml @@ -25,10 +25,10 @@ limitations under the License. * This is the source code documentation for the libCellML C++ library. */ #include "libcellml/component.h" -#include "libcellml/error.h" #include "libcellml/generator.h" #include "libcellml/generatorprofile.h" #include "libcellml/importsource.h" +#include "libcellml/issue.h" #include "libcellml/logger.h" #include "libcellml/model.h" #include "libcellml/parser.h" diff --git a/src/api/libcellml/types.h b/src/api/libcellml/types.h index 640533363..dd7f8905d 100644 --- a/src/api/libcellml/types.h +++ b/src/api/libcellml/types.h @@ -21,8 +21,8 @@ limitations under the License. namespace libcellml { // General classes. -class Error; /**< Forward declaration of Error class. */ -using ErrorPtr = std::shared_ptr; /**< Type definition for shared error pointer. */ +class Issue; /**< Forward declaration of Issue class. */ +using IssuePtr = std::shared_ptr; /**< Type definition for shared issue pointer. */ class Generator; /**< Forward declaration of Generator class. */ using GeneratorPtr = std::shared_ptr; /**< Type definition for shared generator pointer. */ class GeneratorProfile; /**< Forward declaration of GeneratorProfile class. */ diff --git a/src/api/libcellml/units.h b/src/api/libcellml/units.h index fc1508745..4cc69f074 100644 --- a/src/api/libcellml/units.h +++ b/src/api/libcellml/units.h @@ -24,7 +24,7 @@ limitations under the License. #include // MSVC (and some other compilers?) may define PASCAL as __stdcall, resulting in -// some compilation errors for our StandardUnit enum class below. However, that +// some compilation issues for our StandardUnit enum class below. However, that // macro gets defined for backward compatibility, so we can safely undefine it. // (See https://stackoverflow.com/questions/2774171/what-is-far-pascal for more // information.) @@ -404,7 +404,7 @@ class LIBCELLML_EXPORT Units: public NamedEntity, public ImportedEntity * @brief Test to determine whether two @c Units are equivalent or not. * * Two @c Units are considered to be equivalent if they share the same units, - * independently of their dimension (e.g. volt and volt are equivalent as are + * independently of their dimension (e.g. volt and volt are equivalent as are * volt and millivolt). * * @param1 units1 The first units to compare. @@ -418,7 +418,7 @@ class LIBCELLML_EXPORT Units: public NamedEntity, public ImportedEntity * @brief Test to determine whether two @c Units are dimensionally equivalent or not. * * Two @c Units are considered to be dimensionally equivalent if they share the - * exact same units (e.g. volt and volt are dimensionally equivalent but + * exact same units (e.g. volt and volt are dimensionally equivalent but * volt and millivolt are not). * * @param1 units1 The first units to compare. diff --git a/src/api/libcellml/validator.h b/src/api/libcellml/validator.h index 4dee688a8..fc9edab31 100644 --- a/src/api/libcellml/validator.h +++ b/src/api/libcellml/validator.h @@ -53,7 +53,7 @@ class LIBCELLML_EXPORT Validator: public Logger * @brief Validate the @p model using the CellML 2.0 Specification. * * Validate the given @p model and its encapsulated entities using the - * CellML 2.0 Specification. Any errors will be logged in the @c Validator. + * CellML 2.0 Specification. Any issues will be logged in the @c Validator. * * @param model The model to validate. */ diff --git a/src/bindings/interface/error.i b/src/bindings/interface/error.i deleted file mode 100644 index ae4748ae3..000000000 --- a/src/bindings/interface/error.i +++ /dev/null @@ -1,110 +0,0 @@ -%module(package="libcellml") error - -#define LIBCELLML_EXPORT - -%include - -%import "createconstructor.i" -%import "types.i" - -%feature("docstring") libcellml::Error -"Base class for errors used with logger derived classes." - -%feature("docstring") libcellml::Error::description -"Get a string description for why this error was raised."; - -%feature("docstring") libcellml::Error::setDescription -"Sets a string description for why this error was raised."; - -%feature("docstring") libcellml::Error::kind -"Get the ``kind`` of this error. If no kind has been set for this error, will -return Kind::UNDEFINED."; - -%feature("docstring") libcellml::Error::isKind -"Tests if this error matches the given ``kind``."; - -%feature("docstring") libcellml::Error::setKind -"Sets the ``kind`` of this error."; - -%feature("docstring") libcellml::Error::rule -"Get the :class:`SpecificationRule` of this error."; - -%feature("docstring") libcellml::Error::setRule -"Sets the :class:`SpecificationRule` for this error."; - -%feature("docstring") libcellml::Error::specificationHeading -"Returns the CellML 2.0 Specification heading associated with the -:class:`SpecificationRule` for this error (empty string if not set)."; - -%feature("docstring") libcellml::Error::component -"Returns the :class:`Component` that this error is relevant to (or ``None``)."; - -%feature("docstring") libcellml::Error::setComponent -"Sets the :class:`Component` that this error is relevant to (``None`` to unset)."; - -%feature("docstring") libcellml::Error::importSource -"Returns the :class:`ImportSource` that this error is relevant to (or ``None``)."; - -%feature("docstring") libcellml::Error::setImportSource -"Sets the :class:`ImportSource` that this error is relevant to (``None`` to unset)."; - -%feature("docstring") libcellml::Error::model -"Returns the :class:`Model` that this error is relevant to (or ``None``)."; - -%feature("docstring") libcellml::Error::setModel -"Sets the :class:`Model` that this error is relevant to (``None`` to unset)."; - -%feature("docstring") libcellml::Error::units -"Get the :class:`Units` that this error is relevant to (or ``None``)."; - -%feature("docstring") libcellml::Error::setUnits -"Sets the :class`Units` that this error is relevant to (``None`` to unset)."; - -%feature("docstring") libcellml::Error::variable -"Get the :class:`Variable` that this error is relevant to (or ``None``)."; - -%feature("docstring") libcellml::Error::setVariable -"Sets the :class:`Variable` that this error is relevant to (``None`` to unset)."; - -%feature("docstring") libcellml::Error::reset -"Get the :class:`Reset` that this error is relevant to (or ``None``)."; - -%feature("docstring") libcellml::Error::setReset -"Sets the :class:`Reset` that this error is relevant to (``None`` to unset)."; - -%{ -#include "libcellml/error.h" -%} - -%create_constructor(Error) -%extend libcellml::Error { - Error(const ComponentPtr &component) { - auto ptr = new std::shared_ptr< libcellml::Error >(libcellml::Error::create(component)); - return reinterpret_cast(ptr); - } - Error(const ImportSourcePtr &importSource) { - auto ptr = new std::shared_ptr< libcellml::Error >(libcellml::Error::create(importSource)); - return reinterpret_cast(ptr); - } - Error(const ModelPtr &model) { - auto ptr = new std::shared_ptr< libcellml::Error >(libcellml::Error::create(model)); - return reinterpret_cast(ptr); - } - Error(const ResetPtr &reset) { - auto ptr = new std::shared_ptr< libcellml::Error >(libcellml::Error::create(reset)); - return reinterpret_cast(ptr); - } - Error(const UnitsPtr &units) { - auto ptr = new std::shared_ptr< libcellml::Error >(libcellml::Error::create(units)); - return reinterpret_cast(ptr); - } - Error(const VariablePtr &variable) { - auto ptr = new std::shared_ptr< libcellml::Error >(libcellml::Error::create(variable)); - return reinterpret_cast(ptr); - } -} - -%include "libcellml/exportdefinitions.h" -%include "libcellml/specificationrules.h" -%include "libcellml/types.h" -%include "libcellml/error.h" diff --git a/src/bindings/interface/issue.i b/src/bindings/interface/issue.i new file mode 100644 index 000000000..924071cce --- /dev/null +++ b/src/bindings/interface/issue.i @@ -0,0 +1,110 @@ +%module(package="libcellml") issue + +#define LIBCELLML_EXPORT + +%include + +%import "createconstructor.i" +%import "types.i" + +%feature("docstring") libcellml::Issue +"Base class for errors used with logger derived classes." + +%feature("docstring") libcellml::Issue::description +"Get a string description for why this issue was raised."; + +%feature("docstring") libcellml::Issue::setDescription +"Sets a string description for why this issue was raised."; + +%feature("docstring") libcellml::Issue::kind +"Get the ``kind`` of this issue. If no kind has been set for this issue, will +return Kind::UNDEFINED."; + +%feature("docstring") libcellml::Issue::isKind +"Tests if this issue matches the given ``kind``."; + +%feature("docstring") libcellml::Issue::setKind +"Sets the ``kind`` of this issue."; + +%feature("docstring") libcellml::Issue::rule +"Get the :class:`SpecificationRule` of this issue."; + +%feature("docstring") libcellml::Issue::setRule +"Sets the :class:`SpecificationRule` for this issue."; + +%feature("docstring") libcellml::Issue::specificationHeading +"Returns the CellML 2.0 Specification heading associated with the +:class:`SpecificationRule` for this issue (empty string if not set)."; + +%feature("docstring") libcellml::Issue::component +"Returns the :class:`Component` that this issue is relevant to (or ``None``)."; + +%feature("docstring") libcellml::Issue::setComponent +"Sets the :class:`Component` that this issue is relevant to (``None`` to unset)."; + +%feature("docstring") libcellml::Issue::importSource +"Returns the :class:`ImportSource` that this issue is relevant to (or ``None``)."; + +%feature("docstring") libcellml::Issue::setImportSource +"Sets the :class:`ImportSource` that this issue is relevant to (``None`` to unset)."; + +%feature("docstring") libcellml::Issue::model +"Returns the :class:`Model` that this issue is relevant to (or ``None``)."; + +%feature("docstring") libcellml::Issue::setModel +"Sets the :class:`Model` that this issue is relevant to (``None`` to unset)."; + +%feature("docstring") libcellml::Issue::units +"Get the :class:`Units` that this issue is relevant to (or ``None``)."; + +%feature("docstring") libcellml::Issue::setUnits +"Sets the :class`Units` that this issue is relevant to (``None`` to unset)."; + +%feature("docstring") libcellml::Issue::variable +"Get the :class:`Variable` that this issue is relevant to (or ``None``)."; + +%feature("docstring") libcellml::Issue::setVariable +"Sets the :class:`Variable` that this issue is relevant to (``None`` to unset)."; + +%feature("docstring") libcellml::Issue::reset +"Get the :class:`Reset` that this issue is relevant to (or ``None``)."; + +%feature("docstring") libcellml::Issue::setReset +"Sets the :class:`Reset` that this issue is relevant to (``None`` to unset)."; + +%{ +#include "libcellml/issue.h" +%} + +%create_constructor(Issue) +%extend libcellml::Issue { + Issue(const ComponentPtr &component) { + auto ptr = new std::shared_ptr< libcellml::Issue >(libcellml::Issue::create(component)); + return reinterpret_cast(ptr); + } + Issue(const ImportSourcePtr &importSource) { + auto ptr = new std::shared_ptr< libcellml::Issue >(libcellml::Issue::create(importSource)); + return reinterpret_cast(ptr); + } + Issue(const ModelPtr &model) { + auto ptr = new std::shared_ptr< libcellml::Issue >(libcellml::Issue::create(model)); + return reinterpret_cast(ptr); + } + Issue(const ResetPtr &reset) { + auto ptr = new std::shared_ptr< libcellml::Issue >(libcellml::Issue::create(reset)); + return reinterpret_cast(ptr); + } + Issue(const UnitsPtr &units) { + auto ptr = new std::shared_ptr< libcellml::Issue >(libcellml::Issue::create(units)); + return reinterpret_cast(ptr); + } + Issue(const VariablePtr &variable) { + auto ptr = new std::shared_ptr< libcellml::Issue >(libcellml::Issue::create(variable)); + return reinterpret_cast(ptr); + } +} + +%include "libcellml/exportdefinitions.h" +%include "libcellml/specificationrules.h" +%include "libcellml/types.h" +%include "libcellml/issue.h" diff --git a/src/bindings/interface/logger.i b/src/bindings/interface/logger.i index 229267fa3..215c78de0 100644 --- a/src/bindings/interface/logger.i +++ b/src/bindings/interface/logger.i @@ -7,24 +7,24 @@ %feature("docstring") libcellml::Logger "Base class for all serialisable libCellML classes."; -%feature("docstring") libcellml::Logger::addError -"Adds an error to this logger."; +%feature("docstring") libcellml::Logger::addIssue +"Adds an issue to this logger."; %feature("docstring") libcellml::Logger::removeAllErrors "Clears all errors from this logger."; -%feature("docstring") libcellml::Logger::error -"Returns the error at the specified `index`."; +%feature("docstring") libcellml::Logger::issue +"Returns the issue at the specified `index`."; -%feature("docstring") libcellml::Logger::errorCount +%feature("docstring") libcellml::Logger::issueCount "Returns the number of errors currently stored in the logger."; #if defined(SWIGPYTHON) // Treat negative size_t as invalid index (instead of unknown method) %extend libcellml::Logger { - ErrorPtr error(long index) { + IssuePtr issue(long index) { if (index < 0) return nullptr; - return $self->error(size_t(index)); + return $self->issue(size_t(index)); } } #endif diff --git a/src/bindings/interface/types.i b/src/bindings/interface/types.i index 76b06d344..8dced702e 100644 --- a/src/bindings/interface/types.i +++ b/src/bindings/interface/types.i @@ -8,7 +8,7 @@ Only meant to be included, shouldn't be passed to cmake as a module! %shared_ptr(libcellml::Component) %shared_ptr(libcellml::ComponentEntity) %shared_ptr(libcellml::Entity) -%shared_ptr(libcellml::Error) +%shared_ptr(libcellml::Issue) %shared_ptr(libcellml::Generator) %shared_ptr(libcellml::GeneratorProfile) %shared_ptr(libcellml::ImportSource) @@ -50,12 +50,12 @@ Only meant to be included, shouldn't be passed to cmake as a module! } } -%typemap(in) libcellml::Error::Kind (int val, int ecode) { +%typemap(in) libcellml::Issue::Kind (int val, int ecode) { ecode = SWIG_AsVal(int)($input, &val); if (!SWIG_IsOK(ecode)) { %argument_fail(ecode, "$type", $symname, $argnum); } else { - if (val < %static_cast(libcellml::Error::Kind::COMPONENT, int) || %static_cast(libcellml::Error::Kind::XML, int) < val) { + if (val < %static_cast(libcellml::Issue::Kind::COMPONENT, int) || %static_cast(libcellml::Issue::Kind::XML, int) < val) { %argument_fail(ecode, "$type is not a valid value for the enumeration.", $symname, $argnum); } $1 = %static_cast(val,$basetype); @@ -109,5 +109,3 @@ Only meant to be included, shouldn't be passed to cmake as a module! $1 = %static_cast(val,$basetype); } } - - diff --git a/src/bindings/python/CMakeLists.txt b/src/bindings/python/CMakeLists.txt index 288a3507b..55eb1b4ef 100644 --- a/src/bindings/python/CMakeLists.txt +++ b/src/bindings/python/CMakeLists.txt @@ -21,13 +21,13 @@ endif() set(SWIG_INTERFACE_SRCS ../interface/component.i ../interface/componententity.i - ../interface/error.i ../interface/entity.i ../interface/enumerations.i ../interface/generator.i ../interface/generatorprofile.i ../interface/importsource.i ../interface/importedentity.i + ../interface/issue.i ../interface/logger.i ../interface/model.i ../interface/namedentity.i diff --git a/src/bindings/python/__init__.py b/src/bindings/python/__init__.py index 52d7ae408..81c3f71ec 100644 --- a/src/bindings/python/__init__.py +++ b/src/bindings/python/__init__.py @@ -8,7 +8,7 @@ """ from libcellml.component import Component -from libcellml.error import Error +from libcellml.issue import Issue from libcellml.generator import Generator from libcellml.generator import GeneratorVariable from libcellml.generatorprofile import GeneratorProfile @@ -41,7 +41,7 @@ class Object: converting = True if converting: setattr(base if new_base is None else new_base, enum, obj) -convert(Error, 'Kind', [ +convert(Issue, 'Kind', [ 'COMPONENT', 'CONNECTION', 'ENCAPSULATION', diff --git a/src/generator.cpp b/src/generator.cpp index 357ef3b90..ca6783f6d 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1048,15 +1048,15 @@ void Generator::GeneratorImpl::processNode(const XmlNodePtr &node, } } else { std::string modelName = entityName(owningModel(component)); - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + variableName + "' in component '" + component->name() + "' of model '" + modelName + "' is referenced in an equation, but it is not defined anywhere."); - err->setKind(Error::Kind::GENERATOR); + err->setKind(Issue::Kind::GENERATOR); - mGenerator->addError(err); + mGenerator->addIssue(err); } } else if (node->isMathmlElement("cn")) { if (mathmlChildCount(node) == 1) { @@ -1152,7 +1152,7 @@ void Generator::GeneratorImpl::processComponent(const ComponentPtr &component) // Replace the variable held by `generatorVariable`, in case the // existing one has no initial value while `variable` does. Otherwise, - // generate an error if the variable held by `generatorVariable` and + // generate an issue if the variable held by `generatorVariable` and // `variable` are both initialised. if (!variable->initialValue().empty() @@ -1164,7 +1164,7 @@ void Generator::GeneratorImpl::processComponent(const ComponentPtr &component) ModelPtr model = owningModel(component); ComponentPtr trackedVariableComponent = std::dynamic_pointer_cast(generatorVariable->mVariable->parent()); ModelPtr trackedVariableModel = owningModel(trackedVariableComponent); - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + variable->name() + "' in component '" + component->name() @@ -1173,9 +1173,9 @@ void Generator::GeneratorImpl::processComponent(const ComponentPtr &component) + "' in component '" + trackedVariableComponent->name() + "' of model '" + trackedVariableModel->name() + "' are equivalent and cannot therefore both be initialised."); - err->setKind(Error::Kind::GENERATOR); + err->setKind(Issue::Kind::GENERATOR); - mGenerator->addError(err); + mGenerator->addIssue(err); } } @@ -1203,7 +1203,7 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr generatorVariable(variable)->makeVoi(); // Note: we must make the variable a variable of integration in all // cases (i.e. even if there is, for example, already another - // variable of integration) otherwise unnecessary error messages + // variable of integration) otherwise unnecessary issue messages // may be reported (since the type of the variable would be // unknown). @@ -1214,15 +1214,15 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr if (!variable->initialValue().empty()) { ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); std::string modelName = entityName(owningModel(component)); - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + variable->name() + "' in component '" + component->name() + "' of model '" + modelName + "' cannot be both a variable of integration and initialised."); - err->setKind(Error::Kind::GENERATOR); + err->setKind(Issue::Kind::GENERATOR); - mGenerator->addError(err); + mGenerator->addIssue(err); } else { mVoi = variable; } @@ -1232,7 +1232,7 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr ModelPtr voiModel = owningModel(voiComponent); ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); ModelPtr model = owningModel(component); - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + mVoi->name() + "' in component '" + voiComponent->name() @@ -1241,9 +1241,9 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr + "' in component '" + component->name() + "' of model '" + model->name() + "' cannot both be a variable of integration."); - err->setKind(Error::Kind::GENERATOR); + err->setKind(Issue::Kind::GENERATOR); - mGenerator->addError(err); + mGenerator->addIssue(err); } } @@ -1257,15 +1257,15 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr VariablePtr variable = astGreatGrandParent->mRight->mVariable; ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); ModelPtr model = owningModel(component); - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("The differential equation for variable '" + variable->name() + "' in component '" + component->name() + "' of model '" + model->name() + "' must be of the first order."); - err->setKind(Error::Kind::GENERATOR); + err->setKind(Issue::Kind::GENERATOR); - mGenerator->addError(err); + mGenerator->addIssue(err); } } @@ -1366,7 +1366,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) // Process our different equations' AST to determine the type of our // variables. - if (mGenerator->errorCount() == 0) { + if (mGenerator->issueCount() == 0) { for (const auto &equation : mEquations) { processEquationAst(equation->mAst); } @@ -1376,7 +1376,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) // then loop over our equations, checking which variables, if any, can be // determined using a given equation. - if (mGenerator->errorCount() == 0) { + if (mGenerator->issueCount() == 0) { mInternalVariables.sort(compareVariablesByName); size_t variableIndex = MAX_SIZE_T; @@ -1408,7 +1408,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) // Make sure that our variables are valid. - if (mGenerator->errorCount() == 0) { + if (mGenerator->issueCount() == 0) { for (const auto &internalVariable : mInternalVariables) { std::string errorType; @@ -1435,7 +1435,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) } if (!errorType.empty()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); VariablePtr realVariable = internalVariable->mVariable; ComponentPtr realComponent = std::dynamic_pointer_cast(realVariable->parent()); ModelPtr realModel = owningModel(realComponent); @@ -1443,9 +1443,9 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) err->setDescription("Variable '" + realVariable->name() + "' in component '" + realComponent->name() + "' of model '" + realModel->name() + "' " + errorType + "."); - err->setKind(Error::Kind::GENERATOR); + err->setKind(Issue::Kind::GENERATOR); - mGenerator->addError(err); + mGenerator->addIssue(err); } } } @@ -3426,12 +3426,12 @@ void Generator::processModel(const ModelPtr &model) validator->validateModel(model); - if (validator->errorCount() > 0) { - // The model is not valid, so retrieve the validation errors and make + if (validator->issueCount() > 0) { + // The model is not valid, so retrieve the validation issues and make // them our own. - for (size_t i = 0; i < validator->errorCount(); ++i) { - addError(validator->error(i)); + for (size_t i = 0; i < validator->issueCount(); ++i) { + addIssue(validator->issue(i)); } return; diff --git a/src/error.cpp b/src/issue.cpp similarity index 64% rename from src/error.cpp rename to src/issue.cpp index 4d7804aad..6e0ee3cac 100644 --- a/src/error.cpp +++ b/src/issue.cpp @@ -14,7 +14,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -#include "libcellml/error.h" +#include "libcellml/issue.h" #include "libcellml/types.h" #include @@ -23,131 +23,131 @@ limitations under the License. namespace libcellml { /** - * @brief The Error::ErrorImpl struct. + * @brief The Issue::IssueImpl struct. * - * The private implementation for the Error class. + * The private implementation for the Issue class. */ -struct Error::ErrorImpl -{ - std::string mDescription; /**< The string description for why this entity error raised. */ - Error::Kind mKind = Error::Kind::UNDEFINED; /**< The Error::Kind enum value for this error. */ - SpecificationRule mRule = SpecificationRule::UNDEFINED; /**< The SpecificationRule enum value for this error. */ - ComponentPtr mComponent; /**< Pointer to the component that the error occurred in. */ - ImportSourcePtr mImportSource; /**< Pointer to the import source that the error occurred in. */ - ModelPtr mModel; /**< Pointer to the model that the error occurred in. */ - UnitsPtr mUnits; /**< Pointer to the units that the error occurred in. */ - VariablePtr mVariable; /**< Pointer to the variable that the error occurred in. */ - ResetPtr mReset; /**< Pointer to the reset that the error ocurred in. */ +struct Issue::IssueImpl +{ + std::string mDescription; /**< The string description for why this entity issue raised. */ + Issue::Kind mKind = Issue::Kind::UNDEFINED; /**< The Issue::Kind enum value for this issue. */ + SpecificationRule mRule = SpecificationRule::UNDEFINED; /**< The SpecificationRule enum value for this issue. */ + ComponentPtr mComponent; /**< Pointer to the component that the issue occurred in. */ + ImportSourcePtr mImportSource; /**< Pointer to the import source that the issue occurred in. */ + ModelPtr mModel; /**< Pointer to the model that the issue occurred in. */ + UnitsPtr mUnits; /**< Pointer to the units that the issue occurred in. */ + VariablePtr mVariable; /**< Pointer to the variable that the issue occurred in. */ + ResetPtr mReset; /**< Pointer to the reset that the issue ocurred in. */ }; -Error::Error() - : mPimpl(new ErrorImpl()) +Issue::Issue() + : mPimpl(new IssueImpl()) { } -Error::~Error() +Issue::~Issue() { delete mPimpl; } -Error::Error(const ModelPtr &model) - : mPimpl(new ErrorImpl()) +Issue::Issue(const ModelPtr &model) + : mPimpl(new IssueImpl()) { mPimpl->mModel = model; - mPimpl->mKind = Error::Kind::MODEL; + mPimpl->mKind = Issue::Kind::MODEL; } -Error::Error(const ComponentPtr &component) - : mPimpl(new ErrorImpl()) +Issue::Issue(const ComponentPtr &component) + : mPimpl(new IssueImpl()) { mPimpl->mComponent = component; - mPimpl->mKind = Error::Kind::COMPONENT; + mPimpl->mKind = Issue::Kind::COMPONENT; } -Error::Error(const ImportSourcePtr &importSource) - : mPimpl(new ErrorImpl()) +Issue::Issue(const ImportSourcePtr &importSource) + : mPimpl(new IssueImpl()) { mPimpl->mImportSource = importSource; - mPimpl->mKind = Error::Kind::IMPORT; + mPimpl->mKind = Issue::Kind::IMPORT; } -Error::Error(const UnitsPtr &units) - : mPimpl(new ErrorImpl()) +Issue::Issue(const UnitsPtr &units) + : mPimpl(new IssueImpl()) { mPimpl->mUnits = units; - mPimpl->mKind = Error::Kind::UNITS; + mPimpl->mKind = Issue::Kind::UNITS; } -Error::Error(const VariablePtr &variable) - : mPimpl(new ErrorImpl()) +Issue::Issue(const VariablePtr &variable) + : mPimpl(new IssueImpl()) { mPimpl->mVariable = variable; - mPimpl->mKind = Error::Kind::VARIABLE; + mPimpl->mKind = Issue::Kind::VARIABLE; } -Error::Error(const ResetPtr &reset) - : mPimpl(new ErrorImpl()) +Issue::Issue(const ResetPtr &reset) + : mPimpl(new IssueImpl()) { mPimpl->mReset = reset; - mPimpl->mKind = Error::Kind::RESET; + mPimpl->mKind = Issue::Kind::RESET; } -ErrorPtr Error::create() noexcept +IssuePtr Issue::create() noexcept { - return std::shared_ptr {new Error {}}; + return std::shared_ptr {new Issue {}}; } -ErrorPtr Error::create(const ComponentPtr &component) noexcept +IssuePtr Issue::create(const ComponentPtr &component) noexcept { - return std::shared_ptr {new Error {component}}; + return std::shared_ptr {new Issue {component}}; } -ErrorPtr Error::create(const ImportSourcePtr &importSource) noexcept +IssuePtr Issue::create(const ImportSourcePtr &importSource) noexcept { - return std::shared_ptr {new Error {importSource}}; + return std::shared_ptr {new Issue {importSource}}; } -ErrorPtr Error::create(const ModelPtr &model) noexcept +IssuePtr Issue::create(const ModelPtr &model) noexcept { - return std::shared_ptr {new Error {model}}; + return std::shared_ptr {new Issue {model}}; } -ErrorPtr Error::create(const ResetPtr &reset) noexcept +IssuePtr Issue::create(const ResetPtr &reset) noexcept { - return std::shared_ptr {new Error {reset}}; + return std::shared_ptr {new Issue {reset}}; } -ErrorPtr Error::create(const UnitsPtr &units) noexcept +IssuePtr Issue::create(const UnitsPtr &units) noexcept { - return std::shared_ptr {new Error {units}}; + return std::shared_ptr {new Issue {units}}; } -ErrorPtr Error::create(const VariablePtr &variable) noexcept +IssuePtr Issue::create(const VariablePtr &variable) noexcept { - return std::shared_ptr {new Error {variable}}; + return std::shared_ptr {new Issue {variable}}; } -void Error::setDescription(const std::string &description) +void Issue::setDescription(const std::string &description) { mPimpl->mDescription = description; } -std::string Error::description() const +std::string Issue::description() const { return mPimpl->mDescription; } -void Error::setKind(Error::Kind kind) +void Issue::setKind(Issue::Kind kind) { mPimpl->mKind = kind; } -Error::Kind Error::kind() const +Issue::Kind Issue::kind() const { return mPimpl->mKind; } -bool Error::isKind(Kind kind) const +bool Issue::isKind(Kind kind) const { bool response = false; if (mPimpl->mKind == kind) { @@ -156,78 +156,78 @@ bool Error::isKind(Kind kind) const return response; } -void Error::setRule(SpecificationRule rule) +void Issue::setRule(SpecificationRule rule) { mPimpl->mRule = rule; } -SpecificationRule Error::rule() const +SpecificationRule Issue::rule() const { return mPimpl->mRule; } -void Error::setComponent(const ComponentPtr &component) +void Issue::setComponent(const ComponentPtr &component) { mPimpl->mComponent = component; - mPimpl->mKind = Error::Kind::COMPONENT; + mPimpl->mKind = Issue::Kind::COMPONENT; } -ComponentPtr Error::component() const +ComponentPtr Issue::component() const { return mPimpl->mComponent; } -void Error::setImportSource(const ImportSourcePtr &importSource) +void Issue::setImportSource(const ImportSourcePtr &importSource) { mPimpl->mImportSource = importSource; - mPimpl->mKind = Error::Kind::IMPORT; + mPimpl->mKind = Issue::Kind::IMPORT; } -ImportSourcePtr Error::importSource() const +ImportSourcePtr Issue::importSource() const { return mPimpl->mImportSource; } -void Error::setModel(const ModelPtr &model) +void Issue::setModel(const ModelPtr &model) { mPimpl->mModel = model; - mPimpl->mKind = Error::Kind::MODEL; + mPimpl->mKind = Issue::Kind::MODEL; } -ModelPtr Error::model() const +ModelPtr Issue::model() const { return mPimpl->mModel; } -void Error::setUnits(const UnitsPtr &units) +void Issue::setUnits(const UnitsPtr &units) { mPimpl->mUnits = units; - mPimpl->mKind = Error::Kind::UNITS; + mPimpl->mKind = Issue::Kind::UNITS; } -UnitsPtr Error::units() const +UnitsPtr Issue::units() const { return mPimpl->mUnits; } -void Error::setVariable(const VariablePtr &variable) +void Issue::setVariable(const VariablePtr &variable) { mPimpl->mVariable = variable; - mPimpl->mKind = Error::Kind::VARIABLE; + mPimpl->mKind = Issue::Kind::VARIABLE; } -VariablePtr Error::variable() const +VariablePtr Issue::variable() const { return mPimpl->mVariable; } -void Error::setReset(const ResetPtr &reset) +void Issue::setReset(const ResetPtr &reset) { mPimpl->mReset = reset; - mPimpl->mKind = Error::Kind::RESET; + mPimpl->mKind = Issue::Kind::RESET; } -ResetPtr Error::reset() const +ResetPtr Issue::reset() const { return mPimpl->mReset; } @@ -296,7 +296,7 @@ static const std::map ruleToHeading = { {SpecificationRule::MAP_VARIABLES_VARIABLE2, "18.1.2"}, {SpecificationRule::MAP_VARIABLES_UNIQUE, "18.1.3"}}; -std::string Error::specificationHeading() const +std::string Issue::specificationHeading() const { std::string heading = "X.Y.Z"; auto search = ruleToHeading.find(rule()); diff --git a/src/logger.cpp b/src/logger.cpp index 4a18a555a..517bb52ad 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -31,7 +31,7 @@ namespace libcellml { */ struct Logger::LoggerImpl { - std::vector mErrors; + std::vector mErrors; }; Logger::Logger() @@ -49,19 +49,19 @@ void Logger::removeAllErrors() mPimpl->mErrors.clear(); } -void Logger::addError(const ErrorPtr &error) +void Logger::addIssue(const IssuePtr &issue) { - mPimpl->mErrors.push_back(error); + mPimpl->mErrors.push_back(issue); } -size_t Logger::errorCount() const +size_t Logger::issueCount() const { return mPimpl->mErrors.size(); } -ErrorPtr Logger::error(size_t index) const +IssuePtr Logger::issue(size_t index) const { - ErrorPtr err = nullptr; + IssuePtr err = nullptr; if (index < mPimpl->mErrors.size()) { err = mPimpl->mErrors.at(index); } diff --git a/src/parser.cpp b/src/parser.cpp index ccbb599d2..28dd2086a 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -23,8 +23,8 @@ limitations under the License. #include #include "libcellml/component.h" -#include "libcellml/error.h" #include "libcellml/importsource.h" +#include "libcellml/issue.h" #include "libcellml/model.h" #include "libcellml/reset.h" #include "libcellml/variable.h" @@ -201,7 +201,7 @@ struct Parser::ParserImpl * @brief Checks the multiplicity of the @p childType. * * Checks to determine if the @p childType has the correct number of entries - * for a @c Reset. Adds an error to the @c Parser if the @p count is not correct + * for a @c Reset. Adds an issue to the @c Parser if the @p count is not correct * for the @p childType. * * @param count The number of children of the type defined by @p childType. @@ -233,11 +233,11 @@ ModelPtr Parser::parseModel(const std::string &input) removeAllErrors(); ModelPtr model = Model::create(); if (input.empty()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Model is empty."); - err->setKind(Error::Kind::XML); + err->setKind(Issue::Kind::XML); err->setModel(model); - addError(err); + addIssue(err); } else { mPimpl->updateModel(model, input); } @@ -253,25 +253,25 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp { XmlDocPtr doc = std::make_shared(); doc->parse(input); - // Copy any XML parsing errors into the common parser error handler. + // Copy any XML parsing issues into the common parser issue handler. if (doc->xmlErrorCount() > 0) { for (size_t i = 0; i < doc->xmlErrorCount(); ++i) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("LibXml2 error: " + doc->xmlError(i)); - err->setKind(Error::Kind::XML); - mParser->addError(err); + err->setKind(Issue::Kind::XML); + mParser->addIssue(err); } } const XmlNodePtr node = doc->rootNode(); if (!node) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Could not get a valid XML root node from the provided input."); - err->setKind(Error::Kind::XML); - mParser->addError(err); + err->setKind(Issue::Kind::XML); + mParser->addIssue(err); return; } if (!node->isCellmlElement("model")) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); if (node->name() == "model") { std::string nodeNamespace = node->namespaceUri(); if (nodeNamespace.empty()) { @@ -283,7 +283,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp } err->setModel(model); err->setRule(SpecificationRule::MODEL_ELEMENT); - mParser->addError(err); + mParser->addIssue(err); return; } // Get model attributes. @@ -294,10 +294,10 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp } else if (attribute->isType("id")) { model->setId(attribute->value()); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Model '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); err->setModel(model); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -326,11 +326,11 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp if (childAttribute->isType("id")) { model->setEncapsulationId(childAttribute->value()); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid attribute '" + childAttribute->name() + "'."); err->setModel(model); - err->setKind(Error::Kind::ENCAPSULATION); - mParser->addError(err); + err->setKind(Issue::Kind::ENCAPSULATION); + mParser->addIssue(err); } childAttribute = childAttribute->next(); } @@ -339,16 +339,16 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp XmlNodePtr componentRefNode = childNode->firstChild(); if (componentRefNode) { // This component_ref and its child and sibling elements will be loaded - // and error-checked in loadEncapsulation(). + // and issue-checked in loadEncapsulation(). encapsulationNodes.push_back(componentRefNode); } else { // TODO Should this be removed? - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' does not contain any child elements."); err->setModel(model); - err->setKind(Error::Kind::ENCAPSULATION); + err->setKind(Issue::Kind::ENCAPSULATION); err->setRule(SpecificationRule::ENCAPSULATION_COMPONENT_REF); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isCellmlElement("connection")) { connectionNodes.push_back(childNode); @@ -356,20 +356,20 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); err->setRule(SpecificationRule::MODEL_CHILD); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setModel(model); err->setRule(SpecificationRule::MODEL_CHILD); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); } @@ -377,12 +377,12 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp if (!encapsulationNodes.empty()) { loadEncapsulation(model, encapsulationNodes.at(0)); if (encapsulationNodes.size() > 1) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' has more than one encapsulation element."); err->setModel(model); - err->setKind(Error::Kind::ENCAPSULATION); + err->setKind(Issue::Kind::ENCAPSULATION); err->setRule(SpecificationRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); - mParser->addError(err); + mParser->addIssue(err); } } for (const auto &connectionNode : connectionNodes) { @@ -490,10 +490,10 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN } else if (attribute->isType("id")) { component->setId(attribute->value()); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Component '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); err->setComponent(component); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -525,20 +525,20 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Component '" + component->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setComponent(component); err->setRule(SpecificationRule::COMPONENT_CHILD); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Component '" + component->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setComponent(component); err->setRule(SpecificationRule::COMPONENT_CHILD); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); } @@ -553,10 +553,10 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node } else if (attribute->isType("id")) { units->setId(attribute->value()); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); err->setUnits(units); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -568,20 +568,20 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setUnits(units); err->setRule(SpecificationRule::UNITS_CHILD); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setUnits(units); err->setRule(SpecificationRule::UNITS_CHILD); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); } @@ -601,18 +601,18 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setUnits(units); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setUnits(units); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); } @@ -628,31 +628,31 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) exponent = convertToDouble(attribute->value()); } else { // TODO This value won't be saved for validation later, so it does need to be reported now - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an exponent with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_EXPONENT); - mParser->addError(err); + mParser->addIssue(err); } } else if (attribute->isType("multiplier")) { if (isCellMLReal(attribute->value())) { multiplier = convertToDouble(attribute->value()); } else { // TODO his value won't be saved for validation later, so it does need to be reported now - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has a multiplier with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_MULTIPLIER); - mParser->addError(err); + mParser->addIssue(err); } } else if (attribute->isType("id")) { id = attribute->value(); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_OPTIONAL_ATTRIBUTE); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -669,18 +669,18 @@ void Parser::ParserImpl::loadVariable(const VariablePtr &variable, const XmlNode std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + node->attribute("name") + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setVariable(variable); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + node->attribute("name") + "' has an invalid child element '" + childNode->name() + "'."); err->setVariable(variable); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); } @@ -697,10 +697,10 @@ void Parser::ParserImpl::loadVariable(const VariablePtr &variable, const XmlNode } else if (attribute->isType("initial_value")) { variable->setInitialValue(attribute->value()); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); err->setVariable(variable); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -736,31 +736,31 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr } else if (attribute->isType("id")) { connectionId = attribute->value(); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' has an invalid connection attribute '" + attribute->name() + "'."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); - mParser->addError(err); + err->setKind(Issue::Kind::CONNECTION); + mParser->addIssue(err); } attribute = attribute->next(); } // Check that we found both components. if (component1Name.empty()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' does not have a valid component_1 in a connection element."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); + err->setKind(Issue::Kind::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT1); - mParser->addError(err); + mParser->addIssue(err); component1Missing = true; } if (component2Name.empty()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' does not have a valid component_2 in a connection element."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); + err->setKind(Issue::Kind::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT2); - mParser->addError(err); + mParser->addIssue(err); component2Missing = true; } componentNamePair = std::make_pair(component1Name, component2Name); @@ -769,12 +769,12 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr if (!childNode) { // TODO Should this be removed too? - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' must contain one or more 'map_variables' elements."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); + err->setKind(Issue::Kind::CONNECTION); err->setRule(SpecificationRule::CONNECTION_MAP_VARIABLES); - mParser->addError(err); + mParser->addIssue(err); return; } @@ -787,20 +787,20 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr std::string textNode = grandchildNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); - mParser->addError(err); + err->setKind(Issue::Kind::CONNECTION); + mParser->addIssue(err); } } else if (grandchildNode->isComment()) { // Do nothing. } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' has an invalid child element '" + grandchildNode->name() + "' of element '" + childNode->name() + "'."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); - mParser->addError(err); + err->setKind(Issue::Kind::CONNECTION); + mParser->addIssue(err); } grandchildNode = grandchildNode->next(); } @@ -817,31 +817,31 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr } else if (childAttribute->isType("id")) { mappingId = childAttribute->value(); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' has an invalid map_variables attribute '" + childAttribute->name() + "'."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); - mParser->addError(err); + err->setKind(Issue::Kind::CONNECTION); + mParser->addIssue(err); } childAttribute = childAttribute->next(); } // Check that we found both variables. if (variable1Name.empty()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_1 in a map_variables element."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); + err->setKind(Issue::Kind::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); - mParser->addError(err); + mParser->addIssue(err); variable1Missing = true; } if (variable2Name.empty()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_2 in a map_variables element."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); + err->setKind(Issue::Kind::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); - mParser->addError(err); + mParser->addIssue(err); variable2Missing = true; } // We can have multiple map_variables per connection. @@ -853,20 +853,20 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr const std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); - mParser->addError(err); + err->setKind(Issue::Kind::CONNECTION); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); - mParser->addError(err); + err->setKind(Issue::Kind::CONNECTION); + mParser->addIssue(err); } childNode = childNode->next(); @@ -880,24 +880,24 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr component1 = model->component(componentNamePair.first); } else { if (!component1Missing) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.first + "' as component_1 but it does not exist in the model."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); + err->setKind(Issue::Kind::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT1); - mParser->addError(err); + mParser->addIssue(err); } } if (model->containsComponent(componentNamePair.second)) { component2 = model->component(componentNamePair.second); } else { if (!component2Missing) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.second + "' as component_2 but it does not exist in the model."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); + err->setKind(Issue::Kind::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT2); - mParser->addError(err); + mParser->addIssue(err); } } @@ -916,21 +916,21 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr component1->addVariable(variable1); } else { if (!variable1Missing) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + iterPair.first + "' is specified as variable_1 in a connection but it does not exist in component_1 component '" + component1->name() + "' of model '" + model->name() + "'."); err->setComponent(component1); - err->setKind(Error::Kind::CONNECTION); + err->setKind(Issue::Kind::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); - mParser->addError(err); + mParser->addIssue(err); } } } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.first + "' as variable_1 but the corresponding component_1 is invalid."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); + err->setKind(Issue::Kind::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); - mParser->addError(err); + mParser->addIssue(err); } if (component2) { if (component2->hasVariable(iterPair.second)) { @@ -942,21 +942,21 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr component2->addVariable(variable2); } else { if (!variable2Missing) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + iterPair.second + "' is specified as variable_2 in a connection but it does not exist in component_2 component '" + component2->name() + "' of model '" + model->name() + "'."); err->setComponent(component1); - err->setKind(Error::Kind::CONNECTION); + err->setKind(Issue::Kind::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); - mParser->addError(err); + mParser->addIssue(err); } } } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.second + "' as variable_2 but the corresponding component_2 is invalid."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); + err->setKind(Issue::Kind::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); - mParser->addError(err); + mParser->addIssue(err); } // Set the variable equivalence relationship for this variable pair. if ((variable1) && (variable2)) { @@ -964,12 +964,12 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr } } } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' does not have a map_variables element."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); + err->setKind(Issue::Kind::CONNECTION); err->setRule(SpecificationRule::CONNECTION_MAP_VARIABLES); - mParser->addError(err); + mParser->addIssue(err); } } @@ -987,32 +987,32 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X // Will re-add this to the model once we encapsulate the child(ren). parentComponent = model->takeComponent(parentComponentName); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponentName + "' as a component in a component_ref but it does not exist in the model."); err->setModel(model); - err->setKind(Error::Kind::ENCAPSULATION); + err->setKind(Issue::Kind::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); - mParser->addError(err); + mParser->addIssue(err); } } else if (attribute->isType("id")) { encapsulationId = attribute->value(); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid component_ref attribute '" + attribute->name() + "'."); err->setModel(model); - err->setKind(Error::Kind::ENCAPSULATION); + err->setKind(Issue::Kind::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } if ((!parentComponent) && (parentComponentName.empty())) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' does not have a valid component attribute in a component_ref element."); err->setModel(model); - err->setKind(Error::Kind::ENCAPSULATION); + err->setKind(Issue::Kind::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); - mParser->addError(err); + mParser->addIssue(err); } else if (parentComponent) { parentComponent->setEncapsulationId(encapsulationId); } @@ -1030,20 +1030,20 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X const std::string textNode = childComponentNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); - err->setKind(Error::Kind::ENCAPSULATION); - mParser->addError(err); + err->setKind(Issue::Kind::ENCAPSULATION); + mParser->addIssue(err); } } else if (childComponentNode->isComment()) { // Do nothing. } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + childComponentNode->name() + "'."); err->setModel(model); - err->setKind(Error::Kind::ENCAPSULATION); - mParser->addError(err); + err->setKind(Issue::Kind::ENCAPSULATION); + mParser->addIssue(err); } if ((parentComponent) && (childComponent)) { @@ -1070,12 +1070,12 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP const std::string textNode = componentRefNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); - err->setKind(Error::Kind::ENCAPSULATION); + err->setKind(Issue::Kind::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_CHILD); - mParser->addError(err); + mParser->addIssue(err); } else { // Continue to next node if this is whitespace (don't try to parse children of whitespace). componentRefNode = componentRefNode->next(); @@ -1084,30 +1084,30 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP } else if (componentRefNode->isComment()) { // Do nothing. } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + componentRefNode->name() + "'."); err->setModel(model); - err->setKind(Error::Kind::ENCAPSULATION); + err->setKind(Issue::Kind::ENCAPSULATION); err->setRule(SpecificationRule::ENCAPSULATION_COMPONENT_REF); - mParser->addError(err); + mParser->addIssue(err); } // Add the parentComponent to the model with its child(ren) encapsulated. if (parentComponent) { model->addComponent(parentComponent); if (parentComponent->componentCount() == 0) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponent->name() + "' as a parent component_ref but it does not have any children."); err->setModel(model); - err->setKind(Error::Kind::ENCAPSULATION); - mParser->addError(err); + err->setKind(Issue::Kind::ENCAPSULATION); + mParser->addIssue(err); } } else if (!parentComponent && haveComponentRef) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' specifies an invalid parent component_ref that also does not have any children."); err->setModel(model); - err->setKind(Error::Kind::ENCAPSULATION); - mParser->addError(err); + err->setKind(Issue::Kind::ENCAPSULATION); + mParser->addIssue(err); } componentRefNode = componentRefNode->next(); @@ -1125,10 +1125,10 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M } else if (attribute->inNamespaceUri(XLINK_NS)) { // Allow xlink attributes but do nothing for them. } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Import from '" + node->attribute("href") + "' has an invalid attribute '" + attribute->name() + "'."); err->setImportSource(importSource); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -1146,10 +1146,10 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M } else if (childAttribute->isType("component_ref")) { importedComponent->setSourceComponent(importSource, childAttribute->value()); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Import of component '" + childNode->attribute("name") + "' from '" + node->attribute("href") + "' has an invalid attribute '" + childAttribute->name() + "'."); err->setImportSource(importSource); - mParser->addError(err); + mParser->addIssue(err); errorOccurred = true; } childAttribute = childAttribute->next(); @@ -1169,10 +1169,10 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M } else if (childAttribute->isType("units_ref")) { importedUnits->setSourceUnits(importSource, childAttribute->value()); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Import of units '" + childNode->attribute("name") + "' from '" + node->attribute("href") + "' has an invalid attribute '" + childAttribute->name() + "'."); err->setImportSource(importSource); - mParser->addError(err); + mParser->addIssue(err); errorOccurred = true; } childAttribute = childAttribute->next(); @@ -1184,20 +1184,20 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M const std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Import from '" + node->attribute("href") + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setImportSource(importSource); err->setRule(SpecificationRule::IMPORT_CHILD); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Import from '" + node->attribute("href") + "' has an invalid child element '" + childNode->name() + "'."); err->setImportSource(importSource); err->setRule(SpecificationRule::IMPORT_CHILD); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); } @@ -1226,11 +1226,11 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese reset->setResetValueId(childAttribute->value()); } } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' has an unexpected attribute in the " + childType + " block of '" + childAttribute->name() + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mParser->addError(err); + mParser->addIssue(err); } childAttribute = childAttribute->next(); } @@ -1250,11 +1250,11 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese std::string textNode = mathNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("The " + childType + " in the reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' should have a MathML block as a child."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mParser->addError(err); + mParser->addIssue(err); } } mathNode = mathNode->next(); @@ -1275,20 +1275,20 @@ void Parser::ParserImpl::checkResetChildMultiplicity(size_t count, const std::st } if (count > 1) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' has " + convertToString(count) + " " + childType + " blocks."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mParser->addError(err); + mParser->addIssue(err); } if (count == 0) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' does not have a " + childType + " block defined."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mParser->addError(err); + mParser->addIssue(err); } } @@ -1308,13 +1308,13 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co const std::string variableReference = attribute->value(); referencedVariable = component->variable(variableReference); - // TODO This follows the same pattern as the errors returned from parsing the encapsulations + // TODO This follows the same pattern as the issues returned from parsing the encapsulations if (referencedVariable == nullptr) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Reset referencing variable '" + variableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_VARIABLE_REFERENCE); - mParser->addError(err); + mParser->addIssue(err); } else { reset->setVariable(referencedVariable); } @@ -1322,12 +1322,12 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co const std::string testVariableReference = attribute->value(); testVariable = component->variable(testVariableReference); if (testVariable == nullptr) { - // TODO This follows the same pattern as the errors returned from parsing the encapsulations - ErrorPtr err = Error::create(); + // TODO This follows the same pattern as the issues returned from parsing the encapsulations + IssuePtr err = Issue::create(); err->setDescription("Reset referencing test_variable '" + testVariableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); - mParser->addError(err); + mParser->addIssue(err); } else { reset->setTestVariable(testVariable); } @@ -1340,19 +1340,19 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co if (reset->variable() != nullptr) { variableName = reset->variable()->name(); } - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' has a non-integer order value '" + attribute->value() + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_ORDER); - mParser->addError(err); + mParser->addIssue(err); } } else if (attribute->isType("id")) { reset->setId(attribute->value()); } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Reset in component '" + component->name() + "' has an invalid attribute '" + attribute->name() + "'."); err->setReset(reset); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -1360,11 +1360,11 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co if (orderValid) { reset->setOrder(order); } else if (!orderDefined) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Reset in component '" + component->name() + "' does not have its order set."); err->setReset(reset); err->setRule(SpecificationRule::RESET_ORDER); - mParser->addError(err); + mParser->addIssue(err); } XmlNodePtr childNode = node->firstChild(); @@ -1382,11 +1382,11 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Reset has an invalid non-whitespace child text element '" + textNode + "'. Either a test_value block or a reset_value block is expected."); err->setReset(reset); err->setRule(SpecificationRule::RESET_CHILD); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. diff --git a/src/validator.cpp b/src/validator.cpp index 3005b2ba5..4b948e316 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -46,8 +46,8 @@ struct Validator::ValidatorImpl * @brief Validate the given name is unique in the model. * * The @p name is checked against known names in @p names. If - * the @p name already exists an error is added to the validator - * with the model passed to the error for further reference. + * the @p name already exists an issue is added to the validator + * with the model passed to the issue for further reference. * * @param model The model the name is used in. * @param name The name of the component to validate. @@ -59,7 +59,7 @@ struct Validator::ValidatorImpl * @brief Validate the @p component using the CellML 2.0 Specification. * * Validate the given @p component and its encapsulated entities using - * the CellML 2.0 Specification. Any errors will be logged in the @c Validator. + * the CellML 2.0 Specification. Any issues will be logged in the @c Validator. * * @param component The component to validate. */ @@ -68,7 +68,7 @@ struct Validator::ValidatorImpl /** * @brief Validate an imported component. * - * Validates the imported @p component. Any errors will be + * Validates the imported @p component. Any issues will be * logged to the @c Validator. * * @sa validateComponent @@ -93,7 +93,7 @@ struct Validator::ValidatorImpl * @brief Validate the @p units using the CellML 2.0 Specification. * * Validate the given @p units and its encapsulated entities using - * the CellML 2.0 Specification. Any errors will be logged in the @c Validator. + * the CellML 2.0 Specification. Any issues will be logged in the @c Validator. * * @param units The units to validate. * @param unitsNames A vector list of the name attributes of the @p units and its siblings. @@ -104,7 +104,7 @@ struct Validator::ValidatorImpl * @brief Validate the variable connections in the @p model using the CellML 2.0 Specification. * * Validate the variable connections in the given @p model using - * the CellML 2.0 Specification. Any errors will be logged in the @c Validator. + * the CellML 2.0 Specification. Any issues will be logged in the @c Validator. * * @param model The model which may contain variable connections to validate. */ @@ -128,7 +128,7 @@ struct Validator::ValidatorImpl * @brief Validate the @c unit at index @c index from @p units using the CellML 2.0 Specification. * * Validate the @c unit at index @c index from @p units using - * the CellML 2.0 Specification. Any errors will be logged in the @c Validator. + * the CellML 2.0 Specification. Any issues will be logged in the @c Validator. * * @param index The index of the @c unit to validate from @p units. * @param units The units to validate. @@ -140,7 +140,7 @@ struct Validator::ValidatorImpl * @brief Validate the @p variable using the CellML 2.0 Specification. * * Validate the given @p variable using the CellML 2.0 Specification. - * Any errors will be logged in the @c Validator. + * Any issues will be logged in the @c Validator. * * @param variable The variable to validate. * @param variableNames A vector list of the name attributes of the @p variable and its siblings. @@ -151,7 +151,7 @@ struct Validator::ValidatorImpl * @brief Validate the @p reset using the CellML 2.0 Specification. * * Examine the @p reset for conformance to the CellML 2.0 specification. Any - * errors will be logged in the @c Validator. + * issues will be logged in the @c Validator. * * @param reset The reset to validate. * @param component The component the reset belongs to. @@ -162,7 +162,7 @@ struct Validator::ValidatorImpl * @brief Validate the math @p input @c std::string. * * Validate the math @p input @c std::string using the CellML 2.0 Specification and - * the W3C MathML DTD. Any errors will be logged in the @c Validator. + * the W3C MathML DTD. Any issues will be logged in the @c Validator. * * @param input The math @c std::string to validate. * @param component The component containing the math @c std::string to be validated. @@ -211,15 +211,15 @@ struct Validator::ValidatorImpl /** * @brief Validate that equivalent variable pairs in the @p model * have equivalent units. - * Any errors will be logged in the @c Validator. + * Any issues will be logged in the @c Validator. * - * Any difference in base units is reported as an error in the @c Validator, but the multiplier difference does not trigger a validator error. + * Any difference in base units is reported as an issue in the @c Validator, but the multiplier difference does not trigger a validator issue. * Where the base units are equivalent, the multiplier may be interpreted as units_of_v1 = (10^multiplier)*units_of_v2 * * @param model The model containing the variables * @param v1 The variable which may contain units. * @param v2 The equivalent variable which may contain units. - * @param hints String containing error messages to be passed back to the calling function for logging. + * @param hints String containing issue messages to be passed back to the calling function for logging. * @param multiplier Double returning the effective multiplier mismatch between the units. */ bool unitsAreEquivalent(const ModelPtr &model, const VariablePtr &v1, const VariablePtr &v2, std::string &hints, double &multiplier); @@ -253,7 +253,7 @@ struct Validator::ValidatorImpl * @param model The model containing the units to be tested. * @param parent The current @c Units pointer to test. * @param history A vector of the chained dependencies. Cyclic variables exist where the first and last units are equal. - * @param errorList An array of loops, returned so that the reported errors are not too repetitive. + * @param errorList An array of loops, returned so that the reported issues are not too repetitive. */ void checkUnitForCycles(const ModelPtr &model, const UnitsPtr &parent, std::vector &history, @@ -278,15 +278,15 @@ ValidatorPtr Validator::create() noexcept void Validator::validateModel(const ModelPtr &model) { - // Clear any pre-existing errors in ths validator instance. + // Clear any pre-existing issues in ths validator instance. removeAllErrors(); // Check for a valid name attribute. if (!mPimpl->isCellmlIdentifier(model->name())) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Model does not have a valid name attribute."); err->setModel(model); err->setRule(SpecificationRule::MODEL_NAME); - addError(err); + addIssue(err); } // Check for components in this model. if (model->componentCount() > 0) { @@ -311,21 +311,21 @@ void Validator::validateModel(const ModelPtr &model) std::string importSource = units->importSource()->url(); bool foundImportError = false; if (!mPimpl->isCellmlIdentifier(unitsRef)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Imported units '" + unitsName + "' does not have a valid units_ref attribute."); err->setUnits(units); err->setRule(SpecificationRule::IMPORT_UNITS_REF); - addError(err); + addIssue(err); foundImportError = true; } // Check for a xlink:href. // TODO: check this id against the XLink spec (see CellML Spec 5.1.1). if (importSource.empty()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Import of units '" + unitsName + "' does not have a valid locator xlink:href attribute."); err->setImportSource(units->importSource()); err->setRule(SpecificationRule::IMPORT_HREF); - addError(err); + addIssue(err); foundImportError = true; } // Check if we already have another import from the same source with the same units_ref. @@ -333,11 +333,11 @@ void Validator::validateModel(const ModelPtr &model) if (!unitsImportSources.empty() && (!foundImportError)) { if ((std::find(unitsImportSources.begin(), unitsImportSources.end(), importSource) - unitsImportSources.begin()) == (std::find(unitsRefs.begin(), unitsRefs.end(), unitsRef) - unitsRefs.begin())) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' contains multiple imported units from '" + importSource + "' with the same units_ref attribute '" + unitsRef + "'."); err->setModel(model); err->setRule(SpecificationRule::IMPORT_UNITS_REF); - addError(err); + addIssue(err); } } // Push back the unique sources and refs. @@ -346,11 +346,11 @@ void Validator::validateModel(const ModelPtr &model) } // Check for duplicate units names in this model. if (std::find(unitsNames.begin(), unitsNames.end(), unitsName) != unitsNames.end()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' contains multiple units with the name '" + unitsName + "'. Valid units names must be unique to their model."); err->setModel(model); err->setRule(SpecificationRule::UNITS_NAME_UNIQUE); - addError(err); + addIssue(err); } unitsNames.push_back(unitsName); } @@ -375,10 +375,10 @@ void Validator::ValidatorImpl::validateUniqueName(const ModelPtr &model, const s { if (!name.empty()) { if (std::find(names.begin(), names.end(), name) != names.end()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' contains multiple components with the name '" + name + "'. Valid component names must be unique to their model."); err->setModel(model); - mValidator->addError(err); + mValidator->addIssue(err); } else { names.push_back(name); } @@ -402,11 +402,11 @@ void Validator::ValidatorImpl::validateComponentTree(const ModelPtr &model, cons void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &component) { if (!isCellmlIdentifier(component->name())) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setComponent(component); err->setDescription("Imported component does not have a valid name attribute."); err->setRule(SpecificationRule::IMPORT_COMPONENT_NAME); - mValidator->addError(err); + mValidator->addIssue(err); } // Check for a component_ref; assumes imported if the import source is not null. @@ -415,26 +415,26 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com std::string componentName = component->name(); if (!isCellmlIdentifier(componentRef)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Imported component '" + componentName + "' does not have a valid component_ref attribute."); err->setComponent(component); err->setRule(SpecificationRule::IMPORT_COMPONENT_REF); - mValidator->addError(err); + mValidator->addIssue(err); } if (importSource.empty()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Import of component '" + componentName + "' does not have a valid locator xlink:href attribute."); err->setImportSource(component->importSource()); err->setRule(SpecificationRule::IMPORT_HREF); - mValidator->addError(err); + mValidator->addIssue(err); } else { xmlURIPtr uri = xmlParseURI(importSource.c_str()); if (uri == nullptr) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Import of component '" + componentName + "' has an invalid URI in the href attribute."); err->setImportSource(component->importSource()); err->setRule(SpecificationRule::IMPORT_HREF); - mValidator->addError(err); + mValidator->addIssue(err); } else { xmlFreeURI(uri); @@ -446,11 +446,11 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) { // Check for a valid name attribute. if (!isCellmlIdentifier(component->name())) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setComponent(component); err->setDescription("Component does not have a valid name attribute."); err->setRule(SpecificationRule::COMPONENT_NAME); - mValidator->addError(err); + mValidator->addIssue(err); } // Check for variables in this component. std::vector variableNames; @@ -461,11 +461,11 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) std::string variableName = component->variable(i)->name(); if (!variableName.empty()) { if (std::find(variableNames.begin(), variableNames.end(), variableName) != variableNames.end()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Component '" + component->name() + "' contains multiple variables with the name '" + variableName + "'. Valid variable names must be unique to their component."); err->setComponent(component); err->setRule(SpecificationRule::VARIABLE_NAME); - mValidator->addError(err); + mValidator->addIssue(err); } variableNames.push_back(variableName); } @@ -492,7 +492,7 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v { // Check for a valid name attribute. if (!isCellmlIdentifier(units->name())) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setUnits(units); if (units->isImport()) { err->setDescription("Imported units does not have a valid name attribute."); @@ -501,15 +501,15 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v err->setDescription("Units does not have a valid name attribute."); err->setRule(SpecificationRule::UNITS_NAME); } - mValidator->addError(err); + mValidator->addIssue(err); } else { // Check for a matching standard units. if (isStandardUnitName(units->name())) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Units is named '" + units->name() + "' which is a protected standard unit name."); err->setUnits(units); err->setRule(SpecificationRule::UNITS_STANDARD); - mValidator->addError(err); + mValidator->addIssue(err); } } if (units->unitCount() > 0) { @@ -531,37 +531,37 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u units->unitAttributes(index, reference, prefix, exponent, multiplier, id); if (isCellmlIdentifier(reference)) { if ((std::find(unitsNames.begin(), unitsNames.end(), reference) == unitsNames.end()) && (!isStandardUnitName(reference))) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Units reference '" + reference + "' in units '" + units->name() + "' is not a valid reference to a local units or a standard unit type."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_UNITS_REF); - mValidator->addError(err); + mValidator->addIssue(err); } } else { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Unit in units '" + units->name() + "' does not have a valid units reference."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_UNITS_REF); - mValidator->addError(err); + mValidator->addIssue(err); } if (!prefix.empty()) { if (!isStandardPrefixName(prefix)) { if (!isCellMLInteger(prefix)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is not a valid integer or an SI prefix."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_PREFIX); - mValidator->addError(err); + mValidator->addIssue(err); } else { try { int test = std::stoi(prefix); (void)test; } catch (std::out_of_range &) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is out of the integer range."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_PREFIX); - mValidator->addError(err); + mValidator->addIssue(err); } } } @@ -572,40 +572,40 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con { // Check for a valid name attribute. if (!isCellmlIdentifier(variable->name())) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable does not have a valid name attribute."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_NAME); - mValidator->addError(err); + mValidator->addIssue(err); } // Check for a valid units attribute. std::string unitsName = variable->units() != nullptr ? variable->units()->name() : ""; if (!isCellmlIdentifier(unitsName)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + variable->name() + "' does not have a valid units attribute."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_UNITS); - mValidator->addError(err); + mValidator->addIssue(err); } else if (!isStandardUnitName(unitsName)) { ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); ModelPtr model = owningModel(component); if ((model != nullptr) && !model->hasUnits(variable->units())) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + variable->name() + "' has a units reference '" + unitsName + "' that does not correspond with a standard units and is not a units defined in the variable's model."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_UNITS); - mValidator->addError(err); + mValidator->addIssue(err); } } // Check for a valid interface attribute. if (!variable->interfaceType().empty()) { std::string interfaceType = variable->interfaceType(); if ((interfaceType != "public") && (interfaceType != "private") && (interfaceType != "none") && (interfaceType != "public_and_private")) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + variable->name() + "' has an invalid interface attribute value '" + interfaceType + "'."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_INTERFACE); - mValidator->addError(err); + mValidator->addIssue(err); } } // Check for a valid initial value attribute. @@ -615,11 +615,11 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con if (!(std::find(variableNames.begin(), variableNames.end(), initialValue) != variableNames.end())) { // Otherwise, check that the initial value can be converted to a double if (!isCellMLReal(initialValue)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + variable->name() + "' has an invalid initial value '" + initialValue + "'. Initial values must be a real number string or a variable reference."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_INITIAL_VALUE); - mValidator->addError(err); + mValidator->addIssue(err); } } } @@ -686,53 +686,53 @@ void Validator::ValidatorImpl::validateReset(const ResetPtr &reset, const Compon } if (noOrder) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription(description + "does not have an order set."); err->setComponent(component); err->setRule(SpecificationRule::RESET_ORDER); - mValidator->addError(err); + mValidator->addIssue(err); } if (noVariable) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription(description + "does not reference a variable."); err->setReset(reset); err->setRule(SpecificationRule::RESET_VARIABLE_REFERENCE); - mValidator->addError(err); + mValidator->addIssue(err); } if (noTestVariable) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription(description + "does not reference a test_variable."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); - mValidator->addError(err); + mValidator->addIssue(err); } if (noTestValue) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription(description + "does not have a test_value specified."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mValidator->addError(err); + mValidator->addIssue(err); } if (noResetValue) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription(description + "does not have a reset_value specified."); err->setReset(reset); err->setRule(SpecificationRule::RESET_RESET_VALUE); - mValidator->addError(err); + mValidator->addIssue(err); } if (varOutsideComponent) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription(description + "refers to a variable '" + reset->variable()->name() + "' in a different component '" + varParentName + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_VARIABLE_REFERENCE); - mValidator->addError(err); + mValidator->addIssue(err); } if (testVarOutsideComponent) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription(description + "refers to a test_variable '" + reset->testVariable()->name() + "' in a different component '" + testVarParentName + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); - mValidator->addError(err); + mValidator->addIssue(err); } } @@ -741,30 +741,30 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp XmlDocPtr doc = std::make_shared(); // Parse as XML first. doc->parse(input); - // Copy any XML parsing errors into the common validator error handler. + // Copy any XML parsing issues into the common validator issue handler. if (doc->xmlErrorCount() > 0) { for (size_t i = 0; i < doc->xmlErrorCount(); ++i) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("LibXml2 error: " + doc->xmlError(i)); - err->setKind(Error::Kind::XML); - mValidator->addError(err); + err->setKind(Issue::Kind::XML); + mValidator->addIssue(err); } } XmlNodePtr node = doc->rootNode(); if (node == nullptr) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Could not get a valid XML root node from the math on component '" + component->name() + "'."); - err->setKind(Error::Kind::XML); + err->setKind(Issue::Kind::XML); err->setComponent(component); - mValidator->addError(err); + mValidator->addIssue(err); return; } if (!node->isMathmlElement("math")) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Math root node is of invalid type '" + node->name() + "' on component '" + component->name() + "'. A valid math root node should be of type 'math'."); err->setComponent(component); - err->setKind(Error::Kind::XML); - mValidator->addError(err); + err->setKind(Issue::Kind::XML); + mValidator->addIssue(err); return; } @@ -794,14 +794,14 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp // Parse/validate the clean math string with the W3C MathML DTD. XmlDocPtr mathmlDoc = std::make_shared(); mathmlDoc->parseMathML(cleanMathml); - // Copy any MathML validation errors into the common validator error handler. + // Copy any MathML validation issues into the common validator issue handler. if (mathmlDoc->xmlErrorCount() > 0) { for (size_t i = 0; i < mathmlDoc->xmlErrorCount(); ++i) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("W3C MathML DTD error: " + mathmlDoc->xmlError(i)); err->setComponent(component); - err->setKind(Error::Kind::MATHML); - mValidator->addError(err); + err->setKind(Issue::Kind::MATHML); + mValidator->addIssue(err); } } } @@ -812,11 +812,11 @@ bool Validator::ValidatorImpl::validateCnUnits(const ComponentPtr &component, co return true; } - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Math cn element with the value '" + textNode + "' does not have a valid cellml:units attribute."); err->setComponent(component); - err->setKind(Error::Kind::MATHML); - mValidator->addError(err); + err->setKind(Issue::Kind::MATHML); + mValidator->addIssue(err); return false; } @@ -846,11 +846,11 @@ void Validator::ValidatorImpl::validateAndCleanCnNode(const XmlNodePtr &node, co cellmlAttributesToRemove.push_back(attribute); } else if (attribute->inNamespaceUri(CELLML_2_0_NS)) { cellmlAttributesToRemove.push_back(attribute); - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Math " + node->name() + " element has an invalid attribute type '" + attribute->name() + "' in the cellml namespace. Attribute 'units' is the only CellML namespace attribute allowed."); err->setComponent(component); - err->setKind(Error::Kind::MATHML); - mValidator->addError(err); + err->setKind(Issue::Kind::MATHML); + mValidator->addIssue(err); } } attribute = attribute->next(); @@ -868,11 +868,11 @@ void Validator::ValidatorImpl::validateAndCleanCnNode(const XmlNodePtr &node, co if (!model->hasUnits(unitsName)) { // Check for a matching standard units. if (!isStandardUnitName(unitsName)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Math has a " + node->name() + " element with a cellml:units attribute '" + unitsName + "' that is not a valid reference to units in the model '" + model->name() + "' or a standard unit."); err->setComponent(component); - err->setKind(Error::Kind::MATHML); - mValidator->addError(err); + err->setKind(Issue::Kind::MATHML); + mValidator->addIssue(err); } } } @@ -894,11 +894,11 @@ void Validator::ValidatorImpl::validateAndCleanCiNode(const XmlNodePtr &node, co if (!textInNode.empty()) { // Check whether we can find this text as a variable name in this component. if (std::find(variableNames.begin(), variableNames.end(), textInNode) == variableNames.end()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("MathML ci element has the child text '" + textInNode + "' which does not correspond with any variable names present in component '" + component->name() + "'."); err->setComponent(component); - err->setKind(Error::Kind::MATHML); - mValidator->addError(err); + err->setKind(Issue::Kind::MATHML); + mValidator->addIssue(err); } } } @@ -927,11 +927,11 @@ void Validator::ValidatorImpl::validateMathMLElements(const XmlNodePtr &node, co XmlNodePtr childNode = node->firstChild(); if (childNode != nullptr) { if (!childNode->isComment() && !childNode->isText() && !isSupportedMathMLElement(childNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Math has a '" + childNode->name() + "' element that is not a supported MathML element."); err->setComponent(component); - err->setKind(Error::Kind::MATHML); - mValidator->addError(err); + err->setKind(Issue::Kind::MATHML); + mValidator->addIssue(err); } validateMathMLElements(childNode, component); } @@ -939,11 +939,11 @@ void Validator::ValidatorImpl::validateMathMLElements(const XmlNodePtr &node, co XmlNodePtr nextNode = node->next(); if (nextNode != nullptr) { if (!nextNode->isComment() && !nextNode->isText() && !isSupportedMathMLElement(nextNode)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Math has a '" + nextNode->name() + "' element that is not a supported MathML element."); err->setComponent(component); - err->setKind(Error::Kind::MATHML); - mValidator->addError(err); + err->setKind(Issue::Kind::MATHML); + mValidator->addIssue(err); } validateMathMLElements(nextNode, component); } @@ -980,22 +980,22 @@ void Validator::ValidatorImpl::validateConnections(const ModelPtr &model) if (!unitsAreEquivalent(model, variable, equivalentVariable, hints, multiplier)) { auto unitsName = variable->units() == nullptr ? "" : variable->units()->name(); auto equivalentUnitsName = equivalentVariable->units() == nullptr ? "" : equivalentVariable->units()->name(); - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); err->setModel(model); - err->setKind(Error::Kind::UNITS); - mValidator->addError(err); + err->setKind(Issue::Kind::UNITS); + mValidator->addIssue(err); } if (equivalentVariable->hasEquivalentVariable(variable)) { // Check that the equivalent variable has a valid parent component. auto component2 = std::dynamic_pointer_cast(equivalentVariable->parent()); if (component2 == nullptr || !component2->hasVariable(equivalentVariable)) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("Variable '" + equivalentVariable->name() + "' is an equivalent variable to '" + variable->name() + "' but '" + equivalentVariable->name() + "' has no parent component."); err->setModel(model); - err->setKind(Error::Kind::CONNECTION); - mValidator->addError(err); + err->setKind(Issue::Kind::CONNECTION); + mValidator->addIssue(err); } } } @@ -1020,26 +1020,26 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) // Does not start with numeric character. if (isdigit(name[0]) != 0) { result = false; - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("CellML identifiers must not begin with a European numeric character [0-9]."); err->setRule(SpecificationRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); - mValidator->addError(err); + mValidator->addIssue(err); } else { // Basic Latin alphanumeric characters and underscores. if (name.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_") != std::string::npos) { result = false; - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("CellML identifiers must not contain any characters other than [a-zA-Z0-9_]."); err->setRule(SpecificationRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); - mValidator->addError(err); + mValidator->addIssue(err); } } } else { result = false; - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); err->setDescription("CellML identifiers must contain one or more basic Latin alphabetic characters."); err->setRule(SpecificationRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); - mValidator->addError(err); + mValidator->addIssue(err); } return result; } @@ -1103,7 +1103,7 @@ bool Validator::ValidatorImpl::unitsAreEquivalent(const ModelPtr &model, } if (multiplier != 0.0) { - // NB: multiplication errors are only reported when there is a base error mismatch too, does not trigger it alone. + // NB: multiplication issues are only reported when there is a base issue mismatch too, does not trigger it alone. // The multiplication mismatch will be returned through the multiplier argument in all cases. std::string num = std::to_string(multiplier); num.erase(num.find_last_not_of('0') + 1, num.length()); @@ -1178,25 +1178,25 @@ void Validator::ValidatorImpl::validateNoUnitsAreCyclic(const ModelPtr &model) if (!errorList.empty()) { std::vector> reportedErrorList; - for (auto &errors : errorList) { + for (auto &issues : errorList) { std::map hash; - for (auto &e : errors) { + for (auto &e : issues) { hash.insert(std::pair(e, true)); } - // Only return as error if this combo has not been reported already. + // Only return as issue if this combo has not been reported already. if (std::find(reportedErrorList.begin(), reportedErrorList.end(), hash) == reportedErrorList.end()) { - ErrorPtr err = Error::create(); + IssuePtr err = Issue::create(); std::string des = "'"; - for (size_t j = 0; j < errors.size() - 1; ++j) { - des += errors[j] + "' -> '"; + for (size_t j = 0; j < issues.size() - 1; ++j) { + des += issues[j] + "' -> '"; } - des += errors[errors.size() - 1] + "'"; + des += issues[issues.size() - 1] + "'"; err->setDescription("Cyclic units exist: " + des); err->setModel(model); - err->setKind(Error::Kind::UNITS); - mValidator->addError(err); + err->setKind(Issue::Kind::UNITS); + mValidator->addIssue(err); reportedErrorList.push_back(hash); } std::map().swap(hash); diff --git a/tests/bindings/python/test_error.py b/tests/bindings/python/test_error.py index 167c8f301..e28080bfb 100644 --- a/tests/bindings/python/test_error.py +++ b/tests/bindings/python/test_error.py @@ -1,5 +1,5 @@ # -# Tests the Error class bindings +# Tests the Issue class bindings # import unittest @@ -8,62 +8,62 @@ class ErrorTestCase(unittest.TestCase): def test_create_destroy(self): from libcellml import Component - from libcellml import Error + from libcellml import Issue from libcellml import ImportSource from libcellml import Model from libcellml import Reset from libcellml import Units from libcellml import Variable - e1 = Error() + e1 = Issue() del(e1) c = Component() - e2 = Error(c) + e2 = Issue(c) del(e2) i = ImportSource() - e3 = Error(i) + e3 = Issue(i) del(e3) m = Model() - e4 = Error(m) + e4 = Issue(m) del(e4) r = Reset() - e5 = Error(r) + e5 = Issue(r) del(e5) u = Units() - e6 = Error(u) + e6 = Issue(u) del(e6) v = Variable() - e7 = Error(v) + e7 = Issue(v) del(e7) def test_kind_enum(self): - from libcellml import Error - - self.assertIsInstance(Error.Kind.COMPONENT, int) - self.assertIsInstance(Error.Kind.CONNECTION, int) - self.assertIsInstance(Error.Kind.ENCAPSULATION, int) - self.assertIsInstance(Error.Kind.IMPORT, int) - self.assertIsInstance(Error.Kind.MATHML, int) - self.assertIsInstance(Error.Kind.MODEL, int) - self.assertIsInstance(Error.Kind.UNDEFINED, int) - self.assertIsInstance(Error.Kind.UNITS, int) - self.assertIsInstance(Error.Kind.VARIABLE, int) - self.assertIsInstance(Error.Kind.XML, int) + from libcellml import Issue + + self.assertIsInstance(Issue.Kind.COMPONENT, int) + self.assertIsInstance(Issue.Kind.CONNECTION, int) + self.assertIsInstance(Issue.Kind.ENCAPSULATION, int) + self.assertIsInstance(Issue.Kind.IMPORT, int) + self.assertIsInstance(Issue.Kind.MATHML, int) + self.assertIsInstance(Issue.Kind.MODEL, int) + self.assertIsInstance(Issue.Kind.UNDEFINED, int) + self.assertIsInstance(Issue.Kind.UNITS, int) + self.assertIsInstance(Issue.Kind.VARIABLE, int) + self.assertIsInstance(Issue.Kind.XML, int) # Test conversion to enum - e = Error() - e.setKind(Error.Kind.COMPONENT) - self.assertRaises(RuntimeError, e.setKind, Error.Kind.COMPONENT - 1) - self.assertRaises(RuntimeError, e.setKind, Error.Kind.XML + 1) + e = Issue() + e.setKind(Issue.Kind.COMPONENT) + self.assertRaises(RuntimeError, e.setKind, Issue.Kind.COMPONENT - 1) + self.assertRaises(RuntimeError, e.setKind, Issue.Kind.XML + 1) def test_specification_rule_enum(self): - from libcellml import Error, SpecificationRule + from libcellml import Issue, SpecificationRule self.assertIsInstance(SpecificationRule.UNDEFINED, int) self.assertIsInstance(SpecificationRule.DATA_REPR_IDENTIFIER_UNICODE, int) @@ -124,7 +124,7 @@ def test_specification_rule_enum(self): self.assertIsInstance(SpecificationRule.MAP_VARIABLES_UNIQUE, int) # Test conversion to enum - e = Error() + e = Issue() e.setRule(SpecificationRule.UNDEFINED) self.assertRaises( RuntimeError, e.setRule, SpecificationRule.UNDEFINED - 1) @@ -134,81 +134,81 @@ def test_specification_rule_enum(self): del(e) def test_set_description(self): - from libcellml import Error + from libcellml import Issue # void setDescription(const std::string &description) - e = Error() + e = Issue() e.setDescription('hello') e.setDescription('') def test_description(self): - from libcellml import Error + from libcellml import Issue # std::string description() d = 'hi' - e = Error() + e = Issue() self.assertEqual(e.description(), '') e.setDescription(d) self.assertEqual(e.description(), d) del(d, e) def test_set_kind(self): - from libcellml import Error + from libcellml import Issue # void setKind(Kind kind) - e = Error() - e.setKind(Error.Kind.CONNECTION) + e = Issue() + e.setKind(Issue.Kind.CONNECTION) def test_kind(self): - from libcellml import Error + from libcellml import Issue # Kind kind() - e = Error() - self.assertEqual(e.kind(), Error.Kind.UNDEFINED) - e.setKind(Error.Kind.MATHML) - self.assertEqual(e.kind(), Error.Kind.MATHML) + e = Issue() + self.assertEqual(e.kind(), Issue.Kind.UNDEFINED) + e.setKind(Issue.Kind.MATHML) + self.assertEqual(e.kind(), Issue.Kind.MATHML) def test_is_kind(self): - from libcellml import Error + from libcellml import Issue # bool isKind(const Kind &kind) - e = Error() - self.assertTrue(e.isKind(Error.Kind.UNDEFINED)) - self.assertFalse(e.isKind(Error.Kind.MODEL)) + e = Issue() + self.assertTrue(e.isKind(Issue.Kind.UNDEFINED)) + self.assertFalse(e.isKind(Issue.Kind.MODEL)) def test_set_rule(self): - from libcellml import Error, SpecificationRule + from libcellml import Issue, SpecificationRule # void setRule(SpecificationRule rule) - e = Error() + e = Issue() e.setRule(SpecificationRule.MAP_VARIABLES_VARIABLE2) def test_rule(self): - from libcellml import Error, SpecificationRule + from libcellml import Issue, SpecificationRule # SpecificationRule rule() - e = Error() + e = Issue() self.assertEqual(e.rule(), SpecificationRule.UNDEFINED) def test_specification_heading(self): - from libcellml import Error + from libcellml import Issue # std::string specificationHeading() - e = Error() + e = Issue() self.assertEqual('', e.specificationHeading()) def test_set_component(self): - from libcellml import Error, Component + from libcellml import Issue, Component # void setComponent(const ComponentPtr &component) - e = Error() + e = Issue() e.setComponent(Component()) def test_component(self): - from libcellml import Error, Component + from libcellml import Issue, Component # ComponentPtr component() - e = Error() + e = Issue() self.assertIsNone(e.component()) name = 'cellml' c = Component() @@ -218,17 +218,17 @@ def test_component(self): self.assertEqual(e.component().name(), name) def test_set_import_source(self): - from libcellml import Error, ImportSource + from libcellml import Issue, ImportSource # void setImportSource(const ImportSourcePtr &import) - e = Error() + e = Issue() e.setImportSource(ImportSource()) def test_import_source(self): - from libcellml import Error, ImportSource + from libcellml import Issue, ImportSource # ImportSourcePtr importSource() - e = Error() + e = Issue() self.assertIsNone(e.component()) name = 'uri' i = ImportSource() @@ -238,17 +238,17 @@ def test_import_source(self): self.assertEqual(e.importSource().id(), name) def test_set_model(self): - from libcellml import Error, Model + from libcellml import Issue, Model # void setModel(const ModelPtr &model) - e = Error() + e = Issue() e.setModel(Model()) def test_model(self): - from libcellml import Error, Model + from libcellml import Issue, Model # ModelPtr model() - e = Error() + e = Issue() self.assertIsNone(e.model()) name = 'moodle' m = Model() @@ -258,17 +258,17 @@ def test_model(self): self.assertEqual(e.model().name(), name) def test_set_units(self): - from libcellml import Error, Units + from libcellml import Issue, Units # void setUnits(const UnitsPtr &units) - e = Error() + e = Issue() e.setUnits(Units()) def test_units(self): - from libcellml import Error, Units + from libcellml import Issue, Units # UnitsPtr units() - e = Error() + e = Issue() self.assertIsNone(e.units()) name = 'furlong' u = Units() @@ -278,17 +278,17 @@ def test_units(self): self.assertEqual(e.units().name(), name) def test_set_variable(self): - from libcellml import Error, Variable + from libcellml import Issue, Variable # void setVariable(const VariablePtr &variable) - e = Error() + e = Issue() e.setVariable(Variable()) def test_variable(self): - from libcellml import Error, Variable + from libcellml import Issue, Variable # VariablePtr variable() - e = Error() + e = Issue() self.assertIsNone(e.variable()) name = 'var' v = Variable() @@ -298,17 +298,17 @@ def test_variable(self): self.assertEqual(e.variable().name(), name) def test_set_reset(self): - from libcellml import Error, Reset + from libcellml import Issue, Reset # void setReset(const ResetPtr &reset); - e = Error() + e = Issue() e.setReset(Reset()) def test_reset(self): - from libcellml import Error, Reset + from libcellml import Issue, Reset # ResetPtr reset() const; - e = Error() + e = Issue() self.assertIsNone(e.reset()) name = 'res' r = Reset() diff --git a/tests/bindings/python/test_generator.py b/tests/bindings/python/test_generator.py index fc5c99933..c967556a7 100644 --- a/tests/bindings/python/test_generator.py +++ b/tests/bindings/python/test_generator.py @@ -30,11 +30,11 @@ def test_inheritance(self): self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods - self.assertIsNone(x.error(0)) - self.assertIsNone(x.error(-1)) - self.assertEqual(x.errorCount(), 0) - x.addError(libcellml.Error()) - self.assertEqual(x.errorCount(), 1) + self.assertIsNone(x.issue(0)) + self.assertIsNone(x.issue(-1)) + self.assertEqual(x.issueCount(), 0) + x.addIssue(libcellml.Issue()) + self.assertEqual(x.issueCount(), 1) def test_process_model(self): from libcellml import Generator @@ -45,7 +45,7 @@ def test_process_model(self): g.processModel(m) - self.assertEqual(0, g.errorCount()) + self.assertEqual(0, g.issueCount()) self.assertEqual(Generator.ModelType.UNKNOWN, g.modelType()) def test_algebraic_eqn_computed_var_on_rhs(self): diff --git a/tests/bindings/python/test_parser.py b/tests/bindings/python/test_parser.py index d2cf10b32..8b521b70e 100644 --- a/tests/bindings/python/test_parser.py +++ b/tests/bindings/python/test_parser.py @@ -20,11 +20,11 @@ def test_inheritance(self): self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods - self.assertIsNone(x.error(0)) - self.assertIsNone(x.error(-1)) - self.assertEqual(x.errorCount(), 0) - x.addError(libcellml.Error()) - self.assertEqual(x.errorCount(), 1) + self.assertIsNone(x.issue(0)) + self.assertIsNone(x.issue(-1)) + self.assertEqual(x.issueCount(), 0) + x.addIssue(libcellml.Issue()) + self.assertEqual(x.issueCount(), 1) def test_parse_model(self): import libcellml diff --git a/tests/bindings/python/test_printer.py b/tests/bindings/python/test_printer.py index b7d121bc3..e17443d28 100644 --- a/tests/bindings/python/test_printer.py +++ b/tests/bindings/python/test_printer.py @@ -20,11 +20,11 @@ def test_inheritance(self): self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods - self.assertIsNone(x.error(0)) - self.assertIsNone(x.error(-1)) - self.assertEqual(x.errorCount(), 0) - x.addError(libcellml.Error()) - self.assertEqual(x.errorCount(), 1) + self.assertIsNone(x.issue(0)) + self.assertIsNone(x.issue(-1)) + self.assertEqual(x.issueCount(), 0) + x.addIssue(libcellml.Issue()) + self.assertEqual(x.issueCount(), 1) def test_print_model(self): from libcellml import Printer, Model diff --git a/tests/bindings/python/test_validator.py b/tests/bindings/python/test_validator.py index a58a23cbf..b808c1fee 100644 --- a/tests/bindings/python/test_validator.py +++ b/tests/bindings/python/test_validator.py @@ -21,11 +21,11 @@ def test_inheritance(self): self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods - self.assertIsNone(x.error(0)) - self.assertIsNone(x.error(-1)) - self.assertEqual(x.errorCount(), 0) - x.addError(libcellml.Error()) - self.assertEqual(x.errorCount(), 1) + self.assertIsNone(x.issue(0)) + self.assertIsNone(x.issue(-1)) + self.assertEqual(x.issueCount(), 0) + x.addIssue(libcellml.Issue()) + self.assertEqual(x.issueCount(), 1) def test_validate_model(self): import libcellml diff --git a/tests/clone/clone.cpp b/tests/clone/clone.cpp index ce57a6c55..70c11a5bf 100644 --- a/tests/clone/clone.cpp +++ b/tests/clone/clone.cpp @@ -585,7 +585,7 @@ TEST(Clone, generateFromClonedModel) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); diff --git a/tests/component/encapsulation.cpp b/tests/component/encapsulation.cpp index 370d9fb6c..607ee3b9e 100644 --- a/tests/component/encapsulation.cpp +++ b/tests/component/encapsulation.cpp @@ -318,7 +318,7 @@ TEST(Encapsulation, parseAlternateFormHierarchy) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); EXPECT_EQ(size_t(1), model->componentCount()); auto component = model->component(0); for (size_t i = 0; i < 3; ++i) { diff --git a/tests/connection/connection.cpp b/tests/connection/connection.cpp index 0be275a3e..0715c3156 100644 --- a/tests/connection/connection.cpp +++ b/tests/connection/connection.cpp @@ -215,7 +215,7 @@ TEST(Connection, parseValidAlternateFormConnection) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); EXPECT_EQ(size_t(2), model->componentCount()); EXPECT_EQ(size_t(1), model->component("component1")->variable("variable1")->equivalentVariableCount()); } @@ -1089,7 +1089,7 @@ TEST(Connection, importedComponentConnectionAndParse) // Parse libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); a = printer->printModel(model); EXPECT_EQ(e, a); @@ -1126,11 +1126,11 @@ TEST(Connection, componentConnectionAndParseMissingVariable) // Parse libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(s); - EXPECT_EQ(size_t(1), parser->errorCount()); + EXPECT_EQ(size_t(1), parser->issueCount()); - EXPECT_EQ(expectError, parser->error(0)->description()); + EXPECT_EQ(expectError, parser->issue(0)->description()); parser->removeAllErrors(); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::PrinterPtr printer = libcellml::Printer::create(); const std::string a = printer->printModel(model); diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index ff3a3f995..12211ed8c 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -40,7 +40,7 @@ TEST(Coverage, connectionComment) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(in); - EXPECT_EQ(size_t(4), p->errorCount()); + EXPECT_EQ(size_t(4), p->issueCount()); } TEST(Coverage, importWithNonHrefXlink) @@ -63,7 +63,7 @@ TEST(Coverage, importWithNonHrefXlink) // Parse libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Coverage, entityHasParent) diff --git a/tests/error/error.cpp b/tests/error/error.cpp index 1e7e7c150..ae8e2b809 100644 --- a/tests/error/error.cpp +++ b/tests/error/error.cpp @@ -18,55 +18,55 @@ limitations under the License-> #include -TEST(Error, createModelError) +TEST(Issue, createModelError) { libcellml::ModelPtr m = libcellml::Model::create(); - libcellml::ErrorPtr e = libcellml::Error::create(m); + libcellml::IssuePtr e = libcellml::Issue::create(m); - EXPECT_EQ(libcellml::Error::Kind::MODEL, e->kind()); + EXPECT_EQ(libcellml::Issue::Kind::MODEL, e->kind()); } -TEST(Error, createComponemntError) +TEST(Issue, createComponemntError) { libcellml::ComponentPtr c = libcellml::Component::create(); - libcellml::ErrorPtr e = libcellml::Error::create(c); + libcellml::IssuePtr e = libcellml::Issue::create(c); - EXPECT_EQ(libcellml::Error::Kind::COMPONENT, e->kind()); + EXPECT_EQ(libcellml::Issue::Kind::COMPONENT, e->kind()); } -TEST(Error, createVariableError) +TEST(Issue, createVariableError) { libcellml::VariablePtr v = libcellml::Variable::create(); - libcellml::ErrorPtr e = libcellml::Error::create(v); + libcellml::IssuePtr e = libcellml::Issue::create(v); - EXPECT_EQ(libcellml::Error::Kind::VARIABLE, e->kind()); + EXPECT_EQ(libcellml::Issue::Kind::VARIABLE, e->kind()); } -TEST(Error, createUnitsError) +TEST(Issue, createUnitsError) { libcellml::UnitsPtr u = libcellml::Units::create(); - libcellml::ErrorPtr e = libcellml::Error::create(u); + libcellml::IssuePtr e = libcellml::Issue::create(u); - EXPECT_EQ(libcellml::Error::Kind::UNITS, e->kind()); + EXPECT_EQ(libcellml::Issue::Kind::UNITS, e->kind()); } -TEST(Error, createImportSourceError) +TEST(Issue, createImportSourceError) { libcellml::ImportSourcePtr i = libcellml::ImportSource::create(); - libcellml::ErrorPtr e = libcellml::Error::create(i); + libcellml::IssuePtr e = libcellml::Issue::create(i); - EXPECT_EQ(libcellml::Error::Kind::IMPORT, e->kind()); + EXPECT_EQ(libcellml::Issue::Kind::IMPORT, e->kind()); } -TEST(Error, createResetError) +TEST(Issue, createResetError) { libcellml::ResetPtr r = libcellml::Reset::create(); - libcellml::ErrorPtr e = libcellml::Error::create(r); + libcellml::IssuePtr e = libcellml::Issue::create(r); - EXPECT_EQ(libcellml::Error::Kind::RESET, e->kind()); + EXPECT_EQ(libcellml::Issue::Kind::RESET, e->kind()); } -void testSpecificationRule(const libcellml::ErrorPtr &e) +void testSpecificationRule(const libcellml::IssuePtr &e) { switch (e->rule()) { case libcellml::SpecificationRule::COMPONENT_CHILD: @@ -243,10 +243,10 @@ void testSpecificationRule(const libcellml::ErrorPtr &e) } } -TEST(Error, specificationRule) +TEST(Issue, specificationRule) { size_t count = 0; - libcellml::ErrorPtr e = libcellml::Error::create(); + libcellml::IssuePtr e = libcellml::Issue::create(); e->setRule(libcellml::SpecificationRule::UNDEFINED); ++count; testSpecificationRule(e); diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index 206731c39..a58838b1c 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -29,7 +29,7 @@ TEST(Generator, emptyModel) generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::UNKNOWN, generator->modelType()); @@ -52,13 +52,13 @@ TEST(Generator, generatorErrors) generator->processModel(invalidModel); - EXPECT_EQ(size_t(1), generator->errorCount()); + EXPECT_EQ(size_t(1), generator->issueCount()); libcellml::ModelPtr emptyModel = libcellml::Model::create(); generator->processModel(emptyModel); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); } TEST(Generator, initializedVariableOfIntegration) @@ -66,13 +66,13 @@ TEST(Generator, initializedVariableOfIntegration) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/initialized_variable_of_integration.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedErrors = { "Variable 'time' in component 'my_component' of model 'initialized_variable_of_integration' cannot be both a variable of integration and initialised.", }; - const std::vector expectedKinds = { - libcellml::Error::Kind::GENERATOR, + const std::vector expectedKinds = { + libcellml::Issue::Kind::GENERATOR, }; libcellml::GeneratorPtr generator = libcellml::Generator::create(); @@ -99,13 +99,13 @@ TEST(Generator, twoVariablesOfIntegration) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/two_variables_of_integration.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedErrors = { "Variable 'time' in component 'main' of model 'two_variables_of_integration' and variable 'other_time' in component 'sub_sub_sub' of model 'two_variables_of_integration' cannot both be a variable of integration.", }; - const std::vector expectedKinds = { - libcellml::Error::Kind::GENERATOR, + const std::vector expectedKinds = { + libcellml::Issue::Kind::GENERATOR, }; libcellml::GeneratorPtr generator = libcellml::Generator::create(); @@ -132,17 +132,17 @@ TEST(Generator, nonFirstOrderOdes) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/non_first_order_odes.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedErrors = { "The differential equation for variable 'x' in component 'main' of model 'non_first_order_odes' must be of the first order.", "The differential equation for variable 'y' in component 'sub' of model 'non_first_order_odes' must be of the first order.", "The differential equation for variable 'z' in component 'sub_sub' of model 'non_first_order_odes' must be of the first order.", }; - const std::vector expectedKinds = { - libcellml::Error::Kind::GENERATOR, - libcellml::Error::Kind::GENERATOR, - libcellml::Error::Kind::GENERATOR, + const std::vector expectedKinds = { + libcellml::Issue::Kind::GENERATOR, + libcellml::Issue::Kind::GENERATOR, + libcellml::Issue::Kind::GENERATOR, }; libcellml::GeneratorPtr generator = libcellml::Generator::create(); @@ -169,7 +169,7 @@ TEST(Generator, undefinedVariables) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/undefined_variables.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedErrors = { "Variable 'a' in component 'my_component' of model 'undefined_variables' is referenced in an equation, but it is not defined anywhere.", @@ -200,7 +200,7 @@ TEST(Generator, variableInitializedTwice) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/variable_initialized_twice.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedErrors = { "Variable 'x' in component 'sub' of model 'variable_initialized_twice' and variable 'x' in component 'main' of model 'variable_initialized_twice' are equivalent and cannot therefore both be initialised.", @@ -230,7 +230,7 @@ TEST(Generator, nonInitializedState) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/non_initialized_state.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedErrors = { "Variable 'x' in component 'my_component' of model 'non_initialized_state' is used in an ODE, but it is not initialised.", @@ -260,7 +260,7 @@ TEST(Generator, underconstrained) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/underconstrained.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedErrors = { "Variable 'x' in component 'my_component' of model 'my_model' is not computed.", @@ -290,7 +290,7 @@ TEST(Generator, overconstrained) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/overconstrained.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedErrors = { "Variable 'x' in component 'my_component' of model 'my_model' is computed more than once.", @@ -320,7 +320,7 @@ TEST(Generator, unsuitablyConstrained) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/unsuitably_constrained.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); const std::vector expectedErrors = { "Variable 'x' in component 'my_component' of model 'my_model' is not computed.", @@ -351,13 +351,13 @@ TEST(Generator, algebraicEqnComputedVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_computed_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ALGEBRAIC, generator->modelType()); @@ -385,13 +385,13 @@ TEST(Generator, algebraicEqnConstVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_const_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ALGEBRAIC, generator->modelType()); @@ -419,13 +419,13 @@ TEST(Generator, algebraicEqnConstantOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_constant_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ALGEBRAIC, generator->modelType()); @@ -453,13 +453,13 @@ TEST(Generator, algebraicEqnDerivativeOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_derivative_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -488,13 +488,13 @@ TEST(Generator, algebraicEqnDerivativeOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_derivative_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -523,13 +523,13 @@ TEST(Generator, algebraicEqnStateVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_state_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -558,13 +558,13 @@ TEST(Generator, algebraicEqnStateVarOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_state_var_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -593,13 +593,13 @@ TEST(Generator, odeComputedVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_computed_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -628,13 +628,13 @@ TEST(Generator, odeComputedVarOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_computed_var_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -663,13 +663,13 @@ TEST(Generator, odeConstVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_const_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -698,13 +698,13 @@ TEST(Generator, odeConstVarOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_const_var_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -733,13 +733,13 @@ TEST(Generator, odeConstantOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_constant_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -767,13 +767,13 @@ TEST(Generator, odeConstantOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_constant_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -801,13 +801,13 @@ TEST(Generator, odeMultipleDependentOdes) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_multiple_dependent_odes/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -836,13 +836,13 @@ TEST(Generator, odeMultipleDependentOdesOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_multiple_dependent_odes_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -871,13 +871,13 @@ TEST(Generator, odeMultipleOdesWithSameName) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_multiple_odes_with_same_name/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -906,13 +906,13 @@ TEST(Generator, cellmlMappingsAndEncapsulations) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/cellml_mappings_and_encapsulations/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -941,13 +941,13 @@ TEST(Generator, dependentEqns) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/dependent_eqns/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -976,13 +976,13 @@ TEST(Generator, fabbriFantiniWildersSeveriHumanSanModel2017) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -1011,13 +1011,13 @@ TEST(Generator, garnyKohlHunterBoyettNobleRabbitSanModel2003) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -1046,13 +1046,13 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -1106,13 +1106,13 @@ TEST(Generator, nobleModel1962) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/noble_model_1962/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -1141,13 +1141,13 @@ TEST(Generator, coverage) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/coverage/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); diff --git a/tests/isolated/generator.cpp b/tests/isolated/generator.cpp index b124fa6a7..f36dad72b 100644 --- a/tests/isolated/generator.cpp +++ b/tests/isolated/generator.cpp @@ -195,10 +195,10 @@ TEST(Generator, isolatedFirstOrderModel) // units added to the model. model->linkUnits(); - // 4.c Validate the final arrangement. No errors are expected at this stage. + // 4.c Validate the final arrangement. No issues are expected at this stage. libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); // 5.a Create a Generator instance. By default the options set in the // generator constructor are: @@ -208,6 +208,6 @@ TEST(Generator, isolatedFirstOrderModel) libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - // 5.b Check whether the generator has encountered any errors. - EXPECT_EQ(size_t(0), generator->errorCount()); + // 5.b Check whether the generator has encountered any issues. + EXPECT_EQ(size_t(0), generator->issueCount()); } diff --git a/tests/parser/file_parser.cpp b/tests/parser/file_parser.cpp index 8db1c8683..fd1163719 100644 --- a/tests/parser/file_parser.cpp +++ b/tests/parser/file_parser.cpp @@ -30,7 +30,7 @@ TEST(Parser, parseSineModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(fileContents("sine_approximations.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); } TEST(Parser, parseSineImportsModelFromFile) @@ -38,7 +38,7 @@ TEST(Parser, parseSineImportsModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(fileContents("sine_approximations_import.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); } TEST(Parser, parseInvalidModelFromFile) @@ -59,7 +59,7 @@ TEST(Parser, parseOrdModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("Ohara_Rudy_2011.cellml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); // Test some random values. std::string a = model->component("intracellular_ions")->variable("BSLmax")->initialValue(); @@ -81,7 +81,7 @@ TEST(Parser, parseComplexEncapsulationModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(fileContents("complex_encapsulation.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); } TEST(Parser, parseModelWithComponentsWithMultipleMathElements) @@ -121,7 +121,7 @@ TEST(Parser, parseModelWithComponentsWithMultipleMathElements) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("a_plus_b.cellml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); std::string a = model->component("c1")->math(); EXPECT_EQ(e1, a); @@ -150,7 +150,7 @@ TEST(Parser, simpleGeneratorModel) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("generator/initialized_variable_of_integration.cellml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); std::string a = model->component("my_component")->math(); EXPECT_EQ(e, a); diff --git a/tests/parser/libxml_user.cpp b/tests/parser/libxml_user.cpp index 83b13ee35..e5b733058 100644 --- a/tests/parser/libxml_user.cpp +++ b/tests/parser/libxml_user.cpp @@ -54,7 +54,7 @@ TEST(Parser, parseInvalidXmlDirectlyUsingLibxml) // parse the string using libcellml libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(e); - EXPECT_NE(size_t(0), parser->errorCount()); + EXPECT_NE(size_t(0), parser->issueCount()); // and now parse directly using libxml2 xmlParserCtxtPtr context = xmlNewParserCtxt(); diff --git a/tests/parser/parser.cpp b/tests/parser/parser.cpp index a31d34ae5..b0996e1f3 100644 --- a/tests/parser/parser.cpp +++ b/tests/parser/parser.cpp @@ -48,13 +48,13 @@ TEST(Parser, invalidXMLElements) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(input); - EXPECT_EQ(expectedErrors.size() - 1, p->errorCount()); - for (size_t i = 0; i < p->errorCount(); ++i) { + EXPECT_EQ(expectedErrors.size() - 1, p->issueCount()); + for (size_t i = 0; i < p->issueCount(); ++i) { if (i == 0) { - EXPECT_TRUE((p->error(i)->description() != expectedErrors.at(0)) - || (p->error(i)->description() != expectedErrors.at(1))); + EXPECT_TRUE((p->issue(i)->description() != expectedErrors.at(0)) + || (p->issue(i)->description() != expectedErrors.at(1))); } else { - EXPECT_EQ(expectedErrors.at(i + 1), p->error(i)->description()); + EXPECT_EQ(expectedErrors.at(i + 1), p->issue(i)->description()); } } } @@ -92,7 +92,7 @@ TEST(Parser, makeError) { const std::string ex; - libcellml::ErrorPtr e = libcellml::Error::create(); + libcellml::IssuePtr e = libcellml::Issue::create(); EXPECT_EQ(ex, e->description()); } @@ -238,10 +238,10 @@ TEST(Parser, parseModelWithInvalidAttributeAndGetError) EXPECT_EQ_ERRORS(expectedErrors, parser); // Get ModelError and check. - EXPECT_EQ(model, parser->error(0)->model()); + EXPECT_EQ(model, parser->issue(0)->model()); // Get const modelError and check. - const libcellml::ErrorPtr err = parser->error(0); - libcellml::Error *rawErr = err.get(); + const libcellml::IssuePtr err = parser->issue(0); + libcellml::Issue *rawErr = err.get(); const libcellml::ModelPtr modelFromError = rawErr->model(); EXPECT_EQ(model, modelFromError); } @@ -355,11 +355,11 @@ TEST(Parser, parseModelWithNamedComponentWithInvalidBaseUnitsAttributeAndGetErro libcellml::UnitsPtr unitsExpected = model->units("unit_name"); - // Get units from error and check. - EXPECT_EQ(unitsExpected, parser->error(0)->units()); + // Get units from issue and check. + EXPECT_EQ(unitsExpected, parser->issue(0)->units()); - // Get const units from error and check. - const libcellml::ErrorPtr err = parser->error(0); + // Get const units from issue and check. + const libcellml::IssuePtr err = parser->issue(0); const libcellml::UnitsPtr unitsFromError = err->units(); EXPECT_EQ(unitsExpected, unitsFromError); } @@ -382,16 +382,16 @@ TEST(Parser, parseModelWithInvalidComponentAttributeAndGetError) EXPECT_EQ_ERRORS(expectedErrors, parser); - // Get component from error and check. - EXPECT_EQ(component, parser->error(0)->component()); - // Get const component from error and check. - const libcellml::ErrorPtr err = parser->error(0); - libcellml::Error *rawErr = err.get(); + // Get component from issue and check. + EXPECT_EQ(component, parser->issue(0)->component()); + // Get const component from issue and check. + const libcellml::IssuePtr err = parser->issue(0); + libcellml::Issue *rawErr = err.get(); const libcellml::ComponentPtr componentFromError = rawErr->component(); EXPECT_EQ(component, componentFromError); - // Get non-existent error - EXPECT_EQ(nullptr, parser->error(1)); + // Get non-existent issue + EXPECT_EQ(nullptr, parser->issue(1)); } TEST(Parser, componentAttributeErrors) @@ -455,13 +455,13 @@ TEST(Parser, componentElementErrors) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(input1); - EXPECT_EQ(size_t(1), p->errorCount()); - EXPECT_EQ(expectError1, p->error(0)->description()); + EXPECT_EQ(size_t(1), p->issueCount()); + EXPECT_EQ(expectError1, p->issue(0)->description()); p->removeAllErrors(); p->parseModel(input2); - EXPECT_EQ(size_t(1), p->errorCount()); - EXPECT_EQ(expectError2, p->error(0)->description()); + EXPECT_EQ(size_t(1), p->issueCount()); + EXPECT_EQ(expectError2, p->issue(0)->description()); } TEST(Parser, parseModelWithTwoComponents) @@ -655,7 +655,7 @@ TEST(Parser, validEncapsulation) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); } TEST(Parser, encapsulationWithCycleDefined) @@ -685,7 +685,7 @@ TEST(Parser, encapsulationWithCycleDefined) libcellml::ParserPtr p = libcellml::Parser::create(); auto m = p->parseModel(ex); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); libcellml::PrinterPtr printer = libcellml::Printer::create(); auto output = printer->printModel(m); @@ -914,17 +914,17 @@ TEST(Parser, invalidVariableAttributesAndGetVariableError) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(in); - EXPECT_EQ(expectedErrors.size(), p->errorCount()); - for (size_t i = 0; i < p->errorCount(); ++i) { - EXPECT_EQ(expectedErrors.at(i), p->error(i)->description()); + EXPECT_EQ(expectedErrors.size(), p->issueCount()); + for (size_t i = 0; i < p->issueCount(); ++i) { + EXPECT_EQ(expectedErrors.at(i), p->issue(i)->description()); } libcellml::VariablePtr variableExpected = model->component("componentA")->variable("quixote"); - // Get variable from error and check. - EXPECT_EQ(variableExpected, p->error(0)->variable()); - // Get const variable from error and check. - libcellml::ErrorPtr err = p->error(0); - libcellml::Error *rawErr = err.get(); + // Get variable from issue and check. + EXPECT_EQ(variableExpected, p->issue(0)->variable()); + // Get const variable from issue and check. + libcellml::IssuePtr err = p->issue(0); + libcellml::Issue *rawErr = err.get(); const libcellml::VariablePtr variableFromError = rawErr->variable(); EXPECT_EQ(variableExpected, variableFromError); } @@ -953,14 +953,14 @@ TEST(Parser, variableAttributeAndChildErrors) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(input1); - EXPECT_EQ(size_t(1), p->errorCount()); - EXPECT_EQ(expectError1, p->error(0)->description()); + EXPECT_EQ(size_t(1), p->issueCount()); + EXPECT_EQ(expectError1, p->issue(0)->description()); p->removeAllErrors(); p->parseModel(input2); - EXPECT_EQ(size_t(2), p->errorCount()); - EXPECT_EQ(expectError2, p->error(0)->description()); - EXPECT_EQ(expectError3, p->error(1)->description()); + EXPECT_EQ(size_t(2), p->issueCount()); + EXPECT_EQ(expectError2, p->issue(0)->description()); + EXPECT_EQ(expectError3, p->issue(1)->description()); } TEST(Parser, emptyConnections) @@ -1121,7 +1121,7 @@ TEST(Parser, importedComponent2Connection) // Parse libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, validConnectionMapVariablesFirst) @@ -1142,7 +1142,7 @@ TEST(Parser, validConnectionMapVariablesFirst) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, component2ConnectionVariableMissing) @@ -1317,32 +1317,32 @@ TEST(Parser, invalidImportsAndGetError) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr m = p->parseModel(input); - EXPECT_EQ(size_t(4), p->errorCount()); - EXPECT_EQ(expectError1, p->error(0)->description()); - EXPECT_EQ(expectError2, p->error(1)->description()); - EXPECT_EQ(expectError3, p->error(2)->description()); - EXPECT_EQ(expectError4, p->error(3)->description()); + EXPECT_EQ(size_t(4), p->issueCount()); + EXPECT_EQ(expectError1, p->issue(0)->description()); + EXPECT_EQ(expectError2, p->issue(1)->description()); + EXPECT_EQ(expectError3, p->issue(2)->description()); + EXPECT_EQ(expectError4, p->issue(3)->description()); libcellml::PrinterPtr printer = libcellml::Printer::create(); const std::string a = printer->printModel(m); EXPECT_EQ(output, a); libcellml::ImportSourcePtr import = m->units("units_in_this_model")->importSource(); - // Get import from error and check. - EXPECT_EQ(import, p->error(0)->importSource()); - // Get const import from error and check. - const libcellml::ErrorPtr err = p->error(0); - libcellml::Error *rawErr = err.get(); + // Get import from issue and check. + EXPECT_EQ(import, p->issue(0)->importSource()); + // Get const import from issue and check. + const libcellml::IssuePtr err = p->issue(0); + libcellml::Issue *rawErr = err.get(); const libcellml::ImportSourcePtr importFromError = rawErr->importSource(); EXPECT_EQ(import, importFromError); } TEST(Parser, invalidModelWithAllKindsOfErrors) { - // Check for all kinds of errors. + // Check for all kinds of issues. std::vector foundKind(9, false); - // Trigger CellML entity errors + // Trigger CellML entity issues const std::string input = "\n" "\n" @@ -1369,40 +1369,40 @@ TEST(Parser, invalidModelWithAllKindsOfErrors) "Connection in model 'starwars' must contain one or more 'map_variables' elements.", }; - // Parse and check for CellML errors. + // Parse and check for CellML issues. libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); EXPECT_EQ_ERRORS(expectedErrors, parser); - for (size_t i = 0; i < parser->errorCount(); ++i) { - switch (parser->error(i)->kind()) { - case libcellml::Error::Kind::COMPONENT: + for (size_t i = 0; i < parser->issueCount(); ++i) { + switch (parser->issue(i)->kind()) { + case libcellml::Issue::Kind::COMPONENT: foundKind.at(0) = true; break; - case (libcellml::Error::Kind::CONNECTION): + case (libcellml::Issue::Kind::CONNECTION): foundKind.at(1) = true; break; - case (libcellml::Error::Kind::ENCAPSULATION): + case (libcellml::Issue::Kind::ENCAPSULATION): foundKind.at(2) = true; break; - case (libcellml::Error::Kind::IMPORT): + case (libcellml::Issue::Kind::IMPORT): foundKind.at(3) = true; break; - case (libcellml::Error::Kind::MODEL): + case (libcellml::Issue::Kind::MODEL): foundKind.at(4) = true; break; - case (libcellml::Error::Kind::UNITS): + case (libcellml::Issue::Kind::UNITS): foundKind.at(5) = true; break; - case (libcellml::Error::Kind::VARIABLE): + case (libcellml::Issue::Kind::VARIABLE): foundKind.at(6) = true; break; - case libcellml::Error::Kind::MATHML: - case libcellml::Error::Kind::RESET: - case libcellml::Error::Kind::UNDEFINED: - case libcellml::Error::Kind::XML: - case libcellml::Error::Kind::GENERATOR: + case libcellml::Issue::Kind::MATHML: + case libcellml::Issue::Kind::RESET: + case libcellml::Issue::Kind::UNDEFINED: + case libcellml::Issue::Kind::XML: + case libcellml::Issue::Kind::GENERATOR: break; } } @@ -1410,10 +1410,10 @@ TEST(Parser, invalidModelWithAllKindsOfErrors) // Trigger undefined error libcellml::ParserPtr parser2 = libcellml::Parser::create(); // Add an undefined error - libcellml::ErrorPtr undefinedError = libcellml::Error::create(); - parser2->addError(undefinedError); - EXPECT_EQ(size_t(1), parser2->errorCount()); - if (parser2->error(0)->isKind(libcellml::Error::Kind::UNDEFINED)) { + libcellml::IssuePtr undefinedError = libcellml::Issue::create(); + parser2->addIssue(undefinedError); + EXPECT_EQ(size_t(1), parser2->issueCount()); + if (parser2->issue(0)->isKind(libcellml::Issue::Kind::UNDEFINED)) { foundKind.at(7) = true; } @@ -1426,13 +1426,13 @@ TEST(Parser, invalidModelWithAllKindsOfErrors) libcellml::ParserPtr parser3 = libcellml::Parser::create(); parser3->parseModel(input3); EXPECT_EQ_ERRORS(expectedErrors3, parser3); - for (size_t i = 0; i < parser3->errorCount(); ++i) { - if (parser3->error(i)->isKind(libcellml::Error::Kind::XML)) { + for (size_t i = 0; i < parser3->issueCount(); ++i) { + if (parser3->issue(i)->isKind(libcellml::Issue::Kind::XML)) { foundKind.at(8) = true; } } - // Check that we've found all the possible error types + // Check that we've found all the possible issue types bool foundAllKinds = false; if (std::all_of(foundKind.begin(), foundKind.end(), [](bool i) { return i; })) { foundAllKinds = true; @@ -1495,7 +1495,7 @@ TEST(Parser, invalidModelWithTextInAllElements) "Connection in model 'starwars' specifies '' as variable_2 but the corresponding component_2 is invalid.", }; - // Parse and check for CellML errors. + // Parse and check for CellML issues. libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); @@ -1523,7 +1523,7 @@ TEST(Parser, parseIds) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(input); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_EQ("mid", model->id()); EXPECT_EQ("c1id", model->component("component1")->id()); EXPECT_EQ("i1id", model->component("component1")->importSource()->id()); @@ -1591,7 +1591,7 @@ TEST(Parser, parseIdsOnEverythingButMath) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); EXPECT_EQ("mid", model->id()); EXPECT_EQ("c1id", model->component("component1")->id()); EXPECT_EQ("i1id", model->component("component1")->importSource()->id()); @@ -1755,7 +1755,7 @@ TEST(Parser, parseResetsWithErrors) EXPECT_EQ_ERRORS(expectedErrors, p); - EXPECT_EQ(resetExpected, p->error(0)->reset()); + EXPECT_EQ(resetExpected, p->issue(0)->reset()); } TEST(Parser, unitsWithCellMLRealVariations) @@ -1844,7 +1844,7 @@ TEST(Parser, xmlComments) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, mathWithNamespacesDefinedOnTheMathNode) @@ -1870,7 +1870,7 @@ TEST(Parser, mathWithNamespacesDefinedOnTheMathNode) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, mathWithNamespacesDefinedOnTheNodeThatUsesNamespace) @@ -1896,7 +1896,7 @@ TEST(Parser, mathWithNamespacesDefinedOnTheNodeThatUsesNamespace) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, mathWithNonStandardCellMLPrefix) @@ -1922,7 +1922,7 @@ TEST(Parser, mathWithNonStandardCellMLPrefix) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, mathWithMathmlNamespaceOnModel) @@ -1948,7 +1948,7 @@ TEST(Parser, mathWithMathmlNamespaceOnModel) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, repeatedMathParsePrintBehaviour) diff --git a/tests/printer/printer.cpp b/tests/printer/printer.cpp index 35366747d..1e30d9afd 100644 --- a/tests/printer/printer.cpp +++ b/tests/printer/printer.cpp @@ -219,7 +219,7 @@ TEST(Printer, printModelWithImports) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("sine_approximations_import.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); libcellml::PrinterPtr printer = libcellml::Printer::create(); diff --git a/tests/resolve_imports/file_parser.cpp b/tests/resolve_imports/file_parser.cpp index 475e20e5c..85029deae 100644 --- a/tests/resolve_imports/file_parser.cpp +++ b/tests/resolve_imports/file_parser.cpp @@ -31,7 +31,7 @@ TEST(ResolveImports, resolveSineModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("sine_approximations.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_FALSE(model->hasUnresolvedImports()); } @@ -39,7 +39,7 @@ TEST(ResolveImports, resolveSineImportsModelFromFile) { libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("sine_approximations_import.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -50,7 +50,7 @@ TEST(ResolveImports, resolveComplexImportsModelFromFile) { libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("complex_imports.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -62,7 +62,7 @@ TEST(ResolveImports, resolveUnitsImportFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("import_units_model.cellml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -74,7 +74,7 @@ TEST(ResolveImports, resolveImportsFromFileLevel0) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("level0.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -86,7 +86,7 @@ TEST(ResolveImports, resolveImportsFromFileLevel0Unresolvable) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("level0-broken-imports.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -112,7 +112,7 @@ TEST(ResolveImports, componentNotInResolvingModel) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(modelImportingComponent); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp index 292cc1ee5..1b07362b7 100644 --- a/tests/test_utils.cpp +++ b/tests/test_utils.cpp @@ -42,51 +42,51 @@ std::string fileContents(const std::string &fileName) void printErrors(const libcellml::LoggerPtr &l, bool headings, bool kinds, bool rule) { - for (size_t i = 0; i < l->errorCount(); ++i) { - std::cout << "Error " << std::setw(3) << i + 1 << ": "; - std::cout << l->error(i)->description(); + for (size_t i = 0; i < l->issueCount(); ++i) { + std::cout << "Issue " << std::setw(3) << i + 1 << ": "; + std::cout << l->issue(i)->description(); if (headings) { - std::cout << ", " << l->error(i)->specificationHeading(); + std::cout << ", " << l->issue(i)->specificationHeading(); } if (kinds) { - std::cout << ", " << static_cast(l->error(i)->kind()); + std::cout << ", " << static_cast(l->issue(i)->kind()); } if (rule) { - std::cout << ", " << static_cast(l->error(i)->rule()); + std::cout << ", " << static_cast(l->issue(i)->rule()); } std::cout << std::endl; } } -void expectEqualErrors(const std::vector &errors, const libcellml::LoggerPtr &logger) +void expectEqualErrors(const std::vector &issues, const libcellml::LoggerPtr &logger) { - EXPECT_EQ(errors.size(), logger->errorCount()); - for (size_t i = 0; i < logger->errorCount() && i < errors.size(); ++i) { - EXPECT_EQ(errors.at(i), logger->error(i)->description()); + EXPECT_EQ(issues.size(), logger->issueCount()); + for (size_t i = 0; i < logger->issueCount() && i < issues.size(); ++i) { + EXPECT_EQ(issues.at(i), logger->issue(i)->description()); } } -void expectEqualErrorsSpecificationHeadings(const std::vector &errors, +void expectEqualErrorsSpecificationHeadings(const std::vector &issues, const std::vector &specificationHeadings, const libcellml::LoggerPtr &logger) { - EXPECT_EQ(errors.size(), logger->errorCount()); - EXPECT_EQ(specificationHeadings.size(), logger->errorCount()); - for (size_t i = 0; i < logger->errorCount() && i < errors.size(); ++i) { - EXPECT_EQ(errors.at(i), logger->error(i)->description()); - EXPECT_EQ(specificationHeadings.at(i), logger->error(i)->specificationHeading()); + EXPECT_EQ(issues.size(), logger->issueCount()); + EXPECT_EQ(specificationHeadings.size(), logger->issueCount()); + for (size_t i = 0; i < logger->issueCount() && i < issues.size(); ++i) { + EXPECT_EQ(issues.at(i), logger->issue(i)->description()); + EXPECT_EQ(specificationHeadings.at(i), logger->issue(i)->specificationHeading()); } } -void expectEqualErrorsKinds(const std::vector &errors, - const std::vector &kinds, +void expectEqualErrorsKinds(const std::vector &issues, + const std::vector &kinds, const libcellml::LoggerPtr &logger) { - EXPECT_EQ(errors.size(), logger->errorCount()); - EXPECT_EQ(kinds.size(), logger->errorCount()); - for (size_t i = 0; i < logger->errorCount() && i < errors.size(); ++i) { - EXPECT_EQ(errors.at(i), logger->error(i)->description()); - EXPECT_EQ(kinds.at(i), logger->error(i)->kind()); + EXPECT_EQ(issues.size(), logger->issueCount()); + EXPECT_EQ(kinds.size(), logger->issueCount()); + for (size_t i = 0; i < logger->issueCount() && i < issues.size(); ++i) { + EXPECT_EQ(issues.at(i), logger->issue(i)->description()); + EXPECT_EQ(kinds.at(i), logger->issue(i)->kind()); } } diff --git a/tests/test_utils.h b/tests/test_utils.h index 26f6cc5aa..a1a02973e 100644 --- a/tests/test_utils.h +++ b/tests/test_utils.h @@ -79,13 +79,13 @@ std::string TEST_EXPORT fileContents(const std::string &fileName); void TEST_EXPORT printErrors(const libcellml::LoggerPtr &l, bool headings = false, bool kinds = false, bool rule = false); -void TEST_EXPORT expectEqualErrors(const std::vector &errors, +void TEST_EXPORT expectEqualErrors(const std::vector &issues, const libcellml::LoggerPtr &logger); -void TEST_EXPORT expectEqualErrorsSpecificationHeadings(const std::vector &errors, +void TEST_EXPORT expectEqualErrorsSpecificationHeadings(const std::vector &issues, const std::vector &specificationHeadings, const libcellml::LoggerPtr &logger); -void TEST_EXPORT expectEqualErrorsKinds(const std::vector &errors, - const std::vector &kinds, +void TEST_EXPORT expectEqualErrorsKinds(const std::vector &issues, + const std::vector &kinds, const libcellml::LoggerPtr &logger); libcellml::ModelPtr TEST_EXPORT createModel(const std::string &name = ""); @@ -93,14 +93,14 @@ libcellml::ModelPtr TEST_EXPORT createModelWithComponent(const std::string &name libcellml::VariablePtr TEST_EXPORT createVariableWithUnits(const std::string &name, const std::string &units); libcellml::ModelPtr TEST_EXPORT createModelTwoComponentsWithOneVariableEach(const std::string &modelName = "", const std::string &c1Name = "", const std::string &c2Name = "", const std::string &v1Name = "", const std::string &v2Name = ""); -#define EXPECT_EQ_ERRORS(errors, logger) \ - SCOPED_TRACE("Error occured here."); \ - expectEqualErrors(errors, logger) +#define EXPECT_EQ_ERRORS(issues, logger) \ + SCOPED_TRACE("Issue occured here."); \ + expectEqualErrors(issues, logger) -#define EXPECT_EQ_ERRORS_SPECIFICATION_HEADINGS(errors, specificationHeadings, logger) \ - SCOPED_TRACE("Error occured here."); \ - expectEqualErrorsSpecificationHeadings(errors, specificationHeadings, logger) +#define EXPECT_EQ_ERRORS_SPECIFICATION_HEADINGS(issues, specificationHeadings, logger) \ + SCOPED_TRACE("Issue occured here."); \ + expectEqualErrorsSpecificationHeadings(issues, specificationHeadings, logger) -#define EXPECT_EQ_ERRORS_KINDS(errors, kinds, logger) \ - SCOPED_TRACE("Error occured here."); \ - expectEqualErrorsKinds(errors, kinds, logger) +#define EXPECT_EQ_ERRORS_KINDS(issues, kinds, logger) \ + SCOPED_TRACE("Issue occured here."); \ + expectEqualErrorsKinds(issues, kinds, logger) diff --git a/tests/units/units.cpp b/tests/units/units.cpp index f26497584..74fd06340 100644 --- a/tests/units/units.cpp +++ b/tests/units/units.cpp @@ -788,8 +788,8 @@ TEST(Units, unitsWithPrefixOutOfRange) validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->errorCount()); - EXPECT_EQ(e, validator->error(0)->description()); + EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(e, validator->issue(0)->description()); } TEST(Units, parentOfUnits) diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 360534d84..4c1a83274 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -31,7 +31,7 @@ TEST(Validator, namedModel) libcellml::ModelPtr model = libcellml::Model::create(); model->setName("awesomeName"); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unnamedModel) @@ -254,7 +254,7 @@ TEST(Validator, importUnits) importedUnits->setSourceUnits(imp, "units_in_that_model"); m->addUnits(importedUnits); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); // Invalid units import- missing refs libcellml::ImportSourcePtr imp2 = libcellml::ImportSource::create(); @@ -263,7 +263,7 @@ TEST(Validator, importUnits) importedUnits2->setSourceUnits(imp2, ""); m->addUnits(importedUnits2); v->validateModel(m); - EXPECT_EQ(size_t(3), v->errorCount()); + EXPECT_EQ(size_t(3), v->issueCount()); // Invalid units import - duplicate refs libcellml::ImportSourcePtr imp3 = libcellml::ImportSource::create(); @@ -273,7 +273,7 @@ TEST(Validator, importUnits) importedUnits3->setSourceUnits(imp3, "units_in_that_model"); m->addUnits(importedUnits3); v->validateModel(m); - EXPECT_EQ(size_t(4), v->errorCount()); + EXPECT_EQ(size_t(4), v->issueCount()); // Invalid units import - unnamed units libcellml::ImportSourcePtr imp4 = libcellml::ImportSource::create(); @@ -310,7 +310,7 @@ TEST(Validator, importComponents) importedComponent->setSourceComponent(imp, "component_in_that_model"); m->addComponent(importedComponent); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); // Another valid component import libcellml::ImportSourcePtr imp2 = libcellml::ImportSource::create(); @@ -320,7 +320,7 @@ TEST(Validator, importComponents) importedComponent2->setSourceComponent(imp2, "new_shiny_component_ref"); m->addComponent(importedComponent2); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); // Invalid component import - missing ref to source component libcellml::ImportSourcePtr imp3 = libcellml::ImportSource::create(); @@ -329,7 +329,7 @@ TEST(Validator, importComponents) importedComponent3->setSourceComponent(imp3, ""); m->addComponent(importedComponent3); v->validateModel(m); - EXPECT_EQ(size_t(3), v->errorCount()); + EXPECT_EQ(size_t(3), v->issueCount()); // Valid component import - two components imported from the same place is allowed libcellml::ImportSourcePtr imp4 = libcellml::ImportSource::create(); @@ -339,7 +339,7 @@ TEST(Validator, importComponents) importedComponent4->setSourceComponent(imp4, "component_in_that_model"); m->addComponent(importedComponent4); v->validateModel(m); - EXPECT_EQ(size_t(3), v->errorCount()); + EXPECT_EQ(size_t(3), v->issueCount()); // Invalid - name missing from component libcellml::ImportSourcePtr imp5 = libcellml::ImportSource::create(); @@ -348,7 +348,7 @@ TEST(Validator, importComponents) importedComponent5->setSourceComponent(imp5, "component_in_that_model"); m->addComponent(importedComponent5); v->validateModel(m); - EXPECT_EQ(size_t(5), v->errorCount()); + EXPECT_EQ(size_t(5), v->issueCount()); // Valid - two components from the same source is allowed libcellml::ImportSourcePtr imp7 = libcellml::ImportSource::create(); @@ -358,7 +358,7 @@ TEST(Validator, importComponents) importedComponent7->setSourceComponent(imp7, "new_shiny_component_ref"); m->addComponent(importedComponent7); v->validateModel(m); - EXPECT_EQ(size_t(5), v->errorCount()); + EXPECT_EQ(size_t(5), v->issueCount()); // Valid - duplicate component_ref from a different source libcellml::ImportSourcePtr imp8 = libcellml::ImportSource::create(); @@ -368,7 +368,7 @@ TEST(Validator, importComponents) importedComponent8->setSourceComponent(imp8, "component_in_that_model"); m->addComponent(importedComponent8); v->validateModel(m); - EXPECT_EQ(size_t(5), v->errorCount()); + EXPECT_EQ(size_t(5), v->issueCount()); // Invalid: component_ref url is not valid html libcellml::ImportSourcePtr imp9 = libcellml::ImportSource::create(); @@ -423,7 +423,7 @@ TEST(Validator, validMath) m->addComponent(c); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); } TEST(Validator, invalidMath) @@ -478,8 +478,8 @@ TEST(Validator, invalidMathMLElements) "No declaration for element equals.", "No declaration for element addition.", }; - // Note: the MathML DTD also gives errors that list every possible operator when an - // invalid option is given. We'll just explicitly check the less verbose errors here. + // Note: the MathML DTD also gives issues that list every possible operator when an + // invalid option is given. We'll just explicitly check the less verbose issues here. libcellml::ValidatorPtr v = libcellml::Validator::create(); libcellml::ModelPtr m = libcellml::Model::create(); @@ -509,7 +509,7 @@ TEST(Validator, invalidMathMLElements) // Check for two expected error messages (see note above). for (size_t i = 0; i < 2; ++i) { - EXPECT_EQ(expectedErrors.at(i), v->error(i)->description()); + EXPECT_EQ(expectedErrors.at(i), v->issue(i)->description()); } } @@ -766,7 +766,7 @@ TEST(Validator, validMathMLCiAndCnElementsWithCellMLUnits) m->addComponent(c); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); } TEST(Validator, parseAndValidateInvalidUnitErrors) @@ -794,7 +794,7 @@ TEST(Validator, parseAndValidateInvalidUnitErrors) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr m = p->parseModel(input); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); libcellml::ValidatorPtr v = libcellml::Validator::create(); v->validateModel(m); @@ -889,7 +889,7 @@ TEST(Validator, validateInvalidConnectionsDanglingReciprocalEquivalence) v1_2->removeAllEquivalences(); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); } TEST(Validator, integerStrings) @@ -1009,7 +1009,7 @@ TEST(Validator, resetValid) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, resetNoVariable) @@ -1046,8 +1046,8 @@ TEST(Validator, resetNoVariable) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->errorCount()); - EXPECT_EQ(expectedError, validator->error(0)->description()); + EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(expectedError, validator->issue(0)->description()); } TEST(Validator, resetNoTestVariable) @@ -1084,8 +1084,8 @@ TEST(Validator, resetNoTestVariable) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->errorCount()); - EXPECT_EQ(expectedError, validator->error(0)->description()); + EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(expectedError, validator->issue(0)->description()); } TEST(Validator, resetNoOrder) @@ -1121,8 +1121,8 @@ TEST(Validator, resetNoOrder) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->errorCount()); - EXPECT_EQ(expectedError, validator->error(0)->description()); + EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(expectedError, validator->issue(0)->description()); } TEST(Validator, resetNoResetValue) @@ -1158,8 +1158,8 @@ TEST(Validator, resetNoResetValue) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->errorCount()); - EXPECT_EQ(expectedError, validator->error(0)->description()); + EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(expectedError, validator->issue(0)->description()); } TEST(Validator, resetNoTestValue) @@ -1273,7 +1273,7 @@ TEST(Validator, resetEmptyMathML) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, resetNegativeOrder) @@ -1308,7 +1308,7 @@ TEST(Validator, resetNegativeOrder) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, resetVariableOutsideComponent) @@ -1392,7 +1392,7 @@ TEST(Validator, validMathCnElements) m->addComponent(c); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); } TEST(Validator, validMathCnElementsMissingCellMLNamespace) @@ -1480,7 +1480,7 @@ TEST(Validator, unitAmericanSpellingOfUnitsRemoved) "Variable 'tomayto' has units of 'testunit1' and an equivalent variable 'tomahto' with non-matching units of 'testunit2'. The mismatch is: metre^1.", }; - // This one is now an error. + // This one is now an issue. libcellml::Variable::addEquivalence(v1, v2); validator->validateModel(m); @@ -1555,7 +1555,7 @@ TEST(Validator, unitEquivalenceStandardUnitsToBaseUnits) base->addUnit(baseUnits.first, 0, baseUnits.second, 1.0); } validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } } @@ -1598,7 +1598,7 @@ TEST(Validator, unitEquivalenceBasicDimensionlessUnits) libcellml::Variable::addEquivalence(v1, v2); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unitEquivalenceDimensionlessUnits) @@ -1652,7 +1652,7 @@ TEST(Validator, unitEquivalenceDimensionlessUnits) libcellml::Variable::addEquivalence(v2, v3); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unitEquivalenceMultiplierPrefix) @@ -1702,7 +1702,7 @@ TEST(Validator, unitEquivalenceMultiplierPrefix) libcellml::Variable::addEquivalence(v2, v3); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unitEquivalenceComplicatedNestedUnits) @@ -1862,7 +1862,7 @@ TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) libcellml::Variable::addEquivalence(v1, v2); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unitUserCreatedUnitsBananasAndApples) @@ -2039,7 +2039,7 @@ TEST(Validator, unitSimpleCycle) // Network valid at this stage. v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); // Time loop Grandfather paradox created! u1 no longer a base variable: u1 -> u3 -> u2 -> u1. u1->addUnit("child"); @@ -2101,7 +2101,7 @@ TEST(Validator, unitComplexCycle) u6->addUnit("mother"); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); // As soon as a dependency of the grandfather on the brotherFromAnotherMother is added, then a // _directed_ loop (u1->u2->u4->u1) is created and the network is no longer valid: @@ -2164,7 +2164,7 @@ TEST(Validator, multipleDefinitionsOfCellMLNamespace) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, validateModelWithoutAndWithMath) @@ -2191,7 +2191,7 @@ TEST(Validator, validateModelWithoutAndWithMath) c3->addVariable(v); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); const std::string math = "\n" @@ -2205,7 +2205,7 @@ TEST(Validator, validateModelWithoutAndWithMath) c3->setMath(math); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unitEquivalenceMultiplier) @@ -2245,7 +2245,7 @@ TEST(Validator, unitEquivalenceMultiplier) validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unfoundUnitsInEncapsulatedComponents) diff --git a/tests/variable/variable.cpp b/tests/variable/variable.cpp index 75cc475ef..4ae9d712f 100644 --- a/tests/variable/variable.cpp +++ b/tests/variable/variable.cpp @@ -1166,7 +1166,7 @@ TEST(Variable, modelUnitsAttributeBeforeNameAttribute) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Variable, parentlessUsingRemoveVariable) From d9c64797b6d131d126a17d15040ef7889362c077 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 15 Jan 2020 11:32:06 +0100 Subject: [PATCH 02/88] Added level indicator, renamed test files --- src/api/libcellml/issue.h | 12 ++++++++++++ src/issue.cpp | 1 + tests/CMakeLists.txt | 2 +- tests/{error/error.cpp => issue/issue.cpp} | 0 tests/{error => issue}/tests.cmake | 5 ++--- 5 files changed, 16 insertions(+), 4 deletions(-) rename tests/{error/error.cpp => issue/issue.cpp} (100%) rename tests/{error => issue}/tests.cmake (88%) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 1ab24e815..f41994065 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -109,6 +109,18 @@ class LIBCELLML_EXPORT Issue GENERATOR }; + /** + * @brief The issue Level enum class. + * + * Enum to describe the level of severity that a given issue has. + */ + enum class Level + { + FATAL, + WARNING, + INFORMATION, + }; + /** * @brief Set the description for this issue. * diff --git a/src/issue.cpp b/src/issue.cpp index 6e0ee3cac..134bede4f 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -31,6 +31,7 @@ struct Issue::IssueImpl { std::string mDescription; /**< The string description for why this entity issue raised. */ Issue::Kind mKind = Issue::Kind::UNDEFINED; /**< The Issue::Kind enum value for this issue. */ + Issue::Level mLevel = Issue::Level::FATAL; /**< The Issue::Level enum value for this issue. */ SpecificationRule mRule = SpecificationRule::UNDEFINED; /**< The SpecificationRule enum value for this issue. */ ComponentPtr mComponent; /**< Pointer to the component that the issue occurred in. */ ImportSourcePtr mImportSource; /**< Pointer to the import source that the issue occurred in. */ diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 7f438ce84..8dc526cce 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -31,9 +31,9 @@ include(clone/tests.cmake) include(component/tests.cmake) include(connection/tests.cmake) include(coverage/tests.cmake) -include(error/tests.cmake) include(generator/tests.cmake) include(isolated/tests.cmake) +include(issue/tests.cmake) include(math/tests.cmake) include(model/tests.cmake) include(parser/tests.cmake) diff --git a/tests/error/error.cpp b/tests/issue/issue.cpp similarity index 100% rename from tests/error/error.cpp rename to tests/issue/issue.cpp diff --git a/tests/error/tests.cmake b/tests/issue/tests.cmake similarity index 88% rename from tests/error/tests.cmake rename to tests/issue/tests.cmake index 9b21319e0..9a688411d 100644 --- a/tests/error/tests.cmake +++ b/tests/issue/tests.cmake @@ -1,7 +1,7 @@ # Set the test name, 'test_' will be prepended to the # name set here -set(CURRENT_TEST error) +set(CURRENT_TEST issue) # Set a category name to enable running commands like: # ctest -R # which will run the tests matching this category-label. @@ -10,9 +10,8 @@ set(${CURRENT_TEST}_CATEGORY object) list(APPEND LIBCELLML_TESTS ${CURRENT_TEST}) # Using absolute path relative to this file set(${CURRENT_TEST}_SRCS - ${CMAKE_CURRENT_LIST_DIR}/error.cpp + ${CMAKE_CURRENT_LIST_DIR}/issue.cpp ) #set(${CURRENT_TEST}_HDRS # ${CMAKE_CURRENT_LIST_DIR}/ #) - From 51b27cc3dfca0b0f04deb643d4aafdf87dde9468 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 15 Jan 2020 11:40:26 +0100 Subject: [PATCH 03/88] Rename "Kind" to "Cause" Makes it easier to understand: we have the cause (the type of object with an error) and the level (fatal, warning, info) --- src/api/libcellml/issue.h | 22 +++++----- src/bindings/interface/issue.i | 6 +-- src/bindings/interface/types.i | 4 +- src/bindings/python/__init__.py | 2 +- src/generator.cpp | 12 +++--- src/issue.cpp | 38 ++++++++--------- src/parser.cpp | 66 ++++++++++++++--------------- src/validator.cpp | 26 ++++++------ tests/bindings/python/test_error.py | 44 +++++++++---------- tests/generator/generator.cpp | 22 +++++----- tests/gtest/include/gtest/gtest.h | 12 +++--- tests/issue/issue.cpp | 12 +++--- tests/parser/parser.cpp | 60 +++++++++++++------------- tests/test_utils.cpp | 8 ++-- tests/test_utils.h | 6 +-- 15 files changed, 170 insertions(+), 170 deletions(-) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index f41994065..7c6ca2444 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -89,11 +89,11 @@ class LIBCELLML_EXPORT Issue static IssuePtr create(const VariablePtr &variable) noexcept; /** - * @brief The issue Kind enum class. + * @brief The issue Cause enum class. * * Enum to describe the kind of issue a given issue is. */ - enum class Kind + enum class Cause { COMPONENT, CONNECTION, @@ -143,32 +143,32 @@ class LIBCELLML_EXPORT Issue * @brief Set the kind of this issue. * * Set the @p kind of this issue from the options available in - * @c Issue::Kind. + * @c Issue::Cause. * - * @param kind The @c Issue::Kind to set. + * @param kind The @c Issue::Cause to set. */ - void setKind(Kind kind); + void setCause(Cause kind); /** * @brief Get the kind of this issue. * * Get the @c kind of this issue. If no kind has been set for - * this issue, will return Kind::UNDEFINED. + * this issue, will return Cause::UNDEFINED. * - * @return The @c Issue::Kind set for this issue. + * @return The @c Issue::Cause set for this issue. */ - Kind kind() const; + Cause cause() const; /** * @brief Check whether the kind of this issue matches the argument kind. * - * Return @c true if the @p kind matches the the @c Issue::Kind for this + * Return @c true if the @p kind matches the the @c Issue::Cause for this * issue and @c false otherwise. * - * @return @c true if the @p kind matches the the @c Issue::Kind for this + * @return @c true if the @p kind matches the the @c Issue::Cause for this * issue and @c false otherwise. */ - bool isKind(Kind kind) const; + bool isCause(Cause kind) const; /** * @brief Set the @c enum SpecificationRule of this issue. diff --git a/src/bindings/interface/issue.i b/src/bindings/interface/issue.i index 924071cce..6a0aefde1 100644 --- a/src/bindings/interface/issue.i +++ b/src/bindings/interface/issue.i @@ -18,12 +18,12 @@ %feature("docstring") libcellml::Issue::kind "Get the ``kind`` of this issue. If no kind has been set for this issue, will -return Kind::UNDEFINED."; +return Cause::UNDEFINED."; -%feature("docstring") libcellml::Issue::isKind +%feature("docstring") libcellml::Issue::isCause "Tests if this issue matches the given ``kind``."; -%feature("docstring") libcellml::Issue::setKind +%feature("docstring") libcellml::Issue::setCause "Sets the ``kind`` of this issue."; %feature("docstring") libcellml::Issue::rule diff --git a/src/bindings/interface/types.i b/src/bindings/interface/types.i index 8dced702e..97e13028e 100644 --- a/src/bindings/interface/types.i +++ b/src/bindings/interface/types.i @@ -50,12 +50,12 @@ Only meant to be included, shouldn't be passed to cmake as a module! } } -%typemap(in) libcellml::Issue::Kind (int val, int ecode) { +%typemap(in) libcellml::Issue::Cause (int val, int ecode) { ecode = SWIG_AsVal(int)($input, &val); if (!SWIG_IsOK(ecode)) { %argument_fail(ecode, "$type", $symname, $argnum); } else { - if (val < %static_cast(libcellml::Issue::Kind::COMPONENT, int) || %static_cast(libcellml::Issue::Kind::XML, int) < val) { + if (val < %static_cast(libcellml::Issue::Cause::COMPONENT, int) || %static_cast(libcellml::Issue::Cause::XML, int) < val) { %argument_fail(ecode, "$type is not a valid value for the enumeration.", $symname, $argnum); } $1 = %static_cast(val,$basetype); diff --git a/src/bindings/python/__init__.py b/src/bindings/python/__init__.py index 81c3f71ec..32d8ae86d 100644 --- a/src/bindings/python/__init__.py +++ b/src/bindings/python/__init__.py @@ -41,7 +41,7 @@ class Object: converting = True if converting: setattr(base if new_base is None else new_base, enum, obj) -convert(Issue, 'Kind', [ +convert(Issue, 'Cause', [ 'COMPONENT', 'CONNECTION', 'ENCAPSULATION', diff --git a/src/generator.cpp b/src/generator.cpp index ca6783f6d..e22bb39aa 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1054,7 +1054,7 @@ void Generator::GeneratorImpl::processNode(const XmlNodePtr &node, + "' in component '" + component->name() + "' of model '" + modelName + "' is referenced in an equation, but it is not defined anywhere."); - err->setKind(Issue::Kind::GENERATOR); + err->setCause(Issue::Cause::GENERATOR); mGenerator->addIssue(err); } @@ -1173,7 +1173,7 @@ void Generator::GeneratorImpl::processComponent(const ComponentPtr &component) + "' in component '" + trackedVariableComponent->name() + "' of model '" + trackedVariableModel->name() + "' are equivalent and cannot therefore both be initialised."); - err->setKind(Issue::Kind::GENERATOR); + err->setCause(Issue::Cause::GENERATOR); mGenerator->addIssue(err); } @@ -1220,7 +1220,7 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr + "' in component '" + component->name() + "' of model '" + modelName + "' cannot be both a variable of integration and initialised."); - err->setKind(Issue::Kind::GENERATOR); + err->setCause(Issue::Cause::GENERATOR); mGenerator->addIssue(err); } else { @@ -1241,7 +1241,7 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr + "' in component '" + component->name() + "' of model '" + model->name() + "' cannot both be a variable of integration."); - err->setKind(Issue::Kind::GENERATOR); + err->setCause(Issue::Cause::GENERATOR); mGenerator->addIssue(err); } @@ -1263,7 +1263,7 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr + "' in component '" + component->name() + "' of model '" + model->name() + "' must be of the first order."); - err->setKind(Issue::Kind::GENERATOR); + err->setCause(Issue::Cause::GENERATOR); mGenerator->addIssue(err); } @@ -1443,7 +1443,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) err->setDescription("Variable '" + realVariable->name() + "' in component '" + realComponent->name() + "' of model '" + realModel->name() + "' " + errorType + "."); - err->setKind(Issue::Kind::GENERATOR); + err->setCause(Issue::Cause::GENERATOR); mGenerator->addIssue(err); } diff --git a/src/issue.cpp b/src/issue.cpp index 134bede4f..285288309 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -30,7 +30,7 @@ namespace libcellml { struct Issue::IssueImpl { std::string mDescription; /**< The string description for why this entity issue raised. */ - Issue::Kind mKind = Issue::Kind::UNDEFINED; /**< The Issue::Kind enum value for this issue. */ + Issue::Cause mCause = Issue::Cause::UNDEFINED; /**< The Issue::Cause enum value for this issue. */ Issue::Level mLevel = Issue::Level::FATAL; /**< The Issue::Level enum value for this issue. */ SpecificationRule mRule = SpecificationRule::UNDEFINED; /**< The SpecificationRule enum value for this issue. */ ComponentPtr mComponent; /**< Pointer to the component that the issue occurred in. */ @@ -55,42 +55,42 @@ Issue::Issue(const ModelPtr &model) : mPimpl(new IssueImpl()) { mPimpl->mModel = model; - mPimpl->mKind = Issue::Kind::MODEL; + mPimpl->mCause = Issue::Cause::MODEL; } Issue::Issue(const ComponentPtr &component) : mPimpl(new IssueImpl()) { mPimpl->mComponent = component; - mPimpl->mKind = Issue::Kind::COMPONENT; + mPimpl->mCause = Issue::Cause::COMPONENT; } Issue::Issue(const ImportSourcePtr &importSource) : mPimpl(new IssueImpl()) { mPimpl->mImportSource = importSource; - mPimpl->mKind = Issue::Kind::IMPORT; + mPimpl->mCause = Issue::Cause::IMPORT; } Issue::Issue(const UnitsPtr &units) : mPimpl(new IssueImpl()) { mPimpl->mUnits = units; - mPimpl->mKind = Issue::Kind::UNITS; + mPimpl->mCause = Issue::Cause::UNITS; } Issue::Issue(const VariablePtr &variable) : mPimpl(new IssueImpl()) { mPimpl->mVariable = variable; - mPimpl->mKind = Issue::Kind::VARIABLE; + mPimpl->mCause = Issue::Cause::VARIABLE; } Issue::Issue(const ResetPtr &reset) : mPimpl(new IssueImpl()) { mPimpl->mReset = reset; - mPimpl->mKind = Issue::Kind::RESET; + mPimpl->mCause = Issue::Cause::RESET; } IssuePtr Issue::create() noexcept @@ -138,20 +138,20 @@ std::string Issue::description() const return mPimpl->mDescription; } -void Issue::setKind(Issue::Kind kind) +void Issue::setCause(Issue::Cause kind) { - mPimpl->mKind = kind; + mPimpl->mCause = kind; } -Issue::Kind Issue::kind() const +Issue::Cause Issue::cause() const { - return mPimpl->mKind; + return mPimpl->mCause; } -bool Issue::isKind(Kind kind) const +bool Issue::isCause(Cause kind) const { bool response = false; - if (mPimpl->mKind == kind) { + if (mPimpl->mCause == kind) { response = true; } return response; @@ -170,7 +170,7 @@ SpecificationRule Issue::rule() const void Issue::setComponent(const ComponentPtr &component) { mPimpl->mComponent = component; - mPimpl->mKind = Issue::Kind::COMPONENT; + mPimpl->mCause = Issue::Cause::COMPONENT; } ComponentPtr Issue::component() const @@ -181,7 +181,7 @@ ComponentPtr Issue::component() const void Issue::setImportSource(const ImportSourcePtr &importSource) { mPimpl->mImportSource = importSource; - mPimpl->mKind = Issue::Kind::IMPORT; + mPimpl->mCause = Issue::Cause::IMPORT; } ImportSourcePtr Issue::importSource() const @@ -192,7 +192,7 @@ ImportSourcePtr Issue::importSource() const void Issue::setModel(const ModelPtr &model) { mPimpl->mModel = model; - mPimpl->mKind = Issue::Kind::MODEL; + mPimpl->mCause = Issue::Cause::MODEL; } ModelPtr Issue::model() const @@ -203,7 +203,7 @@ ModelPtr Issue::model() const void Issue::setUnits(const UnitsPtr &units) { mPimpl->mUnits = units; - mPimpl->mKind = Issue::Kind::UNITS; + mPimpl->mCause = Issue::Cause::UNITS; } UnitsPtr Issue::units() const @@ -214,7 +214,7 @@ UnitsPtr Issue::units() const void Issue::setVariable(const VariablePtr &variable) { mPimpl->mVariable = variable; - mPimpl->mKind = Issue::Kind::VARIABLE; + mPimpl->mCause = Issue::Cause::VARIABLE; } VariablePtr Issue::variable() const @@ -225,7 +225,7 @@ VariablePtr Issue::variable() const void Issue::setReset(const ResetPtr &reset) { mPimpl->mReset = reset; - mPimpl->mKind = Issue::Kind::RESET; + mPimpl->mCause = Issue::Cause::RESET; } ResetPtr Issue::reset() const diff --git a/src/parser.cpp b/src/parser.cpp index 28dd2086a..7d6286711 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -235,7 +235,7 @@ ModelPtr Parser::parseModel(const std::string &input) if (input.empty()) { IssuePtr err = Issue::create(); err->setDescription("Model is empty."); - err->setKind(Issue::Kind::XML); + err->setCause(Issue::Cause::XML); err->setModel(model); addIssue(err); } else { @@ -258,7 +258,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp for (size_t i = 0; i < doc->xmlErrorCount(); ++i) { IssuePtr err = Issue::create(); err->setDescription("LibXml2 error: " + doc->xmlError(i)); - err->setKind(Issue::Kind::XML); + err->setCause(Issue::Cause::XML); mParser->addIssue(err); } } @@ -266,7 +266,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp if (!node) { IssuePtr err = Issue::create(); err->setDescription("Could not get a valid XML root node from the provided input."); - err->setKind(Issue::Kind::XML); + err->setCause(Issue::Cause::XML); mParser->addIssue(err); return; } @@ -329,7 +329,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid attribute '" + childAttribute->name() + "'."); err->setModel(model); - err->setKind(Issue::Kind::ENCAPSULATION); + err->setCause(Issue::Cause::ENCAPSULATION); mParser->addIssue(err); } childAttribute = childAttribute->next(); @@ -346,7 +346,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' does not contain any child elements."); err->setModel(model); - err->setKind(Issue::Kind::ENCAPSULATION); + err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::ENCAPSULATION_COMPONENT_REF); mParser->addIssue(err); } @@ -380,7 +380,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' has more than one encapsulation element."); err->setModel(model); - err->setKind(Issue::Kind::ENCAPSULATION); + err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); mParser->addIssue(err); } @@ -739,7 +739,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' has an invalid connection attribute '" + attribute->name() + "'."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); mParser->addIssue(err); } attribute = attribute->next(); @@ -749,7 +749,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' does not have a valid component_1 in a connection element."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT1); mParser->addIssue(err); component1Missing = true; @@ -758,7 +758,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' does not have a valid component_2 in a connection element."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT2); mParser->addIssue(err); component2Missing = true; @@ -772,7 +772,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' must contain one or more 'map_variables' elements."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_MAP_VARIABLES); mParser->addIssue(err); return; @@ -790,7 +790,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); mParser->addIssue(err); } } else if (grandchildNode->isComment()) { @@ -799,7 +799,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' has an invalid child element '" + grandchildNode->name() + "' of element '" + childNode->name() + "'."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); mParser->addIssue(err); } grandchildNode = grandchildNode->next(); @@ -820,7 +820,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' has an invalid map_variables attribute '" + childAttribute->name() + "'."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); mParser->addIssue(err); } childAttribute = childAttribute->next(); @@ -830,7 +830,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_1 in a map_variables element."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); mParser->addIssue(err); variable1Missing = true; @@ -839,7 +839,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_2 in a map_variables element."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); mParser->addIssue(err); variable2Missing = true; @@ -856,7 +856,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); mParser->addIssue(err); } } else if (childNode->isComment()) { @@ -865,7 +865,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); mParser->addIssue(err); } @@ -883,7 +883,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.first + "' as component_1 but it does not exist in the model."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT1); mParser->addIssue(err); } @@ -895,7 +895,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.second + "' as component_2 but it does not exist in the model."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT2); mParser->addIssue(err); } @@ -919,7 +919,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Variable '" + iterPair.first + "' is specified as variable_1 in a connection but it does not exist in component_1 component '" + component1->name() + "' of model '" + model->name() + "'."); err->setComponent(component1); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); mParser->addIssue(err); } @@ -928,7 +928,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.first + "' as variable_1 but the corresponding component_1 is invalid."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); mParser->addIssue(err); } @@ -945,7 +945,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Variable '" + iterPair.second + "' is specified as variable_2 in a connection but it does not exist in component_2 component '" + component2->name() + "' of model '" + model->name() + "'."); err->setComponent(component1); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); mParser->addIssue(err); } @@ -954,7 +954,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.second + "' as variable_2 but the corresponding component_2 is invalid."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); mParser->addIssue(err); } @@ -967,7 +967,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr IssuePtr err = Issue::create(); err->setDescription("Connection in model '" + model->name() + "' does not have a map_variables element."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_MAP_VARIABLES); mParser->addIssue(err); } @@ -990,7 +990,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponentName + "' as a component in a component_ref but it does not exist in the model."); err->setModel(model); - err->setKind(Issue::Kind::ENCAPSULATION); + err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); mParser->addIssue(err); } @@ -1000,7 +1000,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid component_ref attribute '" + attribute->name() + "'."); err->setModel(model); - err->setKind(Issue::Kind::ENCAPSULATION); + err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); mParser->addIssue(err); } @@ -1010,7 +1010,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' does not have a valid component attribute in a component_ref element."); err->setModel(model); - err->setKind(Issue::Kind::ENCAPSULATION); + err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); mParser->addIssue(err); } else if (parentComponent) { @@ -1033,7 +1033,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); - err->setKind(Issue::Kind::ENCAPSULATION); + err->setCause(Issue::Cause::ENCAPSULATION); mParser->addIssue(err); } } else if (childComponentNode->isComment()) { @@ -1042,7 +1042,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + childComponentNode->name() + "'."); err->setModel(model); - err->setKind(Issue::Kind::ENCAPSULATION); + err->setCause(Issue::Cause::ENCAPSULATION); mParser->addIssue(err); } @@ -1073,7 +1073,7 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); - err->setKind(Issue::Kind::ENCAPSULATION); + err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_CHILD); mParser->addIssue(err); } else { @@ -1087,7 +1087,7 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + componentRefNode->name() + "'."); err->setModel(model); - err->setKind(Issue::Kind::ENCAPSULATION); + err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::ENCAPSULATION_COMPONENT_REF); mParser->addIssue(err); } @@ -1099,14 +1099,14 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponent->name() + "' as a parent component_ref but it does not have any children."); err->setModel(model); - err->setKind(Issue::Kind::ENCAPSULATION); + err->setCause(Issue::Cause::ENCAPSULATION); mParser->addIssue(err); } } else if (!parentComponent && haveComponentRef) { IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' specifies an invalid parent component_ref that also does not have any children."); err->setModel(model); - err->setKind(Issue::Kind::ENCAPSULATION); + err->setCause(Issue::Cause::ENCAPSULATION); mParser->addIssue(err); } diff --git a/src/validator.cpp b/src/validator.cpp index 4b948e316..9052476e4 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -746,7 +746,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp for (size_t i = 0; i < doc->xmlErrorCount(); ++i) { IssuePtr err = Issue::create(); err->setDescription("LibXml2 error: " + doc->xmlError(i)); - err->setKind(Issue::Kind::XML); + err->setCause(Issue::Cause::XML); mValidator->addIssue(err); } } @@ -754,7 +754,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp if (node == nullptr) { IssuePtr err = Issue::create(); err->setDescription("Could not get a valid XML root node from the math on component '" + component->name() + "'."); - err->setKind(Issue::Kind::XML); + err->setCause(Issue::Cause::XML); err->setComponent(component); mValidator->addIssue(err); return; @@ -763,7 +763,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp IssuePtr err = Issue::create(); err->setDescription("Math root node is of invalid type '" + node->name() + "' on component '" + component->name() + "'. A valid math root node should be of type 'math'."); err->setComponent(component); - err->setKind(Issue::Kind::XML); + err->setCause(Issue::Cause::XML); mValidator->addIssue(err); return; } @@ -800,7 +800,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp IssuePtr err = Issue::create(); err->setDescription("W3C MathML DTD error: " + mathmlDoc->xmlError(i)); err->setComponent(component); - err->setKind(Issue::Kind::MATHML); + err->setCause(Issue::Cause::MATHML); mValidator->addIssue(err); } } @@ -815,7 +815,7 @@ bool Validator::ValidatorImpl::validateCnUnits(const ComponentPtr &component, co IssuePtr err = Issue::create(); err->setDescription("Math cn element with the value '" + textNode + "' does not have a valid cellml:units attribute."); err->setComponent(component); - err->setKind(Issue::Kind::MATHML); + err->setCause(Issue::Cause::MATHML); mValidator->addIssue(err); return false; @@ -849,7 +849,7 @@ void Validator::ValidatorImpl::validateAndCleanCnNode(const XmlNodePtr &node, co IssuePtr err = Issue::create(); err->setDescription("Math " + node->name() + " element has an invalid attribute type '" + attribute->name() + "' in the cellml namespace. Attribute 'units' is the only CellML namespace attribute allowed."); err->setComponent(component); - err->setKind(Issue::Kind::MATHML); + err->setCause(Issue::Cause::MATHML); mValidator->addIssue(err); } } @@ -871,7 +871,7 @@ void Validator::ValidatorImpl::validateAndCleanCnNode(const XmlNodePtr &node, co IssuePtr err = Issue::create(); err->setDescription("Math has a " + node->name() + " element with a cellml:units attribute '" + unitsName + "' that is not a valid reference to units in the model '" + model->name() + "' or a standard unit."); err->setComponent(component); - err->setKind(Issue::Kind::MATHML); + err->setCause(Issue::Cause::MATHML); mValidator->addIssue(err); } } @@ -897,7 +897,7 @@ void Validator::ValidatorImpl::validateAndCleanCiNode(const XmlNodePtr &node, co IssuePtr err = Issue::create(); err->setDescription("MathML ci element has the child text '" + textInNode + "' which does not correspond with any variable names present in component '" + component->name() + "'."); err->setComponent(component); - err->setKind(Issue::Kind::MATHML); + err->setCause(Issue::Cause::MATHML); mValidator->addIssue(err); } } @@ -930,7 +930,7 @@ void Validator::ValidatorImpl::validateMathMLElements(const XmlNodePtr &node, co IssuePtr err = Issue::create(); err->setDescription("Math has a '" + childNode->name() + "' element that is not a supported MathML element."); err->setComponent(component); - err->setKind(Issue::Kind::MATHML); + err->setCause(Issue::Cause::MATHML); mValidator->addIssue(err); } validateMathMLElements(childNode, component); @@ -942,7 +942,7 @@ void Validator::ValidatorImpl::validateMathMLElements(const XmlNodePtr &node, co IssuePtr err = Issue::create(); err->setDescription("Math has a '" + nextNode->name() + "' element that is not a supported MathML element."); err->setComponent(component); - err->setKind(Issue::Kind::MATHML); + err->setCause(Issue::Cause::MATHML); mValidator->addIssue(err); } validateMathMLElements(nextNode, component); @@ -983,7 +983,7 @@ void Validator::ValidatorImpl::validateConnections(const ModelPtr &model) IssuePtr err = Issue::create(); err->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); err->setModel(model); - err->setKind(Issue::Kind::UNITS); + err->setCause(Issue::Cause::UNITS); mValidator->addIssue(err); } @@ -994,7 +994,7 @@ void Validator::ValidatorImpl::validateConnections(const ModelPtr &model) IssuePtr err = Issue::create(); err->setDescription("Variable '" + equivalentVariable->name() + "' is an equivalent variable to '" + variable->name() + "' but '" + equivalentVariable->name() + "' has no parent component."); err->setModel(model); - err->setKind(Issue::Kind::CONNECTION); + err->setCause(Issue::Cause::CONNECTION); mValidator->addIssue(err); } } @@ -1195,7 +1195,7 @@ void Validator::ValidatorImpl::validateNoUnitsAreCyclic(const ModelPtr &model) des += issues[issues.size() - 1] + "'"; err->setDescription("Cyclic units exist: " + des); err->setModel(model); - err->setKind(Issue::Kind::UNITS); + err->setCause(Issue::Cause::UNITS); mValidator->addIssue(err); reportedErrorList.push_back(hash); } diff --git a/tests/bindings/python/test_error.py b/tests/bindings/python/test_error.py index e28080bfb..60775c690 100644 --- a/tests/bindings/python/test_error.py +++ b/tests/bindings/python/test_error.py @@ -45,22 +45,22 @@ def test_create_destroy(self): def test_kind_enum(self): from libcellml import Issue - self.assertIsInstance(Issue.Kind.COMPONENT, int) - self.assertIsInstance(Issue.Kind.CONNECTION, int) - self.assertIsInstance(Issue.Kind.ENCAPSULATION, int) - self.assertIsInstance(Issue.Kind.IMPORT, int) - self.assertIsInstance(Issue.Kind.MATHML, int) - self.assertIsInstance(Issue.Kind.MODEL, int) - self.assertIsInstance(Issue.Kind.UNDEFINED, int) - self.assertIsInstance(Issue.Kind.UNITS, int) - self.assertIsInstance(Issue.Kind.VARIABLE, int) - self.assertIsInstance(Issue.Kind.XML, int) + self.assertIsInstance(Issue.Cause.COMPONENT, int) + self.assertIsInstance(Issue.Cause.CONNECTION, int) + self.assertIsInstance(Issue.Cause.ENCAPSULATION, int) + self.assertIsInstance(Issue.Cause.IMPORT, int) + self.assertIsInstance(Issue.Cause.MATHML, int) + self.assertIsInstance(Issue.Cause.MODEL, int) + self.assertIsInstance(Issue.Cause.UNDEFINED, int) + self.assertIsInstance(Issue.Cause.UNITS, int) + self.assertIsInstance(Issue.Cause.VARIABLE, int) + self.assertIsInstance(Issue.Cause.XML, int) # Test conversion to enum e = Issue() - e.setKind(Issue.Kind.COMPONENT) - self.assertRaises(RuntimeError, e.setKind, Issue.Kind.COMPONENT - 1) - self.assertRaises(RuntimeError, e.setKind, Issue.Kind.XML + 1) + e.setCause(Issue.Cause.COMPONENT) + self.assertRaises(RuntimeError, e.setCause, Issue.Cause.COMPONENT - 1) + self.assertRaises(RuntimeError, e.setCause, Issue.Cause.XML + 1) def test_specification_rule_enum(self): from libcellml import Issue, SpecificationRule @@ -155,26 +155,26 @@ def test_description(self): def test_set_kind(self): from libcellml import Issue - # void setKind(Kind kind) + # void setCause(Cause kind) e = Issue() - e.setKind(Issue.Kind.CONNECTION) + e.setCause(Issue.Cause.CONNECTION) def test_kind(self): from libcellml import Issue - # Kind kind() + # Cause cause() e = Issue() - self.assertEqual(e.kind(), Issue.Kind.UNDEFINED) - e.setKind(Issue.Kind.MATHML) - self.assertEqual(e.kind(), Issue.Kind.MATHML) + self.assertEqual(e.cause(), Issue.Cause.UNDEFINED) + e.setCause(Issue.Cause.MATHML) + self.assertEqual(e.cause(), Issue.Cause.MATHML) def test_is_kind(self): from libcellml import Issue - # bool isKind(const Kind &kind) + # bool isCause(const Cause &kind) e = Issue() - self.assertTrue(e.isKind(Issue.Kind.UNDEFINED)) - self.assertFalse(e.isKind(Issue.Kind.MODEL)) + self.assertTrue(e.isCause(Issue.Cause.UNDEFINED)) + self.assertFalse(e.isCause(Issue.Cause.MODEL)) def test_set_rule(self): from libcellml import Issue, SpecificationRule diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index a58838b1c..a98ed8807 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -71,15 +71,15 @@ TEST(Generator, initializedVariableOfIntegration) const std::vector expectedErrors = { "Variable 'time' in component 'my_component' of model 'initialized_variable_of_integration' cannot be both a variable of integration and initialised.", }; - const std::vector expectedKinds = { - libcellml::Issue::Kind::GENERATOR, + const std::vector expectedCauses = { + libcellml::Issue::Cause::GENERATOR, }; libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ_ERRORS_KINDS(expectedErrors, expectedKinds, generator); + EXPECT_EQ_ERRORS_KINDS(expectedErrors, expectedCauses, generator); EXPECT_EQ(libcellml::Generator::ModelType::INVALID, generator->modelType()); @@ -104,15 +104,15 @@ TEST(Generator, twoVariablesOfIntegration) const std::vector expectedErrors = { "Variable 'time' in component 'main' of model 'two_variables_of_integration' and variable 'other_time' in component 'sub_sub_sub' of model 'two_variables_of_integration' cannot both be a variable of integration.", }; - const std::vector expectedKinds = { - libcellml::Issue::Kind::GENERATOR, + const std::vector expectedCauses = { + libcellml::Issue::Cause::GENERATOR, }; libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ_ERRORS_KINDS(expectedErrors, expectedKinds, generator); + EXPECT_EQ_ERRORS_KINDS(expectedErrors, expectedCauses, generator); EXPECT_EQ(libcellml::Generator::ModelType::INVALID, generator->modelType()); @@ -139,17 +139,17 @@ TEST(Generator, nonFirstOrderOdes) "The differential equation for variable 'y' in component 'sub' of model 'non_first_order_odes' must be of the first order.", "The differential equation for variable 'z' in component 'sub_sub' of model 'non_first_order_odes' must be of the first order.", }; - const std::vector expectedKinds = { - libcellml::Issue::Kind::GENERATOR, - libcellml::Issue::Kind::GENERATOR, - libcellml::Issue::Kind::GENERATOR, + const std::vector expectedCauses = { + libcellml::Issue::Cause::GENERATOR, + libcellml::Issue::Cause::GENERATOR, + libcellml::Issue::Cause::GENERATOR, }; libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ_ERRORS_KINDS(expectedErrors, expectedKinds, generator); + EXPECT_EQ_ERRORS_KINDS(expectedErrors, expectedCauses, generator); EXPECT_EQ(libcellml::Generator::ModelType::INVALID, generator->modelType()); diff --git a/tests/gtest/include/gtest/gtest.h b/tests/gtest/include/gtest/gtest.h index ebb16db7b..3d3cda6f8 100644 --- a/tests/gtest/include/gtest/gtest.h +++ b/tests/gtest/include/gtest/gtest.h @@ -10440,7 +10440,7 @@ GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes, // For selecting which printer to use when a given type has neither << // nor PrintTo(). -enum TypeKind { +enum TypeCause { kProtobuf, // a protobuf type kConvertibleToInteger, // a type implicitly convertible to BiggestInt // (e.g. a named or unnamed enum type) @@ -10451,14 +10451,14 @@ enum TypeKind { kOtherType // anything else }; -// TypeWithoutFormatter::PrintValue(value, os) is called +// TypeWithoutFormatter::PrintValue(value, os) is called // by the universal printer to print a value of type T when neither -// operator<< nor PrintTo() is defined for T, where kTypeKind is the -// "kind" of T as defined by enum TypeKind. -template +// operator<< nor PrintTo() is defined for T, where kTypeCause is the +// "kind" of T as defined by enum TypeCause. +template class TypeWithoutFormatter { public: - // This default version is called when kTypeKind is kOtherType. + // This default version is called when kTypeCause is kOtherType. static void PrintValue(const T& value, ::std::ostream* os) { PrintBytesInObjectTo(static_cast( reinterpret_cast(&value)), diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index ae8e2b809..68a8b1c01 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -23,7 +23,7 @@ TEST(Issue, createModelError) libcellml::ModelPtr m = libcellml::Model::create(); libcellml::IssuePtr e = libcellml::Issue::create(m); - EXPECT_EQ(libcellml::Issue::Kind::MODEL, e->kind()); + EXPECT_EQ(libcellml::Issue::Cause::MODEL, e->cause()); } TEST(Issue, createComponemntError) @@ -31,7 +31,7 @@ TEST(Issue, createComponemntError) libcellml::ComponentPtr c = libcellml::Component::create(); libcellml::IssuePtr e = libcellml::Issue::create(c); - EXPECT_EQ(libcellml::Issue::Kind::COMPONENT, e->kind()); + EXPECT_EQ(libcellml::Issue::Cause::COMPONENT, e->cause()); } TEST(Issue, createVariableError) @@ -39,7 +39,7 @@ TEST(Issue, createVariableError) libcellml::VariablePtr v = libcellml::Variable::create(); libcellml::IssuePtr e = libcellml::Issue::create(v); - EXPECT_EQ(libcellml::Issue::Kind::VARIABLE, e->kind()); + EXPECT_EQ(libcellml::Issue::Cause::VARIABLE, e->cause()); } TEST(Issue, createUnitsError) @@ -47,7 +47,7 @@ TEST(Issue, createUnitsError) libcellml::UnitsPtr u = libcellml::Units::create(); libcellml::IssuePtr e = libcellml::Issue::create(u); - EXPECT_EQ(libcellml::Issue::Kind::UNITS, e->kind()); + EXPECT_EQ(libcellml::Issue::Cause::UNITS, e->cause()); } TEST(Issue, createImportSourceError) @@ -55,7 +55,7 @@ TEST(Issue, createImportSourceError) libcellml::ImportSourcePtr i = libcellml::ImportSource::create(); libcellml::IssuePtr e = libcellml::Issue::create(i); - EXPECT_EQ(libcellml::Issue::Kind::IMPORT, e->kind()); + EXPECT_EQ(libcellml::Issue::Cause::IMPORT, e->cause()); } TEST(Issue, createResetError) @@ -63,7 +63,7 @@ TEST(Issue, createResetError) libcellml::ResetPtr r = libcellml::Reset::create(); libcellml::IssuePtr e = libcellml::Issue::create(r); - EXPECT_EQ(libcellml::Issue::Kind::RESET, e->kind()); + EXPECT_EQ(libcellml::Issue::Cause::RESET, e->cause()); } void testSpecificationRule(const libcellml::IssuePtr &e) diff --git a/tests/parser/parser.cpp b/tests/parser/parser.cpp index b0996e1f3..cb5a7c137 100644 --- a/tests/parser/parser.cpp +++ b/tests/parser/parser.cpp @@ -1337,10 +1337,10 @@ TEST(Parser, invalidImportsAndGetError) EXPECT_EQ(import, importFromError); } -TEST(Parser, invalidModelWithAllKindsOfErrors) +TEST(Parser, invalidModelWithAllCausesOfErrors) { // Check for all kinds of issues. - std::vector foundKind(9, false); + std::vector foundCause(9, false); // Trigger CellML entity issues const std::string input = @@ -1376,33 +1376,33 @@ TEST(Parser, invalidModelWithAllKindsOfErrors) EXPECT_EQ_ERRORS(expectedErrors, parser); for (size_t i = 0; i < parser->issueCount(); ++i) { - switch (parser->issue(i)->kind()) { - case libcellml::Issue::Kind::COMPONENT: - foundKind.at(0) = true; + switch (parser->issue(i)->cause()) { + case libcellml::Issue::Cause::COMPONENT: + foundCause.at(0) = true; break; - case (libcellml::Issue::Kind::CONNECTION): - foundKind.at(1) = true; + case (libcellml::Issue::Cause::CONNECTION): + foundCause.at(1) = true; break; - case (libcellml::Issue::Kind::ENCAPSULATION): - foundKind.at(2) = true; + case (libcellml::Issue::Cause::ENCAPSULATION): + foundCause.at(2) = true; break; - case (libcellml::Issue::Kind::IMPORT): - foundKind.at(3) = true; + case (libcellml::Issue::Cause::IMPORT): + foundCause.at(3) = true; break; - case (libcellml::Issue::Kind::MODEL): - foundKind.at(4) = true; + case (libcellml::Issue::Cause::MODEL): + foundCause.at(4) = true; break; - case (libcellml::Issue::Kind::UNITS): - foundKind.at(5) = true; + case (libcellml::Issue::Cause::UNITS): + foundCause.at(5) = true; break; - case (libcellml::Issue::Kind::VARIABLE): - foundKind.at(6) = true; + case (libcellml::Issue::Cause::VARIABLE): + foundCause.at(6) = true; break; - case libcellml::Issue::Kind::MATHML: - case libcellml::Issue::Kind::RESET: - case libcellml::Issue::Kind::UNDEFINED: - case libcellml::Issue::Kind::XML: - case libcellml::Issue::Kind::GENERATOR: + case libcellml::Issue::Cause::MATHML: + case libcellml::Issue::Cause::RESET: + case libcellml::Issue::Cause::UNDEFINED: + case libcellml::Issue::Cause::XML: + case libcellml::Issue::Cause::GENERATOR: break; } } @@ -1413,8 +1413,8 @@ TEST(Parser, invalidModelWithAllKindsOfErrors) libcellml::IssuePtr undefinedError = libcellml::Issue::create(); parser2->addIssue(undefinedError); EXPECT_EQ(size_t(1), parser2->issueCount()); - if (parser2->issue(0)->isKind(libcellml::Issue::Kind::UNDEFINED)) { - foundKind.at(7) = true; + if (parser2->issue(0)->isCause(libcellml::Issue::Cause::UNDEFINED)) { + foundCause.at(7) = true; } // Trigger an XML error @@ -1427,17 +1427,17 @@ TEST(Parser, invalidModelWithAllKindsOfErrors) parser3->parseModel(input3); EXPECT_EQ_ERRORS(expectedErrors3, parser3); for (size_t i = 0; i < parser3->issueCount(); ++i) { - if (parser3->issue(i)->isKind(libcellml::Issue::Kind::XML)) { - foundKind.at(8) = true; + if (parser3->issue(i)->isCause(libcellml::Issue::Cause::XML)) { + foundCause.at(8) = true; } } // Check that we've found all the possible issue types - bool foundAllKinds = false; - if (std::all_of(foundKind.begin(), foundKind.end(), [](bool i) { return i; })) { - foundAllKinds = true; + bool foundAllCauses = false; + if (std::all_of(foundCause.begin(), foundCause.end(), [](bool i) { return i; })) { + foundAllCauses = true; } - EXPECT_TRUE(foundAllKinds); + EXPECT_TRUE(foundAllCauses); } TEST(Parser, invalidModelWithTextInAllElements) diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp index 1b07362b7..82c68c346 100644 --- a/tests/test_utils.cpp +++ b/tests/test_utils.cpp @@ -49,7 +49,7 @@ void printErrors(const libcellml::LoggerPtr &l, bool headings, bool kinds, bool std::cout << ", " << l->issue(i)->specificationHeading(); } if (kinds) { - std::cout << ", " << static_cast(l->issue(i)->kind()); + std::cout << ", " << static_cast(l->issue(i)->cause()); } if (rule) { std::cout << ", " << static_cast(l->issue(i)->rule()); @@ -78,15 +78,15 @@ void expectEqualErrorsSpecificationHeadings(const std::vector &issu } } -void expectEqualErrorsKinds(const std::vector &issues, - const std::vector &kinds, +void expectEqualErrorsCauses(const std::vector &issues, + const std::vector &kinds, const libcellml::LoggerPtr &logger) { EXPECT_EQ(issues.size(), logger->issueCount()); EXPECT_EQ(kinds.size(), logger->issueCount()); for (size_t i = 0; i < logger->issueCount() && i < issues.size(); ++i) { EXPECT_EQ(issues.at(i), logger->issue(i)->description()); - EXPECT_EQ(kinds.at(i), logger->issue(i)->kind()); + EXPECT_EQ(kinds.at(i), logger->issue(i)->cause()); } } diff --git a/tests/test_utils.h b/tests/test_utils.h index a1a02973e..0266035cb 100644 --- a/tests/test_utils.h +++ b/tests/test_utils.h @@ -84,8 +84,8 @@ void TEST_EXPORT expectEqualErrors(const std::vector &issues, void TEST_EXPORT expectEqualErrorsSpecificationHeadings(const std::vector &issues, const std::vector &specificationHeadings, const libcellml::LoggerPtr &logger); -void TEST_EXPORT expectEqualErrorsKinds(const std::vector &issues, - const std::vector &kinds, +void TEST_EXPORT expectEqualErrorsCauses(const std::vector &issues, + const std::vector &kinds, const libcellml::LoggerPtr &logger); libcellml::ModelPtr TEST_EXPORT createModel(const std::string &name = ""); @@ -103,4 +103,4 @@ libcellml::ModelPtr TEST_EXPORT createModelTwoComponentsWithOneVariableEach(cons #define EXPECT_EQ_ERRORS_KINDS(issues, kinds, logger) \ SCOPED_TRACE("Issue occured here."); \ - expectEqualErrorsKinds(issues, kinds, logger) + expectEqualErrorsCauses(issues, kinds, logger) From 58f44d899484843e3b9b1dcac30cc894ebc4eef7 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 15 Jan 2020 12:04:46 +0100 Subject: [PATCH 04/88] Updated docstrings --- src/bindings/interface/issue.i | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/bindings/interface/issue.i b/src/bindings/interface/issue.i index 6a0aefde1..135da30ee 100644 --- a/src/bindings/interface/issue.i +++ b/src/bindings/interface/issue.i @@ -16,15 +16,15 @@ %feature("docstring") libcellml::Issue::setDescription "Sets a string description for why this issue was raised."; -%feature("docstring") libcellml::Issue::kind -"Get the ``kind`` of this issue. If no kind has been set for this issue, will +%feature("docstring") libcellml::Issue::cause +"Get the ``cause`` of this issue. If no cause has been set for this issue, will return Cause::UNDEFINED."; %feature("docstring") libcellml::Issue::isCause -"Tests if this issue matches the given ``kind``."; +"Tests if this issue matches the given ``cause``."; %feature("docstring") libcellml::Issue::setCause -"Sets the ``kind`` of this issue."; +"Sets the ``cause`` of this issue."; %feature("docstring") libcellml::Issue::rule "Get the :class:`SpecificationRule` of this issue."; From 050a62b1207c76be2ea1b66080438c459c0830a1 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 15 Jan 2020 12:07:50 +0100 Subject: [PATCH 05/88] More subs cause for kind --- src/api/libcellml/issue.h | 22 +++++++++++----------- src/issue.cpp | 8 ++++---- tests/bindings/python/test_error.py | 12 ++++++------ tests/test_utils.cpp | 10 +++++----- tests/test_utils.h | 8 ++++---- 5 files changed, 30 insertions(+), 30 deletions(-) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 7c6ca2444..616579bdf 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -91,7 +91,7 @@ class LIBCELLML_EXPORT Issue /** * @brief The issue Cause enum class. * - * Enum to describe the kind of issue a given issue is. + * Enum to describe the cause of issue a given issue is. */ enum class Cause { @@ -140,19 +140,19 @@ class LIBCELLML_EXPORT Issue std::string description() const; /** - * @brief Set the kind of this issue. + * @brief Set the cause of this issue. * - * Set the @p kind of this issue from the options available in + * Set the @p cause of this issue from the options available in * @c Issue::Cause. * - * @param kind The @c Issue::Cause to set. + * @param cause The @c Issue::Cause to set. */ - void setCause(Cause kind); + void setCause(Cause cause); /** - * @brief Get the kind of this issue. + * @brief Get the cause of this issue. * - * Get the @c kind of this issue. If no kind has been set for + * Get the @c cause of this issue. If no cause has been set for * this issue, will return Cause::UNDEFINED. * * @return The @c Issue::Cause set for this issue. @@ -160,15 +160,15 @@ class LIBCELLML_EXPORT Issue Cause cause() const; /** - * @brief Check whether the kind of this issue matches the argument kind. + * @brief Check whether the cause of this issue matches the argument cause. * - * Return @c true if the @p kind matches the the @c Issue::Cause for this + * Return @c true if the @p cause matches the the @c Issue::Cause for this * issue and @c false otherwise. * - * @return @c true if the @p kind matches the the @c Issue::Cause for this + * @return @c true if the @p cause matches the the @c Issue::Cause for this * issue and @c false otherwise. */ - bool isCause(Cause kind) const; + bool isCause(Cause cause) const; /** * @brief Set the @c enum SpecificationRule of this issue. diff --git a/src/issue.cpp b/src/issue.cpp index 285288309..1e66db5b4 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -138,9 +138,9 @@ std::string Issue::description() const return mPimpl->mDescription; } -void Issue::setCause(Issue::Cause kind) +void Issue::setCause(Issue::Cause cause) { - mPimpl->mCause = kind; + mPimpl->mCause = cause; } Issue::Cause Issue::cause() const @@ -148,10 +148,10 @@ Issue::Cause Issue::cause() const return mPimpl->mCause; } -bool Issue::isCause(Cause kind) const +bool Issue::isCause(Cause cause) const { bool response = false; - if (mPimpl->mCause == kind) { + if (mPimpl->mCause == cause) { response = true; } return response; diff --git a/tests/bindings/python/test_error.py b/tests/bindings/python/test_error.py index 60775c690..fd59189da 100644 --- a/tests/bindings/python/test_error.py +++ b/tests/bindings/python/test_error.py @@ -42,7 +42,7 @@ def test_create_destroy(self): e7 = Issue(v) del(e7) - def test_kind_enum(self): + def test_cause_enum(self): from libcellml import Issue self.assertIsInstance(Issue.Cause.COMPONENT, int) @@ -152,14 +152,14 @@ def test_description(self): self.assertEqual(e.description(), d) del(d, e) - def test_set_kind(self): + def test_set_cause(self): from libcellml import Issue - # void setCause(Cause kind) + # void setCause(Cause cause) e = Issue() e.setCause(Issue.Cause.CONNECTION) - def test_kind(self): + def test_cause(self): from libcellml import Issue # Cause cause() @@ -168,10 +168,10 @@ def test_kind(self): e.setCause(Issue.Cause.MATHML) self.assertEqual(e.cause(), Issue.Cause.MATHML) - def test_is_kind(self): + def test_is_cause(self): from libcellml import Issue - # bool isCause(const Cause &kind) + # bool isCause(const Cause &cause) e = Issue() self.assertTrue(e.isCause(Issue.Cause.UNDEFINED)) self.assertFalse(e.isCause(Issue.Cause.MODEL)) diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp index 82c68c346..65c27895c 100644 --- a/tests/test_utils.cpp +++ b/tests/test_utils.cpp @@ -40,7 +40,7 @@ std::string fileContents(const std::string &fileName) return buffer.str(); } -void printErrors(const libcellml::LoggerPtr &l, bool headings, bool kinds, bool rule) +void printErrors(const libcellml::LoggerPtr &l, bool headings, bool causes, bool rule) { for (size_t i = 0; i < l->issueCount(); ++i) { std::cout << "Issue " << std::setw(3) << i + 1 << ": "; @@ -48,7 +48,7 @@ void printErrors(const libcellml::LoggerPtr &l, bool headings, bool kinds, bool if (headings) { std::cout << ", " << l->issue(i)->specificationHeading(); } - if (kinds) { + if (causes) { std::cout << ", " << static_cast(l->issue(i)->cause()); } if (rule) { @@ -79,14 +79,14 @@ void expectEqualErrorsSpecificationHeadings(const std::vector &issu } void expectEqualErrorsCauses(const std::vector &issues, - const std::vector &kinds, + const std::vector &causes, const libcellml::LoggerPtr &logger) { EXPECT_EQ(issues.size(), logger->issueCount()); - EXPECT_EQ(kinds.size(), logger->issueCount()); + EXPECT_EQ(causes.size(), logger->issueCount()); for (size_t i = 0; i < logger->issueCount() && i < issues.size(); ++i) { EXPECT_EQ(issues.at(i), logger->issue(i)->description()); - EXPECT_EQ(kinds.at(i), logger->issue(i)->cause()); + EXPECT_EQ(causes.at(i), logger->issue(i)->cause()); } } diff --git a/tests/test_utils.h b/tests/test_utils.h index 0266035cb..c0caed3c5 100644 --- a/tests/test_utils.h +++ b/tests/test_utils.h @@ -77,7 +77,7 @@ std::string TEST_EXPORT resourcePath(const std::string &resourceRelativePath = " std::string TEST_EXPORT fileContents(const std::string &fileName); -void TEST_EXPORT printErrors(const libcellml::LoggerPtr &l, bool headings = false, bool kinds = false, bool rule = false); +void TEST_EXPORT printErrors(const libcellml::LoggerPtr &l, bool headings = false, bool causes = false, bool rule = false); void TEST_EXPORT expectEqualErrors(const std::vector &issues, const libcellml::LoggerPtr &logger); @@ -85,7 +85,7 @@ void TEST_EXPORT expectEqualErrorsSpecificationHeadings(const std::vector &specificationHeadings, const libcellml::LoggerPtr &logger); void TEST_EXPORT expectEqualErrorsCauses(const std::vector &issues, - const std::vector &kinds, + const std::vector &causes, const libcellml::LoggerPtr &logger); libcellml::ModelPtr TEST_EXPORT createModel(const std::string &name = ""); @@ -101,6 +101,6 @@ libcellml::ModelPtr TEST_EXPORT createModelTwoComponentsWithOneVariableEach(cons SCOPED_TRACE("Issue occured here."); \ expectEqualErrorsSpecificationHeadings(issues, specificationHeadings, logger) -#define EXPECT_EQ_ERRORS_KINDS(issues, kinds, logger) \ +#define EXPECT_EQ_ERRORS_KINDS(issues, causes, logger) \ SCOPED_TRACE("Issue occured here."); \ - expectEqualErrorsCauses(issues, kinds, logger) + expectEqualErrorsCauses(issues, causes, logger) From 10ce5103ec65ff376d58715a5d6e30402a3d8b90 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 15 Jan 2020 13:01:26 +0100 Subject: [PATCH 06/88] Make clang_format happy --- tests/test_utils.cpp | 4 ++-- tests/test_utils.h | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp index 65c27895c..9f2b5b9fa 100644 --- a/tests/test_utils.cpp +++ b/tests/test_utils.cpp @@ -79,8 +79,8 @@ void expectEqualErrorsSpecificationHeadings(const std::vector &issu } void expectEqualErrorsCauses(const std::vector &issues, - const std::vector &causes, - const libcellml::LoggerPtr &logger) + const std::vector &causes, + const libcellml::LoggerPtr &logger) { EXPECT_EQ(issues.size(), logger->issueCount()); EXPECT_EQ(causes.size(), logger->issueCount()); diff --git a/tests/test_utils.h b/tests/test_utils.h index c0caed3c5..9f2370c6c 100644 --- a/tests/test_utils.h +++ b/tests/test_utils.h @@ -85,8 +85,8 @@ void TEST_EXPORT expectEqualErrorsSpecificationHeadings(const std::vector &specificationHeadings, const libcellml::LoggerPtr &logger); void TEST_EXPORT expectEqualErrorsCauses(const std::vector &issues, - const std::vector &causes, - const libcellml::LoggerPtr &logger); + const std::vector &causes, + const libcellml::LoggerPtr &logger); libcellml::ModelPtr TEST_EXPORT createModel(const std::string &name = ""); libcellml::ModelPtr TEST_EXPORT createModelWithComponent(const std::string &name = ""); From 297fc06b66ef6f48caeb1ed17bb55bef9863fb45 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 15 Jan 2020 13:01:51 +0100 Subject: [PATCH 07/88] Add set/get/is methods for level in issue --- src/api/libcellml/issue.h | 31 +++++++++++++++++++++++++++++++ src/issue.cpp | 19 +++++++++++++++++++ 2 files changed, 50 insertions(+) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 616579bdf..43206d9be 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -170,6 +170,37 @@ class LIBCELLML_EXPORT Issue */ bool isCause(Cause cause) const; + /** + * @brief Set the level of this issue. + * + * Set the @p level of this issue from the options available in + * @c Issue::Level. + * + * @param level The @c Issue::Level to set. + */ + void setLevel(Level level); + + /** + * @brief Get the level of this issue. + * + * Get the @c level of this issue. If no level has been set for + * this issue, will return Level::FATAL. + * + * @return The @c Issue::Level set for this issue. + */ + Level level() const; + + /** + * @brief Check whether the level of this issue matches the argument level. + * + * Return @c true if the @p level matches the the @c Issue::Level for this + * issue and @c false otherwise. + * + * @return @c true if the @p level matches the the @c Issue::Level for this + * issue and @c false otherwise. + */ + bool isLevel(Level level) const; + /** * @brief Set the @c enum SpecificationRule of this issue. * diff --git a/src/issue.cpp b/src/issue.cpp index 1e66db5b4..5ab7dd087 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -157,6 +157,25 @@ bool Issue::isCause(Cause cause) const return response; } +void Issue::setLevel(Issue::Level level) +{ + mPimpl->mLevel = level; +} + +Issue::Level Issue::level() const +{ + return mPimpl->mLevel; +} + +bool Issue::isLevel(Level level) const +{ + bool response = false; + if (mPimpl->mLevel == level) { + response = true; + } + return response; +} + void Issue::setRule(SpecificationRule rule) { mPimpl->mRule = rule; From 46d90136f9fab6480d26ba60c88c627550e64e94 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 15 Jan 2020 14:14:00 +0100 Subject: [PATCH 08/88] Changed back to allow current defaults to use Issue::error() --- src/api/libcellml/logger.h | 6 +- src/bindings/interface/issue.i | 10 ++ src/bindings/interface/logger.i | 12 +-- src/generator.cpp | 24 ++--- src/logger.cpp | 18 +++- src/parser.cpp | 132 ++++++++++++------------ src/validator.cpp | 104 ++++++++++--------- tests/bindings/python/test_generator.py | 12 +-- tests/bindings/python/test_parser.py | 10 +- tests/bindings/python/test_printer.py | 10 +- tests/bindings/python/test_validator.py | 10 +- tests/clone/clone.cpp | 2 +- tests/component/encapsulation.cpp | 2 +- tests/connection/connection.cpp | 10 +- tests/coverage/coverage.cpp | 4 +- tests/generator/generator.cpp | 116 ++++++++++----------- tests/isolated/generator.cpp | 4 +- tests/issue/issue.cpp | 60 +++++++++++ tests/parser/file_parser.cpp | 12 +-- tests/parser/libxml_user.cpp | 2 +- tests/parser/parser.cpp | 104 +++++++++---------- tests/printer/printer.cpp | 2 +- tests/resolve_imports/file_parser.cpp | 14 +-- tests/test_utils.cpp | 36 +++---- tests/units/units.cpp | 4 +- tests/validator/validator.cpp | 112 +++++++++++++------- tests/variable/variable.cpp | 2 +- 27 files changed, 481 insertions(+), 353 deletions(-) diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index 7fa3eace5..d942087bd 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -51,7 +51,7 @@ class LIBCELLML_EXPORT Logger * * @param issue The @c IssuePtr to add. */ - void addIssue(const IssuePtr &issue); + void addError(const IssuePtr &issue); /** * @brief Get the number of issues. @@ -60,7 +60,7 @@ class LIBCELLML_EXPORT Logger * * @return The number of issues. */ - size_t issueCount() const; + size_t errorCount() const; /** * @brief Get issue at the specified @p index. @@ -73,7 +73,7 @@ class LIBCELLML_EXPORT Logger * * @return A reference to the issue at the given index on success, @c nullptr otherwise. */ - IssuePtr issue(size_t index) const; + IssuePtr error(size_t index) const; protected: Logger(); /**< Constructor */ diff --git a/src/bindings/interface/issue.i b/src/bindings/interface/issue.i index 135da30ee..d60c477c7 100644 --- a/src/bindings/interface/issue.i +++ b/src/bindings/interface/issue.i @@ -26,6 +26,16 @@ return Cause::UNDEFINED."; %feature("docstring") libcellml::Issue::setCause "Sets the ``cause`` of this issue."; +%feature("docstring") libcellml::Issue::level +"Get the ``level`` of this issue. If no level has been set for this issue, will +return Level::ERROR."; + +%feature("docstring") libcellml::Issue::isLevel +"Tests if this issue matches the given ``level``."; + +%feature("docstring") libcellml::Issue::setLevel +"Sets the ``level`` of this issue."; + %feature("docstring") libcellml::Issue::rule "Get the :class:`SpecificationRule` of this issue."; diff --git a/src/bindings/interface/logger.i b/src/bindings/interface/logger.i index 215c78de0..229c77781 100644 --- a/src/bindings/interface/logger.i +++ b/src/bindings/interface/logger.i @@ -7,24 +7,24 @@ %feature("docstring") libcellml::Logger "Base class for all serialisable libCellML classes."; -%feature("docstring") libcellml::Logger::addIssue +%feature("docstring") libcellml::Logger::addError "Adds an issue to this logger."; %feature("docstring") libcellml::Logger::removeAllErrors "Clears all errors from this logger."; -%feature("docstring") libcellml::Logger::issue -"Returns the issue at the specified `index`."; +%feature("docstring") libcellml::Logger::error +"Returns the issue of level 'error' at the specified `index`."; -%feature("docstring") libcellml::Logger::issueCount +%feature("docstring") libcellml::Logger::errorCount "Returns the number of errors currently stored in the logger."; #if defined(SWIGPYTHON) // Treat negative size_t as invalid index (instead of unknown method) %extend libcellml::Logger { - IssuePtr issue(long index) { + IssuePtr error(long index) { if (index < 0) return nullptr; - return $self->issue(size_t(index)); + return $self->error(size_t(index)); } } #endif diff --git a/src/generator.cpp b/src/generator.cpp index e22bb39aa..3b343d580 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1056,7 +1056,7 @@ void Generator::GeneratorImpl::processNode(const XmlNodePtr &node, + "' is referenced in an equation, but it is not defined anywhere."); err->setCause(Issue::Cause::GENERATOR); - mGenerator->addIssue(err); + mGenerator->addError(err); } } else if (node->isMathmlElement("cn")) { if (mathmlChildCount(node) == 1) { @@ -1175,7 +1175,7 @@ void Generator::GeneratorImpl::processComponent(const ComponentPtr &component) + "' are equivalent and cannot therefore both be initialised."); err->setCause(Issue::Cause::GENERATOR); - mGenerator->addIssue(err); + mGenerator->addError(err); } } @@ -1222,7 +1222,7 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr + "' cannot be both a variable of integration and initialised."); err->setCause(Issue::Cause::GENERATOR); - mGenerator->addIssue(err); + mGenerator->addError(err); } else { mVoi = variable; } @@ -1243,7 +1243,7 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr + "' cannot both be a variable of integration."); err->setCause(Issue::Cause::GENERATOR); - mGenerator->addIssue(err); + mGenerator->addError(err); } } @@ -1265,7 +1265,7 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr + "' must be of the first order."); err->setCause(Issue::Cause::GENERATOR); - mGenerator->addIssue(err); + mGenerator->addError(err); } } @@ -1366,7 +1366,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) // Process our different equations' AST to determine the type of our // variables. - if (mGenerator->issueCount() == 0) { + if (mGenerator->errorCount() == 0) { for (const auto &equation : mEquations) { processEquationAst(equation->mAst); } @@ -1376,7 +1376,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) // then loop over our equations, checking which variables, if any, can be // determined using a given equation. - if (mGenerator->issueCount() == 0) { + if (mGenerator->errorCount() == 0) { mInternalVariables.sort(compareVariablesByName); size_t variableIndex = MAX_SIZE_T; @@ -1408,7 +1408,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) // Make sure that our variables are valid. - if (mGenerator->issueCount() == 0) { + if (mGenerator->errorCount() == 0) { for (const auto &internalVariable : mInternalVariables) { std::string errorType; @@ -1445,7 +1445,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) + "' of model '" + realModel->name() + "' " + errorType + "."); err->setCause(Issue::Cause::GENERATOR); - mGenerator->addIssue(err); + mGenerator->addError(err); } } } @@ -3426,12 +3426,12 @@ void Generator::processModel(const ModelPtr &model) validator->validateModel(model); - if (validator->issueCount() > 0) { + if (validator->errorCount() > 0) { // The model is not valid, so retrieve the validation issues and make // them our own. - for (size_t i = 0; i < validator->issueCount(); ++i) { - addIssue(validator->issue(i)); + for (size_t i = 0; i < validator->errorCount(); ++i) { + addError(validator->error(i)); } return; diff --git a/src/logger.cpp b/src/logger.cpp index 517bb52ad..bb65aa93b 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -49,17 +49,17 @@ void Logger::removeAllErrors() mPimpl->mErrors.clear(); } -void Logger::addIssue(const IssuePtr &issue) +void Logger::addError(const IssuePtr &issue) { mPimpl->mErrors.push_back(issue); } -size_t Logger::issueCount() const +size_t Logger::errorCount() const { return mPimpl->mErrors.size(); } -IssuePtr Logger::issue(size_t index) const +IssuePtr Logger::error(size_t index) const { IssuePtr err = nullptr; if (index < mPimpl->mErrors.size()) { @@ -68,4 +68,16 @@ IssuePtr Logger::issue(size_t index) const return err; } + + +// IssuePtr Logger::error(size_t index) const +// { +// IssuePtr err = nullptr; +// if (index < mPimpl->mIssues.size()) { +// err = mPimpl->mErrors.at(index); +// } +// return err; +// } + + } // namespace libcellml diff --git a/src/parser.cpp b/src/parser.cpp index 7d6286711..f36b52884 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -237,7 +237,7 @@ ModelPtr Parser::parseModel(const std::string &input) err->setDescription("Model is empty."); err->setCause(Issue::Cause::XML); err->setModel(model); - addIssue(err); + addError(err); } else { mPimpl->updateModel(model, input); } @@ -259,7 +259,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr err = Issue::create(); err->setDescription("LibXml2 error: " + doc->xmlError(i)); err->setCause(Issue::Cause::XML); - mParser->addIssue(err); + mParser->addError(err); } } const XmlNodePtr node = doc->rootNode(); @@ -267,7 +267,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr err = Issue::create(); err->setDescription("Could not get a valid XML root node from the provided input."); err->setCause(Issue::Cause::XML); - mParser->addIssue(err); + mParser->addError(err); return; } if (!node->isCellmlElement("model")) { @@ -283,7 +283,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp } err->setModel(model); err->setRule(SpecificationRule::MODEL_ELEMENT); - mParser->addIssue(err); + mParser->addError(err); return; } // Get model attributes. @@ -297,7 +297,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr err = Issue::create(); err->setDescription("Model '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); err->setModel(model); - mParser->addIssue(err); + mParser->addError(err); } attribute = attribute->next(); } @@ -330,7 +330,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid attribute '" + childAttribute->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addIssue(err); + mParser->addError(err); } childAttribute = childAttribute->next(); } @@ -348,7 +348,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::ENCAPSULATION_COMPONENT_REF); - mParser->addIssue(err); + mParser->addError(err); } } else if (childNode->isCellmlElement("connection")) { connectionNodes.push_back(childNode); @@ -360,7 +360,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setDescription("Model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); err->setRule(SpecificationRule::MODEL_CHILD); - mParser->addIssue(err); + mParser->addError(err); } } else if (childNode->isComment()) { // Do nothing. @@ -369,7 +369,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setDescription("Model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setModel(model); err->setRule(SpecificationRule::MODEL_CHILD); - mParser->addIssue(err); + mParser->addError(err); } childNode = childNode->next(); } @@ -382,7 +382,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); - mParser->addIssue(err); + mParser->addError(err); } } for (const auto &connectionNode : connectionNodes) { @@ -493,7 +493,7 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN IssuePtr err = Issue::create(); err->setDescription("Component '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); err->setComponent(component); - mParser->addIssue(err); + mParser->addError(err); } attribute = attribute->next(); } @@ -529,7 +529,7 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN err->setDescription("Component '" + component->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setComponent(component); err->setRule(SpecificationRule::COMPONENT_CHILD); - mParser->addIssue(err); + mParser->addError(err); } } else if (childNode->isComment()) { // Do nothing. @@ -538,7 +538,7 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN err->setDescription("Component '" + component->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setComponent(component); err->setRule(SpecificationRule::COMPONENT_CHILD); - mParser->addIssue(err); + mParser->addError(err); } childNode = childNode->next(); } @@ -556,7 +556,7 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node IssuePtr err = Issue::create(); err->setDescription("Units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); err->setUnits(units); - mParser->addIssue(err); + mParser->addError(err); } attribute = attribute->next(); } @@ -572,7 +572,7 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node err->setDescription("Units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setUnits(units); err->setRule(SpecificationRule::UNITS_CHILD); - mParser->addIssue(err); + mParser->addError(err); } } else if (childNode->isComment()) { // Do nothing. @@ -581,7 +581,7 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node err->setDescription("Units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setUnits(units); err->setRule(SpecificationRule::UNITS_CHILD); - mParser->addIssue(err); + mParser->addError(err); } childNode = childNode->next(); } @@ -604,7 +604,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr err = Issue::create(); err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setUnits(units); - mParser->addIssue(err); + mParser->addError(err); } } else if (childNode->isComment()) { // Do nothing. @@ -612,7 +612,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr err = Issue::create(); err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setUnits(units); - mParser->addIssue(err); + mParser->addError(err); } childNode = childNode->next(); } @@ -632,7 +632,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an exponent with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_EXPONENT); - mParser->addIssue(err); + mParser->addError(err); } } else if (attribute->isType("multiplier")) { if (isCellMLReal(attribute->value())) { @@ -643,7 +643,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has a multiplier with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_MULTIPLIER); - mParser->addIssue(err); + mParser->addError(err); } } else if (attribute->isType("id")) { id = attribute->value(); @@ -652,7 +652,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_OPTIONAL_ATTRIBUTE); - mParser->addIssue(err); + mParser->addError(err); } attribute = attribute->next(); } @@ -672,7 +672,7 @@ void Parser::ParserImpl::loadVariable(const VariablePtr &variable, const XmlNode IssuePtr err = Issue::create(); err->setDescription("Variable '" + node->attribute("name") + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setVariable(variable); - mParser->addIssue(err); + mParser->addError(err); } } else if (childNode->isComment()) { // Do nothing. @@ -680,7 +680,7 @@ void Parser::ParserImpl::loadVariable(const VariablePtr &variable, const XmlNode IssuePtr err = Issue::create(); err->setDescription("Variable '" + node->attribute("name") + "' has an invalid child element '" + childNode->name() + "'."); err->setVariable(variable); - mParser->addIssue(err); + mParser->addError(err); } childNode = childNode->next(); } @@ -700,7 +700,7 @@ void Parser::ParserImpl::loadVariable(const VariablePtr &variable, const XmlNode IssuePtr err = Issue::create(); err->setDescription("Variable '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); err->setVariable(variable); - mParser->addIssue(err); + mParser->addError(err); } attribute = attribute->next(); } @@ -740,7 +740,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' has an invalid connection attribute '" + attribute->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mParser->addIssue(err); + mParser->addError(err); } attribute = attribute->next(); } @@ -751,7 +751,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT1); - mParser->addIssue(err); + mParser->addError(err); component1Missing = true; } if (component2Name.empty()) { @@ -760,7 +760,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT2); - mParser->addIssue(err); + mParser->addError(err); component2Missing = true; } componentNamePair = std::make_pair(component1Name, component2Name); @@ -774,7 +774,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_MAP_VARIABLES); - mParser->addIssue(err); + mParser->addError(err); return; } @@ -791,7 +791,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mParser->addIssue(err); + mParser->addError(err); } } else if (grandchildNode->isComment()) { // Do nothing. @@ -800,7 +800,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' has an invalid child element '" + grandchildNode->name() + "' of element '" + childNode->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mParser->addIssue(err); + mParser->addError(err); } grandchildNode = grandchildNode->next(); } @@ -821,7 +821,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' has an invalid map_variables attribute '" + childAttribute->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mParser->addIssue(err); + mParser->addError(err); } childAttribute = childAttribute->next(); } @@ -832,7 +832,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); - mParser->addIssue(err); + mParser->addError(err); variable1Missing = true; } if (variable2Name.empty()) { @@ -841,7 +841,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); - mParser->addIssue(err); + mParser->addError(err); variable2Missing = true; } // We can have multiple map_variables per connection. @@ -857,7 +857,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mParser->addIssue(err); + mParser->addError(err); } } else if (childNode->isComment()) { // Do nothing. @@ -866,7 +866,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mParser->addIssue(err); + mParser->addError(err); } childNode = childNode->next(); @@ -885,7 +885,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT1); - mParser->addIssue(err); + mParser->addError(err); } } if (model->containsComponent(componentNamePair.second)) { @@ -897,7 +897,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT2); - mParser->addIssue(err); + mParser->addError(err); } } @@ -921,7 +921,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setComponent(component1); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); - mParser->addIssue(err); + mParser->addError(err); } } } else { @@ -930,7 +930,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); - mParser->addIssue(err); + mParser->addError(err); } if (component2) { if (component2->hasVariable(iterPair.second)) { @@ -947,7 +947,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setComponent(component1); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); - mParser->addIssue(err); + mParser->addError(err); } } } else { @@ -956,7 +956,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); - mParser->addIssue(err); + mParser->addError(err); } // Set the variable equivalence relationship for this variable pair. if ((variable1) && (variable2)) { @@ -969,7 +969,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_MAP_VARIABLES); - mParser->addIssue(err); + mParser->addError(err); } } @@ -992,7 +992,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); - mParser->addIssue(err); + mParser->addError(err); } } else if (attribute->isType("id")) { encapsulationId = attribute->value(); @@ -1002,7 +1002,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); - mParser->addIssue(err); + mParser->addError(err); } attribute = attribute->next(); } @@ -1012,7 +1012,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); - mParser->addIssue(err); + mParser->addError(err); } else if (parentComponent) { parentComponent->setEncapsulationId(encapsulationId); } @@ -1034,7 +1034,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addIssue(err); + mParser->addError(err); } } else if (childComponentNode->isComment()) { // Do nothing. @@ -1043,7 +1043,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + childComponentNode->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addIssue(err); + mParser->addError(err); } if ((parentComponent) && (childComponent)) { @@ -1075,7 +1075,7 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_CHILD); - mParser->addIssue(err); + mParser->addError(err); } else { // Continue to next node if this is whitespace (don't try to parse children of whitespace). componentRefNode = componentRefNode->next(); @@ -1089,7 +1089,7 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::ENCAPSULATION_COMPONENT_REF); - mParser->addIssue(err); + mParser->addError(err); } // Add the parentComponent to the model with its child(ren) encapsulated. @@ -1100,14 +1100,14 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP err->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponent->name() + "' as a parent component_ref but it does not have any children."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addIssue(err); + mParser->addError(err); } } else if (!parentComponent && haveComponentRef) { IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' specifies an invalid parent component_ref that also does not have any children."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addIssue(err); + mParser->addError(err); } componentRefNode = componentRefNode->next(); @@ -1128,7 +1128,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M IssuePtr err = Issue::create(); err->setDescription("Import from '" + node->attribute("href") + "' has an invalid attribute '" + attribute->name() + "'."); err->setImportSource(importSource); - mParser->addIssue(err); + mParser->addError(err); } attribute = attribute->next(); } @@ -1149,7 +1149,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M IssuePtr err = Issue::create(); err->setDescription("Import of component '" + childNode->attribute("name") + "' from '" + node->attribute("href") + "' has an invalid attribute '" + childAttribute->name() + "'."); err->setImportSource(importSource); - mParser->addIssue(err); + mParser->addError(err); errorOccurred = true; } childAttribute = childAttribute->next(); @@ -1172,7 +1172,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M IssuePtr err = Issue::create(); err->setDescription("Import of units '" + childNode->attribute("name") + "' from '" + node->attribute("href") + "' has an invalid attribute '" + childAttribute->name() + "'."); err->setImportSource(importSource); - mParser->addIssue(err); + mParser->addError(err); errorOccurred = true; } childAttribute = childAttribute->next(); @@ -1188,7 +1188,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M err->setDescription("Import from '" + node->attribute("href") + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setImportSource(importSource); err->setRule(SpecificationRule::IMPORT_CHILD); - mParser->addIssue(err); + mParser->addError(err); } } else if (childNode->isComment()) { // Do nothing. @@ -1197,7 +1197,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M err->setDescription("Import from '" + node->attribute("href") + "' has an invalid child element '" + childNode->name() + "'."); err->setImportSource(importSource); err->setRule(SpecificationRule::IMPORT_CHILD); - mParser->addIssue(err); + mParser->addError(err); } childNode = childNode->next(); } @@ -1230,7 +1230,7 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' has an unexpected attribute in the " + childType + " block of '" + childAttribute->name() + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mParser->addIssue(err); + mParser->addError(err); } childAttribute = childAttribute->next(); } @@ -1254,7 +1254,7 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese err->setDescription("The " + childType + " in the reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' should have a MathML block as a child."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mParser->addIssue(err); + mParser->addError(err); } } mathNode = mathNode->next(); @@ -1280,7 +1280,7 @@ void Parser::ParserImpl::checkResetChildMultiplicity(size_t count, const std::st + variableName + "' and test_variable '" + testVariableName + "' has " + convertToString(count) + " " + childType + " blocks."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mParser->addIssue(err); + mParser->addError(err); } if (count == 0) { IssuePtr err = Issue::create(); @@ -1288,7 +1288,7 @@ void Parser::ParserImpl::checkResetChildMultiplicity(size_t count, const std::st + variableName + "' and test_variable '" + testVariableName + "' does not have a " + childType + " block defined."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mParser->addIssue(err); + mParser->addError(err); } } @@ -1314,7 +1314,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co err->setDescription("Reset referencing variable '" + variableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_VARIABLE_REFERENCE); - mParser->addIssue(err); + mParser->addError(err); } else { reset->setVariable(referencedVariable); } @@ -1327,7 +1327,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co err->setDescription("Reset referencing test_variable '" + testVariableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); - mParser->addIssue(err); + mParser->addError(err); } else { reset->setTestVariable(testVariable); } @@ -1344,7 +1344,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' has a non-integer order value '" + attribute->value() + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_ORDER); - mParser->addIssue(err); + mParser->addError(err); } } else if (attribute->isType("id")) { reset->setId(attribute->value()); @@ -1352,7 +1352,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr err = Issue::create(); err->setDescription("Reset in component '" + component->name() + "' has an invalid attribute '" + attribute->name() + "'."); err->setReset(reset); - mParser->addIssue(err); + mParser->addError(err); } attribute = attribute->next(); } @@ -1364,7 +1364,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co err->setDescription("Reset in component '" + component->name() + "' does not have its order set."); err->setReset(reset); err->setRule(SpecificationRule::RESET_ORDER); - mParser->addIssue(err); + mParser->addError(err); } XmlNodePtr childNode = node->firstChild(); @@ -1386,7 +1386,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co err->setDescription("Reset has an invalid non-whitespace child text element '" + textNode + "'. Either a test_value block or a reset_value block is expected."); err->setReset(reset); err->setRule(SpecificationRule::RESET_CHILD); - mParser->addIssue(err); + mParser->addError(err); } } else if (childNode->isComment()) { // Do nothing. diff --git a/src/validator.cpp b/src/validator.cpp index 9052476e4..2bed06631 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -286,7 +286,7 @@ void Validator::validateModel(const ModelPtr &model) err->setDescription("Model does not have a valid name attribute."); err->setModel(model); err->setRule(SpecificationRule::MODEL_NAME); - addIssue(err); + addError(err); } // Check for components in this model. if (model->componentCount() > 0) { @@ -315,7 +315,7 @@ void Validator::validateModel(const ModelPtr &model) err->setDescription("Imported units '" + unitsName + "' does not have a valid units_ref attribute."); err->setUnits(units); err->setRule(SpecificationRule::IMPORT_UNITS_REF); - addIssue(err); + addError(err); foundImportError = true; } // Check for a xlink:href. @@ -325,7 +325,7 @@ void Validator::validateModel(const ModelPtr &model) err->setDescription("Import of units '" + unitsName + "' does not have a valid locator xlink:href attribute."); err->setImportSource(units->importSource()); err->setRule(SpecificationRule::IMPORT_HREF); - addIssue(err); + addError(err); foundImportError = true; } // Check if we already have another import from the same source with the same units_ref. @@ -337,7 +337,7 @@ void Validator::validateModel(const ModelPtr &model) err->setDescription("Model '" + model->name() + "' contains multiple imported units from '" + importSource + "' with the same units_ref attribute '" + unitsRef + "'."); err->setModel(model); err->setRule(SpecificationRule::IMPORT_UNITS_REF); - addIssue(err); + addError(err); } } // Push back the unique sources and refs. @@ -350,7 +350,7 @@ void Validator::validateModel(const ModelPtr &model) err->setDescription("Model '" + model->name() + "' contains multiple units with the name '" + unitsName + "'. Valid units names must be unique to their model."); err->setModel(model); err->setRule(SpecificationRule::UNITS_NAME_UNIQUE); - addIssue(err); + addError(err); } unitsNames.push_back(unitsName); } @@ -378,7 +378,7 @@ void Validator::ValidatorImpl::validateUniqueName(const ModelPtr &model, const s IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' contains multiple components with the name '" + name + "'. Valid component names must be unique to their model."); err->setModel(model); - mValidator->addIssue(err); + mValidator->addError(err); } else { names.push_back(name); } @@ -406,7 +406,7 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com err->setComponent(component); err->setDescription("Imported component does not have a valid name attribute."); err->setRule(SpecificationRule::IMPORT_COMPONENT_NAME); - mValidator->addIssue(err); + mValidator->addError(err); } // Check for a component_ref; assumes imported if the import source is not null. @@ -419,14 +419,14 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com err->setDescription("Imported component '" + componentName + "' does not have a valid component_ref attribute."); err->setComponent(component); err->setRule(SpecificationRule::IMPORT_COMPONENT_REF); - mValidator->addIssue(err); + mValidator->addError(err); } if (importSource.empty()) { IssuePtr err = Issue::create(); err->setDescription("Import of component '" + componentName + "' does not have a valid locator xlink:href attribute."); err->setImportSource(component->importSource()); err->setRule(SpecificationRule::IMPORT_HREF); - mValidator->addIssue(err); + mValidator->addError(err); } else { xmlURIPtr uri = xmlParseURI(importSource.c_str()); if (uri == nullptr) { @@ -434,7 +434,7 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com err->setDescription("Import of component '" + componentName + "' has an invalid URI in the href attribute."); err->setImportSource(component->importSource()); err->setRule(SpecificationRule::IMPORT_HREF); - mValidator->addIssue(err); + mValidator->addError(err); } else { xmlFreeURI(uri); @@ -450,7 +450,7 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) err->setComponent(component); err->setDescription("Component does not have a valid name attribute."); err->setRule(SpecificationRule::COMPONENT_NAME); - mValidator->addIssue(err); + mValidator->addError(err); } // Check for variables in this component. std::vector variableNames; @@ -465,7 +465,7 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) err->setDescription("Component '" + component->name() + "' contains multiple variables with the name '" + variableName + "'. Valid variable names must be unique to their component."); err->setComponent(component); err->setRule(SpecificationRule::VARIABLE_NAME); - mValidator->addIssue(err); + mValidator->addError(err); } variableNames.push_back(variableName); } @@ -501,7 +501,7 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v err->setDescription("Units does not have a valid name attribute."); err->setRule(SpecificationRule::UNITS_NAME); } - mValidator->addIssue(err); + mValidator->addError(err); } else { // Check for a matching standard units. if (isStandardUnitName(units->name())) { @@ -509,7 +509,7 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v err->setDescription("Units is named '" + units->name() + "' which is a protected standard unit name."); err->setUnits(units); err->setRule(SpecificationRule::UNITS_STANDARD); - mValidator->addIssue(err); + mValidator->addError(err); } } if (units->unitCount() > 0) { @@ -535,14 +535,14 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u err->setDescription("Units reference '" + reference + "' in units '" + units->name() + "' is not a valid reference to a local units or a standard unit type."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_UNITS_REF); - mValidator->addIssue(err); + mValidator->addError(err); } } else { IssuePtr err = Issue::create(); err->setDescription("Unit in units '" + units->name() + "' does not have a valid units reference."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_UNITS_REF); - mValidator->addIssue(err); + mValidator->addError(err); } if (!prefix.empty()) { if (!isStandardPrefixName(prefix)) { @@ -551,7 +551,7 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u err->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is not a valid integer or an SI prefix."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_PREFIX); - mValidator->addIssue(err); + mValidator->addError(err); } else { try { int test = std::stoi(prefix); @@ -561,7 +561,7 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u err->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is out of the integer range."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_PREFIX); - mValidator->addIssue(err); + mValidator->addError(err); } } } @@ -576,7 +576,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con err->setDescription("Variable does not have a valid name attribute."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_NAME); - mValidator->addIssue(err); + mValidator->addError(err); } // Check for a valid units attribute. std::string unitsName = variable->units() != nullptr ? variable->units()->name() : ""; @@ -585,7 +585,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con err->setDescription("Variable '" + variable->name() + "' does not have a valid units attribute."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_UNITS); - mValidator->addIssue(err); + mValidator->addError(err); } else if (!isStandardUnitName(unitsName)) { ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); ModelPtr model = owningModel(component); @@ -594,7 +594,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con err->setDescription("Variable '" + variable->name() + "' has a units reference '" + unitsName + "' that does not correspond with a standard units and is not a units defined in the variable's model."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_UNITS); - mValidator->addIssue(err); + mValidator->addError(err); } } // Check for a valid interface attribute. @@ -605,7 +605,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con err->setDescription("Variable '" + variable->name() + "' has an invalid interface attribute value '" + interfaceType + "'."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_INTERFACE); - mValidator->addIssue(err); + mValidator->addError(err); } } // Check for a valid initial value attribute. @@ -619,7 +619,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con err->setDescription("Variable '" + variable->name() + "' has an invalid initial value '" + initialValue + "'. Initial values must be a real number string or a variable reference."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_INITIAL_VALUE); - mValidator->addIssue(err); + mValidator->addError(err); } } } @@ -690,49 +690,49 @@ void Validator::ValidatorImpl::validateReset(const ResetPtr &reset, const Compon err->setDescription(description + "does not have an order set."); err->setComponent(component); err->setRule(SpecificationRule::RESET_ORDER); - mValidator->addIssue(err); + mValidator->addError(err); } if (noVariable) { IssuePtr err = Issue::create(); err->setDescription(description + "does not reference a variable."); err->setReset(reset); err->setRule(SpecificationRule::RESET_VARIABLE_REFERENCE); - mValidator->addIssue(err); + mValidator->addError(err); } if (noTestVariable) { IssuePtr err = Issue::create(); err->setDescription(description + "does not reference a test_variable."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); - mValidator->addIssue(err); + mValidator->addError(err); } if (noTestValue) { IssuePtr err = Issue::create(); err->setDescription(description + "does not have a test_value specified."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mValidator->addIssue(err); + mValidator->addError(err); } if (noResetValue) { IssuePtr err = Issue::create(); err->setDescription(description + "does not have a reset_value specified."); err->setReset(reset); err->setRule(SpecificationRule::RESET_RESET_VALUE); - mValidator->addIssue(err); + mValidator->addError(err); } if (varOutsideComponent) { IssuePtr err = Issue::create(); err->setDescription(description + "refers to a variable '" + reset->variable()->name() + "' in a different component '" + varParentName + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_VARIABLE_REFERENCE); - mValidator->addIssue(err); + mValidator->addError(err); } if (testVarOutsideComponent) { IssuePtr err = Issue::create(); err->setDescription(description + "refers to a test_variable '" + reset->testVariable()->name() + "' in a different component '" + testVarParentName + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); - mValidator->addIssue(err); + mValidator->addError(err); } } @@ -747,7 +747,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp IssuePtr err = Issue::create(); err->setDescription("LibXml2 error: " + doc->xmlError(i)); err->setCause(Issue::Cause::XML); - mValidator->addIssue(err); + mValidator->addError(err); } } XmlNodePtr node = doc->rootNode(); @@ -756,7 +756,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp err->setDescription("Could not get a valid XML root node from the math on component '" + component->name() + "'."); err->setCause(Issue::Cause::XML); err->setComponent(component); - mValidator->addIssue(err); + mValidator->addError(err); return; } if (!node->isMathmlElement("math")) { @@ -764,7 +764,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp err->setDescription("Math root node is of invalid type '" + node->name() + "' on component '" + component->name() + "'. A valid math root node should be of type 'math'."); err->setComponent(component); err->setCause(Issue::Cause::XML); - mValidator->addIssue(err); + mValidator->addError(err); return; } @@ -801,7 +801,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp err->setDescription("W3C MathML DTD error: " + mathmlDoc->xmlError(i)); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + mValidator->addError(err); } } } @@ -816,7 +816,7 @@ bool Validator::ValidatorImpl::validateCnUnits(const ComponentPtr &component, co err->setDescription("Math cn element with the value '" + textNode + "' does not have a valid cellml:units attribute."); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + mValidator->addError(err); return false; } @@ -850,7 +850,7 @@ void Validator::ValidatorImpl::validateAndCleanCnNode(const XmlNodePtr &node, co err->setDescription("Math " + node->name() + " element has an invalid attribute type '" + attribute->name() + "' in the cellml namespace. Attribute 'units' is the only CellML namespace attribute allowed."); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + mValidator->addError(err); } } attribute = attribute->next(); @@ -872,7 +872,7 @@ void Validator::ValidatorImpl::validateAndCleanCnNode(const XmlNodePtr &node, co err->setDescription("Math has a " + node->name() + " element with a cellml:units attribute '" + unitsName + "' that is not a valid reference to units in the model '" + model->name() + "' or a standard unit."); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + mValidator->addError(err); } } } @@ -898,7 +898,7 @@ void Validator::ValidatorImpl::validateAndCleanCiNode(const XmlNodePtr &node, co err->setDescription("MathML ci element has the child text '" + textInNode + "' which does not correspond with any variable names present in component '" + component->name() + "'."); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + mValidator->addError(err); } } } @@ -931,7 +931,7 @@ void Validator::ValidatorImpl::validateMathMLElements(const XmlNodePtr &node, co err->setDescription("Math has a '" + childNode->name() + "' element that is not a supported MathML element."); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + mValidator->addError(err); } validateMathMLElements(childNode, component); } @@ -943,7 +943,7 @@ void Validator::ValidatorImpl::validateMathMLElements(const XmlNodePtr &node, co err->setDescription("Math has a '" + nextNode->name() + "' element that is not a supported MathML element."); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + mValidator->addError(err); } validateMathMLElements(nextNode, component); } @@ -984,8 +984,19 @@ void Validator::ValidatorImpl::validateConnections(const ModelPtr &model) err->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); err->setModel(model); err->setCause(Issue::Cause::UNITS); - mValidator->addIssue(err); + mValidator->addError(err); } + // } else if (multiplier != 0.0) { + // // KRM Warning when the multipliers are not the same. + // auto unitsName = variable->units() == nullptr ? "" : variable->units()->name(); + // auto equivalentUnitsName = equivalentVariable->units() == nullptr ? "" : equivalentVariable->units()->name(); + // IssuePtr err = Issue::create(); + // err->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); + // err->setModel(model); + // err->setLevel(libcellml::Issue::Level::WARNING); + // err->setCause(Issue::Cause::UNITS); + // mValidator->addError(err); + // } if (equivalentVariable->hasEquivalentVariable(variable)) { // Check that the equivalent variable has a valid parent component. @@ -995,7 +1006,7 @@ void Validator::ValidatorImpl::validateConnections(const ModelPtr &model) err->setDescription("Variable '" + equivalentVariable->name() + "' is an equivalent variable to '" + variable->name() + "' but '" + equivalentVariable->name() + "' has no parent component."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mValidator->addIssue(err); + mValidator->addError(err); } } } @@ -1023,7 +1034,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) IssuePtr err = Issue::create(); err->setDescription("CellML identifiers must not begin with a European numeric character [0-9]."); err->setRule(SpecificationRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); - mValidator->addIssue(err); + mValidator->addError(err); } else { // Basic Latin alphanumeric characters and underscores. if (name.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_") != std::string::npos) { @@ -1031,7 +1042,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) IssuePtr err = Issue::create(); err->setDescription("CellML identifiers must not contain any characters other than [a-zA-Z0-9_]."); err->setRule(SpecificationRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); - mValidator->addIssue(err); + mValidator->addError(err); } } } else { @@ -1039,7 +1050,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) IssuePtr err = Issue::create(); err->setDescription("CellML identifiers must contain one or more basic Latin alphabetic characters."); err->setRule(SpecificationRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); - mValidator->addIssue(err); + mValidator->addError(err); } return result; } @@ -1105,6 +1116,7 @@ bool Validator::ValidatorImpl::unitsAreEquivalent(const ModelPtr &model, if (multiplier != 0.0) { // NB: multiplication issues are only reported when there is a base issue mismatch too, does not trigger it alone. // The multiplication mismatch will be returned through the multiplier argument in all cases. + std::string num = std::to_string(multiplier); num.erase(num.find_last_not_of('0') + 1, num.length()); if (num.back() == '.') { @@ -1196,7 +1208,7 @@ void Validator::ValidatorImpl::validateNoUnitsAreCyclic(const ModelPtr &model) err->setDescription("Cyclic units exist: " + des); err->setModel(model); err->setCause(Issue::Cause::UNITS); - mValidator->addIssue(err); + mValidator->addError(err); reportedErrorList.push_back(hash); } std::map().swap(hash); diff --git a/tests/bindings/python/test_generator.py b/tests/bindings/python/test_generator.py index c967556a7..6ab5edc33 100644 --- a/tests/bindings/python/test_generator.py +++ b/tests/bindings/python/test_generator.py @@ -30,11 +30,11 @@ def test_inheritance(self): self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods - self.assertIsNone(x.issue(0)) - self.assertIsNone(x.issue(-1)) - self.assertEqual(x.issueCount(), 0) - x.addIssue(libcellml.Issue()) - self.assertEqual(x.issueCount(), 1) + self.assertIsNone(x.error(0)) + self.assertIsNone(x.error(-1)) + self.assertEqual(x.errorCount(), 0) + x.addError(libcellml.Issue()) + self.assertEqual(x.errorCount(), 1) def test_process_model(self): from libcellml import Generator @@ -45,7 +45,7 @@ def test_process_model(self): g.processModel(m) - self.assertEqual(0, g.issueCount()) + self.assertEqual(0, g.errorCount()) self.assertEqual(Generator.ModelType.UNKNOWN, g.modelType()) def test_algebraic_eqn_computed_var_on_rhs(self): diff --git a/tests/bindings/python/test_parser.py b/tests/bindings/python/test_parser.py index 8b521b70e..80a5df661 100644 --- a/tests/bindings/python/test_parser.py +++ b/tests/bindings/python/test_parser.py @@ -20,11 +20,11 @@ def test_inheritance(self): self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods - self.assertIsNone(x.issue(0)) - self.assertIsNone(x.issue(-1)) - self.assertEqual(x.issueCount(), 0) - x.addIssue(libcellml.Issue()) - self.assertEqual(x.issueCount(), 1) + self.assertIsNone(x.error(0)) + self.assertIsNone(x.error(-1)) + self.assertEqual(x.errorCount(), 0) + x.addError(libcellml.Issue()) + self.assertEqual(x.errorCount(), 1) def test_parse_model(self): import libcellml diff --git a/tests/bindings/python/test_printer.py b/tests/bindings/python/test_printer.py index e17443d28..05d9c4589 100644 --- a/tests/bindings/python/test_printer.py +++ b/tests/bindings/python/test_printer.py @@ -20,11 +20,11 @@ def test_inheritance(self): self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods - self.assertIsNone(x.issue(0)) - self.assertIsNone(x.issue(-1)) - self.assertEqual(x.issueCount(), 0) - x.addIssue(libcellml.Issue()) - self.assertEqual(x.issueCount(), 1) + self.assertIsNone(x.error(0)) + self.assertIsNone(x.error(-1)) + self.assertEqual(x.errorCount(), 0) + x.addError(libcellml.Issue()) + self.assertEqual(x.errorCount(), 1) def test_print_model(self): from libcellml import Printer, Model diff --git a/tests/bindings/python/test_validator.py b/tests/bindings/python/test_validator.py index b808c1fee..0701ee011 100644 --- a/tests/bindings/python/test_validator.py +++ b/tests/bindings/python/test_validator.py @@ -21,11 +21,11 @@ def test_inheritance(self): self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods - self.assertIsNone(x.issue(0)) - self.assertIsNone(x.issue(-1)) - self.assertEqual(x.issueCount(), 0) - x.addIssue(libcellml.Issue()) - self.assertEqual(x.issueCount(), 1) + self.assertIsNone(x.error(0)) + self.assertIsNone(x.error(-1)) + self.assertEqual(x.errorCount(), 0) + x.addError(libcellml.Issue()) + self.assertEqual(x.errorCount(), 1) def test_validate_model(self): import libcellml diff --git a/tests/clone/clone.cpp b/tests/clone/clone.cpp index 70c11a5bf..ce57a6c55 100644 --- a/tests/clone/clone.cpp +++ b/tests/clone/clone.cpp @@ -585,7 +585,7 @@ TEST(Clone, generateFromClonedModel) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); diff --git a/tests/component/encapsulation.cpp b/tests/component/encapsulation.cpp index 607ee3b9e..370d9fb6c 100644 --- a/tests/component/encapsulation.cpp +++ b/tests/component/encapsulation.cpp @@ -318,7 +318,7 @@ TEST(Encapsulation, parseAlternateFormHierarchy) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); EXPECT_EQ(size_t(1), model->componentCount()); auto component = model->component(0); for (size_t i = 0; i < 3; ++i) { diff --git a/tests/connection/connection.cpp b/tests/connection/connection.cpp index 0715c3156..0be275a3e 100644 --- a/tests/connection/connection.cpp +++ b/tests/connection/connection.cpp @@ -215,7 +215,7 @@ TEST(Connection, parseValidAlternateFormConnection) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); EXPECT_EQ(size_t(2), model->componentCount()); EXPECT_EQ(size_t(1), model->component("component1")->variable("variable1")->equivalentVariableCount()); } @@ -1089,7 +1089,7 @@ TEST(Connection, importedComponentConnectionAndParse) // Parse libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); a = printer->printModel(model); EXPECT_EQ(e, a); @@ -1126,11 +1126,11 @@ TEST(Connection, componentConnectionAndParseMissingVariable) // Parse libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(s); - EXPECT_EQ(size_t(1), parser->issueCount()); + EXPECT_EQ(size_t(1), parser->errorCount()); - EXPECT_EQ(expectError, parser->issue(0)->description()); + EXPECT_EQ(expectError, parser->error(0)->description()); parser->removeAllErrors(); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::PrinterPtr printer = libcellml::Printer::create(); const std::string a = printer->printModel(model); diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index 12211ed8c..ff3a3f995 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -40,7 +40,7 @@ TEST(Coverage, connectionComment) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(in); - EXPECT_EQ(size_t(4), p->issueCount()); + EXPECT_EQ(size_t(4), p->errorCount()); } TEST(Coverage, importWithNonHrefXlink) @@ -63,7 +63,7 @@ TEST(Coverage, importWithNonHrefXlink) // Parse libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); } TEST(Coverage, entityHasParent) diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index a98ed8807..7c4853254 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -29,7 +29,7 @@ TEST(Generator, emptyModel) generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::UNKNOWN, generator->modelType()); @@ -52,13 +52,13 @@ TEST(Generator, generatorErrors) generator->processModel(invalidModel); - EXPECT_EQ(size_t(1), generator->issueCount()); + EXPECT_EQ(size_t(1), generator->errorCount()); libcellml::ModelPtr emptyModel = libcellml::Model::create(); generator->processModel(emptyModel); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); } TEST(Generator, initializedVariableOfIntegration) @@ -66,7 +66,7 @@ TEST(Generator, initializedVariableOfIntegration) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/initialized_variable_of_integration.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); const std::vector expectedErrors = { "Variable 'time' in component 'my_component' of model 'initialized_variable_of_integration' cannot be both a variable of integration and initialised.", @@ -99,7 +99,7 @@ TEST(Generator, twoVariablesOfIntegration) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/two_variables_of_integration.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); const std::vector expectedErrors = { "Variable 'time' in component 'main' of model 'two_variables_of_integration' and variable 'other_time' in component 'sub_sub_sub' of model 'two_variables_of_integration' cannot both be a variable of integration.", @@ -132,7 +132,7 @@ TEST(Generator, nonFirstOrderOdes) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/non_first_order_odes.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); const std::vector expectedErrors = { "The differential equation for variable 'x' in component 'main' of model 'non_first_order_odes' must be of the first order.", @@ -169,7 +169,7 @@ TEST(Generator, undefinedVariables) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/undefined_variables.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); const std::vector expectedErrors = { "Variable 'a' in component 'my_component' of model 'undefined_variables' is referenced in an equation, but it is not defined anywhere.", @@ -200,7 +200,7 @@ TEST(Generator, variableInitializedTwice) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/variable_initialized_twice.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); const std::vector expectedErrors = { "Variable 'x' in component 'sub' of model 'variable_initialized_twice' and variable 'x' in component 'main' of model 'variable_initialized_twice' are equivalent and cannot therefore both be initialised.", @@ -230,7 +230,7 @@ TEST(Generator, nonInitializedState) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/non_initialized_state.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); const std::vector expectedErrors = { "Variable 'x' in component 'my_component' of model 'non_initialized_state' is used in an ODE, but it is not initialised.", @@ -260,7 +260,7 @@ TEST(Generator, underconstrained) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/underconstrained.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); const std::vector expectedErrors = { "Variable 'x' in component 'my_component' of model 'my_model' is not computed.", @@ -290,7 +290,7 @@ TEST(Generator, overconstrained) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/overconstrained.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); const std::vector expectedErrors = { "Variable 'x' in component 'my_component' of model 'my_model' is computed more than once.", @@ -320,7 +320,7 @@ TEST(Generator, unsuitablyConstrained) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/unsuitably_constrained.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); const std::vector expectedErrors = { "Variable 'x' in component 'my_component' of model 'my_model' is not computed.", @@ -351,13 +351,13 @@ TEST(Generator, algebraicEqnComputedVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_computed_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ALGEBRAIC, generator->modelType()); @@ -385,13 +385,13 @@ TEST(Generator, algebraicEqnConstVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_const_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ALGEBRAIC, generator->modelType()); @@ -419,13 +419,13 @@ TEST(Generator, algebraicEqnConstantOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_constant_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ALGEBRAIC, generator->modelType()); @@ -453,13 +453,13 @@ TEST(Generator, algebraicEqnDerivativeOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_derivative_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -488,13 +488,13 @@ TEST(Generator, algebraicEqnDerivativeOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_derivative_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -523,13 +523,13 @@ TEST(Generator, algebraicEqnStateVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_state_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -558,13 +558,13 @@ TEST(Generator, algebraicEqnStateVarOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_state_var_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -593,13 +593,13 @@ TEST(Generator, odeComputedVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_computed_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -628,13 +628,13 @@ TEST(Generator, odeComputedVarOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_computed_var_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -663,13 +663,13 @@ TEST(Generator, odeConstVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_const_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -698,13 +698,13 @@ TEST(Generator, odeConstVarOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_const_var_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -733,13 +733,13 @@ TEST(Generator, odeConstantOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_constant_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -767,13 +767,13 @@ TEST(Generator, odeConstantOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_constant_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -801,13 +801,13 @@ TEST(Generator, odeMultipleDependentOdes) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_multiple_dependent_odes/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -836,13 +836,13 @@ TEST(Generator, odeMultipleDependentOdesOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_multiple_dependent_odes_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -871,13 +871,13 @@ TEST(Generator, odeMultipleOdesWithSameName) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_multiple_odes_with_same_name/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -906,13 +906,13 @@ TEST(Generator, cellmlMappingsAndEncapsulations) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/cellml_mappings_and_encapsulations/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -941,13 +941,13 @@ TEST(Generator, dependentEqns) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/dependent_eqns/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -976,13 +976,13 @@ TEST(Generator, fabbriFantiniWildersSeveriHumanSanModel2017) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -1011,13 +1011,13 @@ TEST(Generator, garnyKohlHunterBoyettNobleRabbitSanModel2003) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -1046,13 +1046,13 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -1106,13 +1106,13 @@ TEST(Generator, nobleModel1962) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/noble_model_1962/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -1141,13 +1141,13 @@ TEST(Generator, coverage) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/coverage/model.cellml")); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); diff --git a/tests/isolated/generator.cpp b/tests/isolated/generator.cpp index f36dad72b..765966ca5 100644 --- a/tests/isolated/generator.cpp +++ b/tests/isolated/generator.cpp @@ -198,7 +198,7 @@ TEST(Generator, isolatedFirstOrderModel) // 4.c Validate the final arrangement. No issues are expected at this stage. libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); // 5.a Create a Generator instance. By default the options set in the // generator constructor are: @@ -209,5 +209,5 @@ TEST(Generator, isolatedFirstOrderModel) generator->processModel(model); // 5.b Check whether the generator has encountered any issues. - EXPECT_EQ(size_t(0), generator->issueCount()); + EXPECT_EQ(size_t(0), generator->errorCount()); } diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index 68a8b1c01..9862f32d9 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -402,3 +402,63 @@ TEST(Issue, specificationRule) testSpecificationRule(e); EXPECT_EQ(size_t(51), count); } + +TEST(Issue, createModelWarning) +{ + libcellml::ModelPtr m = libcellml::Model::create(); + libcellml::IssuePtr e = libcellml::Issue::create(m); + + e->setLevel(libcellml::Issue::Level::WARNING); + + EXPECT_EQ(libcellml::Issue::Cause::MODEL, e->cause()); + EXPECT_EQ(libcellml::Issue::Level::WARNING, e->level()); +} + +TEST(Issue, createComponemntWarning) +{ + libcellml::ComponentPtr c = libcellml::Component::create(); + libcellml::IssuePtr e = libcellml::Issue::create(c); + e->setLevel(libcellml::Issue::Level::WARNING); + EXPECT_EQ(libcellml::Issue::Cause::COMPONENT, e->cause()); + EXPECT_EQ(libcellml::Issue::Level::WARNING, e->level()); +} + +TEST(Issue, createVariableWarning) +{ + libcellml::VariablePtr v = libcellml::Variable::create(); + libcellml::IssuePtr e = libcellml::Issue::create(v); + e->setLevel(libcellml::Issue::Level::WARNING); + + EXPECT_EQ(libcellml::Issue::Cause::VARIABLE, e->cause()); + EXPECT_EQ(libcellml::Issue::Level::WARNING, e->level()); +} + +TEST(Issue, createUnitsWarning) +{ + libcellml::UnitsPtr u = libcellml::Units::create(); + libcellml::IssuePtr e = libcellml::Issue::create(u); + e->setLevel(libcellml::Issue::Level::WARNING); + + EXPECT_EQ(libcellml::Issue::Cause::UNITS, e->cause()); + EXPECT_EQ(libcellml::Issue::Level::WARNING, e->level()); +} + +TEST(Issue, createImportSourceWarning) +{ + libcellml::ImportSourcePtr i = libcellml::ImportSource::create(); + libcellml::IssuePtr e = libcellml::Issue::create(i); + e->setLevel(libcellml::Issue::Level::WARNING); + + EXPECT_EQ(libcellml::Issue::Cause::IMPORT, e->cause()); + EXPECT_EQ(libcellml::Issue::Level::WARNING, e->level()); +} + +TEST(Issue, createResetWarning) +{ + libcellml::ResetPtr r = libcellml::Reset::create(); + libcellml::IssuePtr e = libcellml::Issue::create(r); + e->setLevel(libcellml::Issue::Level::WARNING); + + EXPECT_EQ(libcellml::Issue::Cause::RESET, e->cause()); + EXPECT_EQ(libcellml::Issue::Level::WARNING, e->level()); +} diff --git a/tests/parser/file_parser.cpp b/tests/parser/file_parser.cpp index fd1163719..8db1c8683 100644 --- a/tests/parser/file_parser.cpp +++ b/tests/parser/file_parser.cpp @@ -30,7 +30,7 @@ TEST(Parser, parseSineModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(fileContents("sine_approximations.xml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); } TEST(Parser, parseSineImportsModelFromFile) @@ -38,7 +38,7 @@ TEST(Parser, parseSineImportsModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(fileContents("sine_approximations_import.xml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); } TEST(Parser, parseInvalidModelFromFile) @@ -59,7 +59,7 @@ TEST(Parser, parseOrdModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("Ohara_Rudy_2011.cellml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); // Test some random values. std::string a = model->component("intracellular_ions")->variable("BSLmax")->initialValue(); @@ -81,7 +81,7 @@ TEST(Parser, parseComplexEncapsulationModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(fileContents("complex_encapsulation.xml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); } TEST(Parser, parseModelWithComponentsWithMultipleMathElements) @@ -121,7 +121,7 @@ TEST(Parser, parseModelWithComponentsWithMultipleMathElements) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("a_plus_b.cellml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); std::string a = model->component("c1")->math(); EXPECT_EQ(e1, a); @@ -150,7 +150,7 @@ TEST(Parser, simpleGeneratorModel) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("generator/initialized_variable_of_integration.cellml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); std::string a = model->component("my_component")->math(); EXPECT_EQ(e, a); diff --git a/tests/parser/libxml_user.cpp b/tests/parser/libxml_user.cpp index e5b733058..83b13ee35 100644 --- a/tests/parser/libxml_user.cpp +++ b/tests/parser/libxml_user.cpp @@ -54,7 +54,7 @@ TEST(Parser, parseInvalidXmlDirectlyUsingLibxml) // parse the string using libcellml libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(e); - EXPECT_NE(size_t(0), parser->issueCount()); + EXPECT_NE(size_t(0), parser->errorCount()); // and now parse directly using libxml2 xmlParserCtxtPtr context = xmlNewParserCtxt(); diff --git a/tests/parser/parser.cpp b/tests/parser/parser.cpp index cb5a7c137..706d8f9de 100644 --- a/tests/parser/parser.cpp +++ b/tests/parser/parser.cpp @@ -48,13 +48,13 @@ TEST(Parser, invalidXMLElements) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(input); - EXPECT_EQ(expectedErrors.size() - 1, p->issueCount()); - for (size_t i = 0; i < p->issueCount(); ++i) { + EXPECT_EQ(expectedErrors.size() - 1, p->errorCount()); + for (size_t i = 0; i < p->errorCount(); ++i) { if (i == 0) { - EXPECT_TRUE((p->issue(i)->description() != expectedErrors.at(0)) - || (p->issue(i)->description() != expectedErrors.at(1))); + EXPECT_TRUE((p->error(i)->description() != expectedErrors.at(0)) + || (p->error(i)->description() != expectedErrors.at(1))); } else { - EXPECT_EQ(expectedErrors.at(i + 1), p->issue(i)->description()); + EXPECT_EQ(expectedErrors.at(i + 1), p->error(i)->description()); } } } @@ -238,9 +238,9 @@ TEST(Parser, parseModelWithInvalidAttributeAndGetError) EXPECT_EQ_ERRORS(expectedErrors, parser); // Get ModelError and check. - EXPECT_EQ(model, parser->issue(0)->model()); + EXPECT_EQ(model, parser->error(0)->model()); // Get const modelError and check. - const libcellml::IssuePtr err = parser->issue(0); + const libcellml::IssuePtr err = parser->error(0); libcellml::Issue *rawErr = err.get(); const libcellml::ModelPtr modelFromError = rawErr->model(); EXPECT_EQ(model, modelFromError); @@ -356,10 +356,10 @@ TEST(Parser, parseModelWithNamedComponentWithInvalidBaseUnitsAttributeAndGetErro libcellml::UnitsPtr unitsExpected = model->units("unit_name"); // Get units from issue and check. - EXPECT_EQ(unitsExpected, parser->issue(0)->units()); + EXPECT_EQ(unitsExpected, parser->error(0)->units()); // Get const units from issue and check. - const libcellml::IssuePtr err = parser->issue(0); + const libcellml::IssuePtr err = parser->error(0); const libcellml::UnitsPtr unitsFromError = err->units(); EXPECT_EQ(unitsExpected, unitsFromError); } @@ -383,15 +383,15 @@ TEST(Parser, parseModelWithInvalidComponentAttributeAndGetError) EXPECT_EQ_ERRORS(expectedErrors, parser); // Get component from issue and check. - EXPECT_EQ(component, parser->issue(0)->component()); + EXPECT_EQ(component, parser->error(0)->component()); // Get const component from issue and check. - const libcellml::IssuePtr err = parser->issue(0); + const libcellml::IssuePtr err = parser->error(0); libcellml::Issue *rawErr = err.get(); const libcellml::ComponentPtr componentFromError = rawErr->component(); EXPECT_EQ(component, componentFromError); // Get non-existent issue - EXPECT_EQ(nullptr, parser->issue(1)); + EXPECT_EQ(nullptr, parser->error(1)); } TEST(Parser, componentAttributeErrors) @@ -455,13 +455,13 @@ TEST(Parser, componentElementErrors) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(input1); - EXPECT_EQ(size_t(1), p->issueCount()); - EXPECT_EQ(expectError1, p->issue(0)->description()); + EXPECT_EQ(size_t(1), p->errorCount()); + EXPECT_EQ(expectError1, p->error(0)->description()); p->removeAllErrors(); p->parseModel(input2); - EXPECT_EQ(size_t(1), p->issueCount()); - EXPECT_EQ(expectError2, p->issue(0)->description()); + EXPECT_EQ(size_t(1), p->errorCount()); + EXPECT_EQ(expectError2, p->error(0)->description()); } TEST(Parser, parseModelWithTwoComponents) @@ -655,7 +655,7 @@ TEST(Parser, validEncapsulation) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); } TEST(Parser, encapsulationWithCycleDefined) @@ -685,7 +685,7 @@ TEST(Parser, encapsulationWithCycleDefined) libcellml::ParserPtr p = libcellml::Parser::create(); auto m = p->parseModel(ex); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); libcellml::PrinterPtr printer = libcellml::Printer::create(); auto output = printer->printModel(m); @@ -914,16 +914,16 @@ TEST(Parser, invalidVariableAttributesAndGetVariableError) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(in); - EXPECT_EQ(expectedErrors.size(), p->issueCount()); - for (size_t i = 0; i < p->issueCount(); ++i) { - EXPECT_EQ(expectedErrors.at(i), p->issue(i)->description()); + EXPECT_EQ(expectedErrors.size(), p->errorCount()); + for (size_t i = 0; i < p->errorCount(); ++i) { + EXPECT_EQ(expectedErrors.at(i), p->error(i)->description()); } libcellml::VariablePtr variableExpected = model->component("componentA")->variable("quixote"); // Get variable from issue and check. - EXPECT_EQ(variableExpected, p->issue(0)->variable()); + EXPECT_EQ(variableExpected, p->error(0)->variable()); // Get const variable from issue and check. - libcellml::IssuePtr err = p->issue(0); + libcellml::IssuePtr err = p->error(0); libcellml::Issue *rawErr = err.get(); const libcellml::VariablePtr variableFromError = rawErr->variable(); EXPECT_EQ(variableExpected, variableFromError); @@ -953,14 +953,14 @@ TEST(Parser, variableAttributeAndChildErrors) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(input1); - EXPECT_EQ(size_t(1), p->issueCount()); - EXPECT_EQ(expectError1, p->issue(0)->description()); + EXPECT_EQ(size_t(1), p->errorCount()); + EXPECT_EQ(expectError1, p->error(0)->description()); p->removeAllErrors(); p->parseModel(input2); - EXPECT_EQ(size_t(2), p->issueCount()); - EXPECT_EQ(expectError2, p->issue(0)->description()); - EXPECT_EQ(expectError3, p->issue(1)->description()); + EXPECT_EQ(size_t(2), p->errorCount()); + EXPECT_EQ(expectError2, p->error(0)->description()); + EXPECT_EQ(expectError3, p->error(1)->description()); } TEST(Parser, emptyConnections) @@ -1121,7 +1121,7 @@ TEST(Parser, importedComponent2Connection) // Parse libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); } TEST(Parser, validConnectionMapVariablesFirst) @@ -1142,7 +1142,7 @@ TEST(Parser, validConnectionMapVariablesFirst) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); } TEST(Parser, component2ConnectionVariableMissing) @@ -1317,11 +1317,11 @@ TEST(Parser, invalidImportsAndGetError) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr m = p->parseModel(input); - EXPECT_EQ(size_t(4), p->issueCount()); - EXPECT_EQ(expectError1, p->issue(0)->description()); - EXPECT_EQ(expectError2, p->issue(1)->description()); - EXPECT_EQ(expectError3, p->issue(2)->description()); - EXPECT_EQ(expectError4, p->issue(3)->description()); + EXPECT_EQ(size_t(4), p->errorCount()); + EXPECT_EQ(expectError1, p->error(0)->description()); + EXPECT_EQ(expectError2, p->error(1)->description()); + EXPECT_EQ(expectError3, p->error(2)->description()); + EXPECT_EQ(expectError4, p->error(3)->description()); libcellml::PrinterPtr printer = libcellml::Printer::create(); const std::string a = printer->printModel(m); @@ -1329,9 +1329,9 @@ TEST(Parser, invalidImportsAndGetError) libcellml::ImportSourcePtr import = m->units("units_in_this_model")->importSource(); // Get import from issue and check. - EXPECT_EQ(import, p->issue(0)->importSource()); + EXPECT_EQ(import, p->error(0)->importSource()); // Get const import from issue and check. - const libcellml::IssuePtr err = p->issue(0); + const libcellml::IssuePtr err = p->error(0); libcellml::Issue *rawErr = err.get(); const libcellml::ImportSourcePtr importFromError = rawErr->importSource(); EXPECT_EQ(import, importFromError); @@ -1375,8 +1375,8 @@ TEST(Parser, invalidModelWithAllCausesOfErrors) EXPECT_EQ_ERRORS(expectedErrors, parser); - for (size_t i = 0; i < parser->issueCount(); ++i) { - switch (parser->issue(i)->cause()) { + for (size_t i = 0; i < parser->errorCount(); ++i) { + switch (parser->error(i)->cause()) { case libcellml::Issue::Cause::COMPONENT: foundCause.at(0) = true; break; @@ -1411,9 +1411,9 @@ TEST(Parser, invalidModelWithAllCausesOfErrors) libcellml::ParserPtr parser2 = libcellml::Parser::create(); // Add an undefined error libcellml::IssuePtr undefinedError = libcellml::Issue::create(); - parser2->addIssue(undefinedError); - EXPECT_EQ(size_t(1), parser2->issueCount()); - if (parser2->issue(0)->isCause(libcellml::Issue::Cause::UNDEFINED)) { + parser2->addError(undefinedError); + EXPECT_EQ(size_t(1), parser2->errorCount()); + if (parser2->error(0)->isCause(libcellml::Issue::Cause::UNDEFINED)) { foundCause.at(7) = true; } @@ -1426,8 +1426,8 @@ TEST(Parser, invalidModelWithAllCausesOfErrors) libcellml::ParserPtr parser3 = libcellml::Parser::create(); parser3->parseModel(input3); EXPECT_EQ_ERRORS(expectedErrors3, parser3); - for (size_t i = 0; i < parser3->issueCount(); ++i) { - if (parser3->issue(i)->isCause(libcellml::Issue::Cause::XML)) { + for (size_t i = 0; i < parser3->errorCount(); ++i) { + if (parser3->error(i)->isCause(libcellml::Issue::Cause::XML)) { foundCause.at(8) = true; } } @@ -1523,7 +1523,7 @@ TEST(Parser, parseIds) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(input); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); EXPECT_EQ("mid", model->id()); EXPECT_EQ("c1id", model->component("component1")->id()); EXPECT_EQ("i1id", model->component("component1")->importSource()->id()); @@ -1591,7 +1591,7 @@ TEST(Parser, parseIdsOnEverythingButMath) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); EXPECT_EQ("mid", model->id()); EXPECT_EQ("c1id", model->component("component1")->id()); EXPECT_EQ("i1id", model->component("component1")->importSource()->id()); @@ -1755,7 +1755,7 @@ TEST(Parser, parseResetsWithErrors) EXPECT_EQ_ERRORS(expectedErrors, p); - EXPECT_EQ(resetExpected, p->issue(0)->reset()); + EXPECT_EQ(resetExpected, p->error(0)->reset()); } TEST(Parser, unitsWithCellMLRealVariations) @@ -1844,7 +1844,7 @@ TEST(Parser, xmlComments) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); } TEST(Parser, mathWithNamespacesDefinedOnTheMathNode) @@ -1870,7 +1870,7 @@ TEST(Parser, mathWithNamespacesDefinedOnTheMathNode) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); } TEST(Parser, mathWithNamespacesDefinedOnTheNodeThatUsesNamespace) @@ -1896,7 +1896,7 @@ TEST(Parser, mathWithNamespacesDefinedOnTheNodeThatUsesNamespace) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); } TEST(Parser, mathWithNonStandardCellMLPrefix) @@ -1922,7 +1922,7 @@ TEST(Parser, mathWithNonStandardCellMLPrefix) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); } TEST(Parser, mathWithMathmlNamespaceOnModel) @@ -1948,7 +1948,7 @@ TEST(Parser, mathWithMathmlNamespaceOnModel) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); } TEST(Parser, repeatedMathParsePrintBehaviour) diff --git a/tests/printer/printer.cpp b/tests/printer/printer.cpp index 1e30d9afd..35366747d 100644 --- a/tests/printer/printer.cpp +++ b/tests/printer/printer.cpp @@ -219,7 +219,7 @@ TEST(Printer, printModelWithImports) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("sine_approximations_import.xml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); EXPECT_TRUE(model->hasUnresolvedImports()); libcellml::PrinterPtr printer = libcellml::Printer::create(); diff --git a/tests/resolve_imports/file_parser.cpp b/tests/resolve_imports/file_parser.cpp index 85029deae..475e20e5c 100644 --- a/tests/resolve_imports/file_parser.cpp +++ b/tests/resolve_imports/file_parser.cpp @@ -31,7 +31,7 @@ TEST(ResolveImports, resolveSineModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("sine_approximations.xml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); EXPECT_FALSE(model->hasUnresolvedImports()); } @@ -39,7 +39,7 @@ TEST(ResolveImports, resolveSineImportsModelFromFile) { libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("sine_approximations_import.xml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -50,7 +50,7 @@ TEST(ResolveImports, resolveComplexImportsModelFromFile) { libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("complex_imports.xml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -62,7 +62,7 @@ TEST(ResolveImports, resolveUnitsImportFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("import_units_model.cellml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -74,7 +74,7 @@ TEST(ResolveImports, resolveImportsFromFileLevel0) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("level0.xml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -86,7 +86,7 @@ TEST(ResolveImports, resolveImportsFromFileLevel0Unresolvable) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("level0-broken-imports.xml")); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -112,7 +112,7 @@ TEST(ResolveImports, componentNotInResolvingModel) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(modelImportingComponent); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp index 9f2b5b9fa..42684b539 100644 --- a/tests/test_utils.cpp +++ b/tests/test_utils.cpp @@ -42,17 +42,17 @@ std::string fileContents(const std::string &fileName) void printErrors(const libcellml::LoggerPtr &l, bool headings, bool causes, bool rule) { - for (size_t i = 0; i < l->issueCount(); ++i) { + for (size_t i = 0; i < l->errorCount(); ++i) { std::cout << "Issue " << std::setw(3) << i + 1 << ": "; - std::cout << l->issue(i)->description(); + std::cout << l->error(i)->description(); if (headings) { - std::cout << ", " << l->issue(i)->specificationHeading(); + std::cout << ", " << l->error(i)->specificationHeading(); } if (causes) { - std::cout << ", " << static_cast(l->issue(i)->cause()); + std::cout << ", " << static_cast(l->error(i)->cause()); } if (rule) { - std::cout << ", " << static_cast(l->issue(i)->rule()); + std::cout << ", " << static_cast(l->error(i)->rule()); } std::cout << std::endl; } @@ -60,9 +60,9 @@ void printErrors(const libcellml::LoggerPtr &l, bool headings, bool causes, bool void expectEqualErrors(const std::vector &issues, const libcellml::LoggerPtr &logger) { - EXPECT_EQ(issues.size(), logger->issueCount()); - for (size_t i = 0; i < logger->issueCount() && i < issues.size(); ++i) { - EXPECT_EQ(issues.at(i), logger->issue(i)->description()); + EXPECT_EQ(issues.size(), logger->errorCount()); + for (size_t i = 0; i < logger->errorCount() && i < issues.size(); ++i) { + EXPECT_EQ(issues.at(i), logger->error(i)->description()); } } @@ -70,11 +70,11 @@ void expectEqualErrorsSpecificationHeadings(const std::vector &issu const std::vector &specificationHeadings, const libcellml::LoggerPtr &logger) { - EXPECT_EQ(issues.size(), logger->issueCount()); - EXPECT_EQ(specificationHeadings.size(), logger->issueCount()); - for (size_t i = 0; i < logger->issueCount() && i < issues.size(); ++i) { - EXPECT_EQ(issues.at(i), logger->issue(i)->description()); - EXPECT_EQ(specificationHeadings.at(i), logger->issue(i)->specificationHeading()); + EXPECT_EQ(issues.size(), logger->errorCount()); + EXPECT_EQ(specificationHeadings.size(), logger->errorCount()); + for (size_t i = 0; i < logger->errorCount() && i < issues.size(); ++i) { + EXPECT_EQ(issues.at(i), logger->error(i)->description()); + EXPECT_EQ(specificationHeadings.at(i), logger->error(i)->specificationHeading()); } } @@ -82,11 +82,11 @@ void expectEqualErrorsCauses(const std::vector &issues, const std::vector &causes, const libcellml::LoggerPtr &logger) { - EXPECT_EQ(issues.size(), logger->issueCount()); - EXPECT_EQ(causes.size(), logger->issueCount()); - for (size_t i = 0; i < logger->issueCount() && i < issues.size(); ++i) { - EXPECT_EQ(issues.at(i), logger->issue(i)->description()); - EXPECT_EQ(causes.at(i), logger->issue(i)->cause()); + EXPECT_EQ(issues.size(), logger->errorCount()); + EXPECT_EQ(causes.size(), logger->errorCount()); + for (size_t i = 0; i < logger->errorCount() && i < issues.size(); ++i) { + EXPECT_EQ(issues.at(i), logger->error(i)->description()); + EXPECT_EQ(causes.at(i), logger->error(i)->cause()); } } diff --git a/tests/units/units.cpp b/tests/units/units.cpp index 74fd06340..f26497584 100644 --- a/tests/units/units.cpp +++ b/tests/units/units.cpp @@ -788,8 +788,8 @@ TEST(Units, unitsWithPrefixOutOfRange) validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->issueCount()); - EXPECT_EQ(e, validator->issue(0)->description()); + EXPECT_EQ(size_t(1), validator->errorCount()); + EXPECT_EQ(e, validator->error(0)->description()); } TEST(Units, parentOfUnits) diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 4c1a83274..888a17412 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -31,7 +31,7 @@ TEST(Validator, namedModel) libcellml::ModelPtr model = libcellml::Model::create(); model->setName("awesomeName"); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); } TEST(Validator, unnamedModel) @@ -254,7 +254,7 @@ TEST(Validator, importUnits) importedUnits->setSourceUnits(imp, "units_in_that_model"); m->addUnits(importedUnits); v->validateModel(m); - EXPECT_EQ(size_t(0), v->issueCount()); + EXPECT_EQ(size_t(0), v->errorCount()); // Invalid units import- missing refs libcellml::ImportSourcePtr imp2 = libcellml::ImportSource::create(); @@ -263,7 +263,7 @@ TEST(Validator, importUnits) importedUnits2->setSourceUnits(imp2, ""); m->addUnits(importedUnits2); v->validateModel(m); - EXPECT_EQ(size_t(3), v->issueCount()); + EXPECT_EQ(size_t(3), v->errorCount()); // Invalid units import - duplicate refs libcellml::ImportSourcePtr imp3 = libcellml::ImportSource::create(); @@ -273,7 +273,7 @@ TEST(Validator, importUnits) importedUnits3->setSourceUnits(imp3, "units_in_that_model"); m->addUnits(importedUnits3); v->validateModel(m); - EXPECT_EQ(size_t(4), v->issueCount()); + EXPECT_EQ(size_t(4), v->errorCount()); // Invalid units import - unnamed units libcellml::ImportSourcePtr imp4 = libcellml::ImportSource::create(); @@ -310,7 +310,7 @@ TEST(Validator, importComponents) importedComponent->setSourceComponent(imp, "component_in_that_model"); m->addComponent(importedComponent); v->validateModel(m); - EXPECT_EQ(size_t(0), v->issueCount()); + EXPECT_EQ(size_t(0), v->errorCount()); // Another valid component import libcellml::ImportSourcePtr imp2 = libcellml::ImportSource::create(); @@ -320,7 +320,7 @@ TEST(Validator, importComponents) importedComponent2->setSourceComponent(imp2, "new_shiny_component_ref"); m->addComponent(importedComponent2); v->validateModel(m); - EXPECT_EQ(size_t(0), v->issueCount()); + EXPECT_EQ(size_t(0), v->errorCount()); // Invalid component import - missing ref to source component libcellml::ImportSourcePtr imp3 = libcellml::ImportSource::create(); @@ -329,7 +329,7 @@ TEST(Validator, importComponents) importedComponent3->setSourceComponent(imp3, ""); m->addComponent(importedComponent3); v->validateModel(m); - EXPECT_EQ(size_t(3), v->issueCount()); + EXPECT_EQ(size_t(3), v->errorCount()); // Valid component import - two components imported from the same place is allowed libcellml::ImportSourcePtr imp4 = libcellml::ImportSource::create(); @@ -339,7 +339,7 @@ TEST(Validator, importComponents) importedComponent4->setSourceComponent(imp4, "component_in_that_model"); m->addComponent(importedComponent4); v->validateModel(m); - EXPECT_EQ(size_t(3), v->issueCount()); + EXPECT_EQ(size_t(3), v->errorCount()); // Invalid - name missing from component libcellml::ImportSourcePtr imp5 = libcellml::ImportSource::create(); @@ -348,7 +348,7 @@ TEST(Validator, importComponents) importedComponent5->setSourceComponent(imp5, "component_in_that_model"); m->addComponent(importedComponent5); v->validateModel(m); - EXPECT_EQ(size_t(5), v->issueCount()); + EXPECT_EQ(size_t(5), v->errorCount()); // Valid - two components from the same source is allowed libcellml::ImportSourcePtr imp7 = libcellml::ImportSource::create(); @@ -358,7 +358,7 @@ TEST(Validator, importComponents) importedComponent7->setSourceComponent(imp7, "new_shiny_component_ref"); m->addComponent(importedComponent7); v->validateModel(m); - EXPECT_EQ(size_t(5), v->issueCount()); + EXPECT_EQ(size_t(5), v->errorCount()); // Valid - duplicate component_ref from a different source libcellml::ImportSourcePtr imp8 = libcellml::ImportSource::create(); @@ -368,7 +368,7 @@ TEST(Validator, importComponents) importedComponent8->setSourceComponent(imp8, "component_in_that_model"); m->addComponent(importedComponent8); v->validateModel(m); - EXPECT_EQ(size_t(5), v->issueCount()); + EXPECT_EQ(size_t(5), v->errorCount()); // Invalid: component_ref url is not valid html libcellml::ImportSourcePtr imp9 = libcellml::ImportSource::create(); @@ -423,7 +423,7 @@ TEST(Validator, validMath) m->addComponent(c); v->validateModel(m); - EXPECT_EQ(size_t(0), v->issueCount()); + EXPECT_EQ(size_t(0), v->errorCount()); } TEST(Validator, invalidMath) @@ -509,7 +509,7 @@ TEST(Validator, invalidMathMLElements) // Check for two expected error messages (see note above). for (size_t i = 0; i < 2; ++i) { - EXPECT_EQ(expectedErrors.at(i), v->issue(i)->description()); + EXPECT_EQ(expectedErrors.at(i), v->error(i)->description()); } } @@ -766,7 +766,7 @@ TEST(Validator, validMathMLCiAndCnElementsWithCellMLUnits) m->addComponent(c); v->validateModel(m); - EXPECT_EQ(size_t(0), v->issueCount()); + EXPECT_EQ(size_t(0), v->errorCount()); } TEST(Validator, parseAndValidateInvalidUnitErrors) @@ -794,7 +794,7 @@ TEST(Validator, parseAndValidateInvalidUnitErrors) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr m = p->parseModel(input); - EXPECT_EQ(size_t(0), p->issueCount()); + EXPECT_EQ(size_t(0), p->errorCount()); libcellml::ValidatorPtr v = libcellml::Validator::create(); v->validateModel(m); @@ -889,7 +889,7 @@ TEST(Validator, validateInvalidConnectionsDanglingReciprocalEquivalence) v1_2->removeAllEquivalences(); v->validateModel(m); - EXPECT_EQ(size_t(0), v->issueCount()); + EXPECT_EQ(size_t(0), v->errorCount()); } TEST(Validator, integerStrings) @@ -1009,7 +1009,7 @@ TEST(Validator, resetValid) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); } TEST(Validator, resetNoVariable) @@ -1046,8 +1046,8 @@ TEST(Validator, resetNoVariable) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->issueCount()); - EXPECT_EQ(expectedError, validator->issue(0)->description()); + EXPECT_EQ(size_t(1), validator->errorCount()); + EXPECT_EQ(expectedError, validator->error(0)->description()); } TEST(Validator, resetNoTestVariable) @@ -1084,8 +1084,8 @@ TEST(Validator, resetNoTestVariable) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->issueCount()); - EXPECT_EQ(expectedError, validator->issue(0)->description()); + EXPECT_EQ(size_t(1), validator->errorCount()); + EXPECT_EQ(expectedError, validator->error(0)->description()); } TEST(Validator, resetNoOrder) @@ -1121,8 +1121,8 @@ TEST(Validator, resetNoOrder) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->issueCount()); - EXPECT_EQ(expectedError, validator->issue(0)->description()); + EXPECT_EQ(size_t(1), validator->errorCount()); + EXPECT_EQ(expectedError, validator->error(0)->description()); } TEST(Validator, resetNoResetValue) @@ -1158,8 +1158,8 @@ TEST(Validator, resetNoResetValue) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->issueCount()); - EXPECT_EQ(expectedError, validator->issue(0)->description()); + EXPECT_EQ(size_t(1), validator->errorCount()); + EXPECT_EQ(expectedError, validator->error(0)->description()); } TEST(Validator, resetNoTestValue) @@ -1273,7 +1273,7 @@ TEST(Validator, resetEmptyMathML) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); } TEST(Validator, resetNegativeOrder) @@ -1308,7 +1308,7 @@ TEST(Validator, resetNegativeOrder) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); } TEST(Validator, resetVariableOutsideComponent) @@ -1392,7 +1392,7 @@ TEST(Validator, validMathCnElements) m->addComponent(c); v->validateModel(m); - EXPECT_EQ(size_t(0), v->issueCount()); + EXPECT_EQ(size_t(0), v->errorCount()); } TEST(Validator, validMathCnElementsMissingCellMLNamespace) @@ -1555,7 +1555,7 @@ TEST(Validator, unitEquivalenceStandardUnitsToBaseUnits) base->addUnit(baseUnits.first, 0, baseUnits.second, 1.0); } validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); } } @@ -1598,7 +1598,7 @@ TEST(Validator, unitEquivalenceBasicDimensionlessUnits) libcellml::Variable::addEquivalence(v1, v2); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); } TEST(Validator, unitEquivalenceDimensionlessUnits) @@ -1652,7 +1652,7 @@ TEST(Validator, unitEquivalenceDimensionlessUnits) libcellml::Variable::addEquivalence(v2, v3); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); } TEST(Validator, unitEquivalenceMultiplierPrefix) @@ -1702,7 +1702,7 @@ TEST(Validator, unitEquivalenceMultiplierPrefix) libcellml::Variable::addEquivalence(v2, v3); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); } TEST(Validator, unitEquivalenceComplicatedNestedUnits) @@ -1862,7 +1862,7 @@ TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) libcellml::Variable::addEquivalence(v1, v2); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); } TEST(Validator, unitUserCreatedUnitsBananasAndApples) @@ -2039,7 +2039,7 @@ TEST(Validator, unitSimpleCycle) // Network valid at this stage. v->validateModel(m); - EXPECT_EQ(size_t(0), v->issueCount()); + EXPECT_EQ(size_t(0), v->errorCount()); // Time loop Grandfather paradox created! u1 no longer a base variable: u1 -> u3 -> u2 -> u1. u1->addUnit("child"); @@ -2101,7 +2101,7 @@ TEST(Validator, unitComplexCycle) u6->addUnit("mother"); v->validateModel(m); - EXPECT_EQ(size_t(0), v->issueCount()); + EXPECT_EQ(size_t(0), v->errorCount()); // As soon as a dependency of the grandfather on the brotherFromAnotherMother is added, then a // _directed_ loop (u1->u2->u4->u1) is created and the network is no longer valid: @@ -2164,7 +2164,7 @@ TEST(Validator, multipleDefinitionsOfCellMLNamespace) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); } TEST(Validator, validateModelWithoutAndWithMath) @@ -2191,7 +2191,7 @@ TEST(Validator, validateModelWithoutAndWithMath) c3->addVariable(v); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); const std::string math = "\n" @@ -2205,7 +2205,7 @@ TEST(Validator, validateModelWithoutAndWithMath) c3->setMath(math); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); } TEST(Validator, unitEquivalenceMultiplier) @@ -2245,7 +2245,7 @@ TEST(Validator, unitEquivalenceMultiplier) validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); } TEST(Validator, unfoundUnitsInEncapsulatedComponents) @@ -2279,3 +2279,37 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) EXPECT_EQ_ERRORS(expectedErrors, v); } + +/****************************************************************************** + * + * ISSUE WARNINGS TESTING FROM HERE DOWN + * + * ==========================================================================*/ + +// TEST(Validator, mismatchedMultipliersInUnits) +// { +// // If two units are linked through variable equivalence mapping and their +// // scaling factor is not the same, it should raise a warning-level issue + +// auto model = libcellml::Model::create("Gulliver"); +// auto c1 = libcellml::Component::create("Brobdingnag"); +// auto c2 = libcellml::Component::create("Lilliput"); +// auto v1 = libcellml::Variable::create("v1"); +// auto v2 = libcellml::Variable::create("v2"); + +// v1->setUnits("metre", "mega"); +// v2->setUnits("metre", "milli"); +// c1->addVariable(v1); +// c2->addVariable(v2); +// model->addComponent(c1); +// model->addComponent(c2); +// v1->setEquivalentTo(v2); + +// auto validator = libcellml::Validator::create(); +// validator->validateModel(model); +// EXPECT_EQ(size_t(0), validator->errorCount()); +// EXPECT_EQ(size_t(1), validator->warningCount()); +// EXPECT_EQ(size_t(1), validator->errorCount()); +// EXPECT_EQ(size_t(1), validator->errorCount(libcellml::Issue::Level::WARNING)); + +// } diff --git a/tests/variable/variable.cpp b/tests/variable/variable.cpp index 4ae9d712f..75cc475ef 100644 --- a/tests/variable/variable.cpp +++ b/tests/variable/variable.cpp @@ -1166,7 +1166,7 @@ TEST(Variable, modelUnitsAttributeBeforeNameAttribute) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->issueCount()); + EXPECT_EQ(size_t(0), parser->errorCount()); } TEST(Variable, parentlessUsingRemoveVariable) From 7696155f4922a54e808d71780c780de544a0fb6c Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 15 Jan 2020 14:24:07 +0100 Subject: [PATCH 09/88] clang format --- src/logger.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/logger.cpp b/src/logger.cpp index bb65aa93b..a045f4a18 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -44,6 +44,7 @@ Logger::~Logger() delete mPimpl; } +// KRM I've left these here as is so that all the existing tests and behaviour stays the same. void Logger::removeAllErrors() { mPimpl->mErrors.clear(); @@ -68,7 +69,7 @@ IssuePtr Logger::error(size_t index) const return err; } - +// KRM Changes start from here // IssuePtr Logger::error(size_t index) const // { @@ -79,5 +80,4 @@ IssuePtr Logger::error(size_t index) const // return err; // } - } // namespace libcellml From a3432c55541c2fbf817f5fe3b2fdc9c54f02745d Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 15 Jan 2020 15:27:47 +0100 Subject: [PATCH 10/88] Basic test and basic implementation --- src/api/libcellml/issue.h | 6 +- src/api/libcellml/logger.h | 105 +++++++++++++++++++++++++++++-- src/bindings/interface/logger.i | 37 +++++++++-- src/generator.cpp | 2 +- src/issue.cpp | 2 +- src/logger.cpp | 106 ++++++++++++++++++++++++++------ src/parser.cpp | 2 +- src/validator.cpp | 2 +- tests/CMakeLists.txt | 1 + tests/connection/connection.cpp | 2 +- tests/logger/logger.cpp | 70 +++++++++++++++++++++ tests/logger/tests.cmake | 16 +++++ tests/parser/parser.cpp | 12 ++-- 13 files changed, 320 insertions(+), 43 deletions(-) create mode 100644 tests/logger/logger.cpp create mode 100644 tests/logger/tests.cmake diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 43206d9be..c66bda5b7 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -116,9 +116,9 @@ class LIBCELLML_EXPORT Issue */ enum class Level { - FATAL, + ERROR, WARNING, - INFORMATION, + HINT, }; /** @@ -184,7 +184,7 @@ class LIBCELLML_EXPORT Issue * @brief Get the level of this issue. * * Get the @c level of this issue. If no level has been set for - * this issue, will return Level::FATAL. + * this issue, will return Level::ERROR. * * @return The @c Issue::Level set for this issue. */ diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index d942087bd..ce5941b2d 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -42,7 +42,7 @@ class LIBCELLML_EXPORT Logger * * Clear the issues from the logger. */ - void removeAllErrors(); + void removeAllIssues(); /** * @brief Add an issue to the logger. @@ -51,19 +51,19 @@ class LIBCELLML_EXPORT Logger * * @param issue The @c IssuePtr to add. */ - void addError(const IssuePtr &issue); + void addIssue(const IssuePtr &issue); /** - * @brief Get the number of issues. + * @brief Get the number of issues * - * Return the number of issues currently stored in the logger. + * Return the number of issues of any level currently stored in the logger. * * @return The number of issues. */ - size_t errorCount() const; + size_t issueCount() const; /** - * @brief Get issue at the specified @p index. + * @brief Get issue of any level at the specified @p index. * * Returns an issue at the @p index. If the @p index * is not valid a @c nullptr is returned, the valid range for the @p index @@ -73,8 +73,101 @@ class LIBCELLML_EXPORT Logger * * @return A reference to the issue at the given index on success, @c nullptr otherwise. */ + IssuePtr issue(size_t index) const; + + /** + * @brief Add an issue of level error to the logger. + * + * Adds the argument @p issue to this logger. + * + * @param issue The @c IssuePtr to add. + */ + void addError(const IssuePtr &issue); + + /** + * @brief Get the number of issues with level of ERROR. + * + * Return the number of errors currently stored in the logger. + * + * @return The number of errors. + */ + size_t errorCount() const; + + /** + * @brief Get issue of level ERROR at the specified @p index. + * + * Returns an error at the @p index. If the @p index + * is not valid a @c nullptr is returned, the valid range for the @p index + * is [0, \#errors). + * + * @param index The index of the error to return. + * + * @return A reference to the error at the given index on success, @c nullptr otherwise. + */ IssuePtr error(size_t index) const; + /** + * @brief Add an issue of level WARNING to the logger. + * + * Adds the argument @p issue to this logger. + * + * @param issue The @c IssuePtr to add. + */ + void addWarning(const IssuePtr &issue); + + /** + * @brief Get the number of issues with level of WARNING. + * + * Return the number of warnings currently stored in the logger. + * + * @return The number of warnings. + */ + size_t warningCount() const; + + /** + * @brief Get issue of level WARNING at the specified @p index. + * + * Returns an warning at the @p index. If the @p index + * is not valid a @c nullptr is returned, the valid range for the @p index + * is [0, \#warnings). + * + * @param index The index of the warning to return. + * + * @return A reference to the warning at the given index on success, @c nullptr otherwise. + */ + IssuePtr warning(size_t index) const; + + /** + * @brief Add an issue of level HINT to the logger. + * + * Adds the argument @p issue to this logger. + * + * @param issue The @c IssuePtr to add. + */ + void addHint(const IssuePtr &issue); + + /** + * @brief Get the number of issues with level of HINT. + * + * Return the number of hints currently stored in the logger. + * + * @return The number of hints. + */ + size_t hintCount() const; + + /** + * @brief Get issue of level HINT at the specified @p index. + * + * Returns an error at the @p index. If the @p index + * is not valid a @c nullptr is returned, the valid range for the @p index + * is [0, \#hints). + * + * @param index The index of the hint to return. + * + * @return A reference to the hint at the given index on success, @c nullptr otherwise. + */ + IssuePtr hint(size_t index) const; + protected: Logger(); /**< Constructor */ diff --git a/src/bindings/interface/logger.i b/src/bindings/interface/logger.i index 229c77781..6ba37b96a 100644 --- a/src/bindings/interface/logger.i +++ b/src/bindings/interface/logger.i @@ -7,17 +7,44 @@ %feature("docstring") libcellml::Logger "Base class for all serialisable libCellML classes."; -%feature("docstring") libcellml::Logger::addError +%feature("docstring") libcellml::Logger::removeAllIssues +"Clears all issues from this logger."; + +%feature("docstring") libcellml::Logger::addIssue "Adds an issue to this logger."; -%feature("docstring") libcellml::Logger::removeAllErrors -"Clears all errors from this logger."; +%feature("docstring") libcellml::Logger::issue +"Returns the issue of any level at the specified 'index'."; + +%feature("docstring") libcellml::Logger::issueCount +"Returns the number of issues currently stored in the logger."; + +%feature("docstring") libcellml::Logger::addError +"Adds an issue with level of 'error' to this logger."; %feature("docstring") libcellml::Logger::error -"Returns the issue of level 'error' at the specified `index`."; +"Returns the issue of level 'error' at the specified 'index'."; %feature("docstring") libcellml::Logger::errorCount -"Returns the number of errors currently stored in the logger."; +"Returns the number of issues of level 'error' currently stored in the logger."; + +%feature("docstring") libcellml::Logger::addWarning +"Adds an issue with level of 'warning' to this logger."; + +%feature("docstring") libcellml::Logger::warning +"Returns the issue of level 'warning' at the specified 'index'."; + +%feature("docstring") libcellml::Logger::warningCount +"Returns the number of issues of level 'warning' currently stored in the logger."; + +%feature("docstring") libcellml::Logger::addHint +"Adds an issue with level of 'hint' to this logger."; + +%feature("docstring") libcellml::Logger::hint +"Returns the issue of level 'hint' at the specified 'index'."; + +%feature("docstring") libcellml::Logger::hintCount +"Returns the number of issues of level 'hint' currently stored in the logger."; #if defined(SWIGPYTHON) // Treat negative size_t as invalid index (instead of unknown method) diff --git a/src/generator.cpp b/src/generator.cpp index 3b343d580..1441f7646 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1354,7 +1354,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) mNeedAcsch = false; mNeedAcoth = false; - mGenerator->removeAllErrors(); + mGenerator->removeAllIssues(); // Recursively process the model's components, so that we end up with an AST // for each of the model's equations. diff --git a/src/issue.cpp b/src/issue.cpp index 5ab7dd087..0b0397de1 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -31,7 +31,7 @@ struct Issue::IssueImpl { std::string mDescription; /**< The string description for why this entity issue raised. */ Issue::Cause mCause = Issue::Cause::UNDEFINED; /**< The Issue::Cause enum value for this issue. */ - Issue::Level mLevel = Issue::Level::FATAL; /**< The Issue::Level enum value for this issue. */ + Issue::Level mLevel = Issue::Level::ERROR; /**< The Issue::Level enum value for this issue. */ SpecificationRule mRule = SpecificationRule::UNDEFINED; /**< The SpecificationRule enum value for this issue. */ ComponentPtr mComponent; /**< Pointer to the component that the issue occurred in. */ ImportSourcePtr mImportSource; /**< Pointer to the import source that the issue occurred in. */ diff --git a/src/logger.cpp b/src/logger.cpp index a045f4a18..97414ac6f 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -31,7 +31,10 @@ namespace libcellml { */ struct Logger::LoggerImpl { - std::vector mErrors; + std::vector mErrors; + std::vector mWarnings; + std::vector mHints; + std::vector mIssues; }; Logger::Logger() @@ -44,15 +47,10 @@ Logger::~Logger() delete mPimpl; } -// KRM I've left these here as is so that all the existing tests and behaviour stays the same. -void Logger::removeAllErrors() -{ - mPimpl->mErrors.clear(); -} - void Logger::addError(const IssuePtr &issue) { - mPimpl->mErrors.push_back(issue); + mPimpl->mIssues.push_back(issue); + mPimpl->mErrors.push_back(mPimpl->mIssues.size() - 1); } size_t Logger::errorCount() const @@ -63,21 +61,93 @@ size_t Logger::errorCount() const IssuePtr Logger::error(size_t index) const { IssuePtr err = nullptr; - if (index < mPimpl->mErrors.size()) { - err = mPimpl->mErrors.at(index); + if ((index < mPimpl->mErrors.size()) && (mPimpl->mErrors.at(index) < mPimpl->mIssues.size())) { + err = mPimpl->mIssues.at(mPimpl->mErrors.at(index)); + } + return err; +} + +void Logger::addWarning(const IssuePtr &issue) +{ + mPimpl->mIssues.push_back(issue); + mPimpl->mWarnings.push_back(mPimpl->mIssues.size() - 1); +} + +size_t Logger::warningCount() const +{ + return mPimpl->mWarnings.size(); +} + +IssuePtr Logger::warning(size_t index) const +{ + IssuePtr err = nullptr; + if ((index < mPimpl->mWarnings.size()) && (mPimpl->mWarnings.at(index) < mPimpl->mIssues.size())) { + err = mPimpl->mIssues.at(mPimpl->mWarnings.at(index)); + } + return err; +} + +void Logger::addHint(const IssuePtr &issue) +{ + mPimpl->mIssues.push_back(issue); + mPimpl->mHints.push_back(mPimpl->mIssues.size() - 1); +} + +size_t Logger::hintCount() const +{ + return mPimpl->mWarnings.size(); +} + +IssuePtr Logger::hint(size_t index) const +{ + IssuePtr err = nullptr; + if ((index < mPimpl->mHints.size()) && (mPimpl->mHints.at(index) < mPimpl->mIssues.size())) { + err = mPimpl->mIssues.at(mPimpl->mHints.at(index)); } return err; } // KRM Changes start from here -// IssuePtr Logger::error(size_t index) const -// { -// IssuePtr err = nullptr; -// if (index < mPimpl->mIssues.size()) { -// err = mPimpl->mErrors.at(index); -// } -// return err; -// } +void Logger::removeAllIssues() +{ + mPimpl->mIssues.clear(); + mPimpl->mErrors.clear(); + mPimpl->mWarnings.clear(); + mPimpl->mHints.clear(); +} + +void Logger::addIssue(const IssuePtr &issue) +{ + // When an issue is added + mPimpl->mIssues.push_back(issue); + size_t index = mPimpl->mIssues.size() - 1; + // Update the appropriate array based on its level + switch (issue->level()) { + case libcellml::Issue::Level::ERROR: + mPimpl->mErrors.push_back(index); + break; + case libcellml::Issue::Level::WARNING: + mPimpl->mWarnings.push_back(index); + break; + case libcellml::Issue::Level::HINT: + mPimpl->mHints.push_back(index); + break; + } +} + +size_t Logger::issueCount() const +{ + return mPimpl->mIssues.size(); +} + +IssuePtr Logger::issue(size_t index) const +{ + IssuePtr err = nullptr; + if (index < mPimpl->mIssues.size()) { + err = mPimpl->mIssues.at(index); + } + return err; +} } // namespace libcellml diff --git a/src/parser.cpp b/src/parser.cpp index f36b52884..35e660713 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -230,7 +230,7 @@ ParserPtr Parser::create() noexcept ModelPtr Parser::parseModel(const std::string &input) { - removeAllErrors(); + removeAllIssues(); ModelPtr model = Model::create(); if (input.empty()) { IssuePtr err = Issue::create(); diff --git a/src/validator.cpp b/src/validator.cpp index 2bed06631..4a71770ef 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -279,7 +279,7 @@ ValidatorPtr Validator::create() noexcept void Validator::validateModel(const ModelPtr &model) { // Clear any pre-existing issues in ths validator instance. - removeAllErrors(); + removeAllIssues(); // Check for a valid name attribute. if (!mPimpl->isCellmlIdentifier(model->name())) { IssuePtr err = Issue::create(); diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 8dc526cce..b54dd44f3 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -34,6 +34,7 @@ include(coverage/tests.cmake) include(generator/tests.cmake) include(isolated/tests.cmake) include(issue/tests.cmake) +include(logger/tests.cmake) include(math/tests.cmake) include(model/tests.cmake) include(parser/tests.cmake) diff --git a/tests/connection/connection.cpp b/tests/connection/connection.cpp index 0be275a3e..2c827b08f 100644 --- a/tests/connection/connection.cpp +++ b/tests/connection/connection.cpp @@ -1129,7 +1129,7 @@ TEST(Connection, componentConnectionAndParseMissingVariable) EXPECT_EQ(size_t(1), parser->errorCount()); EXPECT_EQ(expectError, parser->error(0)->description()); - parser->removeAllErrors(); + parser->removeAllIssues(); EXPECT_EQ(size_t(0), parser->errorCount()); libcellml::PrinterPtr printer = libcellml::Printer::create(); diff --git a/tests/logger/logger.cpp b/tests/logger/logger.cpp new file mode 100644 index 000000000..a68b0128d --- /dev/null +++ b/tests/logger/logger.cpp @@ -0,0 +1,70 @@ +/* +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(Validator, getIssueByLevel) +{ + auto error1 = libcellml::Issue::create(); + error1->setLevel(libcellml::Issue::Level::ERROR); + + auto warning1 = libcellml::Issue::create(); + warning1->setLevel(libcellml::Issue::Level::WARNING); + + auto hint1 = libcellml::Issue::create(); + hint1->setLevel(libcellml::Issue::Level::HINT); + + auto error2 = libcellml::Issue::create(); + error2->setLevel(libcellml::Issue::Level::ERROR); + + auto warning2 = libcellml::Issue::create(); + warning2->setLevel(libcellml::Issue::Level::WARNING); + + auto hint2 = libcellml::Issue::create(); + hint2->setLevel(libcellml::Issue::Level::HINT); + + auto validator = libcellml::Validator::create(); + validator->addIssue(error1); + validator->addIssue(warning1); + validator->addIssue(hint1); + validator->addIssue(hint2); + validator->addIssue(warning2); + validator->addIssue(error2); + + // Expect to be able to call issue(0-5) and have the appropriate one returned + // in the order they were added, irrespective of their level. + EXPECT_EQ(size_t(6), validator->issueCount()); + EXPECT_EQ(error1, validator->issue(0)); + EXPECT_EQ(warning1, validator->issue(1)); + EXPECT_EQ(hint1, validator->issue(2)); + EXPECT_EQ(hint2, validator->issue(3)); + EXPECT_EQ(warning2, validator->issue(4)); + EXPECT_EQ(error2, validator->issue(5)); + + // Expect to call error(0-1) and get the ERROR level issues only + EXPECT_EQ(error1, validator->error(0)); + EXPECT_EQ(error2, validator->error(1)); + + // Expect to call warning(0-1) and get the WARNING level issues only + EXPECT_EQ(warning1, validator->warning(0)); + EXPECT_EQ(warning2, validator->warning(1)); + + // Expect to call hint(0-1) and get the HINT level issues only + EXPECT_EQ(hint1, validator->hint(0)); + EXPECT_EQ(hint2, validator->hint(1)); +} diff --git a/tests/logger/tests.cmake b/tests/logger/tests.cmake new file mode 100644 index 000000000..6a78ab12c --- /dev/null +++ b/tests/logger/tests.cmake @@ -0,0 +1,16 @@ + +# Set the test name, 'test_' will be prepended to the +# name set here +set(CURRENT_TEST logger) +# 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 entities) +list(APPEND LIBCELLML_TESTS ${CURRENT_TEST}) +# Using absolute path relative to this file +set(${CURRENT_TEST}_SRCS + ${CMAKE_CURRENT_LIST_DIR}/logger.cpp +) +set(${CURRENT_TEST}_HDRS +) diff --git a/tests/parser/parser.cpp b/tests/parser/parser.cpp index 706d8f9de..e338717e2 100644 --- a/tests/parser/parser.cpp +++ b/tests/parser/parser.cpp @@ -218,7 +218,7 @@ TEST(Parser, modelWithInvalidElement) p->parseModel(input1); EXPECT_EQ_ERRORS(expectedErrors1, p); - p->removeAllErrors(); + p->removeAllIssues(); p->parseModel(input2); EXPECT_EQ_ERRORS(expectedErrors2, p); } @@ -330,7 +330,7 @@ TEST(Parser, unitsElementErrors) p->parseModel(input1); EXPECT_EQ_ERRORS(expectedErrors1, p); - p->removeAllErrors(); + p->removeAllIssues(); p->parseModel(input2); EXPECT_EQ_ERRORS(expectedErrors2, p); } @@ -425,11 +425,11 @@ TEST(Parser, componentAttributeErrors) p->parseModel(input1); EXPECT_EQ_ERRORS(expectedErrors1, p); - p->removeAllErrors(); + p->removeAllIssues(); p->parseModel(input2); EXPECT_EQ_ERRORS(expectedErrors2, p); - p->removeAllErrors(); + p->removeAllIssues(); p->parseModel(input3); EXPECT_EQ_ERRORS(expectedErrors3, p); } @@ -458,7 +458,7 @@ TEST(Parser, componentElementErrors) EXPECT_EQ(size_t(1), p->errorCount()); EXPECT_EQ(expectError1, p->error(0)->description()); - p->removeAllErrors(); + p->removeAllIssues(); p->parseModel(input2); EXPECT_EQ(size_t(1), p->errorCount()); EXPECT_EQ(expectError2, p->error(0)->description()); @@ -956,7 +956,7 @@ TEST(Parser, variableAttributeAndChildErrors) EXPECT_EQ(size_t(1), p->errorCount()); EXPECT_EQ(expectError1, p->error(0)->description()); - p->removeAllErrors(); + p->removeAllIssues(); p->parseModel(input2); EXPECT_EQ(size_t(2), p->errorCount()); EXPECT_EQ(expectError2, p->error(0)->description()); From a4f2a08636bea54decf26c56293ad2382095f25b Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 15 Jan 2020 16:45:47 +0100 Subject: [PATCH 11/88] Coverage tests for logger and issue classes --- src/logger.cpp | 2 +- tests/issue/issue.cpp | 21 ++++++++++++++++++ tests/logger/logger.cpp | 47 ++++++++++++++++++++++++++++++++++++++++- 3 files changed, 68 insertions(+), 2 deletions(-) diff --git a/src/logger.cpp b/src/logger.cpp index 97414ac6f..f7211e7cc 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -95,7 +95,7 @@ void Logger::addHint(const IssuePtr &issue) size_t Logger::hintCount() const { - return mPimpl->mWarnings.size(); + return mPimpl->mHints.size(); } IssuePtr Logger::hint(size_t index) const diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index 9862f32d9..8f84f5697 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -462,3 +462,24 @@ TEST(Issue, createResetWarning) EXPECT_EQ(libcellml::Issue::Cause::RESET, e->cause()); EXPECT_EQ(libcellml::Issue::Level::WARNING, e->level()); } + +TEST(Issue, isError) +{ + auto e = libcellml::Issue::create(); + e->setLevel(libcellml::Issue::Level::ERROR); + EXPECT_TRUE(e->isLevel(libcellml::Issue::Level::ERROR)); +} + +TEST(Issue, isWarning) +{ + auto e = libcellml::Issue::create(); + e->setLevel(libcellml::Issue::Level::WARNING); + EXPECT_TRUE(e->isLevel(libcellml::Issue::Level::WARNING)); +} + +TEST(Issue, isHint) +{ + auto e = libcellml::Issue::create(); + e->setLevel(libcellml::Issue::Level::HINT); + EXPECT_TRUE(e->isLevel(libcellml::Issue::Level::HINT)); +} diff --git a/tests/logger/logger.cpp b/tests/logger/logger.cpp index a68b0128d..7d3951805 100644 --- a/tests/logger/logger.cpp +++ b/tests/logger/logger.cpp @@ -18,7 +18,7 @@ limitations under the License. #include -TEST(Validator, getIssueByLevel) +TEST(Validator, addIssueGetIssueByLevel) { auto error1 = libcellml::Issue::create(); error1->setLevel(libcellml::Issue::Level::ERROR); @@ -68,3 +68,48 @@ TEST(Validator, getIssueByLevel) EXPECT_EQ(hint1, validator->hint(0)); EXPECT_EQ(hint2, validator->hint(1)); } + +TEST(Logger, addError) +{ + auto err = libcellml::Issue::create(); + err->setLevel(libcellml::Issue::Level::ERROR); + auto logger = libcellml::Validator::create(); + + logger->addError(err); + EXPECT_EQ(size_t(1), logger->issueCount()); + EXPECT_EQ(size_t(1), logger->errorCount()); + EXPECT_EQ(size_t(0), logger->warningCount()); + EXPECT_EQ(size_t(0), logger->hintCount()); + EXPECT_EQ(logger->error(0), err); + EXPECT_EQ(logger->issue(0), err); +} + +TEST(Logger, addWarning) +{ + auto err = libcellml::Issue::create(); + err->setLevel(libcellml::Issue::Level::WARNING); + auto logger = libcellml::Validator::create(); + + logger->addWarning(err); + EXPECT_EQ(size_t(1), logger->issueCount()); + EXPECT_EQ(size_t(0), logger->errorCount()); + EXPECT_EQ(size_t(1), logger->warningCount()); + EXPECT_EQ(size_t(0), logger->hintCount()); + EXPECT_EQ(logger->warning(0), err); + EXPECT_EQ(logger->issue(0), err); +} + +TEST(Logger, addHint) +{ + auto err = libcellml::Issue::create(); + err->setLevel(libcellml::Issue::Level::HINT); + auto logger = libcellml::Validator::create(); + + logger->addHint(err); + EXPECT_EQ(size_t(1), logger->issueCount()); + EXPECT_EQ(size_t(0), logger->errorCount()); + EXPECT_EQ(size_t(0), logger->warningCount()); + EXPECT_EQ(size_t(1), logger->hintCount()); + EXPECT_EQ(logger->hint(0), err); + EXPECT_EQ(logger->issue(0), err); +} From 320f8628d2a3be98e642e06f248cd58ca36bd378 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 16 Jan 2020 10:07:38 +0100 Subject: [PATCH 12/88] Removed sub functions to add error, warning, hint separately --- src/api/libcellml/logger.h | 27 ----- src/bindings/interface/logger.i | 9 -- src/generator.cpp | 14 +-- src/logger.cpp | 20 ---- src/parser.cpp | 132 ++++++++++++------------ src/validator.cpp | 94 ++++++++--------- tests/bindings/python/test_generator.py | 2 +- tests/bindings/python/test_parser.py | 2 +- tests/bindings/python/test_printer.py | 2 +- tests/bindings/python/test_validator.py | 2 +- tests/logger/logger.cpp | 6 +- tests/parser/parser.cpp | 2 +- 12 files changed, 128 insertions(+), 184 deletions(-) diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index ce5941b2d..8e4c23284 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -75,15 +75,6 @@ class LIBCELLML_EXPORT Logger */ IssuePtr issue(size_t index) const; - /** - * @brief Add an issue of level error to the logger. - * - * Adds the argument @p issue to this logger. - * - * @param issue The @c IssuePtr to add. - */ - void addError(const IssuePtr &issue); - /** * @brief Get the number of issues with level of ERROR. * @@ -106,15 +97,6 @@ class LIBCELLML_EXPORT Logger */ IssuePtr error(size_t index) const; - /** - * @brief Add an issue of level WARNING to the logger. - * - * Adds the argument @p issue to this logger. - * - * @param issue The @c IssuePtr to add. - */ - void addWarning(const IssuePtr &issue); - /** * @brief Get the number of issues with level of WARNING. * @@ -137,15 +119,6 @@ class LIBCELLML_EXPORT Logger */ IssuePtr warning(size_t index) const; - /** - * @brief Add an issue of level HINT to the logger. - * - * Adds the argument @p issue to this logger. - * - * @param issue The @c IssuePtr to add. - */ - void addHint(const IssuePtr &issue); - /** * @brief Get the number of issues with level of HINT. * diff --git a/src/bindings/interface/logger.i b/src/bindings/interface/logger.i index 6ba37b96a..2031742b9 100644 --- a/src/bindings/interface/logger.i +++ b/src/bindings/interface/logger.i @@ -19,27 +19,18 @@ %feature("docstring") libcellml::Logger::issueCount "Returns the number of issues currently stored in the logger."; -%feature("docstring") libcellml::Logger::addError -"Adds an issue with level of 'error' to this logger."; - %feature("docstring") libcellml::Logger::error "Returns the issue of level 'error' at the specified 'index'."; %feature("docstring") libcellml::Logger::errorCount "Returns the number of issues of level 'error' currently stored in the logger."; -%feature("docstring") libcellml::Logger::addWarning -"Adds an issue with level of 'warning' to this logger."; - %feature("docstring") libcellml::Logger::warning "Returns the issue of level 'warning' at the specified 'index'."; %feature("docstring") libcellml::Logger::warningCount "Returns the number of issues of level 'warning' currently stored in the logger."; -%feature("docstring") libcellml::Logger::addHint -"Adds an issue with level of 'hint' to this logger."; - %feature("docstring") libcellml::Logger::hint "Returns the issue of level 'hint' at the specified 'index'."; diff --git a/src/generator.cpp b/src/generator.cpp index 1441f7646..71e667c91 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1056,7 +1056,7 @@ void Generator::GeneratorImpl::processNode(const XmlNodePtr &node, + "' is referenced in an equation, but it is not defined anywhere."); err->setCause(Issue::Cause::GENERATOR); - mGenerator->addError(err); + mGenerator->addIssue(err); } } else if (node->isMathmlElement("cn")) { if (mathmlChildCount(node) == 1) { @@ -1175,7 +1175,7 @@ void Generator::GeneratorImpl::processComponent(const ComponentPtr &component) + "' are equivalent and cannot therefore both be initialised."); err->setCause(Issue::Cause::GENERATOR); - mGenerator->addError(err); + mGenerator->addIssue(err); } } @@ -1222,7 +1222,7 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr + "' cannot be both a variable of integration and initialised."); err->setCause(Issue::Cause::GENERATOR); - mGenerator->addError(err); + mGenerator->addIssue(err); } else { mVoi = variable; } @@ -1243,7 +1243,7 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr + "' cannot both be a variable of integration."); err->setCause(Issue::Cause::GENERATOR); - mGenerator->addError(err); + mGenerator->addIssue(err); } } @@ -1265,7 +1265,7 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr + "' must be of the first order."); err->setCause(Issue::Cause::GENERATOR); - mGenerator->addError(err); + mGenerator->addIssue(err); } } @@ -1445,7 +1445,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) + "' of model '" + realModel->name() + "' " + errorType + "."); err->setCause(Issue::Cause::GENERATOR); - mGenerator->addError(err); + mGenerator->addIssue(err); } } } @@ -3431,7 +3431,7 @@ void Generator::processModel(const ModelPtr &model) // them our own. for (size_t i = 0; i < validator->errorCount(); ++i) { - addError(validator->error(i)); + addIssue(validator->error(i)); } return; diff --git a/src/logger.cpp b/src/logger.cpp index f7211e7cc..caa903547 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -47,12 +47,6 @@ Logger::~Logger() delete mPimpl; } -void Logger::addError(const IssuePtr &issue) -{ - mPimpl->mIssues.push_back(issue); - mPimpl->mErrors.push_back(mPimpl->mIssues.size() - 1); -} - size_t Logger::errorCount() const { return mPimpl->mErrors.size(); @@ -67,12 +61,6 @@ IssuePtr Logger::error(size_t index) const return err; } -void Logger::addWarning(const IssuePtr &issue) -{ - mPimpl->mIssues.push_back(issue); - mPimpl->mWarnings.push_back(mPimpl->mIssues.size() - 1); -} - size_t Logger::warningCount() const { return mPimpl->mWarnings.size(); @@ -87,12 +75,6 @@ IssuePtr Logger::warning(size_t index) const return err; } -void Logger::addHint(const IssuePtr &issue) -{ - mPimpl->mIssues.push_back(issue); - mPimpl->mHints.push_back(mPimpl->mIssues.size() - 1); -} - size_t Logger::hintCount() const { return mPimpl->mHints.size(); @@ -107,8 +89,6 @@ IssuePtr Logger::hint(size_t index) const return err; } -// KRM Changes start from here - void Logger::removeAllIssues() { mPimpl->mIssues.clear(); diff --git a/src/parser.cpp b/src/parser.cpp index 35e660713..2234ea6b8 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -237,7 +237,7 @@ ModelPtr Parser::parseModel(const std::string &input) err->setDescription("Model is empty."); err->setCause(Issue::Cause::XML); err->setModel(model); - addError(err); + addIssue(err); } else { mPimpl->updateModel(model, input); } @@ -259,7 +259,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr err = Issue::create(); err->setDescription("LibXml2 error: " + doc->xmlError(i)); err->setCause(Issue::Cause::XML); - mParser->addError(err); + mParser->addIssue(err); } } const XmlNodePtr node = doc->rootNode(); @@ -267,7 +267,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr err = Issue::create(); err->setDescription("Could not get a valid XML root node from the provided input."); err->setCause(Issue::Cause::XML); - mParser->addError(err); + mParser->addIssue(err); return; } if (!node->isCellmlElement("model")) { @@ -283,7 +283,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp } err->setModel(model); err->setRule(SpecificationRule::MODEL_ELEMENT); - mParser->addError(err); + mParser->addIssue(err); return; } // Get model attributes. @@ -297,7 +297,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr err = Issue::create(); err->setDescription("Model '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); err->setModel(model); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -330,7 +330,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid attribute '" + childAttribute->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addError(err); + mParser->addIssue(err); } childAttribute = childAttribute->next(); } @@ -348,7 +348,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::ENCAPSULATION_COMPONENT_REF); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isCellmlElement("connection")) { connectionNodes.push_back(childNode); @@ -360,7 +360,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setDescription("Model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); err->setRule(SpecificationRule::MODEL_CHILD); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. @@ -369,7 +369,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setDescription("Model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setModel(model); err->setRule(SpecificationRule::MODEL_CHILD); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); } @@ -382,7 +382,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); - mParser->addError(err); + mParser->addIssue(err); } } for (const auto &connectionNode : connectionNodes) { @@ -493,7 +493,7 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN IssuePtr err = Issue::create(); err->setDescription("Component '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); err->setComponent(component); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -529,7 +529,7 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN err->setDescription("Component '" + component->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setComponent(component); err->setRule(SpecificationRule::COMPONENT_CHILD); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. @@ -538,7 +538,7 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN err->setDescription("Component '" + component->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setComponent(component); err->setRule(SpecificationRule::COMPONENT_CHILD); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); } @@ -556,7 +556,7 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node IssuePtr err = Issue::create(); err->setDescription("Units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); err->setUnits(units); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -572,7 +572,7 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node err->setDescription("Units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setUnits(units); err->setRule(SpecificationRule::UNITS_CHILD); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. @@ -581,7 +581,7 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node err->setDescription("Units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setUnits(units); err->setRule(SpecificationRule::UNITS_CHILD); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); } @@ -604,7 +604,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr err = Issue::create(); err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setUnits(units); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. @@ -612,7 +612,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr err = Issue::create(); err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setUnits(units); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); } @@ -632,7 +632,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an exponent with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_EXPONENT); - mParser->addError(err); + mParser->addIssue(err); } } else if (attribute->isType("multiplier")) { if (isCellMLReal(attribute->value())) { @@ -643,7 +643,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has a multiplier with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_MULTIPLIER); - mParser->addError(err); + mParser->addIssue(err); } } else if (attribute->isType("id")) { id = attribute->value(); @@ -652,7 +652,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_OPTIONAL_ATTRIBUTE); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -672,7 +672,7 @@ void Parser::ParserImpl::loadVariable(const VariablePtr &variable, const XmlNode IssuePtr err = Issue::create(); err->setDescription("Variable '" + node->attribute("name") + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setVariable(variable); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. @@ -680,7 +680,7 @@ void Parser::ParserImpl::loadVariable(const VariablePtr &variable, const XmlNode IssuePtr err = Issue::create(); err->setDescription("Variable '" + node->attribute("name") + "' has an invalid child element '" + childNode->name() + "'."); err->setVariable(variable); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); } @@ -700,7 +700,7 @@ void Parser::ParserImpl::loadVariable(const VariablePtr &variable, const XmlNode IssuePtr err = Issue::create(); err->setDescription("Variable '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); err->setVariable(variable); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -740,7 +740,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' has an invalid connection attribute '" + attribute->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -751,7 +751,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT1); - mParser->addError(err); + mParser->addIssue(err); component1Missing = true; } if (component2Name.empty()) { @@ -760,7 +760,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT2); - mParser->addError(err); + mParser->addIssue(err); component2Missing = true; } componentNamePair = std::make_pair(component1Name, component2Name); @@ -774,7 +774,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_MAP_VARIABLES); - mParser->addError(err); + mParser->addIssue(err); return; } @@ -791,7 +791,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mParser->addError(err); + mParser->addIssue(err); } } else if (grandchildNode->isComment()) { // Do nothing. @@ -800,7 +800,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' has an invalid child element '" + grandchildNode->name() + "' of element '" + childNode->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mParser->addError(err); + mParser->addIssue(err); } grandchildNode = grandchildNode->next(); } @@ -821,7 +821,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' has an invalid map_variables attribute '" + childAttribute->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mParser->addError(err); + mParser->addIssue(err); } childAttribute = childAttribute->next(); } @@ -832,7 +832,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); - mParser->addError(err); + mParser->addIssue(err); variable1Missing = true; } if (variable2Name.empty()) { @@ -841,7 +841,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); - mParser->addError(err); + mParser->addIssue(err); variable2Missing = true; } // We can have multiple map_variables per connection. @@ -857,7 +857,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. @@ -866,7 +866,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); @@ -885,7 +885,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT1); - mParser->addError(err); + mParser->addIssue(err); } } if (model->containsComponent(componentNamePair.second)) { @@ -897,7 +897,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_COMPONENT2); - mParser->addError(err); + mParser->addIssue(err); } } @@ -921,7 +921,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setComponent(component1); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); - mParser->addError(err); + mParser->addIssue(err); } } } else { @@ -930,7 +930,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); - mParser->addError(err); + mParser->addIssue(err); } if (component2) { if (component2->hasVariable(iterPair.second)) { @@ -947,7 +947,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setComponent(component1); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); - mParser->addError(err); + mParser->addIssue(err); } } } else { @@ -956,7 +956,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); - mParser->addError(err); + mParser->addIssue(err); } // Set the variable equivalence relationship for this variable pair. if ((variable1) && (variable2)) { @@ -969,7 +969,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setModel(model); err->setCause(Issue::Cause::CONNECTION); err->setRule(SpecificationRule::CONNECTION_MAP_VARIABLES); - mParser->addError(err); + mParser->addIssue(err); } } @@ -992,7 +992,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); - mParser->addError(err); + mParser->addIssue(err); } } else if (attribute->isType("id")) { encapsulationId = attribute->value(); @@ -1002,7 +1002,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -1012,7 +1012,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); - mParser->addError(err); + mParser->addIssue(err); } else if (parentComponent) { parentComponent->setEncapsulationId(encapsulationId); } @@ -1034,7 +1034,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addError(err); + mParser->addIssue(err); } } else if (childComponentNode->isComment()) { // Do nothing. @@ -1043,7 +1043,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + childComponentNode->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addError(err); + mParser->addIssue(err); } if ((parentComponent) && (childComponent)) { @@ -1075,7 +1075,7 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::COMPONENT_REF_CHILD); - mParser->addError(err); + mParser->addIssue(err); } else { // Continue to next node if this is whitespace (don't try to parse children of whitespace). componentRefNode = componentRefNode->next(); @@ -1089,7 +1089,7 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); err->setRule(SpecificationRule::ENCAPSULATION_COMPONENT_REF); - mParser->addError(err); + mParser->addIssue(err); } // Add the parentComponent to the model with its child(ren) encapsulated. @@ -1100,14 +1100,14 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP err->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponent->name() + "' as a parent component_ref but it does not have any children."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addError(err); + mParser->addIssue(err); } } else if (!parentComponent && haveComponentRef) { IssuePtr err = Issue::create(); err->setDescription("Encapsulation in model '" + model->name() + "' specifies an invalid parent component_ref that also does not have any children."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addError(err); + mParser->addIssue(err); } componentRefNode = componentRefNode->next(); @@ -1128,7 +1128,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M IssuePtr err = Issue::create(); err->setDescription("Import from '" + node->attribute("href") + "' has an invalid attribute '" + attribute->name() + "'."); err->setImportSource(importSource); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -1149,7 +1149,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M IssuePtr err = Issue::create(); err->setDescription("Import of component '" + childNode->attribute("name") + "' from '" + node->attribute("href") + "' has an invalid attribute '" + childAttribute->name() + "'."); err->setImportSource(importSource); - mParser->addError(err); + mParser->addIssue(err); errorOccurred = true; } childAttribute = childAttribute->next(); @@ -1172,7 +1172,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M IssuePtr err = Issue::create(); err->setDescription("Import of units '" + childNode->attribute("name") + "' from '" + node->attribute("href") + "' has an invalid attribute '" + childAttribute->name() + "'."); err->setImportSource(importSource); - mParser->addError(err); + mParser->addIssue(err); errorOccurred = true; } childAttribute = childAttribute->next(); @@ -1188,7 +1188,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M err->setDescription("Import from '" + node->attribute("href") + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setImportSource(importSource); err->setRule(SpecificationRule::IMPORT_CHILD); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. @@ -1197,7 +1197,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M err->setDescription("Import from '" + node->attribute("href") + "' has an invalid child element '" + childNode->name() + "'."); err->setImportSource(importSource); err->setRule(SpecificationRule::IMPORT_CHILD); - mParser->addError(err); + mParser->addIssue(err); } childNode = childNode->next(); } @@ -1230,7 +1230,7 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' has an unexpected attribute in the " + childType + " block of '" + childAttribute->name() + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mParser->addError(err); + mParser->addIssue(err); } childAttribute = childAttribute->next(); } @@ -1254,7 +1254,7 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese err->setDescription("The " + childType + " in the reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' should have a MathML block as a child."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mParser->addError(err); + mParser->addIssue(err); } } mathNode = mathNode->next(); @@ -1280,7 +1280,7 @@ void Parser::ParserImpl::checkResetChildMultiplicity(size_t count, const std::st + variableName + "' and test_variable '" + testVariableName + "' has " + convertToString(count) + " " + childType + " blocks."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mParser->addError(err); + mParser->addIssue(err); } if (count == 0) { IssuePtr err = Issue::create(); @@ -1288,7 +1288,7 @@ void Parser::ParserImpl::checkResetChildMultiplicity(size_t count, const std::st + variableName + "' and test_variable '" + testVariableName + "' does not have a " + childType + " block defined."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mParser->addError(err); + mParser->addIssue(err); } } @@ -1314,7 +1314,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co err->setDescription("Reset referencing variable '" + variableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_VARIABLE_REFERENCE); - mParser->addError(err); + mParser->addIssue(err); } else { reset->setVariable(referencedVariable); } @@ -1327,7 +1327,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co err->setDescription("Reset referencing test_variable '" + testVariableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); - mParser->addError(err); + mParser->addIssue(err); } else { reset->setTestVariable(testVariable); } @@ -1344,7 +1344,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' has a non-integer order value '" + attribute->value() + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_ORDER); - mParser->addError(err); + mParser->addIssue(err); } } else if (attribute->isType("id")) { reset->setId(attribute->value()); @@ -1352,7 +1352,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr err = Issue::create(); err->setDescription("Reset in component '" + component->name() + "' has an invalid attribute '" + attribute->name() + "'."); err->setReset(reset); - mParser->addError(err); + mParser->addIssue(err); } attribute = attribute->next(); } @@ -1364,7 +1364,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co err->setDescription("Reset in component '" + component->name() + "' does not have its order set."); err->setReset(reset); err->setRule(SpecificationRule::RESET_ORDER); - mParser->addError(err); + mParser->addIssue(err); } XmlNodePtr childNode = node->firstChild(); @@ -1386,7 +1386,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co err->setDescription("Reset has an invalid non-whitespace child text element '" + textNode + "'. Either a test_value block or a reset_value block is expected."); err->setReset(reset); err->setRule(SpecificationRule::RESET_CHILD); - mParser->addError(err); + mParser->addIssue(err); } } else if (childNode->isComment()) { // Do nothing. diff --git a/src/validator.cpp b/src/validator.cpp index 4a71770ef..4ac9c8049 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -286,7 +286,7 @@ void Validator::validateModel(const ModelPtr &model) err->setDescription("Model does not have a valid name attribute."); err->setModel(model); err->setRule(SpecificationRule::MODEL_NAME); - addError(err); + addIssue(err); } // Check for components in this model. if (model->componentCount() > 0) { @@ -315,7 +315,7 @@ void Validator::validateModel(const ModelPtr &model) err->setDescription("Imported units '" + unitsName + "' does not have a valid units_ref attribute."); err->setUnits(units); err->setRule(SpecificationRule::IMPORT_UNITS_REF); - addError(err); + addIssue(err); foundImportError = true; } // Check for a xlink:href. @@ -325,7 +325,7 @@ void Validator::validateModel(const ModelPtr &model) err->setDescription("Import of units '" + unitsName + "' does not have a valid locator xlink:href attribute."); err->setImportSource(units->importSource()); err->setRule(SpecificationRule::IMPORT_HREF); - addError(err); + addIssue(err); foundImportError = true; } // Check if we already have another import from the same source with the same units_ref. @@ -337,7 +337,7 @@ void Validator::validateModel(const ModelPtr &model) err->setDescription("Model '" + model->name() + "' contains multiple imported units from '" + importSource + "' with the same units_ref attribute '" + unitsRef + "'."); err->setModel(model); err->setRule(SpecificationRule::IMPORT_UNITS_REF); - addError(err); + addIssue(err); } } // Push back the unique sources and refs. @@ -350,7 +350,7 @@ void Validator::validateModel(const ModelPtr &model) err->setDescription("Model '" + model->name() + "' contains multiple units with the name '" + unitsName + "'. Valid units names must be unique to their model."); err->setModel(model); err->setRule(SpecificationRule::UNITS_NAME_UNIQUE); - addError(err); + addIssue(err); } unitsNames.push_back(unitsName); } @@ -378,7 +378,7 @@ void Validator::ValidatorImpl::validateUniqueName(const ModelPtr &model, const s IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' contains multiple components with the name '" + name + "'. Valid component names must be unique to their model."); err->setModel(model); - mValidator->addError(err); + mValidator->addIssue(err); } else { names.push_back(name); } @@ -406,7 +406,7 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com err->setComponent(component); err->setDescription("Imported component does not have a valid name attribute."); err->setRule(SpecificationRule::IMPORT_COMPONENT_NAME); - mValidator->addError(err); + mValidator->addIssue(err); } // Check for a component_ref; assumes imported if the import source is not null. @@ -419,14 +419,14 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com err->setDescription("Imported component '" + componentName + "' does not have a valid component_ref attribute."); err->setComponent(component); err->setRule(SpecificationRule::IMPORT_COMPONENT_REF); - mValidator->addError(err); + mValidator->addIssue(err); } if (importSource.empty()) { IssuePtr err = Issue::create(); err->setDescription("Import of component '" + componentName + "' does not have a valid locator xlink:href attribute."); err->setImportSource(component->importSource()); err->setRule(SpecificationRule::IMPORT_HREF); - mValidator->addError(err); + mValidator->addIssue(err); } else { xmlURIPtr uri = xmlParseURI(importSource.c_str()); if (uri == nullptr) { @@ -434,7 +434,7 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com err->setDescription("Import of component '" + componentName + "' has an invalid URI in the href attribute."); err->setImportSource(component->importSource()); err->setRule(SpecificationRule::IMPORT_HREF); - mValidator->addError(err); + mValidator->addIssue(err); } else { xmlFreeURI(uri); @@ -450,7 +450,7 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) err->setComponent(component); err->setDescription("Component does not have a valid name attribute."); err->setRule(SpecificationRule::COMPONENT_NAME); - mValidator->addError(err); + mValidator->addIssue(err); } // Check for variables in this component. std::vector variableNames; @@ -465,7 +465,7 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) err->setDescription("Component '" + component->name() + "' contains multiple variables with the name '" + variableName + "'. Valid variable names must be unique to their component."); err->setComponent(component); err->setRule(SpecificationRule::VARIABLE_NAME); - mValidator->addError(err); + mValidator->addIssue(err); } variableNames.push_back(variableName); } @@ -501,7 +501,7 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v err->setDescription("Units does not have a valid name attribute."); err->setRule(SpecificationRule::UNITS_NAME); } - mValidator->addError(err); + mValidator->addIssue(err); } else { // Check for a matching standard units. if (isStandardUnitName(units->name())) { @@ -509,7 +509,7 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v err->setDescription("Units is named '" + units->name() + "' which is a protected standard unit name."); err->setUnits(units); err->setRule(SpecificationRule::UNITS_STANDARD); - mValidator->addError(err); + mValidator->addIssue(err); } } if (units->unitCount() > 0) { @@ -535,14 +535,14 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u err->setDescription("Units reference '" + reference + "' in units '" + units->name() + "' is not a valid reference to a local units or a standard unit type."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_UNITS_REF); - mValidator->addError(err); + mValidator->addIssue(err); } } else { IssuePtr err = Issue::create(); err->setDescription("Unit in units '" + units->name() + "' does not have a valid units reference."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_UNITS_REF); - mValidator->addError(err); + mValidator->addIssue(err); } if (!prefix.empty()) { if (!isStandardPrefixName(prefix)) { @@ -551,7 +551,7 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u err->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is not a valid integer or an SI prefix."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_PREFIX); - mValidator->addError(err); + mValidator->addIssue(err); } else { try { int test = std::stoi(prefix); @@ -561,7 +561,7 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u err->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is out of the integer range."); err->setUnits(units); err->setRule(SpecificationRule::UNIT_PREFIX); - mValidator->addError(err); + mValidator->addIssue(err); } } } @@ -576,7 +576,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con err->setDescription("Variable does not have a valid name attribute."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_NAME); - mValidator->addError(err); + mValidator->addIssue(err); } // Check for a valid units attribute. std::string unitsName = variable->units() != nullptr ? variable->units()->name() : ""; @@ -585,7 +585,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con err->setDescription("Variable '" + variable->name() + "' does not have a valid units attribute."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_UNITS); - mValidator->addError(err); + mValidator->addIssue(err); } else if (!isStandardUnitName(unitsName)) { ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); ModelPtr model = owningModel(component); @@ -594,7 +594,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con err->setDescription("Variable '" + variable->name() + "' has a units reference '" + unitsName + "' that does not correspond with a standard units and is not a units defined in the variable's model."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_UNITS); - mValidator->addError(err); + mValidator->addIssue(err); } } // Check for a valid interface attribute. @@ -605,7 +605,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con err->setDescription("Variable '" + variable->name() + "' has an invalid interface attribute value '" + interfaceType + "'."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_INTERFACE); - mValidator->addError(err); + mValidator->addIssue(err); } } // Check for a valid initial value attribute. @@ -619,7 +619,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con err->setDescription("Variable '" + variable->name() + "' has an invalid initial value '" + initialValue + "'. Initial values must be a real number string or a variable reference."); err->setVariable(variable); err->setRule(SpecificationRule::VARIABLE_INITIAL_VALUE); - mValidator->addError(err); + mValidator->addIssue(err); } } } @@ -690,49 +690,49 @@ void Validator::ValidatorImpl::validateReset(const ResetPtr &reset, const Compon err->setDescription(description + "does not have an order set."); err->setComponent(component); err->setRule(SpecificationRule::RESET_ORDER); - mValidator->addError(err); + mValidator->addIssue(err); } if (noVariable) { IssuePtr err = Issue::create(); err->setDescription(description + "does not reference a variable."); err->setReset(reset); err->setRule(SpecificationRule::RESET_VARIABLE_REFERENCE); - mValidator->addError(err); + mValidator->addIssue(err); } if (noTestVariable) { IssuePtr err = Issue::create(); err->setDescription(description + "does not reference a test_variable."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); - mValidator->addError(err); + mValidator->addIssue(err); } if (noTestValue) { IssuePtr err = Issue::create(); err->setDescription(description + "does not have a test_value specified."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VALUE); - mValidator->addError(err); + mValidator->addIssue(err); } if (noResetValue) { IssuePtr err = Issue::create(); err->setDescription(description + "does not have a reset_value specified."); err->setReset(reset); err->setRule(SpecificationRule::RESET_RESET_VALUE); - mValidator->addError(err); + mValidator->addIssue(err); } if (varOutsideComponent) { IssuePtr err = Issue::create(); err->setDescription(description + "refers to a variable '" + reset->variable()->name() + "' in a different component '" + varParentName + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_VARIABLE_REFERENCE); - mValidator->addError(err); + mValidator->addIssue(err); } if (testVarOutsideComponent) { IssuePtr err = Issue::create(); err->setDescription(description + "refers to a test_variable '" + reset->testVariable()->name() + "' in a different component '" + testVarParentName + "'."); err->setReset(reset); err->setRule(SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); - mValidator->addError(err); + mValidator->addIssue(err); } } @@ -747,7 +747,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp IssuePtr err = Issue::create(); err->setDescription("LibXml2 error: " + doc->xmlError(i)); err->setCause(Issue::Cause::XML); - mValidator->addError(err); + mValidator->addIssue(err); } } XmlNodePtr node = doc->rootNode(); @@ -756,7 +756,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp err->setDescription("Could not get a valid XML root node from the math on component '" + component->name() + "'."); err->setCause(Issue::Cause::XML); err->setComponent(component); - mValidator->addError(err); + mValidator->addIssue(err); return; } if (!node->isMathmlElement("math")) { @@ -764,7 +764,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp err->setDescription("Math root node is of invalid type '" + node->name() + "' on component '" + component->name() + "'. A valid math root node should be of type 'math'."); err->setComponent(component); err->setCause(Issue::Cause::XML); - mValidator->addError(err); + mValidator->addIssue(err); return; } @@ -801,7 +801,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp err->setDescription("W3C MathML DTD error: " + mathmlDoc->xmlError(i)); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addError(err); + mValidator->addIssue(err); } } } @@ -816,7 +816,7 @@ bool Validator::ValidatorImpl::validateCnUnits(const ComponentPtr &component, co err->setDescription("Math cn element with the value '" + textNode + "' does not have a valid cellml:units attribute."); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addError(err); + mValidator->addIssue(err); return false; } @@ -850,7 +850,7 @@ void Validator::ValidatorImpl::validateAndCleanCnNode(const XmlNodePtr &node, co err->setDescription("Math " + node->name() + " element has an invalid attribute type '" + attribute->name() + "' in the cellml namespace. Attribute 'units' is the only CellML namespace attribute allowed."); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addError(err); + mValidator->addIssue(err); } } attribute = attribute->next(); @@ -872,7 +872,7 @@ void Validator::ValidatorImpl::validateAndCleanCnNode(const XmlNodePtr &node, co err->setDescription("Math has a " + node->name() + " element with a cellml:units attribute '" + unitsName + "' that is not a valid reference to units in the model '" + model->name() + "' or a standard unit."); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addError(err); + mValidator->addIssue(err); } } } @@ -898,7 +898,7 @@ void Validator::ValidatorImpl::validateAndCleanCiNode(const XmlNodePtr &node, co err->setDescription("MathML ci element has the child text '" + textInNode + "' which does not correspond with any variable names present in component '" + component->name() + "'."); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addError(err); + mValidator->addIssue(err); } } } @@ -931,7 +931,7 @@ void Validator::ValidatorImpl::validateMathMLElements(const XmlNodePtr &node, co err->setDescription("Math has a '" + childNode->name() + "' element that is not a supported MathML element."); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addError(err); + mValidator->addIssue(err); } validateMathMLElements(childNode, component); } @@ -943,7 +943,7 @@ void Validator::ValidatorImpl::validateMathMLElements(const XmlNodePtr &node, co err->setDescription("Math has a '" + nextNode->name() + "' element that is not a supported MathML element."); err->setComponent(component); err->setCause(Issue::Cause::MATHML); - mValidator->addError(err); + mValidator->addIssue(err); } validateMathMLElements(nextNode, component); } @@ -984,7 +984,7 @@ void Validator::ValidatorImpl::validateConnections(const ModelPtr &model) err->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); err->setModel(model); err->setCause(Issue::Cause::UNITS); - mValidator->addError(err); + mValidator->addIssue(err); } // } else if (multiplier != 0.0) { // // KRM Warning when the multipliers are not the same. @@ -995,7 +995,7 @@ void Validator::ValidatorImpl::validateConnections(const ModelPtr &model) // err->setModel(model); // err->setLevel(libcellml::Issue::Level::WARNING); // err->setCause(Issue::Cause::UNITS); - // mValidator->addError(err); + // mValidator->addIssue(err); // } if (equivalentVariable->hasEquivalentVariable(variable)) { @@ -1006,7 +1006,7 @@ void Validator::ValidatorImpl::validateConnections(const ModelPtr &model) err->setDescription("Variable '" + equivalentVariable->name() + "' is an equivalent variable to '" + variable->name() + "' but '" + equivalentVariable->name() + "' has no parent component."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - mValidator->addError(err); + mValidator->addIssue(err); } } } @@ -1034,7 +1034,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) IssuePtr err = Issue::create(); err->setDescription("CellML identifiers must not begin with a European numeric character [0-9]."); err->setRule(SpecificationRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); - mValidator->addError(err); + mValidator->addIssue(err); } else { // Basic Latin alphanumeric characters and underscores. if (name.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_") != std::string::npos) { @@ -1042,7 +1042,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) IssuePtr err = Issue::create(); err->setDescription("CellML identifiers must not contain any characters other than [a-zA-Z0-9_]."); err->setRule(SpecificationRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); - mValidator->addError(err); + mValidator->addIssue(err); } } } else { @@ -1050,7 +1050,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) IssuePtr err = Issue::create(); err->setDescription("CellML identifiers must contain one or more basic Latin alphabetic characters."); err->setRule(SpecificationRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); - mValidator->addError(err); + mValidator->addIssue(err); } return result; } @@ -1208,7 +1208,7 @@ void Validator::ValidatorImpl::validateNoUnitsAreCyclic(const ModelPtr &model) err->setDescription("Cyclic units exist: " + des); err->setModel(model); err->setCause(Issue::Cause::UNITS); - mValidator->addError(err); + mValidator->addIssue(err); reportedErrorList.push_back(hash); } std::map().swap(hash); diff --git a/tests/bindings/python/test_generator.py b/tests/bindings/python/test_generator.py index 6ab5edc33..6ed221b96 100644 --- a/tests/bindings/python/test_generator.py +++ b/tests/bindings/python/test_generator.py @@ -33,7 +33,7 @@ def test_inheritance(self): self.assertIsNone(x.error(0)) self.assertIsNone(x.error(-1)) self.assertEqual(x.errorCount(), 0) - x.addError(libcellml.Issue()) + x.addIssue(libcellml.Issue()) self.assertEqual(x.errorCount(), 1) def test_process_model(self): diff --git a/tests/bindings/python/test_parser.py b/tests/bindings/python/test_parser.py index 80a5df661..55c16226c 100644 --- a/tests/bindings/python/test_parser.py +++ b/tests/bindings/python/test_parser.py @@ -23,7 +23,7 @@ def test_inheritance(self): self.assertIsNone(x.error(0)) self.assertIsNone(x.error(-1)) self.assertEqual(x.errorCount(), 0) - x.addError(libcellml.Issue()) + x.addIssue(libcellml.Issue()) self.assertEqual(x.errorCount(), 1) def test_parse_model(self): diff --git a/tests/bindings/python/test_printer.py b/tests/bindings/python/test_printer.py index 05d9c4589..14336ac31 100644 --- a/tests/bindings/python/test_printer.py +++ b/tests/bindings/python/test_printer.py @@ -23,7 +23,7 @@ def test_inheritance(self): self.assertIsNone(x.error(0)) self.assertIsNone(x.error(-1)) self.assertEqual(x.errorCount(), 0) - x.addError(libcellml.Issue()) + x.addIssue(libcellml.Issue()) self.assertEqual(x.errorCount(), 1) def test_print_model(self): diff --git a/tests/bindings/python/test_validator.py b/tests/bindings/python/test_validator.py index 0701ee011..2fcc24092 100644 --- a/tests/bindings/python/test_validator.py +++ b/tests/bindings/python/test_validator.py @@ -24,7 +24,7 @@ def test_inheritance(self): self.assertIsNone(x.error(0)) self.assertIsNone(x.error(-1)) self.assertEqual(x.errorCount(), 0) - x.addError(libcellml.Issue()) + x.addIssue(libcellml.Issue()) self.assertEqual(x.errorCount(), 1) def test_validate_model(self): diff --git a/tests/logger/logger.cpp b/tests/logger/logger.cpp index 7d3951805..9b58cd4a7 100644 --- a/tests/logger/logger.cpp +++ b/tests/logger/logger.cpp @@ -75,7 +75,7 @@ TEST(Logger, addError) err->setLevel(libcellml::Issue::Level::ERROR); auto logger = libcellml::Validator::create(); - logger->addError(err); + logger->addIssue(err); EXPECT_EQ(size_t(1), logger->issueCount()); EXPECT_EQ(size_t(1), logger->errorCount()); EXPECT_EQ(size_t(0), logger->warningCount()); @@ -90,7 +90,7 @@ TEST(Logger, addWarning) err->setLevel(libcellml::Issue::Level::WARNING); auto logger = libcellml::Validator::create(); - logger->addWarning(err); + logger->addIssue(err); EXPECT_EQ(size_t(1), logger->issueCount()); EXPECT_EQ(size_t(0), logger->errorCount()); EXPECT_EQ(size_t(1), logger->warningCount()); @@ -105,7 +105,7 @@ TEST(Logger, addHint) err->setLevel(libcellml::Issue::Level::HINT); auto logger = libcellml::Validator::create(); - logger->addHint(err); + logger->addIssue(err); EXPECT_EQ(size_t(1), logger->issueCount()); EXPECT_EQ(size_t(0), logger->errorCount()); EXPECT_EQ(size_t(0), logger->warningCount()); diff --git a/tests/parser/parser.cpp b/tests/parser/parser.cpp index e338717e2..e498f4342 100644 --- a/tests/parser/parser.cpp +++ b/tests/parser/parser.cpp @@ -1411,7 +1411,7 @@ TEST(Parser, invalidModelWithAllCausesOfErrors) libcellml::ParserPtr parser2 = libcellml::Parser::create(); // Add an undefined error libcellml::IssuePtr undefinedError = libcellml::Issue::create(); - parser2->addError(undefinedError); + parser2->addIssue(undefinedError); EXPECT_EQ(size_t(1), parser2->errorCount()); if (parser2->error(0)->isCause(libcellml::Issue::Cause::UNDEFINED)) { foundCause.at(7) = true; From 083c1807c189917f7ff6708bc3852a0de7ca843d Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 16 Jan 2020 10:46:57 +0100 Subject: [PATCH 13/88] Get issue by index and level --- src/api/libcellml/logger.h | 15 +++++ src/logger.cpp | 24 +++++++ tests/logger/logger.cpp | 127 ++++++++++++++++++++++++++----------- 3 files changed, 128 insertions(+), 38 deletions(-) diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index 8e4c23284..5afb66bd5 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -75,6 +75,21 @@ class LIBCELLML_EXPORT Logger */ IssuePtr issue(size_t index) const; + /** + * @brief Get issue of specified @p level at the specified @p index. + * + * Returns an issue at the @p index. If the @p index + * is not valid a @c nullptr is returned, the valid range for the @p index + * is [0, \#issues_of_level). + * + * @param index The index of the issue to return. + * @param level The level of issue to return. + * + * @return A reference to the issue from the list of issues at the given level, + * at the given index on success, @c nullptr otherwise. + */ + IssuePtr issue(size_t index, libcellml::Issue::Level level) const; + /** * @brief Get the number of issues with level of ERROR. * diff --git a/src/logger.cpp b/src/logger.cpp index caa903547..65a27c17f 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -130,4 +130,28 @@ IssuePtr Logger::issue(size_t index) const return err; } +IssuePtr Logger::issue(size_t index, libcellml::Issue::Level level) const +{ + // Update the appropriate array based on its level + IssuePtr err = nullptr; + switch (level) { + case libcellml::Issue::Level::ERROR: + if ((index < mPimpl->mErrors.size()) && (mPimpl->mErrors.at(index) < mPimpl->mIssues.size())) { + err = mPimpl->mIssues.at(mPimpl->mErrors.at(index)); + } + return err; + case libcellml::Issue::Level::WARNING: + if ((index < mPimpl->mWarnings.size()) && (mPimpl->mWarnings.at(index) < mPimpl->mIssues.size())) { + err = mPimpl->mIssues.at(mPimpl->mWarnings.at(index)); + } + return err; + case libcellml::Issue::Level::HINT: + if ((index < mPimpl->mHints.size()) && (mPimpl->mHints.at(index) < mPimpl->mIssues.size())) { + err = mPimpl->mIssues.at(mPimpl->mHints.at(index)); + } + return err; + } + return err; +} + } // namespace libcellml diff --git a/tests/logger/logger.cpp b/tests/logger/logger.cpp index 9b58cd4a7..d3de285d4 100644 --- a/tests/logger/logger.cpp +++ b/tests/logger/logger.cpp @@ -18,7 +18,52 @@ limitations under the License. #include -TEST(Validator, addIssueGetIssueByLevel) +TEST(Logger, addError) +{ + auto err = libcellml::Issue::create(); + err->setLevel(libcellml::Issue::Level::ERROR); + auto logger = libcellml::Validator::create(); + + logger->addIssue(err); + EXPECT_EQ(size_t(1), logger->issueCount()); + EXPECT_EQ(size_t(1), logger->errorCount()); + EXPECT_EQ(size_t(0), logger->warningCount()); + EXPECT_EQ(size_t(0), logger->hintCount()); + EXPECT_EQ(logger->error(0), err); + EXPECT_EQ(logger->issue(0), err); +} + +TEST(Logger, addWarning) +{ + auto err = libcellml::Issue::create(); + err->setLevel(libcellml::Issue::Level::WARNING); + auto logger = libcellml::Validator::create(); + + logger->addIssue(err); + EXPECT_EQ(size_t(1), logger->issueCount()); + EXPECT_EQ(size_t(0), logger->errorCount()); + EXPECT_EQ(size_t(1), logger->warningCount()); + EXPECT_EQ(size_t(0), logger->hintCount()); + EXPECT_EQ(logger->warning(0), err); + EXPECT_EQ(logger->issue(0), err); +} + +TEST(Logger, addHint) +{ + auto err = libcellml::Issue::create(); + err->setLevel(libcellml::Issue::Level::HINT); + auto logger = libcellml::Validator::create(); + + logger->addIssue(err); + EXPECT_EQ(size_t(1), logger->issueCount()); + EXPECT_EQ(size_t(0), logger->errorCount()); + EXPECT_EQ(size_t(0), logger->warningCount()); + EXPECT_EQ(size_t(1), logger->hintCount()); + EXPECT_EQ(logger->hint(0), err); + EXPECT_EQ(logger->issue(0), err); +} + +TEST(Validator, getIssueByLevelFunction) { auto error1 = libcellml::Issue::create(); error1->setLevel(libcellml::Issue::Level::ERROR); @@ -69,47 +114,53 @@ TEST(Validator, addIssueGetIssueByLevel) EXPECT_EQ(hint2, validator->hint(1)); } -TEST(Logger, addError) +TEST(Validator, getIssueByLevelArgument) { - auto err = libcellml::Issue::create(); - err->setLevel(libcellml::Issue::Level::ERROR); - auto logger = libcellml::Validator::create(); + auto error1 = libcellml::Issue::create(); + error1->setLevel(libcellml::Issue::Level::ERROR); - logger->addIssue(err); - EXPECT_EQ(size_t(1), logger->issueCount()); - EXPECT_EQ(size_t(1), logger->errorCount()); - EXPECT_EQ(size_t(0), logger->warningCount()); - EXPECT_EQ(size_t(0), logger->hintCount()); - EXPECT_EQ(logger->error(0), err); - EXPECT_EQ(logger->issue(0), err); -} + auto warning1 = libcellml::Issue::create(); + warning1->setLevel(libcellml::Issue::Level::WARNING); -TEST(Logger, addWarning) -{ - auto err = libcellml::Issue::create(); - err->setLevel(libcellml::Issue::Level::WARNING); - auto logger = libcellml::Validator::create(); + auto hint1 = libcellml::Issue::create(); + hint1->setLevel(libcellml::Issue::Level::HINT); - logger->addIssue(err); - EXPECT_EQ(size_t(1), logger->issueCount()); - EXPECT_EQ(size_t(0), logger->errorCount()); - EXPECT_EQ(size_t(1), logger->warningCount()); - EXPECT_EQ(size_t(0), logger->hintCount()); - EXPECT_EQ(logger->warning(0), err); - EXPECT_EQ(logger->issue(0), err); -} + auto error2 = libcellml::Issue::create(); + error2->setLevel(libcellml::Issue::Level::ERROR); -TEST(Logger, addHint) -{ - auto err = libcellml::Issue::create(); - err->setLevel(libcellml::Issue::Level::HINT); - auto logger = libcellml::Validator::create(); + auto warning2 = libcellml::Issue::create(); + warning2->setLevel(libcellml::Issue::Level::WARNING); - logger->addIssue(err); - EXPECT_EQ(size_t(1), logger->issueCount()); - EXPECT_EQ(size_t(0), logger->errorCount()); - EXPECT_EQ(size_t(0), logger->warningCount()); - EXPECT_EQ(size_t(1), logger->hintCount()); - EXPECT_EQ(logger->hint(0), err); - EXPECT_EQ(logger->issue(0), err); + auto hint2 = libcellml::Issue::create(); + hint2->setLevel(libcellml::Issue::Level::HINT); + + auto validator = libcellml::Validator::create(); + validator->addIssue(error1); + validator->addIssue(warning1); + validator->addIssue(hint1); + validator->addIssue(hint2); + validator->addIssue(warning2); + validator->addIssue(error2); + + // Expect to be able to call issue(0-5) and have the appropriate one returned + // in the order they were added, irrespective of their level. + EXPECT_EQ(size_t(6), validator->issueCount()); + EXPECT_EQ(error1, validator->issue(0)); + EXPECT_EQ(warning1, validator->issue(1)); + EXPECT_EQ(hint1, validator->issue(2)); + EXPECT_EQ(hint2, validator->issue(3)); + EXPECT_EQ(warning2, validator->issue(4)); + EXPECT_EQ(error2, validator->issue(5)); + + // Expect to call error(0-1) and get the ERROR level issues only + EXPECT_EQ(error1, validator->issue(0, libcellml::Issue::Level::ERROR)); + EXPECT_EQ(error2, validator->issue(1, libcellml::Issue::Level::ERROR)); + + // Expect to call warning(0-1) and get the WARNING level issues only + EXPECT_EQ(warning1, validator->issue(0, libcellml::Issue::Level::WARNING)); + EXPECT_EQ(warning2, validator->issue(1, libcellml::Issue::Level::WARNING)); + + // Expect to call hint(0-1) and get the HINT level issues only + EXPECT_EQ(hint1, validator->issue(0, libcellml::Issue::Level::HINT)); + EXPECT_EQ(hint2, validator->issue(1, libcellml::Issue::Level::HINT)); } From 581b13bea131593dbadb26974364b9ca501a96a8 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 16 Jan 2020 12:15:56 +0100 Subject: [PATCH 14/88] Get issue by vector of levels --- src/api/libcellml/logger.h | 2 ++ src/logger.cpp | 33 +++++++++++++++---------- tests/logger/logger.cpp | 49 ++++++++++++++++++++++++++++++++++++-- 3 files changed, 69 insertions(+), 15 deletions(-) diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index 5afb66bd5..4b40db549 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -90,6 +90,8 @@ class LIBCELLML_EXPORT Logger */ IssuePtr issue(size_t index, libcellml::Issue::Level level) const; + IssuePtr issue(size_t index, std::vector &levels) const; + /** * @brief Get the number of issues with level of ERROR. * diff --git a/src/logger.cpp b/src/logger.cpp index 65a27c17f..0fd53ad2c 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -133,25 +133,32 @@ IssuePtr Logger::issue(size_t index) const IssuePtr Logger::issue(size_t index, libcellml::Issue::Level level) const { // Update the appropriate array based on its level - IssuePtr err = nullptr; switch (level) { case libcellml::Issue::Level::ERROR: - if ((index < mPimpl->mErrors.size()) && (mPimpl->mErrors.at(index) < mPimpl->mIssues.size())) { - err = mPimpl->mIssues.at(mPimpl->mErrors.at(index)); - } - return err; + return error(index); case libcellml::Issue::Level::WARNING: - if ((index < mPimpl->mWarnings.size()) && (mPimpl->mWarnings.at(index) < mPimpl->mIssues.size())) { - err = mPimpl->mIssues.at(mPimpl->mWarnings.at(index)); - } - return err; + return warning(index); case libcellml::Issue::Level::HINT: - if ((index < mPimpl->mHints.size()) && (mPimpl->mHints.at(index) < mPimpl->mIssues.size())) { - err = mPimpl->mIssues.at(mPimpl->mHints.at(index)); + return hint(index); + } + return nullptr; +} + +IssuePtr Logger::issue(size_t index, std::vector &levels) const +{ + size_t i = 0; + index++; + while (i < mPimpl->mIssues.size()) { + for (auto issue : mPimpl->mIssues) { + if (std::find(levels.begin(), levels.end(), issue->level()) != levels.end()) { + i++; + } + if (i == index) { + return issue; + } } - return err; } - return err; + return nullptr; } } // namespace libcellml diff --git a/tests/logger/logger.cpp b/tests/logger/logger.cpp index d3de285d4..22cc3fad3 100644 --- a/tests/logger/logger.cpp +++ b/tests/logger/logger.cpp @@ -63,7 +63,7 @@ TEST(Logger, addHint) EXPECT_EQ(logger->issue(0), err); } -TEST(Validator, getIssueByLevelFunction) +TEST(Logger, getIssueByLevelFunction) { auto error1 = libcellml::Issue::create(); error1->setLevel(libcellml::Issue::Level::ERROR); @@ -114,7 +114,7 @@ TEST(Validator, getIssueByLevelFunction) EXPECT_EQ(hint2, validator->hint(1)); } -TEST(Validator, getIssueByLevelArgument) +TEST(Logger, getIssueByLevelArgument) { auto error1 = libcellml::Issue::create(); error1->setLevel(libcellml::Issue::Level::ERROR); @@ -164,3 +164,48 @@ TEST(Validator, getIssueByLevelArgument) EXPECT_EQ(hint1, validator->issue(0, libcellml::Issue::Level::HINT)); EXPECT_EQ(hint2, validator->issue(1, libcellml::Issue::Level::HINT)); } + +TEST(Logger, getIssueByLevelsArguments) +{ + auto error1 = libcellml::Issue::create(); + error1->setLevel(libcellml::Issue::Level::ERROR); + + auto warning1 = libcellml::Issue::create(); + warning1->setLevel(libcellml::Issue::Level::WARNING); + + auto hint1 = libcellml::Issue::create(); + hint1->setLevel(libcellml::Issue::Level::HINT); + + auto error2 = libcellml::Issue::create(); + error2->setLevel(libcellml::Issue::Level::ERROR); + + auto warning2 = libcellml::Issue::create(); + warning2->setLevel(libcellml::Issue::Level::WARNING); + + auto hint2 = libcellml::Issue::create(); + hint2->setLevel(libcellml::Issue::Level::HINT); + + auto validator = libcellml::Validator::create(); + validator->addIssue(error1); + validator->addIssue(warning1); + validator->addIssue(hint1); + validator->addIssue(hint2); + validator->addIssue(warning2); + validator->addIssue(error2); + + std::vector errorOnly = {libcellml::Issue::Level::ERROR}; + std::vector warningOnly = {libcellml::Issue::Level::WARNING}; + std::vector hintOnly = {libcellml::Issue::Level::HINT}; + std::vector errorAndWarning = {libcellml::Issue::Level::ERROR, libcellml::Issue::Level::WARNING}; + std::vector errorAndHint = {libcellml::Issue::Level::ERROR, libcellml::Issue::Level::HINT}; + std::vector warningAndHint = {libcellml::Issue::Level::HINT, libcellml::Issue::Level::WARNING}; + std::vector allOfThem = {libcellml::Issue::Level::ERROR, libcellml::Issue::Level::WARNING, libcellml::Issue::Level::HINT}; + + EXPECT_EQ(error2, validator->issue(1, errorOnly)); + EXPECT_EQ(warning2, validator->issue(1, warningOnly)); + EXPECT_EQ(hint1, validator->issue(0, hintOnly)); + EXPECT_EQ(error2, validator->issue(3, errorAndWarning)); + EXPECT_EQ(hint2, validator->issue(2, errorAndHint)); + EXPECT_EQ(warning1, validator->issue(0, warningAndHint)); + EXPECT_EQ(warning2, validator->issue(4, allOfThem)); +} From 979fd609e4090aff2a5cdafb94449de016a4c79f Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 16 Jan 2020 12:27:57 +0100 Subject: [PATCH 15/88] including and --- src/api/libcellml/logger.h | 1 + src/logger.cpp | 1 + 2 files changed, 2 insertions(+) diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index 4b40db549..cb82ae4cb 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -21,6 +21,7 @@ limitations under the License. #include "libcellml/types.h" #include +#include namespace libcellml { diff --git a/src/logger.cpp b/src/logger.cpp index 0fd53ad2c..ba9c0cd96 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -18,6 +18,7 @@ limitations under the License. #include "libcellml/logger.h" #include "libcellml/types.h" +#include #include namespace libcellml { From 79ab471658a42942b6f80f7ee21be1c1946585a3 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 16 Jan 2020 12:56:48 +0100 Subject: [PATCH 16/88] Coverage --- src/logger.cpp | 2 -- tests/logger/logger.cpp | 25 +++++++++++++++++++++++++ 2 files changed, 25 insertions(+), 2 deletions(-) diff --git a/src/logger.cpp b/src/logger.cpp index ba9c0cd96..c075fbc7b 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -133,7 +133,6 @@ IssuePtr Logger::issue(size_t index) const IssuePtr Logger::issue(size_t index, libcellml::Issue::Level level) const { - // Update the appropriate array based on its level switch (level) { case libcellml::Issue::Level::ERROR: return error(index); @@ -142,7 +141,6 @@ IssuePtr Logger::issue(size_t index, libcellml::Issue::Level level) const case libcellml::Issue::Level::HINT: return hint(index); } - return nullptr; } IssuePtr Logger::issue(size_t index, std::vector &levels) const diff --git a/tests/logger/logger.cpp b/tests/logger/logger.cpp index 22cc3fad3..3b6723427 100644 --- a/tests/logger/logger.cpp +++ b/tests/logger/logger.cpp @@ -208,4 +208,29 @@ TEST(Logger, getIssueByLevelsArguments) EXPECT_EQ(hint2, validator->issue(2, errorAndHint)); EXPECT_EQ(warning1, validator->issue(0, warningAndHint)); EXPECT_EQ(warning2, validator->issue(4, allOfThem)); + EXPECT_EQ(nullptr, validator->issue(100, errorOnly)); +} + +TEST(Logger, outOfRangeIndex) +{ + auto error1 = libcellml::Issue::create(); + auto warning1 = libcellml::Issue::create(); + auto hint1 = libcellml::Issue::create(); + + error1->setLevel(libcellml::Issue::Level::ERROR); + warning1->setLevel(libcellml::Issue::Level::WARNING); + hint1->setLevel(libcellml::Issue::Level::HINT); + + auto validator = libcellml::Validator::create(); + validator->addIssue(error1); + validator->addIssue(warning1); + validator->addIssue(hint1); + + std::vector errorAndWarning = {libcellml::Issue::Level::ERROR, libcellml::Issue::Level::WARNING}; + + EXPECT_EQ(nullptr, validator->issue(10)); + EXPECT_EQ(nullptr, validator->error(10)); + EXPECT_EQ(nullptr, validator->warning(10)); + EXPECT_EQ(nullptr, validator->hint(10)); + EXPECT_EQ(nullptr, validator->issue(10, errorAndWarning)); } From 3d495310ecde28ee86f6924ae117a3d7391f8ad7 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 16 Jan 2020 13:07:49 +0100 Subject: [PATCH 17/88] Coverage take 2 --- src/logger.cpp | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/logger.cpp b/src/logger.cpp index c075fbc7b..ce23378b3 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -133,14 +133,19 @@ IssuePtr Logger::issue(size_t index) const IssuePtr Logger::issue(size_t index, libcellml::Issue::Level level) const { + IssuePtr e = nullptr; switch (level) { case libcellml::Issue::Level::ERROR: - return error(index); + e = error(index); + break; case libcellml::Issue::Level::WARNING: - return warning(index); + e = warning(index); + break; case libcellml::Issue::Level::HINT: - return hint(index); + e = hint(index); + break; } + return e; } IssuePtr Logger::issue(size_t index, std::vector &levels) const From 6c6779d3193001601934eecaa1474349378f7315 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Tue, 21 Jan 2020 10:22:30 +0100 Subject: [PATCH 18/88] Replacing "SpecificationRule" with "ReferenceRule" --- src/api/libcellml/issue.h | 22 +-- src/api/libcellml/specificationrules.h | 4 +- src/bindings/interface/issue.i | 6 +- src/bindings/interface/types.i | 4 +- src/bindings/python/__init__.py | 2 +- src/issue.cpp | 124 +++++++------- src/parser.cpp | 80 ++++----- src/validator.cpp | 66 ++++---- tests/bindings/python/test_error.py | 136 ++++++++-------- tests/issue/issue.cpp | 216 ++++++++++++------------- 10 files changed, 330 insertions(+), 330 deletions(-) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index c66bda5b7..1a7799ad3 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -202,29 +202,29 @@ class LIBCELLML_EXPORT Issue bool isLevel(Level level) const; /** - * @brief Set the @c enum SpecificationRule of this issue. + * @brief Set the @c enum ReferenceRule of this issue. * * Set the @p rule of this issue from the options available in - * the @c SpecificationRule @c enum. + * the @c ReferenceRule @c enum. * - * @param rule The @c SpecificationRule to set. + * @param rule The @c ReferenceRule to set. */ - void setRule(SpecificationRule rule); + void setRule(ReferenceRule rule); /** - * @brief Get the @c enum SpecificationRule of this issue. + * @brief Get the @c enum ReferenceRule of this issue. * - * Get the @c enum @c SpecificationRule value @p rule of this issue. If - * no rule has been set for this issue, will return SpecificationRule::UNDEFINED. + * Get the @c enum @c ReferenceRule value @p rule of this issue. If + * no rule has been set for this issue, will return ReferenceRule::UNDEFINED. * - * @return The @c SpecificationRule for this issue. + * @return The @c ReferenceRule for this issue. */ - SpecificationRule rule() const; + ReferenceRule rule() const; /** - * @brief Get the @c std::string heading associated with the @c enum SpecificationRule for this issue. + * @brief Get the @c std::string heading associated with the @c enum ReferenceRule for this issue. * - * Get the @c std::string CellML 2.0 Specification heading associated with the @c enum SpecificationRule + * Get the @c std::string CellML 2.0 Specification heading associated with the @c enum ReferenceRule * for this issue. If no rule has been set for this issue, will return an empty string. * * @return The @c std::string referencing the CellML 2.0 Specification heading relevant to this issue. diff --git a/src/api/libcellml/specificationrules.h b/src/api/libcellml/specificationrules.h index 5b683210e..ddd20adea 100644 --- a/src/api/libcellml/specificationrules.h +++ b/src/api/libcellml/specificationrules.h @@ -19,12 +19,12 @@ limitations under the License. namespace libcellml { /** - * @brief The SpecificationRule enum class. + * @brief The ReferenceRule enum class. * * Enum describing the specification rules that are used * for validation. */ -enum class SpecificationRule +enum class ReferenceRule { UNDEFINED, DATA_REPR_IDENTIFIER_UNICODE, diff --git a/src/bindings/interface/issue.i b/src/bindings/interface/issue.i index d60c477c7..bccdf8e4c 100644 --- a/src/bindings/interface/issue.i +++ b/src/bindings/interface/issue.i @@ -37,14 +37,14 @@ return Level::ERROR."; "Sets the ``level`` of this issue."; %feature("docstring") libcellml::Issue::rule -"Get the :class:`SpecificationRule` of this issue."; +"Get the :class:`ReferenceRule` of this issue."; %feature("docstring") libcellml::Issue::setRule -"Sets the :class:`SpecificationRule` for this issue."; +"Sets the :class:`ReferenceRule` for this issue."; %feature("docstring") libcellml::Issue::specificationHeading "Returns the CellML 2.0 Specification heading associated with the -:class:`SpecificationRule` for this issue (empty string if not set)."; +:class:`ReferenceRule` for this issue (empty string if not set)."; %feature("docstring") libcellml::Issue::component "Returns the :class:`Component` that this issue is relevant to (or ``None``)."; diff --git a/src/bindings/interface/types.i b/src/bindings/interface/types.i index 97e13028e..994a132f0 100644 --- a/src/bindings/interface/types.i +++ b/src/bindings/interface/types.i @@ -86,12 +86,12 @@ Only meant to be included, shouldn't be passed to cmake as a module! } } -%typemap(in) libcellml::SpecificationRule (int val, int ecode) { +%typemap(in) libcellml::ReferenceRule (int val, int ecode) { ecode = SWIG_AsVal(int)($input, &val); if (!SWIG_IsOK(ecode)) { %argument_fail(ecode, "$type", $symname, $argnum); } else { - if (val < %static_cast(libcellml::SpecificationRule::UNDEFINED, int) || %static_cast(libcellml::SpecificationRule::MAP_VARIABLES_VARIABLE2, int) < val) { + if (val < %static_cast(libcellml::ReferenceRule::UNDEFINED, int) || %static_cast(libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE2, int) < val) { %argument_fail(ecode, "$type is not a valid value for the enumeration.", $symname, $argnum); } $1 = %static_cast(val,$basetype); diff --git a/src/bindings/python/__init__.py b/src/bindings/python/__init__.py index 32d8ae86d..3ac2a0131 100644 --- a/src/bindings/python/__init__.py +++ b/src/bindings/python/__init__.py @@ -129,7 +129,7 @@ class Object: ], new_base = Units) import libcellml import libcellml.specificationrule -convert(specificationrule, 'SpecificationRule', [ +convert(specificationrule, 'ReferenceRule', [ 'UNDEFINED', 'DATA_REPR_IDENTIFIER_UNICODE', 'DATA_REPR_IDENTIFIER_LATIN_ALPHANUM', diff --git a/src/issue.cpp b/src/issue.cpp index 0b0397de1..e9ce0eacb 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -32,7 +32,7 @@ struct Issue::IssueImpl std::string mDescription; /**< The string description for why this entity issue raised. */ Issue::Cause mCause = Issue::Cause::UNDEFINED; /**< The Issue::Cause enum value for this issue. */ Issue::Level mLevel = Issue::Level::ERROR; /**< The Issue::Level enum value for this issue. */ - SpecificationRule mRule = SpecificationRule::UNDEFINED; /**< The SpecificationRule enum value for this issue. */ + ReferenceRule mRule = ReferenceRule::UNDEFINED; /**< The ReferenceRule enum value for this issue. */ ComponentPtr mComponent; /**< Pointer to the component that the issue occurred in. */ ImportSourcePtr mImportSource; /**< Pointer to the import source that the issue occurred in. */ ModelPtr mModel; /**< Pointer to the model that the issue occurred in. */ @@ -176,12 +176,12 @@ bool Issue::isLevel(Level level) const return response; } -void Issue::setRule(SpecificationRule rule) +void Issue::setRule(ReferenceRule rule) { mPimpl->mRule = rule; } -SpecificationRule Issue::rule() const +ReferenceRule Issue::rule() const { return mPimpl->mRule; } @@ -255,66 +255,66 @@ ResetPtr Issue::reset() const /** * @brief Map SpecificationRules to their section titles. * - * An internal map used to convert a SpecificationRule into its heading string. + * An internal map used to convert a ReferenceRule into its heading string. */ -static const std::map ruleToHeading = { - {SpecificationRule::UNDEFINED, ""}, - {SpecificationRule::DATA_REPR_IDENTIFIER_UNICODE, "3.1.1"}, - {SpecificationRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, "3.1.2"}, - {SpecificationRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, "3.1.3"}, - {SpecificationRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM, "3.1.4"}, - {SpecificationRule::DATA_REPR_IDENTIFIER_IDENTICAL, "3.1.5"}, - {SpecificationRule::DATA_REPR_NNEG_INT_BASE10, "3.2.1"}, - {SpecificationRule::DATA_REPR_NNEG_INT_EURO_NUM, "3.2.2"}, - {SpecificationRule::MODEL_ELEMENT, "4.1"}, - {SpecificationRule::MODEL_NAME, "4.2.1"}, - {SpecificationRule::MODEL_CHILD, "4.2.2"}, - {SpecificationRule::MODEL_MORE_THAN_ONE_ENCAPSULATION, "4.2.3"}, - {SpecificationRule::IMPORT_HREF, "5.1.1"}, - {SpecificationRule::IMPORT_CHILD, "5.1.2"}, - {SpecificationRule::IMPORT_CIRCULAR, "5.1.3"}, // TODO: double-check meaning & implementation. - {SpecificationRule::IMPORT_UNITS_NAME, "6.1.1"}, - {SpecificationRule::IMPORT_UNITS_REF, "6.1.2"}, - {SpecificationRule::IMPORT_COMPONENT_NAME, "7.1.1"}, - {SpecificationRule::IMPORT_COMPONENT_REF, "7.1.2"}, - {SpecificationRule::UNITS_NAME, "8.1.1"}, - {SpecificationRule::UNITS_NAME_UNIQUE, "8.1.2"}, - {SpecificationRule::UNITS_STANDARD, "8.1.3"}, - {SpecificationRule::UNITS_CHILD, "8.1.4"}, - {SpecificationRule::UNIT_UNITS_REF, "9.1.1"}, - {SpecificationRule::UNIT_DIGRAPH, "9.1.1.1"}, // Assume we're skipping this for now. - {SpecificationRule::UNIT_CIRCULAR_REF, "9.1.1.2"}, // TODO: double-check meaning & implementation. - {SpecificationRule::UNIT_OPTIONAL_ATTRIBUTE, "9.1.2"}, - {SpecificationRule::UNIT_PREFIX, "9.1.2.1"}, - {SpecificationRule::UNIT_MULTIPLIER, "9.1.2.2"}, - {SpecificationRule::UNIT_EXPONENT, "9.1.2.3"}, - {SpecificationRule::COMPONENT_NAME, "10.1.1"}, - {SpecificationRule::COMPONENT_CHILD, "10.1.2"}, - {SpecificationRule::VARIABLE_NAME, "11.1.1.1"}, - {SpecificationRule::VARIABLE_UNITS, "11.1.1.2"}, - {SpecificationRule::VARIABLE_INTERFACE, "11.1.2.1"}, - {SpecificationRule::VARIABLE_INITIAL_VALUE, "11.1.2.2"}, - {SpecificationRule::RESET_VARIABLE_REFERENCE, "12.1.1.1"}, - {SpecificationRule::RESET_TEST_VARIABLE_REFERENCE, "12.1.1.1"}, - {SpecificationRule::RESET_ORDER, "12.1.1.2"}, - {SpecificationRule::RESET_CHILD, "12.1.2"}, - {SpecificationRule::RESET_TEST_VALUE, "12.1.2"}, - {SpecificationRule::RESET_RESET_VALUE, "12.1.2"}, - {SpecificationRule::MATH_MATHML, "14.1.1"}, - {SpecificationRule::MATH_CHILD, "14.1.2"}, - {SpecificationRule::MATH_CI_VARIABLE_REFERENCE, "14.1.3"}, - {SpecificationRule::MATH_CN_UNITS_ATTRIBUTE, "14.1.4"}, - {SpecificationRule::ENCAPSULATION_COMPONENT_REF, "15.1.1"}, - {SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE, "16.1.1"}, - {SpecificationRule::COMPONENT_REF_CHILD, "16.1.2"}, - {SpecificationRule::COMPONENT_REF_ENCAPSULATION, "16.1.3"}, // Seems to be the same as 12.1.1? - {SpecificationRule::CONNECTION_COMPONENT1, "17.1.1"}, - {SpecificationRule::CONNECTION_COMPONENT2, "17.1.2"}, - {SpecificationRule::CONNECTION_UNIQUE_TRANSITIVE, "17.1.3"}, - {SpecificationRule::CONNECTION_MAP_VARIABLES, "17.1.4"}, - {SpecificationRule::MAP_VARIABLES_VARIABLE1, "18.1.1"}, - {SpecificationRule::MAP_VARIABLES_VARIABLE2, "18.1.2"}, - {SpecificationRule::MAP_VARIABLES_UNIQUE, "18.1.3"}}; +static const std::map ruleToHeading = { + {ReferenceRule::UNDEFINED, ""}, + {ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE, "3.1.1"}, + {ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, "3.1.2"}, + {ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, "3.1.3"}, + {ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM, "3.1.4"}, + {ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL, "3.1.5"}, + {ReferenceRule::DATA_REPR_NNEG_INT_BASE10, "3.2.1"}, + {ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM, "3.2.2"}, + {ReferenceRule::MODEL_ELEMENT, "4.1"}, + {ReferenceRule::MODEL_NAME, "4.2.1"}, + {ReferenceRule::MODEL_CHILD, "4.2.2"}, + {ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION, "4.2.3"}, + {ReferenceRule::IMPORT_HREF, "5.1.1"}, + {ReferenceRule::IMPORT_CHILD, "5.1.2"}, + {ReferenceRule::IMPORT_CIRCULAR, "5.1.3"}, // TODO: double-check meaning & implementation. + {ReferenceRule::IMPORT_UNITS_NAME, "6.1.1"}, + {ReferenceRule::IMPORT_UNITS_REF, "6.1.2"}, + {ReferenceRule::IMPORT_COMPONENT_NAME, "7.1.1"}, + {ReferenceRule::IMPORT_COMPONENT_REF, "7.1.2"}, + {ReferenceRule::UNITS_NAME, "8.1.1"}, + {ReferenceRule::UNITS_NAME_UNIQUE, "8.1.2"}, + {ReferenceRule::UNITS_STANDARD, "8.1.3"}, + {ReferenceRule::UNITS_CHILD, "8.1.4"}, + {ReferenceRule::UNIT_UNITS_REF, "9.1.1"}, + {ReferenceRule::UNIT_DIGRAPH, "9.1.1.1"}, // Assume we're skipping this for now. + {ReferenceRule::UNIT_CIRCULAR_REF, "9.1.1.2"}, // TODO: double-check meaning & implementation. + {ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE, "9.1.2"}, + {ReferenceRule::UNIT_PREFIX, "9.1.2.1"}, + {ReferenceRule::UNIT_MULTIPLIER, "9.1.2.2"}, + {ReferenceRule::UNIT_EXPONENT, "9.1.2.3"}, + {ReferenceRule::COMPONENT_NAME, "10.1.1"}, + {ReferenceRule::COMPONENT_CHILD, "10.1.2"}, + {ReferenceRule::VARIABLE_NAME, "11.1.1.1"}, + {ReferenceRule::VARIABLE_UNITS, "11.1.1.2"}, + {ReferenceRule::VARIABLE_INTERFACE, "11.1.2.1"}, + {ReferenceRule::VARIABLE_INITIAL_VALUE, "11.1.2.2"}, + {ReferenceRule::RESET_VARIABLE_REFERENCE, "12.1.1.1"}, + {ReferenceRule::RESET_TEST_VARIABLE_REFERENCE, "12.1.1.1"}, + {ReferenceRule::RESET_ORDER, "12.1.1.2"}, + {ReferenceRule::RESET_CHILD, "12.1.2"}, + {ReferenceRule::RESET_TEST_VALUE, "12.1.2"}, + {ReferenceRule::RESET_RESET_VALUE, "12.1.2"}, + {ReferenceRule::MATH_MATHML, "14.1.1"}, + {ReferenceRule::MATH_CHILD, "14.1.2"}, + {ReferenceRule::MATH_CI_VARIABLE_REFERENCE, "14.1.3"}, + {ReferenceRule::MATH_CN_UNITS_ATTRIBUTE, "14.1.4"}, + {ReferenceRule::ENCAPSULATION_COMPONENT_REF, "15.1.1"}, + {ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE, "16.1.1"}, + {ReferenceRule::COMPONENT_REF_CHILD, "16.1.2"}, + {ReferenceRule::COMPONENT_REF_ENCAPSULATION, "16.1.3"}, // Seems to be the same as 12.1.1? + {ReferenceRule::CONNECTION_COMPONENT1, "17.1.1"}, + {ReferenceRule::CONNECTION_COMPONENT2, "17.1.2"}, + {ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE, "17.1.3"}, + {ReferenceRule::CONNECTION_MAP_VARIABLES, "17.1.4"}, + {ReferenceRule::MAP_VARIABLES_VARIABLE1, "18.1.1"}, + {ReferenceRule::MAP_VARIABLES_VARIABLE2, "18.1.2"}, + {ReferenceRule::MAP_VARIABLES_UNIQUE, "18.1.3"}}; std::string Issue::specificationHeading() const { diff --git a/src/parser.cpp b/src/parser.cpp index 2234ea6b8..130d54297 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -282,7 +282,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setDescription("Model element is of invalid type '" + node->name() + "'. A valid CellML root node should be of type 'model'."); } err->setModel(model); - err->setRule(SpecificationRule::MODEL_ELEMENT); + err->setRule(ReferenceRule::MODEL_ELEMENT); mParser->addIssue(err); return; } @@ -347,7 +347,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setDescription("Encapsulation in model '" + model->name() + "' does not contain any child elements."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(SpecificationRule::ENCAPSULATION_COMPONENT_REF); + err->setRule(ReferenceRule::ENCAPSULATION_COMPONENT_REF); mParser->addIssue(err); } } else if (childNode->isCellmlElement("connection")) { @@ -359,7 +359,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); - err->setRule(SpecificationRule::MODEL_CHILD); + err->setRule(ReferenceRule::MODEL_CHILD); mParser->addIssue(err); } } else if (childNode->isComment()) { @@ -368,7 +368,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setModel(model); - err->setRule(SpecificationRule::MODEL_CHILD); + err->setRule(ReferenceRule::MODEL_CHILD); mParser->addIssue(err); } childNode = childNode->next(); @@ -381,7 +381,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp err->setDescription("Model '" + model->name() + "' has more than one encapsulation element."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(SpecificationRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); + err->setRule(ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); mParser->addIssue(err); } } @@ -528,7 +528,7 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN IssuePtr err = Issue::create(); err->setDescription("Component '" + component->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setComponent(component); - err->setRule(SpecificationRule::COMPONENT_CHILD); + err->setRule(ReferenceRule::COMPONENT_CHILD); mParser->addIssue(err); } } else if (childNode->isComment()) { @@ -537,7 +537,7 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN IssuePtr err = Issue::create(); err->setDescription("Component '" + component->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setComponent(component); - err->setRule(SpecificationRule::COMPONENT_CHILD); + err->setRule(ReferenceRule::COMPONENT_CHILD); mParser->addIssue(err); } childNode = childNode->next(); @@ -571,7 +571,7 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node IssuePtr err = Issue::create(); err->setDescription("Units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setUnits(units); - err->setRule(SpecificationRule::UNITS_CHILD); + err->setRule(ReferenceRule::UNITS_CHILD); mParser->addIssue(err); } } else if (childNode->isComment()) { @@ -580,7 +580,7 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node IssuePtr err = Issue::create(); err->setDescription("Units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); err->setUnits(units); - err->setRule(SpecificationRule::UNITS_CHILD); + err->setRule(ReferenceRule::UNITS_CHILD); mParser->addIssue(err); } childNode = childNode->next(); @@ -631,7 +631,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr err = Issue::create(); err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an exponent with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); err->setUnits(units); - err->setRule(SpecificationRule::UNIT_EXPONENT); + err->setRule(ReferenceRule::UNIT_EXPONENT); mParser->addIssue(err); } } else if (attribute->isType("multiplier")) { @@ -642,7 +642,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr err = Issue::create(); err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has a multiplier with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); err->setUnits(units); - err->setRule(SpecificationRule::UNIT_MULTIPLIER); + err->setRule(ReferenceRule::UNIT_MULTIPLIER); mParser->addIssue(err); } } else if (attribute->isType("id")) { @@ -651,7 +651,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr err = Issue::create(); err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); err->setUnits(units); - err->setRule(SpecificationRule::UNIT_OPTIONAL_ATTRIBUTE); + err->setRule(ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); mParser->addIssue(err); } attribute = attribute->next(); @@ -750,7 +750,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' does not have a valid component_1 in a connection element."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - err->setRule(SpecificationRule::CONNECTION_COMPONENT1); + err->setRule(ReferenceRule::CONNECTION_COMPONENT1); mParser->addIssue(err); component1Missing = true; } @@ -759,7 +759,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' does not have a valid component_2 in a connection element."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - err->setRule(SpecificationRule::CONNECTION_COMPONENT2); + err->setRule(ReferenceRule::CONNECTION_COMPONENT2); mParser->addIssue(err); component2Missing = true; } @@ -773,7 +773,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' must contain one or more 'map_variables' elements."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - err->setRule(SpecificationRule::CONNECTION_MAP_VARIABLES); + err->setRule(ReferenceRule::CONNECTION_MAP_VARIABLES); mParser->addIssue(err); return; } @@ -831,7 +831,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_1 in a map_variables element."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); + err->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); mParser->addIssue(err); variable1Missing = true; } @@ -840,7 +840,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_2 in a map_variables element."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); + err->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); mParser->addIssue(err); variable2Missing = true; } @@ -884,7 +884,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.first + "' as component_1 but it does not exist in the model."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - err->setRule(SpecificationRule::CONNECTION_COMPONENT1); + err->setRule(ReferenceRule::CONNECTION_COMPONENT1); mParser->addIssue(err); } } @@ -896,7 +896,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.second + "' as component_2 but it does not exist in the model."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - err->setRule(SpecificationRule::CONNECTION_COMPONENT2); + err->setRule(ReferenceRule::CONNECTION_COMPONENT2); mParser->addIssue(err); } } @@ -920,7 +920,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Variable '" + iterPair.first + "' is specified as variable_1 in a connection but it does not exist in component_1 component '" + component1->name() + "' of model '" + model->name() + "'."); err->setComponent(component1); err->setCause(Issue::Cause::CONNECTION); - err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); + err->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); mParser->addIssue(err); } } @@ -929,7 +929,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.first + "' as variable_1 but the corresponding component_1 is invalid."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE1); + err->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); mParser->addIssue(err); } if (component2) { @@ -946,7 +946,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Variable '" + iterPair.second + "' is specified as variable_2 in a connection but it does not exist in component_2 component '" + component2->name() + "' of model '" + model->name() + "'."); err->setComponent(component1); err->setCause(Issue::Cause::CONNECTION); - err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); + err->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); mParser->addIssue(err); } } @@ -955,7 +955,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.second + "' as variable_2 but the corresponding component_2 is invalid."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - err->setRule(SpecificationRule::MAP_VARIABLES_VARIABLE2); + err->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); mParser->addIssue(err); } // Set the variable equivalence relationship for this variable pair. @@ -968,7 +968,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr err->setDescription("Connection in model '" + model->name() + "' does not have a map_variables element."); err->setModel(model); err->setCause(Issue::Cause::CONNECTION); - err->setRule(SpecificationRule::CONNECTION_MAP_VARIABLES); + err->setRule(ReferenceRule::CONNECTION_MAP_VARIABLES); mParser->addIssue(err); } } @@ -991,7 +991,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponentName + "' as a component in a component_ref but it does not exist in the model."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + err->setRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); mParser->addIssue(err); } } else if (attribute->isType("id")) { @@ -1001,7 +1001,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid component_ref attribute '" + attribute->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + err->setRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); mParser->addIssue(err); } attribute = attribute->next(); @@ -1011,7 +1011,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X err->setDescription("Encapsulation in model '" + model->name() + "' does not have a valid component attribute in a component_ref element."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + err->setRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); mParser->addIssue(err); } else if (parentComponent) { parentComponent->setEncapsulationId(encapsulationId); @@ -1074,7 +1074,7 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(SpecificationRule::COMPONENT_REF_CHILD); + err->setRule(ReferenceRule::COMPONENT_REF_CHILD); mParser->addIssue(err); } else { // Continue to next node if this is whitespace (don't try to parse children of whitespace). @@ -1088,7 +1088,7 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + componentRefNode->name() + "'."); err->setModel(model); err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(SpecificationRule::ENCAPSULATION_COMPONENT_REF); + err->setRule(ReferenceRule::ENCAPSULATION_COMPONENT_REF); mParser->addIssue(err); } @@ -1187,7 +1187,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M IssuePtr err = Issue::create(); err->setDescription("Import from '" + node->attribute("href") + "' has an invalid non-whitespace child text element '" + textNode + "'."); err->setImportSource(importSource); - err->setRule(SpecificationRule::IMPORT_CHILD); + err->setRule(ReferenceRule::IMPORT_CHILD); mParser->addIssue(err); } } else if (childNode->isComment()) { @@ -1196,7 +1196,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M IssuePtr err = Issue::create(); err->setDescription("Import from '" + node->attribute("href") + "' has an invalid child element '" + childNode->name() + "'."); err->setImportSource(importSource); - err->setRule(SpecificationRule::IMPORT_CHILD); + err->setRule(ReferenceRule::IMPORT_CHILD); mParser->addIssue(err); } childNode = childNode->next(); @@ -1229,7 +1229,7 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese IssuePtr err = Issue::create(); err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' has an unexpected attribute in the " + childType + " block of '" + childAttribute->name() + "'."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_TEST_VALUE); + err->setRule(ReferenceRule::RESET_TEST_VALUE); mParser->addIssue(err); } childAttribute = childAttribute->next(); @@ -1253,7 +1253,7 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese IssuePtr err = Issue::create(); err->setDescription("The " + childType + " in the reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' should have a MathML block as a child."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_TEST_VALUE); + err->setRule(ReferenceRule::RESET_TEST_VALUE); mParser->addIssue(err); } } @@ -1279,7 +1279,7 @@ void Parser::ParserImpl::checkResetChildMultiplicity(size_t count, const std::st err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' has " + convertToString(count) + " " + childType + " blocks."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_TEST_VALUE); + err->setRule(ReferenceRule::RESET_TEST_VALUE); mParser->addIssue(err); } if (count == 0) { @@ -1287,7 +1287,7 @@ void Parser::ParserImpl::checkResetChildMultiplicity(size_t count, const std::st err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' does not have a " + childType + " block defined."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_TEST_VALUE); + err->setRule(ReferenceRule::RESET_TEST_VALUE); mParser->addIssue(err); } } @@ -1313,7 +1313,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr err = Issue::create(); err->setDescription("Reset referencing variable '" + variableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_VARIABLE_REFERENCE); + err->setRule(ReferenceRule::RESET_VARIABLE_REFERENCE); mParser->addIssue(err); } else { reset->setVariable(referencedVariable); @@ -1326,7 +1326,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr err = Issue::create(); err->setDescription("Reset referencing test_variable '" + testVariableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); + err->setRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); mParser->addIssue(err); } else { reset->setTestVariable(testVariable); @@ -1343,7 +1343,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr err = Issue::create(); err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' has a non-integer order value '" + attribute->value() + "'."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_ORDER); + err->setRule(ReferenceRule::RESET_ORDER); mParser->addIssue(err); } } else if (attribute->isType("id")) { @@ -1363,7 +1363,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr err = Issue::create(); err->setDescription("Reset in component '" + component->name() + "' does not have its order set."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_ORDER); + err->setRule(ReferenceRule::RESET_ORDER); mParser->addIssue(err); } @@ -1385,7 +1385,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr err = Issue::create(); err->setDescription("Reset has an invalid non-whitespace child text element '" + textNode + "'. Either a test_value block or a reset_value block is expected."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_CHILD); + err->setRule(ReferenceRule::RESET_CHILD); mParser->addIssue(err); } } else if (childNode->isComment()) { diff --git a/src/validator.cpp b/src/validator.cpp index 4ac9c8049..16a1a4283 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -285,7 +285,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr err = Issue::create(); err->setDescription("Model does not have a valid name attribute."); err->setModel(model); - err->setRule(SpecificationRule::MODEL_NAME); + err->setRule(ReferenceRule::MODEL_NAME); addIssue(err); } // Check for components in this model. @@ -314,7 +314,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr err = Issue::create(); err->setDescription("Imported units '" + unitsName + "' does not have a valid units_ref attribute."); err->setUnits(units); - err->setRule(SpecificationRule::IMPORT_UNITS_REF); + err->setRule(ReferenceRule::IMPORT_UNITS_REF); addIssue(err); foundImportError = true; } @@ -324,7 +324,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr err = Issue::create(); err->setDescription("Import of units '" + unitsName + "' does not have a valid locator xlink:href attribute."); err->setImportSource(units->importSource()); - err->setRule(SpecificationRule::IMPORT_HREF); + err->setRule(ReferenceRule::IMPORT_HREF); addIssue(err); foundImportError = true; } @@ -336,7 +336,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' contains multiple imported units from '" + importSource + "' with the same units_ref attribute '" + unitsRef + "'."); err->setModel(model); - err->setRule(SpecificationRule::IMPORT_UNITS_REF); + err->setRule(ReferenceRule::IMPORT_UNITS_REF); addIssue(err); } } @@ -349,7 +349,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr err = Issue::create(); err->setDescription("Model '" + model->name() + "' contains multiple units with the name '" + unitsName + "'. Valid units names must be unique to their model."); err->setModel(model); - err->setRule(SpecificationRule::UNITS_NAME_UNIQUE); + err->setRule(ReferenceRule::UNITS_NAME_UNIQUE); addIssue(err); } unitsNames.push_back(unitsName); @@ -405,7 +405,7 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com IssuePtr err = Issue::create(); err->setComponent(component); err->setDescription("Imported component does not have a valid name attribute."); - err->setRule(SpecificationRule::IMPORT_COMPONENT_NAME); + err->setRule(ReferenceRule::IMPORT_COMPONENT_NAME); mValidator->addIssue(err); } @@ -418,14 +418,14 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com IssuePtr err = Issue::create(); err->setDescription("Imported component '" + componentName + "' does not have a valid component_ref attribute."); err->setComponent(component); - err->setRule(SpecificationRule::IMPORT_COMPONENT_REF); + err->setRule(ReferenceRule::IMPORT_COMPONENT_REF); mValidator->addIssue(err); } if (importSource.empty()) { IssuePtr err = Issue::create(); err->setDescription("Import of component '" + componentName + "' does not have a valid locator xlink:href attribute."); err->setImportSource(component->importSource()); - err->setRule(SpecificationRule::IMPORT_HREF); + err->setRule(ReferenceRule::IMPORT_HREF); mValidator->addIssue(err); } else { xmlURIPtr uri = xmlParseURI(importSource.c_str()); @@ -433,7 +433,7 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com IssuePtr err = Issue::create(); err->setDescription("Import of component '" + componentName + "' has an invalid URI in the href attribute."); err->setImportSource(component->importSource()); - err->setRule(SpecificationRule::IMPORT_HREF); + err->setRule(ReferenceRule::IMPORT_HREF); mValidator->addIssue(err); } else { @@ -449,7 +449,7 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) IssuePtr err = Issue::create(); err->setComponent(component); err->setDescription("Component does not have a valid name attribute."); - err->setRule(SpecificationRule::COMPONENT_NAME); + err->setRule(ReferenceRule::COMPONENT_NAME); mValidator->addIssue(err); } // Check for variables in this component. @@ -464,7 +464,7 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) IssuePtr err = Issue::create(); err->setDescription("Component '" + component->name() + "' contains multiple variables with the name '" + variableName + "'. Valid variable names must be unique to their component."); err->setComponent(component); - err->setRule(SpecificationRule::VARIABLE_NAME); + err->setRule(ReferenceRule::VARIABLE_NAME); mValidator->addIssue(err); } variableNames.push_back(variableName); @@ -496,10 +496,10 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v err->setUnits(units); if (units->isImport()) { err->setDescription("Imported units does not have a valid name attribute."); - err->setRule(SpecificationRule::IMPORT_UNITS_NAME); + err->setRule(ReferenceRule::IMPORT_UNITS_NAME); } else { err->setDescription("Units does not have a valid name attribute."); - err->setRule(SpecificationRule::UNITS_NAME); + err->setRule(ReferenceRule::UNITS_NAME); } mValidator->addIssue(err); } else { @@ -508,7 +508,7 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v IssuePtr err = Issue::create(); err->setDescription("Units is named '" + units->name() + "' which is a protected standard unit name."); err->setUnits(units); - err->setRule(SpecificationRule::UNITS_STANDARD); + err->setRule(ReferenceRule::UNITS_STANDARD); mValidator->addIssue(err); } } @@ -534,14 +534,14 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u IssuePtr err = Issue::create(); err->setDescription("Units reference '" + reference + "' in units '" + units->name() + "' is not a valid reference to a local units or a standard unit type."); err->setUnits(units); - err->setRule(SpecificationRule::UNIT_UNITS_REF); + err->setRule(ReferenceRule::UNIT_UNITS_REF); mValidator->addIssue(err); } } else { IssuePtr err = Issue::create(); err->setDescription("Unit in units '" + units->name() + "' does not have a valid units reference."); err->setUnits(units); - err->setRule(SpecificationRule::UNIT_UNITS_REF); + err->setRule(ReferenceRule::UNIT_UNITS_REF); mValidator->addIssue(err); } if (!prefix.empty()) { @@ -550,7 +550,7 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u IssuePtr err = Issue::create(); err->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is not a valid integer or an SI prefix."); err->setUnits(units); - err->setRule(SpecificationRule::UNIT_PREFIX); + err->setRule(ReferenceRule::UNIT_PREFIX); mValidator->addIssue(err); } else { try { @@ -560,7 +560,7 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u IssuePtr err = Issue::create(); err->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is out of the integer range."); err->setUnits(units); - err->setRule(SpecificationRule::UNIT_PREFIX); + err->setRule(ReferenceRule::UNIT_PREFIX); mValidator->addIssue(err); } } @@ -575,7 +575,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr err = Issue::create(); err->setDescription("Variable does not have a valid name attribute."); err->setVariable(variable); - err->setRule(SpecificationRule::VARIABLE_NAME); + err->setRule(ReferenceRule::VARIABLE_NAME); mValidator->addIssue(err); } // Check for a valid units attribute. @@ -584,7 +584,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr err = Issue::create(); err->setDescription("Variable '" + variable->name() + "' does not have a valid units attribute."); err->setVariable(variable); - err->setRule(SpecificationRule::VARIABLE_UNITS); + err->setRule(ReferenceRule::VARIABLE_UNITS); mValidator->addIssue(err); } else if (!isStandardUnitName(unitsName)) { ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); @@ -593,7 +593,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr err = Issue::create(); err->setDescription("Variable '" + variable->name() + "' has a units reference '" + unitsName + "' that does not correspond with a standard units and is not a units defined in the variable's model."); err->setVariable(variable); - err->setRule(SpecificationRule::VARIABLE_UNITS); + err->setRule(ReferenceRule::VARIABLE_UNITS); mValidator->addIssue(err); } } @@ -604,7 +604,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr err = Issue::create(); err->setDescription("Variable '" + variable->name() + "' has an invalid interface attribute value '" + interfaceType + "'."); err->setVariable(variable); - err->setRule(SpecificationRule::VARIABLE_INTERFACE); + err->setRule(ReferenceRule::VARIABLE_INTERFACE); mValidator->addIssue(err); } } @@ -618,7 +618,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr err = Issue::create(); err->setDescription("Variable '" + variable->name() + "' has an invalid initial value '" + initialValue + "'. Initial values must be a real number string or a variable reference."); err->setVariable(variable); - err->setRule(SpecificationRule::VARIABLE_INITIAL_VALUE); + err->setRule(ReferenceRule::VARIABLE_INITIAL_VALUE); mValidator->addIssue(err); } } @@ -689,49 +689,49 @@ void Validator::ValidatorImpl::validateReset(const ResetPtr &reset, const Compon IssuePtr err = Issue::create(); err->setDescription(description + "does not have an order set."); err->setComponent(component); - err->setRule(SpecificationRule::RESET_ORDER); + err->setRule(ReferenceRule::RESET_ORDER); mValidator->addIssue(err); } if (noVariable) { IssuePtr err = Issue::create(); err->setDescription(description + "does not reference a variable."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_VARIABLE_REFERENCE); + err->setRule(ReferenceRule::RESET_VARIABLE_REFERENCE); mValidator->addIssue(err); } if (noTestVariable) { IssuePtr err = Issue::create(); err->setDescription(description + "does not reference a test_variable."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); + err->setRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); mValidator->addIssue(err); } if (noTestValue) { IssuePtr err = Issue::create(); err->setDescription(description + "does not have a test_value specified."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_TEST_VALUE); + err->setRule(ReferenceRule::RESET_TEST_VALUE); mValidator->addIssue(err); } if (noResetValue) { IssuePtr err = Issue::create(); err->setDescription(description + "does not have a reset_value specified."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_RESET_VALUE); + err->setRule(ReferenceRule::RESET_RESET_VALUE); mValidator->addIssue(err); } if (varOutsideComponent) { IssuePtr err = Issue::create(); err->setDescription(description + "refers to a variable '" + reset->variable()->name() + "' in a different component '" + varParentName + "'."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_VARIABLE_REFERENCE); + err->setRule(ReferenceRule::RESET_VARIABLE_REFERENCE); mValidator->addIssue(err); } if (testVarOutsideComponent) { IssuePtr err = Issue::create(); err->setDescription(description + "refers to a test_variable '" + reset->testVariable()->name() + "' in a different component '" + testVarParentName + "'."); err->setReset(reset); - err->setRule(SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); + err->setRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); mValidator->addIssue(err); } } @@ -1033,7 +1033,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) result = false; IssuePtr err = Issue::create(); err->setDescription("CellML identifiers must not begin with a European numeric character [0-9]."); - err->setRule(SpecificationRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); + err->setRule(ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); mValidator->addIssue(err); } else { // Basic Latin alphanumeric characters and underscores. @@ -1041,7 +1041,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) result = false; IssuePtr err = Issue::create(); err->setDescription("CellML identifiers must not contain any characters other than [a-zA-Z0-9_]."); - err->setRule(SpecificationRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); + err->setRule(ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); mValidator->addIssue(err); } } @@ -1049,7 +1049,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) result = false; IssuePtr err = Issue::create(); err->setDescription("CellML identifiers must contain one or more basic Latin alphabetic characters."); - err->setRule(SpecificationRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); + err->setRule(ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); mValidator->addIssue(err); } return result; diff --git a/tests/bindings/python/test_error.py b/tests/bindings/python/test_error.py index fd59189da..ccc6e45bf 100644 --- a/tests/bindings/python/test_error.py +++ b/tests/bindings/python/test_error.py @@ -63,74 +63,74 @@ def test_cause_enum(self): self.assertRaises(RuntimeError, e.setCause, Issue.Cause.XML + 1) def test_specification_rule_enum(self): - from libcellml import Issue, SpecificationRule - - self.assertIsInstance(SpecificationRule.UNDEFINED, int) - self.assertIsInstance(SpecificationRule.DATA_REPR_IDENTIFIER_UNICODE, int) - self.assertIsInstance(SpecificationRule.DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, int) - self.assertIsInstance(SpecificationRule.DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, int) - self.assertIsInstance(SpecificationRule.DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM, int) - self.assertIsInstance(SpecificationRule.DATA_REPR_IDENTIFIER_IDENTICAL, int) - self.assertIsInstance(SpecificationRule.DATA_REPR_NNEG_INT_BASE10, int) - self.assertIsInstance(SpecificationRule.DATA_REPR_NNEG_INT_EURO_NUM, int) - self.assertIsInstance(SpecificationRule.MODEL_ELEMENT, int) - self.assertIsInstance(SpecificationRule.MODEL_NAME, int) - self.assertIsInstance(SpecificationRule.MODEL_CHILD, int) - self.assertIsInstance(SpecificationRule.MODEL_MORE_THAN_ONE_ENCAPSULATION, int) - self.assertIsInstance(SpecificationRule.IMPORT_HREF, int) - self.assertIsInstance(SpecificationRule.IMPORT_CHILD, int) - self.assertIsInstance(SpecificationRule.IMPORT_CIRCULAR, int) - self.assertIsInstance(SpecificationRule.IMPORT_UNITS_NAME, int) - self.assertIsInstance(SpecificationRule.IMPORT_UNITS_REF, int) - self.assertIsInstance(SpecificationRule.IMPORT_COMPONENT_NAME, int) - self.assertIsInstance(SpecificationRule.IMPORT_COMPONENT_REF, int) - self.assertIsInstance(SpecificationRule.UNITS_NAME, int) - self.assertIsInstance(SpecificationRule.UNITS_NAME_UNIQUE, int) - self.assertIsInstance(SpecificationRule.UNITS_STANDARD, int) - self.assertIsInstance(SpecificationRule.UNITS_CHILD, int) - self.assertIsInstance(SpecificationRule.UNIT_UNITS_REF, int) - self.assertIsInstance(SpecificationRule.UNIT_DIGRAPH, int) - self.assertIsInstance(SpecificationRule.UNIT_CIRCULAR_REF, int) - self.assertIsInstance(SpecificationRule.UNIT_OPTIONAL_ATTRIBUTE, int) - self.assertIsInstance(SpecificationRule.UNIT_PREFIX, int) - self.assertIsInstance(SpecificationRule.UNIT_MULTIPLIER, int) - self.assertIsInstance(SpecificationRule.UNIT_EXPONENT, int) - self.assertIsInstance(SpecificationRule.COMPONENT_NAME, int) - self.assertIsInstance(SpecificationRule.COMPONENT_CHILD, int) - self.assertIsInstance(SpecificationRule.VARIABLE_NAME, int) - self.assertIsInstance(SpecificationRule.VARIABLE_UNITS, int) - self.assertIsInstance(SpecificationRule.VARIABLE_INTERFACE, int) - self.assertIsInstance(SpecificationRule.VARIABLE_INITIAL_VALUE, int) - self.assertIsInstance(SpecificationRule.RESET_VARIABLE_REFERENCE, int) - self.assertIsInstance(SpecificationRule.RESET_TEST_VARIABLE_REFERENCE, int) - self.assertIsInstance(SpecificationRule.RESET_ORDER, int) - self.assertIsInstance(SpecificationRule.RESET_CHILD, int) - self.assertIsInstance(SpecificationRule.RESET_RESET_VALUE, int) - self.assertIsInstance(SpecificationRule.RESET_TEST_VALUE, int) - self.assertIsInstance(SpecificationRule.MATH_MATHML, int) - self.assertIsInstance(SpecificationRule.MATH_CHILD, int) - self.assertIsInstance(SpecificationRule.MATH_CI_VARIABLE_REFERENCE, int) - self.assertIsInstance(SpecificationRule.MATH_CN_UNITS_ATTRIBUTE, int) - self.assertIsInstance(SpecificationRule.ENCAPSULATION_COMPONENT_REF, int) - self.assertIsInstance(SpecificationRule.COMPONENT_REF_COMPONENT_ATTRIBUTE, int) - self.assertIsInstance(SpecificationRule.COMPONENT_REF_CHILD, int) - self.assertIsInstance(SpecificationRule.COMPONENT_REF_ENCAPSULATION, int) - self.assertIsInstance(SpecificationRule.CONNECTION_COMPONENT1, int) - self.assertIsInstance(SpecificationRule.CONNECTION_COMPONENT2, int) - self.assertIsInstance(SpecificationRule.CONNECTION_UNIQUE_TRANSITIVE, int) - self.assertIsInstance(SpecificationRule.CONNECTION_MAP_VARIABLES, int) - self.assertIsInstance(SpecificationRule.MAP_VARIABLES_VARIABLE1, int) - self.assertIsInstance(SpecificationRule.MAP_VARIABLES_VARIABLE2, int) - self.assertIsInstance(SpecificationRule.MAP_VARIABLES_UNIQUE, int) + from libcellml import Issue, ReferenceRule + + self.assertIsInstance(ReferenceRule.UNDEFINED, int) + self.assertIsInstance(ReferenceRule.DATA_REPR_IDENTIFIER_UNICODE, int) + self.assertIsInstance(ReferenceRule.DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, int) + self.assertIsInstance(ReferenceRule.DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, int) + self.assertIsInstance(ReferenceRule.DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM, int) + self.assertIsInstance(ReferenceRule.DATA_REPR_IDENTIFIER_IDENTICAL, int) + self.assertIsInstance(ReferenceRule.DATA_REPR_NNEG_INT_BASE10, int) + self.assertIsInstance(ReferenceRule.DATA_REPR_NNEG_INT_EURO_NUM, int) + self.assertIsInstance(ReferenceRule.MODEL_ELEMENT, int) + self.assertIsInstance(ReferenceRule.MODEL_NAME, int) + self.assertIsInstance(ReferenceRule.MODEL_CHILD, int) + self.assertIsInstance(ReferenceRule.MODEL_MORE_THAN_ONE_ENCAPSULATION, int) + self.assertIsInstance(ReferenceRule.IMPORT_HREF, int) + self.assertIsInstance(ReferenceRule.IMPORT_CHILD, int) + self.assertIsInstance(ReferenceRule.IMPORT_CIRCULAR, int) + self.assertIsInstance(ReferenceRule.IMPORT_UNITS_NAME, int) + self.assertIsInstance(ReferenceRule.IMPORT_UNITS_REF, int) + self.assertIsInstance(ReferenceRule.IMPORT_COMPONENT_NAME, int) + self.assertIsInstance(ReferenceRule.IMPORT_COMPONENT_REF, int) + self.assertIsInstance(ReferenceRule.UNITS_NAME, int) + self.assertIsInstance(ReferenceRule.UNITS_NAME_UNIQUE, int) + self.assertIsInstance(ReferenceRule.UNITS_STANDARD, int) + self.assertIsInstance(ReferenceRule.UNITS_CHILD, int) + self.assertIsInstance(ReferenceRule.UNIT_UNITS_REF, int) + self.assertIsInstance(ReferenceRule.UNIT_DIGRAPH, int) + self.assertIsInstance(ReferenceRule.UNIT_CIRCULAR_REF, int) + self.assertIsInstance(ReferenceRule.UNIT_OPTIONAL_ATTRIBUTE, int) + self.assertIsInstance(ReferenceRule.UNIT_PREFIX, int) + self.assertIsInstance(ReferenceRule.UNIT_MULTIPLIER, int) + self.assertIsInstance(ReferenceRule.UNIT_EXPONENT, int) + self.assertIsInstance(ReferenceRule.COMPONENT_NAME, int) + self.assertIsInstance(ReferenceRule.COMPONENT_CHILD, int) + self.assertIsInstance(ReferenceRule.VARIABLE_NAME, int) + self.assertIsInstance(ReferenceRule.VARIABLE_UNITS, int) + self.assertIsInstance(ReferenceRule.VARIABLE_INTERFACE, int) + self.assertIsInstance(ReferenceRule.VARIABLE_INITIAL_VALUE, int) + self.assertIsInstance(ReferenceRule.RESET_VARIABLE_REFERENCE, int) + self.assertIsInstance(ReferenceRule.RESET_TEST_VARIABLE_REFERENCE, int) + self.assertIsInstance(ReferenceRule.RESET_ORDER, int) + self.assertIsInstance(ReferenceRule.RESET_CHILD, int) + self.assertIsInstance(ReferenceRule.RESET_RESET_VALUE, int) + self.assertIsInstance(ReferenceRule.RESET_TEST_VALUE, int) + self.assertIsInstance(ReferenceRule.MATH_MATHML, int) + self.assertIsInstance(ReferenceRule.MATH_CHILD, int) + self.assertIsInstance(ReferenceRule.MATH_CI_VARIABLE_REFERENCE, int) + self.assertIsInstance(ReferenceRule.MATH_CN_UNITS_ATTRIBUTE, int) + self.assertIsInstance(ReferenceRule.ENCAPSULATION_COMPONENT_REF, int) + self.assertIsInstance(ReferenceRule.COMPONENT_REF_COMPONENT_ATTRIBUTE, int) + self.assertIsInstance(ReferenceRule.COMPONENT_REF_CHILD, int) + self.assertIsInstance(ReferenceRule.COMPONENT_REF_ENCAPSULATION, int) + self.assertIsInstance(ReferenceRule.CONNECTION_COMPONENT1, int) + self.assertIsInstance(ReferenceRule.CONNECTION_COMPONENT2, int) + self.assertIsInstance(ReferenceRule.CONNECTION_UNIQUE_TRANSITIVE, int) + self.assertIsInstance(ReferenceRule.CONNECTION_MAP_VARIABLES, int) + self.assertIsInstance(ReferenceRule.MAP_VARIABLES_VARIABLE1, int) + self.assertIsInstance(ReferenceRule.MAP_VARIABLES_VARIABLE2, int) + self.assertIsInstance(ReferenceRule.MAP_VARIABLES_UNIQUE, int) # Test conversion to enum e = Issue() - e.setRule(SpecificationRule.UNDEFINED) + e.setRule(ReferenceRule.UNDEFINED) self.assertRaises( - RuntimeError, e.setRule, SpecificationRule.UNDEFINED - 1) + RuntimeError, e.setRule, ReferenceRule.UNDEFINED - 1) self.assertRaises( RuntimeError, e.setRule, - SpecificationRule.MAP_VARIABLES_UNIQUE + 1) + ReferenceRule.MAP_VARIABLES_UNIQUE + 1) del(e) def test_set_description(self): @@ -177,18 +177,18 @@ def test_is_cause(self): self.assertFalse(e.isCause(Issue.Cause.MODEL)) def test_set_rule(self): - from libcellml import Issue, SpecificationRule + from libcellml import Issue, ReferenceRule - # void setRule(SpecificationRule rule) + # void setRule(ReferenceRule rule) e = Issue() - e.setRule(SpecificationRule.MAP_VARIABLES_VARIABLE2) + e.setRule(ReferenceRule.MAP_VARIABLES_VARIABLE2) def test_rule(self): - from libcellml import Issue, SpecificationRule + from libcellml import Issue, ReferenceRule - # SpecificationRule rule() + # ReferenceRule rule() e = Issue() - self.assertEqual(e.rule(), SpecificationRule.UNDEFINED) + self.assertEqual(e.rule(), ReferenceRule.UNDEFINED) def test_specification_heading(self): from libcellml import Issue diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index 8f84f5697..d00e3a4f5 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -69,175 +69,175 @@ TEST(Issue, createResetError) void testSpecificationRule(const libcellml::IssuePtr &e) { switch (e->rule()) { - case libcellml::SpecificationRule::COMPONENT_CHILD: + case libcellml::ReferenceRule::COMPONENT_CHILD: EXPECT_EQ("10.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::COMPONENT_NAME: + case libcellml::ReferenceRule::COMPONENT_NAME: EXPECT_EQ("10.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::COMPONENT_REF_CHILD: + case libcellml::ReferenceRule::COMPONENT_REF_CHILD: EXPECT_EQ("16.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE: + case libcellml::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE: EXPECT_EQ("16.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::COMPONENT_REF_ENCAPSULATION: + case libcellml::ReferenceRule::COMPONENT_REF_ENCAPSULATION: EXPECT_EQ("16.1.3", e->specificationHeading()); break; - case libcellml::SpecificationRule::CONNECTION_COMPONENT1: + case libcellml::ReferenceRule::CONNECTION_COMPONENT1: EXPECT_EQ("17.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::CONNECTION_COMPONENT2: + case libcellml::ReferenceRule::CONNECTION_COMPONENT2: EXPECT_EQ("17.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::CONNECTION_UNIQUE_TRANSITIVE: + case libcellml::ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE: EXPECT_EQ("17.1.3", e->specificationHeading()); break; - case libcellml::SpecificationRule::CONNECTION_MAP_VARIABLES: + case libcellml::ReferenceRule::CONNECTION_MAP_VARIABLES: EXPECT_EQ("17.1.4", e->specificationHeading()); break; - case libcellml::SpecificationRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM: + case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM: EXPECT_EQ("3.1.3", e->specificationHeading()); break; - case libcellml::SpecificationRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM: + case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM: EXPECT_EQ("3.1.4", e->specificationHeading()); break; - case libcellml::SpecificationRule::DATA_REPR_IDENTIFIER_IDENTICAL: + case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL: EXPECT_EQ("3.1.5", e->specificationHeading()); break; - case libcellml::SpecificationRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM: + case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM: EXPECT_EQ("3.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::DATA_REPR_IDENTIFIER_UNICODE: + case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE: EXPECT_EQ("3.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::DATA_REPR_NNEG_INT_BASE10: + case libcellml::ReferenceRule::DATA_REPR_NNEG_INT_BASE10: EXPECT_EQ("3.2.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::DATA_REPR_NNEG_INT_EURO_NUM: + case libcellml::ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM: EXPECT_EQ("3.2.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::ENCAPSULATION_COMPONENT_REF: + case libcellml::ReferenceRule::ENCAPSULATION_COMPONENT_REF: EXPECT_EQ("15.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::IMPORT_CHILD: + case libcellml::ReferenceRule::IMPORT_CHILD: EXPECT_EQ("5.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::IMPORT_CIRCULAR: + case libcellml::ReferenceRule::IMPORT_CIRCULAR: EXPECT_EQ("5.1.3", e->specificationHeading()); break; - case libcellml::SpecificationRule::IMPORT_COMPONENT_NAME: + case libcellml::ReferenceRule::IMPORT_COMPONENT_NAME: EXPECT_EQ("7.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::IMPORT_COMPONENT_REF: + case libcellml::ReferenceRule::IMPORT_COMPONENT_REF: EXPECT_EQ("7.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::IMPORT_HREF: + case libcellml::ReferenceRule::IMPORT_HREF: EXPECT_EQ("5.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::IMPORT_UNITS_NAME: + case libcellml::ReferenceRule::IMPORT_UNITS_NAME: EXPECT_EQ("6.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::IMPORT_UNITS_REF: + case libcellml::ReferenceRule::IMPORT_UNITS_REF: EXPECT_EQ("6.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::MAP_VARIABLES_UNIQUE: + case libcellml::ReferenceRule::MAP_VARIABLES_UNIQUE: EXPECT_EQ("18.1.3", e->specificationHeading()); break; - case libcellml::SpecificationRule::MAP_VARIABLES_VARIABLE1: + case libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE1: EXPECT_EQ("18.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::MAP_VARIABLES_VARIABLE2: + case libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE2: EXPECT_EQ("18.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::MATH_CHILD: + case libcellml::ReferenceRule::MATH_CHILD: EXPECT_EQ("14.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::MATH_CI_VARIABLE_REFERENCE: + case libcellml::ReferenceRule::MATH_CI_VARIABLE_REFERENCE: EXPECT_EQ("14.1.3", e->specificationHeading()); break; - case libcellml::SpecificationRule::MATH_CN_UNITS_ATTRIBUTE: + case libcellml::ReferenceRule::MATH_CN_UNITS_ATTRIBUTE: EXPECT_EQ("14.1.4", e->specificationHeading()); break; - case libcellml::SpecificationRule::MATH_MATHML: + case libcellml::ReferenceRule::MATH_MATHML: EXPECT_EQ("14.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::MODEL_CHILD: + case libcellml::ReferenceRule::MODEL_CHILD: EXPECT_EQ("4.2.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::MODEL_ELEMENT: + case libcellml::ReferenceRule::MODEL_ELEMENT: EXPECT_EQ("4.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::MODEL_MORE_THAN_ONE_ENCAPSULATION: + case libcellml::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION: EXPECT_EQ("4.2.3", e->specificationHeading()); break; - case libcellml::SpecificationRule::MODEL_NAME: + case libcellml::ReferenceRule::MODEL_NAME: EXPECT_EQ("4.2.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::RESET_CHILD: + case libcellml::ReferenceRule::RESET_CHILD: EXPECT_EQ("12.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::RESET_VARIABLE_REFERENCE: + case libcellml::ReferenceRule::RESET_VARIABLE_REFERENCE: EXPECT_EQ("12.1.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::RESET_TEST_VARIABLE_REFERENCE: + case libcellml::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE: EXPECT_EQ("12.1.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::RESET_ORDER: + case libcellml::ReferenceRule::RESET_ORDER: EXPECT_EQ("12.1.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::RESET_TEST_VALUE: + case libcellml::ReferenceRule::RESET_TEST_VALUE: EXPECT_EQ("12.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::RESET_RESET_VALUE: + case libcellml::ReferenceRule::RESET_RESET_VALUE: EXPECT_EQ("12.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::UNITS_CHILD: + case libcellml::ReferenceRule::UNITS_CHILD: EXPECT_EQ("8.1.4", e->specificationHeading()); break; - case libcellml::SpecificationRule::UNITS_NAME: + case libcellml::ReferenceRule::UNITS_NAME: EXPECT_EQ("8.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::UNITS_NAME_UNIQUE: + case libcellml::ReferenceRule::UNITS_NAME_UNIQUE: EXPECT_EQ("8.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::UNITS_STANDARD: + case libcellml::ReferenceRule::UNITS_STANDARD: EXPECT_EQ("8.1.3", e->specificationHeading()); break; - case libcellml::SpecificationRule::UNIT_OPTIONAL_ATTRIBUTE: + case libcellml::ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE: EXPECT_EQ("9.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::UNIT_CIRCULAR_REF: + case libcellml::ReferenceRule::UNIT_CIRCULAR_REF: EXPECT_EQ("9.1.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::UNIT_DIGRAPH: + case libcellml::ReferenceRule::UNIT_DIGRAPH: EXPECT_EQ("9.1.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::UNIT_EXPONENT: + case libcellml::ReferenceRule::UNIT_EXPONENT: EXPECT_EQ("9.1.2.3", e->specificationHeading()); break; - case libcellml::SpecificationRule::UNIT_MULTIPLIER: + case libcellml::ReferenceRule::UNIT_MULTIPLIER: EXPECT_EQ("9.1.2.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::UNIT_PREFIX: + case libcellml::ReferenceRule::UNIT_PREFIX: EXPECT_EQ("9.1.2.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::UNIT_UNITS_REF: + case libcellml::ReferenceRule::UNIT_UNITS_REF: EXPECT_EQ("9.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::VARIABLE_INITIAL_VALUE: + case libcellml::ReferenceRule::VARIABLE_INITIAL_VALUE: EXPECT_EQ("11.1.2.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::VARIABLE_INTERFACE: + case libcellml::ReferenceRule::VARIABLE_INTERFACE: EXPECT_EQ("11.1.2.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::VARIABLE_NAME: + case libcellml::ReferenceRule::VARIABLE_NAME: EXPECT_EQ("11.1.1.1", e->specificationHeading()); break; - case libcellml::SpecificationRule::VARIABLE_UNITS: + case libcellml::ReferenceRule::VARIABLE_UNITS: EXPECT_EQ("11.1.1.2", e->specificationHeading()); break; - case libcellml::SpecificationRule::UNDEFINED: + case libcellml::ReferenceRule::UNDEFINED: EXPECT_EQ("", e->specificationHeading()); break; } @@ -247,157 +247,157 @@ TEST(Issue, specificationRule) { size_t count = 0; libcellml::IssuePtr e = libcellml::Issue::create(); - e->setRule(libcellml::SpecificationRule::UNDEFINED); + e->setRule(libcellml::ReferenceRule::UNDEFINED); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::COMPONENT_CHILD); + e->setRule(libcellml::ReferenceRule::COMPONENT_CHILD); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::COMPONENT_NAME); + e->setRule(libcellml::ReferenceRule::COMPONENT_NAME); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::COMPONENT_REF_CHILD); + e->setRule(libcellml::ReferenceRule::COMPONENT_REF_CHILD); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + e->setRule(libcellml::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::COMPONENT_REF_ENCAPSULATION); + e->setRule(libcellml::ReferenceRule::COMPONENT_REF_ENCAPSULATION); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::CONNECTION_COMPONENT1); + e->setRule(libcellml::ReferenceRule::CONNECTION_COMPONENT1); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::CONNECTION_COMPONENT2); + e->setRule(libcellml::ReferenceRule::CONNECTION_COMPONENT2); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::CONNECTION_UNIQUE_TRANSITIVE); + e->setRule(libcellml::ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::CONNECTION_MAP_VARIABLES); + e->setRule(libcellml::ReferenceRule::CONNECTION_MAP_VARIABLES); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); + e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); + e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::DATA_REPR_IDENTIFIER_IDENTICAL); + e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); + e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::DATA_REPR_IDENTIFIER_UNICODE); + e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::DATA_REPR_NNEG_INT_BASE10); + e->setRule(libcellml::ReferenceRule::DATA_REPR_NNEG_INT_BASE10); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::DATA_REPR_NNEG_INT_EURO_NUM); + e->setRule(libcellml::ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::ENCAPSULATION_COMPONENT_REF); + e->setRule(libcellml::ReferenceRule::ENCAPSULATION_COMPONENT_REF); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::IMPORT_CHILD); + e->setRule(libcellml::ReferenceRule::IMPORT_CHILD); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::IMPORT_CIRCULAR); + e->setRule(libcellml::ReferenceRule::IMPORT_CIRCULAR); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::IMPORT_COMPONENT_NAME); + e->setRule(libcellml::ReferenceRule::IMPORT_COMPONENT_NAME); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::IMPORT_COMPONENT_REF); + e->setRule(libcellml::ReferenceRule::IMPORT_COMPONENT_REF); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::IMPORT_HREF); + e->setRule(libcellml::ReferenceRule::IMPORT_HREF); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::IMPORT_UNITS_NAME); + e->setRule(libcellml::ReferenceRule::IMPORT_UNITS_NAME); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::IMPORT_UNITS_REF); + e->setRule(libcellml::ReferenceRule::IMPORT_UNITS_REF); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::MAP_VARIABLES_UNIQUE); + e->setRule(libcellml::ReferenceRule::MAP_VARIABLES_UNIQUE); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::MAP_VARIABLES_VARIABLE1); + e->setRule(libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE1); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::MAP_VARIABLES_VARIABLE2); + e->setRule(libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE2); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::MODEL_CHILD); + e->setRule(libcellml::ReferenceRule::MODEL_CHILD); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::MODEL_ELEMENT); + e->setRule(libcellml::ReferenceRule::MODEL_ELEMENT); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); + e->setRule(libcellml::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::MODEL_NAME); + e->setRule(libcellml::ReferenceRule::MODEL_NAME); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::RESET_CHILD); + e->setRule(libcellml::ReferenceRule::RESET_CHILD); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::RESET_VARIABLE_REFERENCE); + e->setRule(libcellml::ReferenceRule::RESET_VARIABLE_REFERENCE); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::RESET_TEST_VARIABLE_REFERENCE); + e->setRule(libcellml::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::RESET_ORDER); + e->setRule(libcellml::ReferenceRule::RESET_ORDER); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::UNITS_CHILD); + e->setRule(libcellml::ReferenceRule::UNITS_CHILD); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::UNITS_NAME); + e->setRule(libcellml::ReferenceRule::UNITS_NAME); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::UNITS_NAME_UNIQUE); + e->setRule(libcellml::ReferenceRule::UNITS_NAME_UNIQUE); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::UNITS_STANDARD); + e->setRule(libcellml::ReferenceRule::UNITS_STANDARD); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::UNIT_OPTIONAL_ATTRIBUTE); + e->setRule(libcellml::ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::UNIT_CIRCULAR_REF); + e->setRule(libcellml::ReferenceRule::UNIT_CIRCULAR_REF); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::UNIT_DIGRAPH); + e->setRule(libcellml::ReferenceRule::UNIT_DIGRAPH); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::UNIT_EXPONENT); + e->setRule(libcellml::ReferenceRule::UNIT_EXPONENT); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::UNIT_MULTIPLIER); + e->setRule(libcellml::ReferenceRule::UNIT_MULTIPLIER); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::UNIT_PREFIX); + e->setRule(libcellml::ReferenceRule::UNIT_PREFIX); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::UNIT_UNITS_REF); + e->setRule(libcellml::ReferenceRule::UNIT_UNITS_REF); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::VARIABLE_INITIAL_VALUE); + e->setRule(libcellml::ReferenceRule::VARIABLE_INITIAL_VALUE); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::VARIABLE_INTERFACE); + e->setRule(libcellml::ReferenceRule::VARIABLE_INTERFACE); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::VARIABLE_NAME); + e->setRule(libcellml::ReferenceRule::VARIABLE_NAME); ++count; testSpecificationRule(e); - e->setRule(libcellml::SpecificationRule::VARIABLE_UNITS); + e->setRule(libcellml::ReferenceRule::VARIABLE_UNITS); ++count; testSpecificationRule(e); EXPECT_EQ(size_t(51), count); From c3ad8029b1e79ad4c780cf1dae6877750712b168 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Tue, 21 Jan 2020 10:59:13 +0100 Subject: [PATCH 19/88] rename "specification" to "reference" --- src/CMakeLists.txt | 2 +- src/api/libcellml/issue.h | 4 +- ...{specificationrules.h => referencerules.h} | 0 src/bindings/interface/issue.i | 4 +- src/bindings/interface/specificationrule.i | 4 +- src/issue.cpp | 6 +- src/utilities.h | 7 ++ tests/bindings/python/test_error.py | 4 +- tests/issue/issue.cpp | 114 +++++++++--------- tests/test_utils.cpp | 4 +- 10 files changed, 79 insertions(+), 70 deletions(-) rename src/api/libcellml/{specificationrules.h => referencerules.h} (100%) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 5514d3750..b749209fa 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -89,7 +89,7 @@ set(GIT_API_HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/parser.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/printer.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/reset.h - ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/specificationrules.h + ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/referencerules.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/types.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/units.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/validator.h diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 1a7799ad3..471ceabea 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -17,7 +17,7 @@ limitations under the License. #pragma once #include "libcellml/exportdefinitions.h" -#include "libcellml/specificationrules.h" +#include "libcellml/referencerules.h" #include "libcellml/types.h" #include @@ -229,7 +229,7 @@ class LIBCELLML_EXPORT Issue * * @return The @c std::string referencing the CellML 2.0 Specification heading relevant to this issue. */ - std::string specificationHeading() const; + std::string referenceHeading() const; /** * @brief Set the component for this component issue. diff --git a/src/api/libcellml/specificationrules.h b/src/api/libcellml/referencerules.h similarity index 100% rename from src/api/libcellml/specificationrules.h rename to src/api/libcellml/referencerules.h diff --git a/src/bindings/interface/issue.i b/src/bindings/interface/issue.i index bccdf8e4c..f08865067 100644 --- a/src/bindings/interface/issue.i +++ b/src/bindings/interface/issue.i @@ -42,7 +42,7 @@ return Level::ERROR."; %feature("docstring") libcellml::Issue::setRule "Sets the :class:`ReferenceRule` for this issue."; -%feature("docstring") libcellml::Issue::specificationHeading +%feature("docstring") libcellml::Issue::referenceHeading "Returns the CellML 2.0 Specification heading associated with the :class:`ReferenceRule` for this issue (empty string if not set)."; @@ -115,6 +115,6 @@ return Level::ERROR."; } %include "libcellml/exportdefinitions.h" -%include "libcellml/specificationrules.h" +%include "libcellml/referencerules.h" %include "libcellml/types.h" %include "libcellml/issue.h" diff --git a/src/bindings/interface/specificationrule.i b/src/bindings/interface/specificationrule.i index e6f1b8d48..99e67c79b 100644 --- a/src/bindings/interface/specificationrule.i +++ b/src/bindings/interface/specificationrule.i @@ -3,7 +3,7 @@ #define LIBCELLML_EXPORT %{ -#include "libcellml/specificationrules.h" +#include "libcellml/referencerules.h" %} -%include "libcellml/specificationrules.h" +%include "libcellml/referencerules.h" diff --git a/src/issue.cpp b/src/issue.cpp index e9ce0eacb..0fc25dd40 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -29,10 +29,12 @@ namespace libcellml { */ struct Issue::IssueImpl { - std::string mDescription; /**< The string description for why this entity issue raised. */ + std::string mDescription; /**< The string description for why this issue was raised. */ Issue::Cause mCause = Issue::Cause::UNDEFINED; /**< The Issue::Cause enum value for this issue. */ Issue::Level mLevel = Issue::Level::ERROR; /**< The Issue::Level enum value for this issue. */ ReferenceRule mRule = ReferenceRule::UNDEFINED; /**< The ReferenceRule enum value for this issue. */ + std::string mRuleURL; /**< The web address at which the rule and its guidelines are available. By default + it should be the baseIssueUrl plus the reference rule's header number. */ ComponentPtr mComponent; /**< Pointer to the component that the issue occurred in. */ ImportSourcePtr mImportSource; /**< Pointer to the import source that the issue occurred in. */ ModelPtr mModel; /**< Pointer to the model that the issue occurred in. */ @@ -316,7 +318,7 @@ static const std::map ruleToHeading = { {ReferenceRule::MAP_VARIABLES_VARIABLE2, "18.1.2"}, {ReferenceRule::MAP_VARIABLES_UNIQUE, "18.1.3"}}; -std::string Issue::specificationHeading() const +std::string Issue::referenceHeading() const { std::string heading = "X.Y.Z"; auto search = ruleToHeading.find(rule()); diff --git a/src/utilities.h b/src/utilities.h index 6e8534c3a..9ee129f62 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -24,6 +24,13 @@ limitations under the License. namespace libcellml { +/** + * Base URL from which the user guidelines used in the Issue class can be derived. + * Adding the issue's rule number to the end will search the documentation for that section. + * KRM This is clumsy and should be given a static address via formal bookmarks, but will do for proof of concept. + */ +const std::string baseIssueUrl = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q="; + /** * Vector of base units. */ diff --git a/tests/bindings/python/test_error.py b/tests/bindings/python/test_error.py index ccc6e45bf..014896227 100644 --- a/tests/bindings/python/test_error.py +++ b/tests/bindings/python/test_error.py @@ -193,9 +193,9 @@ def test_rule(self): def test_specification_heading(self): from libcellml import Issue - # std::string specificationHeading() + # std::string referenceHeading() e = Issue() - self.assertEqual('', e.specificationHeading()) + self.assertEqual('', e.referenceHeading()) def test_set_component(self): from libcellml import Issue, Component diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index d00e3a4f5..53a0f6a65 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -70,175 +70,175 @@ void testSpecificationRule(const libcellml::IssuePtr &e) { switch (e->rule()) { case libcellml::ReferenceRule::COMPONENT_CHILD: - EXPECT_EQ("10.1.2", e->specificationHeading()); + EXPECT_EQ("10.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::COMPONENT_NAME: - EXPECT_EQ("10.1.1", e->specificationHeading()); + EXPECT_EQ("10.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::COMPONENT_REF_CHILD: - EXPECT_EQ("16.1.2", e->specificationHeading()); + EXPECT_EQ("16.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE: - EXPECT_EQ("16.1.1", e->specificationHeading()); + EXPECT_EQ("16.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::COMPONENT_REF_ENCAPSULATION: - EXPECT_EQ("16.1.3", e->specificationHeading()); + EXPECT_EQ("16.1.3", e->referenceHeading()); break; case libcellml::ReferenceRule::CONNECTION_COMPONENT1: - EXPECT_EQ("17.1.1", e->specificationHeading()); + EXPECT_EQ("17.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::CONNECTION_COMPONENT2: - EXPECT_EQ("17.1.2", e->specificationHeading()); + EXPECT_EQ("17.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE: - EXPECT_EQ("17.1.3", e->specificationHeading()); + EXPECT_EQ("17.1.3", e->referenceHeading()); break; case libcellml::ReferenceRule::CONNECTION_MAP_VARIABLES: - EXPECT_EQ("17.1.4", e->specificationHeading()); + EXPECT_EQ("17.1.4", e->referenceHeading()); break; case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM: - EXPECT_EQ("3.1.3", e->specificationHeading()); + EXPECT_EQ("3.1.3", e->referenceHeading()); break; case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM: - EXPECT_EQ("3.1.4", e->specificationHeading()); + EXPECT_EQ("3.1.4", e->referenceHeading()); break; case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL: - EXPECT_EQ("3.1.5", e->specificationHeading()); + EXPECT_EQ("3.1.5", e->referenceHeading()); break; case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM: - EXPECT_EQ("3.1.2", e->specificationHeading()); + EXPECT_EQ("3.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE: - EXPECT_EQ("3.1.1", e->specificationHeading()); + EXPECT_EQ("3.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::DATA_REPR_NNEG_INT_BASE10: - EXPECT_EQ("3.2.1", e->specificationHeading()); + EXPECT_EQ("3.2.1", e->referenceHeading()); break; case libcellml::ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM: - EXPECT_EQ("3.2.2", e->specificationHeading()); + EXPECT_EQ("3.2.2", e->referenceHeading()); break; case libcellml::ReferenceRule::ENCAPSULATION_COMPONENT_REF: - EXPECT_EQ("15.1.1", e->specificationHeading()); + EXPECT_EQ("15.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::IMPORT_CHILD: - EXPECT_EQ("5.1.2", e->specificationHeading()); + EXPECT_EQ("5.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::IMPORT_CIRCULAR: - EXPECT_EQ("5.1.3", e->specificationHeading()); + EXPECT_EQ("5.1.3", e->referenceHeading()); break; case libcellml::ReferenceRule::IMPORT_COMPONENT_NAME: - EXPECT_EQ("7.1.1", e->specificationHeading()); + EXPECT_EQ("7.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::IMPORT_COMPONENT_REF: - EXPECT_EQ("7.1.2", e->specificationHeading()); + EXPECT_EQ("7.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::IMPORT_HREF: - EXPECT_EQ("5.1.1", e->specificationHeading()); + EXPECT_EQ("5.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::IMPORT_UNITS_NAME: - EXPECT_EQ("6.1.1", e->specificationHeading()); + EXPECT_EQ("6.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::IMPORT_UNITS_REF: - EXPECT_EQ("6.1.2", e->specificationHeading()); + EXPECT_EQ("6.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::MAP_VARIABLES_UNIQUE: - EXPECT_EQ("18.1.3", e->specificationHeading()); + EXPECT_EQ("18.1.3", e->referenceHeading()); break; case libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE1: - EXPECT_EQ("18.1.1", e->specificationHeading()); + EXPECT_EQ("18.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE2: - EXPECT_EQ("18.1.2", e->specificationHeading()); + EXPECT_EQ("18.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::MATH_CHILD: - EXPECT_EQ("14.1.2", e->specificationHeading()); + EXPECT_EQ("14.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::MATH_CI_VARIABLE_REFERENCE: - EXPECT_EQ("14.1.3", e->specificationHeading()); + EXPECT_EQ("14.1.3", e->referenceHeading()); break; case libcellml::ReferenceRule::MATH_CN_UNITS_ATTRIBUTE: - EXPECT_EQ("14.1.4", e->specificationHeading()); + EXPECT_EQ("14.1.4", e->referenceHeading()); break; case libcellml::ReferenceRule::MATH_MATHML: - EXPECT_EQ("14.1.1", e->specificationHeading()); + EXPECT_EQ("14.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::MODEL_CHILD: - EXPECT_EQ("4.2.2", e->specificationHeading()); + EXPECT_EQ("4.2.2", e->referenceHeading()); break; case libcellml::ReferenceRule::MODEL_ELEMENT: - EXPECT_EQ("4.1", e->specificationHeading()); + EXPECT_EQ("4.1", e->referenceHeading()); break; case libcellml::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION: - EXPECT_EQ("4.2.3", e->specificationHeading()); + EXPECT_EQ("4.2.3", e->referenceHeading()); break; case libcellml::ReferenceRule::MODEL_NAME: - EXPECT_EQ("4.2.1", e->specificationHeading()); + EXPECT_EQ("4.2.1", e->referenceHeading()); break; case libcellml::ReferenceRule::RESET_CHILD: - EXPECT_EQ("12.1.2", e->specificationHeading()); + EXPECT_EQ("12.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::RESET_VARIABLE_REFERENCE: - EXPECT_EQ("12.1.1.1", e->specificationHeading()); + EXPECT_EQ("12.1.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE: - EXPECT_EQ("12.1.1.1", e->specificationHeading()); + EXPECT_EQ("12.1.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::RESET_ORDER: - EXPECT_EQ("12.1.1.2", e->specificationHeading()); + EXPECT_EQ("12.1.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::RESET_TEST_VALUE: - EXPECT_EQ("12.1.2", e->specificationHeading()); + EXPECT_EQ("12.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::RESET_RESET_VALUE: - EXPECT_EQ("12.1.2", e->specificationHeading()); + EXPECT_EQ("12.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::UNITS_CHILD: - EXPECT_EQ("8.1.4", e->specificationHeading()); + EXPECT_EQ("8.1.4", e->referenceHeading()); break; case libcellml::ReferenceRule::UNITS_NAME: - EXPECT_EQ("8.1.1", e->specificationHeading()); + EXPECT_EQ("8.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::UNITS_NAME_UNIQUE: - EXPECT_EQ("8.1.2", e->specificationHeading()); + EXPECT_EQ("8.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::UNITS_STANDARD: - EXPECT_EQ("8.1.3", e->specificationHeading()); + EXPECT_EQ("8.1.3", e->referenceHeading()); break; case libcellml::ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE: - EXPECT_EQ("9.1.2", e->specificationHeading()); + EXPECT_EQ("9.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::UNIT_CIRCULAR_REF: - EXPECT_EQ("9.1.1.2", e->specificationHeading()); + EXPECT_EQ("9.1.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::UNIT_DIGRAPH: - EXPECT_EQ("9.1.1.1", e->specificationHeading()); + EXPECT_EQ("9.1.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::UNIT_EXPONENT: - EXPECT_EQ("9.1.2.3", e->specificationHeading()); + EXPECT_EQ("9.1.2.3", e->referenceHeading()); break; case libcellml::ReferenceRule::UNIT_MULTIPLIER: - EXPECT_EQ("9.1.2.2", e->specificationHeading()); + EXPECT_EQ("9.1.2.2", e->referenceHeading()); break; case libcellml::ReferenceRule::UNIT_PREFIX: - EXPECT_EQ("9.1.2.1", e->specificationHeading()); + EXPECT_EQ("9.1.2.1", e->referenceHeading()); break; case libcellml::ReferenceRule::UNIT_UNITS_REF: - EXPECT_EQ("9.1.1", e->specificationHeading()); + EXPECT_EQ("9.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::VARIABLE_INITIAL_VALUE: - EXPECT_EQ("11.1.2.2", e->specificationHeading()); + EXPECT_EQ("11.1.2.2", e->referenceHeading()); break; case libcellml::ReferenceRule::VARIABLE_INTERFACE: - EXPECT_EQ("11.1.2.1", e->specificationHeading()); + EXPECT_EQ("11.1.2.1", e->referenceHeading()); break; case libcellml::ReferenceRule::VARIABLE_NAME: - EXPECT_EQ("11.1.1.1", e->specificationHeading()); + EXPECT_EQ("11.1.1.1", e->referenceHeading()); break; case libcellml::ReferenceRule::VARIABLE_UNITS: - EXPECT_EQ("11.1.1.2", e->specificationHeading()); + EXPECT_EQ("11.1.1.2", e->referenceHeading()); break; case libcellml::ReferenceRule::UNDEFINED: - EXPECT_EQ("", e->specificationHeading()); + EXPECT_EQ("", e->referenceHeading()); break; } } diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp index 42684b539..3d1bf1cce 100644 --- a/tests/test_utils.cpp +++ b/tests/test_utils.cpp @@ -46,7 +46,7 @@ void printErrors(const libcellml::LoggerPtr &l, bool headings, bool causes, bool std::cout << "Issue " << std::setw(3) << i + 1 << ": "; std::cout << l->error(i)->description(); if (headings) { - std::cout << ", " << l->error(i)->specificationHeading(); + std::cout << ", " << l->error(i)->referenceHeading(); } if (causes) { std::cout << ", " << static_cast(l->error(i)->cause()); @@ -74,7 +74,7 @@ void expectEqualErrorsSpecificationHeadings(const std::vector &issu EXPECT_EQ(specificationHeadings.size(), logger->errorCount()); for (size_t i = 0; i < logger->errorCount() && i < issues.size(); ++i) { EXPECT_EQ(issues.at(i), logger->error(i)->description()); - EXPECT_EQ(specificationHeadings.at(i), logger->error(i)->specificationHeading()); + EXPECT_EQ(specificationHeadings.at(i), logger->error(i)->referenceHeading()); } } From 6540bd9c335edf5f297bc5cf389868b4dc1dab78 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Tue, 21 Jan 2020 14:04:04 +0100 Subject: [PATCH 20/88] Adding url to Issue class --- src/api/libcellml/issue.h | 22 ++++++++++++++++++++++ src/bindings/interface/issue.i | 6 ++++++ src/issue.cpp | 17 ++++++++++++++++- 3 files changed, 44 insertions(+), 1 deletion(-) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 471ceabea..0be83005f 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -221,6 +221,28 @@ class LIBCELLML_EXPORT Issue */ ReferenceRule rule() const; + /** + * @brief Set the @c url of this issue. + * + * Manually set the @c url to which the user should refer for more information on the + * specification rule which has been broken or guidelines that haven't been followed. + * If this has not been set manually by use of this function, the default root url + * will be used (specified in baseIssueUrl) in conjunction with the referenceHeading + * string. + * + * @param rule The @c url to set manually. + */ + void setUrl(std::string &url) const; + + /** + * @brief Get the @c url of this issue. + * + * Get the @c url to which the user should refer for more information on this issue. + * + * @return The @c url for this issue. + */ + std::string url() const; + /** * @brief Get the @c std::string heading associated with the @c enum ReferenceRule for this issue. * diff --git a/src/bindings/interface/issue.i b/src/bindings/interface/issue.i index f08865067..50b71c440 100644 --- a/src/bindings/interface/issue.i +++ b/src/bindings/interface/issue.i @@ -42,6 +42,12 @@ return Level::ERROR."; %feature("docstring") libcellml::Issue::setRule "Sets the :class:`ReferenceRule` for this issue."; +%feature("docstring") libcellml::Issue::url +"Get the url for more information about this issue."; + +%feature("docstring") libcellml::Issue::setUrl +"Manually sets the url to which users are referred for this issue."; + %feature("docstring") libcellml::Issue::referenceHeading "Returns the CellML 2.0 Specification heading associated with the :class:`ReferenceRule` for this issue (empty string if not set)."; diff --git a/src/issue.cpp b/src/issue.cpp index 0fc25dd40..d1328595f 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -16,6 +16,7 @@ limitations under the License. #include "libcellml/issue.h" #include "libcellml/types.h" +#include "utilities.h" #include #include @@ -33,7 +34,7 @@ struct Issue::IssueImpl Issue::Cause mCause = Issue::Cause::UNDEFINED; /**< The Issue::Cause enum value for this issue. */ Issue::Level mLevel = Issue::Level::ERROR; /**< The Issue::Level enum value for this issue. */ ReferenceRule mRule = ReferenceRule::UNDEFINED; /**< The ReferenceRule enum value for this issue. */ - std::string mRuleURL; /**< The web address at which the rule and its guidelines are available. By default + std::string mReferenceUrl; /**< The web address at which the rule and its guidelines are available. By default it should be the baseIssueUrl plus the reference rule's header number. */ ComponentPtr mComponent; /**< Pointer to the component that the issue occurred in. */ ImportSourcePtr mImportSource; /**< Pointer to the import source that the issue occurred in. */ @@ -188,6 +189,20 @@ ReferenceRule Issue::rule() const return mPimpl->mRule; } +void Issue::setUrl(std::string &url) const +{ + mPimpl->mReferenceUrl = url; +} + +std::string Issue::url() const +{ + if (mPimpl->mReferenceUrl.empty()) { + // Then construct from the default address formula: baseIssueUrl + rule number. + return baseIssueUrl + referenceHeading(); + } + return mPimpl->mReferenceUrl; +} + void Issue::setComponent(const ComponentPtr &component) { mPimpl->mComponent = component; From 6a71e9a4bd68e8497322fb59a227bc1b322e9ba7 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Tue, 21 Jan 2020 16:36:28 +0100 Subject: [PATCH 21/88] Added tests for coverage --- src/api/libcellml/referencerules.h | 2 + tests/issue/issue.cpp | 126 +++++++++++++++++------------ 2 files changed, 75 insertions(+), 53 deletions(-) diff --git a/src/api/libcellml/referencerules.h b/src/api/libcellml/referencerules.h index ddd20adea..55df1f0c6 100644 --- a/src/api/libcellml/referencerules.h +++ b/src/api/libcellml/referencerules.h @@ -27,6 +27,7 @@ namespace libcellml { enum class ReferenceRule { UNDEFINED, + // Validation errors DATA_REPR_IDENTIFIER_UNICODE, DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, @@ -83,6 +84,7 @@ enum class ReferenceRule MAP_VARIABLES_VARIABLE1, MAP_VARIABLES_VARIABLE2, MAP_VARIABLES_UNIQUE + // Code generation errors go here... TODO }; } // namespace libcellml diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index 53a0f6a65..a024c8562 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -15,6 +15,7 @@ limitations under the License-> */ #include "gtest/gtest.h" +#include "libcellml/referencerules.h" #include @@ -26,7 +27,7 @@ TEST(Issue, createModelError) EXPECT_EQ(libcellml::Issue::Cause::MODEL, e->cause()); } -TEST(Issue, createComponemntError) +TEST(Issue, createComponentError) { libcellml::ComponentPtr c = libcellml::Component::create(); libcellml::IssuePtr e = libcellml::Issue::create(c); @@ -66,7 +67,7 @@ TEST(Issue, createResetError) EXPECT_EQ(libcellml::Issue::Cause::RESET, e->cause()); } -void testSpecificationRule(const libcellml::IssuePtr &e) +void testReferenceRule(const libcellml::IssuePtr &e) { switch (e->rule()) { case libcellml::ReferenceRule::COMPONENT_CHILD: @@ -249,157 +250,157 @@ TEST(Issue, specificationRule) libcellml::IssuePtr e = libcellml::Issue::create(); e->setRule(libcellml::ReferenceRule::UNDEFINED); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::COMPONENT_CHILD); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::COMPONENT_NAME); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::COMPONENT_REF_CHILD); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::COMPONENT_REF_ENCAPSULATION); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::CONNECTION_COMPONENT1); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::CONNECTION_COMPONENT2); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::CONNECTION_MAP_VARIABLES); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::DATA_REPR_NNEG_INT_BASE10); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::ENCAPSULATION_COMPONENT_REF); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::IMPORT_CHILD); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::IMPORT_CIRCULAR); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::IMPORT_COMPONENT_NAME); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::IMPORT_COMPONENT_REF); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::IMPORT_HREF); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::IMPORT_UNITS_NAME); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::IMPORT_UNITS_REF); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::MAP_VARIABLES_UNIQUE); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE1); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE2); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::MODEL_CHILD); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::MODEL_ELEMENT); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::MODEL_NAME); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::RESET_CHILD); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::RESET_VARIABLE_REFERENCE); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::RESET_ORDER); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::UNITS_CHILD); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::UNITS_NAME); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::UNITS_NAME_UNIQUE); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::UNITS_STANDARD); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::UNIT_CIRCULAR_REF); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::UNIT_DIGRAPH); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::UNIT_EXPONENT); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::UNIT_MULTIPLIER); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::UNIT_PREFIX); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::UNIT_UNITS_REF); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::VARIABLE_INITIAL_VALUE); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::VARIABLE_INTERFACE); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::VARIABLE_NAME); ++count; - testSpecificationRule(e); + testReferenceRule(e); e->setRule(libcellml::ReferenceRule::VARIABLE_UNITS); ++count; - testSpecificationRule(e); + testReferenceRule(e); EXPECT_EQ(size_t(51), count); } @@ -483,3 +484,22 @@ TEST(Issue, isHint) e->setLevel(libcellml::Issue::Level::HINT); EXPECT_TRUE(e->isLevel(libcellml::Issue::Level::HINT)); } + +TEST(Issue, getDefaultUrl) +{ + auto e = libcellml::Issue::create(); + e->setRule(libcellml::ReferenceRule::MODEL_NAME); + auto ref = e->referenceHeading(); + + // TODO How to get this from the utilties.h file?? + std::string url = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q=" + ref; + EXPECT_EQ("https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q=4.2.1", url); +} + +TEST(Issue, setAndGetCustomUrl) +{ + auto e = libcellml::Issue::create(); + std::string url = "https://my_custom_url.com"; + e->setUrl(url); + EXPECT_EQ(url, e->url()); +} From ce501c63637bf8791300985d54b56764c6ff7f65 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Tue, 21 Jan 2020 16:50:34 +0100 Subject: [PATCH 22/88] One more line of coverage ... --- tests/issue/issue.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index a024c8562..fa6fa2894 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -493,7 +493,7 @@ TEST(Issue, getDefaultUrl) // TODO How to get this from the utilties.h file?? std::string url = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q=" + ref; - EXPECT_EQ("https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q=4.2.1", url); + EXPECT_EQ(e->url(), url); } TEST(Issue, setAndGetCustomUrl) From a6bdf24a56223d0bd8a5eb7abddbccae0aad09a5 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Tue, 21 Jan 2020 16:52:02 +0100 Subject: [PATCH 23/88] Update issue.cpp --- tests/issue/issue.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index fa6fa2894..2073198e4 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -491,7 +491,7 @@ TEST(Issue, getDefaultUrl) e->setRule(libcellml::ReferenceRule::MODEL_NAME); auto ref = e->referenceHeading(); - // TODO How to get this from the utilties.h file?? + // TODO How to get this from the utilties.h file?? Won't be this address in the long run. std::string url = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q=" + ref; EXPECT_EQ(e->url(), url); } From 5f55adfda5612c7802eac0a5d7532fbd56279acc Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 22 Jan 2020 09:02:37 +0100 Subject: [PATCH 24/88] Multiplier mismatch in equivalent variables --- src/validator.cpp | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/src/validator.cpp b/src/validator.cpp index 16a1a4283..18c6ef133 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -985,18 +985,17 @@ void Validator::ValidatorImpl::validateConnections(const ModelPtr &model) err->setModel(model); err->setCause(Issue::Cause::UNITS); mValidator->addIssue(err); + } else if (multiplier != 0.0) { + // Warning when the multipliers are not the same. + auto unitsName = variable->units() == nullptr ? "" : variable->units()->name(); + auto equivalentUnitsName = equivalentVariable->units() == nullptr ? "" : equivalentVariable->units()->name(); + IssuePtr err = Issue::create(); + err->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); + err->setModel(model); + err->setLevel(libcellml::Issue::Level::WARNING); + err->setCause(Issue::Cause::UNITS); + mValidator->addIssue(err); } - // } else if (multiplier != 0.0) { - // // KRM Warning when the multipliers are not the same. - // auto unitsName = variable->units() == nullptr ? "" : variable->units()->name(); - // auto equivalentUnitsName = equivalentVariable->units() == nullptr ? "" : equivalentVariable->units()->name(); - // IssuePtr err = Issue::create(); - // err->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); - // err->setModel(model); - // err->setLevel(libcellml::Issue::Level::WARNING); - // err->setCause(Issue::Cause::UNITS); - // mValidator->addIssue(err); - // } if (equivalentVariable->hasEquivalentVariable(variable)) { // Check that the equivalent variable has a valid parent component. From 3c43778f701f8cbc667d266f35ac097ab8dd5d7e Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 22 Jan 2020 13:31:30 +0100 Subject: [PATCH 25/88] FIxed bug in multiplier checking --- default.profraw | 0 src/logger.cpp | 27 ++++++- src/validator.cpp | 2 +- tests/test_utils.cpp | 20 +++-- tests/test_utils.h | 8 +- tests/validator/validator.cpp | 143 ++++++++++++++++++++++++++-------- 6 files changed, 158 insertions(+), 42 deletions(-) create mode 100644 default.profraw diff --git a/default.profraw b/default.profraw new file mode 100644 index 000000000..e69de29bb diff --git a/src/logger.cpp b/src/logger.cpp index ce23378b3..c301ed45b 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -104,7 +104,32 @@ void Logger::addIssue(const IssuePtr &issue) mPimpl->mIssues.push_back(issue); size_t index = mPimpl->mIssues.size() - 1; // Update the appropriate array based on its level - switch (issue->level()) { + + libcellml::Issue::Level level = issue->level(); + // if (issue->isLevel(libcellml::Issue::Level::ERROR)) { + // mPimpl->mErrors.push_back(index); + // } + + // if (issue->isLevel(libcellml::Issue::Level::WARNING)) { + // mPimpl->mWarnings.push_back(index); + // } + + // if (issue->isLevel(libcellml::Issue::Level::HINT)) { + // mPimpl->mHints.push_back(index); + // } + // auto level = issue->level(); + + // if (level == libcellml::Issue::Level::ERROR){ + // mPimpl->mErrors.push_back(index); + // } + // else if (level == libcellml::Issue::Level::WARNING){ + // mPimpl->mWarnings.push_back(index); + // } + // else if (level == libcellml::Issue::Level::HINT){ + // mPimpl->mHints.push_back(index); + // } + + switch (level) { case libcellml::Issue::Level::ERROR: mPimpl->mErrors.push_back(index); break; diff --git a/src/validator.cpp b/src/validator.cpp index 18c6ef133..700ecd9f3 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -1169,7 +1169,7 @@ void Validator::ValidatorImpl::updateBaseUnitCount(const ModelPtr &model, for (const auto &iter : standardUnitsList.at(uName)) { unitMap.at(iter.first) += direction * (iter.second * uExp); } - multiplier += direction * logMult; + multiplier += direction * (logMult + standardMultiplierList.at(uName)); // KRM added standardMultiplierList } } diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp index 3d1bf1cce..71c8bd4f3 100644 --- a/tests/test_utils.cpp +++ b/tests/test_utils.cpp @@ -40,19 +40,19 @@ std::string fileContents(const std::string &fileName) return buffer.str(); } -void printErrors(const libcellml::LoggerPtr &l, bool headings, bool causes, bool rule) +void printIssues(const libcellml::LoggerPtr &l, bool headings, bool causes, bool rule) { - for (size_t i = 0; i < l->errorCount(); ++i) { + for (size_t i = 0; i < l->issueCount(); ++i) { std::cout << "Issue " << std::setw(3) << i + 1 << ": "; - std::cout << l->error(i)->description(); + std::cout << l->issue(i)->description(); if (headings) { - std::cout << ", " << l->error(i)->referenceHeading(); + std::cout << ", " << l->issue(i)->referenceHeading(); } if (causes) { - std::cout << ", " << static_cast(l->error(i)->cause()); + std::cout << ", " << static_cast(l->issue(i)->cause()); } if (rule) { - std::cout << ", " << static_cast(l->error(i)->rule()); + std::cout << ", " << static_cast(l->issue(i)->rule()); } std::cout << std::endl; } @@ -66,6 +66,14 @@ void expectEqualErrors(const std::vector &issues, const libcellml:: } } +void expectEqualIssues(const std::vector &issues, const libcellml::LoggerPtr &logger) +{ + EXPECT_EQ(issues.size(), logger->issueCount()); + for (size_t i = 0; i < logger->issueCount() && i < issues.size(); ++i) { + EXPECT_EQ(issues.at(i), logger->issue(i)->description()); + } +} + void expectEqualErrorsSpecificationHeadings(const std::vector &issues, const std::vector &specificationHeadings, const libcellml::LoggerPtr &logger) diff --git a/tests/test_utils.h b/tests/test_utils.h index 9f2370c6c..10f11ba5f 100644 --- a/tests/test_utils.h +++ b/tests/test_utils.h @@ -77,10 +77,12 @@ std::string TEST_EXPORT resourcePath(const std::string &resourceRelativePath = " std::string TEST_EXPORT fileContents(const std::string &fileName); -void TEST_EXPORT printErrors(const libcellml::LoggerPtr &l, bool headings = false, bool causes = false, bool rule = false); +void TEST_EXPORT printIssues(const libcellml::LoggerPtr &l, bool headings = false, bool causes = false, bool rule = false); void TEST_EXPORT expectEqualErrors(const std::vector &issues, const libcellml::LoggerPtr &logger); +void TEST_EXPORT expectEqualIssues(const std::vector &issues, + const libcellml::LoggerPtr &logger); void TEST_EXPORT expectEqualErrorsSpecificationHeadings(const std::vector &issues, const std::vector &specificationHeadings, const libcellml::LoggerPtr &logger); @@ -93,6 +95,10 @@ libcellml::ModelPtr TEST_EXPORT createModelWithComponent(const std::string &name libcellml::VariablePtr TEST_EXPORT createVariableWithUnits(const std::string &name, const std::string &units); libcellml::ModelPtr TEST_EXPORT createModelTwoComponentsWithOneVariableEach(const std::string &modelName = "", const std::string &c1Name = "", const std::string &c2Name = "", const std::string &v1Name = "", const std::string &v2Name = ""); +#define EXPECT_EQ_ISSUES(issues, logger) \ + SCOPED_TRACE("Issue occured here."); \ + expectEqualIssues(issues, logger) + #define EXPECT_EQ_ERRORS(issues, logger) \ SCOPED_TRACE("Issue occured here."); \ expectEqualErrors(issues, logger) diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 888a17412..916fce6b6 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -1798,7 +1798,7 @@ TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) { // This test is intended to demonstrate that the effect of different multiplicator sources (prefix, multiplier term) // does not affect the equivalence of the underlying base variables. - // TODO: when warnings are implemented then the multiplier testing can be reinstated. + std::string expectedWarning = "Variable 'v1' has units of 'u4' and an equivalent variable 'v2' with non-matching units of 'u5'. The mismatch is: multiplication factor of 10^12."; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr model = libcellml::Model::create(); @@ -1838,7 +1838,7 @@ TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) // u4 ~= u5: Units will be equivalent, testing that prefix, multiplier, and exponent validation is correct. // Note: there is a factor of 1000 between u4 and u5 since u4 = 10^15*u3 (rather than 10^18*u3), which is - // fine since we only need units to be equivalent. + // fine since we only need units to be equivalent for validation. // TODO: see issue in specification: https://github.com/cellml/cellml-specification/issues/19. v1->setUnits(u4); v2->setUnits(u5); @@ -1862,7 +1862,11 @@ TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) libcellml::Variable::addEquivalence(v1, v2); validator->validateModel(model); + EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->hintCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); + EXPECT_EQ(expectedWarning, validator->warning(0)->description()); } TEST(Validator, unitUserCreatedUnitsBananasAndApples) @@ -1979,7 +1983,8 @@ TEST(Validator, unitStandardUnitsWhichAreNotBaseUnits) TEST(Validator, unitMultiplierFactorDifference) { - const std::vector expectedErrors = {}; + const std::vector expectedErrors = { + "Variable 'v1' has units of 'litre' and an equivalent variable 'v2' with non-matching units of 'big_barrel'. The mismatch is: multiplication factor of 10^-3."}; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); @@ -1997,11 +2002,70 @@ TEST(Validator, unitMultiplierFactorDifference) v2->setUnits("big_barrel"); - libcellml::Variable::addEquivalence(v1, v2); // litre ~= metre^3 . + libcellml::Variable::addEquivalence(v1, v2); // 1000L = 1m^3 + + m->linkUnits(); validator->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); + EXPECT_EQ(size_t(0), validator->hintCount()); + + EXPECT_EQ_ISSUES(expectedErrors, validator); +} + +TEST(Validator, unitStandardMultipliersLitre) +{ + libcellml::ValidatorPtr validator = libcellml::Validator::create(); + libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); + auto c1 = m->component(0); + auto c2 = m->component(1); + auto v1 = c1->variable(0); + auto v2 = c2->variable(0); + + v1->setUnits("litre"); + + libcellml::UnitsPtr u = libcellml::Units::create(); + u->setName("decimetre_cubed"); + u->addUnit("metre", "deci", 3.0); // a litre is a (0.1m)^3 + m->addUnits(u); + + v2->setUnits("decimetre_cubed"); + + libcellml::Variable::addEquivalence(v1, v2); // litre = dm^3 . + + m->linkUnits(); + + validator->validateModel(m); + printIssues(validator); + + EXPECT_EQ(size_t(0), validator->issueCount()); +} + +TEST(Validator, unitStandardMultipliersGram) +{ + libcellml::ValidatorPtr validator = libcellml::Validator::create(); + libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); + auto c1 = m->component(0); + auto c2 = m->component(1); + auto v1 = c1->variable(0); + auto v2 = c2->variable(0); + + v1->setUnits("kilogram"); + + libcellml::UnitsPtr u = libcellml::Units::create(); + u->setName("thousand_grams"); + u->addUnit("gram", "kilo"); + m->addUnits(u); + v2->setUnits(u); + + libcellml::Variable::addEquivalence(v1, v2); + + validator->validateModel(m); + + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unitSimpleCycle) @@ -2280,36 +2344,49 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) EXPECT_EQ_ERRORS(expectedErrors, v); } -/****************************************************************************** +/** * * ISSUE WARNINGS TESTING FROM HERE DOWN * * ==========================================================================*/ -// TEST(Validator, mismatchedMultipliersInUnits) -// { -// // If two units are linked through variable equivalence mapping and their -// // scaling factor is not the same, it should raise a warning-level issue - -// auto model = libcellml::Model::create("Gulliver"); -// auto c1 = libcellml::Component::create("Brobdingnag"); -// auto c2 = libcellml::Component::create("Lilliput"); -// auto v1 = libcellml::Variable::create("v1"); -// auto v2 = libcellml::Variable::create("v2"); - -// v1->setUnits("metre", "mega"); -// v2->setUnits("metre", "milli"); -// c1->addVariable(v1); -// c2->addVariable(v2); -// model->addComponent(c1); -// model->addComponent(c2); -// v1->setEquivalentTo(v2); - -// auto validator = libcellml::Validator::create(); -// validator->validateModel(model); -// EXPECT_EQ(size_t(0), validator->errorCount()); -// EXPECT_EQ(size_t(1), validator->warningCount()); -// EXPECT_EQ(size_t(1), validator->errorCount()); -// EXPECT_EQ(size_t(1), validator->errorCount(libcellml::Issue::Level::WARNING)); - -// } +TEST(Validator, mismatchedMultipliersInUnits) +{ + // If two units are linked through variable equivalence mapping and their + // scaling factor is not the same, it should raise a warning-level issue + std::vector expectedIssues = { + "Variable 'v1' has units of 'megametre' and an equivalent variable 'v2' with non-matching units of 'millimetre'. The mismatch is: multiplication factor of 10^9."}; + + auto model = libcellml::Model::create("Gulliver"); + auto c1 = libcellml::Component::create("Brobdingnag"); + auto c2 = libcellml::Component::create("Lilliput"); + auto v1 = libcellml::Variable::create("v1"); + auto v2 = libcellml::Variable::create("v2"); + + auto u1 = libcellml::Units::create("megametre"); + u1->addUnit("metre", "mega"); + + auto u2 = libcellml::Units::create("millimetre"); + u2->addUnit("metre", "milli"); + + v1->setUnits(u1); + v2->setUnits(u2); + c1->addVariable(v1); + c2->addVariable(v2); + model->addComponent(c1); + model->addComponent(c2); + model->addUnits(u1); + model->addUnits(u2); + + libcellml::Variable::addEquivalence(v1, v2); + + auto validator = libcellml::Validator::create(); + validator->validateModel(model); + + EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); + EXPECT_EQ(size_t(0), validator->hintCount()); + EXPECT_EQ(size_t(1), validator->issueCount()); + + EXPECT_EQ_ISSUES(expectedIssues, validator); +} From a94dfc0669e5684a25ab3a2d7c7f0cbf84b72fb6 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 22 Jan 2020 13:54:09 +0100 Subject: [PATCH 26/88] Add tests for warnings from dimensional exponents in maths: expect failure --- tests/validator/validator.cpp | 76 ++++++++++++++++++++++++++++++++++- 1 file changed, 75 insertions(+), 1 deletion(-) diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 916fce6b6..afb0f418e 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -2350,7 +2350,7 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) * * ==========================================================================*/ -TEST(Validator, mismatchedMultipliersInUnits) +TEST(Validator, warningMismatchedMultipliersInUnits) { // If two units are linked through variable equivalence mapping and their // scaling factor is not the same, it should raise a warning-level issue @@ -2390,3 +2390,77 @@ TEST(Validator, mismatchedMultipliersInUnits) EXPECT_EQ_ISSUES(expectedIssues, validator); } + +TEST(Validator, warningDimensionalExponentsCiInMathml) +{ + auto validator = libcellml::Validator::create(); + auto model = libcellml::Model::create("model"); + auto component = libcellml::Component::create("component"); + model->addComponent(component); + + auto rhs = libcellml::Variable::create("rhs"); + rhs->setUnits("dimensionless"); + component->addVariable(rhs); + + auto base = libcellml::Variable::create("base"); + base->setUnits("dimensionless"); + component->addVariable(base); + + auto exponent = libcellml::Variable::create("exponent"); + exponent->setUnits("metre"); + component->addVariable(exponent); + + std::string mathHeader = "\n"; + std::string mathFooter = ""; + std::string maths = + " \n" + " rhs\n" + " \n" + " base\n" + " exponent\n" + " \n" + " \n"; + component->setMath(mathHeader); + component->appendMath(maths); + component->appendMath(mathFooter); + + validator->validateModel(model); + + EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); +} + +TEST(Validator, warningDimensionalExponentsCnInMathml) +{ + auto validator = libcellml::Validator::create(); + auto model = libcellml::Model::create("model"); + auto component = libcellml::Component::create("component"); + model->addComponent(component); + + auto rhs = libcellml::Variable::create("rhs"); + rhs->setUnits("dimensionless"); + component->addVariable(rhs); + + auto base = libcellml::Variable::create("base"); + base->setUnits("dimensionless"); + component->addVariable(base); + + std::string mathHeader = "\n"; + std::string mathFooter = ""; + std::string maths = + " \n" + " rhs\n" + " \n" + " base\n" + " 2\n" + " \n" + " \n"; + component->setMath(mathHeader); + component->appendMath(maths); + component->appendMath(mathFooter); + + validator->validateModel(model); + + EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); +} From 7d8eed691c8a62f721511d5787853d20ad24b779 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 22 Jan 2020 15:24:37 +0100 Subject: [PATCH 27/88] Added tests and files for circular import checking --- tests/resolve_imports/file_parser.cpp | 13 +++++++++++++ .../circularimports/circularImport_1.cellml | 8 ++++++++ .../circularimports/circularImport_2.cellml | 8 ++++++++ .../circularimports/circularImport_3.cellml | 8 ++++++++ tests/validator/validator.cpp | 6 ------ 5 files changed, 37 insertions(+), 6 deletions(-) create mode 100644 tests/resources/circularimports/circularImport_1.cellml create mode 100644 tests/resources/circularimports/circularImport_2.cellml create mode 100644 tests/resources/circularimports/circularImport_3.cellml diff --git a/tests/resolve_imports/file_parser.cpp b/tests/resolve_imports/file_parser.cpp index 475e20e5c..e38b539aa 100644 --- a/tests/resolve_imports/file_parser.cpp +++ b/tests/resolve_imports/file_parser.cpp @@ -118,3 +118,16 @@ TEST(ResolveImports, componentNotInResolvingModel) model->resolveImports(resourcePath()); EXPECT_TRUE(model->hasUnresolvedImports()); } + +// *** KRM Adding tests for warning-type issues here + +TEST(ResolveImports, warningCircularImportReferences) +{ + auto parser = libcellml::Parser::create(); + auto validator = libcellml::Validator::create(); + auto model1 = parser->parseModel(fileContents("circularimports/circularImport_1.cellml")); + validator->validateModel(model1); + printIssues(validator); + + EXPECT_EQ(size_t(1), validator->issueCount()); +} diff --git a/tests/resources/circularimports/circularImport_1.cellml b/tests/resources/circularimports/circularImport_1.cellml new file mode 100644 index 000000000..20b757b73 --- /dev/null +++ b/tests/resources/circularimports/circularImport_1.cellml @@ -0,0 +1,8 @@ + + + + + + diff --git a/tests/resources/circularimports/circularImport_2.cellml b/tests/resources/circularimports/circularImport_2.cellml new file mode 100644 index 000000000..8c79dbcb1 --- /dev/null +++ b/tests/resources/circularimports/circularImport_2.cellml @@ -0,0 +1,8 @@ + + + + + + diff --git a/tests/resources/circularimports/circularImport_3.cellml b/tests/resources/circularimports/circularImport_3.cellml new file mode 100644 index 000000000..df9caf0e2 --- /dev/null +++ b/tests/resources/circularimports/circularImport_3.cellml @@ -0,0 +1,8 @@ + + + + + + diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index afb0f418e..6fbe49166 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -2344,12 +2344,6 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) EXPECT_EQ_ERRORS(expectedErrors, v); } -/** - * - * ISSUE WARNINGS TESTING FROM HERE DOWN - * - * ==========================================================================*/ - TEST(Validator, warningMismatchedMultipliersInUnits) { // If two units are linked through variable equivalence mapping and their From 5a3d5a8a4c63ce1ff99c6748f0584eb2f2c693b8 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 22 Jan 2020 17:18:00 +0100 Subject: [PATCH 28/88] working towards cyclic import warning --- src/api/libcellml/model.h | 11 ++++ src/model.cpp | 56 ++++++++++++++--- src/validator.cpp | 86 +++++++++++++++++++++++++++ tests/resolve_imports/file_parser.cpp | 21 ++++--- tests/validator/validator.cpp | 18 ++++++ 5 files changed, 175 insertions(+), 17 deletions(-) diff --git a/src/api/libcellml/model.h b/src/api/libcellml/model.h index 1a8396edc..29363ce41 100644 --- a/src/api/libcellml/model.h +++ b/src/api/libcellml/model.h @@ -306,6 +306,17 @@ class LIBCELLML_EXPORT Model: public ComponentEntity */ void resolveImports(const std::string &baseFile); + /** + * @brief Resolve all imports in this model. + * + * Resolve all @c Component and @c Units imports by loading the models + * from local disk through relative URLs. The @p baseFile is used to determine + * the full path to the source model relative to this one. + * + * @param baseFile The @c std::string location on local disk of the source @c Model. + */ + void resolveImports(const std::string &baseFile, std::vector &history); + /** * @brief Test if this model has unresolved imports. * diff --git a/src/model.cpp b/src/model.cpp index dcab5b420..5f44ba099 100644 --- a/src/model.cpp +++ b/src/model.cpp @@ -24,6 +24,8 @@ limitations under the License. #include #include +#include // KRM + #include "libcellml/component.h" #include "libcellml/importsource.h" #include "libcellml/parser.h" @@ -314,11 +316,29 @@ std::string resolvePath(const std::string &filename, const std::string &base) return path; } -void resolveImport(const ImportedEntityPtr &importedEntity, - const std::string &baseFile) +bool resolveImport(const ImportedEntityPtr &importedEntity, + const std::string &baseFile, + std::vector &history, + bool &cycleFound) { + if (importedEntity->isImport()) { ImportSourcePtr importSource = importedEntity->importSource(); + + // history.push_back(importedEntity->importReference()); + + for (auto &h : history) { + std::cout << h << ", "; + } + std::cout << std::endl; + + if (std::find(history.begin(), history.end(), importedEntity->importReference()) != history.end()) { + // Element in vector. + std::cout << "Found it!" << std::endl; + cycleFound = true; + return; + } + if (!importSource->hasModel()) { std::string url = resolvePath(importSource->url(), baseFile); std::ifstream file(url); @@ -328,32 +348,52 @@ void resolveImport(const ImportedEntityPtr &importedEntity, ParserPtr parser = Parser::create(); ModelPtr model = parser->parseModel(buffer.str()); importSource->setModel(model); - model->resolveImports(url); + model->resolveImports(url, history); } } } } void resolveComponentImports(const ComponentEntityPtr &parentComponentEntity, - const std::string &baseFile) + const std::string &baseFile, + std::vector &history) { for (size_t n = 0; n < parentComponentEntity->componentCount(); ++n) { libcellml::ComponentPtr component = parentComponentEntity->component(n); + history.push_back(component->name()); + + std::cout << component->name() << std::endl; + if (component->isImport()) { - resolveImport(component, baseFile); + resolveImport(component, baseFile, history, cycleFound); } else { - resolveComponentImports(component, baseFile); + resolveComponentImports(component, baseFile, history); } } } +void Model::resolveImports(const std::string &baseFile, std::vector &history, bool &cycleFound) +{ + for (size_t n = 0; n < unitsCount(); ++n) { + libcellml::UnitsPtr units = Model::units(n); + resolveImport(units, baseFile, history, cycleFound); + } + + // history.push_back(u->name()); + resolveComponentImports(shared_from_this(), baseFile, history); +} + void Model::resolveImports(const std::string &baseFile) { + bool cycleFound = false; + std::vector history = {}; for (size_t n = 0; n < unitsCount(); ++n) { libcellml::UnitsPtr units = Model::units(n); - resolveImport(units, baseFile); + resolveImport(units, baseFile, history, cycleFound); } - resolveComponentImports(shared_from_this(), baseFile); + + // history.push_back(u->name()); + resolveComponentImports(shared_from_this(), baseFile, history); } bool isUnresolvedImport(const ImportedEntityPtr &importedEntity) diff --git a/src/validator.cpp b/src/validator.cpp index 700ecd9f3..98b223942 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -258,6 +258,11 @@ struct Validator::ValidatorImpl void checkUnitForCycles(const ModelPtr &model, const UnitsPtr &parent, std::vector &history, std::vector> &errorList); + + void checkNoImportsAreCyclic(const ModelPtr &model); + void checkImportsForCycles(const ModelPtr &model, const UnitsPtr &parent, + std::vector &history, + std::vector> &errorList); }; Validator::Validator() @@ -1254,4 +1259,85 @@ void Validator::ValidatorImpl::checkUnitForCycles(const ModelPtr &model, const U } } +void Validator::ValidatorImpl::checkNoImportsAreCyclic(const ModelPtr &model) +{ + std::vector history; + std::vector> errorList; + + for (size_t i = 0; i < model->unitsCount(); ++i) { + // Test each units' dependencies for presence of self in tree. + UnitsPtr u = model->units(i); + history.push_back(u->name()); + checkImportsForCycles(model, u, history, errorList); + // Have to delete this each time to prevent reinitialisation with previous base variables. + std::vector().swap(history); + } + + if (!errorList.empty()) { + std::vector> reportedErrorList; + for (auto &issues : errorList) { + std::map hash; + + for (auto &e : issues) { + hash.insert(std::pair(e, true)); + } + + // Only return as issue if this combo has not been reported already. + if (std::find(reportedErrorList.begin(), reportedErrorList.end(), hash) == reportedErrorList.end()) { + IssuePtr err = Issue::create(); + std::string des = "'"; + for (size_t j = 0; j < issues.size() - 1; ++j) { + des += issues[j] + "' -> '"; + } + des += issues[issues.size() - 1] + "'"; + err->setDescription("Cyclic units exist: " + des); + err->setModel(model); + err->setCause(Issue::Cause::UNITS); + mValidator->addIssue(err); + reportedErrorList.push_back(hash); + } + std::map().swap(hash); + } + } +} + +void Validator::ValidatorImpl::checkImportsForCycles(const ModelPtr &model, const UnitsPtr &parent, + std::vector &history, + std::vector> &errorList) +{ + if (parent->isBaseUnit()) { + return; + } + + // Recursive function to check for self-referencing in unit definitions. + std::string id; + std::string ref; + std::string prefix; + double exp; + double mult; + + // Take history, and copy it for each new branch. + for (size_t i = 0; i < parent->unitCount(); ++i) { + parent->unitAttributes(i, ref, prefix, exp, mult, id); + if (std::find(history.begin(), history.end(), ref) != history.end()) { + history.push_back(ref); + // Print to error output *only* when the first and last units are the same + // otherwise we get lasso shapes reported. + if (history.front() == history.back()) { + errorList.push_back(history); + } + } else { + // Step into dependencies if they are not built-in units. + if (model->hasUnits(ref)) { + UnitsPtr child = model->units(ref); + history.push_back(ref); + // Making a copy of the history vector to this point. + std::vector child_history(history); + checkImportsForCycles(model, child, child_history, errorList); + std::vector().swap(child_history); + } + } + } +} + } // namespace libcellml diff --git a/tests/resolve_imports/file_parser.cpp b/tests/resolve_imports/file_parser.cpp index e38b539aa..41685013c 100644 --- a/tests/resolve_imports/file_parser.cpp +++ b/tests/resolve_imports/file_parser.cpp @@ -121,13 +121,16 @@ TEST(ResolveImports, componentNotInResolvingModel) // *** KRM Adding tests for warning-type issues here -TEST(ResolveImports, warningCircularImportReferences) -{ - auto parser = libcellml::Parser::create(); - auto validator = libcellml::Validator::create(); - auto model1 = parser->parseModel(fileContents("circularimports/circularImport_1.cellml")); - validator->validateModel(model1); - printIssues(validator); +// TEST(ResolveImports, warningCircularImportReferences) +// { +// auto parser = libcellml::Parser::create(); +// auto validator = libcellml::Validator::create(); +// auto model1 = parser->parseModel(fileContents("circularimports/circularImport_1.cellml")); - EXPECT_EQ(size_t(1), validator->issueCount()); -} +// model1->resolveImports(resourcePath("circularimports/")); + +// validator->validateModel(model1); +// printIssues(validator); + +// EXPECT_EQ(size_t(1), validator->issueCount()); +// } diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 6fbe49166..76318855d 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -25,6 +25,8 @@ limitations under the License. * are not picked up by the main tests testing the API of the library */ +#if 0 + TEST(Validator, namedModel) { libcellml::ValidatorPtr validator = libcellml::Validator::create(); @@ -2458,3 +2460,19 @@ TEST(Validator, warningDimensionalExponentsCnInMathml) EXPECT_EQ(size_t(0), validator->errorCount()); EXPECT_EQ(size_t(1), validator->warningCount()); } +#endif + +TEST(Validator, warningCircularImportReferences) +{ + auto parser = libcellml::Parser::create(); + auto validator = libcellml::Validator::create(); + auto model1 = parser->parseModel(fileContents("circularimports/circularImport_1.cellml")); + + model1->resolveImports(resourcePath("circularimports/")); + model1->flatten(); + + validator->validateModel(model1); + printIssues(validator); + + EXPECT_EQ(size_t(1), validator->issueCount()); +} From ba1f2a1711f13132d892eb2e78890926559e9769 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 22 Jan 2020 17:23:34 +0100 Subject: [PATCH 29/88] undoing tests --- src/model.cpp | 3 +- tests/validator/validator.cpp | 131 ---------------------------------- 2 files changed, 2 insertions(+), 132 deletions(-) diff --git a/src/model.cpp b/src/model.cpp index 5f44ba099..ed689ebc3 100644 --- a/src/model.cpp +++ b/src/model.cpp @@ -356,7 +356,8 @@ bool resolveImport(const ImportedEntityPtr &importedEntity, void resolveComponentImports(const ComponentEntityPtr &parentComponentEntity, const std::string &baseFile, - std::vector &history) + std::vector &history, + ) { for (size_t n = 0; n < parentComponentEntity->componentCount(); ++n) { libcellml::ComponentPtr component = parentComponentEntity->component(n); diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 76318855d..f12c81067 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -2345,134 +2345,3 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) EXPECT_EQ_ERRORS(expectedErrors, v); } - -TEST(Validator, warningMismatchedMultipliersInUnits) -{ - // If two units are linked through variable equivalence mapping and their - // scaling factor is not the same, it should raise a warning-level issue - std::vector expectedIssues = { - "Variable 'v1' has units of 'megametre' and an equivalent variable 'v2' with non-matching units of 'millimetre'. The mismatch is: multiplication factor of 10^9."}; - - auto model = libcellml::Model::create("Gulliver"); - auto c1 = libcellml::Component::create("Brobdingnag"); - auto c2 = libcellml::Component::create("Lilliput"); - auto v1 = libcellml::Variable::create("v1"); - auto v2 = libcellml::Variable::create("v2"); - - auto u1 = libcellml::Units::create("megametre"); - u1->addUnit("metre", "mega"); - - auto u2 = libcellml::Units::create("millimetre"); - u2->addUnit("metre", "milli"); - - v1->setUnits(u1); - v2->setUnits(u2); - c1->addVariable(v1); - c2->addVariable(v2); - model->addComponent(c1); - model->addComponent(c2); - model->addUnits(u1); - model->addUnits(u2); - - libcellml::Variable::addEquivalence(v1, v2); - - auto validator = libcellml::Validator::create(); - validator->validateModel(model); - - EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); - EXPECT_EQ(size_t(0), validator->hintCount()); - EXPECT_EQ(size_t(1), validator->issueCount()); - - EXPECT_EQ_ISSUES(expectedIssues, validator); -} - -TEST(Validator, warningDimensionalExponentsCiInMathml) -{ - auto validator = libcellml::Validator::create(); - auto model = libcellml::Model::create("model"); - auto component = libcellml::Component::create("component"); - model->addComponent(component); - - auto rhs = libcellml::Variable::create("rhs"); - rhs->setUnits("dimensionless"); - component->addVariable(rhs); - - auto base = libcellml::Variable::create("base"); - base->setUnits("dimensionless"); - component->addVariable(base); - - auto exponent = libcellml::Variable::create("exponent"); - exponent->setUnits("metre"); - component->addVariable(exponent); - - std::string mathHeader = "\n"; - std::string mathFooter = ""; - std::string maths = - " \n" - " rhs\n" - " \n" - " base\n" - " exponent\n" - " \n" - " \n"; - component->setMath(mathHeader); - component->appendMath(maths); - component->appendMath(mathFooter); - - validator->validateModel(model); - - EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); -} - -TEST(Validator, warningDimensionalExponentsCnInMathml) -{ - auto validator = libcellml::Validator::create(); - auto model = libcellml::Model::create("model"); - auto component = libcellml::Component::create("component"); - model->addComponent(component); - - auto rhs = libcellml::Variable::create("rhs"); - rhs->setUnits("dimensionless"); - component->addVariable(rhs); - - auto base = libcellml::Variable::create("base"); - base->setUnits("dimensionless"); - component->addVariable(base); - - std::string mathHeader = "\n"; - std::string mathFooter = ""; - std::string maths = - " \n" - " rhs\n" - " \n" - " base\n" - " 2\n" - " \n" - " \n"; - component->setMath(mathHeader); - component->appendMath(maths); - component->appendMath(mathFooter); - - validator->validateModel(model); - - EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); -} -#endif - -TEST(Validator, warningCircularImportReferences) -{ - auto parser = libcellml::Parser::create(); - auto validator = libcellml::Validator::create(); - auto model1 = parser->parseModel(fileContents("circularimports/circularImport_1.cellml")); - - model1->resolveImports(resourcePath("circularimports/")); - model1->flatten(); - - validator->validateModel(model1); - printIssues(validator); - - EXPECT_EQ(size_t(1), validator->issueCount()); -} From 5a3f06f43880f20cd223d0e158ba71102957313b Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 22 Jan 2020 17:32:53 +0100 Subject: [PATCH 30/88] Revert "undoing tests" This reverts commit ba1f2a1711f13132d892eb2e78890926559e9769. --- src/model.cpp | 3 +- tests/validator/validator.cpp | 131 ++++++++++++++++++++++++++++++++++ 2 files changed, 132 insertions(+), 2 deletions(-) diff --git a/src/model.cpp b/src/model.cpp index ed689ebc3..5f44ba099 100644 --- a/src/model.cpp +++ b/src/model.cpp @@ -356,8 +356,7 @@ bool resolveImport(const ImportedEntityPtr &importedEntity, void resolveComponentImports(const ComponentEntityPtr &parentComponentEntity, const std::string &baseFile, - std::vector &history, - ) + std::vector &history) { for (size_t n = 0; n < parentComponentEntity->componentCount(); ++n) { libcellml::ComponentPtr component = parentComponentEntity->component(n); diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index f12c81067..76318855d 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -2345,3 +2345,134 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) EXPECT_EQ_ERRORS(expectedErrors, v); } + +TEST(Validator, warningMismatchedMultipliersInUnits) +{ + // If two units are linked through variable equivalence mapping and their + // scaling factor is not the same, it should raise a warning-level issue + std::vector expectedIssues = { + "Variable 'v1' has units of 'megametre' and an equivalent variable 'v2' with non-matching units of 'millimetre'. The mismatch is: multiplication factor of 10^9."}; + + auto model = libcellml::Model::create("Gulliver"); + auto c1 = libcellml::Component::create("Brobdingnag"); + auto c2 = libcellml::Component::create("Lilliput"); + auto v1 = libcellml::Variable::create("v1"); + auto v2 = libcellml::Variable::create("v2"); + + auto u1 = libcellml::Units::create("megametre"); + u1->addUnit("metre", "mega"); + + auto u2 = libcellml::Units::create("millimetre"); + u2->addUnit("metre", "milli"); + + v1->setUnits(u1); + v2->setUnits(u2); + c1->addVariable(v1); + c2->addVariable(v2); + model->addComponent(c1); + model->addComponent(c2); + model->addUnits(u1); + model->addUnits(u2); + + libcellml::Variable::addEquivalence(v1, v2); + + auto validator = libcellml::Validator::create(); + validator->validateModel(model); + + EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); + EXPECT_EQ(size_t(0), validator->hintCount()); + EXPECT_EQ(size_t(1), validator->issueCount()); + + EXPECT_EQ_ISSUES(expectedIssues, validator); +} + +TEST(Validator, warningDimensionalExponentsCiInMathml) +{ + auto validator = libcellml::Validator::create(); + auto model = libcellml::Model::create("model"); + auto component = libcellml::Component::create("component"); + model->addComponent(component); + + auto rhs = libcellml::Variable::create("rhs"); + rhs->setUnits("dimensionless"); + component->addVariable(rhs); + + auto base = libcellml::Variable::create("base"); + base->setUnits("dimensionless"); + component->addVariable(base); + + auto exponent = libcellml::Variable::create("exponent"); + exponent->setUnits("metre"); + component->addVariable(exponent); + + std::string mathHeader = "\n"; + std::string mathFooter = ""; + std::string maths = + " \n" + " rhs\n" + " \n" + " base\n" + " exponent\n" + " \n" + " \n"; + component->setMath(mathHeader); + component->appendMath(maths); + component->appendMath(mathFooter); + + validator->validateModel(model); + + EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); +} + +TEST(Validator, warningDimensionalExponentsCnInMathml) +{ + auto validator = libcellml::Validator::create(); + auto model = libcellml::Model::create("model"); + auto component = libcellml::Component::create("component"); + model->addComponent(component); + + auto rhs = libcellml::Variable::create("rhs"); + rhs->setUnits("dimensionless"); + component->addVariable(rhs); + + auto base = libcellml::Variable::create("base"); + base->setUnits("dimensionless"); + component->addVariable(base); + + std::string mathHeader = "\n"; + std::string mathFooter = ""; + std::string maths = + " \n" + " rhs\n" + " \n" + " base\n" + " 2\n" + " \n" + " \n"; + component->setMath(mathHeader); + component->appendMath(maths); + component->appendMath(mathFooter); + + validator->validateModel(model); + + EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); +} +#endif + +TEST(Validator, warningCircularImportReferences) +{ + auto parser = libcellml::Parser::create(); + auto validator = libcellml::Validator::create(); + auto model1 = parser->parseModel(fileContents("circularimports/circularImport_1.cellml")); + + model1->resolveImports(resourcePath("circularimports/")); + model1->flatten(); + + validator->validateModel(model1); + printIssues(validator); + + EXPECT_EQ(size_t(1), validator->issueCount()); +} From f73107a4c1123eb19f49e2755ee3124885493937 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 22 Jan 2020 17:33:02 +0100 Subject: [PATCH 31/88] Revert "working towards cyclic import warning" This reverts commit 5a3d5a8a4c63ce1ff99c6748f0584eb2f2c693b8. --- src/api/libcellml/model.h | 11 ---- src/model.cpp | 56 +++-------------- src/validator.cpp | 86 --------------------------- tests/resolve_imports/file_parser.cpp | 21 +++---- tests/validator/validator.cpp | 18 ------ 5 files changed, 17 insertions(+), 175 deletions(-) diff --git a/src/api/libcellml/model.h b/src/api/libcellml/model.h index 29363ce41..1a8396edc 100644 --- a/src/api/libcellml/model.h +++ b/src/api/libcellml/model.h @@ -306,17 +306,6 @@ class LIBCELLML_EXPORT Model: public ComponentEntity */ void resolveImports(const std::string &baseFile); - /** - * @brief Resolve all imports in this model. - * - * Resolve all @c Component and @c Units imports by loading the models - * from local disk through relative URLs. The @p baseFile is used to determine - * the full path to the source model relative to this one. - * - * @param baseFile The @c std::string location on local disk of the source @c Model. - */ - void resolveImports(const std::string &baseFile, std::vector &history); - /** * @brief Test if this model has unresolved imports. * diff --git a/src/model.cpp b/src/model.cpp index 5f44ba099..dcab5b420 100644 --- a/src/model.cpp +++ b/src/model.cpp @@ -24,8 +24,6 @@ limitations under the License. #include #include -#include // KRM - #include "libcellml/component.h" #include "libcellml/importsource.h" #include "libcellml/parser.h" @@ -316,29 +314,11 @@ std::string resolvePath(const std::string &filename, const std::string &base) return path; } -bool resolveImport(const ImportedEntityPtr &importedEntity, - const std::string &baseFile, - std::vector &history, - bool &cycleFound) +void resolveImport(const ImportedEntityPtr &importedEntity, + const std::string &baseFile) { - if (importedEntity->isImport()) { ImportSourcePtr importSource = importedEntity->importSource(); - - // history.push_back(importedEntity->importReference()); - - for (auto &h : history) { - std::cout << h << ", "; - } - std::cout << std::endl; - - if (std::find(history.begin(), history.end(), importedEntity->importReference()) != history.end()) { - // Element in vector. - std::cout << "Found it!" << std::endl; - cycleFound = true; - return; - } - if (!importSource->hasModel()) { std::string url = resolvePath(importSource->url(), baseFile); std::ifstream file(url); @@ -348,52 +328,32 @@ bool resolveImport(const ImportedEntityPtr &importedEntity, ParserPtr parser = Parser::create(); ModelPtr model = parser->parseModel(buffer.str()); importSource->setModel(model); - model->resolveImports(url, history); + model->resolveImports(url); } } } } void resolveComponentImports(const ComponentEntityPtr &parentComponentEntity, - const std::string &baseFile, - std::vector &history) + const std::string &baseFile) { for (size_t n = 0; n < parentComponentEntity->componentCount(); ++n) { libcellml::ComponentPtr component = parentComponentEntity->component(n); - history.push_back(component->name()); - - std::cout << component->name() << std::endl; - if (component->isImport()) { - resolveImport(component, baseFile, history, cycleFound); + resolveImport(component, baseFile); } else { - resolveComponentImports(component, baseFile, history); + resolveComponentImports(component, baseFile); } } } -void Model::resolveImports(const std::string &baseFile, std::vector &history, bool &cycleFound) -{ - for (size_t n = 0; n < unitsCount(); ++n) { - libcellml::UnitsPtr units = Model::units(n); - resolveImport(units, baseFile, history, cycleFound); - } - - // history.push_back(u->name()); - resolveComponentImports(shared_from_this(), baseFile, history); -} - void Model::resolveImports(const std::string &baseFile) { - bool cycleFound = false; - std::vector history = {}; for (size_t n = 0; n < unitsCount(); ++n) { libcellml::UnitsPtr units = Model::units(n); - resolveImport(units, baseFile, history, cycleFound); + resolveImport(units, baseFile); } - - // history.push_back(u->name()); - resolveComponentImports(shared_from_this(), baseFile, history); + resolveComponentImports(shared_from_this(), baseFile); } bool isUnresolvedImport(const ImportedEntityPtr &importedEntity) diff --git a/src/validator.cpp b/src/validator.cpp index 98b223942..700ecd9f3 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -258,11 +258,6 @@ struct Validator::ValidatorImpl void checkUnitForCycles(const ModelPtr &model, const UnitsPtr &parent, std::vector &history, std::vector> &errorList); - - void checkNoImportsAreCyclic(const ModelPtr &model); - void checkImportsForCycles(const ModelPtr &model, const UnitsPtr &parent, - std::vector &history, - std::vector> &errorList); }; Validator::Validator() @@ -1259,85 +1254,4 @@ void Validator::ValidatorImpl::checkUnitForCycles(const ModelPtr &model, const U } } -void Validator::ValidatorImpl::checkNoImportsAreCyclic(const ModelPtr &model) -{ - std::vector history; - std::vector> errorList; - - for (size_t i = 0; i < model->unitsCount(); ++i) { - // Test each units' dependencies for presence of self in tree. - UnitsPtr u = model->units(i); - history.push_back(u->name()); - checkImportsForCycles(model, u, history, errorList); - // Have to delete this each time to prevent reinitialisation with previous base variables. - std::vector().swap(history); - } - - if (!errorList.empty()) { - std::vector> reportedErrorList; - for (auto &issues : errorList) { - std::map hash; - - for (auto &e : issues) { - hash.insert(std::pair(e, true)); - } - - // Only return as issue if this combo has not been reported already. - if (std::find(reportedErrorList.begin(), reportedErrorList.end(), hash) == reportedErrorList.end()) { - IssuePtr err = Issue::create(); - std::string des = "'"; - for (size_t j = 0; j < issues.size() - 1; ++j) { - des += issues[j] + "' -> '"; - } - des += issues[issues.size() - 1] + "'"; - err->setDescription("Cyclic units exist: " + des); - err->setModel(model); - err->setCause(Issue::Cause::UNITS); - mValidator->addIssue(err); - reportedErrorList.push_back(hash); - } - std::map().swap(hash); - } - } -} - -void Validator::ValidatorImpl::checkImportsForCycles(const ModelPtr &model, const UnitsPtr &parent, - std::vector &history, - std::vector> &errorList) -{ - if (parent->isBaseUnit()) { - return; - } - - // Recursive function to check for self-referencing in unit definitions. - std::string id; - std::string ref; - std::string prefix; - double exp; - double mult; - - // Take history, and copy it for each new branch. - for (size_t i = 0; i < parent->unitCount(); ++i) { - parent->unitAttributes(i, ref, prefix, exp, mult, id); - if (std::find(history.begin(), history.end(), ref) != history.end()) { - history.push_back(ref); - // Print to error output *only* when the first and last units are the same - // otherwise we get lasso shapes reported. - if (history.front() == history.back()) { - errorList.push_back(history); - } - } else { - // Step into dependencies if they are not built-in units. - if (model->hasUnits(ref)) { - UnitsPtr child = model->units(ref); - history.push_back(ref); - // Making a copy of the history vector to this point. - std::vector child_history(history); - checkImportsForCycles(model, child, child_history, errorList); - std::vector().swap(child_history); - } - } - } -} - } // namespace libcellml diff --git a/tests/resolve_imports/file_parser.cpp b/tests/resolve_imports/file_parser.cpp index 41685013c..e38b539aa 100644 --- a/tests/resolve_imports/file_parser.cpp +++ b/tests/resolve_imports/file_parser.cpp @@ -121,16 +121,13 @@ TEST(ResolveImports, componentNotInResolvingModel) // *** KRM Adding tests for warning-type issues here -// TEST(ResolveImports, warningCircularImportReferences) -// { -// auto parser = libcellml::Parser::create(); -// auto validator = libcellml::Validator::create(); -// auto model1 = parser->parseModel(fileContents("circularimports/circularImport_1.cellml")); - -// model1->resolveImports(resourcePath("circularimports/")); - -// validator->validateModel(model1); -// printIssues(validator); +TEST(ResolveImports, warningCircularImportReferences) +{ + auto parser = libcellml::Parser::create(); + auto validator = libcellml::Validator::create(); + auto model1 = parser->parseModel(fileContents("circularimports/circularImport_1.cellml")); + validator->validateModel(model1); + printIssues(validator); -// EXPECT_EQ(size_t(1), validator->issueCount()); -// } + EXPECT_EQ(size_t(1), validator->issueCount()); +} diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 76318855d..6fbe49166 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -25,8 +25,6 @@ limitations under the License. * are not picked up by the main tests testing the API of the library */ -#if 0 - TEST(Validator, namedModel) { libcellml::ValidatorPtr validator = libcellml::Validator::create(); @@ -2460,19 +2458,3 @@ TEST(Validator, warningDimensionalExponentsCnInMathml) EXPECT_EQ(size_t(0), validator->errorCount()); EXPECT_EQ(size_t(1), validator->warningCount()); } -#endif - -TEST(Validator, warningCircularImportReferences) -{ - auto parser = libcellml::Parser::create(); - auto validator = libcellml::Validator::create(); - auto model1 = parser->parseModel(fileContents("circularimports/circularImport_1.cellml")); - - model1->resolveImports(resourcePath("circularimports/")); - model1->flatten(); - - validator->validateModel(model1); - printIssues(validator); - - EXPECT_EQ(size_t(1), validator->issueCount()); -} From 5a97a353053a34a4f58368ecc3037c4e66985b7e Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 22 Jan 2020 17:33:08 +0100 Subject: [PATCH 32/88] Revert "Added tests and files for circular import checking" This reverts commit 7d8eed691c8a62f721511d5787853d20ad24b779. --- tests/resolve_imports/file_parser.cpp | 13 ------------- .../circularimports/circularImport_1.cellml | 8 -------- .../circularimports/circularImport_2.cellml | 8 -------- .../circularimports/circularImport_3.cellml | 8 -------- tests/validator/validator.cpp | 6 ++++++ 5 files changed, 6 insertions(+), 37 deletions(-) delete mode 100644 tests/resources/circularimports/circularImport_1.cellml delete mode 100644 tests/resources/circularimports/circularImport_2.cellml delete mode 100644 tests/resources/circularimports/circularImport_3.cellml diff --git a/tests/resolve_imports/file_parser.cpp b/tests/resolve_imports/file_parser.cpp index e38b539aa..475e20e5c 100644 --- a/tests/resolve_imports/file_parser.cpp +++ b/tests/resolve_imports/file_parser.cpp @@ -118,16 +118,3 @@ TEST(ResolveImports, componentNotInResolvingModel) model->resolveImports(resourcePath()); EXPECT_TRUE(model->hasUnresolvedImports()); } - -// *** KRM Adding tests for warning-type issues here - -TEST(ResolveImports, warningCircularImportReferences) -{ - auto parser = libcellml::Parser::create(); - auto validator = libcellml::Validator::create(); - auto model1 = parser->parseModel(fileContents("circularimports/circularImport_1.cellml")); - validator->validateModel(model1); - printIssues(validator); - - EXPECT_EQ(size_t(1), validator->issueCount()); -} diff --git a/tests/resources/circularimports/circularImport_1.cellml b/tests/resources/circularimports/circularImport_1.cellml deleted file mode 100644 index 20b757b73..000000000 --- a/tests/resources/circularimports/circularImport_1.cellml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - diff --git a/tests/resources/circularimports/circularImport_2.cellml b/tests/resources/circularimports/circularImport_2.cellml deleted file mode 100644 index 8c79dbcb1..000000000 --- a/tests/resources/circularimports/circularImport_2.cellml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - diff --git a/tests/resources/circularimports/circularImport_3.cellml b/tests/resources/circularimports/circularImport_3.cellml deleted file mode 100644 index df9caf0e2..000000000 --- a/tests/resources/circularimports/circularImport_3.cellml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 6fbe49166..afb0f418e 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -2344,6 +2344,12 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) EXPECT_EQ_ERRORS(expectedErrors, v); } +/** + * + * ISSUE WARNINGS TESTING FROM HERE DOWN + * + * ==========================================================================*/ + TEST(Validator, warningMismatchedMultipliersInUnits) { // If two units are linked through variable equivalence mapping and their From 7183e371b9e60da11e62414cef76803e17445d86 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 22 Jan 2020 17:33:18 +0100 Subject: [PATCH 33/88] Revert "Add tests for warnings from dimensional exponents in maths: expect failure" This reverts commit a94dfc0669e5684a25ab3a2d7c7f0cbf84b72fb6. --- tests/validator/validator.cpp | 76 +---------------------------------- 1 file changed, 1 insertion(+), 75 deletions(-) diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index afb0f418e..916fce6b6 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -2350,7 +2350,7 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) * * ==========================================================================*/ -TEST(Validator, warningMismatchedMultipliersInUnits) +TEST(Validator, mismatchedMultipliersInUnits) { // If two units are linked through variable equivalence mapping and their // scaling factor is not the same, it should raise a warning-level issue @@ -2390,77 +2390,3 @@ TEST(Validator, warningMismatchedMultipliersInUnits) EXPECT_EQ_ISSUES(expectedIssues, validator); } - -TEST(Validator, warningDimensionalExponentsCiInMathml) -{ - auto validator = libcellml::Validator::create(); - auto model = libcellml::Model::create("model"); - auto component = libcellml::Component::create("component"); - model->addComponent(component); - - auto rhs = libcellml::Variable::create("rhs"); - rhs->setUnits("dimensionless"); - component->addVariable(rhs); - - auto base = libcellml::Variable::create("base"); - base->setUnits("dimensionless"); - component->addVariable(base); - - auto exponent = libcellml::Variable::create("exponent"); - exponent->setUnits("metre"); - component->addVariable(exponent); - - std::string mathHeader = "\n"; - std::string mathFooter = ""; - std::string maths = - " \n" - " rhs\n" - " \n" - " base\n" - " exponent\n" - " \n" - " \n"; - component->setMath(mathHeader); - component->appendMath(maths); - component->appendMath(mathFooter); - - validator->validateModel(model); - - EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); -} - -TEST(Validator, warningDimensionalExponentsCnInMathml) -{ - auto validator = libcellml::Validator::create(); - auto model = libcellml::Model::create("model"); - auto component = libcellml::Component::create("component"); - model->addComponent(component); - - auto rhs = libcellml::Variable::create("rhs"); - rhs->setUnits("dimensionless"); - component->addVariable(rhs); - - auto base = libcellml::Variable::create("base"); - base->setUnits("dimensionless"); - component->addVariable(base); - - std::string mathHeader = "\n"; - std::string mathFooter = ""; - std::string maths = - " \n" - " rhs\n" - " \n" - " base\n" - " 2\n" - " \n" - " \n"; - component->setMath(mathHeader); - component->appendMath(maths); - component->appendMath(mathFooter); - - validator->validateModel(model); - - EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); -} From dcf51dfecbcca38575307e78a0a6fcfcca087d65 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 23 Jan 2020 11:11:46 +1300 Subject: [PATCH 34/88] A lot of minor cleaning up. --- src/api/libcellml/logger.h | 22 +- src/bindings/interface/issue.i | 6 +- src/bindings/interface/logger.i | 18 +- src/generator.cpp | 116 ++-- src/issue.cpp | 2 +- src/logger.cpp | 47 +- src/parser.cpp | 676 ++++++++++++------------ src/validator.cpp | 490 ++++++++--------- tests/bindings/python/test_error.py | 2 +- tests/bindings/python/test_generator.py | 8 +- tests/bindings/python/test_parser.py | 8 +- tests/bindings/python/test_printer.py | 8 +- tests/bindings/python/test_validator.py | 8 +- tests/clone/clone.cpp | 2 +- tests/component/encapsulation.cpp | 6 +- tests/connection/connection.cpp | 12 +- tests/coverage/coverage.cpp | 4 +- tests/generator/generator.cpp | 154 +++--- tests/isolated/generator.cpp | 4 +- tests/issue/issue.cpp | 12 +- tests/logger/logger.cpp | 30 +- tests/parser/file_parser.cpp | 16 +- tests/parser/libxml_user.cpp | 2 +- tests/parser/parser.cpp | 352 ++++++------ tests/printer/printer.cpp | 2 +- tests/resolve_imports/file_parser.cpp | 14 +- tests/test_utils.cpp | 32 +- tests/test_utils.h | 18 +- tests/units/units.cpp | 4 +- tests/validator/validator.cpp | 218 ++++---- tests/variable/variable.cpp | 2 +- 31 files changed, 1134 insertions(+), 1161 deletions(-) diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index cb82ae4cb..ea71be432 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -21,7 +21,6 @@ limitations under the License. #include "libcellml/types.h" #include -#include namespace libcellml { @@ -55,7 +54,7 @@ class LIBCELLML_EXPORT Logger void addIssue(const IssuePtr &issue); /** - * @brief Get the number of issues + * @brief Get the number of issues. * * Return the number of issues of any level currently stored in the logger. * @@ -79,7 +78,7 @@ class LIBCELLML_EXPORT Logger /** * @brief Get issue of specified @p level at the specified @p index. * - * Returns an issue at the @p index. If the @p index + * Returns an issue at the @p index of specified @p level. If the @p index * is not valid a @c nullptr is returned, the valid range for the @p index * is [0, \#issues_of_level). * @@ -91,6 +90,19 @@ class LIBCELLML_EXPORT Logger */ IssuePtr issue(size_t index, libcellml::Issue::Level level) const; + /** + * @brief Get issue of one of the specified @p levels at the specified @p index. + * + * Returns an issue at the @p index of one of the specified @p levels. If the @p index + * is not valid a @c nullptr is returned, the valid range for the @p index + * is [0, \#issues_of_levels). + * + * @param index The index of the issue to return. + * @param levels The levels of issue to return. + * + * @return A reference to the issue from the list of issues at one of the given levels, + * at the given index on success, @c nullptr otherwise. + */ IssuePtr issue(size_t index, std::vector &levels) const; /** @@ -127,7 +139,7 @@ class LIBCELLML_EXPORT Logger /** * @brief Get issue of level WARNING at the specified @p index. * - * Returns an warning at the @p index. If the @p index + * Returns a warning at the @p index. If the @p index * is not valid a @c nullptr is returned, the valid range for the @p index * is [0, \#warnings). * @@ -149,7 +161,7 @@ class LIBCELLML_EXPORT Logger /** * @brief Get issue of level HINT at the specified @p index. * - * Returns an error at the @p index. If the @p index + * Returns a hint at the @p index. If the @p index * is not valid a @c nullptr is returned, the valid range for the @p index * is [0, \#hints). * diff --git a/src/bindings/interface/issue.i b/src/bindings/interface/issue.i index 50b71c440..4e9f67f83 100644 --- a/src/bindings/interface/issue.i +++ b/src/bindings/interface/issue.i @@ -8,7 +8,7 @@ %import "types.i" %feature("docstring") libcellml::Issue -"Base class for errors used with logger derived classes." +"Base class for issues used with logger derived classes." %feature("docstring") libcellml::Issue::description "Get a string description for why this issue was raised."; @@ -27,8 +27,8 @@ return Cause::UNDEFINED."; "Sets the ``cause`` of this issue."; %feature("docstring") libcellml::Issue::level -"Get the ``level`` of this issue. If no level has been set for this issue, will -return Level::ERROR."; +"Get the ``level`` of this issue. If no level has been set for this issue, +Level::ERROR will be returned."; %feature("docstring") libcellml::Issue::isLevel "Tests if this issue matches the given ``level``."; diff --git a/src/bindings/interface/logger.i b/src/bindings/interface/logger.i index 2031742b9..a17af8436 100644 --- a/src/bindings/interface/logger.i +++ b/src/bindings/interface/logger.i @@ -14,35 +14,35 @@ "Adds an issue to this logger."; %feature("docstring") libcellml::Logger::issue -"Returns the issue of any level at the specified 'index'."; +"Returns the issue of any level at the specified ``index``."; %feature("docstring") libcellml::Logger::issueCount "Returns the number of issues currently stored in the logger."; %feature("docstring") libcellml::Logger::error -"Returns the issue of level 'error' at the specified 'index'."; +"Returns the issue of level ERROR at the specified ``index``."; %feature("docstring") libcellml::Logger::errorCount -"Returns the number of issues of level 'error' currently stored in the logger."; +"Returns the number of issues of level ERROR currently stored in the logger."; %feature("docstring") libcellml::Logger::warning -"Returns the issue of level 'warning' at the specified 'index'."; +"Returns the issue of level WARNING at the specified ``index``."; %feature("docstring") libcellml::Logger::warningCount -"Returns the number of issues of level 'warning' currently stored in the logger."; +"Returns the number of issues of level WARNING currently stored in the logger."; %feature("docstring") libcellml::Logger::hint -"Returns the issue of level 'hint' at the specified 'index'."; +"Returns the issue of level HINT at the specified ``index``."; %feature("docstring") libcellml::Logger::hintCount -"Returns the number of issues of level 'hint' currently stored in the logger."; +"Returns the number of issues of level HINT currently stored in the logger."; #if defined(SWIGPYTHON) // Treat negative size_t as invalid index (instead of unknown method) %extend libcellml::Logger { - IssuePtr error(long index) { + IssuePtr issue(long index) { if (index < 0) return nullptr; - return $self->error(size_t(index)); + return $self->issue(size_t(index)); } } #endif diff --git a/src/generator.cpp b/src/generator.cpp index 71e667c91..2acb4275b 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1048,15 +1048,15 @@ void Generator::GeneratorImpl::processNode(const XmlNodePtr &node, } } else { std::string modelName = entityName(owningModel(component)); - IssuePtr err = Issue::create(); + IssuePtr issue = Issue::create(); - err->setDescription("Variable '" + variableName - + "' in component '" + component->name() - + "' of model '" + modelName - + "' is referenced in an equation, but it is not defined anywhere."); - err->setCause(Issue::Cause::GENERATOR); + issue->setDescription("Variable '" + variableName + + "' in component '" + component->name() + + "' of model '" + modelName + + "' is referenced in an equation, but it is not defined anywhere."); + issue->setCause(Issue::Cause::GENERATOR); - mGenerator->addIssue(err); + mGenerator->addIssue(issue); } } else if (node->isMathmlElement("cn")) { if (mathmlChildCount(node) == 1) { @@ -1164,18 +1164,18 @@ void Generator::GeneratorImpl::processComponent(const ComponentPtr &component) ModelPtr model = owningModel(component); ComponentPtr trackedVariableComponent = std::dynamic_pointer_cast(generatorVariable->mVariable->parent()); ModelPtr trackedVariableModel = owningModel(trackedVariableComponent); - IssuePtr err = Issue::create(); + IssuePtr issue = Issue::create(); - err->setDescription("Variable '" + variable->name() - + "' in component '" + component->name() - + "' of model '" + model->name() - + "' and variable '" + generatorVariable->mVariable->name() - + "' in component '" + trackedVariableComponent->name() - + "' of model '" + trackedVariableModel->name() - + "' are equivalent and cannot therefore both be initialised."); - err->setCause(Issue::Cause::GENERATOR); + issue->setDescription("Variable '" + variable->name() + + "' in component '" + component->name() + + "' of model '" + model->name() + + "' and variable '" + generatorVariable->mVariable->name() + + "' in component '" + trackedVariableComponent->name() + + "' of model '" + trackedVariableModel->name() + + "' are equivalent and cannot therefore both be initialised."); + issue->setCause(Issue::Cause::GENERATOR); - mGenerator->addIssue(err); + mGenerator->addIssue(issue); } } @@ -1214,15 +1214,15 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr if (!variable->initialValue().empty()) { ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); std::string modelName = entityName(owningModel(component)); - IssuePtr err = Issue::create(); + IssuePtr issue = Issue::create(); - err->setDescription("Variable '" + variable->name() - + "' in component '" + component->name() - + "' of model '" + modelName - + "' cannot be both a variable of integration and initialised."); - err->setCause(Issue::Cause::GENERATOR); + issue->setDescription("Variable '" + variable->name() + + "' in component '" + component->name() + + "' of model '" + modelName + + "' cannot be both a variable of integration and initialised."); + issue->setCause(Issue::Cause::GENERATOR); - mGenerator->addIssue(err); + mGenerator->addIssue(issue); } else { mVoi = variable; } @@ -1232,18 +1232,18 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr ModelPtr voiModel = owningModel(voiComponent); ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); ModelPtr model = owningModel(component); - IssuePtr err = Issue::create(); + IssuePtr issue = Issue::create(); - err->setDescription("Variable '" + mVoi->name() - + "' in component '" + voiComponent->name() - + "' of model '" + voiModel->name() - + "' and variable '" + variable->name() - + "' in component '" + component->name() - + "' of model '" + model->name() - + "' cannot both be a variable of integration."); - err->setCause(Issue::Cause::GENERATOR); + issue->setDescription("Variable '" + mVoi->name() + + "' in component '" + voiComponent->name() + + "' of model '" + voiModel->name() + + "' and variable '" + variable->name() + + "' in component '" + component->name() + + "' of model '" + model->name() + + "' cannot both be a variable of integration."); + issue->setCause(Issue::Cause::GENERATOR); - mGenerator->addIssue(err); + mGenerator->addIssue(issue); } } @@ -1257,15 +1257,15 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr VariablePtr variable = astGreatGrandParent->mRight->mVariable; ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); ModelPtr model = owningModel(component); - IssuePtr err = Issue::create(); + IssuePtr issue = Issue::create(); - err->setDescription("The differential equation for variable '" + variable->name() - + "' in component '" + component->name() - + "' of model '" + model->name() - + "' must be of the first order."); - err->setCause(Issue::Cause::GENERATOR); + issue->setDescription("The differential equation for variable '" + variable->name() + + "' in component '" + component->name() + + "' of model '" + model->name() + + "' must be of the first order."); + issue->setCause(Issue::Cause::GENERATOR); - mGenerator->addIssue(err); + mGenerator->addIssue(issue); } } @@ -1366,7 +1366,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) // Process our different equations' AST to determine the type of our // variables. - if (mGenerator->errorCount() == 0) { + if (mGenerator->issueCount() == 0) { for (const auto &equation : mEquations) { processEquationAst(equation->mAst); } @@ -1376,7 +1376,7 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) // then loop over our equations, checking which variables, if any, can be // determined using a given equation. - if (mGenerator->errorCount() == 0) { + if (mGenerator->issueCount() == 0) { mInternalVariables.sort(compareVariablesByName); size_t variableIndex = MAX_SIZE_T; @@ -1408,17 +1408,17 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) // Make sure that our variables are valid. - if (mGenerator->errorCount() == 0) { + if (mGenerator->issueCount() == 0) { for (const auto &internalVariable : mInternalVariables) { - std::string errorType; + std::string issueType; switch (internalVariable->mType) { case GeneratorInternalVariable::Type::UNKNOWN: - errorType = "is not computed"; + issueType = "is not computed"; break; case GeneratorInternalVariable::Type::SHOULD_BE_STATE: - errorType = "is used in an ODE, but it is not initialised"; + issueType = "is used in an ODE, but it is not initialised"; break; case GeneratorInternalVariable::Type::VARIABLE_OF_INTEGRATION: @@ -1429,23 +1429,23 @@ void Generator::GeneratorImpl::processModel(const ModelPtr &model) case GeneratorInternalVariable::Type::ALGEBRAIC: break; case GeneratorInternalVariable::Type::OVERCONSTRAINED: - errorType = "is computed more than once"; + issueType = "is computed more than once"; break; } - if (!errorType.empty()) { - IssuePtr err = Issue::create(); + if (!issueType.empty()) { + IssuePtr issue = Issue::create(); VariablePtr realVariable = internalVariable->mVariable; ComponentPtr realComponent = std::dynamic_pointer_cast(realVariable->parent()); ModelPtr realModel = owningModel(realComponent); - err->setDescription("Variable '" + realVariable->name() - + "' in component '" + realComponent->name() - + "' of model '" + realModel->name() + "' " + errorType + "."); - err->setCause(Issue::Cause::GENERATOR); + issue->setDescription("Variable '" + realVariable->name() + + "' in component '" + realComponent->name() + + "' of model '" + realModel->name() + "' " + issueType + "."); + issue->setCause(Issue::Cause::GENERATOR); - mGenerator->addIssue(err); + mGenerator->addIssue(issue); } } } @@ -3426,12 +3426,12 @@ void Generator::processModel(const ModelPtr &model) validator->validateModel(model); - if (validator->errorCount() > 0) { + if (validator->issueCount() > 0) { // The model is not valid, so retrieve the validation issues and make // them our own. - for (size_t i = 0; i < validator->errorCount(); ++i) { - addIssue(validator->error(i)); + for (size_t i = 0; i < validator->issueCount(); ++i) { + addIssue(validator->issue(i)); } return; diff --git a/src/issue.cpp b/src/issue.cpp index d1328595f..17f3fb0ba 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -270,7 +270,7 @@ ResetPtr Issue::reset() const } /** - * @brief Map SpecificationRules to their section titles. + * @brief Map ReferenceRules to their section titles. * * An internal map used to convert a ReferenceRule into its heading string. */ diff --git a/src/logger.cpp b/src/logger.cpp index c301ed45b..68ecfc2e1 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -55,11 +55,11 @@ size_t Logger::errorCount() const IssuePtr Logger::error(size_t index) const { - IssuePtr err = nullptr; + IssuePtr issue = nullptr; if ((index < mPimpl->mErrors.size()) && (mPimpl->mErrors.at(index) < mPimpl->mIssues.size())) { - err = mPimpl->mIssues.at(mPimpl->mErrors.at(index)); + issue = mPimpl->mIssues.at(mPimpl->mErrors.at(index)); } - return err; + return issue; } size_t Logger::warningCount() const @@ -69,11 +69,11 @@ size_t Logger::warningCount() const IssuePtr Logger::warning(size_t index) const { - IssuePtr err = nullptr; + IssuePtr issue = nullptr; if ((index < mPimpl->mWarnings.size()) && (mPimpl->mWarnings.at(index) < mPimpl->mIssues.size())) { - err = mPimpl->mIssues.at(mPimpl->mWarnings.at(index)); + issue = mPimpl->mIssues.at(mPimpl->mWarnings.at(index)); } - return err; + return issue; } size_t Logger::hintCount() const @@ -83,11 +83,11 @@ size_t Logger::hintCount() const IssuePtr Logger::hint(size_t index) const { - IssuePtr err = nullptr; + IssuePtr issue = nullptr; if ((index < mPimpl->mHints.size()) && (mPimpl->mHints.at(index) < mPimpl->mIssues.size())) { - err = mPimpl->mIssues.at(mPimpl->mHints.at(index)); + issue = mPimpl->mIssues.at(mPimpl->mHints.at(index)); } - return err; + return issue; } void Logger::removeAllIssues() @@ -106,29 +106,6 @@ void Logger::addIssue(const IssuePtr &issue) // Update the appropriate array based on its level libcellml::Issue::Level level = issue->level(); - // if (issue->isLevel(libcellml::Issue::Level::ERROR)) { - // mPimpl->mErrors.push_back(index); - // } - - // if (issue->isLevel(libcellml::Issue::Level::WARNING)) { - // mPimpl->mWarnings.push_back(index); - // } - - // if (issue->isLevel(libcellml::Issue::Level::HINT)) { - // mPimpl->mHints.push_back(index); - // } - // auto level = issue->level(); - - // if (level == libcellml::Issue::Level::ERROR){ - // mPimpl->mErrors.push_back(index); - // } - // else if (level == libcellml::Issue::Level::WARNING){ - // mPimpl->mWarnings.push_back(index); - // } - // else if (level == libcellml::Issue::Level::HINT){ - // mPimpl->mHints.push_back(index); - // } - switch (level) { case libcellml::Issue::Level::ERROR: mPimpl->mErrors.push_back(index); @@ -149,11 +126,11 @@ size_t Logger::issueCount() const IssuePtr Logger::issue(size_t index) const { - IssuePtr err = nullptr; + IssuePtr issue = nullptr; if (index < mPimpl->mIssues.size()) { - err = mPimpl->mIssues.at(index); + issue = mPimpl->mIssues.at(index); } - return err; + return issue; } IssuePtr Logger::issue(size_t index, libcellml::Issue::Level level) const diff --git a/src/parser.cpp b/src/parser.cpp index 130d54297..af1a0cf77 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -233,11 +233,11 @@ ModelPtr Parser::parseModel(const std::string &input) removeAllIssues(); ModelPtr model = Model::create(); if (input.empty()) { - IssuePtr err = Issue::create(); - err->setDescription("Model is empty."); - err->setCause(Issue::Cause::XML); - err->setModel(model); - addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Model is empty."); + issue->setCause(Issue::Cause::XML); + issue->setModel(model); + addIssue(issue); } else { mPimpl->updateModel(model, input); } @@ -256,34 +256,34 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp // Copy any XML parsing issues into the common parser issue handler. if (doc->xmlErrorCount() > 0) { for (size_t i = 0; i < doc->xmlErrorCount(); ++i) { - IssuePtr err = Issue::create(); - err->setDescription("LibXml2 error: " + doc->xmlError(i)); - err->setCause(Issue::Cause::XML); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("LibXml2 error: " + doc->xmlError(i)); + issue->setCause(Issue::Cause::XML); + mParser->addIssue(issue); } } const XmlNodePtr node = doc->rootNode(); if (!node) { - IssuePtr err = Issue::create(); - err->setDescription("Could not get a valid XML root node from the provided input."); - err->setCause(Issue::Cause::XML); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Could not get a valid XML root node from the provided input."); + issue->setCause(Issue::Cause::XML); + mParser->addIssue(issue); return; } if (!node->isCellmlElement("model")) { - IssuePtr err = Issue::create(); + IssuePtr issue = Issue::create(); if (node->name() == "model") { std::string nodeNamespace = node->namespaceUri(); if (nodeNamespace.empty()) { nodeNamespace = "null"; } - err->setDescription("Model element is in invalid namespace '" + nodeNamespace + "'. A valid CellML root node should be in namespace '" + CELLML_2_0_NS + "'."); + issue->setDescription("Model element is in invalid namespace '" + nodeNamespace + "'. A valid CellML root node should be in namespace '" + CELLML_2_0_NS + "'."); } else { - err->setDescription("Model element is of invalid type '" + node->name() + "'. A valid CellML root node should be of type 'model'."); + issue->setDescription("Model element is of invalid type '" + node->name() + "'. A valid CellML root node should be of type 'model'."); } - err->setModel(model); - err->setRule(ReferenceRule::MODEL_ELEMENT); - mParser->addIssue(err); + issue->setModel(model); + issue->setRule(ReferenceRule::MODEL_ELEMENT); + mParser->addIssue(issue); return; } // Get model attributes. @@ -294,10 +294,10 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp } else if (attribute->isType("id")) { model->setId(attribute->value()); } else { - IssuePtr err = Issue::create(); - err->setDescription("Model '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); - err->setModel(model); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Model '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); + issue->setModel(model); + mParser->addIssue(issue); } attribute = attribute->next(); } @@ -326,11 +326,11 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp if (childAttribute->isType("id")) { model->setEncapsulationId(childAttribute->value()); } else { - IssuePtr err = Issue::create(); - err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid attribute '" + childAttribute->name() + "'."); - err->setModel(model); - err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Encapsulation in model '" + model->name() + "' has an invalid attribute '" + childAttribute->name() + "'."); + issue->setModel(model); + issue->setCause(Issue::Cause::ENCAPSULATION); + mParser->addIssue(issue); } childAttribute = childAttribute->next(); } @@ -343,12 +343,12 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp encapsulationNodes.push_back(componentRefNode); } else { // TODO Should this be removed? - IssuePtr err = Issue::create(); - err->setDescription("Encapsulation in model '" + model->name() + "' does not contain any child elements."); - err->setModel(model); - err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(ReferenceRule::ENCAPSULATION_COMPONENT_REF); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Encapsulation in model '" + model->name() + "' does not contain any child elements."); + issue->setModel(model); + issue->setCause(Issue::Cause::ENCAPSULATION); + issue->setRule(ReferenceRule::ENCAPSULATION_COMPONENT_REF); + mParser->addIssue(issue); } } else if (childNode->isCellmlElement("connection")) { connectionNodes.push_back(childNode); @@ -356,20 +356,20 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); - err->setModel(model); - err->setRule(ReferenceRule::MODEL_CHILD); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); + issue->setModel(model); + issue->setRule(ReferenceRule::MODEL_CHILD); + mParser->addIssue(issue); } } else if (childNode->isComment()) { // Do nothing. } else { - IssuePtr err = Issue::create(); - err->setDescription("Model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); - err->setModel(model); - err->setRule(ReferenceRule::MODEL_CHILD); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); + issue->setModel(model); + issue->setRule(ReferenceRule::MODEL_CHILD); + mParser->addIssue(issue); } childNode = childNode->next(); } @@ -377,12 +377,12 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp if (!encapsulationNodes.empty()) { loadEncapsulation(model, encapsulationNodes.at(0)); if (encapsulationNodes.size() > 1) { - IssuePtr err = Issue::create(); - err->setDescription("Model '" + model->name() + "' has more than one encapsulation element."); - err->setModel(model); - err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Model '" + model->name() + "' has more than one encapsulation element."); + issue->setModel(model); + issue->setCause(Issue::Cause::ENCAPSULATION); + issue->setRule(ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); + mParser->addIssue(issue); } } for (const auto &connectionNode : connectionNodes) { @@ -490,10 +490,10 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN } else if (attribute->isType("id")) { component->setId(attribute->value()); } else { - IssuePtr err = Issue::create(); - err->setDescription("Component '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); - err->setComponent(component); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Component '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); + issue->setComponent(component); + mParser->addIssue(issue); } attribute = attribute->next(); } @@ -525,20 +525,20 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Component '" + component->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); - err->setComponent(component); - err->setRule(ReferenceRule::COMPONENT_CHILD); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Component '" + component->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); + issue->setComponent(component); + issue->setRule(ReferenceRule::COMPONENT_CHILD); + mParser->addIssue(issue); } } else if (childNode->isComment()) { // Do nothing. } else { - IssuePtr err = Issue::create(); - err->setDescription("Component '" + component->name() + "' has an invalid child element '" + childNode->name() + "'."); - err->setComponent(component); - err->setRule(ReferenceRule::COMPONENT_CHILD); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Component '" + component->name() + "' has an invalid child element '" + childNode->name() + "'."); + issue->setComponent(component); + issue->setRule(ReferenceRule::COMPONENT_CHILD); + mParser->addIssue(issue); } childNode = childNode->next(); } @@ -553,10 +553,10 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node } else if (attribute->isType("id")) { units->setId(attribute->value()); } else { - IssuePtr err = Issue::create(); - err->setDescription("Units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); - err->setUnits(units); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); + issue->setUnits(units); + mParser->addIssue(issue); } attribute = attribute->next(); } @@ -568,20 +568,20 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); - err->setUnits(units); - err->setRule(ReferenceRule::UNITS_CHILD); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); + issue->setUnits(units); + issue->setRule(ReferenceRule::UNITS_CHILD); + mParser->addIssue(issue); } } else if (childNode->isComment()) { // Do nothing. } else { - IssuePtr err = Issue::create(); - err->setDescription("Units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); - err->setUnits(units); - err->setRule(ReferenceRule::UNITS_CHILD); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); + issue->setUnits(units); + issue->setRule(ReferenceRule::UNITS_CHILD); + mParser->addIssue(issue); } childNode = childNode->next(); } @@ -601,18 +601,18 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); - err->setUnits(units); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); + issue->setUnits(units); + mParser->addIssue(issue); } } else if (childNode->isComment()) { // Do nothing. } else { - IssuePtr err = Issue::create(); - err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); - err->setUnits(units); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); + issue->setUnits(units); + mParser->addIssue(issue); } childNode = childNode->next(); } @@ -628,31 +628,31 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) exponent = convertToDouble(attribute->value()); } else { // TODO This value won't be saved for validation later, so it does need to be reported now - IssuePtr err = Issue::create(); - err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an exponent with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); - err->setUnits(units); - err->setRule(ReferenceRule::UNIT_EXPONENT); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an exponent with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); + issue->setUnits(units); + issue->setRule(ReferenceRule::UNIT_EXPONENT); + mParser->addIssue(issue); } } else if (attribute->isType("multiplier")) { if (isCellMLReal(attribute->value())) { multiplier = convertToDouble(attribute->value()); } else { // TODO his value won't be saved for validation later, so it does need to be reported now - IssuePtr err = Issue::create(); - err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has a multiplier with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); - err->setUnits(units); - err->setRule(ReferenceRule::UNIT_MULTIPLIER); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has a multiplier with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); + issue->setUnits(units); + issue->setRule(ReferenceRule::UNIT_MULTIPLIER); + mParser->addIssue(issue); } } else if (attribute->isType("id")) { id = attribute->value(); } else { - IssuePtr err = Issue::create(); - err->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); - err->setUnits(units); - err->setRule(ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); + issue->setUnits(units); + issue->setRule(ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); + mParser->addIssue(issue); } attribute = attribute->next(); } @@ -669,18 +669,18 @@ void Parser::ParserImpl::loadVariable(const VariablePtr &variable, const XmlNode std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Variable '" + node->attribute("name") + "' has an invalid non-whitespace child text element '" + textNode + "'."); - err->setVariable(variable); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable '" + node->attribute("name") + "' has an invalid non-whitespace child text element '" + textNode + "'."); + issue->setVariable(variable); + mParser->addIssue(issue); } } else if (childNode->isComment()) { // Do nothing. } else { - IssuePtr err = Issue::create(); - err->setDescription("Variable '" + node->attribute("name") + "' has an invalid child element '" + childNode->name() + "'."); - err->setVariable(variable); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable '" + node->attribute("name") + "' has an invalid child element '" + childNode->name() + "'."); + issue->setVariable(variable); + mParser->addIssue(issue); } childNode = childNode->next(); } @@ -697,10 +697,10 @@ void Parser::ParserImpl::loadVariable(const VariablePtr &variable, const XmlNode } else if (attribute->isType("initial_value")) { variable->setInitialValue(attribute->value()); } else { - IssuePtr err = Issue::create(); - err->setDescription("Variable '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); - err->setVariable(variable); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable '" + node->attribute("name") + "' has an invalid attribute '" + attribute->name() + "'."); + issue->setVariable(variable); + mParser->addIssue(issue); } attribute = attribute->next(); } @@ -736,31 +736,31 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr } else if (attribute->isType("id")) { connectionId = attribute->value(); } else { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' has an invalid connection attribute '" + attribute->name() + "'."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' has an invalid connection attribute '" + attribute->name() + "'."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + mParser->addIssue(issue); } attribute = attribute->next(); } // Check that we found both components. if (component1Name.empty()) { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' does not have a valid component_1 in a connection element."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - err->setRule(ReferenceRule::CONNECTION_COMPONENT1); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' does not have a valid component_1 in a connection element."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + issue->setRule(ReferenceRule::CONNECTION_COMPONENT1); + mParser->addIssue(issue); component1Missing = true; } if (component2Name.empty()) { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' does not have a valid component_2 in a connection element."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - err->setRule(ReferenceRule::CONNECTION_COMPONENT2); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' does not have a valid component_2 in a connection element."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + issue->setRule(ReferenceRule::CONNECTION_COMPONENT2); + mParser->addIssue(issue); component2Missing = true; } componentNamePair = std::make_pair(component1Name, component2Name); @@ -769,12 +769,12 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr if (!childNode) { // TODO Should this be removed too? - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' must contain one or more 'map_variables' elements."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - err->setRule(ReferenceRule::CONNECTION_MAP_VARIABLES); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' must contain one or more 'map_variables' elements."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + issue->setRule(ReferenceRule::CONNECTION_MAP_VARIABLES); + mParser->addIssue(issue); return; } @@ -787,20 +787,20 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr std::string textNode = grandchildNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + mParser->addIssue(issue); } } else if (grandchildNode->isComment()) { // Do nothing. } else { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' has an invalid child element '" + grandchildNode->name() + "' of element '" + childNode->name() + "'."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' has an invalid child element '" + grandchildNode->name() + "' of element '" + childNode->name() + "'."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + mParser->addIssue(issue); } grandchildNode = grandchildNode->next(); } @@ -817,31 +817,31 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr } else if (childAttribute->isType("id")) { mappingId = childAttribute->value(); } else { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' has an invalid map_variables attribute '" + childAttribute->name() + "'."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' has an invalid map_variables attribute '" + childAttribute->name() + "'."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + mParser->addIssue(issue); } childAttribute = childAttribute->next(); } // Check that we found both variables. if (variable1Name.empty()) { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_1 in a map_variables element."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - err->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_1 in a map_variables element."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + issue->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); + mParser->addIssue(issue); variable1Missing = true; } if (variable2Name.empty()) { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_2 in a map_variables element."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - err->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_2 in a map_variables element."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + issue->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); + mParser->addIssue(issue); variable2Missing = true; } // We can have multiple map_variables per connection. @@ -853,20 +853,20 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr const std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + mParser->addIssue(issue); } } else if (childNode->isComment()) { // Do nothing. } else { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + mParser->addIssue(issue); } childNode = childNode->next(); @@ -880,24 +880,24 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr component1 = model->component(componentNamePair.first); } else { if (!component1Missing) { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.first + "' as component_1 but it does not exist in the model."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - err->setRule(ReferenceRule::CONNECTION_COMPONENT1); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.first + "' as component_1 but it does not exist in the model."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + issue->setRule(ReferenceRule::CONNECTION_COMPONENT1); + mParser->addIssue(issue); } } if (model->containsComponent(componentNamePair.second)) { component2 = model->component(componentNamePair.second); } else { if (!component2Missing) { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.second + "' as component_2 but it does not exist in the model."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - err->setRule(ReferenceRule::CONNECTION_COMPONENT2); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.second + "' as component_2 but it does not exist in the model."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + issue->setRule(ReferenceRule::CONNECTION_COMPONENT2); + mParser->addIssue(issue); } } @@ -916,21 +916,21 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr component1->addVariable(variable1); } else { if (!variable1Missing) { - IssuePtr err = Issue::create(); - err->setDescription("Variable '" + iterPair.first + "' is specified as variable_1 in a connection but it does not exist in component_1 component '" + component1->name() + "' of model '" + model->name() + "'."); - err->setComponent(component1); - err->setCause(Issue::Cause::CONNECTION); - err->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable '" + iterPair.first + "' is specified as variable_1 in a connection but it does not exist in component_1 component '" + component1->name() + "' of model '" + model->name() + "'."); + issue->setComponent(component1); + issue->setCause(Issue::Cause::CONNECTION); + issue->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); + mParser->addIssue(issue); } } } else { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.first + "' as variable_1 but the corresponding component_1 is invalid."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - err->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.first + "' as variable_1 but the corresponding component_1 is invalid."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + issue->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); + mParser->addIssue(issue); } if (component2) { if (component2->hasVariable(iterPair.second)) { @@ -942,21 +942,21 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr component2->addVariable(variable2); } else { if (!variable2Missing) { - IssuePtr err = Issue::create(); - err->setDescription("Variable '" + iterPair.second + "' is specified as variable_2 in a connection but it does not exist in component_2 component '" + component2->name() + "' of model '" + model->name() + "'."); - err->setComponent(component1); - err->setCause(Issue::Cause::CONNECTION); - err->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable '" + iterPair.second + "' is specified as variable_2 in a connection but it does not exist in component_2 component '" + component2->name() + "' of model '" + model->name() + "'."); + issue->setComponent(component1); + issue->setCause(Issue::Cause::CONNECTION); + issue->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); + mParser->addIssue(issue); } } } else { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.second + "' as variable_2 but the corresponding component_2 is invalid."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - err->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.second + "' as variable_2 but the corresponding component_2 is invalid."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + issue->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); + mParser->addIssue(issue); } // Set the variable equivalence relationship for this variable pair. if ((variable1) && (variable2)) { @@ -964,12 +964,12 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr } } } else { - IssuePtr err = Issue::create(); - err->setDescription("Connection in model '" + model->name() + "' does not have a map_variables element."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - err->setRule(ReferenceRule::CONNECTION_MAP_VARIABLES); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Connection in model '" + model->name() + "' does not have a map_variables element."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + issue->setRule(ReferenceRule::CONNECTION_MAP_VARIABLES); + mParser->addIssue(issue); } } @@ -987,32 +987,32 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X // Will re-add this to the model once we encapsulate the child(ren). parentComponent = model->takeComponent(parentComponentName); } else { - IssuePtr err = Issue::create(); - err->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponentName + "' as a component in a component_ref but it does not exist in the model."); - err->setModel(model); - err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponentName + "' as a component in a component_ref but it does not exist in the model."); + issue->setModel(model); + issue->setCause(Issue::Cause::ENCAPSULATION); + issue->setRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + mParser->addIssue(issue); } } else if (attribute->isType("id")) { encapsulationId = attribute->value(); } else { - IssuePtr err = Issue::create(); - err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid component_ref attribute '" + attribute->name() + "'."); - err->setModel(model); - err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Encapsulation in model '" + model->name() + "' has an invalid component_ref attribute '" + attribute->name() + "'."); + issue->setModel(model); + issue->setCause(Issue::Cause::ENCAPSULATION); + issue->setRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + mParser->addIssue(issue); } attribute = attribute->next(); } if ((!parentComponent) && (parentComponentName.empty())) { - IssuePtr err = Issue::create(); - err->setDescription("Encapsulation in model '" + model->name() + "' does not have a valid component attribute in a component_ref element."); - err->setModel(model); - err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Encapsulation in model '" + model->name() + "' does not have a valid component attribute in a component_ref element."); + issue->setModel(model); + issue->setCause(Issue::Cause::ENCAPSULATION); + issue->setRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + mParser->addIssue(issue); } else if (parentComponent) { parentComponent->setEncapsulationId(encapsulationId); } @@ -1030,20 +1030,20 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X const std::string textNode = childComponentNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); - err->setModel(model); - err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); + issue->setModel(model); + issue->setCause(Issue::Cause::ENCAPSULATION); + mParser->addIssue(issue); } } else if (childComponentNode->isComment()) { // Do nothing. } else { - IssuePtr err = Issue::create(); - err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + childComponentNode->name() + "'."); - err->setModel(model); - err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + childComponentNode->name() + "'."); + issue->setModel(model); + issue->setCause(Issue::Cause::ENCAPSULATION); + mParser->addIssue(issue); } if ((parentComponent) && (childComponent)) { @@ -1070,12 +1070,12 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP const std::string textNode = componentRefNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); - err->setModel(model); - err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(ReferenceRule::COMPONENT_REF_CHILD); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); + issue->setModel(model); + issue->setCause(Issue::Cause::ENCAPSULATION); + issue->setRule(ReferenceRule::COMPONENT_REF_CHILD); + mParser->addIssue(issue); } else { // Continue to next node if this is whitespace (don't try to parse children of whitespace). componentRefNode = componentRefNode->next(); @@ -1084,30 +1084,30 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP } else if (componentRefNode->isComment()) { // Do nothing. } else { - IssuePtr err = Issue::create(); - err->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + componentRefNode->name() + "'."); - err->setModel(model); - err->setCause(Issue::Cause::ENCAPSULATION); - err->setRule(ReferenceRule::ENCAPSULATION_COMPONENT_REF); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + componentRefNode->name() + "'."); + issue->setModel(model); + issue->setCause(Issue::Cause::ENCAPSULATION); + issue->setRule(ReferenceRule::ENCAPSULATION_COMPONENT_REF); + mParser->addIssue(issue); } // Add the parentComponent to the model with its child(ren) encapsulated. if (parentComponent) { model->addComponent(parentComponent); if (parentComponent->componentCount() == 0) { - IssuePtr err = Issue::create(); - err->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponent->name() + "' as a parent component_ref but it does not have any children."); - err->setModel(model); - err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponent->name() + "' as a parent component_ref but it does not have any children."); + issue->setModel(model); + issue->setCause(Issue::Cause::ENCAPSULATION); + mParser->addIssue(issue); } } else if (!parentComponent && haveComponentRef) { - IssuePtr err = Issue::create(); - err->setDescription("Encapsulation in model '" + model->name() + "' specifies an invalid parent component_ref that also does not have any children."); - err->setModel(model); - err->setCause(Issue::Cause::ENCAPSULATION); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Encapsulation in model '" + model->name() + "' specifies an invalid parent component_ref that also does not have any children."); + issue->setModel(model); + issue->setCause(Issue::Cause::ENCAPSULATION); + mParser->addIssue(issue); } componentRefNode = componentRefNode->next(); @@ -1125,10 +1125,10 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M } else if (attribute->inNamespaceUri(XLINK_NS)) { // Allow xlink attributes but do nothing for them. } else { - IssuePtr err = Issue::create(); - err->setDescription("Import from '" + node->attribute("href") + "' has an invalid attribute '" + attribute->name() + "'."); - err->setImportSource(importSource); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Import from '" + node->attribute("href") + "' has an invalid attribute '" + attribute->name() + "'."); + issue->setImportSource(importSource); + mParser->addIssue(issue); } attribute = attribute->next(); } @@ -1146,10 +1146,10 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M } else if (childAttribute->isType("component_ref")) { importedComponent->setSourceComponent(importSource, childAttribute->value()); } else { - IssuePtr err = Issue::create(); - err->setDescription("Import of component '" + childNode->attribute("name") + "' from '" + node->attribute("href") + "' has an invalid attribute '" + childAttribute->name() + "'."); - err->setImportSource(importSource); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Import of component '" + childNode->attribute("name") + "' from '" + node->attribute("href") + "' has an invalid attribute '" + childAttribute->name() + "'."); + issue->setImportSource(importSource); + mParser->addIssue(issue); errorOccurred = true; } childAttribute = childAttribute->next(); @@ -1169,10 +1169,10 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M } else if (childAttribute->isType("units_ref")) { importedUnits->setSourceUnits(importSource, childAttribute->value()); } else { - IssuePtr err = Issue::create(); - err->setDescription("Import of units '" + childNode->attribute("name") + "' from '" + node->attribute("href") + "' has an invalid attribute '" + childAttribute->name() + "'."); - err->setImportSource(importSource); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Import of units '" + childNode->attribute("name") + "' from '" + node->attribute("href") + "' has an invalid attribute '" + childAttribute->name() + "'."); + issue->setImportSource(importSource); + mParser->addIssue(issue); errorOccurred = true; } childAttribute = childAttribute->next(); @@ -1184,20 +1184,20 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M const std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Import from '" + node->attribute("href") + "' has an invalid non-whitespace child text element '" + textNode + "'."); - err->setImportSource(importSource); - err->setRule(ReferenceRule::IMPORT_CHILD); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Import from '" + node->attribute("href") + "' has an invalid non-whitespace child text element '" + textNode + "'."); + issue->setImportSource(importSource); + issue->setRule(ReferenceRule::IMPORT_CHILD); + mParser->addIssue(issue); } } else if (childNode->isComment()) { // Do nothing. } else { - IssuePtr err = Issue::create(); - err->setDescription("Import from '" + node->attribute("href") + "' has an invalid child element '" + childNode->name() + "'."); - err->setImportSource(importSource); - err->setRule(ReferenceRule::IMPORT_CHILD); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Import from '" + node->attribute("href") + "' has an invalid child element '" + childNode->name() + "'."); + issue->setImportSource(importSource); + issue->setRule(ReferenceRule::IMPORT_CHILD); + mParser->addIssue(issue); } childNode = childNode->next(); } @@ -1226,11 +1226,11 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese reset->setResetValueId(childAttribute->value()); } } else { - IssuePtr err = Issue::create(); - err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' has an unexpected attribute in the " + childType + " block of '" + childAttribute->name() + "'."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_TEST_VALUE); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' has an unexpected attribute in the " + childType + " block of '" + childAttribute->name() + "'."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_TEST_VALUE); + mParser->addIssue(issue); } childAttribute = childAttribute->next(); } @@ -1250,11 +1250,11 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese std::string textNode = mathNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - IssuePtr err = Issue::create(); - err->setDescription("The " + childType + " in the reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' should have a MathML block as a child."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_TEST_VALUE); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("The " + childType + " in the reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' should have a MathML block as a child."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_TEST_VALUE); + mParser->addIssue(issue); } } mathNode = mathNode->next(); @@ -1275,20 +1275,20 @@ void Parser::ParserImpl::checkResetChildMultiplicity(size_t count, const std::st } if (count > 1) { - IssuePtr err = Issue::create(); - err->setDescription("Reset in component '" + component->name() + "' referencing variable '" - + variableName + "' and test_variable '" + testVariableName + "' has " + convertToString(count) + " " + childType + " blocks."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_TEST_VALUE); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Reset in component '" + component->name() + "' referencing variable '" + + variableName + "' and test_variable '" + testVariableName + "' has " + convertToString(count) + " " + childType + " blocks."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_TEST_VALUE); + mParser->addIssue(issue); } if (count == 0) { - IssuePtr err = Issue::create(); - err->setDescription("Reset in component '" + component->name() + "' referencing variable '" - + variableName + "' and test_variable '" + testVariableName + "' does not have a " + childType + " block defined."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_TEST_VALUE); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Reset in component '" + component->name() + "' referencing variable '" + + variableName + "' and test_variable '" + testVariableName + "' does not have a " + childType + " block defined."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_TEST_VALUE); + mParser->addIssue(issue); } } @@ -1310,11 +1310,11 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co // TODO This follows the same pattern as the issues returned from parsing the encapsulations if (referencedVariable == nullptr) { - IssuePtr err = Issue::create(); - err->setDescription("Reset referencing variable '" + variableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_VARIABLE_REFERENCE); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Reset referencing variable '" + variableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_VARIABLE_REFERENCE); + mParser->addIssue(issue); } else { reset->setVariable(referencedVariable); } @@ -1323,11 +1323,11 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co testVariable = component->variable(testVariableReference); if (testVariable == nullptr) { // TODO This follows the same pattern as the issues returned from parsing the encapsulations - IssuePtr err = Issue::create(); - err->setDescription("Reset referencing test_variable '" + testVariableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Reset referencing test_variable '" + testVariableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); + mParser->addIssue(issue); } else { reset->setTestVariable(testVariable); } @@ -1340,19 +1340,19 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co if (reset->variable() != nullptr) { variableName = reset->variable()->name(); } - IssuePtr err = Issue::create(); - err->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' has a non-integer order value '" + attribute->value() + "'."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_ORDER); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' has a non-integer order value '" + attribute->value() + "'."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_ORDER); + mParser->addIssue(issue); } } else if (attribute->isType("id")) { reset->setId(attribute->value()); } else { - IssuePtr err = Issue::create(); - err->setDescription("Reset in component '" + component->name() + "' has an invalid attribute '" + attribute->name() + "'."); - err->setReset(reset); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Reset in component '" + component->name() + "' has an invalid attribute '" + attribute->name() + "'."); + issue->setReset(reset); + mParser->addIssue(issue); } attribute = attribute->next(); } @@ -1360,11 +1360,11 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co if (orderValid) { reset->setOrder(order); } else if (!orderDefined) { - IssuePtr err = Issue::create(); - err->setDescription("Reset in component '" + component->name() + "' does not have its order set."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_ORDER); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Reset in component '" + component->name() + "' does not have its order set."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_ORDER); + mParser->addIssue(issue); } XmlNodePtr childNode = node->firstChild(); @@ -1382,11 +1382,11 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co std::string textNode = childNode->convertToString(); // Ignore whitespace when parsing. if (hasNonWhitespaceCharacters(textNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Reset has an invalid non-whitespace child text element '" + textNode + "'. Either a test_value block or a reset_value block is expected."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_CHILD); - mParser->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Reset has an invalid non-whitespace child text element '" + textNode + "'. Either a test_value block or a reset_value block is expected."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_CHILD); + mParser->addIssue(issue); } } else if (childNode->isComment()) { // Do nothing. diff --git a/src/validator.cpp b/src/validator.cpp index 700ecd9f3..a26aa11bf 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -282,11 +282,11 @@ void Validator::validateModel(const ModelPtr &model) removeAllIssues(); // Check for a valid name attribute. if (!mPimpl->isCellmlIdentifier(model->name())) { - IssuePtr err = Issue::create(); - err->setDescription("Model does not have a valid name attribute."); - err->setModel(model); - err->setRule(ReferenceRule::MODEL_NAME); - addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Model does not have a valid name attribute."); + issue->setModel(model); + issue->setRule(ReferenceRule::MODEL_NAME); + addIssue(issue); } // Check for components in this model. if (model->componentCount() > 0) { @@ -309,35 +309,35 @@ void Validator::validateModel(const ModelPtr &model) // Check for a units_ref. std::string unitsRef = units->importReference(); std::string importSource = units->importSource()->url(); - bool foundImportError = false; + bool foundImportIssue = false; if (!mPimpl->isCellmlIdentifier(unitsRef)) { - IssuePtr err = Issue::create(); - err->setDescription("Imported units '" + unitsName + "' does not have a valid units_ref attribute."); - err->setUnits(units); - err->setRule(ReferenceRule::IMPORT_UNITS_REF); - addIssue(err); - foundImportError = true; + IssuePtr issue = Issue::create(); + issue->setDescription("Imported units '" + unitsName + "' does not have a valid units_ref attribute."); + issue->setUnits(units); + issue->setRule(ReferenceRule::IMPORT_UNITS_REF); + addIssue(issue); + foundImportIssue = true; } // Check for a xlink:href. // TODO: check this id against the XLink spec (see CellML Spec 5.1.1). if (importSource.empty()) { - IssuePtr err = Issue::create(); - err->setDescription("Import of units '" + unitsName + "' does not have a valid locator xlink:href attribute."); - err->setImportSource(units->importSource()); - err->setRule(ReferenceRule::IMPORT_HREF); - addIssue(err); - foundImportError = true; + IssuePtr issue = Issue::create(); + issue->setDescription("Import of units '" + unitsName + "' does not have a valid locator xlink:href attribute."); + issue->setImportSource(units->importSource()); + issue->setRule(ReferenceRule::IMPORT_HREF); + addIssue(issue); + foundImportIssue = true; } // Check if we already have another import from the same source with the same units_ref. // (This looks for matching entries at the same position in the source and ref vectors). - if (!unitsImportSources.empty() && (!foundImportError)) { + if (!unitsImportSources.empty() && (!foundImportIssue)) { if ((std::find(unitsImportSources.begin(), unitsImportSources.end(), importSource) - unitsImportSources.begin()) == (std::find(unitsRefs.begin(), unitsRefs.end(), unitsRef) - unitsRefs.begin())) { - IssuePtr err = Issue::create(); - err->setDescription("Model '" + model->name() + "' contains multiple imported units from '" + importSource + "' with the same units_ref attribute '" + unitsRef + "'."); - err->setModel(model); - err->setRule(ReferenceRule::IMPORT_UNITS_REF); - addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Model '" + model->name() + "' contains multiple imported units from '" + importSource + "' with the same units_ref attribute '" + unitsRef + "'."); + issue->setModel(model); + issue->setRule(ReferenceRule::IMPORT_UNITS_REF); + addIssue(issue); } } // Push back the unique sources and refs. @@ -346,11 +346,11 @@ void Validator::validateModel(const ModelPtr &model) } // Check for duplicate units names in this model. if (std::find(unitsNames.begin(), unitsNames.end(), unitsName) != unitsNames.end()) { - IssuePtr err = Issue::create(); - err->setDescription("Model '" + model->name() + "' contains multiple units with the name '" + unitsName + "'. Valid units names must be unique to their model."); - err->setModel(model); - err->setRule(ReferenceRule::UNITS_NAME_UNIQUE); - addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Model '" + model->name() + "' contains multiple units with the name '" + unitsName + "'. Valid units names must be unique to their model."); + issue->setModel(model); + issue->setRule(ReferenceRule::UNITS_NAME_UNIQUE); + addIssue(issue); } unitsNames.push_back(unitsName); } @@ -375,10 +375,10 @@ void Validator::ValidatorImpl::validateUniqueName(const ModelPtr &model, const s { if (!name.empty()) { if (std::find(names.begin(), names.end(), name) != names.end()) { - IssuePtr err = Issue::create(); - err->setDescription("Model '" + model->name() + "' contains multiple components with the name '" + name + "'. Valid component names must be unique to their model."); - err->setModel(model); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Model '" + model->name() + "' contains multiple components with the name '" + name + "'. Valid component names must be unique to their model."); + issue->setModel(model); + mValidator->addIssue(issue); } else { names.push_back(name); } @@ -402,11 +402,11 @@ void Validator::ValidatorImpl::validateComponentTree(const ModelPtr &model, cons void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &component) { if (!isCellmlIdentifier(component->name())) { - IssuePtr err = Issue::create(); - err->setComponent(component); - err->setDescription("Imported component does not have a valid name attribute."); - err->setRule(ReferenceRule::IMPORT_COMPONENT_NAME); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setComponent(component); + issue->setDescription("Imported component does not have a valid name attribute."); + issue->setRule(ReferenceRule::IMPORT_COMPONENT_NAME); + mValidator->addIssue(issue); } // Check for a component_ref; assumes imported if the import source is not null. @@ -415,26 +415,26 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com std::string componentName = component->name(); if (!isCellmlIdentifier(componentRef)) { - IssuePtr err = Issue::create(); - err->setDescription("Imported component '" + componentName + "' does not have a valid component_ref attribute."); - err->setComponent(component); - err->setRule(ReferenceRule::IMPORT_COMPONENT_REF); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Imported component '" + componentName + "' does not have a valid component_ref attribute."); + issue->setComponent(component); + issue->setRule(ReferenceRule::IMPORT_COMPONENT_REF); + mValidator->addIssue(issue); } if (importSource.empty()) { - IssuePtr err = Issue::create(); - err->setDescription("Import of component '" + componentName + "' does not have a valid locator xlink:href attribute."); - err->setImportSource(component->importSource()); - err->setRule(ReferenceRule::IMPORT_HREF); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Import of component '" + componentName + "' does not have a valid locator xlink:href attribute."); + issue->setImportSource(component->importSource()); + issue->setRule(ReferenceRule::IMPORT_HREF); + mValidator->addIssue(issue); } else { xmlURIPtr uri = xmlParseURI(importSource.c_str()); if (uri == nullptr) { - IssuePtr err = Issue::create(); - err->setDescription("Import of component '" + componentName + "' has an invalid URI in the href attribute."); - err->setImportSource(component->importSource()); - err->setRule(ReferenceRule::IMPORT_HREF); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Import of component '" + componentName + "' has an invalid URI in the href attribute."); + issue->setImportSource(component->importSource()); + issue->setRule(ReferenceRule::IMPORT_HREF); + mValidator->addIssue(issue); } else { xmlFreeURI(uri); @@ -446,11 +446,11 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) { // Check for a valid name attribute. if (!isCellmlIdentifier(component->name())) { - IssuePtr err = Issue::create(); - err->setComponent(component); - err->setDescription("Component does not have a valid name attribute."); - err->setRule(ReferenceRule::COMPONENT_NAME); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setComponent(component); + issue->setDescription("Component does not have a valid name attribute."); + issue->setRule(ReferenceRule::COMPONENT_NAME); + mValidator->addIssue(issue); } // Check for variables in this component. std::vector variableNames; @@ -461,11 +461,11 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) std::string variableName = component->variable(i)->name(); if (!variableName.empty()) { if (std::find(variableNames.begin(), variableNames.end(), variableName) != variableNames.end()) { - IssuePtr err = Issue::create(); - err->setDescription("Component '" + component->name() + "' contains multiple variables with the name '" + variableName + "'. Valid variable names must be unique to their component."); - err->setComponent(component); - err->setRule(ReferenceRule::VARIABLE_NAME); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Component '" + component->name() + "' contains multiple variables with the name '" + variableName + "'. Valid variable names must be unique to their component."); + issue->setComponent(component); + issue->setRule(ReferenceRule::VARIABLE_NAME); + mValidator->addIssue(issue); } variableNames.push_back(variableName); } @@ -492,24 +492,24 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v { // Check for a valid name attribute. if (!isCellmlIdentifier(units->name())) { - IssuePtr err = Issue::create(); - err->setUnits(units); + IssuePtr issue = Issue::create(); + issue->setUnits(units); if (units->isImport()) { - err->setDescription("Imported units does not have a valid name attribute."); - err->setRule(ReferenceRule::IMPORT_UNITS_NAME); + issue->setDescription("Imported units does not have a valid name attribute."); + issue->setRule(ReferenceRule::IMPORT_UNITS_NAME); } else { - err->setDescription("Units does not have a valid name attribute."); - err->setRule(ReferenceRule::UNITS_NAME); + issue->setDescription("Units does not have a valid name attribute."); + issue->setRule(ReferenceRule::UNITS_NAME); } - mValidator->addIssue(err); + mValidator->addIssue(issue); } else { // Check for a matching standard units. if (isStandardUnitName(units->name())) { - IssuePtr err = Issue::create(); - err->setDescription("Units is named '" + units->name() + "' which is a protected standard unit name."); - err->setUnits(units); - err->setRule(ReferenceRule::UNITS_STANDARD); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Units is named '" + units->name() + "' which is a protected standard unit name."); + issue->setUnits(units); + issue->setRule(ReferenceRule::UNITS_STANDARD); + mValidator->addIssue(issue); } } if (units->unitCount() > 0) { @@ -531,37 +531,37 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u units->unitAttributes(index, reference, prefix, exponent, multiplier, id); if (isCellmlIdentifier(reference)) { if ((std::find(unitsNames.begin(), unitsNames.end(), reference) == unitsNames.end()) && (!isStandardUnitName(reference))) { - IssuePtr err = Issue::create(); - err->setDescription("Units reference '" + reference + "' in units '" + units->name() + "' is not a valid reference to a local units or a standard unit type."); - err->setUnits(units); - err->setRule(ReferenceRule::UNIT_UNITS_REF); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Units reference '" + reference + "' in units '" + units->name() + "' is not a valid reference to a local units or a standard unit type."); + issue->setUnits(units); + issue->setRule(ReferenceRule::UNIT_UNITS_REF); + mValidator->addIssue(issue); } } else { - IssuePtr err = Issue::create(); - err->setDescription("Unit in units '" + units->name() + "' does not have a valid units reference."); - err->setUnits(units); - err->setRule(ReferenceRule::UNIT_UNITS_REF); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Unit in units '" + units->name() + "' does not have a valid units reference."); + issue->setUnits(units); + issue->setRule(ReferenceRule::UNIT_UNITS_REF); + mValidator->addIssue(issue); } if (!prefix.empty()) { if (!isStandardPrefixName(prefix)) { if (!isCellMLInteger(prefix)) { - IssuePtr err = Issue::create(); - err->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is not a valid integer or an SI prefix."); - err->setUnits(units); - err->setRule(ReferenceRule::UNIT_PREFIX); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is not a valid integer or an SI prefix."); + issue->setUnits(units); + issue->setRule(ReferenceRule::UNIT_PREFIX); + mValidator->addIssue(issue); } else { try { int test = std::stoi(prefix); (void)test; } catch (std::out_of_range &) { - IssuePtr err = Issue::create(); - err->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is out of the integer range."); - err->setUnits(units); - err->setRule(ReferenceRule::UNIT_PREFIX); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is out of the integer range."); + issue->setUnits(units); + issue->setRule(ReferenceRule::UNIT_PREFIX); + mValidator->addIssue(issue); } } } @@ -572,40 +572,40 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con { // Check for a valid name attribute. if (!isCellmlIdentifier(variable->name())) { - IssuePtr err = Issue::create(); - err->setDescription("Variable does not have a valid name attribute."); - err->setVariable(variable); - err->setRule(ReferenceRule::VARIABLE_NAME); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable does not have a valid name attribute."); + issue->setVariable(variable); + issue->setRule(ReferenceRule::VARIABLE_NAME); + mValidator->addIssue(issue); } // Check for a valid units attribute. std::string unitsName = variable->units() != nullptr ? variable->units()->name() : ""; if (!isCellmlIdentifier(unitsName)) { - IssuePtr err = Issue::create(); - err->setDescription("Variable '" + variable->name() + "' does not have a valid units attribute."); - err->setVariable(variable); - err->setRule(ReferenceRule::VARIABLE_UNITS); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable '" + variable->name() + "' does not have a valid units attribute."); + issue->setVariable(variable); + issue->setRule(ReferenceRule::VARIABLE_UNITS); + mValidator->addIssue(issue); } else if (!isStandardUnitName(unitsName)) { ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); ModelPtr model = owningModel(component); if ((model != nullptr) && !model->hasUnits(variable->units())) { - IssuePtr err = Issue::create(); - err->setDescription("Variable '" + variable->name() + "' has a units reference '" + unitsName + "' that does not correspond with a standard units and is not a units defined in the variable's model."); - err->setVariable(variable); - err->setRule(ReferenceRule::VARIABLE_UNITS); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable '" + variable->name() + "' has a units reference '" + unitsName + "' that does not correspond with a standard units and is not a units defined in the variable's model."); + issue->setVariable(variable); + issue->setRule(ReferenceRule::VARIABLE_UNITS); + mValidator->addIssue(issue); } } // Check for a valid interface attribute. if (!variable->interfaceType().empty()) { std::string interfaceType = variable->interfaceType(); if ((interfaceType != "public") && (interfaceType != "private") && (interfaceType != "none") && (interfaceType != "public_and_private")) { - IssuePtr err = Issue::create(); - err->setDescription("Variable '" + variable->name() + "' has an invalid interface attribute value '" + interfaceType + "'."); - err->setVariable(variable); - err->setRule(ReferenceRule::VARIABLE_INTERFACE); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable '" + variable->name() + "' has an invalid interface attribute value '" + interfaceType + "'."); + issue->setVariable(variable); + issue->setRule(ReferenceRule::VARIABLE_INTERFACE); + mValidator->addIssue(issue); } } // Check for a valid initial value attribute. @@ -615,11 +615,11 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con if (!(std::find(variableNames.begin(), variableNames.end(), initialValue) != variableNames.end())) { // Otherwise, check that the initial value can be converted to a double if (!isCellMLReal(initialValue)) { - IssuePtr err = Issue::create(); - err->setDescription("Variable '" + variable->name() + "' has an invalid initial value '" + initialValue + "'. Initial values must be a real number string or a variable reference."); - err->setVariable(variable); - err->setRule(ReferenceRule::VARIABLE_INITIAL_VALUE); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable '" + variable->name() + "' has an invalid initial value '" + initialValue + "'. Initial values must be a real number string or a variable reference."); + issue->setVariable(variable); + issue->setRule(ReferenceRule::VARIABLE_INITIAL_VALUE); + mValidator->addIssue(issue); } } } @@ -686,53 +686,53 @@ void Validator::ValidatorImpl::validateReset(const ResetPtr &reset, const Compon } if (noOrder) { - IssuePtr err = Issue::create(); - err->setDescription(description + "does not have an order set."); - err->setComponent(component); - err->setRule(ReferenceRule::RESET_ORDER); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription(description + "does not have an order set."); + issue->setComponent(component); + issue->setRule(ReferenceRule::RESET_ORDER); + mValidator->addIssue(issue); } if (noVariable) { - IssuePtr err = Issue::create(); - err->setDescription(description + "does not reference a variable."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_VARIABLE_REFERENCE); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription(description + "does not reference a variable."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_VARIABLE_REFERENCE); + mValidator->addIssue(issue); } if (noTestVariable) { - IssuePtr err = Issue::create(); - err->setDescription(description + "does not reference a test_variable."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription(description + "does not reference a test_variable."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); + mValidator->addIssue(issue); } if (noTestValue) { - IssuePtr err = Issue::create(); - err->setDescription(description + "does not have a test_value specified."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_TEST_VALUE); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription(description + "does not have a test_value specified."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_TEST_VALUE); + mValidator->addIssue(issue); } if (noResetValue) { - IssuePtr err = Issue::create(); - err->setDescription(description + "does not have a reset_value specified."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_RESET_VALUE); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription(description + "does not have a reset_value specified."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_RESET_VALUE); + mValidator->addIssue(issue); } if (varOutsideComponent) { - IssuePtr err = Issue::create(); - err->setDescription(description + "refers to a variable '" + reset->variable()->name() + "' in a different component '" + varParentName + "'."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_VARIABLE_REFERENCE); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription(description + "refers to a variable '" + reset->variable()->name() + "' in a different component '" + varParentName + "'."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_VARIABLE_REFERENCE); + mValidator->addIssue(issue); } if (testVarOutsideComponent) { - IssuePtr err = Issue::create(); - err->setDescription(description + "refers to a test_variable '" + reset->testVariable()->name() + "' in a different component '" + testVarParentName + "'."); - err->setReset(reset); - err->setRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription(description + "refers to a test_variable '" + reset->testVariable()->name() + "' in a different component '" + testVarParentName + "'."); + issue->setReset(reset); + issue->setRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); + mValidator->addIssue(issue); } } @@ -744,27 +744,27 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp // Copy any XML parsing issues into the common validator issue handler. if (doc->xmlErrorCount() > 0) { for (size_t i = 0; i < doc->xmlErrorCount(); ++i) { - IssuePtr err = Issue::create(); - err->setDescription("LibXml2 error: " + doc->xmlError(i)); - err->setCause(Issue::Cause::XML); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("LibXml2 error: " + doc->xmlError(i)); + issue->setCause(Issue::Cause::XML); + mValidator->addIssue(issue); } } XmlNodePtr node = doc->rootNode(); if (node == nullptr) { - IssuePtr err = Issue::create(); - err->setDescription("Could not get a valid XML root node from the math on component '" + component->name() + "'."); - err->setCause(Issue::Cause::XML); - err->setComponent(component); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Could not get a valid XML root node from the math on component '" + component->name() + "'."); + issue->setCause(Issue::Cause::XML); + issue->setComponent(component); + mValidator->addIssue(issue); return; } if (!node->isMathmlElement("math")) { - IssuePtr err = Issue::create(); - err->setDescription("Math root node is of invalid type '" + node->name() + "' on component '" + component->name() + "'. A valid math root node should be of type 'math'."); - err->setComponent(component); - err->setCause(Issue::Cause::XML); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Math root node is of invalid type '" + node->name() + "' on component '" + component->name() + "'. A valid math root node should be of type 'math'."); + issue->setComponent(component); + issue->setCause(Issue::Cause::XML); + mValidator->addIssue(issue); return; } @@ -797,11 +797,11 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp // Copy any MathML validation issues into the common validator issue handler. if (mathmlDoc->xmlErrorCount() > 0) { for (size_t i = 0; i < mathmlDoc->xmlErrorCount(); ++i) { - IssuePtr err = Issue::create(); - err->setDescription("W3C MathML DTD error: " + mathmlDoc->xmlError(i)); - err->setComponent(component); - err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("W3C MathML DTD error: " + mathmlDoc->xmlError(i)); + issue->setComponent(component); + issue->setCause(Issue::Cause::MATHML); + mValidator->addIssue(issue); } } } @@ -812,11 +812,11 @@ bool Validator::ValidatorImpl::validateCnUnits(const ComponentPtr &component, co return true; } - IssuePtr err = Issue::create(); - err->setDescription("Math cn element with the value '" + textNode + "' does not have a valid cellml:units attribute."); - err->setComponent(component); - err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Math cn element with the value '" + textNode + "' does not have a valid cellml:units attribute."); + issue->setComponent(component); + issue->setCause(Issue::Cause::MATHML); + mValidator->addIssue(issue); return false; } @@ -846,11 +846,11 @@ void Validator::ValidatorImpl::validateAndCleanCnNode(const XmlNodePtr &node, co cellmlAttributesToRemove.push_back(attribute); } else if (attribute->inNamespaceUri(CELLML_2_0_NS)) { cellmlAttributesToRemove.push_back(attribute); - IssuePtr err = Issue::create(); - err->setDescription("Math " + node->name() + " element has an invalid attribute type '" + attribute->name() + "' in the cellml namespace. Attribute 'units' is the only CellML namespace attribute allowed."); - err->setComponent(component); - err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Math " + node->name() + " element has an invalid attribute type '" + attribute->name() + "' in the cellml namespace. Attribute 'units' is the only CellML namespace attribute allowed."); + issue->setComponent(component); + issue->setCause(Issue::Cause::MATHML); + mValidator->addIssue(issue); } } attribute = attribute->next(); @@ -868,11 +868,11 @@ void Validator::ValidatorImpl::validateAndCleanCnNode(const XmlNodePtr &node, co if (!model->hasUnits(unitsName)) { // Check for a matching standard units. if (!isStandardUnitName(unitsName)) { - IssuePtr err = Issue::create(); - err->setDescription("Math has a " + node->name() + " element with a cellml:units attribute '" + unitsName + "' that is not a valid reference to units in the model '" + model->name() + "' or a standard unit."); - err->setComponent(component); - err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Math has a " + node->name() + " element with a cellml:units attribute '" + unitsName + "' that is not a valid reference to units in the model '" + model->name() + "' or a standard unit."); + issue->setComponent(component); + issue->setCause(Issue::Cause::MATHML); + mValidator->addIssue(issue); } } } @@ -894,11 +894,11 @@ void Validator::ValidatorImpl::validateAndCleanCiNode(const XmlNodePtr &node, co if (!textInNode.empty()) { // Check whether we can find this text as a variable name in this component. if (std::find(variableNames.begin(), variableNames.end(), textInNode) == variableNames.end()) { - IssuePtr err = Issue::create(); - err->setDescription("MathML ci element has the child text '" + textInNode + "' which does not correspond with any variable names present in component '" + component->name() + "'."); - err->setComponent(component); - err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("MathML ci element has the child text '" + textInNode + "' which does not correspond with any variable names present in component '" + component->name() + "'."); + issue->setComponent(component); + issue->setCause(Issue::Cause::MATHML); + mValidator->addIssue(issue); } } } @@ -927,11 +927,11 @@ void Validator::ValidatorImpl::validateMathMLElements(const XmlNodePtr &node, co XmlNodePtr childNode = node->firstChild(); if (childNode != nullptr) { if (!childNode->isComment() && !childNode->isText() && !isSupportedMathMLElement(childNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Math has a '" + childNode->name() + "' element that is not a supported MathML element."); - err->setComponent(component); - err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Math has a '" + childNode->name() + "' element that is not a supported MathML element."); + issue->setComponent(component); + issue->setCause(Issue::Cause::MATHML); + mValidator->addIssue(issue); } validateMathMLElements(childNode, component); } @@ -939,11 +939,11 @@ void Validator::ValidatorImpl::validateMathMLElements(const XmlNodePtr &node, co XmlNodePtr nextNode = node->next(); if (nextNode != nullptr) { if (!nextNode->isComment() && !nextNode->isText() && !isSupportedMathMLElement(nextNode)) { - IssuePtr err = Issue::create(); - err->setDescription("Math has a '" + nextNode->name() + "' element that is not a supported MathML element."); - err->setComponent(component); - err->setCause(Issue::Cause::MATHML); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Math has a '" + nextNode->name() + "' element that is not a supported MathML element."); + issue->setComponent(component); + issue->setCause(Issue::Cause::MATHML); + mValidator->addIssue(issue); } validateMathMLElements(nextNode, component); } @@ -980,32 +980,32 @@ void Validator::ValidatorImpl::validateConnections(const ModelPtr &model) if (!unitsAreEquivalent(model, variable, equivalentVariable, hints, multiplier)) { auto unitsName = variable->units() == nullptr ? "" : variable->units()->name(); auto equivalentUnitsName = equivalentVariable->units() == nullptr ? "" : equivalentVariable->units()->name(); - IssuePtr err = Issue::create(); - err->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); - err->setModel(model); - err->setCause(Issue::Cause::UNITS); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); + issue->setModel(model); + issue->setCause(Issue::Cause::UNITS); + mValidator->addIssue(issue); } else if (multiplier != 0.0) { // Warning when the multipliers are not the same. auto unitsName = variable->units() == nullptr ? "" : variable->units()->name(); auto equivalentUnitsName = equivalentVariable->units() == nullptr ? "" : equivalentVariable->units()->name(); - IssuePtr err = Issue::create(); - err->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); - err->setModel(model); - err->setLevel(libcellml::Issue::Level::WARNING); - err->setCause(Issue::Cause::UNITS); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); + issue->setModel(model); + issue->setLevel(libcellml::Issue::Level::WARNING); + issue->setCause(Issue::Cause::UNITS); + mValidator->addIssue(issue); } if (equivalentVariable->hasEquivalentVariable(variable)) { // Check that the equivalent variable has a valid parent component. auto component2 = std::dynamic_pointer_cast(equivalentVariable->parent()); if (component2 == nullptr || !component2->hasVariable(equivalentVariable)) { - IssuePtr err = Issue::create(); - err->setDescription("Variable '" + equivalentVariable->name() + "' is an equivalent variable to '" + variable->name() + "' but '" + equivalentVariable->name() + "' has no parent component."); - err->setModel(model); - err->setCause(Issue::Cause::CONNECTION); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("Variable '" + equivalentVariable->name() + "' is an equivalent variable to '" + variable->name() + "' but '" + equivalentVariable->name() + "' has no parent component."); + issue->setModel(model); + issue->setCause(Issue::Cause::CONNECTION); + mValidator->addIssue(issue); } } } @@ -1030,26 +1030,26 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) // Does not start with numeric character. if (isdigit(name[0]) != 0) { result = false; - IssuePtr err = Issue::create(); - err->setDescription("CellML identifiers must not begin with a European numeric character [0-9]."); - err->setRule(ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("CellML identifiers must not begin with a European numeric character [0-9]."); + issue->setRule(ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); + mValidator->addIssue(issue); } else { // Basic Latin alphanumeric characters and underscores. if (name.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_") != std::string::npos) { result = false; - IssuePtr err = Issue::create(); - err->setDescription("CellML identifiers must not contain any characters other than [a-zA-Z0-9_]."); - err->setRule(ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("CellML identifiers must not contain any characters other than [a-zA-Z0-9_]."); + issue->setRule(ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); + mValidator->addIssue(issue); } } } else { result = false; - IssuePtr err = Issue::create(); - err->setDescription("CellML identifiers must contain one or more basic Latin alphabetic characters."); - err->setRule(ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); - mValidator->addIssue(err); + IssuePtr issue = Issue::create(); + issue->setDescription("CellML identifiers must contain one or more basic Latin alphabetic characters."); + issue->setRule(ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); + mValidator->addIssue(issue); } return result; } @@ -1169,27 +1169,27 @@ void Validator::ValidatorImpl::updateBaseUnitCount(const ModelPtr &model, for (const auto &iter : standardUnitsList.at(uName)) { unitMap.at(iter.first) += direction * (iter.second * uExp); } - multiplier += direction * (logMult + standardMultiplierList.at(uName)); // KRM added standardMultiplierList + multiplier += direction * (logMult + standardMultiplierList.at(uName)); } } void Validator::ValidatorImpl::validateNoUnitsAreCyclic(const ModelPtr &model) { std::vector history; - std::vector> errorList; + std::vector> issueList; for (size_t i = 0; i < model->unitsCount(); ++i) { // Test each units' dependencies for presence of self in tree. UnitsPtr u = model->units(i); history.push_back(u->name()); - checkUnitForCycles(model, u, history, errorList); + checkUnitForCycles(model, u, history, issueList); // Have to delete this each time to prevent reinitialisation with previous base variables. std::vector().swap(history); } - if (!errorList.empty()) { - std::vector> reportedErrorList; - for (auto &issues : errorList) { + if (!issueList.empty()) { + std::vector> reportedIssueList; + for (auto &issues : issueList) { std::map hash; for (auto &e : issues) { @@ -1197,18 +1197,18 @@ void Validator::ValidatorImpl::validateNoUnitsAreCyclic(const ModelPtr &model) } // Only return as issue if this combo has not been reported already. - if (std::find(reportedErrorList.begin(), reportedErrorList.end(), hash) == reportedErrorList.end()) { - IssuePtr err = Issue::create(); + if (std::find(reportedIssueList.begin(), reportedIssueList.end(), hash) == reportedIssueList.end()) { + IssuePtr issue = Issue::create(); std::string des = "'"; for (size_t j = 0; j < issues.size() - 1; ++j) { des += issues[j] + "' -> '"; } des += issues[issues.size() - 1] + "'"; - err->setDescription("Cyclic units exist: " + des); - err->setModel(model); - err->setCause(Issue::Cause::UNITS); - mValidator->addIssue(err); - reportedErrorList.push_back(hash); + issue->setDescription("Cyclic units exist: " + des); + issue->setModel(model); + issue->setCause(Issue::Cause::UNITS); + mValidator->addIssue(issue); + reportedIssueList.push_back(hash); } std::map().swap(hash); } diff --git a/tests/bindings/python/test_error.py b/tests/bindings/python/test_error.py index 014896227..4b0a315f7 100644 --- a/tests/bindings/python/test_error.py +++ b/tests/bindings/python/test_error.py @@ -4,7 +4,7 @@ import unittest -class ErrorTestCase(unittest.TestCase): +class IssueTestCase(unittest.TestCase): def test_create_destroy(self): from libcellml import Component diff --git a/tests/bindings/python/test_generator.py b/tests/bindings/python/test_generator.py index 6ed221b96..f1943b170 100644 --- a/tests/bindings/python/test_generator.py +++ b/tests/bindings/python/test_generator.py @@ -30,11 +30,11 @@ def test_inheritance(self): self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods - self.assertIsNone(x.error(0)) - self.assertIsNone(x.error(-1)) - self.assertEqual(x.errorCount(), 0) + self.assertIsNone(x.issue(0)) + self.assertIsNone(x.issue(-1)) + self.assertEqual(x.issueCount(), 0) x.addIssue(libcellml.Issue()) - self.assertEqual(x.errorCount(), 1) + self.assertEqual(x.issueCount(), 1) def test_process_model(self): from libcellml import Generator diff --git a/tests/bindings/python/test_parser.py b/tests/bindings/python/test_parser.py index 55c16226c..8b521b70e 100644 --- a/tests/bindings/python/test_parser.py +++ b/tests/bindings/python/test_parser.py @@ -20,11 +20,11 @@ def test_inheritance(self): self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods - self.assertIsNone(x.error(0)) - self.assertIsNone(x.error(-1)) - self.assertEqual(x.errorCount(), 0) + self.assertIsNone(x.issue(0)) + self.assertIsNone(x.issue(-1)) + self.assertEqual(x.issueCount(), 0) x.addIssue(libcellml.Issue()) - self.assertEqual(x.errorCount(), 1) + self.assertEqual(x.issueCount(), 1) def test_parse_model(self): import libcellml diff --git a/tests/bindings/python/test_printer.py b/tests/bindings/python/test_printer.py index 14336ac31..e17443d28 100644 --- a/tests/bindings/python/test_printer.py +++ b/tests/bindings/python/test_printer.py @@ -20,11 +20,11 @@ def test_inheritance(self): self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods - self.assertIsNone(x.error(0)) - self.assertIsNone(x.error(-1)) - self.assertEqual(x.errorCount(), 0) + self.assertIsNone(x.issue(0)) + self.assertIsNone(x.issue(-1)) + self.assertEqual(x.issueCount(), 0) x.addIssue(libcellml.Issue()) - self.assertEqual(x.errorCount(), 1) + self.assertEqual(x.issueCount(), 1) def test_print_model(self): from libcellml import Printer, Model diff --git a/tests/bindings/python/test_validator.py b/tests/bindings/python/test_validator.py index 2fcc24092..b808c1fee 100644 --- a/tests/bindings/python/test_validator.py +++ b/tests/bindings/python/test_validator.py @@ -21,11 +21,11 @@ def test_inheritance(self): self.assertIsInstance(x, libcellml.logger.Logger) # Test access to inherited methods - self.assertIsNone(x.error(0)) - self.assertIsNone(x.error(-1)) - self.assertEqual(x.errorCount(), 0) + self.assertIsNone(x.issue(0)) + self.assertIsNone(x.issue(-1)) + self.assertEqual(x.issueCount(), 0) x.addIssue(libcellml.Issue()) - self.assertEqual(x.errorCount(), 1) + self.assertEqual(x.issueCount(), 1) def test_validate_model(self): import libcellml diff --git a/tests/clone/clone.cpp b/tests/clone/clone.cpp index ce57a6c55..70c11a5bf 100644 --- a/tests/clone/clone.cpp +++ b/tests/clone/clone.cpp @@ -585,7 +585,7 @@ TEST(Clone, generateFromClonedModel) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); diff --git a/tests/component/encapsulation.cpp b/tests/component/encapsulation.cpp index 370d9fb6c..25bec5375 100644 --- a/tests/component/encapsulation.cpp +++ b/tests/component/encapsulation.cpp @@ -225,7 +225,7 @@ TEST(Encapsulation, hierarchyRepeatedComponent) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Model 'main' contains multiple components with the name 'repeated_component'. Valid component names must be unique to their model.", }; @@ -246,7 +246,7 @@ TEST(Encapsulation, hierarchyRepeatedComponent) libcellml::ValidatorPtr v = libcellml::Validator::create(); v->validateModel(model); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Encapsulation, hierarchyWaterfallAndParse) @@ -318,7 +318,7 @@ TEST(Encapsulation, parseAlternateFormHierarchy) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); EXPECT_EQ(size_t(1), model->componentCount()); auto component = model->component(0); for (size_t i = 0; i < 3; ++i) { diff --git a/tests/connection/connection.cpp b/tests/connection/connection.cpp index 2c827b08f..074a11106 100644 --- a/tests/connection/connection.cpp +++ b/tests/connection/connection.cpp @@ -215,7 +215,7 @@ TEST(Connection, parseValidAlternateFormConnection) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); EXPECT_EQ(size_t(2), model->componentCount()); EXPECT_EQ(size_t(1), model->component("component1")->variable("variable1")->equivalentVariableCount()); } @@ -1089,7 +1089,7 @@ TEST(Connection, importedComponentConnectionAndParse) // Parse libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); a = printer->printModel(model); EXPECT_EQ(e, a); @@ -1121,16 +1121,16 @@ TEST(Connection, componentConnectionAndParseMissingVariable) " \n" "\n"; - const std::string expectError = "Variable 'variable_angus' is specified as variable_1 in a connection but it does not exist in component_1 component 'component_dave' of model ''."; + const std::string expectIssue = "Variable 'variable_angus' is specified as variable_1 in a connection but it does not exist in component_1 component 'component_dave' of model ''."; // Parse libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(s); - EXPECT_EQ(size_t(1), parser->errorCount()); + EXPECT_EQ(size_t(1), parser->issueCount()); - EXPECT_EQ(expectError, parser->error(0)->description()); + EXPECT_EQ(expectIssue, parser->issue(0)->description()); parser->removeAllIssues(); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::PrinterPtr printer = libcellml::Printer::create(); const std::string a = printer->printModel(model); diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index ff3a3f995..12211ed8c 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -40,7 +40,7 @@ TEST(Coverage, connectionComment) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(in); - EXPECT_EQ(size_t(4), p->errorCount()); + EXPECT_EQ(size_t(4), p->issueCount()); } TEST(Coverage, importWithNonHrefXlink) @@ -63,7 +63,7 @@ TEST(Coverage, importWithNonHrefXlink) // Parse libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Coverage, entityHasParent) diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index 7c4853254..09bfd6314 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -29,7 +29,7 @@ TEST(Generator, emptyModel) generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::UNKNOWN, generator->modelType()); @@ -44,7 +44,7 @@ TEST(Generator, emptyModel) EXPECT_EQ(EMPTY_STRING, generator->implementationCode()); } -TEST(Generator, generatorErrors) +TEST(Generator, generatorIssues) { libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr invalidModel = parser->parseModel(fileContents("generator/initialized_variable_of_integration.cellml")); @@ -52,13 +52,13 @@ TEST(Generator, generatorErrors) generator->processModel(invalidModel); - EXPECT_EQ(size_t(1), generator->errorCount()); + EXPECT_EQ(size_t(1), generator->issueCount()); libcellml::ModelPtr emptyModel = libcellml::Model::create(); generator->processModel(emptyModel); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); } TEST(Generator, initializedVariableOfIntegration) @@ -66,9 +66,9 @@ TEST(Generator, initializedVariableOfIntegration) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/initialized_variable_of_integration.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); - const std::vector expectedErrors = { + const std::vector expectedIsues = { "Variable 'time' in component 'my_component' of model 'initialized_variable_of_integration' cannot be both a variable of integration and initialised.", }; const std::vector expectedCauses = { @@ -79,7 +79,7 @@ TEST(Generator, initializedVariableOfIntegration) generator->processModel(model); - EXPECT_EQ_ERRORS_KINDS(expectedErrors, expectedCauses, generator); + EXPECT_EQ_ISSUES_KINDS(expectedIsues, expectedCauses, generator); EXPECT_EQ(libcellml::Generator::ModelType::INVALID, generator->modelType()); @@ -99,9 +99,9 @@ TEST(Generator, twoVariablesOfIntegration) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/two_variables_of_integration.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); - const std::vector expectedErrors = { + const std::vector expectedIsues = { "Variable 'time' in component 'main' of model 'two_variables_of_integration' and variable 'other_time' in component 'sub_sub_sub' of model 'two_variables_of_integration' cannot both be a variable of integration.", }; const std::vector expectedCauses = { @@ -112,7 +112,7 @@ TEST(Generator, twoVariablesOfIntegration) generator->processModel(model); - EXPECT_EQ_ERRORS_KINDS(expectedErrors, expectedCauses, generator); + EXPECT_EQ_ISSUES_KINDS(expectedIsues, expectedCauses, generator); EXPECT_EQ(libcellml::Generator::ModelType::INVALID, generator->modelType()); @@ -132,9 +132,9 @@ TEST(Generator, nonFirstOrderOdes) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/non_first_order_odes.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); - const std::vector expectedErrors = { + const std::vector expectedIsues = { "The differential equation for variable 'x' in component 'main' of model 'non_first_order_odes' must be of the first order.", "The differential equation for variable 'y' in component 'sub' of model 'non_first_order_odes' must be of the first order.", "The differential equation for variable 'z' in component 'sub_sub' of model 'non_first_order_odes' must be of the first order.", @@ -149,7 +149,7 @@ TEST(Generator, nonFirstOrderOdes) generator->processModel(model); - EXPECT_EQ_ERRORS_KINDS(expectedErrors, expectedCauses, generator); + EXPECT_EQ_ISSUES_KINDS(expectedIsues, expectedCauses, generator); EXPECT_EQ(libcellml::Generator::ModelType::INVALID, generator->modelType()); @@ -169,9 +169,9 @@ TEST(Generator, undefinedVariables) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/undefined_variables.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); - const std::vector expectedErrors = { + const std::vector expectedIsues = { "Variable 'a' in component 'my_component' of model 'undefined_variables' is referenced in an equation, but it is not defined anywhere.", "Variable 'b' in component 'my_component' of model 'undefined_variables' is referenced in an equation, but it is not defined anywhere.", }; @@ -180,7 +180,7 @@ TEST(Generator, undefinedVariables) generator->processModel(model); - EXPECT_EQ_ERRORS(expectedErrors, generator); + EXPECT_EQ_ISSUES(expectedIsues, generator); EXPECT_EQ(libcellml::Generator::ModelType::INVALID, generator->modelType()); @@ -200,9 +200,9 @@ TEST(Generator, variableInitializedTwice) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/variable_initialized_twice.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); - const std::vector expectedErrors = { + const std::vector expectedIsues = { "Variable 'x' in component 'sub' of model 'variable_initialized_twice' and variable 'x' in component 'main' of model 'variable_initialized_twice' are equivalent and cannot therefore both be initialised.", }; @@ -210,7 +210,7 @@ TEST(Generator, variableInitializedTwice) generator->processModel(model); - EXPECT_EQ_ERRORS(expectedErrors, generator); + EXPECT_EQ_ISSUES(expectedIsues, generator); EXPECT_EQ(libcellml::Generator::ModelType::INVALID, generator->modelType()); @@ -230,9 +230,9 @@ TEST(Generator, nonInitializedState) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/non_initialized_state.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); - const std::vector expectedErrors = { + const std::vector expectedIsues = { "Variable 'x' in component 'my_component' of model 'non_initialized_state' is used in an ODE, but it is not initialised.", }; @@ -240,7 +240,7 @@ TEST(Generator, nonInitializedState) generator->processModel(model); - EXPECT_EQ_ERRORS(expectedErrors, generator); + EXPECT_EQ_ISSUES(expectedIsues, generator); EXPECT_EQ(libcellml::Generator::ModelType::UNDERCONSTRAINED, generator->modelType()); @@ -260,9 +260,9 @@ TEST(Generator, underconstrained) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/underconstrained.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); - const std::vector expectedErrors = { + const std::vector expectedIsues = { "Variable 'x' in component 'my_component' of model 'my_model' is not computed.", }; @@ -270,7 +270,7 @@ TEST(Generator, underconstrained) generator->processModel(model); - EXPECT_EQ_ERRORS(expectedErrors, generator); + EXPECT_EQ_ISSUES(expectedIsues, generator); EXPECT_EQ(libcellml::Generator::ModelType::UNDERCONSTRAINED, generator->modelType()); @@ -290,9 +290,9 @@ TEST(Generator, overconstrained) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/overconstrained.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); - const std::vector expectedErrors = { + const std::vector expectedIsues = { "Variable 'x' in component 'my_component' of model 'my_model' is computed more than once.", }; @@ -300,7 +300,7 @@ TEST(Generator, overconstrained) generator->processModel(model); - EXPECT_EQ_ERRORS(expectedErrors, generator); + EXPECT_EQ_ISSUES(expectedIsues, generator); EXPECT_EQ(libcellml::Generator::ModelType::OVERCONSTRAINED, generator->modelType()); @@ -320,9 +320,9 @@ TEST(Generator, unsuitablyConstrained) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/unsuitably_constrained.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); - const std::vector expectedErrors = { + const std::vector expectedIsues = { "Variable 'x' in component 'my_component' of model 'my_model' is not computed.", "Variable 'y' in component 'my_component' of model 'my_model' is computed more than once.", }; @@ -331,7 +331,7 @@ TEST(Generator, unsuitablyConstrained) generator->processModel(model); - EXPECT_EQ_ERRORS(expectedErrors, generator); + EXPECT_EQ_ISSUES(expectedIsues, generator); EXPECT_EQ(libcellml::Generator::ModelType::UNSUITABLY_CONSTRAINED, generator->modelType()); @@ -351,13 +351,13 @@ TEST(Generator, algebraicEqnComputedVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_computed_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ALGEBRAIC, generator->modelType()); @@ -385,13 +385,13 @@ TEST(Generator, algebraicEqnConstVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_const_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ALGEBRAIC, generator->modelType()); @@ -419,13 +419,13 @@ TEST(Generator, algebraicEqnConstantOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_constant_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ALGEBRAIC, generator->modelType()); @@ -453,13 +453,13 @@ TEST(Generator, algebraicEqnDerivativeOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_derivative_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -488,13 +488,13 @@ TEST(Generator, algebraicEqnDerivativeOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_derivative_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -523,13 +523,13 @@ TEST(Generator, algebraicEqnStateVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_state_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -558,13 +558,13 @@ TEST(Generator, algebraicEqnStateVarOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/algebraic_eqn_state_var_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -593,13 +593,13 @@ TEST(Generator, odeComputedVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_computed_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -628,13 +628,13 @@ TEST(Generator, odeComputedVarOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_computed_var_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -663,13 +663,13 @@ TEST(Generator, odeConstVarOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_const_var_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -698,13 +698,13 @@ TEST(Generator, odeConstVarOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_const_var_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -733,13 +733,13 @@ TEST(Generator, odeConstantOnRhs) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_constant_on_rhs/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -767,13 +767,13 @@ TEST(Generator, odeConstantOnRhsOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_constant_on_rhs_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -801,13 +801,13 @@ TEST(Generator, odeMultipleDependentOdes) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_multiple_dependent_odes/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -836,13 +836,13 @@ TEST(Generator, odeMultipleDependentOdesOneComponent) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_multiple_dependent_odes_one_component/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -871,13 +871,13 @@ TEST(Generator, odeMultipleOdesWithSameName) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/ode_multiple_odes_with_same_name/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -906,13 +906,13 @@ TEST(Generator, cellmlMappingsAndEncapsulations) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/cellml_mappings_and_encapsulations/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -941,13 +941,13 @@ TEST(Generator, dependentEqns) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/dependent_eqns/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -976,13 +976,13 @@ TEST(Generator, fabbriFantiniWildersSeveriHumanSanModel2017) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -1011,13 +1011,13 @@ TEST(Generator, garnyKohlHunterBoyettNobleRabbitSanModel2003) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -1046,13 +1046,13 @@ TEST(Generator, hodgkinHuxleySquidAxonModel1952) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -1106,13 +1106,13 @@ TEST(Generator, nobleModel1962) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/noble_model_1962/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); @@ -1141,13 +1141,13 @@ TEST(Generator, coverage) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(fileContents("generator/coverage/model.cellml")); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); libcellml::GeneratorPtr generator = libcellml::Generator::create(); generator->processModel(model); - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); EXPECT_EQ(libcellml::Generator::ModelType::ODE, generator->modelType()); diff --git a/tests/isolated/generator.cpp b/tests/isolated/generator.cpp index 765966ca5..f36dad72b 100644 --- a/tests/isolated/generator.cpp +++ b/tests/isolated/generator.cpp @@ -198,7 +198,7 @@ TEST(Generator, isolatedFirstOrderModel) // 4.c Validate the final arrangement. No issues are expected at this stage. libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); // 5.a Create a Generator instance. By default the options set in the // generator constructor are: @@ -209,5 +209,5 @@ TEST(Generator, isolatedFirstOrderModel) generator->processModel(model); // 5.b Check whether the generator has encountered any issues. - EXPECT_EQ(size_t(0), generator->errorCount()); + EXPECT_EQ(size_t(0), generator->issueCount()); } diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index 2073198e4..2b8aa80c7 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -19,7 +19,7 @@ limitations under the License-> #include -TEST(Issue, createModelError) +TEST(Issue, createModelIssue) { libcellml::ModelPtr m = libcellml::Model::create(); libcellml::IssuePtr e = libcellml::Issue::create(m); @@ -27,7 +27,7 @@ TEST(Issue, createModelError) EXPECT_EQ(libcellml::Issue::Cause::MODEL, e->cause()); } -TEST(Issue, createComponentError) +TEST(Issue, createComponentIssue) { libcellml::ComponentPtr c = libcellml::Component::create(); libcellml::IssuePtr e = libcellml::Issue::create(c); @@ -35,7 +35,7 @@ TEST(Issue, createComponentError) EXPECT_EQ(libcellml::Issue::Cause::COMPONENT, e->cause()); } -TEST(Issue, createVariableError) +TEST(Issue, createVariableIssue) { libcellml::VariablePtr v = libcellml::Variable::create(); libcellml::IssuePtr e = libcellml::Issue::create(v); @@ -43,7 +43,7 @@ TEST(Issue, createVariableError) EXPECT_EQ(libcellml::Issue::Cause::VARIABLE, e->cause()); } -TEST(Issue, createUnitsError) +TEST(Issue, createUnitsIssue) { libcellml::UnitsPtr u = libcellml::Units::create(); libcellml::IssuePtr e = libcellml::Issue::create(u); @@ -51,7 +51,7 @@ TEST(Issue, createUnitsError) EXPECT_EQ(libcellml::Issue::Cause::UNITS, e->cause()); } -TEST(Issue, createImportSourceError) +TEST(Issue, createImportSourceIssue) { libcellml::ImportSourcePtr i = libcellml::ImportSource::create(); libcellml::IssuePtr e = libcellml::Issue::create(i); @@ -59,7 +59,7 @@ TEST(Issue, createImportSourceError) EXPECT_EQ(libcellml::Issue::Cause::IMPORT, e->cause()); } -TEST(Issue, createResetError) +TEST(Issue, createResetIssue) { libcellml::ResetPtr r = libcellml::Reset::create(); libcellml::IssuePtr e = libcellml::Issue::create(r); diff --git a/tests/logger/logger.cpp b/tests/logger/logger.cpp index 3b6723427..8fdc1f162 100644 --- a/tests/logger/logger.cpp +++ b/tests/logger/logger.cpp @@ -20,47 +20,47 @@ limitations under the License. TEST(Logger, addError) { - auto err = libcellml::Issue::create(); - err->setLevel(libcellml::Issue::Level::ERROR); + auto issue = libcellml::Issue::create(); + issue->setLevel(libcellml::Issue::Level::ERROR); auto logger = libcellml::Validator::create(); - logger->addIssue(err); + logger->addIssue(issue); EXPECT_EQ(size_t(1), logger->issueCount()); EXPECT_EQ(size_t(1), logger->errorCount()); EXPECT_EQ(size_t(0), logger->warningCount()); EXPECT_EQ(size_t(0), logger->hintCount()); - EXPECT_EQ(logger->error(0), err); - EXPECT_EQ(logger->issue(0), err); + EXPECT_EQ(logger->error(0), issue); + EXPECT_EQ(logger->issue(0), issue); } TEST(Logger, addWarning) { - auto err = libcellml::Issue::create(); - err->setLevel(libcellml::Issue::Level::WARNING); + auto issue = libcellml::Issue::create(); + issue->setLevel(libcellml::Issue::Level::WARNING); auto logger = libcellml::Validator::create(); - logger->addIssue(err); + logger->addIssue(issue); EXPECT_EQ(size_t(1), logger->issueCount()); EXPECT_EQ(size_t(0), logger->errorCount()); EXPECT_EQ(size_t(1), logger->warningCount()); EXPECT_EQ(size_t(0), logger->hintCount()); - EXPECT_EQ(logger->warning(0), err); - EXPECT_EQ(logger->issue(0), err); + EXPECT_EQ(logger->warning(0), issue); + EXPECT_EQ(logger->issue(0), issue); } TEST(Logger, addHint) { - auto err = libcellml::Issue::create(); - err->setLevel(libcellml::Issue::Level::HINT); + auto issue = libcellml::Issue::create(); + issue->setLevel(libcellml::Issue::Level::HINT); auto logger = libcellml::Validator::create(); - logger->addIssue(err); + logger->addIssue(issue); EXPECT_EQ(size_t(1), logger->issueCount()); EXPECT_EQ(size_t(0), logger->errorCount()); EXPECT_EQ(size_t(0), logger->warningCount()); EXPECT_EQ(size_t(1), logger->hintCount()); - EXPECT_EQ(logger->hint(0), err); - EXPECT_EQ(logger->issue(0), err); + EXPECT_EQ(logger->hint(0), issue); + EXPECT_EQ(logger->issue(0), issue); } TEST(Logger, getIssueByLevelFunction) diff --git a/tests/parser/file_parser.cpp b/tests/parser/file_parser.cpp index 8db1c8683..377ce6b21 100644 --- a/tests/parser/file_parser.cpp +++ b/tests/parser/file_parser.cpp @@ -30,7 +30,7 @@ TEST(Parser, parseSineModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(fileContents("sine_approximations.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); } TEST(Parser, parseSineImportsModelFromFile) @@ -38,12 +38,12 @@ TEST(Parser, parseSineImportsModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(fileContents("sine_approximations_import.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); } TEST(Parser, parseInvalidModelFromFile) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "LibXml2 error: Start tag expected, '<' not found.", "Could not get a valid XML root node from the provided input.", }; @@ -51,7 +51,7 @@ TEST(Parser, parseInvalidModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(fileContents("invalid_cellml_2.0.xml")); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, parseOrdModelFromFile) @@ -59,7 +59,7 @@ TEST(Parser, parseOrdModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("Ohara_Rudy_2011.cellml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); // Test some random values. std::string a = model->component("intracellular_ions")->variable("BSLmax")->initialValue(); @@ -81,7 +81,7 @@ TEST(Parser, parseComplexEncapsulationModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(fileContents("complex_encapsulation.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); } TEST(Parser, parseModelWithComponentsWithMultipleMathElements) @@ -121,7 +121,7 @@ TEST(Parser, parseModelWithComponentsWithMultipleMathElements) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("a_plus_b.cellml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); std::string a = model->component("c1")->math(); EXPECT_EQ(e1, a); @@ -150,7 +150,7 @@ TEST(Parser, simpleGeneratorModel) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("generator/initialized_variable_of_integration.cellml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); std::string a = model->component("my_component")->math(); EXPECT_EQ(e, a); diff --git a/tests/parser/libxml_user.cpp b/tests/parser/libxml_user.cpp index 83b13ee35..e5b733058 100644 --- a/tests/parser/libxml_user.cpp +++ b/tests/parser/libxml_user.cpp @@ -54,7 +54,7 @@ TEST(Parser, parseInvalidXmlDirectlyUsingLibxml) // parse the string using libcellml libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(e); - EXPECT_NE(size_t(0), parser->errorCount()); + EXPECT_NE(size_t(0), parser->issueCount()); // and now parse directly using libxml2 xmlParserCtxtPtr context = xmlNewParserCtxt(); diff --git a/tests/parser/parser.cpp b/tests/parser/parser.cpp index e498f4342..32897536f 100644 --- a/tests/parser/parser.cpp +++ b/tests/parser/parser.cpp @@ -34,7 +34,7 @@ TEST(Parser, invalidXMLElements) " Gandalf\n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Specification mandate value for attribute bearded.", "Specification mandates value for attribute bearded.", "LibXml2 error: Opening and ending tag mismatch: Dwarf line 3 and ShortGuy.", @@ -48,13 +48,13 @@ TEST(Parser, invalidXMLElements) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(input); - EXPECT_EQ(expectedErrors.size() - 1, p->errorCount()); - for (size_t i = 0; i < p->errorCount(); ++i) { + EXPECT_EQ(expectedIssues.size() - 1, p->issueCount()); + for (size_t i = 0; i < p->issueCount(); ++i) { if (i == 0) { - EXPECT_TRUE((p->error(i)->description() != expectedErrors.at(0)) - || (p->error(i)->description() != expectedErrors.at(1))); + EXPECT_TRUE((p->issue(i)->description() != expectedIssues.at(0)) + || (p->issue(i)->description() != expectedIssues.at(1))); } else { - EXPECT_EQ(expectedErrors.at(i + 1), p->error(i)->description()); + EXPECT_EQ(expectedIssues.at(i + 1), p->issue(i)->description()); } } } @@ -88,7 +88,7 @@ TEST(Parser, parseNamedModel) EXPECT_EQ(e, a); } -TEST(Parser, makeError) +TEST(Parser, makeIssue) { const std::string ex; @@ -100,26 +100,26 @@ TEST(Parser, makeError) TEST(Parser, emptyModelString) { const std::string e; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Model is empty.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(e); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, nonXmlString) { const std::string ex = "Not an xml string."; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "LibXml2 error: Start tag expected, '<' not found.", "Could not get a valid XML root node from the provided input.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, invalidRootNode) @@ -128,13 +128,13 @@ TEST(Parser, invalidRootNode) "\n" "\n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Model element is of invalid type 'yodel'. A valid CellML root node should be of type 'model'.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, noModelNamespace) @@ -142,13 +142,13 @@ TEST(Parser, noModelNamespace) const std::string ex = "\n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Model element is in invalid namespace 'null'. A valid CellML root node should be in namespace 'http://www.cellml.org/cellml/2.0#'.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, invalidModelNamespace) @@ -156,13 +156,13 @@ TEST(Parser, invalidModelNamespace) const std::string ex = "\n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Model element is in invalid namespace 'http://www.cellml.org/cellml/1.2#'. A valid CellML root node should be in namespace 'http://www.cellml.org/cellml/2.0#'.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, invalidModelAttribute) @@ -170,13 +170,13 @@ TEST(Parser, invalidModelAttribute) const std::string ex = "\n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Model '' has an invalid attribute 'game'.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, invalidModelElement) @@ -186,13 +186,13 @@ TEST(Parser, invalidModelElement) "\n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Model 'model_name' has an invalid child element 'uknits'.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, modelWithInvalidElement) @@ -202,7 +202,7 @@ TEST(Parser, modelWithInvalidElement) "\n" " \n" "\n"; - const std::vector expectedErrors1 = { + const std::vector expectedIssues1 = { "Model 'bilbo' has an invalid child element 'hobbit'.", }; const std::string input2 = @@ -210,40 +210,40 @@ TEST(Parser, modelWithInvalidElement) "\n" " \n" "\n"; - const std::vector expectedErrors2 = { + const std::vector expectedIssues2 = { "Model '' has an invalid child element 'hobbit'.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(input1); - EXPECT_EQ_ERRORS(expectedErrors1, p); + EXPECT_EQ_ISSUES(expectedIssues1, p); p->removeAllIssues(); p->parseModel(input2); - EXPECT_EQ_ERRORS(expectedErrors2, p); + EXPECT_EQ_ISSUES(expectedIssues2, p); } -TEST(Parser, parseModelWithInvalidAttributeAndGetError) +TEST(Parser, parseModelWithInvalidAttributeAndGetIssue) { const std::string input = "\n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Model 'modelName' has an invalid attribute 'nonsense'.", }; libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(input); - EXPECT_EQ_ERRORS(expectedErrors, parser); + EXPECT_EQ_ISSUES(expectedIssues, parser); - // Get ModelError and check. - EXPECT_EQ(model, parser->error(0)->model()); - // Get const modelError and check. - const libcellml::IssuePtr err = parser->error(0); - libcellml::Issue *rawErr = err.get(); - const libcellml::ModelPtr modelFromError = rawErr->model(); - EXPECT_EQ(model, modelFromError); + // Get ModelIssue and check. + EXPECT_EQ(model, parser->issue(0)->model()); + // Get const modelIssue and check. + const libcellml::IssuePtr issue = parser->issue(0); + libcellml::Issue *rawIssue = issue.get(); + const libcellml::ModelPtr modelFromIssue = rawIssue->model(); + EXPECT_EQ(model, modelFromIssue); } TEST(Parser, parseNamedModelWithNamedComponent) @@ -287,23 +287,23 @@ TEST(Parser, parseModelWithUnitsAndNamedComponent) EXPECT_EQ(e, a); } -TEST(Parser, unitsAttributeError) +TEST(Parser, unitsAttributeIssue) { const std::string ex = "\n" "\n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Units 'pH' has an invalid attribute 'invalid_attribute'.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } -TEST(Parser, unitsElementErrors) +TEST(Parser, unitsElementIssues) { const std::string input1 = "\n" @@ -312,7 +312,7 @@ TEST(Parser, unitsElementErrors) " \n" " \n" "\n"; - const std::vector expectedErrors1 = { + const std::vector expectedIssues1 = { "Units '' has an invalid child element 'son'.", }; const std::string input2 = @@ -322,20 +322,20 @@ TEST(Parser, unitsElementErrors) " \n" " \n" "\n"; - const std::vector expectedErrors2 = { + const std::vector expectedIssues2 = { "Units 'randy' has an invalid child element 'son'.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(input1); - EXPECT_EQ_ERRORS(expectedErrors1, p); + EXPECT_EQ_ISSUES(expectedIssues1, p); p->removeAllIssues(); p->parseModel(input2); - EXPECT_EQ_ERRORS(expectedErrors2, p); + EXPECT_EQ_ISSUES(expectedIssues2, p); } -TEST(Parser, parseModelWithNamedComponentWithInvalidBaseUnitsAttributeAndGetError) +TEST(Parser, parseModelWithNamedComponentWithInvalidBaseUnitsAttributeAndGetIssue) { const std::string in = "\n" @@ -344,27 +344,27 @@ TEST(Parser, parseModelWithNamedComponentWithInvalidBaseUnitsAttributeAndGetErro " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Units 'unit_name' has an invalid attribute 'base_unit'.", }; libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(in); - EXPECT_EQ_ERRORS(expectedErrors, parser); + EXPECT_EQ_ISSUES(expectedIssues, parser); libcellml::UnitsPtr unitsExpected = model->units("unit_name"); // Get units from issue and check. - EXPECT_EQ(unitsExpected, parser->error(0)->units()); + EXPECT_EQ(unitsExpected, parser->issue(0)->units()); // Get const units from issue and check. - const libcellml::IssuePtr err = parser->error(0); - const libcellml::UnitsPtr unitsFromError = err->units(); - EXPECT_EQ(unitsExpected, unitsFromError); + const libcellml::IssuePtr issue = parser->issue(0); + const libcellml::UnitsPtr unitsFromIssue = issue->units(); + EXPECT_EQ(unitsExpected, unitsFromIssue); } -TEST(Parser, parseModelWithInvalidComponentAttributeAndGetError) +TEST(Parser, parseModelWithInvalidComponentAttributeAndGetIssue) { const std::string cName = "componentName"; const std::string input = @@ -372,7 +372,7 @@ TEST(Parser, parseModelWithInvalidComponentAttributeAndGetError) "\n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Component 'componentName' has an invalid attribute 'nonsense'.", }; @@ -380,28 +380,28 @@ TEST(Parser, parseModelWithInvalidComponentAttributeAndGetError) libcellml::ModelPtr model = parser->parseModel(input); libcellml::ComponentPtr component = model->component(cName); - EXPECT_EQ_ERRORS(expectedErrors, parser); + EXPECT_EQ_ISSUES(expectedIssues, parser); // Get component from issue and check. - EXPECT_EQ(component, parser->error(0)->component()); + EXPECT_EQ(component, parser->issue(0)->component()); // Get const component from issue and check. - const libcellml::IssuePtr err = parser->error(0); - libcellml::Issue *rawErr = err.get(); - const libcellml::ComponentPtr componentFromError = rawErr->component(); - EXPECT_EQ(component, componentFromError); + const libcellml::IssuePtr issue = parser->issue(0); + libcellml::Issue *rawIssue = issue.get(); + const libcellml::ComponentPtr componentFromIssue = rawIssue->component(); + EXPECT_EQ(component, componentFromIssue); // Get non-existent issue - EXPECT_EQ(nullptr, parser->error(1)); + EXPECT_EQ(nullptr, parser->issue(1)); } -TEST(Parser, componentAttributeErrors) +TEST(Parser, componentAttributeIssues) { const std::string input1 = "\n" "\n" " \n" "\n"; - const std::vector expectedErrors1 = { + const std::vector expectedIssues1 = { "Component '' has an invalid attribute 'lame'.", }; const std::string input2 = @@ -409,7 +409,7 @@ TEST(Parser, componentAttributeErrors) "\n" " \n" "\n"; - const std::vector expectedErrors2 = { + const std::vector expectedIssues2 = { "Component 'randy' has an invalid attribute 'son'.", }; const std::string input3 = @@ -417,24 +417,24 @@ TEST(Parser, componentAttributeErrors) "\n" " \n" "\n"; - const std::vector expectedErrors3 = { + const std::vector expectedIssues3 = { "Component 'randy' has an invalid attribute 'son'.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(input1); - EXPECT_EQ_ERRORS(expectedErrors1, p); + EXPECT_EQ_ISSUES(expectedIssues1, p); p->removeAllIssues(); p->parseModel(input2); - EXPECT_EQ_ERRORS(expectedErrors2, p); + EXPECT_EQ_ISSUES(expectedIssues2, p); p->removeAllIssues(); p->parseModel(input3); - EXPECT_EQ_ERRORS(expectedErrors3, p); + EXPECT_EQ_ISSUES(expectedIssues3, p); } -TEST(Parser, componentElementErrors) +TEST(Parser, componentElementIssues) { const std::string input1 = "\n" @@ -455,13 +455,13 @@ TEST(Parser, componentElementErrors) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(input1); - EXPECT_EQ(size_t(1), p->errorCount()); - EXPECT_EQ(expectError1, p->error(0)->description()); + EXPECT_EQ(size_t(1), p->issueCount()); + EXPECT_EQ(expectError1, p->issue(0)->description()); p->removeAllIssues(); p->parseModel(input2); - EXPECT_EQ(size_t(1), p->errorCount()); - EXPECT_EQ(expectError2, p->error(0)->description()); + EXPECT_EQ(size_t(1), p->issueCount()); + EXPECT_EQ(expectError2, p->issue(0)->description()); } TEST(Parser, parseModelWithTwoComponents) @@ -598,7 +598,7 @@ TEST(Parser, modelWithInvalidUnits) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Units 'fahrenheitish' has an invalid attribute 'temperature'.", "Unit referencing 'kelvin' in units 'fahrenheitish' has an invalid child element 'degrees'.", "Unit referencing 'kelvin' in units 'fahrenheitish' has a multiplier with the value 'Z' that is not a representation of a CellML real valued number.", @@ -613,7 +613,7 @@ TEST(Parser, modelWithInvalidUnits) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(in); - EXPECT_EQ_ERRORS(expectedErrors, parser); + EXPECT_EQ_ISSUES(expectedIssues, parser); libcellml::PrinterPtr printer = libcellml::Printer::create(); const std::string a = printer->printModel(model); @@ -628,13 +628,13 @@ TEST(Parser, emptyEncapsulation) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Encapsulation in model 'model_name' does not contain any child elements.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, validEncapsulation) @@ -655,7 +655,7 @@ TEST(Parser, validEncapsulation) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); } TEST(Parser, encapsulationWithCycleDefined) @@ -678,14 +678,14 @@ TEST(Parser, encapsulationWithCycleDefined) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Model 'model_name' contains multiple components with the name 'bob'. Valid component names must be unique to their model.", }; libcellml::ParserPtr p = libcellml::Parser::create(); auto m = p->parseModel(ex); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); libcellml::PrinterPtr printer = libcellml::Printer::create(); auto output = printer->printModel(m); @@ -694,7 +694,7 @@ TEST(Parser, encapsulationWithCycleDefined) libcellml::ValidatorPtr v = libcellml::Validator::create(); v->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Parser, encapsulationWithNoComponentAttribute) @@ -707,7 +707,7 @@ TEST(Parser, encapsulationWithNoComponentAttribute) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Encapsulation in model 'model_name' does not have a valid component attribute in a component_ref element.", "Encapsulation in model 'model_name' specifies an invalid parent component_ref that also does not have any children.", }; @@ -715,12 +715,12 @@ TEST(Parser, encapsulationWithNoComponentAttribute) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, encapsulationWithNoComponentRef) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Encapsulation in model 'model_name' has an invalid child element 'component_free'.", }; @@ -735,12 +735,12 @@ TEST(Parser, encapsulationWithNoComponentRef) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, encapsulationWithNoComponent) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Encapsulation in model 'model_name' specifies 'bob' as a component in a component_ref but it does not exist in the model.", "Encapsulation in model 'model_name' does not have a valid component attribute in a component_ref element.", "Encapsulation in model 'model_name' specifies an invalid parent component_ref that also does not have any children.", @@ -759,12 +759,12 @@ TEST(Parser, encapsulationWithNoComponent) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, encapsulationWithMissingComponent) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Encapsulation in model 'model_name' specifies 'dave' as a component in a component_ref but it does not exist in the model.", "Encapsulation in model 'model_name' specifies 'bob' as a parent component_ref but it does not have any children.", }; @@ -783,7 +783,7 @@ TEST(Parser, encapsulationWithMissingComponent) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, encapsulationWithNoComponentChild) @@ -796,13 +796,13 @@ TEST(Parser, encapsulationWithNoComponentChild) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Encapsulation in model 'model_name' specifies 'bob' as a parent component_ref but it does not have any children.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, encapsulationNoChildComponentRef) @@ -818,7 +818,7 @@ TEST(Parser, encapsulationNoChildComponentRef) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Encapsulation in model 'model_name' has an invalid child element 'component_free'.", "Encapsulation in model 'model_name' specifies 'bob' as a parent component_ref but it does not have any children.", }; @@ -826,7 +826,7 @@ TEST(Parser, encapsulationNoChildComponentRef) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, encapsulationWithNoGrandchildComponentRef) @@ -845,14 +845,14 @@ TEST(Parser, encapsulationWithNoGrandchildComponentRef) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Encapsulation in model 'model_name' has an invalid child element 'component_free'.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, invalidEncapsulations) @@ -877,7 +877,7 @@ TEST(Parser, invalidEncapsulations) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Encapsulation in model 'ringo' has an invalid attribute 'relationship'.", "Encapsulation in model 'ringo' has an invalid component_ref attribute 'bogus'.", "Encapsulation in model 'ringo' has an invalid component_ref attribute 'bogus'.", @@ -894,10 +894,10 @@ TEST(Parser, invalidEncapsulations) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ_ERRORS(expectedErrors, parser); + EXPECT_EQ_ISSUES(expectedIssues, parser); } -TEST(Parser, invalidVariableAttributesAndGetVariableError) +TEST(Parser, invalidVariableAttributesAndGetVariableIssue) { const std::string in = "\n" @@ -907,29 +907,29 @@ TEST(Parser, invalidVariableAttributesAndGetVariableError) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Variable 'quixote' has an invalid attribute 'don'.", "Variable '' has an invalid attribute 'windmill'.", }; libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(in); - EXPECT_EQ(expectedErrors.size(), p->errorCount()); - for (size_t i = 0; i < p->errorCount(); ++i) { - EXPECT_EQ(expectedErrors.at(i), p->error(i)->description()); + EXPECT_EQ(expectedIssues.size(), p->issueCount()); + for (size_t i = 0; i < p->issueCount(); ++i) { + EXPECT_EQ(expectedIssues.at(i), p->issue(i)->description()); } libcellml::VariablePtr variableExpected = model->component("componentA")->variable("quixote"); // Get variable from issue and check. - EXPECT_EQ(variableExpected, p->error(0)->variable()); + EXPECT_EQ(variableExpected, p->issue(0)->variable()); // Get const variable from issue and check. - libcellml::IssuePtr err = p->error(0); - libcellml::Issue *rawErr = err.get(); - const libcellml::VariablePtr variableFromError = rawErr->variable(); - EXPECT_EQ(variableExpected, variableFromError); + libcellml::IssuePtr issue = p->issue(0); + libcellml::Issue *rawIssue = issue.get(); + const libcellml::VariablePtr variableFromIssue = rawIssue->variable(); + EXPECT_EQ(variableExpected, variableFromIssue); } -TEST(Parser, variableAttributeAndChildErrors) +TEST(Parser, variableAttributeAndChildIssues) { const std::string input1 = "\n" @@ -953,14 +953,14 @@ TEST(Parser, variableAttributeAndChildErrors) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(input1); - EXPECT_EQ(size_t(1), p->errorCount()); - EXPECT_EQ(expectError1, p->error(0)->description()); + EXPECT_EQ(size_t(1), p->issueCount()); + EXPECT_EQ(expectError1, p->issue(0)->description()); p->removeAllIssues(); p->parseModel(input2); - EXPECT_EQ(size_t(2), p->errorCount()); - EXPECT_EQ(expectError2, p->error(0)->description()); - EXPECT_EQ(expectError3, p->error(1)->description()); + EXPECT_EQ(size_t(2), p->issueCount()); + EXPECT_EQ(expectError2, p->issue(0)->description()); + EXPECT_EQ(expectError3, p->issue(1)->description()); } TEST(Parser, emptyConnections) @@ -970,7 +970,7 @@ TEST(Parser, emptyConnections) "\n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Connection in model 'model_name' does not have a valid component_1 in a connection element.", "Connection in model 'model_name' does not have a valid component_2 in a connection element.", "Connection in model 'model_name' must contain one or more 'map_variables' elements.", @@ -978,7 +978,7 @@ TEST(Parser, emptyConnections) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(ex); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, connectionErrorNoComponent2) @@ -993,7 +993,7 @@ TEST(Parser, connectionErrorNoComponent2) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Connection in model 'modelA' does not have a valid component_2 in a connection element.", "Connection in model 'modelA' specifies 'component1' as component_1 but it does not exist in the model.", "Connection in model 'modelA' specifies 'variable1' as variable_1 but the corresponding component_1 is invalid.", @@ -1003,7 +1003,7 @@ TEST(Parser, connectionErrorNoComponent2) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(in); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, connectionErrorNoComponent2InModel) @@ -1018,14 +1018,14 @@ TEST(Parser, connectionErrorNoComponent2InModel) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Connection in model 'modelName' specifies 'component2' as component_2 but it does not exist in the model.", "Connection in model 'modelName' specifies 'variable2' as variable_2 but the corresponding component_2 is invalid.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(in); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, connectionErrorNoComponent1) @@ -1040,7 +1040,7 @@ TEST(Parser, connectionErrorNoComponent1) " \n" "\n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Connection in model 'modelName' does not have a valid component_1 in a connection element.", "Connection in model 'modelName' specifies 'variable1' as variable_1 but the corresponding component_1 is invalid.", "Variable 'variable2' is specified as variable_2 in a connection but it does not exist in component_2 component 'componentA' of model 'modelName'.", @@ -1048,7 +1048,7 @@ TEST(Parser, connectionErrorNoComponent1) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(in); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, connectionErrorNoMapComponents) @@ -1065,7 +1065,7 @@ TEST(Parser, connectionErrorNoMapComponents) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Connection in model 'modelName' has an invalid connection attribute 'name'.", "Connection in model 'modelName' does not have a valid component_1 in a connection element.", "Connection in model 'modelName' does not have a valid component_2 in a connection element.", @@ -1077,7 +1077,7 @@ TEST(Parser, connectionErrorNoMapComponents) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(in); - EXPECT_EQ_ERRORS(expectedErrors, parser); + EXPECT_EQ_ISSUES(expectedIssues, parser); } TEST(Parser, connectionErrorNoMapVariables) @@ -1091,7 +1091,7 @@ TEST(Parser, connectionErrorNoMapVariables) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Connection in model '' has an invalid connection attribute 'component_3'.", "Connection in model '' must contain one or more 'map_variables' elements.", "Connection in model '' must contain one or more 'map_variables' elements.", @@ -1099,7 +1099,7 @@ TEST(Parser, connectionErrorNoMapVariables) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(in); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, importedComponent2Connection) @@ -1121,7 +1121,7 @@ TEST(Parser, importedComponent2Connection) // Parse libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, validConnectionMapVariablesFirst) @@ -1142,7 +1142,7 @@ TEST(Parser, validConnectionMapVariablesFirst) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, component2ConnectionVariableMissing) @@ -1160,14 +1160,14 @@ TEST(Parser, component2ConnectionVariableMissing) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Variable 'variable_angus' is specified as variable_2 in a connection but it does not exist in component_2 component 'component_dave' of model ''.", }; // Parse libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(e); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, component2InConnectionMissing) @@ -1196,7 +1196,7 @@ TEST(Parser, component2InConnectionMissing) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Connection in model '' does not have a valid component_2 in a connection element.", "Connection in model '' specifies 'variable_angus' as variable_2 but the corresponding component_2 is invalid.", }; @@ -1204,7 +1204,7 @@ TEST(Parser, component2InConnectionMissing) // Parse libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr m = p->parseModel(in); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); libcellml::PrinterPtr printer = libcellml::Printer::create(); const std::string a = printer->printModel(m); @@ -1227,14 +1227,14 @@ TEST(Parser, connectionVariable2Missing) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Connection in model '' does not have a valid variable_2 in a map_variables element.", }; // Parse libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(e); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, connectionVariable1Missing) @@ -1252,14 +1252,14 @@ TEST(Parser, connectionVariable1Missing) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Connection in model '' does not have a valid variable_1 in a map_variables element.", }; // Parse libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(e); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, connectionErrorNoMapVariablesType) @@ -1277,17 +1277,17 @@ TEST(Parser, connectionErrorNoMapVariablesType) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Connection in model '' has an invalid child element 'map_variabels'.", "Connection in model '' does not have a map_variables element.", }; libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(in); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } -TEST(Parser, invalidImportsAndGetError) +TEST(Parser, invalidImportsAndGetIssue) { const std::string input = "\n" @@ -1317,11 +1317,11 @@ TEST(Parser, invalidImportsAndGetError) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr m = p->parseModel(input); - EXPECT_EQ(size_t(4), p->errorCount()); - EXPECT_EQ(expectError1, p->error(0)->description()); - EXPECT_EQ(expectError2, p->error(1)->description()); - EXPECT_EQ(expectError3, p->error(2)->description()); - EXPECT_EQ(expectError4, p->error(3)->description()); + EXPECT_EQ(size_t(4), p->issueCount()); + EXPECT_EQ(expectError1, p->issue(0)->description()); + EXPECT_EQ(expectError2, p->issue(1)->description()); + EXPECT_EQ(expectError3, p->issue(2)->description()); + EXPECT_EQ(expectError4, p->issue(3)->description()); libcellml::PrinterPtr printer = libcellml::Printer::create(); const std::string a = printer->printModel(m); @@ -1329,17 +1329,17 @@ TEST(Parser, invalidImportsAndGetError) libcellml::ImportSourcePtr import = m->units("units_in_this_model")->importSource(); // Get import from issue and check. - EXPECT_EQ(import, p->error(0)->importSource()); + EXPECT_EQ(import, p->issue(0)->importSource()); // Get const import from issue and check. - const libcellml::IssuePtr err = p->error(0); - libcellml::Issue *rawErr = err.get(); - const libcellml::ImportSourcePtr importFromError = rawErr->importSource(); - EXPECT_EQ(import, importFromError); + const libcellml::IssuePtr issue = p->issue(0); + libcellml::Issue *rawIssue = issue.get(); + const libcellml::ImportSourcePtr importFromIssue = rawIssue->importSource(); + EXPECT_EQ(import, importFromIssue); } -TEST(Parser, invalidModelWithAllCausesOfErrors) +TEST(Parser, invalidModelWithAllCausesOfIssues) { - // Check for all kinds of issues. + // Check for all causes of issues. std::vector foundCause(9, false); // Trigger CellML entity issues @@ -1355,7 +1355,7 @@ TEST(Parser, invalidModelWithAllCausesOfErrors) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Model 'starwars' has an invalid attribute 'episode'.", "Import from '' has an invalid attribute 'princess'.", "Units '' has an invalid attribute 'jedi'.", @@ -1373,10 +1373,10 @@ TEST(Parser, invalidModelWithAllCausesOfErrors) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ_ERRORS(expectedErrors, parser); + EXPECT_EQ_ISSUES(expectedIssues, parser); - for (size_t i = 0; i < parser->errorCount(); ++i) { - switch (parser->error(i)->cause()) { + for (size_t i = 0; i < parser->issueCount(); ++i) { + switch (parser->issue(i)->cause()) { case libcellml::Issue::Cause::COMPONENT: foundCause.at(0) = true; break; @@ -1407,27 +1407,27 @@ TEST(Parser, invalidModelWithAllCausesOfErrors) } } - // Trigger undefined error + // Trigger undefined issue libcellml::ParserPtr parser2 = libcellml::Parser::create(); - // Add an undefined error - libcellml::IssuePtr undefinedError = libcellml::Issue::create(); - parser2->addIssue(undefinedError); - EXPECT_EQ(size_t(1), parser2->errorCount()); - if (parser2->error(0)->isCause(libcellml::Issue::Cause::UNDEFINED)) { + // Add an undefined issue + libcellml::IssuePtr undefinedIssue = libcellml::Issue::create(); + parser2->addIssue(undefinedIssue); + EXPECT_EQ(size_t(1), parser2->issueCount()); + if (parser2->issue(0)->isCause(libcellml::Issue::Cause::UNDEFINED)) { foundCause.at(7) = true; } - // Trigger an XML error + // Trigger an XML issue const std::string input3 = "jarjarbinks"; - const std::vector expectedErrors3 = { + const std::vector expectedIssues3 = { "LibXml2 error: Start tag expected, '<' not found.", "Could not get a valid XML root node from the provided input.", }; libcellml::ParserPtr parser3 = libcellml::Parser::create(); parser3->parseModel(input3); - EXPECT_EQ_ERRORS(expectedErrors3, parser3); - for (size_t i = 0; i < parser3->errorCount(); ++i) { - if (parser3->error(i)->isCause(libcellml::Issue::Cause::XML)) { + EXPECT_EQ_ISSUES(expectedIssues3, parser3); + for (size_t i = 0; i < parser3->issueCount(); ++i) { + if (parser3->issue(i)->isCause(libcellml::Issue::Cause::XML)) { foundCause.at(8) = true; } } @@ -1475,7 +1475,7 @@ TEST(Parser, invalidModelWithTextInAllElements) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Model 'starwars' has an invalid non-whitespace child text element '\n episode7\n '.", "Import from 'sith.xml' has an invalid non-whitespace child text element '\n kylo\n '.", "Units 'robot' has an invalid non-whitespace child text element '\n bb-8\n '.", @@ -1499,7 +1499,7 @@ TEST(Parser, invalidModelWithTextInAllElements) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ_ERRORS(expectedErrors, parser); + EXPECT_EQ_ISSUES(expectedIssues, parser); } TEST(Parser, parseIds) @@ -1523,7 +1523,7 @@ TEST(Parser, parseIds) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(input); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_EQ("mid", model->id()); EXPECT_EQ("c1id", model->component("component1")->id()); EXPECT_EQ("i1id", model->component("component1")->importSource()->id()); @@ -1591,7 +1591,7 @@ TEST(Parser, parseIdsOnEverythingButMath) libcellml::ParserPtr parser = libcellml::Parser::create(); libcellml::ModelPtr model = parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); EXPECT_EQ("mid", model->id()); EXPECT_EQ("c1id", model->component("component1")->id()); EXPECT_EQ("i1id", model->component("component1")->importSource()->id()); @@ -1662,7 +1662,7 @@ TEST(Parser, parseResets) EXPECT_EQ(rt, resetValueString); } -TEST(Parser, parseResetsWithErrors) +TEST(Parser, parseResetsWithIssues) { const std::string input = "\n" @@ -1731,7 +1731,7 @@ TEST(Parser, parseResetsWithErrors) " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Reset referencing variable 'variable3' is not a valid reference for a variable in component 'component2'.", "Reset referencing test_variable 'variable1' is not a valid reference for a variable in component 'component2'.", "Reset in component 'component2' referencing variable '' and test_variable '' has an unexpected attribute in the test_value block of 'one_invalid_attribute'.", @@ -1753,9 +1753,9 @@ TEST(Parser, parseResetsWithErrors) libcellml::ResetPtr resetExpected = model->component(1)->reset(0); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); - EXPECT_EQ(resetExpected, p->error(0)->reset()); + EXPECT_EQ(resetExpected, p->issue(0)->reset()); } TEST(Parser, unitsWithCellMLRealVariations) @@ -1844,7 +1844,7 @@ TEST(Parser, xmlComments) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, mathWithNamespacesDefinedOnTheMathNode) @@ -1870,7 +1870,7 @@ TEST(Parser, mathWithNamespacesDefinedOnTheMathNode) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, mathWithNamespacesDefinedOnTheNodeThatUsesNamespace) @@ -1896,7 +1896,7 @@ TEST(Parser, mathWithNamespacesDefinedOnTheNodeThatUsesNamespace) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, mathWithNonStandardCellMLPrefix) @@ -1922,7 +1922,7 @@ TEST(Parser, mathWithNonStandardCellMLPrefix) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, mathWithMathmlNamespaceOnModel) @@ -1948,7 +1948,7 @@ TEST(Parser, mathWithMathmlNamespaceOnModel) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(input); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Parser, repeatedMathParsePrintBehaviour) diff --git a/tests/printer/printer.cpp b/tests/printer/printer.cpp index 35366747d..1e30d9afd 100644 --- a/tests/printer/printer.cpp +++ b/tests/printer/printer.cpp @@ -219,7 +219,7 @@ TEST(Printer, printModelWithImports) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("sine_approximations_import.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); libcellml::PrinterPtr printer = libcellml::Printer::create(); diff --git a/tests/resolve_imports/file_parser.cpp b/tests/resolve_imports/file_parser.cpp index 475e20e5c..85029deae 100644 --- a/tests/resolve_imports/file_parser.cpp +++ b/tests/resolve_imports/file_parser.cpp @@ -31,7 +31,7 @@ TEST(ResolveImports, resolveSineModelFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("sine_approximations.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_FALSE(model->hasUnresolvedImports()); } @@ -39,7 +39,7 @@ TEST(ResolveImports, resolveSineImportsModelFromFile) { libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("sine_approximations_import.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -50,7 +50,7 @@ TEST(ResolveImports, resolveComplexImportsModelFromFile) { libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("complex_imports.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -62,7 +62,7 @@ TEST(ResolveImports, resolveUnitsImportFromFile) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("import_units_model.cellml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -74,7 +74,7 @@ TEST(ResolveImports, resolveImportsFromFileLevel0) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("level0.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -86,7 +86,7 @@ TEST(ResolveImports, resolveImportsFromFileLevel0Unresolvable) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(fileContents("level0-broken-imports.xml")); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); @@ -112,7 +112,7 @@ TEST(ResolveImports, componentNotInResolvingModel) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr model = p->parseModel(modelImportingComponent); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); EXPECT_TRUE(model->hasUnresolvedImports()); model->resolveImports(resourcePath()); diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp index 71c8bd4f3..42a2bceb7 100644 --- a/tests/test_utils.cpp +++ b/tests/test_utils.cpp @@ -58,14 +58,6 @@ void printIssues(const libcellml::LoggerPtr &l, bool headings, bool causes, bool } } -void expectEqualErrors(const std::vector &issues, const libcellml::LoggerPtr &logger) -{ - EXPECT_EQ(issues.size(), logger->errorCount()); - for (size_t i = 0; i < logger->errorCount() && i < issues.size(); ++i) { - EXPECT_EQ(issues.at(i), logger->error(i)->description()); - } -} - void expectEqualIssues(const std::vector &issues, const libcellml::LoggerPtr &logger) { EXPECT_EQ(issues.size(), logger->issueCount()); @@ -74,27 +66,27 @@ void expectEqualIssues(const std::vector &issues, const libcellml:: } } -void expectEqualErrorsSpecificationHeadings(const std::vector &issues, +void expectEqualIssuesSpecificationHeadings(const std::vector &issues, const std::vector &specificationHeadings, const libcellml::LoggerPtr &logger) { - EXPECT_EQ(issues.size(), logger->errorCount()); - EXPECT_EQ(specificationHeadings.size(), logger->errorCount()); - for (size_t i = 0; i < logger->errorCount() && i < issues.size(); ++i) { - EXPECT_EQ(issues.at(i), logger->error(i)->description()); - EXPECT_EQ(specificationHeadings.at(i), logger->error(i)->referenceHeading()); + EXPECT_EQ(issues.size(), logger->issueCount()); + EXPECT_EQ(specificationHeadings.size(), logger->issueCount()); + for (size_t i = 0; i < logger->issueCount() && i < issues.size(); ++i) { + EXPECT_EQ(issues.at(i), logger->issue(i)->description()); + EXPECT_EQ(specificationHeadings.at(i), logger->issue(i)->referenceHeading()); } } -void expectEqualErrorsCauses(const std::vector &issues, +void expectEqualIssuesCauses(const std::vector &issues, const std::vector &causes, const libcellml::LoggerPtr &logger) { - EXPECT_EQ(issues.size(), logger->errorCount()); - EXPECT_EQ(causes.size(), logger->errorCount()); - for (size_t i = 0; i < logger->errorCount() && i < issues.size(); ++i) { - EXPECT_EQ(issues.at(i), logger->error(i)->description()); - EXPECT_EQ(causes.at(i), logger->error(i)->cause()); + EXPECT_EQ(issues.size(), logger->issueCount()); + EXPECT_EQ(causes.size(), logger->issueCount()); + for (size_t i = 0; i < logger->issueCount() && i < issues.size(); ++i) { + EXPECT_EQ(issues.at(i), logger->issue(i)->description()); + EXPECT_EQ(causes.at(i), logger->issue(i)->cause()); } } diff --git a/tests/test_utils.h b/tests/test_utils.h index 10f11ba5f..b9173b580 100644 --- a/tests/test_utils.h +++ b/tests/test_utils.h @@ -79,14 +79,12 @@ std::string TEST_EXPORT fileContents(const std::string &fileName); void TEST_EXPORT printIssues(const libcellml::LoggerPtr &l, bool headings = false, bool causes = false, bool rule = false); -void TEST_EXPORT expectEqualErrors(const std::vector &issues, - const libcellml::LoggerPtr &logger); void TEST_EXPORT expectEqualIssues(const std::vector &issues, const libcellml::LoggerPtr &logger); -void TEST_EXPORT expectEqualErrorsSpecificationHeadings(const std::vector &issues, +void TEST_EXPORT expectEqualIssuesSpecificationHeadings(const std::vector &issues, const std::vector &specificationHeadings, const libcellml::LoggerPtr &logger); -void TEST_EXPORT expectEqualErrorsCauses(const std::vector &issues, +void TEST_EXPORT expectEqualIssuesCauses(const std::vector &issues, const std::vector &causes, const libcellml::LoggerPtr &logger); @@ -99,14 +97,10 @@ libcellml::ModelPtr TEST_EXPORT createModelTwoComponentsWithOneVariableEach(cons SCOPED_TRACE("Issue occured here."); \ expectEqualIssues(issues, logger) -#define EXPECT_EQ_ERRORS(issues, logger) \ - SCOPED_TRACE("Issue occured here."); \ - expectEqualErrors(issues, logger) - -#define EXPECT_EQ_ERRORS_SPECIFICATION_HEADINGS(issues, specificationHeadings, logger) \ +#define EXPECT_EQ_ISSUES_SPECIFICATION_HEADINGS(issues, specificationHeadings, logger) \ SCOPED_TRACE("Issue occured here."); \ - expectEqualErrorsSpecificationHeadings(issues, specificationHeadings, logger) + expectEqualIssuesSpecificationHeadings(issues, specificationHeadings, logger) -#define EXPECT_EQ_ERRORS_KINDS(issues, causes, logger) \ +#define EXPECT_EQ_ISSUES_KINDS(issues, causes, logger) \ SCOPED_TRACE("Issue occured here."); \ - expectEqualErrorsCauses(issues, causes, logger) + expectEqualIssuesCauses(issues, causes, logger) diff --git a/tests/units/units.cpp b/tests/units/units.cpp index f26497584..74fd06340 100644 --- a/tests/units/units.cpp +++ b/tests/units/units.cpp @@ -788,8 +788,8 @@ TEST(Units, unitsWithPrefixOutOfRange) validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->errorCount()); - EXPECT_EQ(e, validator->error(0)->description()); + EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(e, validator->issue(0)->description()); } TEST(Units, parentOfUnits) diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 916fce6b6..b3f6f0635 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -31,12 +31,12 @@ TEST(Validator, namedModel) libcellml::ModelPtr model = libcellml::Model::create(); model->setName("awesomeName"); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unnamedModel) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "CellML identifiers must contain one or more basic Latin alphabetic characters.", "Model does not have a valid name attribute.", }; @@ -47,12 +47,12 @@ TEST(Validator, unnamedModel) libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr model = libcellml::Model::create(); validator->validateModel(model); - EXPECT_EQ_ERRORS_SPECIFICATION_HEADINGS(expectedErrors, expectedSpecificationHeadings, validator); + EXPECT_EQ_ISSUES_SPECIFICATION_HEADINGS(expectedIssues, expectedSpecificationHeadings, validator); } TEST(Validator, invalidCellMLIdentifiersWithSpecificationHeading) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "CellML identifiers must not begin with a European numeric character [0-9].", "Model does not have a valid name attribute.", "CellML identifiers must not contain any characters other than [a-zA-Z0-9_].", @@ -99,12 +99,12 @@ TEST(Validator, invalidCellMLIdentifiersWithSpecificationHeading) v->validateModel(model); - EXPECT_EQ_ERRORS_SPECIFICATION_HEADINGS(expectedErrors, expectedSpecificationHeadings, v); + EXPECT_EQ_ISSUES_SPECIFICATION_HEADINGS(expectedIssues, expectedSpecificationHeadings, v); } TEST(Validator, namedModelWithUnnamedComponent) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "CellML identifiers must contain one or more basic Latin alphabetic characters.", "Component does not have a valid name attribute.", }; @@ -114,12 +114,12 @@ TEST(Validator, namedModelWithUnnamedComponent) model->setName("awesomeName"); model->addComponent(component); validator->validateModel(model); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unnamedModelWithUnnamedComponentWithUnnamedUnits) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "CellML identifiers must contain one or more basic Latin alphabetic characters.", "Model does not have a valid name attribute.", "CellML identifiers must contain one or more basic Latin alphabetic characters.", @@ -136,12 +136,12 @@ TEST(Validator, unnamedModelWithUnnamedComponentWithUnnamedUnits) model->addUnits(units); validator->validateModel(model); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, modelWithDuplicateComponentsAndUnits) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Model 'multiplicity' contains multiple components with the name 'michael'. Valid component names must be unique to their model.", "Model 'multiplicity' contains multiple units with the name 'keaton'. Valid units names must be unique to their model.", }; @@ -164,12 +164,12 @@ TEST(Validator, modelWithDuplicateComponentsAndUnits) u2->setName("keaton"); validator->validateModel(model); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unnamedAndDuplicateNamedVariablesWithAndWithoutValidUnits) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Component 'fargo' contains multiple variables with the name 'margie'. Valid variable names must be unique to their component.", "CellML identifiers must not begin with a European numeric character [0-9].", "Variable does not have a valid name attribute.", @@ -202,12 +202,12 @@ TEST(Validator, unnamedAndDuplicateNamedVariablesWithAndWithoutValidUnits) v4->setUnits("dollars"); validator->validateModel(model); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, invalidVariableInitialValuesAndInterfaces) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Variable 'candidate' has an invalid interface attribute value 'orange'.", "Variable 'candidate' has an invalid initial value 'trump'. Initial values must be a real number string or a variable reference.", }; @@ -228,12 +228,12 @@ TEST(Validator, invalidVariableInitialValuesAndInterfaces) validator->validateModel(model); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, importUnits) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "CellML identifiers must contain one or more basic Latin alphabetic characters.", "Imported units 'invalid_imported_units_in_this_model' does not have a valid units_ref attribute.", "Import of units 'invalid_imported_units_in_this_model' does not have a valid locator xlink:href attribute.", @@ -254,7 +254,7 @@ TEST(Validator, importUnits) importedUnits->setSourceUnits(imp, "units_in_that_model"); m->addUnits(importedUnits); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); // Invalid units import- missing refs libcellml::ImportSourcePtr imp2 = libcellml::ImportSource::create(); @@ -263,7 +263,7 @@ TEST(Validator, importUnits) importedUnits2->setSourceUnits(imp2, ""); m->addUnits(importedUnits2); v->validateModel(m); - EXPECT_EQ(size_t(3), v->errorCount()); + EXPECT_EQ(size_t(3), v->issueCount()); // Invalid units import - duplicate refs libcellml::ImportSourcePtr imp3 = libcellml::ImportSource::create(); @@ -273,7 +273,7 @@ TEST(Validator, importUnits) importedUnits3->setSourceUnits(imp3, "units_in_that_model"); m->addUnits(importedUnits3); v->validateModel(m); - EXPECT_EQ(size_t(4), v->errorCount()); + EXPECT_EQ(size_t(4), v->issueCount()); // Invalid units import - unnamed units libcellml::ImportSourcePtr imp4 = libcellml::ImportSource::create(); @@ -284,12 +284,12 @@ TEST(Validator, importUnits) v->validateModel(m); // Check for expected error messages - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, importComponents) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "CellML identifiers must contain one or more basic Latin alphabetic characters.", "Imported component 'invalid_imported_component_in_this_model' does not have a valid component_ref attribute.", "Import of component 'invalid_imported_component_in_this_model' does not have a valid locator xlink:href attribute.", @@ -310,7 +310,7 @@ TEST(Validator, importComponents) importedComponent->setSourceComponent(imp, "component_in_that_model"); m->addComponent(importedComponent); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); // Another valid component import libcellml::ImportSourcePtr imp2 = libcellml::ImportSource::create(); @@ -320,7 +320,7 @@ TEST(Validator, importComponents) importedComponent2->setSourceComponent(imp2, "new_shiny_component_ref"); m->addComponent(importedComponent2); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); // Invalid component import - missing ref to source component libcellml::ImportSourcePtr imp3 = libcellml::ImportSource::create(); @@ -329,7 +329,7 @@ TEST(Validator, importComponents) importedComponent3->setSourceComponent(imp3, ""); m->addComponent(importedComponent3); v->validateModel(m); - EXPECT_EQ(size_t(3), v->errorCount()); + EXPECT_EQ(size_t(3), v->issueCount()); // Valid component import - two components imported from the same place is allowed libcellml::ImportSourcePtr imp4 = libcellml::ImportSource::create(); @@ -339,7 +339,7 @@ TEST(Validator, importComponents) importedComponent4->setSourceComponent(imp4, "component_in_that_model"); m->addComponent(importedComponent4); v->validateModel(m); - EXPECT_EQ(size_t(3), v->errorCount()); + EXPECT_EQ(size_t(3), v->issueCount()); // Invalid - name missing from component libcellml::ImportSourcePtr imp5 = libcellml::ImportSource::create(); @@ -348,7 +348,7 @@ TEST(Validator, importComponents) importedComponent5->setSourceComponent(imp5, "component_in_that_model"); m->addComponent(importedComponent5); v->validateModel(m); - EXPECT_EQ(size_t(5), v->errorCount()); + EXPECT_EQ(size_t(5), v->issueCount()); // Valid - two components from the same source is allowed libcellml::ImportSourcePtr imp7 = libcellml::ImportSource::create(); @@ -358,7 +358,7 @@ TEST(Validator, importComponents) importedComponent7->setSourceComponent(imp7, "new_shiny_component_ref"); m->addComponent(importedComponent7); v->validateModel(m); - EXPECT_EQ(size_t(5), v->errorCount()); + EXPECT_EQ(size_t(5), v->issueCount()); // Valid - duplicate component_ref from a different source libcellml::ImportSourcePtr imp8 = libcellml::ImportSource::create(); @@ -368,7 +368,7 @@ TEST(Validator, importComponents) importedComponent8->setSourceComponent(imp8, "component_in_that_model"); m->addComponent(importedComponent8); v->validateModel(m); - EXPECT_EQ(size_t(5), v->errorCount()); + EXPECT_EQ(size_t(5), v->issueCount()); // Invalid: component_ref url is not valid html libcellml::ImportSourcePtr imp9 = libcellml::ImportSource::create(); @@ -380,7 +380,7 @@ TEST(Validator, importComponents) v->validateModel(m); // Check for expected error messages - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, validMath) @@ -423,7 +423,7 @@ TEST(Validator, validMath) m->addComponent(c); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); } TEST(Validator, invalidMath) @@ -433,7 +433,7 @@ TEST(Validator, invalidMath) " \n" "\n"; const std::string math2 = "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "LibXml2 error: Opening and ending tag mismatch: invalid_xml line 2 and not_valid.", "Could not get a valid XML root node from the math on component 'componentName1'.", "Math root node is of invalid type 'invalid_math' on component 'componentName2'. A valid math root node should be of type 'math'.", @@ -455,7 +455,7 @@ TEST(Validator, invalidMath) v->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, invalidMathMLElements) @@ -472,7 +472,7 @@ TEST(Validator, invalidMathMLElements) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Math has a 'equals' element that is not a supported MathML element.", "Math has a 'addition' element that is not a supported MathML element.", "No declaration for element equals.", @@ -509,7 +509,7 @@ TEST(Validator, invalidMathMLElements) // Check for two expected error messages (see note above). for (size_t i = 0; i < 2; ++i) { - EXPECT_EQ(expectedErrors.at(i), v->error(i)->description()); + EXPECT_EQ(expectedIssues.at(i), v->issue(i)->description()); } } @@ -551,7 +551,7 @@ TEST(Validator, invalidMathMLVariables) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Math has a 'partialdiff' element that is not a supported MathML element.", "Math has a 'nonsense' element that is not a supported MathML element.", "MathML ci element has the child text 'answer' which does not correspond with any variable names present in component 'componentName'.", @@ -586,7 +586,7 @@ TEST(Validator, invalidMathMLVariables) v->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, invalidSimpleMathmlCellMLUnits) @@ -599,7 +599,7 @@ TEST(Validator, invalidSimpleMathmlCellMLUnits) " \n" " \n" ""; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "CellML identifiers must contain one or more basic Latin alphabetic characters.", "Model does not have a valid name attribute.", "CellML identifiers must contain one or more basic Latin alphabetic characters.", @@ -616,14 +616,14 @@ TEST(Validator, invalidSimpleMathmlCellMLUnits) m->addComponent(c); v->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, invalidMathmlCellMLNsOnNode) { const std::string math = "B"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "CellML identifiers must contain one or more basic Latin alphabetic characters.", "Model does not have a valid name attribute.", "CellML identifiers must contain one or more basic Latin alphabetic characters.", @@ -640,7 +640,7 @@ TEST(Validator, invalidMathmlCellMLNsOnNode) m->addComponent(c); v->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, invalidMathMLCiAndCnElementsWithCellMLUnits) @@ -681,7 +681,7 @@ TEST(Validator, invalidMathMLCiAndCnElementsWithCellMLUnits) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Math cn element has an invalid attribute type 'value' in the cellml namespace. Attribute 'units' is the only CellML namespace attribute allowed.", "Math has a cn element with a cellml:units attribute 'invalid' that is not a valid reference to units in the model 'modelName' or a standard unit.", "MathML ci element has the child text 'new_bvar' which does not correspond with any variable names present in component 'componentName'.", @@ -718,7 +718,7 @@ TEST(Validator, invalidMathMLCiAndCnElementsWithCellMLUnits) v->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, validMathMLCiAndCnElementsWithCellMLUnits) @@ -766,10 +766,10 @@ TEST(Validator, validMathMLCiAndCnElementsWithCellMLUnits) m->addComponent(c); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); } -TEST(Validator, parseAndValidateInvalidUnitErrors) +TEST(Validator, parseAndValidateInvalidUnitIssues) { const std::string input = "\n" @@ -784,7 +784,7 @@ TEST(Validator, parseAndValidateInvalidUnitErrors) " \n" " \n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Units is named 'ampere' which is a protected standard unit name.", "Units reference 'ned' in units 'stark' is not a valid reference to a local units or a standard unit type.", "CellML identifiers must not contain any characters other than [a-zA-Z0-9_].", @@ -794,16 +794,16 @@ TEST(Validator, parseAndValidateInvalidUnitErrors) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr m = p->parseModel(input); - EXPECT_EQ(size_t(0), p->errorCount()); + EXPECT_EQ(size_t(0), p->issueCount()); libcellml::ValidatorPtr v = libcellml::Validator::create(); v->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, validateInvalidConnectionsVariableWithoutParentComponent) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Variable 'variable2' is an equivalent variable to 'variable1' but 'variable2' has no parent component.", }; libcellml::ModelPtr m = libcellml::Model::create(); @@ -833,7 +833,7 @@ TEST(Validator, validateInvalidConnectionsVariableWithoutParentComponent) libcellml::ValidatorPtr v = libcellml::Validator::create(); v->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, validateInvalidConnectionsDanglingReciprocalEquivalence) @@ -889,7 +889,7 @@ TEST(Validator, validateInvalidConnectionsDanglingReciprocalEquivalence) v1_2->removeAllEquivalences(); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); } TEST(Validator, integerStrings) @@ -970,12 +970,12 @@ TEST(Validator, integerStrings) libcellml::ParserPtr p = libcellml::Parser::create(); libcellml::ModelPtr m = p->parseModel(input); - EXPECT_EQ_ERRORS(expectedParsingErrors, p); + EXPECT_EQ_ISSUES(expectedParsingErrors, p); libcellml::ValidatorPtr v = libcellml::Validator::create(); v->validateModel(m); - EXPECT_EQ_ERRORS(expectedValidationErrors, v); + EXPECT_EQ_ISSUES(expectedValidationErrors, v); } TEST(Validator, resetValid) @@ -1009,7 +1009,7 @@ TEST(Validator, resetValid) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, resetNoVariable) @@ -1046,8 +1046,8 @@ TEST(Validator, resetNoVariable) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->errorCount()); - EXPECT_EQ(expectedError, validator->error(0)->description()); + EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(expectedError, validator->issue(0)->description()); } TEST(Validator, resetNoTestVariable) @@ -1084,8 +1084,8 @@ TEST(Validator, resetNoTestVariable) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->errorCount()); - EXPECT_EQ(expectedError, validator->error(0)->description()); + EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(expectedError, validator->issue(0)->description()); } TEST(Validator, resetNoOrder) @@ -1121,8 +1121,8 @@ TEST(Validator, resetNoOrder) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->errorCount()); - EXPECT_EQ(expectedError, validator->error(0)->description()); + EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(expectedError, validator->issue(0)->description()); } TEST(Validator, resetNoResetValue) @@ -1158,13 +1158,13 @@ TEST(Validator, resetNoResetValue) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->errorCount()); - EXPECT_EQ(expectedError, validator->error(0)->description()); + EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(expectedError, validator->issue(0)->description()); } TEST(Validator, resetNoTestValue) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Reset in component 'comp' with order '7', with variable 'var', with test_variable 'var2', does not have a test_value specified.", }; @@ -1197,12 +1197,12 @@ TEST(Validator, resetNoTestValue) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, resetWhitespaceAsMaths) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Reset in component 'comp' with order '8', with variable 'var', with test_variable 'var2', does not have a test_value specified.", "Reset in component 'comp' with order '8', with variable 'var', with test_variable 'var2', does not have a reset_value specified.", }; @@ -1237,7 +1237,7 @@ TEST(Validator, resetWhitespaceAsMaths) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, resetEmptyMathML) @@ -1273,7 +1273,7 @@ TEST(Validator, resetEmptyMathML) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, resetNegativeOrder) @@ -1308,12 +1308,12 @@ TEST(Validator, resetNegativeOrder) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, resetVariableOutsideComponent) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Reset in component 'c1' with order '1', with variable 'v2', with test_variable 'v1', refers to a variable 'v2' in a different component 'c2'.", "Reset in component 'c2' with order '1', with variable 'v2', with test_variable 'v1', refers to a test_variable 'v1' in a different component 'c1'."}; @@ -1358,7 +1358,7 @@ TEST(Validator, resetVariableOutsideComponent) validator->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, validMathCnElements) @@ -1392,7 +1392,7 @@ TEST(Validator, validMathCnElements) m->addComponent(c); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); } TEST(Validator, validMathCnElementsMissingCellMLNamespace) @@ -1410,7 +1410,7 @@ TEST(Validator, validMathCnElementsMissingCellMLNamespace) " \n" "\n"; - const std::vector expectedErrors { + const std::vector expectedIssues { "LibXml2 error: Namespace prefix cellml for units on cn is not defined.", "LibXml2 error: Namespace prefix cellml for units on cn is not defined.", "CellML identifiers must contain one or more basic Latin alphabetic characters.", @@ -1439,7 +1439,7 @@ TEST(Validator, validMathCnElementsMissingCellMLNamespace) m->addComponent(c); v->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, unitAmericanSpellingOfUnitsRemoved) @@ -1475,7 +1475,7 @@ TEST(Validator, unitAmericanSpellingOfUnitsRemoved) m->addUnits(u1); m->addUnits(u2); - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Units reference 'meter' in units 'testunit2' is not a valid reference to a local units or a standard unit type.", "Variable 'tomayto' has units of 'testunit1' and an equivalent variable 'tomahto' with non-matching units of 'testunit2'. The mismatch is: metre^1.", }; @@ -1484,7 +1484,7 @@ TEST(Validator, unitAmericanSpellingOfUnitsRemoved) libcellml::Variable::addEquivalence(v1, v2); validator->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unitEquivalenceStandardUnitsToBaseUnits) @@ -1555,7 +1555,7 @@ TEST(Validator, unitEquivalenceStandardUnitsToBaseUnits) base->addUnit(baseUnits.first, 0, baseUnits.second, 1.0); } validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } } @@ -1598,7 +1598,7 @@ TEST(Validator, unitEquivalenceBasicDimensionlessUnits) libcellml::Variable::addEquivalence(v1, v2); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unitEquivalenceDimensionlessUnits) @@ -1652,7 +1652,7 @@ TEST(Validator, unitEquivalenceDimensionlessUnits) libcellml::Variable::addEquivalence(v2, v3); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unitEquivalenceMultiplierPrefix) @@ -1702,12 +1702,12 @@ TEST(Validator, unitEquivalenceMultiplierPrefix) libcellml::Variable::addEquivalence(v2, v3); validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unitEquivalenceComplicatedNestedUnits) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Variable 'pjs' has units of 'testunit13' and an equivalent variable 'pajamas' with non-matching units of 'testunit14'. The mismatch is: metre^1, multiplication factor of 10^3.", }; @@ -1791,7 +1791,7 @@ TEST(Validator, unitEquivalenceComplicatedNestedUnits) validator->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) @@ -1863,6 +1863,7 @@ TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) validator->validateModel(model); + EXPECT_EQ(size_t(1), validator->issueCount()); EXPECT_EQ(size_t(0), validator->errorCount()); EXPECT_EQ(size_t(0), validator->hintCount()); EXPECT_EQ(size_t(1), validator->warningCount()); @@ -1871,7 +1872,7 @@ TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) TEST(Validator, unitUserCreatedUnitsBananasAndApples) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Variable 'v1' has units of 'bushell_of_apples' and an equivalent variable 'v2' with non-matching units of 'bunch_of_bananas'. The mismatch is: apple^10, banana^-5.", }; @@ -1908,12 +1909,12 @@ TEST(Validator, unitUserCreatedUnitsBananasAndApples) validator->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unitIllDefinedEquivalentUnits) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "CellML identifiers must contain one or more basic Latin alphabetic characters.", "Variable 'v1' does not have a valid units attribute.", "CellML identifiers must contain one or more basic Latin alphabetic characters.", @@ -1932,12 +1933,12 @@ TEST(Validator, unitIllDefinedEquivalentUnits) validator->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unitStandardUnitsWhichAreBaseUnits) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Variable 'v1' has units of 'metre' and an equivalent variable 'v2' with non-matching units of 'second'. The mismatch is: metre^1, second^-1.", }; @@ -1955,12 +1956,12 @@ TEST(Validator, unitStandardUnitsWhichAreBaseUnits) validator->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unitStandardUnitsWhichAreNotBaseUnits) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Variable 'v1' has units of 'litre' and an equivalent variable 'v2' with non-matching units of 'gram'. The mismatch is: kilogram^-1, metre^3.", }; @@ -1978,12 +1979,12 @@ TEST(Validator, unitStandardUnitsWhichAreNotBaseUnits) validator->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unitMultiplierFactorDifference) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Variable 'v1' has units of 'litre' and an equivalent variable 'v2' with non-matching units of 'big_barrel'. The mismatch is: multiplication factor of 10^-3."}; libcellml::ValidatorPtr validator = libcellml::Validator::create(); @@ -2013,7 +2014,7 @@ TEST(Validator, unitMultiplierFactorDifference) EXPECT_EQ(size_t(1), validator->warningCount()); EXPECT_EQ(size_t(0), validator->hintCount()); - EXPECT_EQ_ISSUES(expectedErrors, validator); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unitStandardMultipliersLitre) @@ -2076,7 +2077,7 @@ TEST(Validator, unitSimpleCycle) // | | // +----------------------------------------+ - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Cyclic units exist: 'grandfather' -> 'child' -> 'father' -> 'grandfather'", }; @@ -2103,13 +2104,13 @@ TEST(Validator, unitSimpleCycle) // Network valid at this stage. v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); // Time loop Grandfather paradox created! u1 no longer a base variable: u1 -> u3 -> u2 -> u1. u1->addUnit("child"); v->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, unitComplexCycle) @@ -2165,7 +2166,7 @@ TEST(Validator, unitComplexCycle) u6->addUnit("mother"); v->validateModel(m); - EXPECT_EQ(size_t(0), v->errorCount()); + EXPECT_EQ(size_t(0), v->issueCount()); // As soon as a dependency of the grandfather on the brotherFromAnotherMother is added, then a // _directed_ loop (u1->u2->u4->u1) is created and the network is no longer valid: @@ -2178,7 +2179,7 @@ TEST(Validator, unitComplexCycle) // <- mother (u3) <-+ // <- sisterFromAnotherFather (u6) - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Cyclic units exist: 'grandfather' -> 'brotherFromAnotherMother' -> 'father' -> 'grandfather'", }; @@ -2186,7 +2187,7 @@ TEST(Validator, unitComplexCycle) u1->addUnit("brotherFromAnotherMother"); v->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, duplicatedCellMLUnitsOnCiElement) @@ -2196,7 +2197,7 @@ TEST(Validator, duplicatedCellMLUnitsOnCiElement) " B\n" "\n"; - const std::vector expectedErrors = { + const std::vector expectedIssues = { "LibXml2 error: Attribute cellml:units redefined.", "Could not get a valid XML root node from the math on component 'componentName'.", }; @@ -2217,7 +2218,7 @@ TEST(Validator, duplicatedCellMLUnitsOnCiElement) v->validateModel(m); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } TEST(Validator, multipleDefinitionsOfCellMLNamespace) @@ -2228,7 +2229,7 @@ TEST(Validator, multipleDefinitionsOfCellMLNamespace) libcellml::ValidatorPtr validator = libcellml::Validator::create(); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, validateModelWithoutAndWithMath) @@ -2255,7 +2256,7 @@ TEST(Validator, validateModelWithoutAndWithMath) c3->addVariable(v); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); const std::string math = "\n" @@ -2269,7 +2270,7 @@ TEST(Validator, validateModelWithoutAndWithMath) c3->setMath(math); validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); } TEST(Validator, unitEquivalenceMultiplier) @@ -2309,12 +2310,15 @@ TEST(Validator, unitEquivalenceMultiplier) validator->validateModel(m); + EXPECT_EQ(size_t(1), validator->issueCount()); EXPECT_EQ(size_t(0), validator->errorCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); + EXPECT_EQ(size_t(0), validator->hintCount()); } TEST(Validator, unfoundUnitsInEncapsulatedComponents) { - const std::vector expectedErrors = { + const std::vector expectedIssues = { "Variable 'v' has a units reference 'non_existent_deep' that does not correspond with a standard units and is not a units defined in the variable's model.", "Variable 'v' has a units reference 'non_existent_shallow' that does not correspond with a standard units and is not a units defined in the variable's model.", }; @@ -2341,15 +2345,9 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) v->validateModel(model); - EXPECT_EQ_ERRORS(expectedErrors, v); + EXPECT_EQ_ISSUES(expectedIssues, v); } -/** - * - * ISSUE WARNINGS TESTING FROM HERE DOWN - * - * ==========================================================================*/ - TEST(Validator, mismatchedMultipliersInUnits) { // If two units are linked through variable equivalence mapping and their @@ -2383,10 +2381,10 @@ TEST(Validator, mismatchedMultipliersInUnits) auto validator = libcellml::Validator::create(); validator->validateModel(model); + EXPECT_EQ(size_t(1), validator->issueCount()); EXPECT_EQ(size_t(0), validator->errorCount()); EXPECT_EQ(size_t(1), validator->warningCount()); EXPECT_EQ(size_t(0), validator->hintCount()); - EXPECT_EQ(size_t(1), validator->issueCount()); EXPECT_EQ_ISSUES(expectedIssues, validator); } diff --git a/tests/variable/variable.cpp b/tests/variable/variable.cpp index 75cc475ef..4ae9d712f 100644 --- a/tests/variable/variable.cpp +++ b/tests/variable/variable.cpp @@ -1166,7 +1166,7 @@ TEST(Variable, modelUnitsAttributeBeforeNameAttribute) libcellml::ParserPtr parser = libcellml::Parser::create(); parser->parseModel(e); - EXPECT_EQ(size_t(0), parser->errorCount()); + EXPECT_EQ(size_t(0), parser->issueCount()); } TEST(Variable, parentlessUsingRemoveVariable) From 499cbe82c3b44c898b8c0231f19da5ef7ddac4ef Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Fri, 24 Jan 2020 09:14:11 +0100 Subject: [PATCH 35/88] Put back into logger.h --- src/api/libcellml/logger.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index ea71be432..7bc896242 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -21,6 +21,7 @@ limitations under the License. #include "libcellml/types.h" #include +#include namespace libcellml { From c1d6959fc6281dd69dcc6930fd3aa3d4838c698d Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 12:18:54 +1300 Subject: [PATCH 36/88] Fix merge conflicts --- src/validator.cpp | 3 +-- tests/validator/validator.cpp | 7 ++----- 2 files changed, 3 insertions(+), 7 deletions(-) diff --git a/src/validator.cpp b/src/validator.cpp index c6dcccc46..7ef1e2bd6 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -590,9 +590,8 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); ModelPtr model = owningModel(component); if ((model != nullptr) && !model->hasUnits(variable->units())) { - IssuePtr issue = Issue::create(); - issue->setDescription("Variable '" + variable->name() + "' has a units reference '" + unitsName + "' that does not correspond with a standard units and is not a units defined in the variable's model."); + issue->setDescription("Variable '" + variable->name() + "' in component '" + component->name() + "' has a units reference '" + unitsName + "' which is neither standard nor defined in the parent model."); issue->setVariable(variable); issue->setRule(ReferenceRule::VARIABLE_UNITS); mValidator->addIssue(issue); diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index bd7221cb3..9baa57e65 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -2064,12 +2064,9 @@ TEST(Validator, unitStandardMultipliersGram) libcellml::Variable::addEquivalence(v1, v2); - m->linkUnits(); validator->validateModel(m); -n EXPECT_EQ(size_t(0), validator->issueCount()); - } TEST(Validator, unitSimpleCycle) @@ -2322,8 +2319,8 @@ TEST(Validator, unitEquivalenceMultiplier) TEST(Validator, unfoundUnitsInEncapsulatedComponents) { const std::vector expectedIssues = { - "Variable 'v' has a units reference 'non_existent_deep' that does not correspond with a standard units and is not a units defined in the variable's model.", - "Variable 'v' has a units reference 'non_existent_shallow' that does not correspond with a standard units and is not a units defined in the variable's model.", + "Variable 'v' in component 'c3' has a units reference 'non_existent_deep' which is neither standard nor defined in the parent model.", + "Variable 'v' in component 'c2' has a units reference 'non_existent_shallow' which is neither standard nor defined in the parent model.", }; libcellml::ModelPtr model = libcellml::Model::create(); From 7583436df4f7a0e6c6ac115642ee4e056812e6ba Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 14:17:17 +1300 Subject: [PATCH 37/88] Changes as per review NB: Haven't removed the helper funcitons errorCount() etc --- src/api/libcellml/issue.h | 17 ++--------------- src/api/libcellml/referencerules.h | 4 ++-- src/bindings/interface/issue.i | 3 --- src/issue.cpp | 5 ----- tests/issue/issue.cpp | 8 -------- 5 files changed, 4 insertions(+), 33 deletions(-) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 0be83005f..acb526b3c 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -221,19 +221,6 @@ class LIBCELLML_EXPORT Issue */ ReferenceRule rule() const; - /** - * @brief Set the @c url of this issue. - * - * Manually set the @c url to which the user should refer for more information on the - * specification rule which has been broken or guidelines that haven't been followed. - * If this has not been set manually by use of this function, the default root url - * will be used (specified in baseIssueUrl) in conjunction with the referenceHeading - * string. - * - * @param rule The @c url to set manually. - */ - void setUrl(std::string &url) const; - /** * @brief Get the @c url of this issue. * @@ -246,10 +233,10 @@ class LIBCELLML_EXPORT Issue /** * @brief Get the @c std::string heading associated with the @c enum ReferenceRule for this issue. * - * Get the @c std::string CellML 2.0 Specification heading associated with the @c enum ReferenceRule + * Get the @c std::string CellML 2.0 Reference heading associated with the @c enum ReferenceRule * for this issue. If no rule has been set for this issue, will return an empty string. * - * @return The @c std::string referencing the CellML 2.0 Specification heading relevant to this issue. + * @return The @c std::string referencing the CellML 2.0 Reference heading relevant to this issue. */ std::string referenceHeading() const; diff --git a/src/api/libcellml/referencerules.h b/src/api/libcellml/referencerules.h index 55df1f0c6..118ecf48c 100644 --- a/src/api/libcellml/referencerules.h +++ b/src/api/libcellml/referencerules.h @@ -27,7 +27,7 @@ namespace libcellml { enum class ReferenceRule { UNDEFINED, - // Validation errors + // Specification errors. DATA_REPR_IDENTIFIER_UNICODE, DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, @@ -84,7 +84,7 @@ enum class ReferenceRule MAP_VARIABLES_VARIABLE1, MAP_VARIABLES_VARIABLE2, MAP_VARIABLES_UNIQUE - // Code generation errors go here... TODO + // Code generation errors go here ... TODO }; } // namespace libcellml diff --git a/src/bindings/interface/issue.i b/src/bindings/interface/issue.i index 4e9f67f83..be1ac4608 100644 --- a/src/bindings/interface/issue.i +++ b/src/bindings/interface/issue.i @@ -45,9 +45,6 @@ Level::ERROR will be returned."; %feature("docstring") libcellml::Issue::url "Get the url for more information about this issue."; -%feature("docstring") libcellml::Issue::setUrl -"Manually sets the url to which users are referred for this issue."; - %feature("docstring") libcellml::Issue::referenceHeading "Returns the CellML 2.0 Specification heading associated with the :class:`ReferenceRule` for this issue (empty string if not set)."; diff --git a/src/issue.cpp b/src/issue.cpp index 17f3fb0ba..ab030e56b 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -189,11 +189,6 @@ ReferenceRule Issue::rule() const return mPimpl->mRule; } -void Issue::setUrl(std::string &url) const -{ - mPimpl->mReferenceUrl = url; -} - std::string Issue::url() const { if (mPimpl->mReferenceUrl.empty()) { diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index 2b8aa80c7..333328a28 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -495,11 +495,3 @@ TEST(Issue, getDefaultUrl) std::string url = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q=" + ref; EXPECT_EQ(e->url(), url); } - -TEST(Issue, setAndGetCustomUrl) -{ - auto e = libcellml::Issue::create(); - std::string url = "https://my_custom_url.com"; - e->setUrl(url); - EXPECT_EQ(url, e->url()); -} From 12460028ba62b565a8324de8743a65d2b7403f59 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 14:31:10 +1300 Subject: [PATCH 38/88] Added explicit defaults to docstring --- src/api/libcellml/issue.h | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index acb526b3c..6cb36756c 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -54,6 +54,12 @@ class LIBCELLML_EXPORT Issue * - libcellml::UnitsPtr * - libcellml::VariablePtr * + * The default values for the enumerations are:: + * + * - libcellml::Issue::Cause::UNDEFINED; + * - libcellml::Issue::Level::ERROR; + * - libcellml::ReferenceRule::UNDEFINED; + * * @return A smart pointer to an @c Issue object. */ static IssuePtr create() noexcept; From e1af61beb0d859c56c56335cfdb06d679d514df2 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 14:52:25 +1300 Subject: [PATCH 39/88] Removed mReferenceUrl from Issue class as now not needed --- src/issue.cpp | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/src/issue.cpp b/src/issue.cpp index ab030e56b..31b0e62de 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -34,8 +34,6 @@ struct Issue::IssueImpl Issue::Cause mCause = Issue::Cause::UNDEFINED; /**< The Issue::Cause enum value for this issue. */ Issue::Level mLevel = Issue::Level::ERROR; /**< The Issue::Level enum value for this issue. */ ReferenceRule mRule = ReferenceRule::UNDEFINED; /**< The ReferenceRule enum value for this issue. */ - std::string mReferenceUrl; /**< The web address at which the rule and its guidelines are available. By default - it should be the baseIssueUrl plus the reference rule's header number. */ ComponentPtr mComponent; /**< Pointer to the component that the issue occurred in. */ ImportSourcePtr mImportSource; /**< Pointer to the import source that the issue occurred in. */ ModelPtr mModel; /**< Pointer to the model that the issue occurred in. */ @@ -191,11 +189,9 @@ ReferenceRule Issue::rule() const std::string Issue::url() const { - if (mPimpl->mReferenceUrl.empty()) { - // Then construct from the default address formula: baseIssueUrl + rule number. - return baseIssueUrl + referenceHeading(); - } - return mPimpl->mReferenceUrl; + // Construct from the default address formula: baseIssueUrl + rule number. + // TODO check that this is appropriate for however we need to handle them. + return baseIssueUrl + referenceHeading(); } void Issue::setComponent(const ComponentPtr &component) From 3f8ff8edf43377584a8e211f969c6ec3f190bba7 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 15:03:24 +1300 Subject: [PATCH 40/88] Update .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index a8388617a..648fc3019 100644 --- a/.gitignore +++ b/.gitignore @@ -18,3 +18,4 @@ CMakeLists.txt.user # VS Code system files .vscode/ +default.profraw From ef8405324e29995a7934105bf5ef03142b7c0e5f Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 15:04:33 +1300 Subject: [PATCH 41/88] Update __init__.py --- src/bindings/python/__init__.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/bindings/python/__init__.py b/src/bindings/python/__init__.py index a33b21309..36d8a6f89 100644 --- a/src/bindings/python/__init__.py +++ b/src/bindings/python/__init__.py @@ -128,8 +128,8 @@ class Object: 'YOCTO', ], new_base = Units) import libcellml -import libcellml.specificationrule -convert(specificationrule, 'ReferenceRule', [ +import libcellml.referencerule +convert(referencerule, 'ReferenceRule', [ 'UNDEFINED', 'DATA_REPR_IDENTIFIER_UNICODE', 'DATA_REPR_IDENTIFIER_LATIN_ALPHANUM', From 70136db474747d3b799ec10d43f301df421e1094 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 15:34:16 +1300 Subject: [PATCH 42/88] Update gtest.h --- tests/gtest/include/gtest/gtest.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/gtest/include/gtest/gtest.h b/tests/gtest/include/gtest/gtest.h index 3d3cda6f8..ebb16db7b 100644 --- a/tests/gtest/include/gtest/gtest.h +++ b/tests/gtest/include/gtest/gtest.h @@ -10440,7 +10440,7 @@ GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes, // For selecting which printer to use when a given type has neither << // nor PrintTo(). -enum TypeCause { +enum TypeKind { kProtobuf, // a protobuf type kConvertibleToInteger, // a type implicitly convertible to BiggestInt // (e.g. a named or unnamed enum type) @@ -10451,14 +10451,14 @@ enum TypeCause { kOtherType // anything else }; -// TypeWithoutFormatter::PrintValue(value, os) is called +// TypeWithoutFormatter::PrintValue(value, os) is called // by the universal printer to print a value of type T when neither -// operator<< nor PrintTo() is defined for T, where kTypeCause is the -// "kind" of T as defined by enum TypeCause. -template +// operator<< nor PrintTo() is defined for T, where kTypeKind is the +// "kind" of T as defined by enum TypeKind. +template class TypeWithoutFormatter { public: - // This default version is called when kTypeCause is kOtherType. + // This default version is called when kTypeKind is kOtherType. static void PrintValue(const T& value, ::std::ostream* os) { PrintBytesInObjectTo(static_cast( reinterpret_cast(&value)), From d5e2a232cdfa13807552a7de53793212973d2e17 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 15:34:56 +1300 Subject: [PATCH 43/88] test_error.py renamed to test_issue.py --- tests/bindings/python/CMakeLists.txt | 2 +- tests/bindings/python/{test_error.py => test_issue.py} | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename tests/bindings/python/{test_error.py => test_issue.py} (100%) diff --git a/tests/bindings/python/CMakeLists.txt b/tests/bindings/python/CMakeLists.txt index 1f27c741c..851034d40 100644 --- a/tests/bindings/python/CMakeLists.txt +++ b/tests/bindings/python/CMakeLists.txt @@ -14,10 +14,10 @@ set(TEST_SRCS test_component.py - test_error.py test_generator.py test_generator_profile.py test_import_source.py + test_issue.py test_model.py test_parser.py test_printer.py diff --git a/tests/bindings/python/test_error.py b/tests/bindings/python/test_issue.py similarity index 100% rename from tests/bindings/python/test_error.py rename to tests/bindings/python/test_issue.py From e892ef5a5a70769c92dd209b6c4bd0ff6e81253b Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 15:56:23 +1300 Subject: [PATCH 44/88] renaming interface files --- src/bindings/interface/{specificationrule.i => referencerule.i} | 2 +- src/bindings/python/CMakeLists.txt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) rename src/bindings/interface/{specificationrule.i => referencerule.i} (70%) diff --git a/src/bindings/interface/specificationrule.i b/src/bindings/interface/referencerule.i similarity index 70% rename from src/bindings/interface/specificationrule.i rename to src/bindings/interface/referencerule.i index 99e67c79b..0118ea134 100644 --- a/src/bindings/interface/specificationrule.i +++ b/src/bindings/interface/referencerule.i @@ -1,4 +1,4 @@ -%module(package="libcellml") specificationrule +%module(package="libcellml") referencerule #define LIBCELLML_EXPORT diff --git a/src/bindings/python/CMakeLists.txt b/src/bindings/python/CMakeLists.txt index 6c3776392..e2d0cdef0 100644 --- a/src/bindings/python/CMakeLists.txt +++ b/src/bindings/python/CMakeLists.txt @@ -34,7 +34,7 @@ set(SWIG_INTERFACE_SRCS ../interface/parser.i ../interface/printer.i ../interface/reset.i - ../interface/specificationrule.i + ../interface/referencerule.i ../interface/units.i ../interface/validator.i ../interface/variable.i From a704fea953c548c1030b2ae7b521052a0bdea5e5 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 16:14:07 +1300 Subject: [PATCH 45/88] Update issue.cpp --- tests/issue/issue.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index 333328a28..344c11932 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -244,7 +244,7 @@ void testReferenceRule(const libcellml::IssuePtr &e) } } -TEST(Issue, specificationRule) +TEST(Issue, referenceRule) { size_t count = 0; libcellml::IssuePtr e = libcellml::Issue::create(); From 6c72aabadb5b6ce6df2c511b56bbceb26a299d2e Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 16:15:11 +1300 Subject: [PATCH 46/88] Update units.h --- src/api/libcellml/units.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/api/libcellml/units.h b/src/api/libcellml/units.h index b25054a73..26df6c4be 100644 --- a/src/api/libcellml/units.h +++ b/src/api/libcellml/units.h @@ -24,7 +24,7 @@ limitations under the License. #include // MSVC (and some other compilers?) may define PASCAL as __stdcall, resulting in -// some compilation issues for our StandardUnit enum class below. However, that +// some compilation errors for our StandardUnit enum class below. However, that // macro gets defined for backward compatibility, so we can safely undefine it. // (See https://stackoverflow.com/questions/2774171/what-is-far-pascal for more // information.) From 7c8f27a65a743cab181ebdea3ea6eeb2472d84e8 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 16:40:15 +1300 Subject: [PATCH 47/88] Delete default.profraw --- default.profraw | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 default.profraw diff --git a/default.profraw b/default.profraw deleted file mode 100644 index e69de29bb..000000000 From 5fabe53985b072f9a9880a725909dd64fe301fc1 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 16:40:41 +1300 Subject: [PATCH 48/88] Update .gitignore --- .gitignore | 1 - 1 file changed, 1 deletion(-) diff --git a/.gitignore b/.gitignore index 648fc3019..a8388617a 100644 --- a/.gitignore +++ b/.gitignore @@ -18,4 +18,3 @@ CMakeLists.txt.user # VS Code system files .vscode/ -default.profraw From 7cb987275b67c264ad6d8c10b10c5f10f87d7879 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 16:49:20 +1300 Subject: [PATCH 49/88] Improve comments for clarity --- src/api/libcellml/logger.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index 7bc896242..ea6fafef4 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -84,7 +84,7 @@ class LIBCELLML_EXPORT Logger * is [0, \#issues_of_level). * * @param index The index of the issue to return. - * @param level The level of issue to return. + * @param level The level of issue to search. * * @return A reference to the issue from the list of issues at the given level, * at the given index on success, @c nullptr otherwise. @@ -98,8 +98,8 @@ class LIBCELLML_EXPORT Logger * is not valid a @c nullptr is returned, the valid range for the @p index * is [0, \#issues_of_levels). * - * @param index The index of the issue to return. - * @param levels The levels of issue to return. + * @param index The index of the issue to return from within the combined set of levels. + * @param levels The levels of issues to search. * * @return A reference to the issue from the list of issues at one of the given levels, * at the given index on success, @c nullptr otherwise. From 17cbc510db9fc3c5b276d6f6a4c6614f6c3218c6 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 20 Feb 2020 17:07:49 +1300 Subject: [PATCH 50/88] Update issue.h --- src/api/libcellml/issue.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 6cb36756c..00584b085 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -239,10 +239,10 @@ class LIBCELLML_EXPORT Issue /** * @brief Get the @c std::string heading associated with the @c enum ReferenceRule for this issue. * - * Get the @c std::string CellML 2.0 Reference heading associated with the @c enum ReferenceRule + * Get the @c std::string libCellML Reference heading associated with the @c enum ReferenceRule * for this issue. If no rule has been set for this issue, will return an empty string. * - * @return The @c std::string referencing the CellML 2.0 Reference heading relevant to this issue. + * @return The @c std::string libCellML Reference heading relevant to this issue. */ std::string referenceHeading() const; From 624e04f09a94b9b79983a13ac23b1ecd305ca752 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Fri, 21 Feb 2020 16:02:01 +1300 Subject: [PATCH 51/88] Capitalise BASE_ISSUE_URL --- src/issue.cpp | 4 ++-- src/utilities.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/issue.cpp b/src/issue.cpp index 31b0e62de..9dd445077 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -189,9 +189,9 @@ ReferenceRule Issue::rule() const std::string Issue::url() const { - // Construct from the default address formula: baseIssueUrl + rule number. + // Construct from the default address formula: BASE_ISSUE_URL + rule number. // TODO check that this is appropriate for however we need to handle them. - return baseIssueUrl + referenceHeading(); + return BASE_ISSUE_URL + referenceHeading(); } void Issue::setComponent(const ComponentPtr &component) diff --git a/src/utilities.h b/src/utilities.h index 9ee129f62..1de2c3b03 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -29,7 +29,7 @@ namespace libcellml { * Adding the issue's rule number to the end will search the documentation for that section. * KRM This is clumsy and should be given a static address via formal bookmarks, but will do for proof of concept. */ -const std::string baseIssueUrl = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q="; +const std::string BASE_ISSUE_URL = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q="; /** * Vector of base units. From f7896168cc19adf360f5f4d1090e20984ad7b2e3 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Fri, 21 Feb 2020 16:12:43 +1300 Subject: [PATCH 52/88] Removed warning for multiplier mismatch from validator --- src/validator.cpp | 10 ---------- tests/validator/validator.cpp | 28 ++++++++-------------------- 2 files changed, 8 insertions(+), 30 deletions(-) diff --git a/src/validator.cpp b/src/validator.cpp index 7ef1e2bd6..bd8d0837f 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -985,16 +985,6 @@ void Validator::ValidatorImpl::validateConnections(const ModelPtr &model) issue->setModel(model); issue->setCause(Issue::Cause::UNITS); mValidator->addIssue(issue); - } else if (multiplier != 0.0) { - // Warning when the multipliers are not the same. - auto unitsName = variable->units() == nullptr ? "" : variable->units()->name(); - auto equivalentUnitsName = equivalentVariable->units() == nullptr ? "" : equivalentVariable->units()->name(); - IssuePtr issue = Issue::create(); - issue->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); - issue->setModel(model); - issue->setLevel(libcellml::Issue::Level::WARNING); - issue->setCause(Issue::Cause::UNITS); - mValidator->addIssue(issue); } if (equivalentVariable->hasEquivalentVariable(variable)) { diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 9baa57e65..d41db47f9 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -1798,7 +1798,6 @@ TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) { // This test is intended to demonstrate that the effect of different multiplicator sources (prefix, multiplier term) // does not affect the equivalence of the underlying base variables. - std::string expectedWarning = "Variable 'v1' has units of 'u4' and an equivalent variable 'v2' with non-matching units of 'u5'. The mismatch is: multiplication factor of 10^12."; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr model = libcellml::Model::create(); @@ -1863,11 +1862,10 @@ TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) validator->validateModel(model); - EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); EXPECT_EQ(size_t(0), validator->errorCount()); EXPECT_EQ(size_t(0), validator->hintCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); - EXPECT_EQ(expectedWarning, validator->warning(0)->description()); + EXPECT_EQ(size_t(0), validator->warningCount()); } TEST(Validator, unitUserCreatedUnitsBananasAndApples) @@ -1984,8 +1982,6 @@ TEST(Validator, unitStandardUnitsWhichAreNotBaseUnits) TEST(Validator, unitMultiplierFactorDifference) { - const std::vector expectedIssues = { - "Variable 'v1' has units of 'litre' and an equivalent variable 'v2' with non-matching units of 'big_barrel'. The mismatch is: multiplication factor of 10^-3."}; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); @@ -2009,12 +2005,10 @@ TEST(Validator, unitMultiplierFactorDifference) validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); + EXPECT_EQ(size_t(0), validator->warningCount()); EXPECT_EQ(size_t(0), validator->hintCount()); - - EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unitStandardMultipliersLitre) @@ -2310,9 +2304,9 @@ TEST(Validator, unitEquivalenceMultiplier) validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); + EXPECT_EQ(size_t(0), validator->warningCount()); EXPECT_EQ(size_t(0), validator->hintCount()); } @@ -2353,11 +2347,6 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) TEST(Validator, mismatchedMultipliersInUnits) { - // If two units are linked through variable equivalence mapping and their - // scaling factor is not the same, it should raise a warning-level issue - std::vector expectedIssues = { - "Variable 'v1' has units of 'megametre' and an equivalent variable 'v2' with non-matching units of 'millimetre'. The mismatch is: multiplication factor of 10^9."}; - auto model = libcellml::Model::create("Gulliver"); auto c1 = libcellml::Component::create("Brobdingnag"); auto c2 = libcellml::Component::create("Lilliput"); @@ -2384,12 +2373,11 @@ TEST(Validator, mismatchedMultipliersInUnits) auto validator = libcellml::Validator::create(); validator->validateModel(model); - EXPECT_EQ(size_t(1), validator->issueCount()); + EXPECT_EQ(size_t(0), validator->issueCount()); EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); + EXPECT_EQ(size_t(0), validator->warningCount()); EXPECT_EQ(size_t(0), validator->hintCount()); - EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, refToUnitsByNameNeedsLinkUnitsToValidate) From a5138dbd40a6027bde858fdd4519af9fb5735ede Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Fri, 21 Feb 2020 16:13:12 +1300 Subject: [PATCH 53/88] formatting --- tests/validator/validator.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index d41db47f9..7e0915017 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -1982,7 +1982,6 @@ TEST(Validator, unitStandardUnitsWhichAreNotBaseUnits) TEST(Validator, unitMultiplierFactorDifference) { - libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); auto c1 = m->component(0); @@ -2377,7 +2376,6 @@ TEST(Validator, mismatchedMultipliersInUnits) EXPECT_EQ(size_t(0), validator->errorCount()); EXPECT_EQ(size_t(0), validator->warningCount()); EXPECT_EQ(size_t(0), validator->hintCount()); - } TEST(Validator, refToUnitsByNameNeedsLinkUnitsToValidate) From 0d123251b1ab850174c8f1f29d18c0225b4a23a3 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Fri, 21 Feb 2020 16:31:05 +1300 Subject: [PATCH 54/88] Update parser.cpp --- tests/parser/parser.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/parser/parser.cpp b/tests/parser/parser.cpp index 1729c61e0..e566b9fba 100644 --- a/tests/parser/parser.cpp +++ b/tests/parser/parser.cpp @@ -309,7 +309,7 @@ TEST(Parser, unitsAttributeIssue) libcellml::ParserPtr p = libcellml::Parser::create(); p->parseModel(e); - EXPECT_EQ_ERRORS(expectedErrors, p); + EXPECT_EQ_ISSUES(expectedIssues, p); } TEST(Parser, unitsElementIssues) From 09900a4d1519ba9e56fd58e79ade990bb85dfc18 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Sat, 22 Feb 2020 09:06:05 +1300 Subject: [PATCH 55/88] Removing multiple level overload from issue fetching functions --- src/api/libcellml/logger.h | 15 ------------ src/logger.cpp | 17 ------------- tests/logger/logger.cpp | 49 -------------------------------------- 3 files changed, 81 deletions(-) diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index ea6fafef4..78af71228 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -91,21 +91,6 @@ class LIBCELLML_EXPORT Logger */ IssuePtr issue(size_t index, libcellml::Issue::Level level) const; - /** - * @brief Get issue of one of the specified @p levels at the specified @p index. - * - * Returns an issue at the @p index of one of the specified @p levels. If the @p index - * is not valid a @c nullptr is returned, the valid range for the @p index - * is [0, \#issues_of_levels). - * - * @param index The index of the issue to return from within the combined set of levels. - * @param levels The levels of issues to search. - * - * @return A reference to the issue from the list of issues at one of the given levels, - * at the given index on success, @c nullptr otherwise. - */ - IssuePtr issue(size_t index, std::vector &levels) const; - /** * @brief Get the number of issues with level of ERROR. * diff --git a/src/logger.cpp b/src/logger.cpp index 68ecfc2e1..dfc7d9241 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -150,21 +150,4 @@ IssuePtr Logger::issue(size_t index, libcellml::Issue::Level level) const return e; } -IssuePtr Logger::issue(size_t index, std::vector &levels) const -{ - size_t i = 0; - index++; - while (i < mPimpl->mIssues.size()) { - for (auto issue : mPimpl->mIssues) { - if (std::find(levels.begin(), levels.end(), issue->level()) != levels.end()) { - i++; - } - if (i == index) { - return issue; - } - } - } - return nullptr; -} - } // namespace libcellml diff --git a/tests/logger/logger.cpp b/tests/logger/logger.cpp index 8fdc1f162..97923181d 100644 --- a/tests/logger/logger.cpp +++ b/tests/logger/logger.cpp @@ -165,52 +165,6 @@ TEST(Logger, getIssueByLevelArgument) EXPECT_EQ(hint2, validator->issue(1, libcellml::Issue::Level::HINT)); } -TEST(Logger, getIssueByLevelsArguments) -{ - auto error1 = libcellml::Issue::create(); - error1->setLevel(libcellml::Issue::Level::ERROR); - - auto warning1 = libcellml::Issue::create(); - warning1->setLevel(libcellml::Issue::Level::WARNING); - - auto hint1 = libcellml::Issue::create(); - hint1->setLevel(libcellml::Issue::Level::HINT); - - auto error2 = libcellml::Issue::create(); - error2->setLevel(libcellml::Issue::Level::ERROR); - - auto warning2 = libcellml::Issue::create(); - warning2->setLevel(libcellml::Issue::Level::WARNING); - - auto hint2 = libcellml::Issue::create(); - hint2->setLevel(libcellml::Issue::Level::HINT); - - auto validator = libcellml::Validator::create(); - validator->addIssue(error1); - validator->addIssue(warning1); - validator->addIssue(hint1); - validator->addIssue(hint2); - validator->addIssue(warning2); - validator->addIssue(error2); - - std::vector errorOnly = {libcellml::Issue::Level::ERROR}; - std::vector warningOnly = {libcellml::Issue::Level::WARNING}; - std::vector hintOnly = {libcellml::Issue::Level::HINT}; - std::vector errorAndWarning = {libcellml::Issue::Level::ERROR, libcellml::Issue::Level::WARNING}; - std::vector errorAndHint = {libcellml::Issue::Level::ERROR, libcellml::Issue::Level::HINT}; - std::vector warningAndHint = {libcellml::Issue::Level::HINT, libcellml::Issue::Level::WARNING}; - std::vector allOfThem = {libcellml::Issue::Level::ERROR, libcellml::Issue::Level::WARNING, libcellml::Issue::Level::HINT}; - - EXPECT_EQ(error2, validator->issue(1, errorOnly)); - EXPECT_EQ(warning2, validator->issue(1, warningOnly)); - EXPECT_EQ(hint1, validator->issue(0, hintOnly)); - EXPECT_EQ(error2, validator->issue(3, errorAndWarning)); - EXPECT_EQ(hint2, validator->issue(2, errorAndHint)); - EXPECT_EQ(warning1, validator->issue(0, warningAndHint)); - EXPECT_EQ(warning2, validator->issue(4, allOfThem)); - EXPECT_EQ(nullptr, validator->issue(100, errorOnly)); -} - TEST(Logger, outOfRangeIndex) { auto error1 = libcellml::Issue::create(); @@ -226,11 +180,8 @@ TEST(Logger, outOfRangeIndex) validator->addIssue(warning1); validator->addIssue(hint1); - std::vector errorAndWarning = {libcellml::Issue::Level::ERROR, libcellml::Issue::Level::WARNING}; - EXPECT_EQ(nullptr, validator->issue(10)); EXPECT_EQ(nullptr, validator->error(10)); EXPECT_EQ(nullptr, validator->warning(10)); EXPECT_EQ(nullptr, validator->hint(10)); - EXPECT_EQ(nullptr, validator->issue(10, errorAndWarning)); } From e2e9d9cee15e5d2e7baafbe6a5b62d944208d437 Mon Sep 17 00:00:00 2001 From: Hugh Sorby Date: Thu, 27 Feb 2020 15:36:39 +1300 Subject: [PATCH 56/88] Resolve compilation errors arrising from merge. --- src/validator.cpp | 77 +++++++++++++------------------------------- tests/test_utils.cpp | 2 +- tests/test_utils.h | 5 ++- 3 files changed, 26 insertions(+), 58 deletions(-) diff --git a/src/validator.cpp b/src/validator.cpp index 305efe633..6e0662bb6 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -741,65 +741,34 @@ void Validator::ValidatorImpl::validateReset(const ResetPtr &reset, const Compon void Validator::ValidatorImpl::validateMath(const std::string &input, const ComponentPtr &component) { // Parse as XML first. -// <<<<<<< i314_issue_class std::vector docs = multiRootXml(input); for (const auto &doc : docs) { - // Copy any XML parsing issues into the common validator issue handler. - if (doc->xmlErrorCount() > 0) { - for (size_t i = 0; i < doc->xmlErrorCount(); ++i) { + // Copy any XML parsing issues into the common validator issue handler. + if (doc->xmlErrorCount() > 0) { + for (size_t i = 0; i < doc->xmlErrorCount(); ++i) { + IssuePtr issue = Issue::create(); + issue->setDescription("LibXml2 error: " + doc->xmlError(i)); + issue->setCause(Issue::Cause::XML); + mValidator->addIssue(issue); + } + } + XmlNodePtr node = doc->rootNode(); + if (node == nullptr) { IssuePtr issue = Issue::create(); - issue->setDescription("LibXml2 error: " + doc->xmlError(i)); + issue->setDescription("Could not get a valid XML root node from the math on component '" + component->name() + "'."); issue->setCause(Issue::Cause::XML); + issue->setComponent(component); mValidator->addIssue(issue); + return; + } + if (!node->isMathmlElement("math")) { + IssuePtr issue = Issue::create(); + issue->setDescription("Math root node is of invalid type '" + node->name() + "' on component '" + component->name() + "'. A valid math root node should be of type 'math'."); + issue->setComponent(component); + issue->setCause(Issue::Cause::XML); + mValidator->addIssue(issue); + return; } - } - XmlNodePtr node = doc->rootNode(); - if (node == nullptr) { - IssuePtr issue = Issue::create(); - issue->setDescription("Could not get a valid XML root node from the math on component '" + component->name() + "'."); - issue->setCause(Issue::Cause::XML); - issue->setComponent(component); - mValidator->addIssue(issue); - return; - } - if (!node->isMathmlElement("math")) { - IssuePtr issue = Issue::create(); - issue->setDescription("Math root node is of invalid type '" + node->name() + "' on component '" + component->name() + "'. A valid math root node should be of type 'math'."); - issue->setComponent(component); - issue->setCause(Issue::Cause::XML); - mValidator->addIssue(issue); - return; - } -// ======= -// std::vector docs = multiRootXml(input); -// for (const auto &doc : docs) { -// // Copy any XML parsing errors into the common validator error handler. -// if (doc->xmlErrorCount() > 0) { -// for (size_t i = 0; i < doc->xmlErrorCount(); ++i) { -// ErrorPtr err = Error::create(); -// err->setDescription("LibXml2 error: " + doc->xmlError(i)); -// err->setKind(Error::Kind::XML); -// mValidator->addError(err); -// } -// } -// XmlNodePtr node = doc->rootNode(); -// if (node == nullptr) { -// ErrorPtr err = Error::create(); -// err->setDescription("Could not get a valid XML root node from the math on component '" + component->name() + "'."); -// err->setKind(Error::Kind::XML); -// err->setComponent(component); -// mValidator->addError(err); -// return; -// } -// if (!node->isMathmlElement("math")) { -// ErrorPtr err = Error::create(); -// err->setDescription("Math root node is of invalid type '" + node->name() + "' on component '" + component->name() + "'. A valid math root node should be of type 'math'."); -// err->setComponent(component); -// err->setKind(Error::Kind::XML); -// mValidator->addError(err); -// return; -// } -// >>>>>>> develop XmlNodePtr nodeCopy = node; std::vector variableNames; @@ -833,7 +802,7 @@ void Validator::ValidatorImpl::validateMath(const std::string &input, const Comp IssuePtr issue = Issue::create(); issue->setDescription("W3C MathML DTD error: " + mathmlDoc->xmlError(i)); issue->setComponent(component); - issue->setKind(Error::Kind::MATHML); + issue->setCause(Issue::Cause::MATHML); mValidator->addIssue(issue); } } diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp index 58ed898ef..11b316d1c 100644 --- a/tests/test_utils.cpp +++ b/tests/test_utils.cpp @@ -132,7 +132,7 @@ void printComponent(const libcellml::ComponentPtr &component, size_t const c, st } } -void expectEqualIssues(const std::vector &errors, const libcellml::LoggerPtr &logger) +void expectEqualIssues(const std::vector &issues, const libcellml::LoggerPtr &logger) { EXPECT_EQ(issues.size(), logger->issueCount()); diff --git a/tests/test_utils.h b/tests/test_utils.h index e8155f657..b4a743f36 100644 --- a/tests/test_utils.h +++ b/tests/test_utils.h @@ -79,13 +79,12 @@ std::string TEST_EXPORT fileContents(const std::string &fileName); void TEST_EXPORT printIssues(const libcellml::LoggerPtr &l, bool headings = false, bool causes = false, bool rule = false); -void TEST_EXPORT expectEqualIssues(const std::vector &issues, - void TEST_EXPORT printComponent(const libcellml::ComponentPtr &component, size_t const c, std::string const spacer); void TEST_EXPORT printModel(libcellml::ModelPtr &model); - const libcellml::LoggerPtr &logger); +void TEST_EXPORT expectEqualIssues(const std::vector &issues, const libcellml::LoggerPtr &logger); + void TEST_EXPORT expectEqualIssuesSpecificationHeadings(const std::vector &issues, const std::vector &specificationHeadings, const libcellml::LoggerPtr &logger); From 17ea5030d60d3db0616da7ec8ddccfeb1249cdd9 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Mon, 2 Mar 2020 15:59:58 +1300 Subject: [PATCH 57/88] Make clang format happy --- src/generator.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/generator.cpp b/src/generator.cpp index fcc6eb90e..a5696d834 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -1300,12 +1300,12 @@ void Generator::GeneratorImpl::processEquationAst(const GeneratorEquationAstPtr IssuePtr issue = Issue::create(); issue->setDescription("Variable '" + mVoi->variable()->name() - + "' in component '" + mVoi->component()->name() - + "' of model '" + voiModel->name() - + "' and variable '" + variable->name() - + "' in component '" + component->name() - + "' of model '" + model->name() - + "' cannot both be a variable of integration."); + + "' in component '" + mVoi->component()->name() + + "' of model '" + voiModel->name() + + "' and variable '" + variable->name() + + "' in component '" + component->name() + + "' of model '" + model->name() + + "' cannot both be a variable of integration."); issue->setCause(Issue::Cause::GENERATOR); mGenerator->addIssue(issue); From e14c9b8410d3285ca6c654d14668f1ecc4c12c88 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Mon, 2 Mar 2020 16:13:53 +1300 Subject: [PATCH 58/88] Removed Issue::url functionality until spec is finalised --- src/api/libcellml/issue.h | 17 +++++++++-------- src/issue.cpp | 13 +++++++------ tests/issue/issue.cpp | 21 +++++++++++---------- 3 files changed, 27 insertions(+), 24 deletions(-) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 00584b085..f91d5bde3 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -227,14 +227,15 @@ class LIBCELLML_EXPORT Issue */ ReferenceRule rule() const; - /** - * @brief Get the @c url of this issue. - * - * Get the @c url to which the user should refer for more information on this issue. - * - * @return The @c url for this issue. - */ - std::string url() const; + // /** + // * @brief Get the @c url of this issue. + // * + // * Get the @c url to which the user should refer for more information on this issue. + // * + // * @return The @c url for this issue. + // */ + // TODO Removed until the base URL and CellML 2.0 specification has been finalised. + // std::string url() const; /** * @brief Get the @c std::string heading associated with the @c enum ReferenceRule for this issue. diff --git a/src/issue.cpp b/src/issue.cpp index 9dd445077..fa2b294cc 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -187,12 +187,13 @@ ReferenceRule Issue::rule() const return mPimpl->mRule; } -std::string Issue::url() const -{ - // Construct from the default address formula: BASE_ISSUE_URL + rule number. - // TODO check that this is appropriate for however we need to handle them. - return BASE_ISSUE_URL + referenceHeading(); -} +// TODO Removed until the BASE_ISSUE_URL is finalised and ready. +// std::string Issue::url() const +// { +// // Construct from the default address formula: BASE_ISSUE_URL + rule number. +// // TODO check that this is appropriate for however we need to handle them. +// return BASE_ISSUE_URL + referenceHeading(); +// } void Issue::setComponent(const ComponentPtr &component) { diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index 344c11932..0d243eaf4 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -485,13 +485,14 @@ TEST(Issue, isHint) EXPECT_TRUE(e->isLevel(libcellml::Issue::Level::HINT)); } -TEST(Issue, getDefaultUrl) -{ - auto e = libcellml::Issue::create(); - e->setRule(libcellml::ReferenceRule::MODEL_NAME); - auto ref = e->referenceHeading(); - - // TODO How to get this from the utilties.h file?? Won't be this address in the long run. - std::string url = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q=" + ref; - EXPECT_EQ(e->url(), url); -} +// TODO Remove this test until the base URL for the CellML2.0 specification exists and the spec is finalised. +// TEST(Issue, getDefaultUrl) +// { +// auto e = libcellml::Issue::create(); +// e->setRule(libcellml::ReferenceRule::MODEL_NAME); +// auto ref = e->referenceHeading(); + +// // TODO How to get this from the utilties.h file?? Won't be this address in the long run. +// std::string url = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q=" + ref; +// EXPECT_EQ(e->url(), url); +// } From b4affe1e11a76eb2229c6eb352f5953a45c1515e Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Wed, 11 Mar 2020 10:26:24 +1300 Subject: [PATCH 59/88] merge conflicts, multiplier warning between equiv units --- default.profraw | 0 src/validator.cpp | 25 ++++++++++++++++++- tests/issue/issue.cpp | 3 +++ tests/validator/validator.cpp | 46 +++++++++++++++++++++-------------- 4 files changed, 55 insertions(+), 19 deletions(-) create mode 100644 default.profraw diff --git a/default.profraw b/default.profraw new file mode 100644 index 000000000..e69de29bb diff --git a/src/validator.cpp b/src/validator.cpp index 5a3d60b9c..658adbafd 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -1102,16 +1102,39 @@ void Validator::ValidatorImpl::validateEquivalenceUnits(const ModelPtr &model, c auto it = std::find(alreadyReported.begin(), alreadyReported.end(), reversePair); if (it == alreadyReported.end()) { VariablePair pair = std::make_pair(variable, equivalentVariable); + ComponentPtr parent1 = std::dynamic_pointer_cast(variable->parent()); + ComponentPtr parent2 = std::dynamic_pointer_cast(equivalentVariable->parent()); alreadyReported.push_back(pair); auto unitsName = variable->units() == nullptr ? "" : variable->units()->name(); auto equivalentUnitsName = equivalentVariable->units() == nullptr ? "" : equivalentVariable->units()->name(); IssuePtr err = Issue::create(); - err->setDescription("Variable '" + variable->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); + err->setDescription("Variable '" + variable->name() + "' in component '" + parent1->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' in component '" + parent2->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); err->setModel(model); err->setCause(Issue::Cause::UNITS); err->setRule(ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); mValidator->addIssue(err); } + } else if (multiplier != 0.0) { + VariablePair reversePair = std::make_pair(equivalentVariable, variable); + auto it = std::find(alreadyReported.begin(), alreadyReported.end(), reversePair); + if (it == alreadyReported.end()) { + VariablePair pair = std::make_pair(variable, equivalentVariable); + ComponentPtr parent1 = std::dynamic_pointer_cast(variable->parent()); + ComponentPtr parent2 = std::dynamic_pointer_cast(equivalentVariable->parent()); + alreadyReported.push_back(pair); + auto unitsName = variable->units() == nullptr ? "" : variable->units()->name(); + auto equivalentUnitsName = equivalentVariable->units() == nullptr ? "" : equivalentVariable->units()->name(); + IssuePtr err = Issue::create(); + std::string des = "Variable '" + variable->name() + "' in component '" + parent1->name() + "' has units of '" + unitsName; + des += "' and an equivalent variable '" + equivalentVariable->name() + "' in component '" + parent2->name(); + des += "' has compatible but not equivalent units of '" + equivalentUnitsName + "'. The mismatch is: " + hints; + err->setModel(model); + err->setDescription(des); + err->setCause(Issue::Cause::UNITS); + err->setRule(ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); + err->setLevel(Issue::Level::WARNING); + mValidator->addIssue(err); + } } } } diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index 0d243eaf4..ca4b5ca14 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -142,6 +142,9 @@ void testReferenceRule(const libcellml::IssuePtr &e) case libcellml::ReferenceRule::IMPORT_UNITS_REF: EXPECT_EQ("6.1.2", e->referenceHeading()); break; + case libcellml::ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION: + EXPECT_EQ("16.1.3", e->referenceHeading()); + break; case libcellml::ReferenceRule::MAP_VARIABLES_UNIQUE: EXPECT_EQ("18.1.3", e->referenceHeading()); break; diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index a31246e53..25c0bc900 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -1542,7 +1542,7 @@ TEST(Validator, unitAmericanSpellingOfUnitsRemoved) const std::vector expectedIssues = { "Variable 'tomahto' in component 'comp2' has a units reference 'testunit2' which is neither standard nor defined in the parent model.", "Units reference 'meter' in units 'testunit2' is not a valid reference to a local units or a standard unit type.", - "Variable 'tomayto' has units of 'testunit1' and an equivalent variable 'tomahto' with non-matching units of 'testunit2'. The mismatch is: metre^1.", + "Variable 'tomayto' in component 'comp1' has units of 'testunit1' and an equivalent variable 'tomahto' in component 'comp2' with non-matching units of 'testunit2'. The mismatch is: metre^1.", }; // This one is now an issue. @@ -1777,8 +1777,7 @@ TEST(Validator, unitEquivalenceMultiplierPrefix) TEST(Validator, unitEquivalenceComplicatedNestedUnits) { const std::vector expectedIssues = { - "Variable 'pjs' has units of 'testunit13' and an equivalent variable 'pajamas' with non-matching units of 'testunit14'. The mismatch is: metre^1, multiplication factor of 10^3.", - }; + "Variable 'pjs' in component 'yousay' has units of 'testunit13' and an equivalent variable 'pajamas' in component 'wesay' with non-matching units of 'testunit14'. The mismatch is: metre^1, multiplication factor of 10^3."}; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = libcellml::Model::create(); @@ -1869,6 +1868,7 @@ TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) { // This test is intended to demonstrate that the effect of different multiplicator sources (prefix, multiplier term) // does not affect the equivalence of the underlying base variables. + const std::vector expectedIssues = {"Variable 'v1' in component 'component1' has units of 'u4' and an equivalent variable 'v2' in component 'component2' has compatible but not equivalent units of 'u5'. The mismatch is: multiplication factor of 10^12."}; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr model = libcellml::Model::create(); @@ -1935,17 +1935,17 @@ TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) validator->validateModel(model); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(1), validator->issueCount()); EXPECT_EQ(size_t(0), validator->errorCount()); EXPECT_EQ(size_t(0), validator->hintCount()); - EXPECT_EQ(size_t(0), validator->warningCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unitUserCreatedUnitsBananasAndApples) { const std::vector expectedIssues = { - "Variable 'v1' has units of 'bushell_of_apples' and an equivalent variable 'v2' with non-matching units of 'bunch_of_bananas'. The mismatch is: apple^10, banana^-5.", - }; + "Variable 'v1' in component 'c1' has units of 'bushell_of_apples' and an equivalent variable 'v2' in component 'c2' with non-matching units of 'bunch_of_bananas'. The mismatch is: apple^10, banana^-5."}; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); @@ -1990,7 +1990,7 @@ TEST(Validator, unitIllDefinedEquivalentUnits) "Variable 'v1' does not have a valid units attribute.", "CellML identifiers must contain one or more basic Latin alphabetic characters.", "Variable 'v2' does not have a valid units attribute.", - "Variable 'v1' has units of '' and an equivalent variable 'v2' with non-matching units of ''. The mismatch is: ", + "Variable 'v1' in component 'c1' has units of '' and an equivalent variable 'v2' in component 'c2' with non-matching units of ''. The mismatch is: ", }; libcellml::ValidatorPtr validator = libcellml::Validator::create(); @@ -2010,8 +2010,7 @@ TEST(Validator, unitIllDefinedEquivalentUnits) TEST(Validator, unitStandardUnitsWhichAreBaseUnits) { const std::vector expectedIssues = { - "Variable 'v1' has units of 'metre' and an equivalent variable 'v2' with non-matching units of 'second'. The mismatch is: metre^1, second^-1.", - }; + "Variable 'v1' in component 'c1' has units of 'metre' and an equivalent variable 'v2' in component 'c2' with non-matching units of 'second'. The mismatch is: metre^1, second^-1."}; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); @@ -2033,8 +2032,7 @@ TEST(Validator, unitStandardUnitsWhichAreBaseUnits) TEST(Validator, unitStandardUnitsWhichAreNotBaseUnits) { const std::vector expectedIssues = { - "Variable 'v1' has units of 'litre' and an equivalent variable 'v2' with non-matching units of 'gram'. The mismatch is: kilogram^-1, metre^3.", - }; + "Variable 'v1' in component 'c1' has units of 'litre' and an equivalent variable 'v2' in component 'c2' with non-matching units of 'gram'. The mismatch is: kilogram^-1, metre^3."}; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); @@ -2055,6 +2053,8 @@ TEST(Validator, unitStandardUnitsWhichAreNotBaseUnits) TEST(Validator, unitMultiplierFactorDifference) { + const std::vector expectedIssues = { + "Variable 'v1' in component 'c1' has units of 'litre' and an equivalent variable 'v2' in component 'c2' has compatible but not equivalent units of 'big_barrel'. The mismatch is: multiplication factor of 10^-3."}; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); auto c1 = m->component(0); @@ -2077,10 +2077,11 @@ TEST(Validator, unitMultiplierFactorDifference) validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(1), validator->issueCount()); EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(0), validator->warningCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); EXPECT_EQ(size_t(0), validator->hintCount()); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unitStandardMultipliersLitre) @@ -2341,6 +2342,8 @@ TEST(Validator, validateModelWithoutAndWithMath) TEST(Validator, unitEquivalenceMultiplier) { + const std::vector expectedIssues = { + "Variable 'v1' in component 'comp1' has units of 'u1' and an equivalent variable 'v2' in component 'comp2' has compatible but not equivalent units of 'u2'. The mismatch is: multiplication factor of 10^1."}; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = libcellml::Model::create(); libcellml::ComponentPtr comp1 = libcellml::Component::create(); @@ -2378,10 +2381,11 @@ TEST(Validator, unitEquivalenceMultiplier) validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->issueCount()); + EXPECT_EQ(size_t(1), validator->issueCount()); EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(0), validator->warningCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); EXPECT_EQ(size_t(0), validator->hintCount()); + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, unfoundUnitsInEncapsulatedComponents) @@ -2421,6 +2425,8 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) TEST(Validator, mismatchedMultipliersInUnits) { + const std::vector expectedIssues = { + "Variable 'v1' in component 'Brobdingnag' has units of 'megametre' and an equivalent variable 'v2' in component 'Lilliput' has compatible but not equivalent units of 'millimetre'. The mismatch is: multiplication factor of 10^9."}; auto model = libcellml::Model::create("Gulliver"); auto c1 = libcellml::Component::create("Brobdingnag"); auto c2 = libcellml::Component::create("Lilliput"); @@ -2435,6 +2441,8 @@ TEST(Validator, mismatchedMultipliersInUnits) v1->setUnits(u1); v2->setUnits(u2); + v1->setInterfaceType("public"); + v2->setInterfaceType("public"); c1->addVariable(v1); c2->addVariable(v2); model->addComponent(c1); @@ -2447,10 +2455,12 @@ TEST(Validator, mismatchedMultipliersInUnits) auto validator = libcellml::Validator::create(); validator->validateModel(model); - EXPECT_EQ(size_t(2), validator->issueCount()); + EXPECT_EQ(size_t(1), validator->issueCount()); EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(2), validator->warningCount()); + EXPECT_EQ(size_t(1), validator->warningCount()); EXPECT_EQ(size_t(0), validator->hintCount()); + + EXPECT_EQ_ISSUES(expectedIssues, validator); } TEST(Validator, variableEquivalenceValidNetwork) From 1d769999c8d86645ef0f67732639fd4c7192519c Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 19 Mar 2020 09:32:56 +1300 Subject: [PATCH 60/88] Review fixes (take 1) --- src/bindings/interface/types.i | 2 +- src/bindings/python/CMakeLists.txt | 2 +- src/issue.cpp | 1 + src/logger.cpp | 6 ++---- src/validator.cpp | 16 ---------------- tests/issue/issue.cpp | 9 +-------- tests/test_utils.h | 7 ------- tests/validator/validator.cpp | 12 ++++++++---- 8 files changed, 14 insertions(+), 41 deletions(-) diff --git a/src/bindings/interface/types.i b/src/bindings/interface/types.i index e6b10dfad..4472c4152 100644 --- a/src/bindings/interface/types.i +++ b/src/bindings/interface/types.i @@ -8,11 +8,11 @@ Only meant to be included, shouldn't be passed to cmake as a module! %shared_ptr(libcellml::Component) %shared_ptr(libcellml::ComponentEntity) %shared_ptr(libcellml::Entity) -%shared_ptr(libcellml::Issue) %shared_ptr(libcellml::Generator) %shared_ptr(libcellml::GeneratorProfile) %shared_ptr(libcellml::ImportSource) %shared_ptr(libcellml::ImportedEntity) +%shared_ptr(libcellml::Issue) %shared_ptr(libcellml::Logger) %shared_ptr(libcellml::Model) %shared_ptr(libcellml::NamedEntity) diff --git a/src/bindings/python/CMakeLists.txt b/src/bindings/python/CMakeLists.txt index c953613d0..ac5cbb2c2 100644 --- a/src/bindings/python/CMakeLists.txt +++ b/src/bindings/python/CMakeLists.txt @@ -32,8 +32,8 @@ set(SWIG_INTERFACE_SRCS ../interface/namedentity.i ../interface/parser.i ../interface/printer.i - ../interface/reset.i ../interface/referencerule.i + ../interface/reset.i ../interface/units.i ../interface/validator.i ../interface/variable.i diff --git a/src/issue.cpp b/src/issue.cpp index fa2b294cc..87420e54f 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -16,6 +16,7 @@ limitations under the License. #include "libcellml/issue.h" #include "libcellml/types.h" + #include "utilities.h" #include diff --git a/src/logger.cpp b/src/logger.cpp index dfc7d9241..997ff70bf 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -100,11 +100,9 @@ void Logger::removeAllIssues() void Logger::addIssue(const IssuePtr &issue) { - // When an issue is added + // When an issue is added, update the appropriate array based on its level. + size_t index = mPimpl->mIssues.size(); mPimpl->mIssues.push_back(issue); - size_t index = mPimpl->mIssues.size() - 1; - // Update the appropriate array based on its level - libcellml::Issue::Level level = issue->level(); switch (level) { case libcellml::Issue::Level::ERROR: diff --git a/src/validator.cpp b/src/validator.cpp index 64b05a80d..6fa7938d1 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -273,22 +273,6 @@ struct Validator::ValidatorImpl */ bool isSupportedMathMLElement(const XmlNodePtr &node); - /** - * @brief Validate that equivalent variable pairs in the @p model - * have equivalent units. - * Any issues will be logged in the @c Validator. - * - * Any difference in base units is reported as an issue in the @c Validator, but the multiplier difference does not trigger a validator issue. - * Where the base units are equivalent, the multiplier may be interpreted as units_of_v1 = (10^multiplier)*units_of_v2 - * - * @param model The model containing the variables - * @param v1 The variable which may contain units. - * @param v2 The equivalent variable which may contain units. - * @param hints String containing issue messages to be passed back to the calling function for logging. - * @param multiplier Double returning the effective multiplier mismatch between the units. - */ - // KRM bool unitsAreEquivalent(const ModelPtr &model, const VariablePtr &v1, const VariablePtr &v2, std::string &hints, double &multiplier); - /** * @brief Utility function used by unitsAreEquivalent to compare base units of two variables. * diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index ca4b5ca14..a1170c3ac 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -15,7 +15,6 @@ limitations under the License-> */ #include "gtest/gtest.h" -#include "libcellml/referencerules.h" #include @@ -411,9 +410,7 @@ TEST(Issue, createModelWarning) { libcellml::ModelPtr m = libcellml::Model::create(); libcellml::IssuePtr e = libcellml::Issue::create(m); - e->setLevel(libcellml::Issue::Level::WARNING); - EXPECT_EQ(libcellml::Issue::Cause::MODEL, e->cause()); EXPECT_EQ(libcellml::Issue::Level::WARNING, e->level()); } @@ -432,7 +429,6 @@ TEST(Issue, createVariableWarning) libcellml::VariablePtr v = libcellml::Variable::create(); libcellml::IssuePtr e = libcellml::Issue::create(v); e->setLevel(libcellml::Issue::Level::WARNING); - EXPECT_EQ(libcellml::Issue::Cause::VARIABLE, e->cause()); EXPECT_EQ(libcellml::Issue::Level::WARNING, e->level()); } @@ -442,7 +438,6 @@ TEST(Issue, createUnitsWarning) libcellml::UnitsPtr u = libcellml::Units::create(); libcellml::IssuePtr e = libcellml::Issue::create(u); e->setLevel(libcellml::Issue::Level::WARNING); - EXPECT_EQ(libcellml::Issue::Cause::UNITS, e->cause()); EXPECT_EQ(libcellml::Issue::Level::WARNING, e->level()); } @@ -452,7 +447,6 @@ TEST(Issue, createImportSourceWarning) libcellml::ImportSourcePtr i = libcellml::ImportSource::create(); libcellml::IssuePtr e = libcellml::Issue::create(i); e->setLevel(libcellml::Issue::Level::WARNING); - EXPECT_EQ(libcellml::Issue::Cause::IMPORT, e->cause()); EXPECT_EQ(libcellml::Issue::Level::WARNING, e->level()); } @@ -462,7 +456,6 @@ TEST(Issue, createResetWarning) libcellml::ResetPtr r = libcellml::Reset::create(); libcellml::IssuePtr e = libcellml::Issue::create(r); e->setLevel(libcellml::Issue::Level::WARNING); - EXPECT_EQ(libcellml::Issue::Cause::RESET, e->cause()); EXPECT_EQ(libcellml::Issue::Level::WARNING, e->level()); } @@ -478,6 +471,7 @@ TEST(Issue, isWarning) { auto e = libcellml::Issue::create(); e->setLevel(libcellml::Issue::Level::WARNING); + EXPECT_TRUE(e->isLevel(libcellml::Issue::Level::WARNING)); } @@ -494,7 +488,6 @@ TEST(Issue, isHint) // auto e = libcellml::Issue::create(); // e->setRule(libcellml::ReferenceRule::MODEL_NAME); // auto ref = e->referenceHeading(); - // // TODO How to get this from the utilties.h file?? Won't be this address in the long run. // std::string url = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q=" + ref; // EXPECT_EQ(e->url(), url); diff --git a/tests/test_utils.h b/tests/test_utils.h index 894312918..64ec9f64a 100644 --- a/tests/test_utils.h +++ b/tests/test_utils.h @@ -74,24 +74,17 @@ struct Debug }; std::string TEST_EXPORT resourcePath(const std::string &resourceRelativePath = ""); - std::string TEST_EXPORT fileContents(const std::string &fileName); - void TEST_EXPORT printIssues(const libcellml::LoggerPtr &l, bool headings = false, bool causes = false, bool rule = false); - void TEST_EXPORT printComponent(const libcellml::ComponentPtr &component, size_t const c, std::string const spacer); - void TEST_EXPORT printModel(const libcellml::ModelPtr &model); - void TEST_EXPORT expectEqualIssues(const std::vector &issues, const libcellml::LoggerPtr &logger); - void TEST_EXPORT expectEqualIssuesSpecificationHeadings(const std::vector &issues, const std::vector &specificationHeadings, const libcellml::LoggerPtr &logger); void TEST_EXPORT expectEqualIssuesCauses(const std::vector &issues, const std::vector &causes, const libcellml::LoggerPtr &logger); - libcellml::ModelPtr TEST_EXPORT createModel(const std::string &name = ""); libcellml::ModelPtr TEST_EXPORT createModelWithComponent(const std::string &name = ""); libcellml::VariablePtr TEST_EXPORT createVariableWithUnits(const std::string &name, const std::string &units); diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 25c0bc900..9592da23b 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -1777,7 +1777,8 @@ TEST(Validator, unitEquivalenceMultiplierPrefix) TEST(Validator, unitEquivalenceComplicatedNestedUnits) { const std::vector expectedIssues = { - "Variable 'pjs' in component 'yousay' has units of 'testunit13' and an equivalent variable 'pajamas' in component 'wesay' with non-matching units of 'testunit14'. The mismatch is: metre^1, multiplication factor of 10^3."}; + "Variable 'pjs' in component 'yousay' has units of 'testunit13' and an equivalent variable 'pajamas' in component 'wesay' with non-matching units of 'testunit14'. The mismatch is: metre^1, multiplication factor of 10^3.", + }; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = libcellml::Model::create(); @@ -2010,7 +2011,8 @@ TEST(Validator, unitIllDefinedEquivalentUnits) TEST(Validator, unitStandardUnitsWhichAreBaseUnits) { const std::vector expectedIssues = { - "Variable 'v1' in component 'c1' has units of 'metre' and an equivalent variable 'v2' in component 'c2' with non-matching units of 'second'. The mismatch is: metre^1, second^-1."}; + "Variable 'v1' in component 'c1' has units of 'metre' and an equivalent variable 'v2' in component 'c2' with non-matching units of 'second'. The mismatch is: metre^1, second^-1.", + }; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); @@ -2054,7 +2056,8 @@ TEST(Validator, unitStandardUnitsWhichAreNotBaseUnits) TEST(Validator, unitMultiplierFactorDifference) { const std::vector expectedIssues = { - "Variable 'v1' in component 'c1' has units of 'litre' and an equivalent variable 'v2' in component 'c2' has compatible but not equivalent units of 'big_barrel'. The mismatch is: multiplication factor of 10^-3."}; + "Variable 'v1' in component 'c1' has units of 'litre' and an equivalent variable 'v2' in component 'c2' has compatible but not equivalent units of 'big_barrel'. The mismatch is: multiplication factor of 10^-3.", + }; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); auto c1 = m->component(0); @@ -2426,7 +2429,8 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) TEST(Validator, mismatchedMultipliersInUnits) { const std::vector expectedIssues = { - "Variable 'v1' in component 'Brobdingnag' has units of 'megametre' and an equivalent variable 'v2' in component 'Lilliput' has compatible but not equivalent units of 'millimetre'. The mismatch is: multiplication factor of 10^9."}; + "Variable 'v1' in component 'Brobdingnag' has units of 'megametre' and an equivalent variable 'v2' in component 'Lilliput' has compatible but not equivalent units of 'millimetre'. The mismatch is: multiplication factor of 10^9.", + }; auto model = libcellml::Model::create("Gulliver"); auto c1 = libcellml::Component::create("Brobdingnag"); auto c2 = libcellml::Component::create("Lilliput"); From 7a7b6dd36db8fcf74bc409ac8c751cc1899e3b2b Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 19 Mar 2020 09:51:06 +1300 Subject: [PATCH 61/88] Removing warning example and related tests --- src/validator.cpp | 43 ++-- tests/validator/validator.cpp | 387 +++++++++++++++++----------------- 2 files changed, 219 insertions(+), 211 deletions(-) diff --git a/src/validator.cpp b/src/validator.cpp index 6fa7938d1..9df5d0b6e 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -1096,27 +1096,28 @@ void Validator::ValidatorImpl::validateEquivalenceUnits(const ModelPtr &model, c err->setRule(ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); mValidator->addIssue(err); } - } else if (multiplier != 0.0) { - VariablePair reversePair = std::make_pair(equivalentVariable, variable); - auto it = std::find(alreadyReported.begin(), alreadyReported.end(), reversePair); - if (it == alreadyReported.end()) { - VariablePair pair = std::make_pair(variable, equivalentVariable); - ComponentPtr parent1 = std::dynamic_pointer_cast(variable->parent()); - ComponentPtr parent2 = std::dynamic_pointer_cast(equivalentVariable->parent()); - alreadyReported.push_back(pair); - auto unitsName = variable->units() == nullptr ? "" : variable->units()->name(); - auto equivalentUnitsName = equivalentVariable->units() == nullptr ? "" : equivalentVariable->units()->name(); - IssuePtr err = Issue::create(); - std::string des = "Variable '" + variable->name() + "' in component '" + parent1->name() + "' has units of '" + unitsName; - des += "' and an equivalent variable '" + equivalentVariable->name() + "' in component '" + parent2->name(); - des += "' has compatible but not equivalent units of '" + equivalentUnitsName + "'. The mismatch is: " + hints; - err->setModel(model); - err->setDescription(des); - err->setCause(Issue::Cause::UNITS); - err->setRule(ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); - err->setLevel(Issue::Level::WARNING); - mValidator->addIssue(err); - } + // TODO Removed until after PR 521 has been merged. + // } else if (multiplier != 0.0) { + // VariablePair reversePair = std::make_pair(equivalentVariable, variable); + // auto it = std::find(alreadyReported.begin(), alreadyReported.end(), reversePair); + // if (it == alreadyReported.end()) { + // VariablePair pair = std::make_pair(variable, equivalentVariable); + // ComponentPtr parent1 = std::dynamic_pointer_cast(variable->parent()); + // ComponentPtr parent2 = std::dynamic_pointer_cast(equivalentVariable->parent()); + // alreadyReported.push_back(pair); + // auto unitsName = variable->units() == nullptr ? "" : variable->units()->name(); + // auto equivalentUnitsName = equivalentVariable->units() == nullptr ? "" : equivalentVariable->units()->name(); + // IssuePtr err = Issue::create(); + // std::string des = "Variable '" + variable->name() + "' in component '" + parent1->name() + "' has units of '" + unitsName; + // des += "' and an equivalent variable '" + equivalentVariable->name() + "' in component '" + parent2->name(); + // des += "' has compatible but not equivalent units of '" + equivalentUnitsName + "'. The mismatch is: " + hints; + // err->setModel(model); + // err->setDescription(des); + // err->setCause(Issue::Cause::UNITS); + // err->setRule(ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); + // err->setLevel(Issue::Level::WARNING); + // mValidator->addIssue(err); + // } } } } diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 9592da23b..e2610e984 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -1865,83 +1865,86 @@ TEST(Validator, unitEquivalenceComplicatedNestedUnits) EXPECT_EQ_ISSUES(expectedIssues, validator); } -TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) -{ - // This test is intended to demonstrate that the effect of different multiplicator sources (prefix, multiplier term) - // does not affect the equivalence of the underlying base variables. - const std::vector expectedIssues = {"Variable 'v1' in component 'component1' has units of 'u4' and an equivalent variable 'v2' in component 'component2' has compatible but not equivalent units of 'u5'. The mismatch is: multiplication factor of 10^12."}; - - libcellml::ValidatorPtr validator = libcellml::Validator::create(); - libcellml::ModelPtr model = libcellml::Model::create(); - - libcellml::ComponentPtr comp1 = libcellml::Component::create(); - libcellml::ComponentPtr comp2 = libcellml::Component::create(); - - libcellml::VariablePtr v1 = libcellml::Variable::create(); - libcellml::VariablePtr v2 = libcellml::Variable::create(); - - v1->setName("v1"); - v1->setInterfaceType("public"); - v2->setName("v2"); - v2->setInterfaceType("public"); - - // millimetres - libcellml::UnitsPtr u1 = libcellml::Units::create(); - u1->setName("u1"); - u1->addUnit("metre", "milli"); // standard, prefix. - - // mm^3 - libcellml::UnitsPtr u2 = libcellml::Units::create(); - u2->setName("u2"); - u2->addUnit("u1", 3.0); // standard, exponent. - - // mm^6 - libcellml::UnitsPtr u3 = libcellml::Units::create(); - u3->setName("u3"); - u3->addUnit("u2", 2.0); // standard, exponent. - - // m^6 - libcellml::UnitsPtr u4 = libcellml::Units::create(); - u4->setName("u4"); - u4->addUnit("u3", 15, 1.0); // standard, prefix, exponent. - - libcellml::UnitsPtr u5 = libcellml::Units::create(); - u5->setName("u5"); - u5->addUnit("metre", 6.0); // standard, exponent. - - // u4 ~= u5: Units will be equivalent, testing that prefix, multiplier, and exponent validation is correct. - // Note: there is a factor of 1000 between u4 and u5 since u4 = 10^15*u3 (rather than 10^18*u3), which is - // fine since we only need units to be equivalent for validation. - // TODO: see issue in specification: https://github.com/cellml/cellml-specification/issues/19. - v1->setUnits(u4); - v2->setUnits(u5); - - comp1->setName("component1"); - comp1->addVariable(v1); - - comp2->setName("component2"); - comp2->addVariable(v2); - - model->setName("model"); - model->addComponent(comp1); - model->addComponent(comp2); - - model->addUnits(u1); - model->addUnits(u2); - model->addUnits(u3); - model->addUnits(u4); - model->addUnits(u5); - - libcellml::Variable::addEquivalence(v1, v2); - - validator->validateModel(model); - - EXPECT_EQ(size_t(1), validator->issueCount()); - EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(0), validator->hintCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); - EXPECT_EQ_ISSUES(expectedIssues, validator); -} +// TODO Removed until after PR521 has been merged. +// TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) +// { +// // This test is intended to demonstrate that the effect of different multiplicator sources (prefix, multiplier term) +// // does not affect the equivalence of the underlying base variables. +// const std::vector expectedIssues = { +// "Variable 'v1' in component 'component1' has units of 'u4' and an equivalent variable 'v2' in component 'component2' has compatible but not equivalent units of 'u5'. The mismatch is: multiplication factor of 10^12.", +// }; + +// libcellml::ValidatorPtr validator = libcellml::Validator::create(); +// libcellml::ModelPtr model = libcellml::Model::create(); + +// libcellml::ComponentPtr comp1 = libcellml::Component::create(); +// libcellml::ComponentPtr comp2 = libcellml::Component::create(); + +// libcellml::VariablePtr v1 = libcellml::Variable::create(); +// libcellml::VariablePtr v2 = libcellml::Variable::create(); + +// v1->setName("v1"); +// v1->setInterfaceType("public"); +// v2->setName("v2"); +// v2->setInterfaceType("public"); + +// // millimetres +// libcellml::UnitsPtr u1 = libcellml::Units::create(); +// u1->setName("u1"); +// u1->addUnit("metre", "milli"); // standard, prefix. + +// // mm^3 +// libcellml::UnitsPtr u2 = libcellml::Units::create(); +// u2->setName("u2"); +// u2->addUnit("u1", 3.0); // standard, exponent. + +// // mm^6 +// libcellml::UnitsPtr u3 = libcellml::Units::create(); +// u3->setName("u3"); +// u3->addUnit("u2", 2.0); // standard, exponent. + +// // m^6 +// libcellml::UnitsPtr u4 = libcellml::Units::create(); +// u4->setName("u4"); +// u4->addUnit("u3", 15, 1.0); // standard, prefix, exponent. + +// libcellml::UnitsPtr u5 = libcellml::Units::create(); +// u5->setName("u5"); +// u5->addUnit("metre", 6.0); // standard, exponent. + +// // u4 ~= u5: Units will be equivalent, testing that prefix, multiplier, and exponent validation is correct. +// // Note: there is a factor of 1000 between u4 and u5 since u4 = 10^15*u3 (rather than 10^18*u3), which is +// // fine since we only need units to be equivalent for validation. +// // TODO: see issue in specification: https://github.com/cellml/cellml-specification/issues/19. +// v1->setUnits(u4); +// v2->setUnits(u5); + +// comp1->setName("component1"); +// comp1->addVariable(v1); + +// comp2->setName("component2"); +// comp2->addVariable(v2); + +// model->setName("model"); +// model->addComponent(comp1); +// model->addComponent(comp2); + +// model->addUnits(u1); +// model->addUnits(u2); +// model->addUnits(u3); +// model->addUnits(u4); +// model->addUnits(u5); + +// libcellml::Variable::addEquivalence(v1, v2); + +// validator->validateModel(model); + +// EXPECT_EQ(size_t(1), validator->issueCount()); +// EXPECT_EQ(size_t(0), validator->errorCount()); +// EXPECT_EQ(size_t(0), validator->hintCount()); +// EXPECT_EQ(size_t(1), validator->warningCount()); +// EXPECT_EQ_ISSUES(expectedIssues, validator); +// } TEST(Validator, unitUserCreatedUnitsBananasAndApples) { @@ -2053,39 +2056,40 @@ TEST(Validator, unitStandardUnitsWhichAreNotBaseUnits) EXPECT_EQ_ISSUES(expectedIssues, validator); } -TEST(Validator, unitMultiplierFactorDifference) -{ - const std::vector expectedIssues = { - "Variable 'v1' in component 'c1' has units of 'litre' and an equivalent variable 'v2' in component 'c2' has compatible but not equivalent units of 'big_barrel'. The mismatch is: multiplication factor of 10^-3.", - }; - libcellml::ValidatorPtr validator = libcellml::Validator::create(); - libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); - auto c1 = m->component(0); - auto c2 = m->component(1); - auto v1 = c1->variable(0); - auto v2 = c2->variable(0); +// TODO Removed until after PR 521 has been merged +// TEST(Validator, unitMultiplierFactorDifference) +// { +// const std::vector expectedIssues = { +// "Variable 'v1' in component 'c1' has units of 'litre' and an equivalent variable 'v2' in component 'c2' has compatible but not equivalent units of 'big_barrel'. The mismatch is: multiplication factor of 10^-3.", +// }; +// libcellml::ValidatorPtr validator = libcellml::Validator::create(); +// libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); +// auto c1 = m->component(0); +// auto c2 = m->component(1); +// auto v1 = c1->variable(0); +// auto v2 = c2->variable(0); - v1->setUnits("litre"); +// v1->setUnits("litre"); - libcellml::UnitsPtr u = libcellml::Units::create(); - u->setName("big_barrel"); - u->addUnit("metre", 3.0); - m->addUnits(u); +// libcellml::UnitsPtr u = libcellml::Units::create(); +// u->setName("big_barrel"); +// u->addUnit("metre", 3.0); +// m->addUnits(u); - v2->setUnits("big_barrel"); +// v2->setUnits("big_barrel"); - libcellml::Variable::addEquivalence(v1, v2); // 1000L = 1m^3 +// libcellml::Variable::addEquivalence(v1, v2); // 1000L = 1m^3 - m->linkUnits(); +// m->linkUnits(); - validator->validateModel(m); +// validator->validateModel(m); - EXPECT_EQ(size_t(1), validator->issueCount()); - EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); - EXPECT_EQ(size_t(0), validator->hintCount()); - EXPECT_EQ_ISSUES(expectedIssues, validator); -} +// EXPECT_EQ(size_t(1), validator->issueCount()); +// EXPECT_EQ(size_t(0), validator->errorCount()); +// EXPECT_EQ(size_t(1), validator->warningCount()); +// EXPECT_EQ(size_t(0), validator->hintCount()); +// EXPECT_EQ_ISSUES(expectedIssues, validator); +// } TEST(Validator, unitStandardMultipliersLitre) { @@ -2343,53 +2347,55 @@ TEST(Validator, validateModelWithoutAndWithMath) EXPECT_EQ(size_t(0), validator->issueCount()); } -TEST(Validator, unitEquivalenceMultiplier) -{ - const std::vector expectedIssues = { - "Variable 'v1' in component 'comp1' has units of 'u1' and an equivalent variable 'v2' in component 'comp2' has compatible but not equivalent units of 'u2'. The mismatch is: multiplication factor of 10^1."}; - libcellml::ValidatorPtr validator = libcellml::Validator::create(); - libcellml::ModelPtr m = libcellml::Model::create(); - libcellml::ComponentPtr comp1 = libcellml::Component::create(); - libcellml::ComponentPtr comp2 = libcellml::Component::create(); - libcellml::VariablePtr v1 = libcellml::Variable::create(); - libcellml::VariablePtr v2 = libcellml::Variable::create(); - - v1->setName("v1"); - v1->setInterfaceType("public"); - v2->setName("v2"); - v2->setInterfaceType("public"); - m->setName("model"); - comp1->setName("comp1"); - comp2->setName("comp2"); - comp1->addVariable(v1); - comp2->addVariable(v2); - m->addComponent(comp1); - m->addComponent(comp2); - - // u1 = 10*u2 - libcellml::UnitsPtr u1 = libcellml::Units::create(); - u1->setName("u1"); - u1->addUnit("metre", 1, 1.0, 10.0); - libcellml::UnitsPtr u2 = libcellml::Units::create(); - u2->setName("u2"); - u2->addUnit("metre", 1, 1.0, 1.0); - - v1->setUnits(u1); - v2->setUnits(u2); - - m->addUnits(u1); - m->addUnits(u2); - - libcellml::Variable::addEquivalence(v1, v2); - - validator->validateModel(m); - - EXPECT_EQ(size_t(1), validator->issueCount()); - EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); - EXPECT_EQ(size_t(0), validator->hintCount()); - EXPECT_EQ_ISSUES(expectedIssues, validator); -} +// TODO Removed until after PR 521 is merged. +// TEST(Validator, unitEquivalenceMultiplier) +// { +// const std::vector expectedIssues = { +// "Variable 'v1' in component 'comp1' has units of 'u1' and an equivalent variable 'v2' in component 'comp2' has compatible but not equivalent units of 'u2'. The mismatch is: multiplication factor of 10^1.", +// }; +// libcellml::ValidatorPtr validator = libcellml::Validator::create(); +// libcellml::ModelPtr m = libcellml::Model::create(); +// libcellml::ComponentPtr comp1 = libcellml::Component::create(); +// libcellml::ComponentPtr comp2 = libcellml::Component::create(); +// libcellml::VariablePtr v1 = libcellml::Variable::create(); +// libcellml::VariablePtr v2 = libcellml::Variable::create(); + +// v1->setName("v1"); +// v1->setInterfaceType("public"); +// v2->setName("v2"); +// v2->setInterfaceType("public"); +// m->setName("model"); +// comp1->setName("comp1"); +// comp2->setName("comp2"); +// comp1->addVariable(v1); +// comp2->addVariable(v2); +// m->addComponent(comp1); +// m->addComponent(comp2); + +// // u1 = 10*u2 +// libcellml::UnitsPtr u1 = libcellml::Units::create(); +// u1->setName("u1"); +// u1->addUnit("metre", 1, 1.0, 10.0); +// libcellml::UnitsPtr u2 = libcellml::Units::create(); +// u2->setName("u2"); +// u2->addUnit("metre", 1, 1.0, 1.0); + +// v1->setUnits(u1); +// v2->setUnits(u2); + +// m->addUnits(u1); +// m->addUnits(u2); + +// libcellml::Variable::addEquivalence(v1, v2); + +// validator->validateModel(m); + +// EXPECT_EQ(size_t(1), validator->issueCount()); +// EXPECT_EQ(size_t(0), validator->errorCount()); +// EXPECT_EQ(size_t(1), validator->warningCount()); +// EXPECT_EQ(size_t(0), validator->hintCount()); +// EXPECT_EQ_ISSUES(expectedIssues, validator); +// } TEST(Validator, unfoundUnitsInEncapsulatedComponents) { @@ -2426,46 +2432,47 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) EXPECT_EQ_ISSUES(expectedIssues, v); } -TEST(Validator, mismatchedMultipliersInUnits) -{ - const std::vector expectedIssues = { - "Variable 'v1' in component 'Brobdingnag' has units of 'megametre' and an equivalent variable 'v2' in component 'Lilliput' has compatible but not equivalent units of 'millimetre'. The mismatch is: multiplication factor of 10^9.", - }; - auto model = libcellml::Model::create("Gulliver"); - auto c1 = libcellml::Component::create("Brobdingnag"); - auto c2 = libcellml::Component::create("Lilliput"); - auto v1 = libcellml::Variable::create("v1"); - auto v2 = libcellml::Variable::create("v2"); - - auto u1 = libcellml::Units::create("megametre"); - u1->addUnit("metre", "mega"); - - auto u2 = libcellml::Units::create("millimetre"); - u2->addUnit("metre", "milli"); - - v1->setUnits(u1); - v2->setUnits(u2); - v1->setInterfaceType("public"); - v2->setInterfaceType("public"); - c1->addVariable(v1); - c2->addVariable(v2); - model->addComponent(c1); - model->addComponent(c2); - model->addUnits(u1); - model->addUnits(u2); - - libcellml::Variable::addEquivalence(v1, v2); - - auto validator = libcellml::Validator::create(); - validator->validateModel(model); - - EXPECT_EQ(size_t(1), validator->issueCount()); - EXPECT_EQ(size_t(0), validator->errorCount()); - EXPECT_EQ(size_t(1), validator->warningCount()); - EXPECT_EQ(size_t(0), validator->hintCount()); - - EXPECT_EQ_ISSUES(expectedIssues, validator); -} +// TODO Removed until after PR 521 is merged. +// TEST(Validator, mismatchedMultipliersInUnits) +// { +// const std::vector expectedIssues = { +// "Variable 'v1' in component 'Brobdingnag' has units of 'megametre' and an equivalent variable 'v2' in component 'Lilliput' has compatible but not equivalent units of 'millimetre'. The mismatch is: multiplication factor of 10^9.", +// }; +// auto model = libcellml::Model::create("Gulliver"); +// auto c1 = libcellml::Component::create("Brobdingnag"); +// auto c2 = libcellml::Component::create("Lilliput"); +// auto v1 = libcellml::Variable::create("v1"); +// auto v2 = libcellml::Variable::create("v2"); + +// auto u1 = libcellml::Units::create("megametre"); +// u1->addUnit("metre", "mega"); + +// auto u2 = libcellml::Units::create("millimetre"); +// u2->addUnit("metre", "milli"); + +// v1->setUnits(u1); +// v2->setUnits(u2); +// v1->setInterfaceType("public"); +// v2->setInterfaceType("public"); +// c1->addVariable(v1); +// c2->addVariable(v2); +// model->addComponent(c1); +// model->addComponent(c2); +// model->addUnits(u1); +// model->addUnits(u2); + +// libcellml::Variable::addEquivalence(v1, v2); + +// auto validator = libcellml::Validator::create(); +// validator->validateModel(model); + +// EXPECT_EQ(size_t(1), validator->issueCount()); +// EXPECT_EQ(size_t(0), validator->errorCount()); +// EXPECT_EQ(size_t(1), validator->warningCount()); +// EXPECT_EQ(size_t(0), validator->hintCount()); + +// EXPECT_EQ_ISSUES(expectedIssues, validator); +// } TEST(Validator, variableEquivalenceValidNetwork) { From 1227820eb03f4df6004cb5a015e0a3c44a45ade1 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 19 Mar 2020 10:07:06 +1300 Subject: [PATCH 62/88] Removing standard multiplier tests to another PR --- tests/validator/validator.cpp | 52 ----------------------------------- 1 file changed, 52 deletions(-) diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index e2610e984..db346f32d 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -2091,58 +2091,6 @@ TEST(Validator, unitStandardUnitsWhichAreNotBaseUnits) // EXPECT_EQ_ISSUES(expectedIssues, validator); // } -TEST(Validator, unitStandardMultipliersLitre) -{ - libcellml::ValidatorPtr validator = libcellml::Validator::create(); - libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); - auto c1 = m->component(0); - auto c2 = m->component(1); - auto v1 = c1->variable(0); - auto v2 = c2->variable(0); - - v1->setUnits("litre"); - - libcellml::UnitsPtr u = libcellml::Units::create(); - u->setName("decimetre_cubed"); - u->addUnit("metre", "deci", 3.0); // a litre is a (0.1m)^3 - m->addUnits(u); - - v2->setUnits("decimetre_cubed"); - - libcellml::Variable::addEquivalence(v1, v2); // litre = dm^3 . - - m->linkUnits(); - - validator->validateModel(m); - printIssues(validator); - - EXPECT_EQ(size_t(0), validator->issueCount()); -} - -TEST(Validator, unitStandardMultipliersGram) -{ - libcellml::ValidatorPtr validator = libcellml::Validator::create(); - libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); - auto c1 = m->component(0); - auto c2 = m->component(1); - auto v1 = c1->variable(0); - auto v2 = c2->variable(0); - - v1->setUnits("kilogram"); - - libcellml::UnitsPtr u = libcellml::Units::create(); - u->setName("thousand_grams"); - u->addUnit("gram", "kilo"); - m->addUnits(u); - v2->setUnits(u); - - libcellml::Variable::addEquivalence(v1, v2); - - m->linkUnits(); - validator->validateModel(m); - EXPECT_EQ(size_t(0), validator->issueCount()); -} - TEST(Validator, unitSimpleCycle) { // Testing that indirect dependence is caught in the unit cycles. The network is: From cdad7ab04b94c6bd7de5052c415322491edf7a03 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 19 Mar 2020 10:09:05 +1300 Subject: [PATCH 63/88] Formatting error strings with commas --- tests/validator/validator.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index db346f32d..4881a3a80 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -1371,7 +1371,8 @@ TEST(Validator, resetVariableOutsideComponent) { const std::vector expectedIssues = { "Reset in component 'c1' with order '1', with variable 'v2', with test_variable 'v1', refers to a variable 'v2' in a different component 'c2'.", - "Reset in component 'c2' with order '1', with variable 'v2', with test_variable 'v1', refers to a test_variable 'v1' in a different component 'c1'."}; + "Reset in component 'c2' with order '1', with variable 'v2', with test_variable 'v1', refers to a test_variable 'v1' in a different component 'c1'.", + }; libcellml::ModelPtr m = libcellml::Model::create(); libcellml::ComponentPtr c1 = libcellml::Component::create(); @@ -1949,7 +1950,8 @@ TEST(Validator, unitEquivalenceComplicatedNestedUnits) TEST(Validator, unitUserCreatedUnitsBananasAndApples) { const std::vector expectedIssues = { - "Variable 'v1' in component 'c1' has units of 'bushell_of_apples' and an equivalent variable 'v2' in component 'c2' with non-matching units of 'bunch_of_bananas'. The mismatch is: apple^10, banana^-5."}; + "Variable 'v1' in component 'c1' has units of 'bushell_of_apples' and an equivalent variable 'v2' in component 'c2' with non-matching units of 'bunch_of_bananas'. The mismatch is: apple^10, banana^-5.", + }; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); @@ -2037,7 +2039,8 @@ TEST(Validator, unitStandardUnitsWhichAreBaseUnits) TEST(Validator, unitStandardUnitsWhichAreNotBaseUnits) { const std::vector expectedIssues = { - "Variable 'v1' in component 'c1' has units of 'litre' and an equivalent variable 'v2' in component 'c2' with non-matching units of 'gram'. The mismatch is: kilogram^-1, metre^3."}; + "Variable 'v1' in component 'c1' has units of 'litre' and an equivalent variable 'v2' in component 'c2' with non-matching units of 'gram'. The mismatch is: kilogram^-1, metre^3.", + }; libcellml::ValidatorPtr validator = libcellml::Validator::create(); libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); From eb3fb4dda85e0076d567dc59f76293977af85dad Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 19 Mar 2020 10:19:53 +1300 Subject: [PATCH 64/88] Removed unneeded function declaration --- src/validator.cpp | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/src/validator.cpp b/src/validator.cpp index 9df5d0b6e..20221e8aa 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -273,22 +273,6 @@ struct Validator::ValidatorImpl */ bool isSupportedMathMLElement(const XmlNodePtr &node); - /** - * @brief Utility function used by unitsAreEquivalent to compare base units of two variables. - * - * @param model The model containing the variables. - * @param unitMap A list of the exponents of base variables. - * @param uName String name of the current variable being investigated. - * @param standardList Nested map of the conversion between built-in units and the base units they contain - * @param uExp Exponent of the current unit in its parent. - * @param direction Specify whether we want to increment (1) or decrement (-1). - */ - void updateBaseUnitCount(const ModelPtr &model, - std::map &unitMap, - double &multiplier, - const std::string &uName, - double uExp, double logMult, int direction); - /** * @brief Checks dependency hierarchies of units in the model. * From 310ee0838b326cf7ca42f4c267ef1ac87dea75aa Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 19 Mar 2020 15:50:02 +1300 Subject: [PATCH 65/88] rename rule and setRule, removed isCause, isIssue --- src/api/libcellml/issue.h | 26 +------ src/bindings/interface/issue.i | 10 +-- src/issue.cpp | 24 +----- src/parser.cpp | 80 ++++++++++---------- src/validator.cpp | 70 ++++++++--------- tests/bindings/python/test_issue.py | 22 ++---- tests/issue/issue.cpp | 113 ++++++++++++++-------------- tests/parser/parser.cpp | 4 +- tests/test_utils.cpp | 2 +- 9 files changed, 148 insertions(+), 203 deletions(-) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index f91d5bde3..09ff8b9cf 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -165,17 +165,6 @@ class LIBCELLML_EXPORT Issue */ Cause cause() const; - /** - * @brief Check whether the cause of this issue matches the argument cause. - * - * Return @c true if the @p cause matches the the @c Issue::Cause for this - * issue and @c false otherwise. - * - * @return @c true if the @p cause matches the the @c Issue::Cause for this - * issue and @c false otherwise. - */ - bool isCause(Cause cause) const; - /** * @brief Set the level of this issue. * @@ -196,17 +185,6 @@ class LIBCELLML_EXPORT Issue */ Level level() const; - /** - * @brief Check whether the level of this issue matches the argument level. - * - * Return @c true if the @p level matches the the @c Issue::Level for this - * issue and @c false otherwise. - * - * @return @c true if the @p level matches the the @c Issue::Level for this - * issue and @c false otherwise. - */ - bool isLevel(Level level) const; - /** * @brief Set the @c enum ReferenceRule of this issue. * @@ -215,7 +193,7 @@ class LIBCELLML_EXPORT Issue * * @param rule The @c ReferenceRule to set. */ - void setRule(ReferenceRule rule); + void setReferenceRule(ReferenceRule rule); /** * @brief Get the @c enum ReferenceRule of this issue. @@ -225,7 +203,7 @@ class LIBCELLML_EXPORT Issue * * @return The @c ReferenceRule for this issue. */ - ReferenceRule rule() const; + ReferenceRule referenceRule() const; // /** // * @brief Get the @c url of this issue. diff --git a/src/bindings/interface/issue.i b/src/bindings/interface/issue.i index be1ac4608..5af6d160a 100644 --- a/src/bindings/interface/issue.i +++ b/src/bindings/interface/issue.i @@ -20,9 +20,6 @@ "Get the ``cause`` of this issue. If no cause has been set for this issue, will return Cause::UNDEFINED."; -%feature("docstring") libcellml::Issue::isCause -"Tests if this issue matches the given ``cause``."; - %feature("docstring") libcellml::Issue::setCause "Sets the ``cause`` of this issue."; @@ -30,16 +27,13 @@ return Cause::UNDEFINED."; "Get the ``level`` of this issue. If no level has been set for this issue, Level::ERROR will be returned."; -%feature("docstring") libcellml::Issue::isLevel -"Tests if this issue matches the given ``level``."; - %feature("docstring") libcellml::Issue::setLevel "Sets the ``level`` of this issue."; -%feature("docstring") libcellml::Issue::rule +%feature("docstring") libcellml::Issue::referenceRule "Get the :class:`ReferenceRule` of this issue."; -%feature("docstring") libcellml::Issue::setRule +%feature("docstring") libcellml::Issue::setReferenceRule "Sets the :class:`ReferenceRule` for this issue."; %feature("docstring") libcellml::Issue::url diff --git a/src/issue.cpp b/src/issue.cpp index 87420e54f..c7ead73ec 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -150,15 +150,6 @@ Issue::Cause Issue::cause() const return mPimpl->mCause; } -bool Issue::isCause(Cause cause) const -{ - bool response = false; - if (mPimpl->mCause == cause) { - response = true; - } - return response; -} - void Issue::setLevel(Issue::Level level) { mPimpl->mLevel = level; @@ -169,21 +160,12 @@ Issue::Level Issue::level() const return mPimpl->mLevel; } -bool Issue::isLevel(Level level) const -{ - bool response = false; - if (mPimpl->mLevel == level) { - response = true; - } - return response; -} - -void Issue::setRule(ReferenceRule rule) +void Issue::setReferenceRule(ReferenceRule rule) { mPimpl->mRule = rule; } -ReferenceRule Issue::rule() const +ReferenceRule Issue::referenceRule() const { return mPimpl->mRule; } @@ -329,7 +311,7 @@ static const std::map ruleToHeading = { std::string Issue::referenceHeading() const { std::string heading = "X.Y.Z"; - auto search = ruleToHeading.find(rule()); + auto search = ruleToHeading.find(referenceRule()); if (search != ruleToHeading.end()) { heading = search->second; } diff --git a/src/parser.cpp b/src/parser.cpp index af1a0cf77..8996b39af 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -282,7 +282,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp issue->setDescription("Model element is of invalid type '" + node->name() + "'. A valid CellML root node should be of type 'model'."); } issue->setModel(model); - issue->setRule(ReferenceRule::MODEL_ELEMENT); + issue->setReferenceRule(ReferenceRule::MODEL_ELEMENT); mParser->addIssue(issue); return; } @@ -347,7 +347,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp issue->setDescription("Encapsulation in model '" + model->name() + "' does not contain any child elements."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setRule(ReferenceRule::ENCAPSULATION_COMPONENT_REF); + issue->setReferenceRule(ReferenceRule::ENCAPSULATION_COMPONENT_REF); mParser->addIssue(issue); } } else if (childNode->isCellmlElement("connection")) { @@ -359,7 +359,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr issue = Issue::create(); issue->setDescription("Model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); issue->setModel(model); - issue->setRule(ReferenceRule::MODEL_CHILD); + issue->setReferenceRule(ReferenceRule::MODEL_CHILD); mParser->addIssue(issue); } } else if (childNode->isComment()) { @@ -368,7 +368,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr issue = Issue::create(); issue->setDescription("Model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); issue->setModel(model); - issue->setRule(ReferenceRule::MODEL_CHILD); + issue->setReferenceRule(ReferenceRule::MODEL_CHILD); mParser->addIssue(issue); } childNode = childNode->next(); @@ -381,7 +381,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp issue->setDescription("Model '" + model->name() + "' has more than one encapsulation element."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setRule(ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); + issue->setReferenceRule(ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); mParser->addIssue(issue); } } @@ -528,7 +528,7 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN IssuePtr issue = Issue::create(); issue->setDescription("Component '" + component->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); issue->setComponent(component); - issue->setRule(ReferenceRule::COMPONENT_CHILD); + issue->setReferenceRule(ReferenceRule::COMPONENT_CHILD); mParser->addIssue(issue); } } else if (childNode->isComment()) { @@ -537,7 +537,7 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN IssuePtr issue = Issue::create(); issue->setDescription("Component '" + component->name() + "' has an invalid child element '" + childNode->name() + "'."); issue->setComponent(component); - issue->setRule(ReferenceRule::COMPONENT_CHILD); + issue->setReferenceRule(ReferenceRule::COMPONENT_CHILD); mParser->addIssue(issue); } childNode = childNode->next(); @@ -571,7 +571,7 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node IssuePtr issue = Issue::create(); issue->setDescription("Units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); issue->setUnits(units); - issue->setRule(ReferenceRule::UNITS_CHILD); + issue->setReferenceRule(ReferenceRule::UNITS_CHILD); mParser->addIssue(issue); } } else if (childNode->isComment()) { @@ -580,7 +580,7 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node IssuePtr issue = Issue::create(); issue->setDescription("Units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); issue->setUnits(units); - issue->setRule(ReferenceRule::UNITS_CHILD); + issue->setReferenceRule(ReferenceRule::UNITS_CHILD); mParser->addIssue(issue); } childNode = childNode->next(); @@ -631,7 +631,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr issue = Issue::create(); issue->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an exponent with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); issue->setUnits(units); - issue->setRule(ReferenceRule::UNIT_EXPONENT); + issue->setReferenceRule(ReferenceRule::UNIT_EXPONENT); mParser->addIssue(issue); } } else if (attribute->isType("multiplier")) { @@ -642,7 +642,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr issue = Issue::create(); issue->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has a multiplier with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); issue->setUnits(units); - issue->setRule(ReferenceRule::UNIT_MULTIPLIER); + issue->setReferenceRule(ReferenceRule::UNIT_MULTIPLIER); mParser->addIssue(issue); } } else if (attribute->isType("id")) { @@ -651,7 +651,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr issue = Issue::create(); issue->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); issue->setUnits(units); - issue->setRule(ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); + issue->setReferenceRule(ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); mParser->addIssue(issue); } attribute = attribute->next(); @@ -750,7 +750,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' does not have a valid component_1 in a connection element."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setRule(ReferenceRule::CONNECTION_COMPONENT1); + issue->setReferenceRule(ReferenceRule::CONNECTION_COMPONENT1); mParser->addIssue(issue); component1Missing = true; } @@ -759,7 +759,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' does not have a valid component_2 in a connection element."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setRule(ReferenceRule::CONNECTION_COMPONENT2); + issue->setReferenceRule(ReferenceRule::CONNECTION_COMPONENT2); mParser->addIssue(issue); component2Missing = true; } @@ -773,7 +773,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' must contain one or more 'map_variables' elements."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setRule(ReferenceRule::CONNECTION_MAP_VARIABLES); + issue->setReferenceRule(ReferenceRule::CONNECTION_MAP_VARIABLES); mParser->addIssue(issue); return; } @@ -831,7 +831,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_1 in a map_variables element."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); + issue->setReferenceRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); mParser->addIssue(issue); variable1Missing = true; } @@ -840,7 +840,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_2 in a map_variables element."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); + issue->setReferenceRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); mParser->addIssue(issue); variable2Missing = true; } @@ -884,7 +884,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.first + "' as component_1 but it does not exist in the model."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setRule(ReferenceRule::CONNECTION_COMPONENT1); + issue->setReferenceRule(ReferenceRule::CONNECTION_COMPONENT1); mParser->addIssue(issue); } } @@ -896,7 +896,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.second + "' as component_2 but it does not exist in the model."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setRule(ReferenceRule::CONNECTION_COMPONENT2); + issue->setReferenceRule(ReferenceRule::CONNECTION_COMPONENT2); mParser->addIssue(issue); } } @@ -920,7 +920,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Variable '" + iterPair.first + "' is specified as variable_1 in a connection but it does not exist in component_1 component '" + component1->name() + "' of model '" + model->name() + "'."); issue->setComponent(component1); issue->setCause(Issue::Cause::CONNECTION); - issue->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); + issue->setReferenceRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); mParser->addIssue(issue); } } @@ -929,7 +929,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.first + "' as variable_1 but the corresponding component_1 is invalid."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); + issue->setReferenceRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); mParser->addIssue(issue); } if (component2) { @@ -946,7 +946,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Variable '" + iterPair.second + "' is specified as variable_2 in a connection but it does not exist in component_2 component '" + component2->name() + "' of model '" + model->name() + "'."); issue->setComponent(component1); issue->setCause(Issue::Cause::CONNECTION); - issue->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); + issue->setReferenceRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); mParser->addIssue(issue); } } @@ -955,7 +955,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.second + "' as variable_2 but the corresponding component_2 is invalid."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); + issue->setReferenceRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); mParser->addIssue(issue); } // Set the variable equivalence relationship for this variable pair. @@ -968,7 +968,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' does not have a map_variables element."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setRule(ReferenceRule::CONNECTION_MAP_VARIABLES); + issue->setReferenceRule(ReferenceRule::CONNECTION_MAP_VARIABLES); mParser->addIssue(issue); } } @@ -991,7 +991,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X issue->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponentName + "' as a component in a component_ref but it does not exist in the model."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + issue->setReferenceRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); mParser->addIssue(issue); } } else if (attribute->isType("id")) { @@ -1001,7 +1001,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X issue->setDescription("Encapsulation in model '" + model->name() + "' has an invalid component_ref attribute '" + attribute->name() + "'."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + issue->setReferenceRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); mParser->addIssue(issue); } attribute = attribute->next(); @@ -1011,7 +1011,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X issue->setDescription("Encapsulation in model '" + model->name() + "' does not have a valid component attribute in a component_ref element."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + issue->setReferenceRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); mParser->addIssue(issue); } else if (parentComponent) { parentComponent->setEncapsulationId(encapsulationId); @@ -1074,7 +1074,7 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP issue->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setRule(ReferenceRule::COMPONENT_REF_CHILD); + issue->setReferenceRule(ReferenceRule::COMPONENT_REF_CHILD); mParser->addIssue(issue); } else { // Continue to next node if this is whitespace (don't try to parse children of whitespace). @@ -1088,7 +1088,7 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP issue->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + componentRefNode->name() + "'."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setRule(ReferenceRule::ENCAPSULATION_COMPONENT_REF); + issue->setReferenceRule(ReferenceRule::ENCAPSULATION_COMPONENT_REF); mParser->addIssue(issue); } @@ -1187,7 +1187,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M IssuePtr issue = Issue::create(); issue->setDescription("Import from '" + node->attribute("href") + "' has an invalid non-whitespace child text element '" + textNode + "'."); issue->setImportSource(importSource); - issue->setRule(ReferenceRule::IMPORT_CHILD); + issue->setReferenceRule(ReferenceRule::IMPORT_CHILD); mParser->addIssue(issue); } } else if (childNode->isComment()) { @@ -1196,7 +1196,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M IssuePtr issue = Issue::create(); issue->setDescription("Import from '" + node->attribute("href") + "' has an invalid child element '" + childNode->name() + "'."); issue->setImportSource(importSource); - issue->setRule(ReferenceRule::IMPORT_CHILD); + issue->setReferenceRule(ReferenceRule::IMPORT_CHILD); mParser->addIssue(issue); } childNode = childNode->next(); @@ -1229,7 +1229,7 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese IssuePtr issue = Issue::create(); issue->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' has an unexpected attribute in the " + childType + " block of '" + childAttribute->name() + "'."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_TEST_VALUE); + issue->setReferenceRule(ReferenceRule::RESET_TEST_VALUE); mParser->addIssue(issue); } childAttribute = childAttribute->next(); @@ -1253,7 +1253,7 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese IssuePtr issue = Issue::create(); issue->setDescription("The " + childType + " in the reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' should have a MathML block as a child."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_TEST_VALUE); + issue->setReferenceRule(ReferenceRule::RESET_TEST_VALUE); mParser->addIssue(issue); } } @@ -1279,7 +1279,7 @@ void Parser::ParserImpl::checkResetChildMultiplicity(size_t count, const std::st issue->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' has " + convertToString(count) + " " + childType + " blocks."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_TEST_VALUE); + issue->setReferenceRule(ReferenceRule::RESET_TEST_VALUE); mParser->addIssue(issue); } if (count == 0) { @@ -1287,7 +1287,7 @@ void Parser::ParserImpl::checkResetChildMultiplicity(size_t count, const std::st issue->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' does not have a " + childType + " block defined."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_TEST_VALUE); + issue->setReferenceRule(ReferenceRule::RESET_TEST_VALUE); mParser->addIssue(issue); } } @@ -1313,7 +1313,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr issue = Issue::create(); issue->setDescription("Reset referencing variable '" + variableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_VARIABLE_REFERENCE); + issue->setReferenceRule(ReferenceRule::RESET_VARIABLE_REFERENCE); mParser->addIssue(issue); } else { reset->setVariable(referencedVariable); @@ -1326,7 +1326,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr issue = Issue::create(); issue->setDescription("Reset referencing test_variable '" + testVariableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); + issue->setReferenceRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); mParser->addIssue(issue); } else { reset->setTestVariable(testVariable); @@ -1343,7 +1343,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr issue = Issue::create(); issue->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' has a non-integer order value '" + attribute->value() + "'."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_ORDER); + issue->setReferenceRule(ReferenceRule::RESET_ORDER); mParser->addIssue(issue); } } else if (attribute->isType("id")) { @@ -1363,7 +1363,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr issue = Issue::create(); issue->setDescription("Reset in component '" + component->name() + "' does not have its order set."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_ORDER); + issue->setReferenceRule(ReferenceRule::RESET_ORDER); mParser->addIssue(issue); } @@ -1385,7 +1385,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr issue = Issue::create(); issue->setDescription("Reset has an invalid non-whitespace child text element '" + textNode + "'. Either a test_value block or a reset_value block is expected."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_CHILD); + issue->setReferenceRule(ReferenceRule::RESET_CHILD); mParser->addIssue(issue); } } else if (childNode->isComment()) { diff --git a/src/validator.cpp b/src/validator.cpp index 20221e8aa..925352381 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -318,7 +318,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr issue = Issue::create(); issue->setDescription("Model does not have a valid name attribute."); issue->setModel(model); - issue->setRule(ReferenceRule::MODEL_NAME); + issue->setReferenceRule(ReferenceRule::MODEL_NAME); addIssue(issue); } // Check for components in this model. @@ -347,7 +347,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr issue = Issue::create(); issue->setDescription("Imported units '" + unitsName + "' does not have a valid units_ref attribute."); issue->setUnits(units); - issue->setRule(ReferenceRule::IMPORT_UNITS_REF); + issue->setReferenceRule(ReferenceRule::IMPORT_UNITS_REF); addIssue(issue); foundImportIssue = true; } @@ -357,7 +357,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr issue = Issue::create(); issue->setDescription("Import of units '" + unitsName + "' does not have a valid locator xlink:href attribute."); issue->setImportSource(units->importSource()); - issue->setRule(ReferenceRule::IMPORT_HREF); + issue->setReferenceRule(ReferenceRule::IMPORT_HREF); addIssue(issue); foundImportIssue = true; } @@ -369,7 +369,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr issue = Issue::create(); issue->setDescription("Model '" + model->name() + "' contains multiple imported units from '" + importSource + "' with the same units_ref attribute '" + unitsRef + "'."); issue->setModel(model); - issue->setRule(ReferenceRule::IMPORT_UNITS_REF); + issue->setReferenceRule(ReferenceRule::IMPORT_UNITS_REF); addIssue(issue); } } @@ -382,7 +382,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr issue = Issue::create(); issue->setDescription("Model '" + model->name() + "' contains multiple units with the name '" + unitsName + "'. Valid units names must be unique to their model."); issue->setModel(model); - issue->setRule(ReferenceRule::UNITS_NAME_UNIQUE); + issue->setReferenceRule(ReferenceRule::UNITS_NAME_UNIQUE); addIssue(issue); } unitsNames.push_back(unitsName); @@ -438,7 +438,7 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com IssuePtr issue = Issue::create(); issue->setComponent(component); issue->setDescription("Imported component does not have a valid name attribute."); - issue->setRule(ReferenceRule::IMPORT_COMPONENT_NAME); + issue->setReferenceRule(ReferenceRule::IMPORT_COMPONENT_NAME); mValidator->addIssue(issue); } @@ -451,14 +451,14 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com IssuePtr issue = Issue::create(); issue->setDescription("Imported component '" + componentName + "' does not have a valid component_ref attribute."); issue->setComponent(component); - issue->setRule(ReferenceRule::IMPORT_COMPONENT_REF); + issue->setReferenceRule(ReferenceRule::IMPORT_COMPONENT_REF); mValidator->addIssue(issue); } if (importSource.empty()) { IssuePtr issue = Issue::create(); issue->setDescription("Import of component '" + componentName + "' does not have a valid locator xlink:href attribute."); issue->setImportSource(component->importSource()); - issue->setRule(ReferenceRule::IMPORT_HREF); + issue->setReferenceRule(ReferenceRule::IMPORT_HREF); mValidator->addIssue(issue); } else { xmlURIPtr uri = xmlParseURI(importSource.c_str()); @@ -466,7 +466,7 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com IssuePtr issue = Issue::create(); issue->setDescription("Import of component '" + componentName + "' has an invalid URI in the href attribute."); issue->setImportSource(component->importSource()); - issue->setRule(ReferenceRule::IMPORT_HREF); + issue->setReferenceRule(ReferenceRule::IMPORT_HREF); mValidator->addIssue(issue); } else { @@ -482,7 +482,7 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) IssuePtr issue = Issue::create(); issue->setComponent(component); issue->setDescription("Component does not have a valid name attribute."); - issue->setRule(ReferenceRule::COMPONENT_NAME); + issue->setReferenceRule(ReferenceRule::COMPONENT_NAME); mValidator->addIssue(issue); } // Check for variables in this component. @@ -497,7 +497,7 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) IssuePtr issue = Issue::create(); issue->setDescription("Component '" + component->name() + "' contains multiple variables with the name '" + variableName + "'. Valid variable names must be unique to their component."); issue->setComponent(component); - issue->setRule(ReferenceRule::VARIABLE_NAME); + issue->setReferenceRule(ReferenceRule::VARIABLE_NAME); mValidator->addIssue(issue); } variableNames.push_back(variableName); @@ -529,10 +529,10 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v issue->setUnits(units); if (units->isImport()) { issue->setDescription("Imported units does not have a valid name attribute."); - issue->setRule(ReferenceRule::IMPORT_UNITS_NAME); + issue->setReferenceRule(ReferenceRule::IMPORT_UNITS_NAME); } else { issue->setDescription("Units does not have a valid name attribute."); - issue->setRule(ReferenceRule::UNITS_NAME); + issue->setReferenceRule(ReferenceRule::UNITS_NAME); } mValidator->addIssue(issue); } else { @@ -541,7 +541,7 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v IssuePtr issue = Issue::create(); issue->setDescription("Units is named '" + units->name() + "' which is a protected standard unit name."); issue->setUnits(units); - issue->setRule(ReferenceRule::UNITS_STANDARD); + issue->setReferenceRule(ReferenceRule::UNITS_STANDARD); mValidator->addIssue(issue); } } @@ -567,14 +567,14 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u IssuePtr issue = Issue::create(); issue->setDescription("Units reference '" + reference + "' in units '" + units->name() + "' is not a valid reference to a local units or a standard unit type."); issue->setUnits(units); - issue->setRule(ReferenceRule::UNIT_UNITS_REF); + issue->setReferenceRule(ReferenceRule::UNIT_UNITS_REF); mValidator->addIssue(issue); } } else { IssuePtr issue = Issue::create(); issue->setDescription("Unit in units '" + units->name() + "' does not have a valid units reference."); issue->setUnits(units); - issue->setRule(ReferenceRule::UNIT_UNITS_REF); + issue->setReferenceRule(ReferenceRule::UNIT_UNITS_REF); mValidator->addIssue(issue); } if (!prefix.empty()) { @@ -583,7 +583,7 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u IssuePtr issue = Issue::create(); issue->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is not a valid integer or an SI prefix."); issue->setUnits(units); - issue->setRule(ReferenceRule::UNIT_PREFIX); + issue->setReferenceRule(ReferenceRule::UNIT_PREFIX); mValidator->addIssue(issue); } else { try { @@ -593,7 +593,7 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u IssuePtr issue = Issue::create(); issue->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is out of the integer range."); issue->setUnits(units); - issue->setRule(ReferenceRule::UNIT_PREFIX); + issue->setReferenceRule(ReferenceRule::UNIT_PREFIX); mValidator->addIssue(issue); } } @@ -608,7 +608,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr issue = Issue::create(); issue->setDescription("Variable does not have a valid name attribute."); issue->setVariable(variable); - issue->setRule(ReferenceRule::VARIABLE_NAME); + issue->setReferenceRule(ReferenceRule::VARIABLE_NAME); mValidator->addIssue(issue); } // Check for a valid units attribute. @@ -617,7 +617,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr issue = Issue::create(); issue->setDescription("Variable '" + variable->name() + "' does not have a valid units attribute."); issue->setVariable(variable); - issue->setRule(ReferenceRule::VARIABLE_UNITS); + issue->setReferenceRule(ReferenceRule::VARIABLE_UNITS); mValidator->addIssue(issue); } else if (!isStandardUnitName(unitsName)) { ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); @@ -626,7 +626,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr issue = Issue::create(); issue->setDescription("Variable '" + variable->name() + "' in component '" + component->name() + "' has a units reference '" + unitsName + "' which is neither standard nor defined in the parent model."); issue->setVariable(variable); - issue->setRule(ReferenceRule::VARIABLE_UNITS); + issue->setReferenceRule(ReferenceRule::VARIABLE_UNITS); mValidator->addIssue(issue); } } @@ -637,7 +637,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr issue = Issue::create(); issue->setDescription("Variable '" + variable->name() + "' has an invalid interface attribute value '" + interfaceType + "'."); issue->setVariable(variable); - issue->setRule(ReferenceRule::VARIABLE_INTERFACE); + issue->setReferenceRule(ReferenceRule::VARIABLE_INTERFACE); mValidator->addIssue(issue); } } @@ -651,7 +651,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr issue = Issue::create(); issue->setDescription("Variable '" + variable->name() + "' has an invalid initial value '" + initialValue + "'. Initial values must be a real number string or a variable reference."); issue->setVariable(variable); - issue->setRule(ReferenceRule::VARIABLE_INITIAL_VALUE); + issue->setReferenceRule(ReferenceRule::VARIABLE_INITIAL_VALUE); mValidator->addIssue(issue); } } @@ -722,49 +722,49 @@ void Validator::ValidatorImpl::validateReset(const ResetPtr &reset, const Compon IssuePtr issue = Issue::create(); issue->setDescription(description + "does not have an order set."); issue->setComponent(component); - issue->setRule(ReferenceRule::RESET_ORDER); + issue->setReferenceRule(ReferenceRule::RESET_ORDER); mValidator->addIssue(issue); } if (noVariable) { IssuePtr issue = Issue::create(); issue->setDescription(description + "does not reference a variable."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_VARIABLE_REFERENCE); + issue->setReferenceRule(ReferenceRule::RESET_VARIABLE_REFERENCE); mValidator->addIssue(issue); } if (noTestVariable) { IssuePtr issue = Issue::create(); issue->setDescription(description + "does not reference a test_variable."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); + issue->setReferenceRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); mValidator->addIssue(issue); } if (noTestValue) { IssuePtr issue = Issue::create(); issue->setDescription(description + "does not have a test_value specified."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_TEST_VALUE); + issue->setReferenceRule(ReferenceRule::RESET_TEST_VALUE); mValidator->addIssue(issue); } if (noResetValue) { IssuePtr issue = Issue::create(); issue->setDescription(description + "does not have a reset_value specified."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_RESET_VALUE); + issue->setReferenceRule(ReferenceRule::RESET_RESET_VALUE); mValidator->addIssue(issue); } if (varOutsideComponent) { IssuePtr issue = Issue::create(); issue->setDescription(description + "refers to a variable '" + reset->variable()->name() + "' in a different component '" + varParentName + "'."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_VARIABLE_REFERENCE); + issue->setReferenceRule(ReferenceRule::RESET_VARIABLE_REFERENCE); mValidator->addIssue(issue); } if (testVarOutsideComponent) { IssuePtr issue = Issue::create(); issue->setDescription(description + "refers to a test_variable '" + reset->testVariable()->name() + "' in a different component '" + testVarParentName + "'."); issue->setReset(reset); - issue->setRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); + issue->setReferenceRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); mValidator->addIssue(issue); } } @@ -1077,7 +1077,7 @@ void Validator::ValidatorImpl::validateEquivalenceUnits(const ModelPtr &model, c err->setDescription("Variable '" + variable->name() + "' in component '" + parent1->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' in component '" + parent2->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); err->setModel(model); err->setCause(Issue::Cause::UNITS); - err->setRule(ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); + err->setReferenceRule(ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); mValidator->addIssue(err); } // TODO Removed until after PR 521 has been merged. @@ -1098,7 +1098,7 @@ void Validator::ValidatorImpl::validateEquivalenceUnits(const ModelPtr &model, c // err->setModel(model); // err->setDescription(des); // err->setCause(Issue::Cause::UNITS); - // err->setRule(ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); + // err->setReferenceRule(ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); // err->setLevel(Issue::Level::WARNING); // mValidator->addIssue(err); // } @@ -1157,7 +1157,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) result = false; IssuePtr issue = Issue::create(); issue->setDescription("CellML identifiers must not begin with a European numeric character [0-9]."); - issue->setRule(ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); + issue->setReferenceRule(ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); mValidator->addIssue(issue); } else { // Basic Latin alphanumeric characters and underscores. @@ -1165,7 +1165,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) result = false; IssuePtr issue = Issue::create(); issue->setDescription("CellML identifiers must not contain any characters other than [a-zA-Z0-9_]."); - issue->setRule(ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); + issue->setReferenceRule(ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); mValidator->addIssue(issue); } } @@ -1173,7 +1173,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) result = false; IssuePtr issue = Issue::create(); issue->setDescription("CellML identifiers must contain one or more basic Latin alphabetic characters."); - issue->setRule(ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); + issue->setReferenceRule(ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); mValidator->addIssue(issue); } return result; diff --git a/tests/bindings/python/test_issue.py b/tests/bindings/python/test_issue.py index 4b0a315f7..6b4565779 100644 --- a/tests/bindings/python/test_issue.py +++ b/tests/bindings/python/test_issue.py @@ -125,11 +125,11 @@ def test_specification_rule_enum(self): # Test conversion to enum e = Issue() - e.setRule(ReferenceRule.UNDEFINED) + e.setReferenceRule(ReferenceRule.UNDEFINED) self.assertRaises( - RuntimeError, e.setRule, ReferenceRule.UNDEFINED - 1) + RuntimeError, e.setReferenceRule, ReferenceRule.UNDEFINED - 1) self.assertRaises( - RuntimeError, e.setRule, + RuntimeError, e.setReferenceRule, ReferenceRule.MAP_VARIABLES_UNIQUE + 1) del(e) @@ -168,27 +168,19 @@ def test_cause(self): e.setCause(Issue.Cause.MATHML) self.assertEqual(e.cause(), Issue.Cause.MATHML) - def test_is_cause(self): - from libcellml import Issue - - # bool isCause(const Cause &cause) - e = Issue() - self.assertTrue(e.isCause(Issue.Cause.UNDEFINED)) - self.assertFalse(e.isCause(Issue.Cause.MODEL)) - def test_set_rule(self): from libcellml import Issue, ReferenceRule - # void setRule(ReferenceRule rule) + # void setReferenceRule(ReferenceRule rule) e = Issue() - e.setRule(ReferenceRule.MAP_VARIABLES_VARIABLE2) + e.setReferenceRule(ReferenceRule.MAP_VARIABLES_VARIABLE2) def test_rule(self): from libcellml import Issue, ReferenceRule - # ReferenceRule rule() + # ReferenceRule referenceRule() e = Issue() - self.assertEqual(e.rule(), ReferenceRule.UNDEFINED) + self.assertEqual(e.referenceRule(), ReferenceRule.UNDEFINED) def test_specification_heading(self): from libcellml import Issue diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index a1170c3ac..cbeb98990 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -68,7 +68,7 @@ TEST(Issue, createResetIssue) void testReferenceRule(const libcellml::IssuePtr &e) { - switch (e->rule()) { + switch (e->referenceRule()) { case libcellml::ReferenceRule::COMPONENT_CHILD: EXPECT_EQ("10.1.2", e->referenceHeading()); break; @@ -250,157 +250,157 @@ TEST(Issue, referenceRule) { size_t count = 0; libcellml::IssuePtr e = libcellml::Issue::create(); - e->setRule(libcellml::ReferenceRule::UNDEFINED); + e->setReferenceRule(libcellml::ReferenceRule::UNDEFINED); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::COMPONENT_CHILD); + e->setReferenceRule(libcellml::ReferenceRule::COMPONENT_CHILD); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::COMPONENT_NAME); + e->setReferenceRule(libcellml::ReferenceRule::COMPONENT_NAME); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::COMPONENT_REF_CHILD); + e->setReferenceRule(libcellml::ReferenceRule::COMPONENT_REF_CHILD); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + e->setReferenceRule(libcellml::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::COMPONENT_REF_ENCAPSULATION); + e->setReferenceRule(libcellml::ReferenceRule::COMPONENT_REF_ENCAPSULATION); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::CONNECTION_COMPONENT1); + e->setReferenceRule(libcellml::ReferenceRule::CONNECTION_COMPONENT1); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::CONNECTION_COMPONENT2); + e->setReferenceRule(libcellml::ReferenceRule::CONNECTION_COMPONENT2); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE); + e->setReferenceRule(libcellml::ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::CONNECTION_MAP_VARIABLES); + e->setReferenceRule(libcellml::ReferenceRule::CONNECTION_MAP_VARIABLES); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); + e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); + e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL); + e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); + e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE); + e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::DATA_REPR_NNEG_INT_BASE10); + e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_NNEG_INT_BASE10); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM); + e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::ENCAPSULATION_COMPONENT_REF); + e->setReferenceRule(libcellml::ReferenceRule::ENCAPSULATION_COMPONENT_REF); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::IMPORT_CHILD); + e->setReferenceRule(libcellml::ReferenceRule::IMPORT_CHILD); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::IMPORT_CIRCULAR); + e->setReferenceRule(libcellml::ReferenceRule::IMPORT_CIRCULAR); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::IMPORT_COMPONENT_NAME); + e->setReferenceRule(libcellml::ReferenceRule::IMPORT_COMPONENT_NAME); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::IMPORT_COMPONENT_REF); + e->setReferenceRule(libcellml::ReferenceRule::IMPORT_COMPONENT_REF); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::IMPORT_HREF); + e->setReferenceRule(libcellml::ReferenceRule::IMPORT_HREF); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::IMPORT_UNITS_NAME); + e->setReferenceRule(libcellml::ReferenceRule::IMPORT_UNITS_NAME); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::IMPORT_UNITS_REF); + e->setReferenceRule(libcellml::ReferenceRule::IMPORT_UNITS_REF); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::MAP_VARIABLES_UNIQUE); + e->setReferenceRule(libcellml::ReferenceRule::MAP_VARIABLES_UNIQUE); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE1); + e->setReferenceRule(libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE1); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE2); + e->setReferenceRule(libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE2); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::MODEL_CHILD); + e->setReferenceRule(libcellml::ReferenceRule::MODEL_CHILD); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::MODEL_ELEMENT); + e->setReferenceRule(libcellml::ReferenceRule::MODEL_ELEMENT); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); + e->setReferenceRule(libcellml::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::MODEL_NAME); + e->setReferenceRule(libcellml::ReferenceRule::MODEL_NAME); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::RESET_CHILD); + e->setReferenceRule(libcellml::ReferenceRule::RESET_CHILD); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::RESET_VARIABLE_REFERENCE); + e->setReferenceRule(libcellml::ReferenceRule::RESET_VARIABLE_REFERENCE); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); + e->setReferenceRule(libcellml::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::RESET_ORDER); + e->setReferenceRule(libcellml::ReferenceRule::RESET_ORDER); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::UNITS_CHILD); + e->setReferenceRule(libcellml::ReferenceRule::UNITS_CHILD); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::UNITS_NAME); + e->setReferenceRule(libcellml::ReferenceRule::UNITS_NAME); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::UNITS_NAME_UNIQUE); + e->setReferenceRule(libcellml::ReferenceRule::UNITS_NAME_UNIQUE); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::UNITS_STANDARD); + e->setReferenceRule(libcellml::ReferenceRule::UNITS_STANDARD); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); + e->setReferenceRule(libcellml::ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::UNIT_CIRCULAR_REF); + e->setReferenceRule(libcellml::ReferenceRule::UNIT_CIRCULAR_REF); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::UNIT_DIGRAPH); + e->setReferenceRule(libcellml::ReferenceRule::UNIT_DIGRAPH); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::UNIT_EXPONENT); + e->setReferenceRule(libcellml::ReferenceRule::UNIT_EXPONENT); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::UNIT_MULTIPLIER); + e->setReferenceRule(libcellml::ReferenceRule::UNIT_MULTIPLIER); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::UNIT_PREFIX); + e->setReferenceRule(libcellml::ReferenceRule::UNIT_PREFIX); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::UNIT_UNITS_REF); + e->setReferenceRule(libcellml::ReferenceRule::UNIT_UNITS_REF); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::VARIABLE_INITIAL_VALUE); + e->setReferenceRule(libcellml::ReferenceRule::VARIABLE_INITIAL_VALUE); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::VARIABLE_INTERFACE); + e->setReferenceRule(libcellml::ReferenceRule::VARIABLE_INTERFACE); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::VARIABLE_NAME); + e->setReferenceRule(libcellml::ReferenceRule::VARIABLE_NAME); ++count; testReferenceRule(e); - e->setRule(libcellml::ReferenceRule::VARIABLE_UNITS); + e->setReferenceRule(libcellml::ReferenceRule::VARIABLE_UNITS); ++count; testReferenceRule(e); EXPECT_EQ(size_t(51), count); @@ -464,29 +464,28 @@ TEST(Issue, isError) { auto e = libcellml::Issue::create(); e->setLevel(libcellml::Issue::Level::ERROR); - EXPECT_TRUE(e->isLevel(libcellml::Issue::Level::ERROR)); + EXPECT_EQ(e->level(), libcellml::Issue::Level::ERROR); } TEST(Issue, isWarning) { auto e = libcellml::Issue::create(); e->setLevel(libcellml::Issue::Level::WARNING); - - EXPECT_TRUE(e->isLevel(libcellml::Issue::Level::WARNING)); + EXPECT_EQ(e->level(), libcellml::Issue::Level::WARNING); } TEST(Issue, isHint) { auto e = libcellml::Issue::create(); e->setLevel(libcellml::Issue::Level::HINT); - EXPECT_TRUE(e->isLevel(libcellml::Issue::Level::HINT)); + EXPECT_EQ(e->level(), libcellml::Issue::Level::HINT); } // TODO Remove this test until the base URL for the CellML2.0 specification exists and the spec is finalised. // TEST(Issue, getDefaultUrl) // { // auto e = libcellml::Issue::create(); -// e->setRule(libcellml::ReferenceRule::MODEL_NAME); +// e->setReferenceRule(libcellml::ReferenceRule::MODEL_NAME); // auto ref = e->referenceHeading(); // // TODO How to get this from the utilties.h file?? Won't be this address in the long run. // std::string url = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q=" + ref; diff --git a/tests/parser/parser.cpp b/tests/parser/parser.cpp index 4448b766f..0b2ceb3ee 100644 --- a/tests/parser/parser.cpp +++ b/tests/parser/parser.cpp @@ -1420,7 +1420,7 @@ TEST(Parser, invalidModelWithAllCausesOfIssues) libcellml::IssuePtr undefinedIssue = libcellml::Issue::create(); parser2->addIssue(undefinedIssue); EXPECT_EQ(size_t(1), parser2->issueCount()); - if (parser2->issue(0)->isCause(libcellml::Issue::Cause::UNDEFINED)) { + if (parser2->issue(0)->cause()==libcellml::Issue::Cause::UNDEFINED) { foundCause.at(7) = true; } @@ -1434,7 +1434,7 @@ TEST(Parser, invalidModelWithAllCausesOfIssues) parser3->parseModel(input3); EXPECT_EQ_ISSUES(expectedIssues3, parser3); for (size_t i = 0; i < parser3->issueCount(); ++i) { - if (parser3->issue(i)->isCause(libcellml::Issue::Cause::XML)) { + if (parser3->issue(i)->cause()==libcellml::Issue::Cause::XML) { foundCause.at(8) = true; } } diff --git a/tests/test_utils.cpp b/tests/test_utils.cpp index 93c4684e6..686c4b341 100644 --- a/tests/test_utils.cpp +++ b/tests/test_utils.cpp @@ -52,7 +52,7 @@ void printIssues(const libcellml::LoggerPtr &l, bool headings, bool causes, bool std::cout << ", " << static_cast(l->issue(i)->cause()); } if (rule) { - std::cout << ", " << static_cast(l->issue(i)->rule()); + std::cout << ", " << static_cast(l->issue(i)->referenceRule()); } std::cout << std::endl; } From 280e2155550725e9014b281989119f42a486cc40 Mon Sep 17 00:00:00 2001 From: Keri Moyle Date: Thu, 19 Mar 2020 17:07:00 +1300 Subject: [PATCH 66/88] Changes made, one test failing --- src/CMakeLists.txt | 1 - src/api/libcellml/issue.h | 71 +++++++- src/api/libcellml/logger.h | 15 -- src/api/libcellml/referencerules.h | 166 +++++++++---------- src/bindings/interface/issue.i | 1 - src/bindings/interface/referencerule.i | 9 - src/bindings/python/CMakeLists.txt | 1 - src/bindings/python/__init__.py | 31 ++-- src/issue.cpp | 124 +++++++------- src/logger.cpp | 17 -- src/parser.cpp | 80 ++++----- src/validator.cpp | 70 ++++---- tests/bindings/python/test_issue.py | 143 ++++++++-------- tests/issue/issue.cpp | 220 ++++++++++++------------- tests/logger/logger.cpp | 51 ------ tests/parser/parser.cpp | 4 +- 16 files changed, 490 insertions(+), 514 deletions(-) delete mode 100644 src/bindings/interface/referencerule.i diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 2248d23ec..ea3a13d14 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -85,7 +85,6 @@ set(GIT_API_HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/parser.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/printer.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/reset.h - ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/referencerules.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/types.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/units.h ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/validator.h diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 09ff8b9cf..300feaa01 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -17,7 +17,6 @@ limitations under the License. #pragma once #include "libcellml/exportdefinitions.h" -#include "libcellml/referencerules.h" #include "libcellml/types.h" #include @@ -58,7 +57,7 @@ class LIBCELLML_EXPORT Issue * * - libcellml::Issue::Cause::UNDEFINED; * - libcellml::Issue::Level::ERROR; - * - libcellml::ReferenceRule::UNDEFINED; + * - libcellml::Issue::ReferenceRule::UNDEFINED; * * @return A smart pointer to an @c Issue object. */ @@ -127,6 +126,74 @@ class LIBCELLML_EXPORT Issue HINT, }; + /** + * @brief The issue Reference enum class. + * + * Enum to describe the rule which the issue addresses. + */ + enum class ReferenceRule + { + UNDEFINED, + // Specification errors. + DATA_REPR_IDENTIFIER_UNICODE, + DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, + DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, + DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM, + DATA_REPR_IDENTIFIER_IDENTICAL, + DATA_REPR_NNEG_INT_BASE10, + DATA_REPR_NNEG_INT_EURO_NUM, + MODEL_ELEMENT, + MODEL_NAME, + MODEL_CHILD, + MODEL_MORE_THAN_ONE_ENCAPSULATION, + IMPORT_HREF, + IMPORT_CHILD, + IMPORT_CIRCULAR, + IMPORT_UNITS_NAME, + IMPORT_UNITS_REF, + IMPORT_COMPONENT_NAME, + IMPORT_COMPONENT_REF, + UNITS_NAME, + UNITS_NAME_UNIQUE, + UNITS_STANDARD, + UNITS_CHILD, + UNIT_UNITS_REF, + UNIT_DIGRAPH, + UNIT_CIRCULAR_REF, + UNIT_OPTIONAL_ATTRIBUTE, + UNIT_PREFIX, + UNIT_MULTIPLIER, + UNIT_EXPONENT, + COMPONENT_NAME, + COMPONENT_CHILD, + VARIABLE_NAME, + VARIABLE_UNITS, + VARIABLE_INTERFACE, + VARIABLE_INITIAL_VALUE, + RESET_CHILD, + RESET_ORDER, + RESET_VARIABLE_REFERENCE, + RESET_TEST_VARIABLE_REFERENCE, + RESET_TEST_VALUE, + RESET_RESET_VALUE, + MATH_MATHML, + MATH_CHILD, + MATH_CI_VARIABLE_REFERENCE, + MATH_CN_UNITS_ATTRIBUTE, + ENCAPSULATION_COMPONENT_REF, + COMPONENT_REF_COMPONENT_ATTRIBUTE, + COMPONENT_REF_CHILD, + COMPONENT_REF_ENCAPSULATION, + CONNECTION_COMPONENT1, + CONNECTION_COMPONENT2, + CONNECTION_UNIQUE_TRANSITIVE, + CONNECTION_MAP_VARIABLES, + MAP_VARIABLES_VARIABLE1, + MAP_VARIABLES_VARIABLE2, + MAP_VARIABLES_UNIQUE, + MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION + }; + /** * @brief Set the description for this issue. * diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index 78af71228..9c2bd2663 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -76,21 +76,6 @@ class LIBCELLML_EXPORT Logger */ IssuePtr issue(size_t index) const; - /** - * @brief Get issue of specified @p level at the specified @p index. - * - * Returns an issue at the @p index of specified @p level. If the @p index - * is not valid a @c nullptr is returned, the valid range for the @p index - * is [0, \#issues_of_level). - * - * @param index The index of the issue to return. - * @param level The level of issue to search. - * - * @return A reference to the issue from the list of issues at the given level, - * at the given index on success, @c nullptr otherwise. - */ - IssuePtr issue(size_t index, libcellml::Issue::Level level) const; - /** * @brief Get the number of issues with level of ERROR. * diff --git a/src/api/libcellml/referencerules.h b/src/api/libcellml/referencerules.h index d8ffa5bb3..3f78a77ce 100644 --- a/src/api/libcellml/referencerules.h +++ b/src/api/libcellml/referencerules.h @@ -1,90 +1,90 @@ -/* -Copyright libCellML Contributors +// /* +// 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 +// 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 +// 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. -*/ +// 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. +// */ -#pragma once +// #pragma once -namespace libcellml { +// namespace libcellml { -/** - * @brief The ReferenceRule enum class. - * - * Enum describing the specification rules that are used - * for validation. - */ -enum class ReferenceRule -{ - UNDEFINED, - // Specification errors. - DATA_REPR_IDENTIFIER_UNICODE, - DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, - DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, - DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM, - DATA_REPR_IDENTIFIER_IDENTICAL, - DATA_REPR_NNEG_INT_BASE10, - DATA_REPR_NNEG_INT_EURO_NUM, - MODEL_ELEMENT, - MODEL_NAME, - MODEL_CHILD, - MODEL_MORE_THAN_ONE_ENCAPSULATION, - IMPORT_HREF, - IMPORT_CHILD, - IMPORT_CIRCULAR, - IMPORT_UNITS_NAME, - IMPORT_UNITS_REF, - IMPORT_COMPONENT_NAME, - IMPORT_COMPONENT_REF, - UNITS_NAME, - UNITS_NAME_UNIQUE, - UNITS_STANDARD, - UNITS_CHILD, - UNIT_UNITS_REF, - UNIT_DIGRAPH, - UNIT_CIRCULAR_REF, - UNIT_OPTIONAL_ATTRIBUTE, - UNIT_PREFIX, - UNIT_MULTIPLIER, - UNIT_EXPONENT, - COMPONENT_NAME, - COMPONENT_CHILD, - VARIABLE_NAME, - VARIABLE_UNITS, - VARIABLE_INTERFACE, - VARIABLE_INITIAL_VALUE, - RESET_CHILD, - RESET_ORDER, - RESET_VARIABLE_REFERENCE, - RESET_TEST_VARIABLE_REFERENCE, - RESET_TEST_VALUE, - RESET_RESET_VALUE, - MATH_MATHML, - MATH_CHILD, - MATH_CI_VARIABLE_REFERENCE, - MATH_CN_UNITS_ATTRIBUTE, - ENCAPSULATION_COMPONENT_REF, - COMPONENT_REF_COMPONENT_ATTRIBUTE, - COMPONENT_REF_CHILD, - COMPONENT_REF_ENCAPSULATION, - CONNECTION_COMPONENT1, - CONNECTION_COMPONENT2, - CONNECTION_UNIQUE_TRANSITIVE, - CONNECTION_MAP_VARIABLES, - MAP_VARIABLES_VARIABLE1, - MAP_VARIABLES_VARIABLE2, - MAP_VARIABLES_UNIQUE, - MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION -}; +// /** +// * @brief The ReferenceRule enum class. +// * +// * Enum describing the specification rules that are used +// * for validation. +// */ +// enum class ReferenceRule +// { +// UNDEFINED, +// // Specification errors. +// DATA_REPR_IDENTIFIER_UNICODE, +// DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, +// DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, +// DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM, +// DATA_REPR_IDENTIFIER_IDENTICAL, +// DATA_REPR_NNEG_INT_BASE10, +// DATA_REPR_NNEG_INT_EURO_NUM, +// MODEL_ELEMENT, +// MODEL_NAME, +// MODEL_CHILD, +// MODEL_MORE_THAN_ONE_ENCAPSULATION, +// IMPORT_HREF, +// IMPORT_CHILD, +// IMPORT_CIRCULAR, +// IMPORT_UNITS_NAME, +// IMPORT_UNITS_REF, +// IMPORT_COMPONENT_NAME, +// IMPORT_COMPONENT_REF, +// UNITS_NAME, +// UNITS_NAME_UNIQUE, +// UNITS_STANDARD, +// UNITS_CHILD, +// UNIT_UNITS_REF, +// UNIT_DIGRAPH, +// UNIT_CIRCULAR_REF, +// UNIT_OPTIONAL_ATTRIBUTE, +// UNIT_PREFIX, +// UNIT_MULTIPLIER, +// UNIT_EXPONENT, +// COMPONENT_NAME, +// COMPONENT_CHILD, +// VARIABLE_NAME, +// VARIABLE_UNITS, +// VARIABLE_INTERFACE, +// VARIABLE_INITIAL_VALUE, +// RESET_CHILD, +// RESET_ORDER, +// RESET_VARIABLE_REFERENCE, +// RESET_TEST_VARIABLE_REFERENCE, +// RESET_TEST_VALUE, +// RESET_RESET_VALUE, +// MATH_MATHML, +// MATH_CHILD, +// MATH_CI_VARIABLE_REFERENCE, +// MATH_CN_UNITS_ATTRIBUTE, +// ENCAPSULATION_COMPONENT_REF, +// COMPONENT_REF_COMPONENT_ATTRIBUTE, +// COMPONENT_REF_CHILD, +// COMPONENT_REF_ENCAPSULATION, +// CONNECTION_COMPONENT1, +// CONNECTION_COMPONENT2, +// CONNECTION_UNIQUE_TRANSITIVE, +// CONNECTION_MAP_VARIABLES, +// MAP_VARIABLES_VARIABLE1, +// MAP_VARIABLES_VARIABLE2, +// MAP_VARIABLES_UNIQUE, +// MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION +// }; -} // namespace libcellml +// } // namespace libcellml diff --git a/src/bindings/interface/issue.i b/src/bindings/interface/issue.i index 5af6d160a..07b4d215b 100644 --- a/src/bindings/interface/issue.i +++ b/src/bindings/interface/issue.i @@ -112,6 +112,5 @@ Level::ERROR will be returned."; } %include "libcellml/exportdefinitions.h" -%include "libcellml/referencerules.h" %include "libcellml/types.h" %include "libcellml/issue.h" diff --git a/src/bindings/interface/referencerule.i b/src/bindings/interface/referencerule.i deleted file mode 100644 index 0118ea134..000000000 --- a/src/bindings/interface/referencerule.i +++ /dev/null @@ -1,9 +0,0 @@ -%module(package="libcellml") referencerule - -#define LIBCELLML_EXPORT - -%{ -#include "libcellml/referencerules.h" -%} - -%include "libcellml/referencerules.h" diff --git a/src/bindings/python/CMakeLists.txt b/src/bindings/python/CMakeLists.txt index ac5cbb2c2..e44a490a3 100644 --- a/src/bindings/python/CMakeLists.txt +++ b/src/bindings/python/CMakeLists.txt @@ -32,7 +32,6 @@ set(SWIG_INTERFACE_SRCS ../interface/namedentity.i ../interface/parser.i ../interface/printer.i - ../interface/referencerule.i ../interface/reset.i ../interface/units.i ../interface/validator.i diff --git a/src/bindings/python/__init__.py b/src/bindings/python/__init__.py index 36d8a6f89..8d4d052ce 100644 --- a/src/bindings/python/__init__.py +++ b/src/bindings/python/__init__.py @@ -7,6 +7,7 @@ XML format. """ +import libcellml from libcellml.component import Component from libcellml.issue import Issue from libcellml.generator import Generator @@ -23,8 +24,11 @@ from libcellml.version import version, versionString # Convert enumerations generated by SWIG + + def convert(base, enum, variables, new_base=None): converting = False + class Object: pass obj = Object() @@ -41,6 +45,8 @@ class Object: converting = True if converting: setattr(base if new_base is None else new_base, enum, obj) + + convert(Issue, 'Cause', [ 'COMPONENT', 'CONNECTION', @@ -52,7 +58,7 @@ class Object: 'UNITS', 'VARIABLE', 'XML', - ]) +]) convert(Generator, 'ModelType', [ 'UNKNOWN', 'ALGEBRAIC', @@ -61,17 +67,17 @@ class Object: 'UNDERCONSTRAINED', 'OVERCONSTRAINED', 'UNSUITABLY_CONSTRAINED', - ]) +]) convert(GeneratorProfile, 'Profile', [ 'C', 'PYTHON', - ]) +]) convert(Variable, 'InterfaceType', [ 'NONE', 'PRIVATE', 'PUBLIC', 'PUBLIC_AND_PRIVATE', - ]) +]) convert(Units, 'StandardUnit', [ 'AMPERE', 'BECQUEREL', @@ -104,7 +110,7 @@ class Object: 'VOLT', 'WATT', 'WEBER', - ]) +]) convert(Units, 'Prefix', [ 'YOTTA', 'ZETTA', @@ -126,10 +132,8 @@ class Object: 'ATTO', 'ZEPTO', 'YOCTO', - ], new_base = Units) -import libcellml -import libcellml.referencerule -convert(referencerule, 'ReferenceRule', [ +], new_base=Units) +convert(Issue, 'ReferenceRule', [ 'UNDEFINED', 'DATA_REPR_IDENTIFIER_UNICODE', 'DATA_REPR_IDENTIFIER_LATIN_ALPHANUM', @@ -166,12 +170,12 @@ class Object: 'VARIABLE_UNITS', 'VARIABLE_INTERFACE', 'VARIABLE_INITIAL_VALUE', + 'RESET_CHILD', + 'RESET_ORDER', 'RESET_VARIABLE_REFERENCE', 'RESET_TEST_VARIABLE_REFERENCE', - 'RESET_ORDER', - 'RESET_CHILD', - 'RESET_RESET_VALUE', 'RESET_TEST_VALUE', + 'RESET_RESET_VALUE', 'MATH_MATHML', 'MATH_CHILD', 'MATH_CI_VARIABLE_REFERENCE', @@ -187,5 +191,6 @@ class Object: 'MAP_VARIABLES_VARIABLE1', 'MAP_VARIABLES_VARIABLE2', 'MAP_VARIABLES_UNIQUE', - ], new_base = libcellml) + 'MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION', +]) del(convert, libcellml) diff --git a/src/issue.cpp b/src/issue.cpp index c7ead73ec..ef01bc4c6 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -34,7 +34,7 @@ struct Issue::IssueImpl std::string mDescription; /**< The string description for why this issue was raised. */ Issue::Cause mCause = Issue::Cause::UNDEFINED; /**< The Issue::Cause enum value for this issue. */ Issue::Level mLevel = Issue::Level::ERROR; /**< The Issue::Level enum value for this issue. */ - ReferenceRule mRule = ReferenceRule::UNDEFINED; /**< The ReferenceRule enum value for this issue. */ + Issue::ReferenceRule mRule = Issue::ReferenceRule::UNDEFINED; /**< The Issue::ReferenceRule enum value for this issue. */ ComponentPtr mComponent; /**< Pointer to the component that the issue occurred in. */ ImportSourcePtr mImportSource; /**< Pointer to the import source that the issue occurred in. */ ModelPtr mModel; /**< Pointer to the model that the issue occurred in. */ @@ -160,12 +160,12 @@ Issue::Level Issue::level() const return mPimpl->mLevel; } -void Issue::setReferenceRule(ReferenceRule rule) +void Issue::setReferenceRule(Issue::ReferenceRule rule) { mPimpl->mRule = rule; } -ReferenceRule Issue::referenceRule() const +Issue::ReferenceRule Issue::referenceRule() const { return mPimpl->mRule; } @@ -247,66 +247,66 @@ ResetPtr Issue::reset() const /** * @brief Map ReferenceRules to their section titles. * - * An internal map used to convert a ReferenceRule into its heading string. + * An internal map used to convert a Issue::ReferenceRule into its heading string. */ -static const std::map ruleToHeading = { - {ReferenceRule::UNDEFINED, ""}, - {ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE, "3.1.1"}, - {ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, "3.1.2"}, - {ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, "3.1.3"}, - {ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM, "3.1.4"}, - {ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL, "3.1.5"}, - {ReferenceRule::DATA_REPR_NNEG_INT_BASE10, "3.2.1"}, - {ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM, "3.2.2"}, - {ReferenceRule::MODEL_ELEMENT, "4.1"}, - {ReferenceRule::MODEL_NAME, "4.2.1"}, - {ReferenceRule::MODEL_CHILD, "4.2.2"}, - {ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION, "4.2.3"}, - {ReferenceRule::IMPORT_HREF, "5.1.1"}, - {ReferenceRule::IMPORT_CHILD, "5.1.2"}, - {ReferenceRule::IMPORT_CIRCULAR, "5.1.3"}, // TODO: double-check meaning & implementation. - {ReferenceRule::IMPORT_UNITS_NAME, "6.1.1"}, - {ReferenceRule::IMPORT_UNITS_REF, "6.1.2"}, - {ReferenceRule::IMPORT_COMPONENT_NAME, "7.1.1"}, - {ReferenceRule::IMPORT_COMPONENT_REF, "7.1.2"}, - {ReferenceRule::UNITS_NAME, "8.1.1"}, - {ReferenceRule::UNITS_NAME_UNIQUE, "8.1.2"}, - {ReferenceRule::UNITS_STANDARD, "8.1.3"}, - {ReferenceRule::UNITS_CHILD, "8.1.4"}, - {ReferenceRule::UNIT_UNITS_REF, "9.1.1"}, - {ReferenceRule::UNIT_DIGRAPH, "9.1.1.1"}, // Assume we're skipping this for now. - {ReferenceRule::UNIT_CIRCULAR_REF, "9.1.1.2"}, // TODO: double-check meaning & implementation. - {ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE, "9.1.2"}, - {ReferenceRule::UNIT_PREFIX, "9.1.2.1"}, - {ReferenceRule::UNIT_MULTIPLIER, "9.1.2.2"}, - {ReferenceRule::UNIT_EXPONENT, "9.1.2.3"}, - {ReferenceRule::COMPONENT_NAME, "10.1.1"}, - {ReferenceRule::COMPONENT_CHILD, "10.1.2"}, - {ReferenceRule::VARIABLE_NAME, "11.1.1.1"}, - {ReferenceRule::VARIABLE_UNITS, "11.1.1.2"}, - {ReferenceRule::VARIABLE_INTERFACE, "11.1.2.1"}, - {ReferenceRule::VARIABLE_INITIAL_VALUE, "11.1.2.2"}, - {ReferenceRule::RESET_VARIABLE_REFERENCE, "12.1.1.1"}, - {ReferenceRule::RESET_TEST_VARIABLE_REFERENCE, "12.1.1.1"}, - {ReferenceRule::RESET_ORDER, "12.1.1.2"}, - {ReferenceRule::RESET_CHILD, "12.1.2"}, - {ReferenceRule::RESET_TEST_VALUE, "12.1.2"}, - {ReferenceRule::RESET_RESET_VALUE, "12.1.2"}, - {ReferenceRule::MATH_MATHML, "14.1.1"}, - {ReferenceRule::MATH_CHILD, "14.1.2"}, - {ReferenceRule::MATH_CI_VARIABLE_REFERENCE, "14.1.3"}, - {ReferenceRule::MATH_CN_UNITS_ATTRIBUTE, "14.1.4"}, - {ReferenceRule::ENCAPSULATION_COMPONENT_REF, "15.1.1"}, - {ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE, "16.1.1"}, - {ReferenceRule::COMPONENT_REF_CHILD, "16.1.2"}, - {ReferenceRule::COMPONENT_REF_ENCAPSULATION, "16.1.3"}, // Seems to be the same as 12.1.1? - {ReferenceRule::CONNECTION_COMPONENT1, "17.1.1"}, - {ReferenceRule::CONNECTION_COMPONENT2, "17.1.2"}, - {ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE, "17.1.3"}, - {ReferenceRule::CONNECTION_MAP_VARIABLES, "17.1.4"}, - {ReferenceRule::MAP_VARIABLES_VARIABLE1, "18.1.1"}, - {ReferenceRule::MAP_VARIABLES_VARIABLE2, "18.1.2"}, - {ReferenceRule::MAP_VARIABLES_UNIQUE, "18.1.3"}}; +static const std::map ruleToHeading = { + {Issue::ReferenceRule::UNDEFINED, ""}, + {Issue::ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE, "3.1.1"}, + {Issue::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, "3.1.2"}, + {Issue::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, "3.1.3"}, + {Issue::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM, "3.1.4"}, + {Issue::ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL, "3.1.5"}, + {Issue::ReferenceRule::DATA_REPR_NNEG_INT_BASE10, "3.2.1"}, + {Issue::ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM, "3.2.2"}, + {Issue::ReferenceRule::MODEL_ELEMENT, "4.1"}, + {Issue::ReferenceRule::MODEL_NAME, "4.2.1"}, + {Issue::ReferenceRule::MODEL_CHILD, "4.2.2"}, + {Issue::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION, "4.2.3"}, + {Issue::ReferenceRule::IMPORT_HREF, "5.1.1"}, + {Issue::ReferenceRule::IMPORT_CHILD, "5.1.2"}, + {Issue::ReferenceRule::IMPORT_CIRCULAR, "5.1.3"}, // TODO: double-check meaning & implementation. + {Issue::ReferenceRule::IMPORT_UNITS_NAME, "6.1.1"}, + {Issue::ReferenceRule::IMPORT_UNITS_REF, "6.1.2"}, + {Issue::ReferenceRule::IMPORT_COMPONENT_NAME, "7.1.1"}, + {Issue::ReferenceRule::IMPORT_COMPONENT_REF, "7.1.2"}, + {Issue::ReferenceRule::UNITS_NAME, "8.1.1"}, + {Issue::ReferenceRule::UNITS_NAME_UNIQUE, "8.1.2"}, + {Issue::ReferenceRule::UNITS_STANDARD, "8.1.3"}, + {Issue::ReferenceRule::UNITS_CHILD, "8.1.4"}, + {Issue::ReferenceRule::UNIT_UNITS_REF, "9.1.1"}, + {Issue::ReferenceRule::UNIT_DIGRAPH, "9.1.1.1"}, // Assume we're skipping this for now. + {Issue::ReferenceRule::UNIT_CIRCULAR_REF, "9.1.1.2"}, // TODO: double-check meaning & implementation. + {Issue::ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE, "9.1.2"}, + {Issue::ReferenceRule::UNIT_PREFIX, "9.1.2.1"}, + {Issue::ReferenceRule::UNIT_MULTIPLIER, "9.1.2.2"}, + {Issue::ReferenceRule::UNIT_EXPONENT, "9.1.2.3"}, + {Issue::ReferenceRule::COMPONENT_NAME, "10.1.1"}, + {Issue::ReferenceRule::COMPONENT_CHILD, "10.1.2"}, + {Issue::ReferenceRule::VARIABLE_NAME, "11.1.1.1"}, + {Issue::ReferenceRule::VARIABLE_UNITS, "11.1.1.2"}, + {Issue::ReferenceRule::VARIABLE_INTERFACE, "11.1.2.1"}, + {Issue::ReferenceRule::VARIABLE_INITIAL_VALUE, "11.1.2.2"}, + {Issue::ReferenceRule::RESET_VARIABLE_REFERENCE, "12.1.1.1"}, + {Issue::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE, "12.1.1.1"}, + {Issue::ReferenceRule::RESET_ORDER, "12.1.1.2"}, + {Issue::ReferenceRule::RESET_CHILD, "12.1.2"}, + {Issue::ReferenceRule::RESET_TEST_VALUE, "12.1.2"}, + {Issue::ReferenceRule::RESET_RESET_VALUE, "12.1.2"}, + {Issue::ReferenceRule::MATH_MATHML, "14.1.1"}, + {Issue::ReferenceRule::MATH_CHILD, "14.1.2"}, + {Issue::ReferenceRule::MATH_CI_VARIABLE_REFERENCE, "14.1.3"}, + {Issue::ReferenceRule::MATH_CN_UNITS_ATTRIBUTE, "14.1.4"}, + {Issue::ReferenceRule::ENCAPSULATION_COMPONENT_REF, "15.1.1"}, + {Issue::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE, "16.1.1"}, + {Issue::ReferenceRule::COMPONENT_REF_CHILD, "16.1.2"}, + {Issue::ReferenceRule::COMPONENT_REF_ENCAPSULATION, "16.1.3"}, // Seems to be the same as 12.1.1? + {Issue::ReferenceRule::CONNECTION_COMPONENT1, "17.1.1"}, + {Issue::ReferenceRule::CONNECTION_COMPONENT2, "17.1.2"}, + {Issue::ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE, "17.1.3"}, + {Issue::ReferenceRule::CONNECTION_MAP_VARIABLES, "17.1.4"}, + {Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1, "18.1.1"}, + {Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2, "18.1.2"}, + {Issue::ReferenceRule::MAP_VARIABLES_UNIQUE, "18.1.3"}}; std::string Issue::referenceHeading() const { diff --git a/src/logger.cpp b/src/logger.cpp index 997ff70bf..2650db2c1 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -131,21 +131,4 @@ IssuePtr Logger::issue(size_t index) const return issue; } -IssuePtr Logger::issue(size_t index, libcellml::Issue::Level level) const -{ - IssuePtr e = nullptr; - switch (level) { - case libcellml::Issue::Level::ERROR: - e = error(index); - break; - case libcellml::Issue::Level::WARNING: - e = warning(index); - break; - case libcellml::Issue::Level::HINT: - e = hint(index); - break; - } - return e; -} - } // namespace libcellml diff --git a/src/parser.cpp b/src/parser.cpp index 8996b39af..769412f6f 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -282,7 +282,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp issue->setDescription("Model element is of invalid type '" + node->name() + "'. A valid CellML root node should be of type 'model'."); } issue->setModel(model); - issue->setReferenceRule(ReferenceRule::MODEL_ELEMENT); + issue->setReferenceRule(Issue::ReferenceRule::MODEL_ELEMENT); mParser->addIssue(issue); return; } @@ -347,7 +347,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp issue->setDescription("Encapsulation in model '" + model->name() + "' does not contain any child elements."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setReferenceRule(ReferenceRule::ENCAPSULATION_COMPONENT_REF); + issue->setReferenceRule(Issue::ReferenceRule::ENCAPSULATION_COMPONENT_REF); mParser->addIssue(issue); } } else if (childNode->isCellmlElement("connection")) { @@ -359,7 +359,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr issue = Issue::create(); issue->setDescription("Model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); issue->setModel(model); - issue->setReferenceRule(ReferenceRule::MODEL_CHILD); + issue->setReferenceRule(Issue::ReferenceRule::MODEL_CHILD); mParser->addIssue(issue); } } else if (childNode->isComment()) { @@ -368,7 +368,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp IssuePtr issue = Issue::create(); issue->setDescription("Model '" + model->name() + "' has an invalid child element '" + childNode->name() + "'."); issue->setModel(model); - issue->setReferenceRule(ReferenceRule::MODEL_CHILD); + issue->setReferenceRule(Issue::ReferenceRule::MODEL_CHILD); mParser->addIssue(issue); } childNode = childNode->next(); @@ -381,7 +381,7 @@ void Parser::ParserImpl::loadModel(const ModelPtr &model, const std::string &inp issue->setDescription("Model '" + model->name() + "' has more than one encapsulation element."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setReferenceRule(ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); + issue->setReferenceRule(Issue::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); mParser->addIssue(issue); } } @@ -528,7 +528,7 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN IssuePtr issue = Issue::create(); issue->setDescription("Component '" + component->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); issue->setComponent(component); - issue->setReferenceRule(ReferenceRule::COMPONENT_CHILD); + issue->setReferenceRule(Issue::ReferenceRule::COMPONENT_CHILD); mParser->addIssue(issue); } } else if (childNode->isComment()) { @@ -537,7 +537,7 @@ void Parser::ParserImpl::loadComponent(const ComponentPtr &component, const XmlN IssuePtr issue = Issue::create(); issue->setDescription("Component '" + component->name() + "' has an invalid child element '" + childNode->name() + "'."); issue->setComponent(component); - issue->setReferenceRule(ReferenceRule::COMPONENT_CHILD); + issue->setReferenceRule(Issue::ReferenceRule::COMPONENT_CHILD); mParser->addIssue(issue); } childNode = childNode->next(); @@ -571,7 +571,7 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node IssuePtr issue = Issue::create(); issue->setDescription("Units '" + units->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); issue->setUnits(units); - issue->setReferenceRule(ReferenceRule::UNITS_CHILD); + issue->setReferenceRule(Issue::ReferenceRule::UNITS_CHILD); mParser->addIssue(issue); } } else if (childNode->isComment()) { @@ -580,7 +580,7 @@ void Parser::ParserImpl::loadUnits(const UnitsPtr &units, const XmlNodePtr &node IssuePtr issue = Issue::create(); issue->setDescription("Units '" + units->name() + "' has an invalid child element '" + childNode->name() + "'."); issue->setUnits(units); - issue->setReferenceRule(ReferenceRule::UNITS_CHILD); + issue->setReferenceRule(Issue::ReferenceRule::UNITS_CHILD); mParser->addIssue(issue); } childNode = childNode->next(); @@ -631,7 +631,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr issue = Issue::create(); issue->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an exponent with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); issue->setUnits(units); - issue->setReferenceRule(ReferenceRule::UNIT_EXPONENT); + issue->setReferenceRule(Issue::ReferenceRule::UNIT_EXPONENT); mParser->addIssue(issue); } } else if (attribute->isType("multiplier")) { @@ -642,7 +642,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr issue = Issue::create(); issue->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has a multiplier with the value '" + attribute->value() + "' that is not a representation of a CellML real valued number."); issue->setUnits(units); - issue->setReferenceRule(ReferenceRule::UNIT_MULTIPLIER); + issue->setReferenceRule(Issue::ReferenceRule::UNIT_MULTIPLIER); mParser->addIssue(issue); } } else if (attribute->isType("id")) { @@ -651,7 +651,7 @@ void Parser::ParserImpl::loadUnit(const UnitsPtr &units, const XmlNodePtr &node) IssuePtr issue = Issue::create(); issue->setDescription("Unit referencing '" + node->attribute("units") + "' in units '" + units->name() + "' has an invalid attribute '" + attribute->name() + "'."); issue->setUnits(units); - issue->setReferenceRule(ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); + issue->setReferenceRule(Issue::ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); mParser->addIssue(issue); } attribute = attribute->next(); @@ -750,7 +750,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' does not have a valid component_1 in a connection element."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setReferenceRule(ReferenceRule::CONNECTION_COMPONENT1); + issue->setReferenceRule(Issue::ReferenceRule::CONNECTION_COMPONENT1); mParser->addIssue(issue); component1Missing = true; } @@ -759,7 +759,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' does not have a valid component_2 in a connection element."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setReferenceRule(ReferenceRule::CONNECTION_COMPONENT2); + issue->setReferenceRule(Issue::ReferenceRule::CONNECTION_COMPONENT2); mParser->addIssue(issue); component2Missing = true; } @@ -773,7 +773,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' must contain one or more 'map_variables' elements."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setReferenceRule(ReferenceRule::CONNECTION_MAP_VARIABLES); + issue->setReferenceRule(Issue::ReferenceRule::CONNECTION_MAP_VARIABLES); mParser->addIssue(issue); return; } @@ -831,7 +831,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_1 in a map_variables element."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setReferenceRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); + issue->setReferenceRule(Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1); mParser->addIssue(issue); variable1Missing = true; } @@ -840,7 +840,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' does not have a valid variable_2 in a map_variables element."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setReferenceRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); + issue->setReferenceRule(Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2); mParser->addIssue(issue); variable2Missing = true; } @@ -884,7 +884,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.first + "' as component_1 but it does not exist in the model."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setReferenceRule(ReferenceRule::CONNECTION_COMPONENT1); + issue->setReferenceRule(Issue::ReferenceRule::CONNECTION_COMPONENT1); mParser->addIssue(issue); } } @@ -896,7 +896,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' specifies '" + componentNamePair.second + "' as component_2 but it does not exist in the model."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setReferenceRule(ReferenceRule::CONNECTION_COMPONENT2); + issue->setReferenceRule(Issue::ReferenceRule::CONNECTION_COMPONENT2); mParser->addIssue(issue); } } @@ -920,7 +920,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Variable '" + iterPair.first + "' is specified as variable_1 in a connection but it does not exist in component_1 component '" + component1->name() + "' of model '" + model->name() + "'."); issue->setComponent(component1); issue->setCause(Issue::Cause::CONNECTION); - issue->setReferenceRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); + issue->setReferenceRule(Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1); mParser->addIssue(issue); } } @@ -929,7 +929,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.first + "' as variable_1 but the corresponding component_1 is invalid."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setReferenceRule(ReferenceRule::MAP_VARIABLES_VARIABLE1); + issue->setReferenceRule(Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1); mParser->addIssue(issue); } if (component2) { @@ -946,7 +946,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Variable '" + iterPair.second + "' is specified as variable_2 in a connection but it does not exist in component_2 component '" + component2->name() + "' of model '" + model->name() + "'."); issue->setComponent(component1); issue->setCause(Issue::Cause::CONNECTION); - issue->setReferenceRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); + issue->setReferenceRule(Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2); mParser->addIssue(issue); } } @@ -955,7 +955,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' specifies '" + iterPair.second + "' as variable_2 but the corresponding component_2 is invalid."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setReferenceRule(ReferenceRule::MAP_VARIABLES_VARIABLE2); + issue->setReferenceRule(Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2); mParser->addIssue(issue); } // Set the variable equivalence relationship for this variable pair. @@ -968,7 +968,7 @@ void Parser::ParserImpl::loadConnection(const ModelPtr &model, const XmlNodePtr issue->setDescription("Connection in model '" + model->name() + "' does not have a map_variables element."); issue->setModel(model); issue->setCause(Issue::Cause::CONNECTION); - issue->setReferenceRule(ReferenceRule::CONNECTION_MAP_VARIABLES); + issue->setReferenceRule(Issue::ReferenceRule::CONNECTION_MAP_VARIABLES); mParser->addIssue(issue); } } @@ -991,7 +991,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X issue->setDescription("Encapsulation in model '" + model->name() + "' specifies '" + parentComponentName + "' as a component in a component_ref but it does not exist in the model."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setReferenceRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + issue->setReferenceRule(Issue::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); mParser->addIssue(issue); } } else if (attribute->isType("id")) { @@ -1001,7 +1001,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X issue->setDescription("Encapsulation in model '" + model->name() + "' has an invalid component_ref attribute '" + attribute->name() + "'."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setReferenceRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + issue->setReferenceRule(Issue::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); mParser->addIssue(issue); } attribute = attribute->next(); @@ -1011,7 +1011,7 @@ ComponentPtr Parser::ParserImpl::loadComponentRef(const ModelPtr &model, const X issue->setDescription("Encapsulation in model '" + model->name() + "' does not have a valid component attribute in a component_ref element."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setReferenceRule(ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + issue->setReferenceRule(Issue::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); mParser->addIssue(issue); } else if (parentComponent) { parentComponent->setEncapsulationId(encapsulationId); @@ -1074,7 +1074,7 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP issue->setDescription("Encapsulation in model '" + model->name() + "' has an invalid non-whitespace child text element '" + textNode + "'."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setReferenceRule(ReferenceRule::COMPONENT_REF_CHILD); + issue->setReferenceRule(Issue::ReferenceRule::COMPONENT_REF_CHILD); mParser->addIssue(issue); } else { // Continue to next node if this is whitespace (don't try to parse children of whitespace). @@ -1088,7 +1088,7 @@ void Parser::ParserImpl::loadEncapsulation(const ModelPtr &model, const XmlNodeP issue->setDescription("Encapsulation in model '" + model->name() + "' has an invalid child element '" + componentRefNode->name() + "'."); issue->setModel(model); issue->setCause(Issue::Cause::ENCAPSULATION); - issue->setReferenceRule(ReferenceRule::ENCAPSULATION_COMPONENT_REF); + issue->setReferenceRule(Issue::ReferenceRule::ENCAPSULATION_COMPONENT_REF); mParser->addIssue(issue); } @@ -1187,7 +1187,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M IssuePtr issue = Issue::create(); issue->setDescription("Import from '" + node->attribute("href") + "' has an invalid non-whitespace child text element '" + textNode + "'."); issue->setImportSource(importSource); - issue->setReferenceRule(ReferenceRule::IMPORT_CHILD); + issue->setReferenceRule(Issue::ReferenceRule::IMPORT_CHILD); mParser->addIssue(issue); } } else if (childNode->isComment()) { @@ -1196,7 +1196,7 @@ void Parser::ParserImpl::loadImport(const ImportSourcePtr &importSource, const M IssuePtr issue = Issue::create(); issue->setDescription("Import from '" + node->attribute("href") + "' has an invalid child element '" + childNode->name() + "'."); issue->setImportSource(importSource); - issue->setReferenceRule(ReferenceRule::IMPORT_CHILD); + issue->setReferenceRule(Issue::ReferenceRule::IMPORT_CHILD); mParser->addIssue(issue); } childNode = childNode->next(); @@ -1229,7 +1229,7 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese IssuePtr issue = Issue::create(); issue->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' has an unexpected attribute in the " + childType + " block of '" + childAttribute->name() + "'."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_TEST_VALUE); + issue->setReferenceRule(Issue::ReferenceRule::RESET_TEST_VALUE); mParser->addIssue(issue); } childAttribute = childAttribute->next(); @@ -1253,7 +1253,7 @@ void Parser::ParserImpl::loadResetChild(const std::string &childType, const Rese IssuePtr issue = Issue::create(); issue->setDescription("The " + childType + " in the reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' should have a MathML block as a child."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_TEST_VALUE); + issue->setReferenceRule(Issue::ReferenceRule::RESET_TEST_VALUE); mParser->addIssue(issue); } } @@ -1279,7 +1279,7 @@ void Parser::ParserImpl::checkResetChildMultiplicity(size_t count, const std::st issue->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' has " + convertToString(count) + " " + childType + " blocks."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_TEST_VALUE); + issue->setReferenceRule(Issue::ReferenceRule::RESET_TEST_VALUE); mParser->addIssue(issue); } if (count == 0) { @@ -1287,7 +1287,7 @@ void Parser::ParserImpl::checkResetChildMultiplicity(size_t count, const std::st issue->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' and test_variable '" + testVariableName + "' does not have a " + childType + " block defined."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_TEST_VALUE); + issue->setReferenceRule(Issue::ReferenceRule::RESET_TEST_VALUE); mParser->addIssue(issue); } } @@ -1313,7 +1313,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr issue = Issue::create(); issue->setDescription("Reset referencing variable '" + variableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_VARIABLE_REFERENCE); + issue->setReferenceRule(Issue::ReferenceRule::RESET_VARIABLE_REFERENCE); mParser->addIssue(issue); } else { reset->setVariable(referencedVariable); @@ -1326,7 +1326,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr issue = Issue::create(); issue->setDescription("Reset referencing test_variable '" + testVariableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); + issue->setReferenceRule(Issue::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); mParser->addIssue(issue); } else { reset->setTestVariable(testVariable); @@ -1343,7 +1343,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr issue = Issue::create(); issue->setDescription("Reset in component '" + component->name() + "' referencing variable '" + variableName + "' has a non-integer order value '" + attribute->value() + "'."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_ORDER); + issue->setReferenceRule(Issue::ReferenceRule::RESET_ORDER); mParser->addIssue(issue); } } else if (attribute->isType("id")) { @@ -1363,7 +1363,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr issue = Issue::create(); issue->setDescription("Reset in component '" + component->name() + "' does not have its order set."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_ORDER); + issue->setReferenceRule(Issue::ReferenceRule::RESET_ORDER); mParser->addIssue(issue); } @@ -1385,7 +1385,7 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co IssuePtr issue = Issue::create(); issue->setDescription("Reset has an invalid non-whitespace child text element '" + textNode + "'. Either a test_value block or a reset_value block is expected."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_CHILD); + issue->setReferenceRule(Issue::ReferenceRule::RESET_CHILD); mParser->addIssue(issue); } } else if (childNode->isComment()) { diff --git a/src/validator.cpp b/src/validator.cpp index 925352381..b861140e2 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -318,7 +318,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr issue = Issue::create(); issue->setDescription("Model does not have a valid name attribute."); issue->setModel(model); - issue->setReferenceRule(ReferenceRule::MODEL_NAME); + issue->setReferenceRule(Issue::ReferenceRule::MODEL_NAME); addIssue(issue); } // Check for components in this model. @@ -347,7 +347,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr issue = Issue::create(); issue->setDescription("Imported units '" + unitsName + "' does not have a valid units_ref attribute."); issue->setUnits(units); - issue->setReferenceRule(ReferenceRule::IMPORT_UNITS_REF); + issue->setReferenceRule(Issue::ReferenceRule::IMPORT_UNITS_REF); addIssue(issue); foundImportIssue = true; } @@ -357,7 +357,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr issue = Issue::create(); issue->setDescription("Import of units '" + unitsName + "' does not have a valid locator xlink:href attribute."); issue->setImportSource(units->importSource()); - issue->setReferenceRule(ReferenceRule::IMPORT_HREF); + issue->setReferenceRule(Issue::ReferenceRule::IMPORT_HREF); addIssue(issue); foundImportIssue = true; } @@ -369,7 +369,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr issue = Issue::create(); issue->setDescription("Model '" + model->name() + "' contains multiple imported units from '" + importSource + "' with the same units_ref attribute '" + unitsRef + "'."); issue->setModel(model); - issue->setReferenceRule(ReferenceRule::IMPORT_UNITS_REF); + issue->setReferenceRule(Issue::ReferenceRule::IMPORT_UNITS_REF); addIssue(issue); } } @@ -382,7 +382,7 @@ void Validator::validateModel(const ModelPtr &model) IssuePtr issue = Issue::create(); issue->setDescription("Model '" + model->name() + "' contains multiple units with the name '" + unitsName + "'. Valid units names must be unique to their model."); issue->setModel(model); - issue->setReferenceRule(ReferenceRule::UNITS_NAME_UNIQUE); + issue->setReferenceRule(Issue::ReferenceRule::UNITS_NAME_UNIQUE); addIssue(issue); } unitsNames.push_back(unitsName); @@ -438,7 +438,7 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com IssuePtr issue = Issue::create(); issue->setComponent(component); issue->setDescription("Imported component does not have a valid name attribute."); - issue->setReferenceRule(ReferenceRule::IMPORT_COMPONENT_NAME); + issue->setReferenceRule(Issue::ReferenceRule::IMPORT_COMPONENT_NAME); mValidator->addIssue(issue); } @@ -451,14 +451,14 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com IssuePtr issue = Issue::create(); issue->setDescription("Imported component '" + componentName + "' does not have a valid component_ref attribute."); issue->setComponent(component); - issue->setReferenceRule(ReferenceRule::IMPORT_COMPONENT_REF); + issue->setReferenceRule(Issue::ReferenceRule::IMPORT_COMPONENT_REF); mValidator->addIssue(issue); } if (importSource.empty()) { IssuePtr issue = Issue::create(); issue->setDescription("Import of component '" + componentName + "' does not have a valid locator xlink:href attribute."); issue->setImportSource(component->importSource()); - issue->setReferenceRule(ReferenceRule::IMPORT_HREF); + issue->setReferenceRule(Issue::ReferenceRule::IMPORT_HREF); mValidator->addIssue(issue); } else { xmlURIPtr uri = xmlParseURI(importSource.c_str()); @@ -466,7 +466,7 @@ void Validator::ValidatorImpl::validateImportedComponent(const ComponentPtr &com IssuePtr issue = Issue::create(); issue->setDescription("Import of component '" + componentName + "' has an invalid URI in the href attribute."); issue->setImportSource(component->importSource()); - issue->setReferenceRule(ReferenceRule::IMPORT_HREF); + issue->setReferenceRule(Issue::ReferenceRule::IMPORT_HREF); mValidator->addIssue(issue); } else { @@ -482,7 +482,7 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) IssuePtr issue = Issue::create(); issue->setComponent(component); issue->setDescription("Component does not have a valid name attribute."); - issue->setReferenceRule(ReferenceRule::COMPONENT_NAME); + issue->setReferenceRule(Issue::ReferenceRule::COMPONENT_NAME); mValidator->addIssue(issue); } // Check for variables in this component. @@ -497,7 +497,7 @@ void Validator::ValidatorImpl::validateComponent(const ComponentPtr &component) IssuePtr issue = Issue::create(); issue->setDescription("Component '" + component->name() + "' contains multiple variables with the name '" + variableName + "'. Valid variable names must be unique to their component."); issue->setComponent(component); - issue->setReferenceRule(ReferenceRule::VARIABLE_NAME); + issue->setReferenceRule(Issue::ReferenceRule::VARIABLE_NAME); mValidator->addIssue(issue); } variableNames.push_back(variableName); @@ -529,10 +529,10 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v issue->setUnits(units); if (units->isImport()) { issue->setDescription("Imported units does not have a valid name attribute."); - issue->setReferenceRule(ReferenceRule::IMPORT_UNITS_NAME); + issue->setReferenceRule(Issue::ReferenceRule::IMPORT_UNITS_NAME); } else { issue->setDescription("Units does not have a valid name attribute."); - issue->setReferenceRule(ReferenceRule::UNITS_NAME); + issue->setReferenceRule(Issue::ReferenceRule::UNITS_NAME); } mValidator->addIssue(issue); } else { @@ -541,7 +541,7 @@ void Validator::ValidatorImpl::validateUnits(const UnitsPtr &units, const std::v IssuePtr issue = Issue::create(); issue->setDescription("Units is named '" + units->name() + "' which is a protected standard unit name."); issue->setUnits(units); - issue->setReferenceRule(ReferenceRule::UNITS_STANDARD); + issue->setReferenceRule(Issue::ReferenceRule::UNITS_STANDARD); mValidator->addIssue(issue); } } @@ -567,14 +567,14 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u IssuePtr issue = Issue::create(); issue->setDescription("Units reference '" + reference + "' in units '" + units->name() + "' is not a valid reference to a local units or a standard unit type."); issue->setUnits(units); - issue->setReferenceRule(ReferenceRule::UNIT_UNITS_REF); + issue->setReferenceRule(Issue::ReferenceRule::UNIT_UNITS_REF); mValidator->addIssue(issue); } } else { IssuePtr issue = Issue::create(); issue->setDescription("Unit in units '" + units->name() + "' does not have a valid units reference."); issue->setUnits(units); - issue->setReferenceRule(ReferenceRule::UNIT_UNITS_REF); + issue->setReferenceRule(Issue::ReferenceRule::UNIT_UNITS_REF); mValidator->addIssue(issue); } if (!prefix.empty()) { @@ -583,7 +583,7 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u IssuePtr issue = Issue::create(); issue->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is not a valid integer or an SI prefix."); issue->setUnits(units); - issue->setReferenceRule(ReferenceRule::UNIT_PREFIX); + issue->setReferenceRule(Issue::ReferenceRule::UNIT_PREFIX); mValidator->addIssue(issue); } else { try { @@ -593,7 +593,7 @@ void Validator::ValidatorImpl::validateUnitsUnit(size_t index, const UnitsPtr &u IssuePtr issue = Issue::create(); issue->setDescription("Prefix '" + prefix + "' of a unit referencing '" + reference + "' in units '" + units->name() + "' is out of the integer range."); issue->setUnits(units); - issue->setReferenceRule(ReferenceRule::UNIT_PREFIX); + issue->setReferenceRule(Issue::ReferenceRule::UNIT_PREFIX); mValidator->addIssue(issue); } } @@ -608,7 +608,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr issue = Issue::create(); issue->setDescription("Variable does not have a valid name attribute."); issue->setVariable(variable); - issue->setReferenceRule(ReferenceRule::VARIABLE_NAME); + issue->setReferenceRule(Issue::ReferenceRule::VARIABLE_NAME); mValidator->addIssue(issue); } // Check for a valid units attribute. @@ -617,7 +617,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr issue = Issue::create(); issue->setDescription("Variable '" + variable->name() + "' does not have a valid units attribute."); issue->setVariable(variable); - issue->setReferenceRule(ReferenceRule::VARIABLE_UNITS); + issue->setReferenceRule(Issue::ReferenceRule::VARIABLE_UNITS); mValidator->addIssue(issue); } else if (!isStandardUnitName(unitsName)) { ComponentPtr component = std::dynamic_pointer_cast(variable->parent()); @@ -626,7 +626,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr issue = Issue::create(); issue->setDescription("Variable '" + variable->name() + "' in component '" + component->name() + "' has a units reference '" + unitsName + "' which is neither standard nor defined in the parent model."); issue->setVariable(variable); - issue->setReferenceRule(ReferenceRule::VARIABLE_UNITS); + issue->setReferenceRule(Issue::ReferenceRule::VARIABLE_UNITS); mValidator->addIssue(issue); } } @@ -637,7 +637,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr issue = Issue::create(); issue->setDescription("Variable '" + variable->name() + "' has an invalid interface attribute value '" + interfaceType + "'."); issue->setVariable(variable); - issue->setReferenceRule(ReferenceRule::VARIABLE_INTERFACE); + issue->setReferenceRule(Issue::ReferenceRule::VARIABLE_INTERFACE); mValidator->addIssue(issue); } } @@ -651,7 +651,7 @@ void Validator::ValidatorImpl::validateVariable(const VariablePtr &variable, con IssuePtr issue = Issue::create(); issue->setDescription("Variable '" + variable->name() + "' has an invalid initial value '" + initialValue + "'. Initial values must be a real number string or a variable reference."); issue->setVariable(variable); - issue->setReferenceRule(ReferenceRule::VARIABLE_INITIAL_VALUE); + issue->setReferenceRule(Issue::ReferenceRule::VARIABLE_INITIAL_VALUE); mValidator->addIssue(issue); } } @@ -722,49 +722,49 @@ void Validator::ValidatorImpl::validateReset(const ResetPtr &reset, const Compon IssuePtr issue = Issue::create(); issue->setDescription(description + "does not have an order set."); issue->setComponent(component); - issue->setReferenceRule(ReferenceRule::RESET_ORDER); + issue->setReferenceRule(Issue::ReferenceRule::RESET_ORDER); mValidator->addIssue(issue); } if (noVariable) { IssuePtr issue = Issue::create(); issue->setDescription(description + "does not reference a variable."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_VARIABLE_REFERENCE); + issue->setReferenceRule(Issue::ReferenceRule::RESET_VARIABLE_REFERENCE); mValidator->addIssue(issue); } if (noTestVariable) { IssuePtr issue = Issue::create(); issue->setDescription(description + "does not reference a test_variable."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); + issue->setReferenceRule(Issue::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); mValidator->addIssue(issue); } if (noTestValue) { IssuePtr issue = Issue::create(); issue->setDescription(description + "does not have a test_value specified."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_TEST_VALUE); + issue->setReferenceRule(Issue::ReferenceRule::RESET_TEST_VALUE); mValidator->addIssue(issue); } if (noResetValue) { IssuePtr issue = Issue::create(); issue->setDescription(description + "does not have a reset_value specified."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_RESET_VALUE); + issue->setReferenceRule(Issue::ReferenceRule::RESET_RESET_VALUE); mValidator->addIssue(issue); } if (varOutsideComponent) { IssuePtr issue = Issue::create(); issue->setDescription(description + "refers to a variable '" + reset->variable()->name() + "' in a different component '" + varParentName + "'."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_VARIABLE_REFERENCE); + issue->setReferenceRule(Issue::ReferenceRule::RESET_VARIABLE_REFERENCE); mValidator->addIssue(issue); } if (testVarOutsideComponent) { IssuePtr issue = Issue::create(); issue->setDescription(description + "refers to a test_variable '" + reset->testVariable()->name() + "' in a different component '" + testVarParentName + "'."); issue->setReset(reset); - issue->setReferenceRule(ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); + issue->setReferenceRule(Issue::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); mValidator->addIssue(issue); } } @@ -1077,7 +1077,7 @@ void Validator::ValidatorImpl::validateEquivalenceUnits(const ModelPtr &model, c err->setDescription("Variable '" + variable->name() + "' in component '" + parent1->name() + "' has units of '" + unitsName + "' and an equivalent variable '" + equivalentVariable->name() + "' in component '" + parent2->name() + "' with non-matching units of '" + equivalentUnitsName + "'. The mismatch is: " + hints); err->setModel(model); err->setCause(Issue::Cause::UNITS); - err->setReferenceRule(ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); + err->setReferenceRule(Issue::ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); mValidator->addIssue(err); } // TODO Removed until after PR 521 has been merged. @@ -1098,7 +1098,7 @@ void Validator::ValidatorImpl::validateEquivalenceUnits(const ModelPtr &model, c // err->setModel(model); // err->setDescription(des); // err->setCause(Issue::Cause::UNITS); - // err->setReferenceRule(ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); + // err->setReferenceRule(Issue::ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); // err->setLevel(Issue::Level::WARNING); // mValidator->addIssue(err); // } @@ -1157,7 +1157,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) result = false; IssuePtr issue = Issue::create(); issue->setDescription("CellML identifiers must not begin with a European numeric character [0-9]."); - issue->setReferenceRule(ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); + issue->setReferenceRule(Issue::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); mValidator->addIssue(issue); } else { // Basic Latin alphanumeric characters and underscores. @@ -1165,7 +1165,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) result = false; IssuePtr issue = Issue::create(); issue->setDescription("CellML identifiers must not contain any characters other than [a-zA-Z0-9_]."); - issue->setReferenceRule(ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); + issue->setReferenceRule(Issue::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); mValidator->addIssue(issue); } } @@ -1173,7 +1173,7 @@ bool Validator::ValidatorImpl::isCellmlIdentifier(const std::string &name) result = false; IssuePtr issue = Issue::create(); issue->setDescription("CellML identifiers must contain one or more basic Latin alphabetic characters."); - issue->setReferenceRule(ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); + issue->setReferenceRule(Issue::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); mValidator->addIssue(issue); } return result; diff --git a/tests/bindings/python/test_issue.py b/tests/bindings/python/test_issue.py index 6b4565779..4d61ed7d6 100644 --- a/tests/bindings/python/test_issue.py +++ b/tests/bindings/python/test_issue.py @@ -6,6 +6,7 @@ class IssueTestCase(unittest.TestCase): + def test_create_destroy(self): from libcellml import Component from libcellml import Issue @@ -62,75 +63,73 @@ def test_cause_enum(self): self.assertRaises(RuntimeError, e.setCause, Issue.Cause.COMPONENT - 1) self.assertRaises(RuntimeError, e.setCause, Issue.Cause.XML + 1) - def test_specification_rule_enum(self): - from libcellml import Issue, ReferenceRule - - self.assertIsInstance(ReferenceRule.UNDEFINED, int) - self.assertIsInstance(ReferenceRule.DATA_REPR_IDENTIFIER_UNICODE, int) - self.assertIsInstance(ReferenceRule.DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, int) - self.assertIsInstance(ReferenceRule.DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, int) - self.assertIsInstance(ReferenceRule.DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM, int) - self.assertIsInstance(ReferenceRule.DATA_REPR_IDENTIFIER_IDENTICAL, int) - self.assertIsInstance(ReferenceRule.DATA_REPR_NNEG_INT_BASE10, int) - self.assertIsInstance(ReferenceRule.DATA_REPR_NNEG_INT_EURO_NUM, int) - self.assertIsInstance(ReferenceRule.MODEL_ELEMENT, int) - self.assertIsInstance(ReferenceRule.MODEL_NAME, int) - self.assertIsInstance(ReferenceRule.MODEL_CHILD, int) - self.assertIsInstance(ReferenceRule.MODEL_MORE_THAN_ONE_ENCAPSULATION, int) - self.assertIsInstance(ReferenceRule.IMPORT_HREF, int) - self.assertIsInstance(ReferenceRule.IMPORT_CHILD, int) - self.assertIsInstance(ReferenceRule.IMPORT_CIRCULAR, int) - self.assertIsInstance(ReferenceRule.IMPORT_UNITS_NAME, int) - self.assertIsInstance(ReferenceRule.IMPORT_UNITS_REF, int) - self.assertIsInstance(ReferenceRule.IMPORT_COMPONENT_NAME, int) - self.assertIsInstance(ReferenceRule.IMPORT_COMPONENT_REF, int) - self.assertIsInstance(ReferenceRule.UNITS_NAME, int) - self.assertIsInstance(ReferenceRule.UNITS_NAME_UNIQUE, int) - self.assertIsInstance(ReferenceRule.UNITS_STANDARD, int) - self.assertIsInstance(ReferenceRule.UNITS_CHILD, int) - self.assertIsInstance(ReferenceRule.UNIT_UNITS_REF, int) - self.assertIsInstance(ReferenceRule.UNIT_DIGRAPH, int) - self.assertIsInstance(ReferenceRule.UNIT_CIRCULAR_REF, int) - self.assertIsInstance(ReferenceRule.UNIT_OPTIONAL_ATTRIBUTE, int) - self.assertIsInstance(ReferenceRule.UNIT_PREFIX, int) - self.assertIsInstance(ReferenceRule.UNIT_MULTIPLIER, int) - self.assertIsInstance(ReferenceRule.UNIT_EXPONENT, int) - self.assertIsInstance(ReferenceRule.COMPONENT_NAME, int) - self.assertIsInstance(ReferenceRule.COMPONENT_CHILD, int) - self.assertIsInstance(ReferenceRule.VARIABLE_NAME, int) - self.assertIsInstance(ReferenceRule.VARIABLE_UNITS, int) - self.assertIsInstance(ReferenceRule.VARIABLE_INTERFACE, int) - self.assertIsInstance(ReferenceRule.VARIABLE_INITIAL_VALUE, int) - self.assertIsInstance(ReferenceRule.RESET_VARIABLE_REFERENCE, int) - self.assertIsInstance(ReferenceRule.RESET_TEST_VARIABLE_REFERENCE, int) - self.assertIsInstance(ReferenceRule.RESET_ORDER, int) - self.assertIsInstance(ReferenceRule.RESET_CHILD, int) - self.assertIsInstance(ReferenceRule.RESET_RESET_VALUE, int) - self.assertIsInstance(ReferenceRule.RESET_TEST_VALUE, int) - self.assertIsInstance(ReferenceRule.MATH_MATHML, int) - self.assertIsInstance(ReferenceRule.MATH_CHILD, int) - self.assertIsInstance(ReferenceRule.MATH_CI_VARIABLE_REFERENCE, int) - self.assertIsInstance(ReferenceRule.MATH_CN_UNITS_ATTRIBUTE, int) - self.assertIsInstance(ReferenceRule.ENCAPSULATION_COMPONENT_REF, int) - self.assertIsInstance(ReferenceRule.COMPONENT_REF_COMPONENT_ATTRIBUTE, int) - self.assertIsInstance(ReferenceRule.COMPONENT_REF_CHILD, int) - self.assertIsInstance(ReferenceRule.COMPONENT_REF_ENCAPSULATION, int) - self.assertIsInstance(ReferenceRule.CONNECTION_COMPONENT1, int) - self.assertIsInstance(ReferenceRule.CONNECTION_COMPONENT2, int) - self.assertIsInstance(ReferenceRule.CONNECTION_UNIQUE_TRANSITIVE, int) - self.assertIsInstance(ReferenceRule.CONNECTION_MAP_VARIABLES, int) - self.assertIsInstance(ReferenceRule.MAP_VARIABLES_VARIABLE1, int) - self.assertIsInstance(ReferenceRule.MAP_VARIABLES_VARIABLE2, int) - self.assertIsInstance(ReferenceRule.MAP_VARIABLES_UNIQUE, int) + def test_reference_rule_enum(self): + from libcellml import Issue - # Test conversion to enum + self.assertIsInstance(Issue.ReferenceRule.UNDEFINED, int) + self.assertIsInstance(Issue.ReferenceRule.DATA_REPR_IDENTIFIER_UNICODE, int) + self.assertIsInstance(Issue.ReferenceRule.DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, int) + self.assertIsInstance(Issue.ReferenceRule.DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, int) + self.assertIsInstance(Issue.ReferenceRule.DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM, int) + self.assertIsInstance(Issue.ReferenceRule.DATA_REPR_IDENTIFIER_IDENTICAL, int) + self.assertIsInstance(Issue.ReferenceRule.DATA_REPR_NNEG_INT_BASE10, int) + self.assertIsInstance(Issue.ReferenceRule.DATA_REPR_NNEG_INT_EURO_NUM, int) + self.assertIsInstance(Issue.ReferenceRule.MODEL_ELEMENT, int) + self.assertIsInstance(Issue.ReferenceRule.MODEL_NAME, int) + self.assertIsInstance(Issue.ReferenceRule.MODEL_CHILD, int) + self.assertIsInstance(Issue.ReferenceRule.MODEL_MORE_THAN_ONE_ENCAPSULATION, int) + self.assertIsInstance(Issue.ReferenceRule.IMPORT_HREF, int) + self.assertIsInstance(Issue.ReferenceRule.IMPORT_CHILD, int) + self.assertIsInstance(Issue.ReferenceRule.IMPORT_CIRCULAR, int) + self.assertIsInstance(Issue.ReferenceRule.IMPORT_UNITS_NAME, int) + self.assertIsInstance(Issue.ReferenceRule.IMPORT_UNITS_REF, int) + self.assertIsInstance(Issue.ReferenceRule.IMPORT_COMPONENT_NAME, int) + self.assertIsInstance(Issue.ReferenceRule.IMPORT_COMPONENT_REF, int) + self.assertIsInstance(Issue.ReferenceRule.UNITS_NAME, int) + self.assertIsInstance(Issue.ReferenceRule.UNITS_NAME_UNIQUE, int) + self.assertIsInstance(Issue.ReferenceRule.UNITS_STANDARD, int) + self.assertIsInstance(Issue.ReferenceRule.UNITS_CHILD, int) + self.assertIsInstance(Issue.ReferenceRule.UNIT_UNITS_REF, int) + self.assertIsInstance(Issue.ReferenceRule.UNIT_DIGRAPH, int) + self.assertIsInstance(Issue.ReferenceRule.UNIT_CIRCULAR_REF, int) + self.assertIsInstance(Issue.ReferenceRule.UNIT_OPTIONAL_ATTRIBUTE, int) + self.assertIsInstance(Issue.ReferenceRule.UNIT_PREFIX, int) + self.assertIsInstance(Issue.ReferenceRule.UNIT_MULTIPLIER, int) + self.assertIsInstance(Issue.ReferenceRule.UNIT_EXPONENT, int) + self.assertIsInstance(Issue.ReferenceRule.COMPONENT_NAME, int) + self.assertIsInstance(Issue.ReferenceRule.COMPONENT_CHILD, int) + self.assertIsInstance(Issue.ReferenceRule.VARIABLE_NAME, int) + self.assertIsInstance(Issue.ReferenceRule.VARIABLE_UNITS, int) + self.assertIsInstance(Issue.ReferenceRule.VARIABLE_INTERFACE, int) + self.assertIsInstance(Issue.ReferenceRule.VARIABLE_INITIAL_VALUE, int) + self.assertIsInstance(Issue.ReferenceRule.RESET_CHILD, int) + self.assertIsInstance(Issue.ReferenceRule.RESET_ORDER, int) + self.assertIsInstance(Issue.ReferenceRule.RESET_VARIABLE_REFERENCE, int) + self.assertIsInstance(Issue.ReferenceRule.RESET_TEST_VARIABLE_REFERENCE, int) + self.assertIsInstance(Issue.ReferenceRule.RESET_TEST_VALUE, int) + self.assertIsInstance(Issue.ReferenceRule.RESET_RESET_VALUE, int) + self.assertIsInstance(Issue.ReferenceRule.MATH_MATHML, int) + self.assertIsInstance(Issue.ReferenceRule.MATH_CHILD, int) + self.assertIsInstance(Issue.ReferenceRule.MATH_CI_VARIABLE_REFERENCE, int) + self.assertIsInstance(Issue.ReferenceRule.MATH_CN_UNITS_ATTRIBUTE, int) + self.assertIsInstance(Issue.ReferenceRule.ENCAPSULATION_COMPONENT_REF, int) + self.assertIsInstance(Issue.ReferenceRule.COMPONENT_REF_COMPONENT_ATTRIBUTE, int) + self.assertIsInstance(Issue.ReferenceRule.COMPONENT_REF_CHILD, int) + self.assertIsInstance(Issue.ReferenceRule.COMPONENT_REF_ENCAPSULATION, int) + self.assertIsInstance(Issue.ReferenceRule.CONNECTION_COMPONENT1, int) + self.assertIsInstance(Issue.ReferenceRule.CONNECTION_COMPONENT2, int) + self.assertIsInstance(Issue.ReferenceRule.CONNECTION_UNIQUE_TRANSITIVE, int) + self.assertIsInstance(Issue.ReferenceRule.CONNECTION_MAP_VARIABLES, int) + self.assertIsInstance(Issue.ReferenceRule.MAP_VARIABLES_VARIABLE1, int) + self.assertIsInstance(Issue.ReferenceRule.MAP_VARIABLES_VARIABLE2, int) + self.assertIsInstance(Issue.ReferenceRule.MAP_VARIABLES_UNIQUE, int) + self.assertIsInstance(Issue.ReferenceRule.MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION, int) + + # Test conversion to enum #KRM not sure why this is failing? e = Issue() - e.setReferenceRule(ReferenceRule.UNDEFINED) - self.assertRaises( - RuntimeError, e.setReferenceRule, ReferenceRule.UNDEFINED - 1) - self.assertRaises( - RuntimeError, e.setReferenceRule, - ReferenceRule.MAP_VARIABLES_UNIQUE + 1) + e.setReferenceRule(Issue.ReferenceRule.UNDEFINED) + self.assertRaises(RuntimeError, e.setReferenceRule, Issue.ReferenceRule.UNDEFINED - 1) + self.assertRaises(RuntimeError, e.setReferenceRule, Issue.ReferenceRule.MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION + 1) del(e) def test_set_description(self): @@ -169,20 +168,20 @@ def test_cause(self): self.assertEqual(e.cause(), Issue.Cause.MATHML) def test_set_rule(self): - from libcellml import Issue, ReferenceRule + from libcellml import Issue # void setReferenceRule(ReferenceRule rule) e = Issue() - e.setReferenceRule(ReferenceRule.MAP_VARIABLES_VARIABLE2) + e.setReferenceRule(Issue.ReferenceRule.MAP_VARIABLES_VARIABLE2) def test_rule(self): - from libcellml import Issue, ReferenceRule + from libcellml import Issue # ReferenceRule referenceRule() e = Issue() - self.assertEqual(e.referenceRule(), ReferenceRule.UNDEFINED) + self.assertEqual(e.referenceRule(), Issue.ReferenceRule.UNDEFINED) - def test_specification_heading(self): + def test_reference_heading(self): from libcellml import Issue # std::string referenceHeading() diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index cbeb98990..bc25c8f33 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -69,178 +69,178 @@ TEST(Issue, createResetIssue) void testReferenceRule(const libcellml::IssuePtr &e) { switch (e->referenceRule()) { - case libcellml::ReferenceRule::COMPONENT_CHILD: + case libcellml::Issue::ReferenceRule::COMPONENT_CHILD: EXPECT_EQ("10.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::COMPONENT_NAME: + case libcellml::Issue::ReferenceRule::COMPONENT_NAME: EXPECT_EQ("10.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::COMPONENT_REF_CHILD: + case libcellml::Issue::ReferenceRule::COMPONENT_REF_CHILD: EXPECT_EQ("16.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE: + case libcellml::Issue::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE: EXPECT_EQ("16.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::COMPONENT_REF_ENCAPSULATION: + case libcellml::Issue::ReferenceRule::COMPONENT_REF_ENCAPSULATION: EXPECT_EQ("16.1.3", e->referenceHeading()); break; - case libcellml::ReferenceRule::CONNECTION_COMPONENT1: + case libcellml::Issue::ReferenceRule::CONNECTION_COMPONENT1: EXPECT_EQ("17.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::CONNECTION_COMPONENT2: + case libcellml::Issue::ReferenceRule::CONNECTION_COMPONENT2: EXPECT_EQ("17.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE: + case libcellml::Issue::ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE: EXPECT_EQ("17.1.3", e->referenceHeading()); break; - case libcellml::ReferenceRule::CONNECTION_MAP_VARIABLES: + case libcellml::Issue::ReferenceRule::CONNECTION_MAP_VARIABLES: EXPECT_EQ("17.1.4", e->referenceHeading()); break; - case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM: + case libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM: EXPECT_EQ("3.1.3", e->referenceHeading()); break; - case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM: + case libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM: EXPECT_EQ("3.1.4", e->referenceHeading()); break; - case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL: + case libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL: EXPECT_EQ("3.1.5", e->referenceHeading()); break; - case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM: + case libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM: EXPECT_EQ("3.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE: + case libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE: EXPECT_EQ("3.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::DATA_REPR_NNEG_INT_BASE10: + case libcellml::Issue::ReferenceRule::DATA_REPR_NNEG_INT_BASE10: EXPECT_EQ("3.2.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM: + case libcellml::Issue::ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM: EXPECT_EQ("3.2.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::ENCAPSULATION_COMPONENT_REF: + case libcellml::Issue::ReferenceRule::ENCAPSULATION_COMPONENT_REF: EXPECT_EQ("15.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::IMPORT_CHILD: + case libcellml::Issue::ReferenceRule::IMPORT_CHILD: EXPECT_EQ("5.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::IMPORT_CIRCULAR: + case libcellml::Issue::ReferenceRule::IMPORT_CIRCULAR: EXPECT_EQ("5.1.3", e->referenceHeading()); break; - case libcellml::ReferenceRule::IMPORT_COMPONENT_NAME: + case libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_NAME: EXPECT_EQ("7.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::IMPORT_COMPONENT_REF: + case libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_REF: EXPECT_EQ("7.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::IMPORT_HREF: + case libcellml::Issue::ReferenceRule::IMPORT_HREF: EXPECT_EQ("5.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::IMPORT_UNITS_NAME: + case libcellml::Issue::ReferenceRule::IMPORT_UNITS_NAME: EXPECT_EQ("6.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::IMPORT_UNITS_REF: + case libcellml::Issue::ReferenceRule::IMPORT_UNITS_REF: EXPECT_EQ("6.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION: + case libcellml::Issue::ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION: EXPECT_EQ("16.1.3", e->referenceHeading()); break; - case libcellml::ReferenceRule::MAP_VARIABLES_UNIQUE: + case libcellml::Issue::ReferenceRule::MAP_VARIABLES_UNIQUE: EXPECT_EQ("18.1.3", e->referenceHeading()); break; - case libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE1: + case libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1: EXPECT_EQ("18.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE2: + case libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2: EXPECT_EQ("18.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::MATH_CHILD: + case libcellml::Issue::ReferenceRule::MATH_CHILD: EXPECT_EQ("14.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::MATH_CI_VARIABLE_REFERENCE: + case libcellml::Issue::ReferenceRule::MATH_CI_VARIABLE_REFERENCE: EXPECT_EQ("14.1.3", e->referenceHeading()); break; - case libcellml::ReferenceRule::MATH_CN_UNITS_ATTRIBUTE: + case libcellml::Issue::ReferenceRule::MATH_CN_UNITS_ATTRIBUTE: EXPECT_EQ("14.1.4", e->referenceHeading()); break; - case libcellml::ReferenceRule::MATH_MATHML: + case libcellml::Issue::ReferenceRule::MATH_MATHML: EXPECT_EQ("14.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::MODEL_CHILD: + case libcellml::Issue::ReferenceRule::MODEL_CHILD: EXPECT_EQ("4.2.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::MODEL_ELEMENT: + case libcellml::Issue::ReferenceRule::MODEL_ELEMENT: EXPECT_EQ("4.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION: + case libcellml::Issue::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION: EXPECT_EQ("4.2.3", e->referenceHeading()); break; - case libcellml::ReferenceRule::MODEL_NAME: + case libcellml::Issue::ReferenceRule::MODEL_NAME: EXPECT_EQ("4.2.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::RESET_CHILD: + case libcellml::Issue::ReferenceRule::RESET_CHILD: EXPECT_EQ("12.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::RESET_VARIABLE_REFERENCE: + case libcellml::Issue::ReferenceRule::RESET_VARIABLE_REFERENCE: EXPECT_EQ("12.1.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE: + case libcellml::Issue::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE: EXPECT_EQ("12.1.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::RESET_ORDER: + case libcellml::Issue::ReferenceRule::RESET_ORDER: EXPECT_EQ("12.1.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::RESET_TEST_VALUE: + case libcellml::Issue::ReferenceRule::RESET_TEST_VALUE: EXPECT_EQ("12.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::RESET_RESET_VALUE: + case libcellml::Issue::ReferenceRule::RESET_RESET_VALUE: EXPECT_EQ("12.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::UNITS_CHILD: + case libcellml::Issue::ReferenceRule::UNITS_CHILD: EXPECT_EQ("8.1.4", e->referenceHeading()); break; - case libcellml::ReferenceRule::UNITS_NAME: + case libcellml::Issue::ReferenceRule::UNITS_NAME: EXPECT_EQ("8.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::UNITS_NAME_UNIQUE: + case libcellml::Issue::ReferenceRule::UNITS_NAME_UNIQUE: EXPECT_EQ("8.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::UNITS_STANDARD: + case libcellml::Issue::ReferenceRule::UNITS_STANDARD: EXPECT_EQ("8.1.3", e->referenceHeading()); break; - case libcellml::ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE: + case libcellml::Issue::ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE: EXPECT_EQ("9.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::UNIT_CIRCULAR_REF: + case libcellml::Issue::ReferenceRule::UNIT_CIRCULAR_REF: EXPECT_EQ("9.1.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::UNIT_DIGRAPH: + case libcellml::Issue::ReferenceRule::UNIT_DIGRAPH: EXPECT_EQ("9.1.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::UNIT_EXPONENT: + case libcellml::Issue::ReferenceRule::UNIT_EXPONENT: EXPECT_EQ("9.1.2.3", e->referenceHeading()); break; - case libcellml::ReferenceRule::UNIT_MULTIPLIER: + case libcellml::Issue::ReferenceRule::UNIT_MULTIPLIER: EXPECT_EQ("9.1.2.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::UNIT_PREFIX: + case libcellml::Issue::ReferenceRule::UNIT_PREFIX: EXPECT_EQ("9.1.2.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::UNIT_UNITS_REF: + case libcellml::Issue::ReferenceRule::UNIT_UNITS_REF: EXPECT_EQ("9.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::VARIABLE_INITIAL_VALUE: + case libcellml::Issue::ReferenceRule::VARIABLE_INITIAL_VALUE: EXPECT_EQ("11.1.2.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::VARIABLE_INTERFACE: + case libcellml::Issue::ReferenceRule::VARIABLE_INTERFACE: EXPECT_EQ("11.1.2.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::VARIABLE_NAME: + case libcellml::Issue::ReferenceRule::VARIABLE_NAME: EXPECT_EQ("11.1.1.1", e->referenceHeading()); break; - case libcellml::ReferenceRule::VARIABLE_UNITS: + case libcellml::Issue::ReferenceRule::VARIABLE_UNITS: EXPECT_EQ("11.1.1.2", e->referenceHeading()); break; - case libcellml::ReferenceRule::UNDEFINED: + case libcellml::Issue::ReferenceRule::UNDEFINED: EXPECT_EQ("", e->referenceHeading()); break; } @@ -250,157 +250,157 @@ TEST(Issue, referenceRule) { size_t count = 0; libcellml::IssuePtr e = libcellml::Issue::create(); - e->setReferenceRule(libcellml::ReferenceRule::UNDEFINED); + e->setReferenceRule(libcellml::Issue::ReferenceRule::UNDEFINED); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::COMPONENT_CHILD); + e->setReferenceRule(libcellml::Issue::ReferenceRule::COMPONENT_CHILD); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::COMPONENT_NAME); + e->setReferenceRule(libcellml::Issue::ReferenceRule::COMPONENT_NAME); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::COMPONENT_REF_CHILD); + e->setReferenceRule(libcellml::Issue::ReferenceRule::COMPONENT_REF_CHILD); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); + e->setReferenceRule(libcellml::Issue::ReferenceRule::COMPONENT_REF_COMPONENT_ATTRIBUTE); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::COMPONENT_REF_ENCAPSULATION); + e->setReferenceRule(libcellml::Issue::ReferenceRule::COMPONENT_REF_ENCAPSULATION); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::CONNECTION_COMPONENT1); + e->setReferenceRule(libcellml::Issue::ReferenceRule::CONNECTION_COMPONENT1); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::CONNECTION_COMPONENT2); + e->setReferenceRule(libcellml::Issue::ReferenceRule::CONNECTION_COMPONENT2); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE); + e->setReferenceRule(libcellml::Issue::ReferenceRule::CONNECTION_UNIQUE_TRANSITIVE); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::CONNECTION_MAP_VARIABLES); + e->setReferenceRule(libcellml::Issue::ReferenceRule::CONNECTION_MAP_VARIABLES); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); + e->setReferenceRule(libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); + e->setReferenceRule(libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL); + e->setReferenceRule(libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_IDENTICAL); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); + e->setReferenceRule(libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_LATIN_ALPHANUM); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE); + e->setReferenceRule(libcellml::Issue::ReferenceRule::DATA_REPR_IDENTIFIER_UNICODE); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_NNEG_INT_BASE10); + e->setReferenceRule(libcellml::Issue::ReferenceRule::DATA_REPR_NNEG_INT_BASE10); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM); + e->setReferenceRule(libcellml::Issue::ReferenceRule::DATA_REPR_NNEG_INT_EURO_NUM); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::ENCAPSULATION_COMPONENT_REF); + e->setReferenceRule(libcellml::Issue::ReferenceRule::ENCAPSULATION_COMPONENT_REF); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::IMPORT_CHILD); + e->setReferenceRule(libcellml::Issue::ReferenceRule::IMPORT_CHILD); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::IMPORT_CIRCULAR); + e->setReferenceRule(libcellml::Issue::ReferenceRule::IMPORT_CIRCULAR); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::IMPORT_COMPONENT_NAME); + e->setReferenceRule(libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_NAME); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::IMPORT_COMPONENT_REF); + e->setReferenceRule(libcellml::Issue::ReferenceRule::IMPORT_COMPONENT_REF); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::IMPORT_HREF); + e->setReferenceRule(libcellml::Issue::ReferenceRule::IMPORT_HREF); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::IMPORT_UNITS_NAME); + e->setReferenceRule(libcellml::Issue::ReferenceRule::IMPORT_UNITS_NAME); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::IMPORT_UNITS_REF); + e->setReferenceRule(libcellml::Issue::ReferenceRule::IMPORT_UNITS_REF); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::MAP_VARIABLES_UNIQUE); + e->setReferenceRule(libcellml::Issue::ReferenceRule::MAP_VARIABLES_UNIQUE); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE1); + e->setReferenceRule(libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE1); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE2); + e->setReferenceRule(libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::MODEL_CHILD); + e->setReferenceRule(libcellml::Issue::ReferenceRule::MODEL_CHILD); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::MODEL_ELEMENT); + e->setReferenceRule(libcellml::Issue::ReferenceRule::MODEL_ELEMENT); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); + e->setReferenceRule(libcellml::Issue::ReferenceRule::MODEL_MORE_THAN_ONE_ENCAPSULATION); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::MODEL_NAME); + e->setReferenceRule(libcellml::Issue::ReferenceRule::MODEL_NAME); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::RESET_CHILD); + e->setReferenceRule(libcellml::Issue::ReferenceRule::RESET_CHILD); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::RESET_VARIABLE_REFERENCE); + e->setReferenceRule(libcellml::Issue::ReferenceRule::RESET_VARIABLE_REFERENCE); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); + e->setReferenceRule(libcellml::Issue::ReferenceRule::RESET_TEST_VARIABLE_REFERENCE); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::RESET_ORDER); + e->setReferenceRule(libcellml::Issue::ReferenceRule::RESET_ORDER); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::UNITS_CHILD); + e->setReferenceRule(libcellml::Issue::ReferenceRule::UNITS_CHILD); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::UNITS_NAME); + e->setReferenceRule(libcellml::Issue::ReferenceRule::UNITS_NAME); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::UNITS_NAME_UNIQUE); + e->setReferenceRule(libcellml::Issue::ReferenceRule::UNITS_NAME_UNIQUE); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::UNITS_STANDARD); + e->setReferenceRule(libcellml::Issue::ReferenceRule::UNITS_STANDARD); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); + e->setReferenceRule(libcellml::Issue::ReferenceRule::UNIT_OPTIONAL_ATTRIBUTE); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::UNIT_CIRCULAR_REF); + e->setReferenceRule(libcellml::Issue::ReferenceRule::UNIT_CIRCULAR_REF); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::UNIT_DIGRAPH); + e->setReferenceRule(libcellml::Issue::ReferenceRule::UNIT_DIGRAPH); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::UNIT_EXPONENT); + e->setReferenceRule(libcellml::Issue::ReferenceRule::UNIT_EXPONENT); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::UNIT_MULTIPLIER); + e->setReferenceRule(libcellml::Issue::ReferenceRule::UNIT_MULTIPLIER); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::UNIT_PREFIX); + e->setReferenceRule(libcellml::Issue::ReferenceRule::UNIT_PREFIX); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::UNIT_UNITS_REF); + e->setReferenceRule(libcellml::Issue::ReferenceRule::UNIT_UNITS_REF); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::VARIABLE_INITIAL_VALUE); + e->setReferenceRule(libcellml::Issue::ReferenceRule::VARIABLE_INITIAL_VALUE); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::VARIABLE_INTERFACE); + e->setReferenceRule(libcellml::Issue::ReferenceRule::VARIABLE_INTERFACE); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::VARIABLE_NAME); + e->setReferenceRule(libcellml::Issue::ReferenceRule::VARIABLE_NAME); ++count; testReferenceRule(e); - e->setReferenceRule(libcellml::ReferenceRule::VARIABLE_UNITS); + e->setReferenceRule(libcellml::Issue::ReferenceRule::VARIABLE_UNITS); ++count; testReferenceRule(e); EXPECT_EQ(size_t(51), count); @@ -485,7 +485,7 @@ TEST(Issue, isHint) // TEST(Issue, getDefaultUrl) // { // auto e = libcellml::Issue::create(); -// e->setReferenceRule(libcellml::ReferenceRule::MODEL_NAME); +// e->setReferenceRule(libcellml::Issue::ReferenceRule::MODEL_NAME); // auto ref = e->referenceHeading(); // // TODO How to get this from the utilties.h file?? Won't be this address in the long run. // std::string url = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q=" + ref; diff --git a/tests/logger/logger.cpp b/tests/logger/logger.cpp index 97923181d..be3cb9050 100644 --- a/tests/logger/logger.cpp +++ b/tests/logger/logger.cpp @@ -114,57 +114,6 @@ TEST(Logger, getIssueByLevelFunction) EXPECT_EQ(hint2, validator->hint(1)); } -TEST(Logger, getIssueByLevelArgument) -{ - auto error1 = libcellml::Issue::create(); - error1->setLevel(libcellml::Issue::Level::ERROR); - - auto warning1 = libcellml::Issue::create(); - warning1->setLevel(libcellml::Issue::Level::WARNING); - - auto hint1 = libcellml::Issue::create(); - hint1->setLevel(libcellml::Issue::Level::HINT); - - auto error2 = libcellml::Issue::create(); - error2->setLevel(libcellml::Issue::Level::ERROR); - - auto warning2 = libcellml::Issue::create(); - warning2->setLevel(libcellml::Issue::Level::WARNING); - - auto hint2 = libcellml::Issue::create(); - hint2->setLevel(libcellml::Issue::Level::HINT); - - auto validator = libcellml::Validator::create(); - validator->addIssue(error1); - validator->addIssue(warning1); - validator->addIssue(hint1); - validator->addIssue(hint2); - validator->addIssue(warning2); - validator->addIssue(error2); - - // Expect to be able to call issue(0-5) and have the appropriate one returned - // in the order they were added, irrespective of their level. - EXPECT_EQ(size_t(6), validator->issueCount()); - EXPECT_EQ(error1, validator->issue(0)); - EXPECT_EQ(warning1, validator->issue(1)); - EXPECT_EQ(hint1, validator->issue(2)); - EXPECT_EQ(hint2, validator->issue(3)); - EXPECT_EQ(warning2, validator->issue(4)); - EXPECT_EQ(error2, validator->issue(5)); - - // Expect to call error(0-1) and get the ERROR level issues only - EXPECT_EQ(error1, validator->issue(0, libcellml::Issue::Level::ERROR)); - EXPECT_EQ(error2, validator->issue(1, libcellml::Issue::Level::ERROR)); - - // Expect to call warning(0-1) and get the WARNING level issues only - EXPECT_EQ(warning1, validator->issue(0, libcellml::Issue::Level::WARNING)); - EXPECT_EQ(warning2, validator->issue(1, libcellml::Issue::Level::WARNING)); - - // Expect to call hint(0-1) and get the HINT level issues only - EXPECT_EQ(hint1, validator->issue(0, libcellml::Issue::Level::HINT)); - EXPECT_EQ(hint2, validator->issue(1, libcellml::Issue::Level::HINT)); -} - TEST(Logger, outOfRangeIndex) { auto error1 = libcellml::Issue::create(); diff --git a/tests/parser/parser.cpp b/tests/parser/parser.cpp index 0b2ceb3ee..538bd4ee6 100644 --- a/tests/parser/parser.cpp +++ b/tests/parser/parser.cpp @@ -1420,7 +1420,7 @@ TEST(Parser, invalidModelWithAllCausesOfIssues) libcellml::IssuePtr undefinedIssue = libcellml::Issue::create(); parser2->addIssue(undefinedIssue); EXPECT_EQ(size_t(1), parser2->issueCount()); - if (parser2->issue(0)->cause()==libcellml::Issue::Cause::UNDEFINED) { + if (parser2->issue(0)->cause() == libcellml::Issue::Cause::UNDEFINED) { foundCause.at(7) = true; } @@ -1434,7 +1434,7 @@ TEST(Parser, invalidModelWithAllCausesOfIssues) parser3->parseModel(input3); EXPECT_EQ_ISSUES(expectedIssues3, parser3); for (size_t i = 0; i < parser3->issueCount(); ++i) { - if (parser3->issue(i)->cause()==libcellml::Issue::Cause::XML) { + if (parser3->issue(i)->cause() == libcellml::Issue::Cause::XML) { foundCause.at(8) = true; } } From ead4070fb8d2fde6e78c449098b09adf405af44c Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 19 Mar 2020 17:17:52 +1300 Subject: [PATCH 67/88] Removed commented code. --- src/validator.cpp | 22 ------ tests/validator/validator.cpp | 127 ---------------------------------- 2 files changed, 149 deletions(-) diff --git a/src/validator.cpp b/src/validator.cpp index b861140e2..08fb1e5b9 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -1080,28 +1080,6 @@ void Validator::ValidatorImpl::validateEquivalenceUnits(const ModelPtr &model, c err->setReferenceRule(Issue::ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); mValidator->addIssue(err); } - // TODO Removed until after PR 521 has been merged. - // } else if (multiplier != 0.0) { - // VariablePair reversePair = std::make_pair(equivalentVariable, variable); - // auto it = std::find(alreadyReported.begin(), alreadyReported.end(), reversePair); - // if (it == alreadyReported.end()) { - // VariablePair pair = std::make_pair(variable, equivalentVariable); - // ComponentPtr parent1 = std::dynamic_pointer_cast(variable->parent()); - // ComponentPtr parent2 = std::dynamic_pointer_cast(equivalentVariable->parent()); - // alreadyReported.push_back(pair); - // auto unitsName = variable->units() == nullptr ? "" : variable->units()->name(); - // auto equivalentUnitsName = equivalentVariable->units() == nullptr ? "" : equivalentVariable->units()->name(); - // IssuePtr err = Issue::create(); - // std::string des = "Variable '" + variable->name() + "' in component '" + parent1->name() + "' has units of '" + unitsName; - // des += "' and an equivalent variable '" + equivalentVariable->name() + "' in component '" + parent2->name(); - // des += "' has compatible but not equivalent units of '" + equivalentUnitsName + "'. The mismatch is: " + hints; - // err->setModel(model); - // err->setDescription(des); - // err->setCause(Issue::Cause::UNITS); - // err->setReferenceRule(Issue::ReferenceRule::MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION); - // err->setLevel(Issue::Level::WARNING); - // mValidator->addIssue(err); - // } } } } diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 4881a3a80..3efdad760 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -2059,41 +2059,6 @@ TEST(Validator, unitStandardUnitsWhichAreNotBaseUnits) EXPECT_EQ_ISSUES(expectedIssues, validator); } -// TODO Removed until after PR 521 has been merged -// TEST(Validator, unitMultiplierFactorDifference) -// { -// const std::vector expectedIssues = { -// "Variable 'v1' in component 'c1' has units of 'litre' and an equivalent variable 'v2' in component 'c2' has compatible but not equivalent units of 'big_barrel'. The mismatch is: multiplication factor of 10^-3.", -// }; -// libcellml::ValidatorPtr validator = libcellml::Validator::create(); -// libcellml::ModelPtr m = createModelTwoComponentsWithOneVariableEach("m", "c1", "c2", "v1", "v2"); -// auto c1 = m->component(0); -// auto c2 = m->component(1); -// auto v1 = c1->variable(0); -// auto v2 = c2->variable(0); - -// v1->setUnits("litre"); - -// libcellml::UnitsPtr u = libcellml::Units::create(); -// u->setName("big_barrel"); -// u->addUnit("metre", 3.0); -// m->addUnits(u); - -// v2->setUnits("big_barrel"); - -// libcellml::Variable::addEquivalence(v1, v2); // 1000L = 1m^3 - -// m->linkUnits(); - -// validator->validateModel(m); - -// EXPECT_EQ(size_t(1), validator->issueCount()); -// EXPECT_EQ(size_t(0), validator->errorCount()); -// EXPECT_EQ(size_t(1), validator->warningCount()); -// EXPECT_EQ(size_t(0), validator->hintCount()); -// EXPECT_EQ_ISSUES(expectedIssues, validator); -// } - TEST(Validator, unitSimpleCycle) { // Testing that indirect dependence is caught in the unit cycles. The network is: @@ -2298,56 +2263,6 @@ TEST(Validator, validateModelWithoutAndWithMath) EXPECT_EQ(size_t(0), validator->issueCount()); } -// TODO Removed until after PR 521 is merged. -// TEST(Validator, unitEquivalenceMultiplier) -// { -// const std::vector expectedIssues = { -// "Variable 'v1' in component 'comp1' has units of 'u1' and an equivalent variable 'v2' in component 'comp2' has compatible but not equivalent units of 'u2'. The mismatch is: multiplication factor of 10^1.", -// }; -// libcellml::ValidatorPtr validator = libcellml::Validator::create(); -// libcellml::ModelPtr m = libcellml::Model::create(); -// libcellml::ComponentPtr comp1 = libcellml::Component::create(); -// libcellml::ComponentPtr comp2 = libcellml::Component::create(); -// libcellml::VariablePtr v1 = libcellml::Variable::create(); -// libcellml::VariablePtr v2 = libcellml::Variable::create(); - -// v1->setName("v1"); -// v1->setInterfaceType("public"); -// v2->setName("v2"); -// v2->setInterfaceType("public"); -// m->setName("model"); -// comp1->setName("comp1"); -// comp2->setName("comp2"); -// comp1->addVariable(v1); -// comp2->addVariable(v2); -// m->addComponent(comp1); -// m->addComponent(comp2); - -// // u1 = 10*u2 -// libcellml::UnitsPtr u1 = libcellml::Units::create(); -// u1->setName("u1"); -// u1->addUnit("metre", 1, 1.0, 10.0); -// libcellml::UnitsPtr u2 = libcellml::Units::create(); -// u2->setName("u2"); -// u2->addUnit("metre", 1, 1.0, 1.0); - -// v1->setUnits(u1); -// v2->setUnits(u2); - -// m->addUnits(u1); -// m->addUnits(u2); - -// libcellml::Variable::addEquivalence(v1, v2); - -// validator->validateModel(m); - -// EXPECT_EQ(size_t(1), validator->issueCount()); -// EXPECT_EQ(size_t(0), validator->errorCount()); -// EXPECT_EQ(size_t(1), validator->warningCount()); -// EXPECT_EQ(size_t(0), validator->hintCount()); -// EXPECT_EQ_ISSUES(expectedIssues, validator); -// } - TEST(Validator, unfoundUnitsInEncapsulatedComponents) { const std::vector expectedIssues = { @@ -2383,48 +2298,6 @@ TEST(Validator, unfoundUnitsInEncapsulatedComponents) EXPECT_EQ_ISSUES(expectedIssues, v); } -// TODO Removed until after PR 521 is merged. -// TEST(Validator, mismatchedMultipliersInUnits) -// { -// const std::vector expectedIssues = { -// "Variable 'v1' in component 'Brobdingnag' has units of 'megametre' and an equivalent variable 'v2' in component 'Lilliput' has compatible but not equivalent units of 'millimetre'. The mismatch is: multiplication factor of 10^9.", -// }; -// auto model = libcellml::Model::create("Gulliver"); -// auto c1 = libcellml::Component::create("Brobdingnag"); -// auto c2 = libcellml::Component::create("Lilliput"); -// auto v1 = libcellml::Variable::create("v1"); -// auto v2 = libcellml::Variable::create("v2"); - -// auto u1 = libcellml::Units::create("megametre"); -// u1->addUnit("metre", "mega"); - -// auto u2 = libcellml::Units::create("millimetre"); -// u2->addUnit("metre", "milli"); - -// v1->setUnits(u1); -// v2->setUnits(u2); -// v1->setInterfaceType("public"); -// v2->setInterfaceType("public"); -// c1->addVariable(v1); -// c2->addVariable(v2); -// model->addComponent(c1); -// model->addComponent(c2); -// model->addUnits(u1); -// model->addUnits(u2); - -// libcellml::Variable::addEquivalence(v1, v2); - -// auto validator = libcellml::Validator::create(); -// validator->validateModel(model); - -// EXPECT_EQ(size_t(1), validator->issueCount()); -// EXPECT_EQ(size_t(0), validator->errorCount()); -// EXPECT_EQ(size_t(1), validator->warningCount()); -// EXPECT_EQ(size_t(0), validator->hintCount()); - -// EXPECT_EQ_ISSUES(expectedIssues, validator); -// } - TEST(Validator, variableEquivalenceValidNetwork) { libcellml::ModelPtr model = libcellml::Model::create(); From b4cf4714c9068c2d988a84e9f255de09e82753fe Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 19 Mar 2020 17:19:28 +1300 Subject: [PATCH 68/88] Validator: an issue is, by default, an error so no need to set its level to ERROR. --- src/validator.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/validator.cpp b/src/validator.cpp index 08fb1e5b9..be9f3abbf 100644 --- a/src/validator.cpp +++ b/src/validator.cpp @@ -1035,7 +1035,6 @@ void Validator::ValidatorImpl::validateVariableInterface(const VariablePtr &vari err->setDescription("The equivalence between '" + variable->name() + "' in component '" + componentName + "' and '" + equivalentVariable->name() + "' in component '" + equivalentComponentName + "' is invalid. Component '" + componentName + "' and '" + equivalentComponentName + "' are neither siblings nor in a parent/child relationship."); err->setVariable(variable); err->setCause(Issue::Cause::CONNECTION); - err->setLevel(Issue::Level::ERROR); mValidator->addIssue(err); } } @@ -1051,7 +1050,6 @@ void Validator::ValidatorImpl::validateVariableInterface(const VariablePtr &vari } err->setVariable(variable); err->setCause(Issue::Cause::CONNECTION); - err->setLevel(Issue::Level::ERROR); mValidator->addIssue(err); } } From f86457c1d419e556de57ea700b33a1f37bcd7575 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 19 Mar 2020 17:32:18 +1300 Subject: [PATCH 69/88] Some minor cleaning up. --- src/api/libcellml/issue.h | 2 +- src/api/libcellml/referencerules.h | 90 ------------------------------ 2 files changed, 1 insertion(+), 91 deletions(-) delete mode 100644 src/api/libcellml/referencerules.h diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index 300feaa01..df36fda71 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -123,7 +123,7 @@ class LIBCELLML_EXPORT Issue { ERROR, WARNING, - HINT, + HINT }; /** diff --git a/src/api/libcellml/referencerules.h b/src/api/libcellml/referencerules.h deleted file mode 100644 index 3f78a77ce..000000000 --- a/src/api/libcellml/referencerules.h +++ /dev/null @@ -1,90 +0,0 @@ -// /* -// 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. -// */ - -// #pragma once - -// namespace libcellml { - -// /** -// * @brief The ReferenceRule enum class. -// * -// * Enum describing the specification rules that are used -// * for validation. -// */ -// enum class ReferenceRule -// { -// UNDEFINED, -// // Specification errors. -// DATA_REPR_IDENTIFIER_UNICODE, -// DATA_REPR_IDENTIFIER_LATIN_ALPHANUM, -// DATA_REPR_IDENTIFIER_AT_LEAST_ONE_ALPHANUM, -// DATA_REPR_IDENTIFIER_BEGIN_EURO_NUM, -// DATA_REPR_IDENTIFIER_IDENTICAL, -// DATA_REPR_NNEG_INT_BASE10, -// DATA_REPR_NNEG_INT_EURO_NUM, -// MODEL_ELEMENT, -// MODEL_NAME, -// MODEL_CHILD, -// MODEL_MORE_THAN_ONE_ENCAPSULATION, -// IMPORT_HREF, -// IMPORT_CHILD, -// IMPORT_CIRCULAR, -// IMPORT_UNITS_NAME, -// IMPORT_UNITS_REF, -// IMPORT_COMPONENT_NAME, -// IMPORT_COMPONENT_REF, -// UNITS_NAME, -// UNITS_NAME_UNIQUE, -// UNITS_STANDARD, -// UNITS_CHILD, -// UNIT_UNITS_REF, -// UNIT_DIGRAPH, -// UNIT_CIRCULAR_REF, -// UNIT_OPTIONAL_ATTRIBUTE, -// UNIT_PREFIX, -// UNIT_MULTIPLIER, -// UNIT_EXPONENT, -// COMPONENT_NAME, -// COMPONENT_CHILD, -// VARIABLE_NAME, -// VARIABLE_UNITS, -// VARIABLE_INTERFACE, -// VARIABLE_INITIAL_VALUE, -// RESET_CHILD, -// RESET_ORDER, -// RESET_VARIABLE_REFERENCE, -// RESET_TEST_VARIABLE_REFERENCE, -// RESET_TEST_VALUE, -// RESET_RESET_VALUE, -// MATH_MATHML, -// MATH_CHILD, -// MATH_CI_VARIABLE_REFERENCE, -// MATH_CN_UNITS_ATTRIBUTE, -// ENCAPSULATION_COMPONENT_REF, -// COMPONENT_REF_COMPONENT_ATTRIBUTE, -// COMPONENT_REF_CHILD, -// COMPONENT_REF_ENCAPSULATION, -// CONNECTION_COMPONENT1, -// CONNECTION_COMPONENT2, -// CONNECTION_UNIQUE_TRANSITIVE, -// CONNECTION_MAP_VARIABLES, -// MAP_VARIABLES_VARIABLE1, -// MAP_VARIABLES_VARIABLE2, -// MAP_VARIABLES_UNIQUE, -// MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION -// }; - -// } // namespace libcellml From 7d24682d6474fc86bfbbced94220d7894bd5da42 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 19 Mar 2020 17:38:45 +1300 Subject: [PATCH 70/88] Reformat src/bindings/python/__init__.py. Done using PyCharm CE. --- src/bindings/python/__init__.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/bindings/python/__init__.py b/src/bindings/python/__init__.py index 8d4d052ce..12e2ae77c 100644 --- a/src/bindings/python/__init__.py +++ b/src/bindings/python/__init__.py @@ -9,11 +9,11 @@ import libcellml from libcellml.component import Component -from libcellml.issue import Issue from libcellml.generator import Generator from libcellml.generator import GeneratorVariable from libcellml.generatorprofile import GeneratorProfile from libcellml.importsource import ImportSource +from libcellml.issue import Issue from libcellml.model import Model from libcellml.parser import Parser from libcellml.printer import Printer @@ -23,6 +23,7 @@ from libcellml.variable import Variable from libcellml.version import version, versionString + # Convert enumerations generated by SWIG @@ -31,6 +32,7 @@ def convert(base, enum, variables, new_base=None): class Object: pass + obj = Object() for var in variables: if hasattr(base, enum + '_' + var): @@ -193,4 +195,4 @@ class Object: 'MAP_VARIABLES_UNIQUE', 'MAP_VARIABLES_IDENTICAL_UNIT_REDUCTION', ]) -del(convert, libcellml) +del (convert, libcellml) From 346843fcc4d97c7950638c978005b16b3add2f61 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 19 Mar 2020 17:47:35 +1300 Subject: [PATCH 71/88] Slight update to our types interface. --- src/bindings/interface/types.i | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/bindings/interface/types.i b/src/bindings/interface/types.i index 4472c4152..f259886b5 100644 --- a/src/bindings/interface/types.i +++ b/src/bindings/interface/types.i @@ -85,12 +85,12 @@ Only meant to be included, shouldn't be passed to cmake as a module! } } -%typemap(in) libcellml::ReferenceRule (int val, int ecode) { +%typemap(in) libcellml::Issue::ReferenceRule (int val, int ecode) { ecode = SWIG_AsVal(int)($input, &val); if (!SWIG_IsOK(ecode)) { %argument_fail(ecode, "$type", $symname, $argnum); } else { - if (val < %static_cast(libcellml::ReferenceRule::UNDEFINED, int) || %static_cast(libcellml::ReferenceRule::MAP_VARIABLES_VARIABLE2, int) < val) { + if (val < %static_cast(libcellml::Issue::ReferenceRule::UNDEFINED, int) || %static_cast(libcellml::Issue::ReferenceRule::MAP_VARIABLES_VARIABLE2, int) < val) { %argument_fail(ecode, "$type is not a valid value for the enumeration.", $symname, $argnum); } $1 = %static_cast(val,$basetype); From 849b64e22726f0b4fc3d130b7784c394d5b27e4d Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 19 Mar 2020 18:49:26 +1300 Subject: [PATCH 72/88] Issue: use reference rule rather than just rule. --- src/api/libcellml/issue.h | 10 +++++----- src/issue.cpp | 8 ++++---- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index df36fda71..ff4ae6453 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -255,18 +255,18 @@ class LIBCELLML_EXPORT Issue /** * @brief Set the @c enum ReferenceRule of this issue. * - * Set the @p rule of this issue from the options available in + * Set the @p referenceRule of this issue from the options available in * the @c ReferenceRule @c enum. * - * @param rule The @c ReferenceRule to set. + * @param referenceRule The @c ReferenceRule to set. */ - void setReferenceRule(ReferenceRule rule); + void setReferenceRule(ReferenceRule referenceRule); /** * @brief Get the @c enum ReferenceRule of this issue. * - * Get the @c enum @c ReferenceRule value @p rule of this issue. If - * no rule has been set for this issue, will return ReferenceRule::UNDEFINED. + * Get the @c enum @c ReferenceRule value of this issue. If no reference + * rule has been set for this issue, return ReferenceRule::UNDEFINED. * * @return The @c ReferenceRule for this issue. */ diff --git a/src/issue.cpp b/src/issue.cpp index ef01bc4c6..163556f18 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -34,7 +34,7 @@ struct Issue::IssueImpl std::string mDescription; /**< The string description for why this issue was raised. */ Issue::Cause mCause = Issue::Cause::UNDEFINED; /**< The Issue::Cause enum value for this issue. */ Issue::Level mLevel = Issue::Level::ERROR; /**< The Issue::Level enum value for this issue. */ - Issue::ReferenceRule mRule = Issue::ReferenceRule::UNDEFINED; /**< The Issue::ReferenceRule enum value for this issue. */ + Issue::ReferenceRule mReferenceRule = Issue::ReferenceRule::UNDEFINED; /**< The Issue::ReferenceRule enum value for this issue. */ ComponentPtr mComponent; /**< Pointer to the component that the issue occurred in. */ ImportSourcePtr mImportSource; /**< Pointer to the import source that the issue occurred in. */ ModelPtr mModel; /**< Pointer to the model that the issue occurred in. */ @@ -160,14 +160,14 @@ Issue::Level Issue::level() const return mPimpl->mLevel; } -void Issue::setReferenceRule(Issue::ReferenceRule rule) +void Issue::setReferenceRule(Issue::ReferenceRule referenceRule) { - mPimpl->mRule = rule; + mPimpl->mReferenceRule = referenceRule; } Issue::ReferenceRule Issue::referenceRule() const { - return mPimpl->mRule; + return mPimpl->mReferenceRule; } // TODO Removed until the BASE_ISSUE_URL is finalised and ready. From 9ff91db216e92574ad0bed63c38653b1b0ceb244 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 19 Mar 2020 19:00:30 +1300 Subject: [PATCH 73/88] Logger: removed an unnecessary test. --- src/logger.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/logger.cpp b/src/logger.cpp index 2650db2c1..b5afe6531 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -56,7 +56,7 @@ size_t Logger::errorCount() const IssuePtr Logger::error(size_t index) const { IssuePtr issue = nullptr; - if ((index < mPimpl->mErrors.size()) && (mPimpl->mErrors.at(index) < mPimpl->mIssues.size())) { + if (index < mPimpl->mErrors.size()) { issue = mPimpl->mIssues.at(mPimpl->mErrors.at(index)); } return issue; From 321226cf47dea4780ef8328d055ae4ef4c21e56a Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Thu, 19 Mar 2020 19:40:31 +1300 Subject: [PATCH 74/88] Removed commented out code. --- tests/validator/validator.cpp | 81 ----------------------------------- 1 file changed, 81 deletions(-) diff --git a/tests/validator/validator.cpp b/tests/validator/validator.cpp index 3efdad760..0316fd34f 100644 --- a/tests/validator/validator.cpp +++ b/tests/validator/validator.cpp @@ -1866,87 +1866,6 @@ TEST(Validator, unitEquivalenceComplicatedNestedUnits) EXPECT_EQ_ISSUES(expectedIssues, validator); } -// TODO Removed until after PR521 has been merged. -// TEST(Validator, unitEquivalenceExponentMultiplierPrefixExponent) -// { -// // This test is intended to demonstrate that the effect of different multiplicator sources (prefix, multiplier term) -// // does not affect the equivalence of the underlying base variables. -// const std::vector expectedIssues = { -// "Variable 'v1' in component 'component1' has units of 'u4' and an equivalent variable 'v2' in component 'component2' has compatible but not equivalent units of 'u5'. The mismatch is: multiplication factor of 10^12.", -// }; - -// libcellml::ValidatorPtr validator = libcellml::Validator::create(); -// libcellml::ModelPtr model = libcellml::Model::create(); - -// libcellml::ComponentPtr comp1 = libcellml::Component::create(); -// libcellml::ComponentPtr comp2 = libcellml::Component::create(); - -// libcellml::VariablePtr v1 = libcellml::Variable::create(); -// libcellml::VariablePtr v2 = libcellml::Variable::create(); - -// v1->setName("v1"); -// v1->setInterfaceType("public"); -// v2->setName("v2"); -// v2->setInterfaceType("public"); - -// // millimetres -// libcellml::UnitsPtr u1 = libcellml::Units::create(); -// u1->setName("u1"); -// u1->addUnit("metre", "milli"); // standard, prefix. - -// // mm^3 -// libcellml::UnitsPtr u2 = libcellml::Units::create(); -// u2->setName("u2"); -// u2->addUnit("u1", 3.0); // standard, exponent. - -// // mm^6 -// libcellml::UnitsPtr u3 = libcellml::Units::create(); -// u3->setName("u3"); -// u3->addUnit("u2", 2.0); // standard, exponent. - -// // m^6 -// libcellml::UnitsPtr u4 = libcellml::Units::create(); -// u4->setName("u4"); -// u4->addUnit("u3", 15, 1.0); // standard, prefix, exponent. - -// libcellml::UnitsPtr u5 = libcellml::Units::create(); -// u5->setName("u5"); -// u5->addUnit("metre", 6.0); // standard, exponent. - -// // u4 ~= u5: Units will be equivalent, testing that prefix, multiplier, and exponent validation is correct. -// // Note: there is a factor of 1000 between u4 and u5 since u4 = 10^15*u3 (rather than 10^18*u3), which is -// // fine since we only need units to be equivalent for validation. -// // TODO: see issue in specification: https://github.com/cellml/cellml-specification/issues/19. -// v1->setUnits(u4); -// v2->setUnits(u5); - -// comp1->setName("component1"); -// comp1->addVariable(v1); - -// comp2->setName("component2"); -// comp2->addVariable(v2); - -// model->setName("model"); -// model->addComponent(comp1); -// model->addComponent(comp2); - -// model->addUnits(u1); -// model->addUnits(u2); -// model->addUnits(u3); -// model->addUnits(u4); -// model->addUnits(u5); - -// libcellml::Variable::addEquivalence(v1, v2); - -// validator->validateModel(model); - -// EXPECT_EQ(size_t(1), validator->issueCount()); -// EXPECT_EQ(size_t(0), validator->errorCount()); -// EXPECT_EQ(size_t(0), validator->hintCount()); -// EXPECT_EQ(size_t(1), validator->warningCount()); -// EXPECT_EQ_ISSUES(expectedIssues, validator); -// } - TEST(Validator, unitUserCreatedUnitsBananasAndApples) { const std::vector expectedIssues = { From c96cc7cdaae7206b6aec992fb2187025611082e0 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 14:27:49 +1300 Subject: [PATCH 75/88] Delete unnecessray `default.profraw` file. --- default.profraw | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 default.profraw diff --git a/default.profraw b/default.profraw deleted file mode 100644 index e69de29bb..000000000 From d740772fe280751e82aeab9ef65613077931b2cc Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 14:37:11 +1300 Subject: [PATCH 76/88] Units: reordering headers. --- src/issue.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/issue.cpp b/src/issue.cpp index 163556f18..946f398d5 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -15,13 +15,14 @@ limitations under the License. */ #include "libcellml/issue.h" -#include "libcellml/types.h" - -#include "utilities.h" #include #include +#include "libcellml/types.h" + +#include "utilities.h" + namespace libcellml { /** From cc601571ec6f2530f5a4fb37d1d9df6a1d2f46c4 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 14:37:44 +1300 Subject: [PATCH 77/88] Removed TODO. --- src/issue.cpp | 8 -------- 1 file changed, 8 deletions(-) diff --git a/src/issue.cpp b/src/issue.cpp index 946f398d5..b0d0e9aa1 100644 --- a/src/issue.cpp +++ b/src/issue.cpp @@ -171,14 +171,6 @@ Issue::ReferenceRule Issue::referenceRule() const return mPimpl->mReferenceRule; } -// TODO Removed until the BASE_ISSUE_URL is finalised and ready. -// std::string Issue::url() const -// { -// // Construct from the default address formula: BASE_ISSUE_URL + rule number. -// // TODO check that this is appropriate for however we need to handle them. -// return BASE_ISSUE_URL + referenceHeading(); -// } - void Issue::setComponent(const ComponentPtr &component) { mPimpl->mComponent = component; From 650f52a7a4b3cc2ff00d9c2ac8e5cc0d47fca865 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 14:38:31 +1300 Subject: [PATCH 78/88] Logger: reordered headers. --- src/logger.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/logger.cpp b/src/logger.cpp index b5afe6531..b55921764 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -14,13 +14,14 @@ See the License for the specific language governing permissions and limitations under the License. */ -#include "libcellml/component.h" #include "libcellml/logger.h" -#include "libcellml/types.h" #include #include +#include "libcellml/component.h" +#include "libcellml/types.h" + namespace libcellml { /** From 96660ef807e7f59809117dcd4790fc7a05bed527 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 14:39:37 +1300 Subject: [PATCH 79/88] Parser test: some minor cleaning up. --- tests/parser/parser.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/parser/parser.cpp b/tests/parser/parser.cpp index 903e5cf4f..5a582b75c 100644 --- a/tests/parser/parser.cpp +++ b/tests/parser/parser.cpp @@ -111,14 +111,14 @@ TEST(Parser, emptyModelString) TEST(Parser, nonXmlString) { - const std::string ex = "Not an xml string."; + const std::string in = "Not an xml string."; const std::vector expectedIssues = { "LibXml2 error: Start tag expected, '<' not found.", "Could not get a valid XML root node from the provided input.", }; libcellml::ParserPtr p = libcellml::Parser::create(); - p->parseModel(ex); + p->parseModel(in); EXPECT_EQ_ISSUES(expectedIssues, p); } From a1417d11bd3fe7b57ed77157d710e2e9e25d95b4 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 14:40:54 +1300 Subject: [PATCH 80/88] Parser: removed some TODOs. --- src/parser.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/parser.cpp b/src/parser.cpp index 8f825a312..5ab84b125 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -1318,7 +1318,6 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co const std::string variableReference = attribute->value(); VariablePtr referencedVariable = component->variable(variableReference); - // TODO This follows the same pattern as the issues returned from parsing the encapsulations. if (referencedVariable == nullptr) { IssuePtr issue = Issue::create(); issue->setDescription("Reset referencing variable '" + variableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); @@ -1332,7 +1331,6 @@ void Parser::ParserImpl::loadReset(const ResetPtr &reset, const ComponentPtr &co const std::string testVariableReference = attribute->value(); VariablePtr testVariable = component->variable(testVariableReference); if (testVariable == nullptr) { - // TODO This follows the same pattern as the issues returned from parsing the encapsulations. IssuePtr issue = Issue::create(); issue->setDescription("Reset referencing test_variable '" + testVariableReference + "' is not a valid reference for a variable in component '" + component->name() + "'."); issue->setReset(reset); From 52bd9d2fcdec15eee371c73026ca02dfc47f86a3 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 14:41:37 +1300 Subject: [PATCH 81/88] Issue test: removed TODO. --- tests/issue/issue.cpp | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/tests/issue/issue.cpp b/tests/issue/issue.cpp index bc25c8f33..7e3c70daf 100644 --- a/tests/issue/issue.cpp +++ b/tests/issue/issue.cpp @@ -480,14 +480,3 @@ TEST(Issue, isHint) e->setLevel(libcellml::Issue::Level::HINT); EXPECT_EQ(e->level(), libcellml::Issue::Level::HINT); } - -// TODO Remove this test until the base URL for the CellML2.0 specification exists and the spec is finalised. -// TEST(Issue, getDefaultUrl) -// { -// auto e = libcellml::Issue::create(); -// e->setReferenceRule(libcellml::Issue::ReferenceRule::MODEL_NAME); -// auto ref = e->referenceHeading(); -// // TODO How to get this from the utilties.h file?? Won't be this address in the long run. -// std::string url = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q=" + ref; -// EXPECT_EQ(e->url(), url); -// } From 39a15162402639d170c92399a13a2ec168b70d40 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 14:46:11 +1300 Subject: [PATCH 82/88] Logger: removed unnecessary tests. --- src/logger.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/logger.cpp b/src/logger.cpp index b55921764..2f2171825 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -71,7 +71,7 @@ size_t Logger::warningCount() const IssuePtr Logger::warning(size_t index) const { IssuePtr issue = nullptr; - if ((index < mPimpl->mWarnings.size()) && (mPimpl->mWarnings.at(index) < mPimpl->mIssues.size())) { + if (index < mPimpl->mWarnings.size()) { issue = mPimpl->mIssues.at(mPimpl->mWarnings.at(index)); } return issue; @@ -85,7 +85,7 @@ size_t Logger::hintCount() const IssuePtr Logger::hint(size_t index) const { IssuePtr issue = nullptr; - if ((index < mPimpl->mHints.size()) && (mPimpl->mHints.at(index) < mPimpl->mIssues.size())) { + if (index < mPimpl->mHints.size()) { issue = mPimpl->mIssues.at(mPimpl->mHints.at(index)); } return issue; From 9f6b2f8a5442fbcd0f0545343b4b72a5bb081091 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 14:48:13 +1300 Subject: [PATCH 83/88] Utilities: removed (currently) unneeded constant. --- src/utilities.h | 7 ------- 1 file changed, 7 deletions(-) diff --git a/src/utilities.h b/src/utilities.h index 3d4cfd3dd..21ae04390 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -29,13 +29,6 @@ limitations under the License. namespace libcellml { -/** - * Base URL from which the user guidelines used in the Issue class can be derived. - * Adding the issue's rule number to the end will search the documentation for that section. - * KRM This is clumsy and should be given a static address via formal bookmarks, but will do for proof of concept. - */ -const std::string BASE_ISSUE_URL = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q="; - /** * Vector of base units. */ From 3291b2474beccd08fe46b9706e729c8be09a931f Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 15:13:24 +1300 Subject: [PATCH 84/88] Reordered some headers. --- src/api/libcellml/entity.h | 4 ++-- src/api/libcellml/generator.h | 4 ++-- src/api/libcellml/importedentity.h | 4 ++-- src/api/libcellml/issue.h | 4 ++-- src/api/libcellml/logger.h | 6 +++--- src/api/libcellml/model.h | 12 ++++++------ src/api/libcellml/namedentity.h | 4 ++-- src/api/libcellml/parser.h | 4 ++-- src/api/libcellml/printer.h | 4 ++-- src/api/libcellml/reset.h | 4 ++-- src/api/libcellml/units.h | 6 +++--- src/api/libcellml/validator.h | 6 +++--- src/api/libcellml/variable.h | 4 ++-- src/api/libcellml/version.h | 4 ++-- src/importsource.cpp | 1 + src/namedentity.cpp | 3 ++- src/units.cpp | 5 +++-- src/version.cpp | 4 ++-- 18 files changed, 43 insertions(+), 40 deletions(-) diff --git a/src/api/libcellml/entity.h b/src/api/libcellml/entity.h index cf911b5b6..9002f0c69 100644 --- a/src/api/libcellml/entity.h +++ b/src/api/libcellml/entity.h @@ -16,11 +16,11 @@ limitations under the License. #pragma once +#include + #include "libcellml/exportdefinitions.h" #include "libcellml/types.h" -#include - namespace libcellml { /** diff --git a/src/api/libcellml/generator.h b/src/api/libcellml/generator.h index a25cb4769..a00171256 100644 --- a/src/api/libcellml/generator.h +++ b/src/api/libcellml/generator.h @@ -16,10 +16,10 @@ limitations under the License. #pragma once -#include "libcellml/logger.h" - #include +#include "libcellml/logger.h" + namespace libcellml { class Generator; diff --git a/src/api/libcellml/importedentity.h b/src/api/libcellml/importedentity.h index 105a708ea..54819b8e5 100644 --- a/src/api/libcellml/importedentity.h +++ b/src/api/libcellml/importedentity.h @@ -16,12 +16,12 @@ limitations under the License. #pragma once +#include + #include "libcellml/exportdefinitions.h" #include "libcellml/namedentity.h" #include "libcellml/types.h" -#include - namespace libcellml { /** diff --git a/src/api/libcellml/issue.h b/src/api/libcellml/issue.h index ff4ae6453..03d66ebbf 100644 --- a/src/api/libcellml/issue.h +++ b/src/api/libcellml/issue.h @@ -16,11 +16,11 @@ limitations under the License. #pragma once +#include + #include "libcellml/exportdefinitions.h" #include "libcellml/types.h" -#include - namespace libcellml { /** diff --git a/src/api/libcellml/logger.h b/src/api/libcellml/logger.h index 9c2bd2663..5debc508b 100644 --- a/src/api/libcellml/logger.h +++ b/src/api/libcellml/logger.h @@ -16,13 +16,13 @@ limitations under the License. #pragma once +#include +#include + #include "libcellml/exportdefinitions.h" #include "libcellml/issue.h" #include "libcellml/types.h" -#include -#include - namespace libcellml { /** diff --git a/src/api/libcellml/model.h b/src/api/libcellml/model.h index b84a20c89..5b5b2e782 100644 --- a/src/api/libcellml/model.h +++ b/src/api/libcellml/model.h @@ -16,11 +16,11 @@ limitations under the License. #pragma once +#include + #include "libcellml/componententity.h" #include "libcellml/exportdefinitions.h" -#include - #ifndef SWIG template class LIBCELLML_EXPORT std::weak_ptr; #endif @@ -259,14 +259,14 @@ class LIBCELLML_EXPORT Model: public ComponentEntity * linked to @c Units added to the model. This method will link * variable units specified by name to units in the model * (if they are found). Any variable units that cannot be linked - * to units in the model are left in an unlinked state. This means it - * is possible to still have unlinked @c Units in the model after + * to units in the model are left in an unlinked state. This means it + * is possible to still have unlinked @c Units in the model after * calling this method. * * Unlinked variable units can occur when a @c Variable's units are - * set by name. If the @c Model to which the @c Variable belongs + * set by name. If the @c Model to which the @c Variable belongs * has @c Units defined with the same name, then that @c Variable's - * @c Units will not be linked to the @c Model's @c Units. This + * @c Units will not be linked to the @c Model's @c Units. This * method will link the two units (the one from the variable and the * one from the model). * diff --git a/src/api/libcellml/namedentity.h b/src/api/libcellml/namedentity.h index ac56b4a1e..b0e0f2c08 100644 --- a/src/api/libcellml/namedentity.h +++ b/src/api/libcellml/namedentity.h @@ -16,12 +16,12 @@ limitations under the License. #pragma once +#include + #include "libcellml/entity.h" #include "libcellml/exportdefinitions.h" #include "libcellml/types.h" -#include - namespace libcellml { /** diff --git a/src/api/libcellml/parser.h b/src/api/libcellml/parser.h index 5c19f3368..3b6fb151c 100644 --- a/src/api/libcellml/parser.h +++ b/src/api/libcellml/parser.h @@ -16,13 +16,13 @@ limitations under the License. #pragma once +#include + #include "libcellml/logger.h" #include "libcellml/model.h" #include "libcellml/types.h" #include "libcellml/units.h" -#include - namespace libcellml { /** diff --git a/src/api/libcellml/printer.h b/src/api/libcellml/printer.h index 47ad4e386..808454e5f 100644 --- a/src/api/libcellml/printer.h +++ b/src/api/libcellml/printer.h @@ -16,11 +16,11 @@ limitations under the License. #pragma once +#include + #include "libcellml/logger.h" #include "libcellml/types.h" -#include - namespace libcellml { /** diff --git a/src/api/libcellml/reset.h b/src/api/libcellml/reset.h index 5f10e1121..05c3c265f 100644 --- a/src/api/libcellml/reset.h +++ b/src/api/libcellml/reset.h @@ -16,12 +16,12 @@ limitations under the License. #pragma once +#include + #include "libcellml/entity.h" #include "libcellml/exportdefinitions.h" #include "libcellml/types.h" -#include - namespace libcellml { /** diff --git a/src/api/libcellml/units.h b/src/api/libcellml/units.h index f84391a36..d74d9ae26 100644 --- a/src/api/libcellml/units.h +++ b/src/api/libcellml/units.h @@ -16,13 +16,13 @@ limitations under the License. #pragma once +#include +#include + #include "libcellml/exportdefinitions.h" #include "libcellml/importedentity.h" #include "libcellml/types.h" -#include -#include - // MSVC (and some other compilers?) may define PASCAL as __stdcall, resulting in // some compilation errors for our StandardUnit enum class below. However, that // macro gets defined for backward compatibility, so we can safely undefine it. diff --git a/src/api/libcellml/validator.h b/src/api/libcellml/validator.h index fc9edab31..9e7c73b15 100644 --- a/src/api/libcellml/validator.h +++ b/src/api/libcellml/validator.h @@ -16,12 +16,12 @@ limitations under the License. #pragma once -#include "libcellml/logger.h" -#include "libcellml/types.h" - #include #include +#include "libcellml/logger.h" +#include "libcellml/types.h" + namespace libcellml { /** diff --git a/src/api/libcellml/variable.h b/src/api/libcellml/variable.h index 781090913..17daeb10a 100644 --- a/src/api/libcellml/variable.h +++ b/src/api/libcellml/variable.h @@ -16,12 +16,12 @@ limitations under the License. #pragma once +#include + #include "libcellml/exportdefinitions.h" #include "libcellml/namedentity.h" #include "libcellml/types.h" -#include - #ifndef SWIG template class LIBCELLML_EXPORT std::weak_ptr; #endif diff --git a/src/api/libcellml/version.h b/src/api/libcellml/version.h index eec33563e..b122c6904 100644 --- a/src/api/libcellml/version.h +++ b/src/api/libcellml/version.h @@ -16,10 +16,10 @@ limitations under the License. #pragma once -#include "libcellml/exportdefinitions.h" - #include +#include "libcellml/exportdefinitions.h" + namespace libcellml { /** diff --git a/src/importsource.cpp b/src/importsource.cpp index 0790f2395..16d7c370c 100644 --- a/src/importsource.cpp +++ b/src/importsource.cpp @@ -15,6 +15,7 @@ limitations under the License. */ #include "libcellml/importsource.h" + #include "libcellml/model.h" namespace libcellml { diff --git a/src/namedentity.cpp b/src/namedentity.cpp index 4c8dbaed2..6d5c77f4d 100644 --- a/src/namedentity.cpp +++ b/src/namedentity.cpp @@ -14,9 +14,10 @@ See the License for the specific language governing permissions and limitations under the License. */ +#include "libcellml/namedentity.h" + #include "libcellml/component.h" #include "libcellml/componententity.h" -#include "libcellml/namedentity.h" namespace libcellml { diff --git a/src/units.cpp b/src/units.cpp index d7f13bcb1..0a3390999 100644 --- a/src/units.cpp +++ b/src/units.cpp @@ -14,11 +14,10 @@ See the License for the specific language governing permissions and limitations under the License. */ -#include "utilities.h" +#include "libcellml/units.h" #include "libcellml/importsource.h" #include "libcellml/model.h" -#include "libcellml/units.h" #include #include @@ -28,6 +27,8 @@ limitations under the License. #include #include +#include "utilities.h" + namespace libcellml { /** diff --git a/src/version.cpp b/src/version.cpp index bdcd49681..9836c407c 100644 --- a/src/version.cpp +++ b/src/version.cpp @@ -14,12 +14,12 @@ See the License for the specific language governing permissions and limitations under the License. */ -#include "versionconfig.h" - #include "libcellml/version.h" #include +#include "versionconfig.h" + namespace libcellml { unsigned int version() From c846a418a5153f17c380c02367aaad1ad9c1ec70 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 15:13:49 +1300 Subject: [PATCH 85/88] Revert "Utilities: removed (currently) unneeded constant." This reverts commit 9f6b2f8a5442fbcd0f0545343b4b72a5bb081091. --- src/utilities.h | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/utilities.h b/src/utilities.h index 21ae04390..3d4cfd3dd 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -29,6 +29,13 @@ limitations under the License. namespace libcellml { +/** + * Base URL from which the user guidelines used in the Issue class can be derived. + * Adding the issue's rule number to the end will search the documentation for that section. + * KRM This is clumsy and should be given a static address via formal bookmarks, but will do for proof of concept. + */ +const std::string BASE_ISSUE_URL = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q="; + /** * Vector of base units. */ From 361ed11eaef3495b3862e7c8ba3d1b59092b8ffd Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 15:35:27 +1300 Subject: [PATCH 86/88] Utilities: updated the BASE_ISSUE_URL constant. --- src/utilities.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/utilities.h b/src/utilities.h index 3d4cfd3dd..572ddf43f 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -34,7 +34,7 @@ namespace libcellml { * Adding the issue's rule number to the end will search the documentation for that section. * KRM This is clumsy and should be given a static address via formal bookmarks, but will do for proof of concept. */ -const std::string BASE_ISSUE_URL = "https://libcellml-tutorials.readthedocs.io/en/pr344_documentation/search.html?q="; +const std::string BASE_ISSUE_URL = "https://libcellml.org/reference/cellml2.0/search.html?q="; /** * Vector of base units. From 5f478db0a2425bca07b7d594ae2e2ad2f7013643 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 15:42:12 +1300 Subject: [PATCH 87/88] Validator API: slight update to the documentation. --- src/api/libcellml/validator.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/api/libcellml/validator.h b/src/api/libcellml/validator.h index 9e7c73b15..80a96c21e 100644 --- a/src/api/libcellml/validator.h +++ b/src/api/libcellml/validator.h @@ -53,7 +53,7 @@ class LIBCELLML_EXPORT Validator: public Logger * @brief Validate the @p model using the CellML 2.0 Specification. * * Validate the given @p model and its encapsulated entities using the - * CellML 2.0 Specification. Any issues will be logged in the @c Validator. + * CellML 2.0 Specification. Any errors will be logged in the @c Validator. * * @param model The model to validate. */ From d4f4b99f9faa2bced568970048496d326dc1bb7f Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Tue, 24 Mar 2020 16:44:50 +1300 Subject: [PATCH 88/88] Utilities: removed (currently) unneeded constant. --- src/utilities.h | 7 ------- 1 file changed, 7 deletions(-) diff --git a/src/utilities.h b/src/utilities.h index 572ddf43f..21ae04390 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -29,13 +29,6 @@ limitations under the License. namespace libcellml { -/** - * Base URL from which the user guidelines used in the Issue class can be derived. - * Adding the issue's rule number to the end will search the documentation for that section. - * KRM This is clumsy and should be given a static address via formal bookmarks, but will do for proof of concept. - */ -const std::string BASE_ISSUE_URL = "https://libcellml.org/reference/cellml2.0/search.html?q="; - /** * Vector of base units. */