based

0 // #define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE

1

2 #include "based/concept/callable.hpp"

3

4 #include <catch2/catch_test_macros.hpp>

5

6 #include "based/concept/is_same.hpp"

7

8 namespace

9 {

10

11 // NOLINTNEXTLINE(*need*)

12 int free_func(int a, double b)

13 {

14 return static_cast<int>(a + b);

15 }

16

17 } // namespace

18

19 using based::trait::IsSame;

20

21 TEST_CASE("free function", "[concept/IsCallable]")

22 {

23 using TypeT = decltype(free_func);

24

25 STATIC_REQUIRE(based::trait::IsCallable<TypeT>);

26 STATIC_REQUIRE(IsSame<based::trait::CallableSigT<TypeT>, int(int, double)>);

27 STATIC_REQUIRE(IsSame<based::trait::CallableRetT<TypeT>, int>);

28 }

29

30 TEST_CASE("lambda", "[concept/IsCallable]")

31 {

32 const auto func = [](int a, double b)

33 {

34 return static_cast<int>(a + b);

35 };

36 using TypeT = decltype(func);

37

38 STATIC_REQUIRE(based::trait::IsCallable<TypeT>);

39 STATIC_REQUIRE(IsSame<based::trait::CallableSigT<TypeT>, int(int, double)>);

40 STATIC_REQUIRE(IsSame<based::trait::CallableRetT<TypeT>, int>);

41 }

42

43 struct Func

44 {

45 auto operator()(auto a, auto b) { return static_cast<int>(a + b); }

46 };

47

48 /*

49 TEST_CASE("member function", "[concept/IsCallable]")

50 {

51 // [&](auto&&... args) -> decltype(auto) { return

52 // f(based::forward<decltype(args)>(args)...); }

53

54 // based::error_template<decltype(&func::template operator()<int, double>)>();

55 STATIC_REQUIRE(based::IsCallable<Func>);

56 STATIC_REQUIRE(IsSame<based::CallableSigT<Func>, int(int, double)>);

57 STATIC_REQUIRE(IsSame<based::CallableRetT<Func>, int>);

58 }

59 */