// <!--
// The MIT License (MIT)
//
// Copyright (c) 2024 Kris Jusiak <kris@jusiak.net>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
#if 0
// -->
[Overview](#Overview) / [Examples](#Examples) / [API](#API) / [FAQ](#FAQ) / [Resources](#Resources)

## UT: C++20 Unit-Testing library

  > "If you liked it then you `"should have put a"_test` on it", Beyonce rule

[![MIT Licence](http://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/license/mit)
[![Version](https://img.shields.io/github/v/release/qlibs/ut)](https://github.com/qlibs/ut/releases)
[![Build](https://img.shields.io/badge/build-green.svg)](https://godbolt.org/z/3qT4vc9nY)
[![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://godbolt.org/z/MG5cjnsbM)

  > https://en.wikipedia.org/wiki/Unit_testing

### Features

- Single header (https://raw.githubusercontent.com/qlibs/ut/main/ut) / C++20 module (https://raw.githubusercontent.com/qlibs/ut/main/ut.cppm)
- Compile-time first (executes tests at compile-time and/or run-time)
    - Detects memory leaks and UBs at compile-time*
- Explicit by design (no implicit conversions, narrowing, epsilon-less floating point comparisions, ...)
- Minimal [API](#api)
- Reflection integration (optional via https://github.com/qlibs/reflect)
- Compiles cleanly with ([`-fno-exceptions -fno-rtti -Wall -Wextra -Werror -pedantic -pedantic-errors`](https://godbolt.org/z/ceK6qsx68))
- Fast compilation times (see [compilation times](#comp))
- Fast run-time execution (see [performance](#perf))
- Verifies itself upon include (can be disabled with `-DNTEST` - see [FAQ](https://github.com/qlibs/.github/blob/main/profile/NTEST.md))

> \*Based on the `constexpr` ability of given compiler/standard

### Requirements

- C++20 ([gcc-12+, clang-16+](https://en.cppreference.com/w/cpp/compiler_support))

### Overview

> Hello world (https://godbolt.org/z/MG5cjnsbM)

```cpp
#include <ut>
#include <iostream> // output at run-time

constexpr auto sum(auto... args) { return (args + ...); }

int main() {
  using namespace ut;

  "sum"_test = [] {
    expect(sum(1) == 1_i);
    expect(sum(1, 2) == 3_i);
    expect(sum(1, 2, 3) == 6_i);
  };
}
```

```sh
$CXX example.cpp -std=c++20 -o example && ./example
PASSED: tests: 1 (1 passed, 0 failed, 1 compile-time), asserts: 3 (3 passed, 0 failed)
```

> Execution model (https://godbolt.org/z/31Gc151Mf)

```cpp
static_assert(("sum"_test = [] { // compile-time only
  expect(sum(1, 2, 3) == 6_i);
}));

int main() {
  "sum"_test = [] {              // compile time and run-time
    expect(sum(1, 2, 3) == 5_i);
  };

  "sum"_test = [] constexpr {    // compile-time and run-time
    expect(sum(1, 2, 3) == 6_i);
  };

  "sum"_test = [] mutable {      // run-time only
    expect(sum(1, 2, 3) == 6_i);
  };

  "sum"_test = [] consteval {    // compile-time only
    expect(sum(1, 2, 3) == 6_i);
  };
}
```

> Note: `UT_RUN_TIME, UT_COMPILE_TIME` can be used instead of `mutable, consteval`.

```sh
$CXX example.cpp -std=c++20 # -DUT_COMPILE_TIME_ONLY
ut:156:25: error: static_assert((test(), "[FAILED]"));
example.cpp:13:44: note:"sum"_test
example.cpp:14:5:  note: in call to 'expect.operator()<ut::eq<int, int>>({6, 5})'
```

```sh
$CXX example.cpp -std=c++20 -o example -DUT_RUN_TIME_ONLY && ./example
example.cpp:14:FAILED:"sum": 6 == 5
FAILED: tests: 3 (2 passed, 1 failed, 0 compile-time), asserts: 2 (1 passed, 1 failed)
```

> Constant evaluation (https://godbolt.org/z/6E86YdbdT)

```cpp
constexpr auto test() {
  if consteval { return 42; } else { return 87; }
}

int main() {
  "compile-time"_test = [] consteval {
    expect(42_i == test());
  };

  "run-time"_test = [] mutable {
    expect(87_i == test());
  };
}
```

```sh
$CXX example.cpp -std=c++20 -o example && ./example
PASSED: tests: 2 (2 passed, 0 failed, 1 compile-time), asserts: 1 (1 passed, 0 failed)
```

> Suites/Sub-tests (https://godbolt.org/z/1oT3Gre93)

```cpp
ut::suite test_suite = [] {
  "vector [sub-tests]"_test = [] {
    std::vector<int> v(5);
    expect(v.size() == 5_ul);
    expect(v.capacity() >= 5_ul);

    "resizing bigger changes size and capacity"_test = [=] {
      mut(v).resize(10);
      expect(v.size() == 10_ul);
      expect(v.capacity() >= 10_ul);
    };
  };
};

int main() { }
```

```sh
$CXX example.cpp -std=c++20 -o example && ./example
PASSED: tests: 2 (2 passed, 0 failed, 1 compile-time), asserts: 4 (4 passed, 0 failed)
```

> Assertions (https://godbolt.org/z/79M7o355a)

```cpp
int main() {
  "expect"_test = [] {
    "different ways"_test = [] {
      expect(42_i == 42);
      expect(eq(42, 42))   << "same as expect(42_i == 42)";
      expect(_i(42) == 42) << "same as expect(42_i == 42)";
    };

    "floating point"_test = [] {
      expect((4.2 == 4.2_d)(.01)) << "floating point comparison with .01 epsilon precision";
    };

    "fatal"_test = [] mutable { // at run-time
      std::vector<int> v{1};
      expect[v.size() > 1_ul] << "fatal, aborts further execution";
      expect(v[1] == 42_i); // not executed
    };

    "compile-time expression"_test = [] {
      expect(constant<42 == 42_i>) << "requires compile-time expression";
    };
  };
}
```

```sh
$CXX example.cpp -std=c++20 -o example && ./example
example.cpp:21:FAILED:"fatal": 1 > 1
FAILED: tests: 3 (2 passed, 1 failed, 3 compile-time), asserts: 5 (4 passed, 1 failed)
```

> Errors/Checks (https://godbolt.org/z/Tvnce9j4d)

```cpp
int main() {
  "leak"_test = [] {
    new int; // compile-time error
  };

  "ub"_test = [] {
    int* i{};
    *i = 42; // compile-time error
  };

  "errors"_test = [] {
    expect(42_i == short(42)); // [ERROR] Comparision of different types is not allowed
    expect(42 == 42);          // [ERROR] Expression required: expect(42_i == 42)
    expect(4.2 == 4.2_d);      // [ERROR] Epsilon is required: expect((4.2 == 4.2_d)(.01))
  };
}
```

### Examples

> Reflection integration (https://godbolt.org/z/v8GG4hfbW)

```cpp
int main() {
  struct foo { int a; int b; };
  struct bar { int a; int b; };

  "reflection"_test = [] {
    auto f = foo{.a=1, .b=2};
    expect(eq(foo{1, 2}, f));
    expect(members(foo{1, 2}) == members(f));
    expect(names(foo{}) == names(bar{}));
  };
};
```

```sh
$CXX example.cpp -std=c++20 -o example && ./example
PASSED: tests: 1 (1 passed, 0 failed, 1 compile-time), asserts: 3 (3 passed, 0 failed)
```

> Custom configuration (https://godbolt.org/z/6MrEEvqja)

```cpp
struct outputter {
  template<ut::events::mode Mode>
  constexpr auto on(const ut::events::test_begin<Mode>&) { }
  template<ut::events::mode Mode>
  constexpr auto on(const ut::events::test_end<Mode>&) { }
  template<class TExpr>
  constexpr auto on(const ut::events::assert_pass<TExpr>&) { }
  template<class TExpr>
  constexpr auto on(const ut::events::assert_fail<TExpr>&) { }
  constexpr auto on(const ut::events::fatal&) { }
  constexpr auto on(const ut::events::summary&) { }
  template<class TMsg>
  constexpr auto on(const ut::events::log<TMsg>&) { }
};

struct custom_config {
  ::outputter outputter{};
  ut::reporter<decltype(outputter)> reporter{outputter};
  ut::runner<decltype(reporter)> runner{reporter};
  const char* current_test_name{}; // optional
};

template<>
auto ut::cfg<ut::override> = custom_config{};

int main() {
  "config"_test = [] mutable {
    expect(42 == 43_i); // no output
  };
};
```

```sh
$CXX example.cpp -std=c++20 -o example && ./example
echo $? # 139 # no output
```

<a name="comp"></a>
### Compilation times

> Include - no iostream (https://raw.githubusercontent.com/qlibs/ut/main/ut)

```cpp
time $CXX -x c++ -std=c++20 ut -c -DNTEST          # 0.028s
time $CXX -x c++ -std=c++20 ut -c                  # 0.049s
```

> Benchmark - 100 tests, 1000 asserts (https://godbolt.org/z/zs5Ee3E7o)

```cpp
[ut]: time $CXX benchmark.cpp -std=c++20           # 0m0.813s
[ut]: time $CXX benchmark.cpp -std=c++20 -DNTEST   # 0m0.758s
-------------------------------------------------------------------------
[ut] https://github.com/qlibs/ut/releases/tag/v2.1.6
```

<a name="perf"></a>
### Performance

> Benchmark - 100 tests, 1000 asserts (https://godbolt.org/z/xKx45s4xq)

```cpp
time ./benchmark # 0m0.002s (-O3)
time ./benchmark # 0m0.013s (-g)
```

> X86-64 assembly -O3 (https://godbolt.org/z/rqbsafaE6)

```cpp
int main() {
  "sum"_test = [] {
    expect(42_i == 42);
  };
}
```

```cpp
main:
  mov  rax, qword ptr [rip + cfg<ut::override>+136]
  inc  dword ptr [rax + 24]
  mov  ecx, dword ptr [rax + 8]
  mov  edx, dword ptr [rax + 92]
  lea  esi, [rdx + 1]
  mov  dword ptr [rax + 92], esi
  mov  dword ptr [rax + 4*rdx + 28], ecx
  mov  rax, qword ptr [rax]
  lea  rcx, [rip + .L.str]
  mov  qword ptr [rax + 8], rcx
  mov  dword ptr [rax + 16], 6
  lea  rcx, [rip + template parameter object for fixed_string
  mov  qword ptr [rax + 24], rcx
  inc  dword ptr [rip + ut::cfg<ut::override>+52]
  mov  rax, qword ptr [rip + ut::cfg<ut::override>+136]
  mov  ecx, dword ptr [rax + 8]
  mov  edx, dword ptr [rax + 92]
  dec  edx
  mov  dword ptr [rax + 92], edx
  xor  esi, esi
  cmp  ecx, dword ptr [rax + 4*rdx + 28]
  sete sil
  inc  dword ptr [rax + 4*rsi + 16]
  xor  eax, eax
  ret
```

### API

```cpp
/**
 * Assert definition
 * @code
 * expect(42 == 42_i);
 * expect(42 == 42_i) << "log";
 * expect[42 == 42_i]; // fatal assertion, aborts further execution
 * @endcode
 */
inline constexpr struct {
  constexpr auto operator()(auto expr);
  constexpr auto operator[](auto expr);
} expect{};
```

```cpp
/**
 * Test suite definition
 * @code
 * suite test_suite = [] { ... };
 * @encode
 */
struct suite;
```

```cpp
/**
 * Test definition
 * @code
 * "foo"_test = []          { ... }; // compile-time and run-time
 * "foo"_test = [] mutable  { ... }; // run-time only
 * "foo"_test = [] constval { ... }; // compile-time only
 * @endcode
 */
template<fixed_string Str>
[[nodiscard]] constexpr auto operator""_test();
```

```cpp
/**
 * Compile time expression
 * @code
 * expect(constant<42_i == 42>); // forces compile-time evaluation and run-time check
 * auto i = 0;
 * expect(constant<i == 42_i>);  // compile-time error
 * @encode
 */
template<auto Expr> inline constexpr auto constant;
```

```cpp
/**
 * Allows mutating object (by default lambdas are immutable)
 * @code
 * "foo"_test = [] {
 *   int i = 0;
 *   "sub"_test = [i] {
 *     mut(i) = 42;
 *   };
 *   expect(i == 42_i);
 * };
 * @endcode
 */
template<class T> [[nodiscard]] constexpr auto& mut(const T&);
```

```cpp
template<class TLhs, class TRhs> struct eq;  // equal
template<class TLhs, class TRhs> struct neq; // not equal
template<class TLhs, class TRhs> struct gt;  // greater
template<class TLhs, class TRhs> struct ge;  // greater equal
template<class TLhs, class TRhs> struct lt;  // less
template<class TLhs, class TRhs> struct le;  // less equal
template<class TLhs, class TRhs> struct nt;  // not
```

```cpp
constexpr auto operator==(const auto& lhs, const auto& rhs) -> decltype(eq{lhs, rhs});
constexpr auto operator!=(const auto& lhs, const auto& rhs) -> decltype(neq{lhs, rhs});
constexpr auto operator> (const auto& lhs, const auto& rhs) -> decltype(gt{lhs, rhs});
constexpr auto operator>=(const auto& lhs, const auto& rhs) -> decltype(ge{lhs, rhs});
constexpr auto operator< (const auto& lhs, const auto& rhs) -> decltype(lt{lhs, rhs});
constexpr auto operator<=(const auto& lhs, const auto& rhs) -> decltype(le{lhs, rhs});
constexpr auto operator! (const auto& t)                    -> decltype(nt{t});
```

```cpp
struct _b;      // bool (true_b = _b{true}, false_b = _b{false})
struct _c;      // char
struct _sc;     // signed char
struct _s;      // short
struct _i;      // int
struct _l;      // long
struct _ll;     // long long
struct _u;      // unsigned
struct _uc;     // unsigned char
struct _us;     // unsigned short
struct _ul;     // unsigned long
struct _ull;    // unsigned long long
struct _f;      // float
struct _d;      // double
struct _ld;     // long double
struct _i8;     // int8_t
struct _i16;    // int16_t
struct _i32;    // int32_t
struct _i64;    // int64_t
struct _u8;     // uint8_t
struct _u16;    // uint16_t
struct _u32;    // uint32_t
struct _u64;    // uint64_t
struct _string; // const char*
```

```cpp
constexpr auto operator""_i(auto value)   -> decltype(_i(value));
constexpr auto operator""_s(auto value)   -> decltype(_s(value));
constexpr auto operator""_c(auto value)   -> decltype(_c(value));
constexpr auto operator""_sc(auto value)  -> decltype(_sc(value));
constexpr auto operator""_l(auto value)   -> decltype(_l(value));
constexpr auto operator""_ll(auto value)  -> decltype(_ll(value));
constexpr auto operator""_u(auto value)   -> decltype(_u(value));
constexpr auto operator""_uc(auto value)  -> decltype(_uc(value));
constexpr auto operator""_us(auto value)  -> decltype(_us(value));
constexpr auto operator""_ul(auto value)  -> decltype(_ul(value));
constexpr auto operator""_ull(auto value) -> decltype(_ull(value));
constexpr auto operator""_f(auto value)   -> decltype(_f(value));
constexpr auto operator""_d(auto value)   -> decltype(_d(value));
constexpr auto operator""_ld(auto value)  -> decltype(_ld(value));
constexpr auto operator""_i8(auto value)  -> decltype(_i8(value));
constexpr auto operator""_i16(auto value) -> decltype(_i16(value));
constexpr auto operator""_i32(auto value) -> decltype(_i32(value));
constexpr auto operator""_i64(auto value) -> decltype(_i64(value));
constexpr auto operator""_u8(auto value)  -> decltype(_u8(value));
constexpr auto operator""_u16(auto value) -> decltype(_u16(value));
constexpr auto operator""_u32(auto value) -> decltype(_u32(value));
constexpr auto operator""_u64(auto value) -> decltype(_u64(value));
```

```cpp
template<fixed_string Str>
[[nodiscard]] constexpr auto operator""_s() -> decltype(_string(Str));
```

> Configuration

```cpp
namespace events {
enum class mode {
  run_time,
  compile_time
};

template<class T>
struct run {
  T test{};
  const char* file_name{};
  int line{};
  const char* name{};
  const char* filter{};
};

template<mode Mode>
struct test_end {
  const char* file_name{};
  int line{};
  const char* name{};
  enum { FAILED, PASSED, COMPILE_TIME } result{};
};

template<class TExpr>
struct assert_pass {
  const char* file_name{};
  int line{};
  TExpr expr{};
};

template<class TExpr>
struct assert_fail {
  const char* file_name{};
  int line{};
  TExpr expr{};
};

struct fatal { };

template<class TMsg>
struct log {
  const TMsg& msg;
  bool result{};
};

struct summary {
  enum { FAILED, PASSED, COMPILE_TIME };
  unsigned asserts[2]{}; /* FAILED, PASSED */
  unsigned tests[3]{}; /* FAILED, PASSED, COMPILE_TIME */
};
} // namespace events
```

```cpp
struct outputter {
  template<events::mode Mode> constexpr auto on(const events::test_begin<Mode>&);
  constexpr auto on(const events::test_begin<events::mode::run_time>& event);
  template<events::mode Mode> constexpr auto on(const events::test_end<Mode>&);
  template<class TExpr> constexpr auto on(const events::assert_pass<TExpr>&);
  template<class TExpr> constexpr auto on(const events::assert_fail<TExpr>&);
  constexpr auto on(const events::fatal&);
  template<class TMsg> constexpr auto on(const events::log<TMsg>&);
  constexpr auto on(const events::summary& event);
};
```

```cpp
struct reporter {
  constexpr auto on(const events::test_begin<events::mode::run_time>&);
  constexpr auto on(const events::test_end<events::mode::run_time>&);
  constexpr auto on(const events::test_begin<events::mode::compile_time>&);
  constexpr auto on(const events::test_end<events::mode::compile_time>&);
  template<class TExpr> constexpr auto on(const events::assert_pass<TExpr>&);
  template<class TExpr> constexpr auto on(const events::assert_fail<TExpr>&);
  constexpr auto on(const events::fatal& event);
};
```

```cpp
struct runner {
  template<class Test> constexpr auto on(Test test) -> bool;
};
```

```cpp
/**
 * Customization point to override the default configuration
 * @code
 * template<class... Ts> auto ut::cfg<ut::override, Ts...> = my_config{};
 * @endcode
 */
struct override { }; /// to override configuration by users
struct default_cfg;  /// default configuration
template <class...> inline auto cfg = default_cfg{};
```

```cpp
#define UT_RUN_TIME             // [mutable] Marks test at run-time only
#define UT_COMPILE_TIME         // [consteval] Marks test as compile-time only
```

```cpp
#define UT_RUN_TIME_ONLY        // If defined tests will be executed
                                // at run-time + static_assert tests
#define UT_COMPILE_TIME_ONLY    // If defined only compile-time tests
                                // will be executed
```

```cpp
env:UT_FILTER                   // If UT_FILTER environment variable is set
                                // only tests which match regex will be executed
```

### FAQ

> - How to disable running tests at compile-time?
>
>   When `-DNTEST` is defined static_asserts tests wont be executed upon include.
>   Note: Use with caution as disabling tests means that there are no gurantees upon include that given compiler/env combination works as expected.
>
> - Similar projects?
>   [ut](https://github.com/boost-ext/ut), [catch2](https://github.com/catchorg/Catch2), [googletest](https://github.com/google/googletest), [gunit](https://github.com/cpp-testing/GUnit), [boost.test](https://www.boost.org/doc/libs/latest/libs/test/doc/html/index.html)

### Resources

> - "unit"_test: Implementing a Macro-free Unit Testing Framework from Scratch in C++20 - https://www.youtube.com/watch?v=-qAXShy1xiE
> - Future of Testing With C++20 - https://www.youtube.com/watch?v=KlU0cb_tbuw
> - Towards Painless Testing - https://www.youtube.com/watch?v=NVrZjT5lW5o

### License

> - [MIT](LICENSE)

<!--
#endif

#pragma once

#define UT_RUN_TIME mutable
#define UT_COMPILE_TIME consteval

extern "C" char *getenv(const char *) throw();

namespace ut::inline v2_1_6 {
namespace type_traits {
template<class, class> inline constexpr auto is_same_v = false;
template<class T> inline constexpr auto is_same_v<T, T> = true;
template<class T> inline constexpr auto is_floating_point_v = false;
template<> inline constexpr auto is_floating_point_v<float> = true;
template<> inline constexpr auto is_floating_point_v<double> = true;
template<> inline constexpr auto is_floating_point_v<long double> = true;
template<class> inline constexpr auto is_mutable_lambda_v = false;
template<class R, class B, class... Ts> inline constexpr auto is_mutable_lambda_v<R (B::*)(Ts...)> = true;
template<class Fn> inline constexpr auto has_capture_lambda_v = sizeof(Fn) > 1ul;
} // type_traits
namespace utility {
template<class T> T&& declval();
template<class T, class...> struct type_identity { using type = T; };
template<unsigned Size> struct fixed_string {
  constexpr fixed_string(const char(&str)[Size]) { for (auto i = 0u; i < Size; ++i) { storage[i] = str[i]; } }
  [[nodiscard]] constexpr auto operator[](const auto i) const { return storage[i]; }
  [[nodiscard]] constexpr auto data() const { return storage; }
  [[nodiscard]] static constexpr auto size() { return Size; }
  constexpr friend auto operator<<(auto& os, const fixed_string& fs) -> decltype(auto) { return os << fs.storage; }
  char storage[Size]{};
};
[[nodiscard]] constexpr auto match(const auto pattern, const auto str) -> bool {
  if (not bool(pattern)) { return true; }
  if (not *pattern) { return not *str; }

  if (not *str) {
    return pattern[0] == '*' ? match(&pattern[1], str) : false;
  }

  if (pattern[0] != '?' and pattern[0] != '*' and pattern[0] != str[0]) {
    return false;
  }

  if (pattern[0] == '*') {
    auto tmp = str;
    auto i = 0u;
    while (tmp++) {
      if (match(&pattern[1], &str[i++])) {
        return true;
      }
    }
    return false;
  }

  return match(&pattern[1], &str[1]);
}
} // utility
namespace events {
enum class mode { run_time, compile_time };
template<class T>
struct run { T test{}; const char* file_name{}; int line{}; const char* name{}; const char* filter{}; };
template<mode Mode> struct test_begin { const char* file_name{}; int line{}; const char* name{}; };
template<mode Mode> struct test_end { const char* file_name{}; int line{}; const char* name{}; enum { FAILED, PASSED, COMPILE_TIME } result{}; };
template<class TExpr> struct assert_pass { const char* file_name{}; int line{}; TExpr expr{}; };
template<class TExpr> struct assert_fail { const char* file_name{}; int line{}; TExpr expr{}; };
struct fatal { };
template<class TMsg> struct log { const TMsg& msg; bool result{}; };
struct summary { enum { FAILED, PASSED, COMPILE_TIME }; unsigned asserts[2]{}; /* FAILED, PASSED */ unsigned tests[3]{}; /* FAILED, PASSED, COMPILE_TIME */ };
} // namespace events

template<class TOStream>
class outputter {
 public:
  template<events::mode Mode> constexpr auto on(const events::test_begin<Mode>&) { }
  constexpr auto on(const events::test_begin<events::mode::run_time>& event) { current_test = event; }
  template<events::mode Mode> constexpr auto on(const events::test_end<Mode>&) { }
  template<class TExpr> constexpr auto on(const events::assert_pass<TExpr>&) { }
  template<class TExpr> constexpr auto on(const events::assert_fail<TExpr>& event) {
    if (!__builtin_is_constant_evaluated()) {
      if (initial_new_line == '\n') { os << initial_new_line; } else { initial_new_line = '\n'; }
      os << event.file_name << ':' << event.line << ':' << "FAILED:" << '\"' << current_test.name << "\": " << event.expr;
    }
  }
  constexpr auto on(const events::fatal&) { }
  template<class TMsg> constexpr auto on(const events::log<TMsg>& event) {
    if (!__builtin_is_constant_evaluated() && !event.result) {
      os << ' ' << event.msg;
    }
  }
  constexpr auto on(const events::summary& event) {
    if (!__builtin_is_constant_evaluated()) {
      if (event.asserts[events::summary::FAILED] || event.tests[events::summary::FAILED]) {
          os << "\nFAILED: ";
      } else {
          os << "PASSED: ";
      }
      os << "tests: " << (event.tests[events::summary::PASSED] + event.tests[events::summary::FAILED]) << " ("
         <<  event.tests[events::summary::PASSED] << " passed, "
         <<  event.tests[events::summary::FAILED] << " failed, "
         <<  event.tests[events::summary::COMPILE_TIME] << " compile-time), "
         << "asserts: " << (event.asserts[events::summary::PASSED] + event.asserts[events::summary::FAILED]) << " ("
         << event.asserts[events::summary::PASSED] << " passed, "
         << event.asserts[events::summary::FAILED] << " failed)\n";
    }
  }

  TOStream& os;
  events::test_begin<events::mode::run_time> current_test{};
  char initial_new_line{};
};

template<class TOutputter, auto MaxDepth = 16u>
struct reporter {
  constexpr auto on(const events::test_begin<events::mode::run_time>& event) {
    asserts_failed[current++] = summary.asserts[events::summary::FAILED];
    outputter.on(event);
  }
  constexpr auto on(const events::test_end<events::mode::run_time>& event) {
    const auto result = summary.asserts[events::summary::FAILED] == asserts_failed[--current];
    ++summary.tests[result];
    events::test_end<events::mode::run_time> te{event};
    te.result = static_cast<decltype(te.result)>(result);
    outputter.on(te);
  }
  constexpr auto on(const events::test_begin<events::mode::compile_time>&) {
    ++summary.tests[events::summary::COMPILE_TIME];
  }
  constexpr auto on(const events::test_end<events::mode::compile_time>&) { }
  template<class TExpr> constexpr auto on(const events::assert_pass<TExpr>& event) {
    ++summary.asserts[events::summary::PASSED];
    outputter.on(event);
  }
  template<class TExpr> constexpr auto on(const events::assert_fail<TExpr>& event) {
    ++summary.asserts[events::summary::FAILED];
    outputter.on(event);
  }
  constexpr auto on(const events::fatal& event) {
    ++summary.tests[events::summary::FAILED];
    outputter.on(event);
    outputter.on(summary);
    __builtin_abort();
  }

  #ifndef UT_COMPILE_TIME_ONLY
  ~reporter() { // non constexpr
    outputter.on(summary);
    if (summary.asserts[events::summary::FAILED]) {
      __builtin_abort();
    }
  }
  #endif

  TOutputter& outputter;
  events::summary summary{};
  unsigned asserts_failed[MaxDepth]{};
  unsigned current{};
};

template<class TReporter>
struct runner {
  template<class Test> constexpr auto on(events::run<Test> run) -> bool {
    if (__builtin_is_constant_evaluated()) {
      if constexpr (!type_traits::is_mutable_lambda_v<decltype(&Test::operator())>) {
        run.test();
        return true;
      } else {
        return false;
      }
    } else {
      #ifndef UT_RUN_TIME_ONLY
        if constexpr (!type_traits::is_mutable_lambda_v<decltype(&Test::operator())> && !type_traits::has_capture_lambda_v<Test>) {
          reporter.on(events::test_begin<events::mode::compile_time>{run.file_name, run.line, run.name});
          static_assert((run.test(), R"([FAILED] Compile-time expectation failed. The error below should indicate the issue. If it's not an assertion it might be that the std and/or compiler don't support running the test at compile-time. In such case mark the test as `mutable` or `UT_RUN_TIME` to force run-time only execution. For example: `"run-time"_test = [] mutable { ... }`.)"));
          reporter.on(events::test_end<events::mode::compile_time>{run.file_name, run.line, run.name});
        }
      #endif

      #ifndef UT_COMPILE_TIME_ONLY
        if (utility::match(run.filter, run.name)) {
          reporter.on(events::test_begin<events::mode::run_time>{run.file_name, run.line, run.name});
          run.test();
          reporter.on(events::test_end<events::mode::run_time>{run.file_name, run.line, run.name});
        }
      #endif
    }
    return true;
  }

  TReporter& reporter;
};
} // namespace ut

namespace std { // iosfwd
template<class> struct char_traits;
template<class, class> class basic_ostream;
extern basic_ostream<char, char_traits<char>> clog; // only used if defined
} // namespace std

namespace ut::inline v2_1_6 {
namespace detail {
struct stream {
  friend constexpr decltype(auto) operator<<([[maybe_unused]] auto& os, [[maybe_unused]] const auto& t) {
    #ifdef UT_COMPILE_TIME_ONLY
      return os;
    #else
      static_assert(requires { std::clog << t; }, "[ERROR] No output supported: Consider #include <iostream> | ut::cfg<ut::override> = custom_cfg{} | #define UT_COMPILE_TIME_ONLY");
      return (std::clog << t);
    #endif
  }
};
} // namespace detail

template<class...>
struct default_cfg {
  detail::stream stream{};
  ut::outputter<decltype(stream)> outputter{stream};
  ut::reporter<decltype(outputter)> reporter{outputter};
  ut::runner<decltype(reporter)> runner{reporter};
  const char* current_test_name{};
};

struct override { };

/**
 * Customization point to override the default configuration
 *
 * @code
 * template<class... Ts> auto ut::cfg<ut::override, Ts...> = my_config{};
 * @endcode
 */
template <class... Ts> inline default_cfg<Ts...> cfg{};

namespace detail {
template<class... Ts>
[[nodiscard]] constexpr auto& cfg(Ts&&...) {
  return ut::cfg<typename utility::type_identity<override, Ts...>::type>;
}
void failed(); /// fail in constexpr context
} // namespace detail

inline constexpr struct {
  constexpr auto operator()(auto expr, const char* file_name = __builtin_FILE(), int line = __builtin_LINE()) const {
    if constexpr (constexpr auto supported = type_traits::is_same_v<bool, decltype(expr)> || !requires { static_cast<bool>(expr); }; supported) {
      static_assert(!supported, "[ERROR] Expression required - `expect(lhs == rhs)`. For example: `expect(3_i == sum(1, 2))`.");
    } else {
      bool result{};
      if (result = static_cast<bool>(expr); __builtin_is_constant_evaluated()) {
        if (!result) { detail::failed(); }
      } else if (result) {
        detail::cfg(expr).reporter.on(events::assert_pass{file_name, line, expr});
      } else {
        detail::cfg(expr).reporter.on(events::assert_fail{file_name, line, expr});
      }
      return log{result};
    }
  }

  struct fatal_expr {
    constexpr fatal_expr(auto expr, const char* file_name = __builtin_FILE(), int line = __builtin_LINE()) {
      if constexpr (constexpr auto supported = type_traits::is_same_v<bool, decltype(expr)> || !requires { static_cast<bool>(expr); }; supported) {
        static_assert(!supported, "[ERROR] Expression required - `expect[lhs == rhs]`. For example: `expect[3_i == sum(1, 2)]`.");
      } else {
        if (result = static_cast<bool>(expr); __builtin_is_constant_evaluated()) {
          if (!result) { detail::failed(); }
        } else if (result) {
          detail::cfg(expr).reporter.on(events::assert_pass{file_name, line, expr});
        } else {
          detail::cfg(expr).reporter.on(events::assert_fail{file_name, line, expr});
        }
      }
    }
    bool result{};
  };
  constexpr auto operator[](fatal_expr e) const { return fatal_log{e.result}; } /// multiple and/or default parameters requires C++23

private:
  struct log {
    template<class TMsg> constexpr const auto& operator<<(const TMsg& msg) const {
      detail::cfg(msg).outputter.on(events::log<TMsg>{msg, result});
      return *this;
    }
    bool result{};
  };
  template<auto tag = []{}>
  struct fatal_log {
    template<class TMsg> constexpr const auto& operator<<(const TMsg& msg) const {
      detail::cfg(msg).outputter.on(events::log<TMsg>{msg, result});
      return *this;
    }
    constexpr ~fatal_log() {
      detail::cfg(tag).reporter.on(events::fatal{});
    }
    bool result{};
  };
} expect{};

struct suite {
  template<class Test> suite(Test test) { test(); } /// not constexpr
};

namespace detail {
template<utility::fixed_string Name>
struct test {
  struct run {
    template<class T> constexpr run(T test, const char* file_name = __builtin_FILE(), int line = __builtin_LINE())
      : result{[&] {
          if (__builtin_is_constant_evaluated()) {
            return cfg(test).runner.on(events::run{test, file_name, line, Name.data()});
          } else {
            if constexpr (requires { cfg(test).current_test_name; }) {
              cfg(test).current_test_name = Name.data();
            }
            return cfg(test).runner.on(events::run{test, file_name, line, Name.data(), getenv("UT_FILTER")});
          }
        }()}
    { }
    bool result{};
  };
  constexpr auto operator=(run test) const { return test.result; }
};
} // namespace detail

template<utility::fixed_string Str>
[[nodiscard]] constexpr auto operator""_test() { return detail::test<Str>{}; }

template<auto Expr> inline constexpr auto constant = Expr;
template<class T> [[nodiscard]] constexpr auto& mut(const T& t) { return const_cast<T&>(t); }

template<class TLhs, class TRhs> struct eq {
  constexpr eq(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs} { }
  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed.");
  [[nodiscard]] constexpr explicit operator bool() const { return false; }
  const TLhs& lhs; const TRhs& rhs;
};
template<class T> struct eq<T, T> {
  constexpr eq(const T& lhs, const T& rhs) : lhs{lhs}, rhs{rhs}, result{lhs == rhs} { }
  constexpr friend auto operator<<(auto& os, const eq& expr) -> decltype(auto) { return (os << expr.lhs << " == " << expr.rhs); }
  [[nodiscard]] constexpr explicit operator bool() const { return result; }
  T lhs; T rhs; bool result{};
};
template<class T> requires type_traits::is_floating_point_v<T> struct eq<T, T> {
  constexpr eq(const T& lhs, const T& rhs) : lhs{lhs}, rhs{rhs} { }
  constexpr friend auto operator<<(auto& os, const eq& expr) -> decltype(auto) { return (os << expr.lhs << " == " << expr.rhs); }
  [[nodiscard]] constexpr explicit operator bool() const {
    static_assert(!type_traits::is_floating_point_v<T>, "[ERROR] Epsilon is required - `expect((lhs == rhs)(epsilon))`. For example: `expect((4.2_f == sum(4.f, .2f))(.01f))`.");
    return {};
  }
  struct epsilon {
    constexpr epsilon(const T& lhs, const T& rhs, const T e) : lhs{lhs}, rhs{rhs}, e{e}, result{(lhs < rhs ? rhs - lhs : lhs - rhs) < e} { }
    [[nodiscard]] constexpr explicit operator bool() const { return result; }
    constexpr friend auto operator<<(auto& os, const epsilon& expr) -> decltype(auto) { return (os << "(" << expr.lhs << " == " << expr.rhs << ")(" << expr.e <<")"); }
    T lhs; T rhs; T e; bool result{};
  };
  [[nodiscard]] constexpr auto operator()(T e) const { return epsilon{lhs, rhs, e}; }
  T lhs; T rhs;
};
template<class TLhs, class TRhs>
  requires requires(TLhs lhs, TRhs rhs) { lhs[0]; rhs[0]; lhs.size(); rhs.size(); }
struct eq<TLhs, TRhs> {
  static_assert(type_traits::is_same_v<decltype(utility::declval<TLhs>()[0]), decltype(utility::declval<TLhs>()[0])>, "[ERROR] Comparision of different underlying types is not allowed.");
  constexpr eq(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs}, result{
    [](const auto& lhs, const auto& rhs) {
      if (lhs.size() != rhs.size()) { return false; }
      for (decltype(lhs.size()) i{}; i < lhs.size(); ++i) { if (lhs[i] != rhs[i]) { return false; } }
      return true;
    }(lhs, rhs)
  } { }
  constexpr friend auto operator<<(auto& os, const eq& expr) -> decltype(auto) { return (os << expr.lhs << " == " << expr.rhs); }
  [[nodiscard]] constexpr explicit operator bool() const { return result; }
  TLhs lhs; TRhs rhs; bool result{};
};

template<class TLhs, class TRhs> struct neq {
  constexpr neq(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs} { }
  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed.");
  [[nodiscard]] constexpr explicit operator bool() const { return false; }
  const TLhs& lhs; const TRhs& rhs;
};
template<class T> struct neq<T, T> {
  constexpr neq(const T& lhs, const T& rhs) : lhs{lhs}, rhs{rhs}, result{lhs != rhs} { }
  constexpr friend auto operator<<(auto& os, const neq& expr) -> decltype(auto) { return (os << expr.lhs << " != " << expr.rhs); }
  [[nodiscard]] constexpr explicit operator bool() const { return result; }
  T lhs; T rhs; bool result{};
};
template<class T> requires type_traits::is_floating_point_v<T> struct neq<T, T> {
  constexpr neq(const T& lhs, const T& rhs) : lhs{lhs}, rhs{rhs} { }
  constexpr friend auto operator<<(auto& os, const neq& expr) -> decltype(auto) { return (os << expr.lhs << " != " << expr.rhs); }
  [[nodiscard]] constexpr explicit operator bool() const {
    static_assert(!type_traits::is_floating_point_v<T>, "[ERROR] Epsilon is required - `expect((lhs != rhs)(epsilon))`. For example: `expect((4.2_f != sum(4.f, .3f))(.01f))`.");
    return {};
  }
  struct epsilon {
    constexpr epsilon(const T& lhs, const T& rhs, const T e) : lhs{lhs}, rhs{rhs}, e{e}, result{(lhs < rhs ? rhs - lhs : lhs - rhs) >= e} { }
    [[nodiscard]] constexpr explicit operator bool() const { return result; }
    constexpr friend auto operator<<(auto& os, const epsilon& expr) -> decltype(auto) { return (os << "(" << expr.lhs << " != " << expr.rhs << ")(" << expr.e <<")"); }
    T lhs; T rhs; T e; bool result{};
  };
  [[nodiscard]] constexpr auto operator()(T e) const { return epsilon{lhs, rhs, e}; }
  T lhs; T rhs;
};

template<class TLhs, class TRhs> struct gt {
  constexpr gt(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs} { }
  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed.");
  [[nodiscard]] constexpr explicit operator bool() const { return false; }
  const TLhs& lhs; const TLhs& rhs;
};
template<class T> struct gt<T, T> {
  constexpr gt(const T& lhs, const T& rhs) : lhs{lhs}, rhs{rhs}, result{lhs > rhs} { }
  constexpr friend auto operator<<(auto& os, const gt& expr) -> decltype(auto) { return (os << expr.lhs << " > " << expr.rhs); }
  [[nodiscard]] constexpr explicit operator bool() const { return result; }
  T lhs; T rhs; bool result{};
};

template<class TLhs, class TRhs> struct ge {
  constexpr ge(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs} { }
  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed.");
  [[nodiscard]] constexpr explicit operator bool() const { return false; }
  const TLhs& lhs; const TLhs& rhs;
};
template<class T> struct ge<T, T> {
  constexpr ge(const T& lhs, const T& rhs) : lhs{lhs}, rhs{rhs}, result{lhs >= rhs} { }
  constexpr friend auto operator<<(auto& os, const ge& expr) -> decltype(auto) { return (os << expr.lhs << " >= " << expr.rhs); }
  [[nodiscard]] constexpr explicit operator bool() const { return result; }
  T lhs; T rhs; bool result{};
};

template<class TLhs, class TRhs> struct lt {
  constexpr lt(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs} { }
  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed.");
  [[nodiscard]] constexpr explicit operator bool() const { return false; }
  const TLhs& lhs; const TLhs& rhs;
};
template<class T> struct lt<T, T> {
  constexpr lt(const T& lhs, const T& rhs) : lhs{lhs}, rhs{rhs}, result{lhs < rhs} { }
  constexpr friend auto operator<<(auto& os, const lt& expr) -> decltype(auto) { return (os << expr.lhs << " < " << expr.rhs); }
  [[nodiscard]] constexpr explicit operator bool() const { return result; }
  T lhs; T rhs; bool result{};
};

template<class TLhs, class TRhs> struct le {
  constexpr le(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs} { }
  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed.");
  [[nodiscard]] constexpr explicit operator bool() const { return false; }
  const TLhs& lhs; const TLhs& rhs;
};
template<class T> struct le<T, T> {
  constexpr le(const T& lhs, const T& rhs) : lhs{lhs}, rhs{rhs}, result{lhs <= rhs} { }
  constexpr friend auto operator<<(auto& os, const le& expr) -> decltype(auto) { return (os << expr.lhs << " <= " << expr.rhs); }
  [[nodiscard]] constexpr explicit operator bool() const { return result; }
  T lhs; T rhs; bool result{};
};

template<class T> struct nt {
  constexpr nt(const T& t) : t{t}, result{!t} { }
  constexpr friend auto operator<<(auto& os, const nt& expr) -> decltype(auto) { return (os << "!" << expr.t); }
  [[nodiscard]] constexpr explicit operator bool() const { return result; }
  T t; bool result{};
};

namespace detail {
constexpr decltype(auto) get(const auto& t) {
  if constexpr (requires { t.VALUE; }) { return t.VALUE; } else { return t; }
}
} // namespace detail

inline namespace dsl {
[[nodiscard]] constexpr auto operator==(const auto& lhs, const auto& rhs) requires (requires { lhs.VALUE; } || requires { rhs.VALUE; }) {
  return eq{detail::get(lhs), detail::get(rhs)};
}
[[nodiscard]] constexpr auto operator!=(const auto& lhs, const auto& rhs) requires (requires { lhs.VALUE; } || requires { rhs.VALUE; }) {
  return neq{detail::get(lhs), detail::get(rhs)};
}
[[nodiscard]] constexpr auto operator>(const auto& lhs, const auto& rhs) requires (requires { lhs.VALUE; } || requires { rhs.VALUE; }) {
  return gt{detail::get(lhs), detail::get(rhs)};
}
[[nodiscard]] constexpr auto operator>=(const auto& lhs, const auto& rhs) requires (requires { lhs.VALUE; } || requires { rhs.VALUE; }) {
  return ge{detail::get(lhs), detail::get(rhs)};
}
[[nodiscard]] constexpr auto operator<(const auto& lhs, const auto& rhs) requires (requires { lhs.VALUE; } || requires { rhs.VALUE; }) {
  return lt{detail::get(lhs), detail::get(rhs)};
}
[[nodiscard]] constexpr auto operator<=(const auto& lhs, const auto& rhs) requires (requires { lhs.VALUE; } || requires { rhs.VALUE; }) {
  return le{detail::get(lhs), detail::get(rhs)};
}
template<class T> [[nodiscard]] constexpr auto operator!(const T& t) requires requires { t.VALUE; } {
  return T{!t.VALUE};
}

struct _b { bool VALUE; };
inline constexpr auto true_b = _b{true};
inline constexpr auto false_b = _b{false};
struct _c { char VALUE{}; };
struct _sc { signed char VALUE{}; };
struct _s { short VALUE{}; constexpr auto operator-() const { return _s(-VALUE); } };
struct _i { int VALUE{}; constexpr auto operator-() const { return _i(-VALUE); } };
struct _l { long VALUE{}; constexpr auto operator-() const { return _l(-VALUE); } };
struct _ll { long long VALUE{}; constexpr auto operator-() const { return _ll(-VALUE); } };
struct _u { unsigned VALUE{}; };
struct _uc { unsigned char VALUE{}; };
struct _us { unsigned short VALUE{}; };
struct _ul { unsigned long VALUE{}; };
struct _ull { unsigned long long VALUE{}; };
struct _f { float VALUE{}; constexpr auto operator-() const { return _f(-VALUE); } };
struct _d { double VALUE{}; constexpr auto operator-() const { return _d(-VALUE); } };
struct _ld { long double VALUE{}; constexpr auto operator-() const { return _ld(-VALUE); } };
struct _i8 { __INT8_TYPE__ VALUE{}; constexpr auto operator-() const { return _i8(-VALUE); } };
struct _i16 { __INT16_TYPE__ VALUE{}; constexpr auto operator-() const { return _i16(-VALUE); } };
struct _i32 { __INT32_TYPE__ VALUE{}; constexpr auto operator-() const { return _i32(-VALUE); } };
struct _i64 { __INT64_TYPE__ VALUE{}; constexpr auto operator-() const { return _i64(-VALUE); } };
struct _u8 { __UINT8_TYPE__ VALUE{}; };
struct _u16 { __UINT16_TYPE__ VALUE{}; };
struct _u32 { __UINT32_TYPE__ VALUE{}; };
struct _u64 { __UINT64_TYPE__ VALUE{}; };
struct _string {
  struct view {
    [[nodiscard]] constexpr auto operator[](auto i) const { return data_[i]; }
    [[nodiscard]] constexpr auto size() const { return size_; }
    constexpr friend auto operator<<(auto& os, const view& v) -> decltype(auto) { return (os << v.data_); }
    [[nodiscard]] constexpr auto operator==(const view& other) const -> bool {
      if (size() != other.size()) { return false; }
      for (decltype(size()) i{}; i < size(); ++i) { if ((*this)[i] != other[i]) { return false; } }
      return true;
    }
    const char* data_{}; unsigned size_{};
  } VALUE{};
};

[[nodiscard]] constexpr auto operator""_i(unsigned long long int value) { return _i(value); }
[[nodiscard]] constexpr auto operator""_s(unsigned long long int value) { return _s(value); }
[[nodiscard]] constexpr auto operator""_c(unsigned long long int value) { return _c(value); }
[[nodiscard]] constexpr auto operator""_sc(unsigned long long int value) { return _sc(value); }
[[nodiscard]] constexpr auto operator""_l(unsigned long long int value) { return _l(value); }
[[nodiscard]] constexpr auto operator""_ll(unsigned long long int value) { return _ll(value); }
[[nodiscard]] constexpr auto operator""_u(unsigned long long int value) { return _u(value); }
[[nodiscard]] constexpr auto operator""_uc(unsigned long long int value) { return _uc(value); }
[[nodiscard]] constexpr auto operator""_us(unsigned long long int value) { return _us(value); }
[[nodiscard]] constexpr auto operator""_ul(unsigned long long int value) { return _ul(value); }
[[nodiscard]] constexpr auto operator""_ull(unsigned long long int value) { return _ull(value); }
[[nodiscard]] constexpr auto operator""_f(long double value) { return _f(value); }
[[nodiscard]] constexpr auto operator""_d(long double value) { return _d(value); }
[[nodiscard]] constexpr auto operator""_ld(long double value) { return _ld(value); }
[[nodiscard]] constexpr auto operator""_i8(unsigned long long int value) { return _i8(value); }
[[nodiscard]] constexpr auto operator""_i16(unsigned long long int value) { return _i16(value); }
[[nodiscard]] constexpr auto operator""_i32(unsigned long long int value) { return _i32(value); }
[[nodiscard]] constexpr auto operator""_i64(unsigned long long int value) { return _i64(value); }
[[nodiscard]] constexpr auto operator""_u8(unsigned long long int value) { return _u8(value); }
[[nodiscard]] constexpr auto operator""_u16(unsigned long long int value) { return _u16(value); }
[[nodiscard]] constexpr auto operator""_u32(unsigned long long int value) { return _u32(value); }
[[nodiscard]] constexpr auto operator""_u64(unsigned long long int value) { return _u64(value); }
template<utility::fixed_string Str> [[nodiscard]] constexpr auto operator""_s() { return _string{Str.data(), Str.size()-1u}; }
} // namespace dsl
} // namespace ut

using ut::operator""_test;

#ifndef NTEST
static_assert(([] {
  // ut::type_traits::is_same_v
  {
    static_assert(!ut::type_traits::is_same_v<int, void>);
    static_assert(!ut::type_traits::is_same_v<void, int>);
    static_assert(!ut::type_traits::is_same_v<void*, int>);
    static_assert(!ut::type_traits::is_same_v<int, const int>);
    static_assert(ut::type_traits::is_same_v<void, void>);
    static_assert(ut::type_traits::is_same_v<int, int>);
  }

  // ut::type_traits::is_mutable_lambda_v
  {
    auto l1 = []() { };
    auto l2 = []() constexpr { };
    auto l3 = []() mutable { };
    auto l4 = []() mutable constexpr { };
    static_assert(!ut::type_traits::is_mutable_lambda_v<decltype(&decltype(l1)::operator())>);
    static_assert(!ut::type_traits::is_mutable_lambda_v<decltype(&decltype(l2)::operator())>);
    static_assert(ut::type_traits::is_mutable_lambda_v<decltype(&decltype(l3)::operator())>);
    static_assert(ut::type_traits::is_mutable_lambda_v<decltype(&decltype(l4)::operator())>);
  }

  // ut::type_traits::has_capture_lambda_v
  {
    int i{};
    auto l1 = []() { return 42; };
    auto l2 = []() constexpr { return 42; };
    auto l3 = []() mutable { return 42; };
    auto l4 = [&i]() constexpr { return i; };
    auto l5 = [i]() mutable { return i; };
    auto l6 = [=]() mutable constexpr { return i; };
    static_assert(!ut::type_traits::has_capture_lambda_v<decltype(l1)>);
    static_assert(!ut::type_traits::has_capture_lambda_v<decltype(l2)>);
    static_assert(!ut::type_traits::has_capture_lambda_v<decltype(l3)>);
    static_assert(ut::type_traits::has_capture_lambda_v<decltype(l4)>);
    static_assert(ut::type_traits::has_capture_lambda_v<decltype(l5)>);
    static_assert(ut::type_traits::has_capture_lambda_v<decltype(l6)>);
  }

  {
    static_assert(!ut::type_traits::is_floating_point_v<int>);
    static_assert(!ut::type_traits::is_floating_point_v<bool>);
    static_assert(!ut::type_traits::is_floating_point_v<char>);
    static_assert(!ut::type_traits::is_floating_point_v<void>);
    static_assert(ut::type_traits::is_floating_point_v<float>);
    static_assert(ut::type_traits::is_floating_point_v<double>);
    static_assert(ut::type_traits::is_floating_point_v<long double>);
  }

  // ut::utility::fixed_string
  {
    static_assert(sizeof("") == ut::utility::fixed_string{""}.size());
    static_assert(sizeof("foo") == ut::utility::fixed_string{"foo"}.size());
    static_assert('f' == ut::utility::fixed_string{"foo"}[0]);
    static_assert('o' == ut::utility::fixed_string{"foo"}[1]);
    static_assert('o' == ut::utility::fixed_string{"foo"}[2]);
    static_assert('\0' == ut::utility::fixed_string{"foo"}[3]);
  }

  // utility::match
  {
    static_assert(ut::utility::match("", ""));
    static_assert(not ut::utility::match("", "foo"));
    static_assert(ut::utility::match("*", ""));
    static_assert(ut::utility::match("*", "foo"));
    static_assert(ut::utility::match("*", "bar"));
    static_assert(ut::utility::match("foo", "foo"));
    static_assert(not ut::utility::match("foo", "bar"));
    static_assert(not ut::utility::match("fo", "foo"));
    static_assert(ut::utility::match("foo*", "foo"));
    static_assert(ut::utility::match("foo*", "foo1"));
    static_assert(ut::utility::match("foo*", "foo2"));
    static_assert(ut::utility::match("foo*", "foo23"));
    static_assert(ut::utility::match("foo?", "foo2"));
    static_assert(ut::utility::match("foo?", "foo1"));
    static_assert(ut::utility::match("foo??", "foo12"));
    static_assert(ut::utility::match("foo?x", "foo1x"));
    static_assert(ut::utility::match("foo?x", "foo2x"));
    static_assert(not ut::utility::match("fo?xx", "fooxxx"));
  }

  // ut::detail::get
  {
    static_assert(42 == ut::detail::get(42));
    static_assert(42u == ut::detail::get(ut::_u(42)));
  }

  // ut::eq
  {
    using namespace ut;
    static_assert(eq(42, 42));
    static_assert(!eq(43, 42));
    static_assert(!eq(42, 43));

    static_assert((eq(4.2, 4.2))(.1));
    static_assert((eq(4.24, 4.23))(.01));
    static_assert(!(eq(4.24, 4.23))(.001));

    static_assert(eq("foo"_s, "foo"_s));
    static_assert(!eq("foo"_s, "bar"_s));
    static_assert(!eq(""_s, "foo"_s));
    static_assert(!eq("bar"_s, ""_s));
  }

  // ut::neq
  {
    using namespace ut;
    static_assert(neq(42, 43));
    static_assert(neq(43, 42));
    static_assert(!neq(42, 42));

    static_assert(!(neq(4.2, 4.2))(.1));
    static_assert(!(neq(4.24, 4.23))(.01));
    static_assert((neq(4.24, 4.23))(.001));
  }

  // ut::gt
  {
    using namespace ut;
    static_assert(gt(43, 42));
    static_assert(!gt(42, 43));
    static_assert(!gt(42, 42));
  }

  // ut::ge
  {
    using namespace ut;
    static_assert(ge(43, 42));
    static_assert(ge(43, 43));
    static_assert(!ge(42, 43));
  }

  // ut::lt
  {
    using namespace ut;
    static_assert(lt(42, 43));
    static_assert(!lt(43, 42));
    static_assert(!lt(42, 42));
  }

  // ut::le
  {
    using namespace ut;
    static_assert(le(42, 43));
    static_assert(le(42, 42));
    static_assert(!le(43, 42));
  }

  // ut::nt
  {
    using namespace ut;
    static_assert(nt(false));
    static_assert(!nt(true));
  }

  using sc = signed char;
  using uc = unsigned char;
  using ul = unsigned long;
  using us = unsigned short;
  using ull = unsigned long long;
  using ll = long long;
  using ld = long double;

  // ut::_
  {
    using namespace ut;

    static_assert(_b{true}.VALUE);
    static_assert(!_b{false}.VALUE);
    static_assert(true_b.VALUE);
    static_assert(!false_b.VALUE);
    static_assert(char('0') == _c{'0'}.VALUE);
    static_assert(sc(42) == _sc{42}.VALUE);
    static_assert(short(-42) == -_s{42}.VALUE);
    static_assert(int(-42) == -_i{42}.VALUE);
    static_assert(long(-42) == -_l{42}.VALUE);
    static_assert(ll(-42) == -_ll{42}.VALUE);
    static_assert(unsigned(42) == _u{42}.VALUE);
    static_assert(uc(42) == _uc{42}.VALUE);
    static_assert(us(42) == _us{42}.VALUE);
    static_assert(ul(42) == _ul{42}.VALUE);
    static_assert(ull(42) == _ull{42}.VALUE);
    static_assert(-_f{4.2}.VALUE < float(0));
    static_assert(-_d{4.2}.VALUE < double(0));
    static_assert(-_ld{4.2}.VALUE < ld(0));

    static_assert((__INT8_TYPE__)(-42) == -_i8{42}.VALUE);
    static_assert((__INT16_TYPE__)(-42) == -_i16{42}.VALUE);
    static_assert((__INT32_TYPE__)(-42) == -_i32{42}.VALUE);
    static_assert((__INT64_TYPE__)(-42) == -_i64{42}.VALUE);
    static_assert((__UINT8_TYPE__)(42) == _u8{42}.VALUE);
    static_assert((__UINT16_TYPE__)(42) == _u16{42}.VALUE);
    static_assert((__UINT32_TYPE__)(42) == _u32{42}.VALUE);
    static_assert((__UINT64_TYPE__)(42) == _u64{42}.VALUE);

    static_assert(sizeof("foo") == _string::view{"foo", sizeof("foo")}.size());
    static_assert('f' == _string::view{"foo", sizeof("foo")}[0]);
    static_assert('o' == _string::view{"foo", sizeof("foo")}[1]);
    static_assert('o' == _string::view{"foo", sizeof("foo")}[2]);
  }

  // ut::operator
  {
    using namespace ut;
    static_assert(int(-42) == -42_i);
    static_assert(short(-42) == -42_s);
    static_assert(char(0xA) == 0xA_c);
    static_assert(sc(0xA) == 0xA_sc);
    static_assert(long(-42) == -42_l);
    static_assert(ll(-42) == -42_ll);
    static_assert(unsigned(42) == 42_u);
    static_assert(uc(42) == 42_uc);
    static_assert(us(42) == 42_us);
    static_assert(ul(42) == 42_ul);
    static_assert(ull(42) == 42_ull);
    static_assert(-4.2_f < float(0));
    static_assert(-4.2_d < double(0));
    static_assert(-4.2_ld < ld(0));
    static_assert((-4.2f == -4.2_f)(.1));
    static_assert((.1234f == .1234_f)(.0001));
    static_assert((.13f == .12_f)(.1));
    static_assert(!(.13f == .12_f)(.001));
    static_assert((-9.12345678 == -9.12345678_d)(.00001));

    static_assert((__INT8_TYPE__)(-42) == -42_i8);
    static_assert((__INT16_TYPE__)(-42) == -42_i16);
    static_assert((__INT32_TYPE__)(-42) == -42_i32);
    static_assert((__INT64_TYPE__)(-42) == -42_i64);
    static_assert((__UINT8_TYPE__)(42) == 42_u8);
    static_assert((__UINT16_TYPE__)(42) == 42_u16);
    static_assert((__UINT32_TYPE__)(42) == 42_u32);
    static_assert((__UINT64_TYPE__)(42) == 42_u64);

    static_assert(sizeof("")-1u == ""_s.VALUE.size());
    static_assert(sizeof("foo")-1u == "foo"_s.VALUE.size());
    static_assert('f' == "foo"_s.VALUE[0]);
    static_assert('o' == "foo"_s.VALUE[1]);
    static_assert('o' == "foo"_s.VALUE[2]);
  }

  // ut::constant
  {
    using namespace ut;
    static_assert(constant<42 == 42>);
    static_assert(constant<42 == 42_i>);
    static_assert(constant<42_i == 42>);
  }

  // ut::mut
  {
    static_assert(43 == [] {
      using namespace ut;
      auto i = 42;
      return [=] { mut(i) = 43; return i; }();
    }());
  }
}(), true));
#endif // NTEST