assert_not_throw.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Klaus Reimer <k@ailis.de>
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <concepts>
#include <exception>
#include <format>
#include <functional>
#include <regex>
#include <string_view>
#include <utility>
 
#include <kaycxx/assert/assertion_error.hpp>
#include <kaycxx/assert/detail/source_location.hpp>
#include <kaycxx/assert/detail/exception_type.hpp>
#include <kaycxx/assert/detail/exception_type_name.hpp>
#include <kaycxx/assert/detail/to_string.hpp>
 
namespace kaycxx::assert {
 
template <std::invocable Function>
void assert_not_throw(
    Function&& function,
    std::string_view reason = {},
    std::optional<std::source_location> location = KAYCXX_ASSERT_DEFAULT_SOURCE
) {
    try {
        std::invoke(std::forward<Function>(function));
    } catch (std::exception const& exception) {
        auto actual_string = std::format(
            "exception of type <{}> with message <{}>",
            detail::exception_type_name(exception),
            detail::to_string(exception.what())
        );
        auto message = std::format("Expected function not to throw but caught {}", actual_string);
        throw assertion_error(message, reason, std::move(actual_string), "no exception", location);
    } catch (...) {
        throw assertion_error(
            "Expected function not to throw but caught <unknown exception>",
            reason,
            "unknown exception",
            "no exception",
            location
        );
    }
}
 
template <detail::exception_type Exception, std::invocable Function>
void assert_not_throw(
    Function&& function,
    std::string_view unexpected_message,
    std::string_view reason = {},
    std::optional<std::source_location> location = KAYCXX_ASSERT_DEFAULT_SOURCE
) {
    auto unexpected_type = detail::exception_type_name<Exception>();
 
    try {
        std::invoke(std::forward<Function>(function));
    } catch (Exception const& exception) {
        auto actual_message = std::string_view(exception.what());
        if (actual_message == unexpected_message) {
            auto expected_string = detail::to_string(unexpected_message);
            auto actual_string = std::format(
                "exception of type <{}> with message <{}>",
                unexpected_type,
                expected_string
            );
            auto message = std::format("Expected function not to throw {}", actual_string);
            throw assertion_error(message, reason, std::move(actual_string), std::move(expected_string), location);
        }
    } catch (...) {
        // Other exceptions do not match this assertion and are intentionally allowed.
    }
}
 
template <detail::exception_type Exception, std::invocable Function>
void assert_not_throw(
    Function&& function,
    std::regex const& unexpected_message,
    std::string_view reason = {},
    std::optional<std::source_location> location = KAYCXX_ASSERT_DEFAULT_SOURCE
) {
    auto unexpected_type = detail::exception_type_name<Exception>();
 
    try {
        std::invoke(std::forward<Function>(function));
    } catch (Exception const& exception) {
        auto actual_message = std::string_view(exception.what());
        if (std::regex_match(actual_message.begin(), actual_message.end(), unexpected_message)) {
            auto actual_string = std::format(
                "exception of type <{}> with message matching regex",
                unexpected_type
            );
            auto message = std::format("Expected function not to throw {}", actual_string);
            throw assertion_error(message, reason, std::move(actual_string), "regex", location);
        }
    } catch (...) {
        // Other exceptions do not match this assertion and are intentionally allowed.
    }
}
 
} // namespace kaycxx::assert