//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef TEST_SUPPORT_ASSERT_MACROS_H
#define TEST_SUPPORT_ASSERT_MACROS_H

// Contains a set of validation macros.
//
// Note these test were added after C++20 was well supported by the compilers
// used. To make the implementation simple the macros require C++20 or newer.
// It's not expected that existing tests start to use these new macros.
//
// These macros are an alternative to using assert. The differences are:
// - The assert message isn't localized.
// - It's possible to log additional information. This is useful when the
//   function asserting is a helper function. In these cases the assertion
//   failure contains to little information to find the issue. For example, in
//   the format functions, the really useful information is the actual output,
//   the expected output, and the format string used. These macros allow
//   logging additional arguments.

#include "test_macros.h"

#include <cstdio>
#include <cstdlib>

// This function prints the given arguments to standard error.
//
// Keeping this as a separate function is important since it provides a single point for
// downstreams to customize how errors are printed on exotic targets, if needed.
template <class ...Args>
void test_eprintf(char const* fmt, Args const& ...args) {
  std::fprintf(stderr, fmt, args...);
}

void test_log(const char* condition, const char* file, int line, const char* message) {
  const char* msg = condition ? "Assertion failure: " : "Unconditional failure:";
  test_eprintf("%s%s %s %d\n%s", msg, condition, file, line, message);
}

template <class F>
void test_log(const char* condition, const char* file, int line, const F& functor) {
  test_eprintf("Assertion failure: %s %s %d\n", condition, file, line);
  functor();
}

template <class Arg>
[[noreturn]] void test_fail(const char* file, int line, const Arg& arg) {
  test_log("", file, line, arg);
  std::abort();
}

template <class Arg>
void test_require(bool condition, const char* condition_str, const char* file, int line, const Arg& arg) {
  if (condition)
    return;

  test_log(condition_str, file, line, arg);
  std::abort();
}

// assert(false) replacement
// The ARG is either a
// - c-string or std::string, in which case the string is printed to stderr,
// - an invocable object, which will be invoked.
#define TEST_FAIL(ARG) ::test_fail(__FILE__, __LINE__, ARG)

// assert replacement.
// ARG is the same as for TEST_FAIL
#define TEST_REQUIRE(CONDITION, ARG) ::test_require(CONDITION, #CONDITION, __FILE__, __LINE__, ARG)

// LIBCPP_ASSERT replacement
//
// This requirement is only tested when the test suite is used for libc++.
// This allows checking libc++ specific requirements, for example the error
// messages of exceptions.
// ARG is the same as for TEST_FAIL
#if defined(_LIBCPP_VERSION)
#  define TEST_LIBCPP_REQUIRE(CONDITION, ARG) ::test_require(CONDITION, #CONDITION, __FILE__, __LINE__, ARG)
#else
#  define TEST_LIBCPP_REQUIRE(...) /* DO NOTHING */
#endif

// Helper macro to test an expression does not throw any exception.
#ifndef TEST_HAS_NO_EXCEPTIONS
#  define TEST_DOES_NOT_THROW(EXPR)                                                                                    \
    do {                                                                                                               \
      try {                                                                                                            \
        static_cast<void>(EXPR);                                                                                       \
      } catch (...) {                                                                                                  \
        ::test_log(#EXPR, __FILE__, __LINE__, "no exception was expected\n");                                          \
        ::std::abort();                                                                                                \
      }                                                                                                                \
    } while (false) /* */

// Helper macro to test an expression throws an exception of the expected type.
#  define TEST_THROWS_TYPE(TYPE, EXPR)                                                                                 \
    do {                                                                                                               \
      try {                                                                                                            \
        static_cast<void>(EXPR);                                                                                       \
        ::test_log(nullptr,                                                                                            \
                   __FILE__,                                                                                           \
                   __LINE__,                                                                                           \
                   "no exception is thrown while an exception of type " #TYPE " was expected\n");                      \
        ::std::abort();                                                                                                \
      } catch (const TYPE&) {                                                                                          \
        /* DO NOTHING */                                                                                               \
      } catch (...) {                                                                                                  \
        ::test_log(nullptr,                                                                                            \
                   __FILE__,                                                                                           \
                   __LINE__,                                                                                           \
                   "the type of the exception caught differs from the expected type " #TYPE "\n");                     \
        ::std::abort();                                                                                                \
      }                                                                                                                \
    } while (false) /* */

// Helper macro to test an expression throws an exception of the expected type and satisfies a predicate.
//
// In order to log additional information the predicate can use log macros.
// The exception caught is used as argument to the predicate.
#  define TEST_VALIDATE_EXCEPTION(TYPE, PRED, EXPR)                                                                    \
    do {                                                                                                               \
      try {                                                                                                            \
        static_cast<void>(EXPR);                                                                                       \
        ::test_log(nullptr,                                                                                            \
                   __FILE__,                                                                                           \
                   __LINE__,                                                                                           \
                   "no exception is thrown while an exception of type " #TYPE " was expected\n");                      \
        ::std::abort();                                                                                                \
      } catch (const TYPE& EXCEPTION) {                                                                                \
        PRED(EXCEPTION);                                                                                               \
      } catch (...) {                                                                                                  \
        ::test_log(nullptr,                                                                                            \
                   __FILE__,                                                                                           \
                   __LINE__,                                                                                           \
                   "the type of the exception caught differs from the expected type " #TYPE "\n");                     \
        ::std::abort();                                                                                                \
      }                                                                                                                \
    } while (false)                    /* */

#else                                  // TEST_HAS_NO_EXCEPTIONS
#  define TEST_DOES_NOT_THROW(EXPR) static_cast<void>(EXPR);
#  define TEST_THROWS_TYPE(...)        /* DO NOTHING */
#  define TEST_VALIDATE_EXCEPTION(...) /* DO NOTHING */
#endif                                 // TEST_HAS_NO_EXCEPTIONS

#endif // TEST_SUPPORT_ASSERT_MACROS_H