| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <functional> |
| |
| #include <lib/fit/function.h> |
| #include <lib/fit/function_traits.h> |
| #include <unittest/unittest.h> |
| |
| namespace { |
| |
| template <typename Callable, typename... Args> |
| void invoke_with_defaults(Callable c, fit::parameter_pack<Args...>) { |
| c(Args()...); |
| } |
| |
| template <typename Callable> |
| void invoke_with_defaults(Callable c) { |
| invoke_with_defaults(std::move(c), typename fit::function_traits<Callable>::args{}); |
| } |
| |
| bool arg_capture() { |
| BEGIN_TEST; |
| |
| int i = 0; |
| invoke_with_defaults([&] { i = 42; }); |
| EXPECT_EQ(42, i); |
| invoke_with_defaults([&](int, float) { i = 54; }); |
| EXPECT_EQ(54, i); |
| |
| END_TEST; |
| } |
| |
| // Performs static assertions against a function-like type of signature int(float, bool). |
| template <typename Callable> |
| struct TraitsTest { |
| using Traits = fit::function_traits<Callable>; |
| |
| static_assert(std::is_same_v<int(float, bool), typename Traits::signature>); |
| static_assert(std::is_same_v<int, typename Traits::return_type>); |
| static_assert(2 == Traits::args::size); |
| static_assert(std::is_same_v<float, typename Traits::args::template at<0>>); |
| static_assert(std::is_same_v<bool, typename Traits::args::template at<1>>); |
| }; |
| |
| // compile-time test |
| namespace signature_traits { |
| using Traits = TraitsTest<int(float, bool)>::Traits; |
| } // namespace signature_traits |
| |
| // compile-time test |
| namespace function_pointer_traits { |
| using Traits = TraitsTest<int (*)(float, bool)>::Traits; |
| static_assert(std::is_same_v<int (*)(float, bool), Traits::type>); |
| } // namespace function_pointer_traits |
| |
| // compile-time test |
| namespace lambda_traits { |
| auto lambda = [](float, bool) { return 0; }; |
| using Traits = TraitsTest<decltype(lambda)>::Traits; |
| } // namespace lambda_traits |
| |
| template <typename Functor> |
| struct FunctorTraitsTest { |
| using Traits = typename TraitsTest<Functor>::Traits; |
| static_assert(std::is_same_v<Functor, typename Traits::type>); |
| }; |
| |
| // compile-time test |
| namespace mutable_functor_traits { |
| struct MutableFunctor { |
| int operator()(float, bool) { return 0; } |
| }; |
| using Traits = FunctorTraitsTest<MutableFunctor>::Traits; |
| } // namespace mutable_functor_traits |
| |
| // compile-time test |
| namespace fit_function_traits { |
| using Traits = FunctorTraitsTest<fit::function<int(float, bool)>>; |
| } // namespace fit_function_traits |
| |
| // compile-time test |
| namespace std_function_traits { |
| using Traits = FunctorTraitsTest<std::function<int(float, bool)>>; |
| } // namespace std_function_traits |
| |
| } // namespace |
| |
| BEGIN_TEST_CASE(function_traits_tests) |
| RUN_TEST(arg_capture) |
| // suppress -Wunneeded-internal-declaration |
| (void)lambda_traits::lambda; |
| END_TEST_CASE(function_traits_tests) |