assert_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 <detail::exception_type Exception, std::invocable Function>
void assert_throw(
    Function&& function,
    std::string_view expected_message,
    std::string_view reason = {},
    std::optional<std::source_location> location = KAYCXX_ASSERT_DEFAULT_SOURCE
) {
    auto expected_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 == expected_message) {
            return;
        }
 
        auto actual_string = detail::to_string(actual_message);
        auto expected_string = detail::to_string(expected_message);
        auto message = std::format(
            "Expected exception message <{}> but caught <{}>",
            expected_string,
            actual_string
        );
        throw assertion_error(message, reason, std::move(actual_string), std::move(expected_string), location);
    } catch (std::exception const& exception) {
        auto actual_string = detail::exception_type_name(exception);
        auto message = std::format(
            "Expected function to throw exception of type <{}> but caught <{}>",
            expected_type,
            actual_string
        );
        throw assertion_error(message, reason, std::move(actual_string), std::move(expected_type), location);
    } catch (...) {
        auto message = std::format(
            "Expected function to throw exception of type <{}> but caught <unknown exception>",
            expected_type
        );
        throw assertion_error(message, reason, "unknown exception", std::move(expected_type), location);
    }
 
    auto expected_string = detail::to_string(expected_message);
    auto message = std::format(
        "Expected function to throw exception of type <{}> with message <{}>",
        expected_type,
        expected_string
    );
    throw assertion_error(message, reason, "no exception", std::move(expected_string), location);
}
 
template <detail::exception_type Exception, std::invocable Function>
void assert_throw(
    Function&& function,
    std::regex const& expected_message,
    std::string_view reason = {},
    std::optional<std::source_location> location = KAYCXX_ASSERT_DEFAULT_SOURCE
) {
    auto expected_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(), expected_message)) {
            return;
        }
 
        auto actual_string = detail::to_string(actual_message);
        auto message = std::format("Expected exception message to match regex but caught <{}>", actual_string);
        throw assertion_error(message, reason, std::move(actual_string), "regex", location);
    } catch (std::exception const& exception) {
        auto actual_string = detail::exception_type_name(exception);
        auto message = std::format(
            "Expected function to throw exception of type <{}> but caught <{}>",
            expected_type,
            actual_string
        );
        throw assertion_error(message, reason, std::move(actual_string), std::move(expected_type), location);
    } catch (...) {
        auto message = std::format(
            "Expected function to throw exception of type <{}> but caught <unknown exception>",
            expected_type
        );
        throw assertion_error(message, reason, "unknown exception", std::move(expected_type), location);
    }
 
    auto message = std::format(
        "Expected function to throw exception of type <{}> with message matching regex",
        expected_type
    );
    throw assertion_error(message, reason, "no exception", "regex", location);
}
 
} // namespace kaycxx::assert