media/utils/tests/inplace_function_tests.cpp - LeafOS-Project/android_frameworks_av - Gitiles

 /*
  * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "inplace_function_tests"

 #include <mediautils/InPlaceFunction.h>

 #include <type_traits>

 #include <gtest/gtest.h>
 #include <log/log.h>

 using namespace android;
 using namespace android::mediautils;

 struct BigCallable {
     BigCallable(size_t* x, size_t val1, size_t val2) : ptr(x), a(val1), b(val2) {}
     size_t* ptr;
     size_t a;
     size_t b;
     size_t operator()(size_t input) const {
         *ptr += a * 100 + b * 10 + input;
         return 8;
     }
 };

 TEST(InPlaceFunctionTests, Basic) {
     size_t x = 5;
     InPlaceFunction<size_t(size_t)> func;
     {
         BigCallable test{&x, 2, 3};
         func = test;
     }
     EXPECT_EQ(func(2), 8ull);
     EXPECT_EQ(x, 232ull + 5);
 }

 TEST(InPlaceFunctionTests, Invalid) {
     InPlaceFunction<size_t(size_t)> func;
     EXPECT_TRUE(!func);
     InPlaceFunction<size_t(size_t)> func2{nullptr};
     EXPECT_TRUE(!func2);
     InPlaceFunction<size_t(size_t)> func3 = [](size_t x) { return x; };
     EXPECT_TRUE(!(!func3));
     func3 = nullptr;
     EXPECT_TRUE(!func3);
 }

 TEST(InPlaceFunctionTests, MultiArg) {
     InPlaceFunction<size_t(size_t, size_t, size_t)> func = [](size_t a, size_t b, size_t c) {
         return a + b + c;
     };
     EXPECT_EQ(func(2, 3, 5), 2ull + 3 + 5);
 }
 struct Record {
     Record(size_t m, size_t c, size_t d) : move_called(m), copy_called(c), dtor_called(d) {}
     Record() {}
     size_t move_called = 0;
     size_t copy_called = 0;
     size_t dtor_called = 0;
     friend std::ostream& operator<<(std::ostream& os, const Record& record) {
         return os << "Record, moves: " << record.move_called << ", copies: " << record.copy_called
                   << ", dtor: " << record.dtor_called << '\n';
     }
 };

 bool operator==(const Record& lhs, const Record& rhs) {
     return lhs.move_called == rhs.move_called && lhs.copy_called == rhs.copy_called &&
            lhs.dtor_called == rhs.dtor_called;
 }

 struct Noisy {
     Record& ref;
     size_t state;
     Noisy(Record& record, size_t val) : ref(record), state(val) {}
     Noisy(const Noisy& other) : ref(other.ref), state(other.state) { ref.copy_called++; }

     Noisy(Noisy&& other) : ref(other.ref), state(other.state) { ref.move_called++; }
     ~Noisy() { ref.dtor_called++; }

     size_t operator()() { return state; }
 };

 TEST(InPlaceFunctionTests, CtorForwarding) {
     Record record;
     Noisy noisy{record, 17};
     InPlaceFunction<size_t()> func{noisy};
     EXPECT_EQ(record, Record(0, 1, 0));  // move, copy, dtor
     EXPECT_EQ(func(), 17ull);
     Record record2;
     Noisy noisy2{record2, 13};
     InPlaceFunction<size_t()> func2{std::move(noisy2)};
     EXPECT_EQ(record2, Record(1, 0, 0));  // move, copy, dtor
     EXPECT_EQ(func2(), 13ull);
 }

 TEST(InPlaceFunctionTests, FunctionCtorForwarding) {
     {
         Record record;
         Noisy noisy{record, 17};
         InPlaceFunction<size_t()> func{noisy};
         EXPECT_EQ(record, Record(0, 1, 0));  // move, copy, dtor
         EXPECT_EQ(func(), 17ull);
         InPlaceFunction<size_t()> func2{func};
         EXPECT_EQ(record, Record(0, 2, 0));  // move, copy, dtor
         EXPECT_EQ(func2(), 17ull);
     }
     Record record;
     Noisy noisy{record, 13};
     InPlaceFunction<size_t()> func{noisy};
     EXPECT_EQ(record, Record(0, 1, 0));  // move, copy, dtor
     EXPECT_EQ(func(), 13ull);
     InPlaceFunction<size_t()> func2{std::move(func)};
     EXPECT_EQ(record, Record(1, 1, 0));  // move, copy, dtor
     EXPECT_EQ(func2(), 13ull);
     // We expect moved from functions to still be valid
     EXPECT_TRUE(!(!func));
     EXPECT_EQ(static_cast<bool>(func), static_cast<bool>(func2));
     EXPECT_EQ(func(), 13ull);
 }

 TEST(InPlaceFunctionTests, Dtor) {
     Record record;
     {
         InPlaceFunction<size_t()> func;
         {
             Noisy noisy{record, 17};
             func = noisy;
         }
         EXPECT_EQ(func(), 17ull);
         EXPECT_EQ(record.dtor_called, 1ull);
     }
     EXPECT_EQ(record.dtor_called, 2ull);
 }

 TEST(InPlaceFunctionTests, Assignment) {
     {
         Record record;
         Record record2;
         Noisy noisy{record, 17};
         Noisy noisy2{record2, 5};
         InPlaceFunction<size_t()> func{noisy};
         EXPECT_EQ(func(), 17ull);
         EXPECT_EQ(record.dtor_called, 0ull);
         func = noisy2;
         EXPECT_EQ(record.dtor_called, 1ull);
         EXPECT_EQ(record2, Record(0, 1, 0));  // move, copy, dtor
         EXPECT_EQ(func(), 5ull);
     }
     {
         Record record;
         Record record2;
         Noisy noisy{record, 17};
         Noisy noisy2{record2, 5};
         InPlaceFunction<size_t()> func{noisy};
         EXPECT_EQ(func(), 17ull);
         EXPECT_EQ(record.dtor_called, 0ull);
         func = std::move(noisy2);
         EXPECT_EQ(record.dtor_called, 1ull);
         EXPECT_EQ(record2, Record(1, 0, 0));  // move, copy, dtor
         EXPECT_EQ(func(), 5ull);
     }

     {
         Record record;
         Record record2;
         Noisy noisy{record, 17};
         Noisy noisy2{record2, 13};
         {
             InPlaceFunction<size_t()> func{noisy};
             EXPECT_EQ(func(), 17ull);
             InPlaceFunction<size_t()> func2{noisy2};
             EXPECT_EQ(record2, Record(0, 1, 0));  // move, copy, dtor
             EXPECT_EQ(record.dtor_called, 0ull);
             func = func2;
             EXPECT_EQ(record.dtor_called, 1ull);
             EXPECT_EQ(func(), 13ull);
             EXPECT_EQ(record2, Record(0, 2, 0));  // move, copy, dtor
             EXPECT_TRUE(static_cast<bool>(func2));
             EXPECT_EQ(func2(), 13ull);
         }
         EXPECT_EQ(record2, Record(0, 2, 2));  // move, copy, dtor
     }

     {
         Record record;
         Record record2;
         Noisy noisy{record, 17};
         Noisy noisy2{record2, 13};
         {
             InPlaceFunction<size_t()> func{noisy};
             EXPECT_EQ(func(), 17ull);
             InPlaceFunction<size_t()> func2{noisy2};
             EXPECT_EQ(record.dtor_called, 0ull);
             EXPECT_EQ(record2, Record(0, 1, 0));  // move, copy, dtor
             func = std::move(func2);
             EXPECT_EQ(record.dtor_called, 1ull);
             EXPECT_EQ(func(), 13ull);
             EXPECT_EQ(record2, Record(1, 1, 0));  // move, copy, dtor
             // Moved from function is still valid
             EXPECT_TRUE(static_cast<bool>(func2));
             EXPECT_EQ(func2(), 13ull);
         }
         EXPECT_EQ(record2, Record(1, 1, 2));  // move, copy, dtor
     }
 }

 TEST(InPlaceFunctionTests, Swap) {
     Record record1;
     Record record2;
     InPlaceFunction<size_t()> func1 = Noisy{record1, 5};
     InPlaceFunction<size_t()> func2 = Noisy{record2, 7};
     EXPECT_EQ(record1, Record(1, 0, 1));  // move, copy, dtor
     EXPECT_EQ(record2, Record(1, 0, 1));  // move, copy, dtor
     EXPECT_EQ(func1(), 5ull);
     EXPECT_EQ(func2(), 7ull);
     func1.swap(func2);
     EXPECT_EQ(record1, Record(2, 0, 2));  // move, copy, dtor
     // An additional move and destroy into the temporary object
     EXPECT_EQ(record2, Record(3, 0, 3));  // move, copy, dtor
     EXPECT_EQ(func1(), 7ull);
     EXPECT_EQ(func2(), 5ull);
 }

 TEST(InPlaceFunctionTests, Conversion) {
     Record record;
     Noisy noisy{record, 15};
     {
         InPlaceFunction<size_t(), 16> func2 = noisy;
         EXPECT_EQ(record, Record(0, 1, 0));  // move, copy, dtor
         {
             InPlaceFunction<size_t(), 32> func{func2};
             EXPECT_EQ(record, Record(0, 2, 0));  // move, copy, dtor
             EXPECT_EQ(func2(), func());
         }
         EXPECT_EQ(record, Record(0, 2, 1));  // move, copy, dtor
     }
     EXPECT_EQ(record, Record(0, 2, 2));  // move, copy, dtor
 }

 TEST(InPlaceFunctionTests, ConversionMove) {
     Record record;
     Noisy noisy{record, 15};
     {
         InPlaceFunction<size_t(), 16> func2 = noisy;
         EXPECT_EQ(record, Record(0, 1, 0));  // move, copy, dtor
         {
             InPlaceFunction<size_t(), 32> func{std::move(func2)};
             EXPECT_EQ(record, Record(1, 1, 0));  // move, copy, dtor
             EXPECT_EQ(func2(), func());
         }
         EXPECT_EQ(record, Record(1, 1, 1));  // move, copy, dtor
     }
     EXPECT_EQ(record, Record(1, 1, 2));  // move, copy, dtor
 }

 TEST(InPlaceFunctionTests, ConversionAssign) {
     Record record;
     Noisy noisy{record, 15};
     {
         InPlaceFunction<size_t(), 32> func;
         {
             InPlaceFunction<size_t(), 16> func2 = noisy;
             EXPECT_EQ(record, Record(0, 1, 0));  // move, copy, dtor
             func = func2;
             EXPECT_EQ(record, Record(0, 2, 0));  // move, copy, dtor
             EXPECT_EQ(func2(), func());
         }
         EXPECT_EQ(record, Record(0, 2, 1));  // move, copy, dtor
     }
     EXPECT_EQ(record, Record(0, 2, 2));  // move, copy, dtor
 }

 TEST(InPlaceFunctionTests, ConversionAssignMove) {
     Record record;
     Noisy noisy{record, 15};
     {
         InPlaceFunction<size_t(), 32> func;
         {
             InPlaceFunction<size_t(), 16> func2 = noisy;
             EXPECT_EQ(record, Record(0, 1, 0));  // move, copy, dtor
             func = std::move(func2);
             EXPECT_EQ(record, Record(1, 1, 0));  // move, copy, dtor
             EXPECT_EQ(func2(), func());
         }
         EXPECT_EQ(record, Record(1, 1, 1));  // move, copy, dtor
     }
     EXPECT_EQ(record, Record(1, 1, 2));  // move, copy, dtor
 }

 struct NoMoveCopy {
     NoMoveCopy() = default;
     NoMoveCopy(const NoMoveCopy&) = delete;
     NoMoveCopy(NoMoveCopy&&) = delete;
 };
 struct TestCallable {
     NoMoveCopy& operator()(NoMoveCopy& x) { return x; }
 };

 TEST(InPlaceFunctionTests, ArgumentForwarding) {
     const auto lambd = [](NoMoveCopy& x) -> NoMoveCopy& { return x; };
     InPlaceFunction<NoMoveCopy&(NoMoveCopy&)> func = lambd;
     const auto lambd2 = [](NoMoveCopy&& x) -> NoMoveCopy&& { return std::move(x); };
     InPlaceFunction<NoMoveCopy && (NoMoveCopy &&)> func2 = lambd2;
     auto lvalue = NoMoveCopy{};
     func(lvalue);
     func2(NoMoveCopy{});
     InPlaceFunction<void(NoMoveCopy&)> func3 = [](const NoMoveCopy&) {};
     func3(lvalue);
     InPlaceFunction<void(NoMoveCopy &&)> func4 = [](const NoMoveCopy&) {};
     func4(std::move(lvalue));
     InPlaceFunction<void(const NoMoveCopy&)> func5 = [](const NoMoveCopy&) {};
     func5(lvalue);
     InPlaceFunction<void(const NoMoveCopy&&)> func6 = [](const NoMoveCopy&) {};
     func6(std::move(lvalue));
     InPlaceFunction<void(const NoMoveCopy&&)> func7 = [](const NoMoveCopy&&) {};
     func7(std::move(lvalue));
     InPlaceFunction<void(NoMoveCopy &&)> func8 = [](const NoMoveCopy&&) {};
     func8(std::move(lvalue));

     {
         Record record;
         Noisy noisy{record, 5};
         const auto lambd3 = [](Noisy) {};
         InPlaceFunction<void(Noisy)> func3{lambd3};
         EXPECT_EQ(record, Record(0, 0, 0));  // move, copy, dtor
         func3(std::move(noisy));
         EXPECT_EQ(record, Record(2, 0, 2));  // move, copy, dtor
     }

     {
         Record record;
         Noisy noisy{record, 5};
         const auto lambd3 = [](Noisy) {};
         InPlaceFunction<void(Noisy)> func3{lambd3};
         EXPECT_EQ(record, Record(0, 0, 0));  // move, copy, dtor
         func3(noisy);
         EXPECT_EQ(record, Record(1, 1, 2));  // move, copy, dtor
     }
 }

 TEST(InPlaceFunctionTests, VoidFunction) {
     InPlaceFunction<void(size_t)> func = [](size_t x) -> size_t { return x; };
     func(5);
     InPlaceFunction<void(void)> func2 = []() -> size_t { return 5; };
     func2();
 }
 NoMoveCopy foo() {
     return NoMoveCopy();
 }
 struct Test {
     NoMoveCopy operator()() { return NoMoveCopy{}; }
 };

 TEST(InPlaceFunctionTests, FullElision) {
     InPlaceFunction<NoMoveCopy()> func = foo;
 }

 TEST(InPlaceFunctionTests, ReturnConversion) {
     const auto lambd = [](int&& x) -> int&& { return std::move(x); };
     InPlaceFunction<int && (int&& x)> func = lambd;
     func(5);
     InPlaceFunction<void(int)> func3 = [](double) {};
     func3(5);
     InPlaceFunction<double()> func4 = []() -> int { return 5; };
     func4();
 }

 struct Overloaded {
     int operator()() & { return 2; }
     int operator()() const& { return 3; }
     int operator()() && { return 4; }
     int operator()() const&& { return 5; }
 };

 TEST(InPlaceFunctionTests, OverloadResolution) {
     InPlaceFunction<int()> func = Overloaded{};
     EXPECT_EQ(func(), 2);
     EXPECT_EQ(std::move(func()), 2);
 }

 template <class T, class U, class = void>
 struct can_assign : std::false_type {};

 template <class T, class U>
 struct can_assign<T, U, typename std::void_t<decltype(T().operator=(U()))>> : std::true_type {};

 template <class From, class To, bool Expected>
 static constexpr bool Convertible =
         (can_assign<To, From>::value ==
          std::is_constructible_v<To, From>)&&(std::is_constructible_v<To, From> == Expected);

 struct TooBig {
     std::array<uint64_t, 5> big = {1, 2, 3, 4, 5};
     size_t operator()() { return static_cast<size_t>(big[0] + big[1] + big[2] + big[3] + big[4]); }
 };
 static_assert(sizeof(TooBig) == 40);
 struct NotCallable {};
 struct WrongArg {
     void operator()(NotCallable) {}
 };
 struct WrongRet {
     NotCallable operator()(size_t) { return NotCallable{}; }
 };

 static_assert(Convertible<InPlaceFunction<size_t(), 32>, InPlaceFunction<size_t(), 32>, true>);
 static_assert(
         Convertible<InPlaceFunction<size_t(size_t), 32>, InPlaceFunction<size_t(), 32>, false>);
 static_assert(Convertible<InPlaceFunction<void(), 32>, InPlaceFunction<size_t(), 32>, false>);
 static_assert(Convertible<TooBig, InPlaceFunction<size_t(), 32>, false>);
 static_assert(Convertible<TooBig, InPlaceFunction<size_t(), 40>, true>);
 static_assert(Convertible<NotCallable, InPlaceFunction<size_t(), 40>, false>);
 static_assert(Convertible<WrongArg, InPlaceFunction<void(size_t), 40>, false>);
 static_assert(Convertible<WrongRet, InPlaceFunction<size_t(size_t), 40>, false>);
 // Void returning functions are modelled by any return type
 static_assert(Convertible<WrongRet, InPlaceFunction<void(size_t), 40>, true>);

 // Check constructibility/assignability from smaller function types
 static_assert(Convertible<InPlaceFunction<size_t(), 32>, InPlaceFunction<size_t(), 24>, false>);
 static_assert(Convertible<InPlaceFunction<size_t(), 32>, InPlaceFunction<size_t(), 40>, true>);
 static_assert(
         Convertible<InPlaceFunction<size_t(), 32>, InPlaceFunction<size_t(size_t), 40>, false>);
 static_assert(
         Convertible<InPlaceFunction<size_t(), 32>, InPlaceFunction<NotCallable(), 40>, false>);

 struct BadLambd {
     int operator()(int&& x) { return std::move(x); }
 };

 static_assert(Convertible<BadLambd, InPlaceFunction<int(int&&), 32>, true>);
 static_assert(Convertible<BadLambd, InPlaceFunction<int&(int&&), 32>, false>);
 static_assert(Convertible<BadLambd, InPlaceFunction<const int&(int&&), 32>, false>);
 static_assert(Convertible<BadLambd, InPlaceFunction<int && (int&&), 32>, false>);
 static_assert(Convertible<BadLambd, InPlaceFunction<const int && (int&&), 32>, false>);

 struct Base {};
 struct Derived : Base {};
 struct Converted {
     Converted(const Derived&) {}
 };

 struct ConvertCallable {
     Derived operator()() { return Derived{}; }
     Derived& operator()(Derived& x) { return x; }
     Derived&& operator()(Derived&& x) { return std::move(x); }
     const Derived& operator()(const Derived& x) { return x; }
     const Derived&& operator()(const Derived&& x) { return std::move(x); }
 };

 static_assert(Convertible<ConvertCallable, InPlaceFunction<Derived&()>, false>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<Base&()>, false>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<Derived()>, true>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<Base()>, true>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<Converted()>, true>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<Converted&()>, false>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<Converted && ()>, false>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<const Converted&()>, false>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<const Converted && ()>, false>);

 static_assert(Convertible<ConvertCallable, InPlaceFunction<Derived&(Derived&)>, true>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<Base&(Derived&)>, true>);

 static_assert(Convertible<ConvertCallable, InPlaceFunction<Derived && (Derived &&)>, true>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<Base && (Derived &&)>, true>);

 static_assert(Convertible<ConvertCallable, InPlaceFunction<const Derived&(const Derived&)>, true>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<const Base&(const Derived&)>, true>);

 static_assert(
         Convertible<ConvertCallable, InPlaceFunction<const Derived && (const Derived&&)>, true>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<const Base && (const Derived&&)>, true>);

 static_assert(Convertible<ConvertCallable, InPlaceFunction<const Derived&(Derived&)>, true>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<const Base&(Derived&)>, true>);

 static_assert(Convertible<ConvertCallable, InPlaceFunction<const Derived && (Derived &&)>, true>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<const Base && (Derived &&)>, true>);

 static_assert(Convertible<ConvertCallable, InPlaceFunction<const Derived&(Derived&&)>, true>);
 static_assert(Convertible<ConvertCallable, InPlaceFunction<const Base&(Derived&&)>, true>);
	/*
	* Copyright (C) 2022 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "inplace_function_tests"

	#include <mediautils/InPlaceFunction.h>

	#include <type_traits>

	#include <gtest/gtest.h>
	#include <log/log.h>

	using namespace android;
	using namespace android::mediautils;

	struct BigCallable {
	BigCallable(size_t* x, size_t val1, size_t val2) : ptr(x), a(val1), b(val2) {}
	size_t* ptr;
	size_t a;
	size_t b;
	size_t operator()(size_t input) const {
	ptr += a 100 + b * 10 + input;
	return 8;
	}
	};

	TEST(InPlaceFunctionTests, Basic) {
	size_t x = 5;
	InPlaceFunction<size_t(size_t)> func;
	{
	BigCallable test{&x, 2, 3};
	func = test;
	}
	EXPECT_EQ(func(2), 8ull);
	EXPECT_EQ(x, 232ull + 5);
	}

	TEST(InPlaceFunctionTests, Invalid) {
	InPlaceFunction<size_t(size_t)> func;
	EXPECT_TRUE(!func);
	InPlaceFunction<size_t(size_t)> func2{nullptr};
	EXPECT_TRUE(!func2);
	InPlaceFunction<size_t(size_t)> func3 = [](size_t x) { return x; };
	EXPECT_TRUE(!(!func3));
	func3 = nullptr;
	EXPECT_TRUE(!func3);
	}

	TEST(InPlaceFunctionTests, MultiArg) {
	InPlaceFunction<size_t(size_t, size_t, size_t)> func = [](size_t a, size_t b, size_t c) {
	return a + b + c;
	};
	EXPECT_EQ(func(2, 3, 5), 2ull + 3 + 5);
	}
	struct Record {
	Record(size_t m, size_t c, size_t d) : move_called(m), copy_called(c), dtor_called(d) {}
	Record() {}
	size_t move_called = 0;
	size_t copy_called = 0;
	size_t dtor_called = 0;
	friend std::ostream& operator<<(std::ostream& os, const Record& record) {
	return os << "Record, moves: " << record.move_called << ", copies: " << record.copy_called
	<< ", dtor: " << record.dtor_called << '\n';
	}
	};

	bool operator==(const Record& lhs, const Record& rhs) {
	return lhs.move_called == rhs.move_called && lhs.copy_called == rhs.copy_called &&
	lhs.dtor_called == rhs.dtor_called;
	}

	struct Noisy {
	Record& ref;
	size_t state;
	Noisy(Record& record, size_t val) : ref(record), state(val) {}
	Noisy(const Noisy& other) : ref(other.ref), state(other.state) { ref.copy_called++; }

	Noisy(Noisy&& other) : ref(other.ref), state(other.state) { ref.move_called++; }
	~Noisy() { ref.dtor_called++; }

	size_t operator()() { return state; }
	};

	TEST(InPlaceFunctionTests, CtorForwarding) {
	Record record;
	Noisy noisy{record, 17};
	InPlaceFunction<size_t()> func{noisy};
	EXPECT_EQ(record, Record(0, 1, 0)); // move, copy, dtor
	EXPECT_EQ(func(), 17ull);
	Record record2;
	Noisy noisy2{record2, 13};
	InPlaceFunction<size_t()> func2{std::move(noisy2)};
	EXPECT_EQ(record2, Record(1, 0, 0)); // move, copy, dtor
	EXPECT_EQ(func2(), 13ull);
	}

	TEST(InPlaceFunctionTests, FunctionCtorForwarding) {
	{
	Record record;
	Noisy noisy{record, 17};
	InPlaceFunction<size_t()> func{noisy};
	EXPECT_EQ(record, Record(0, 1, 0)); // move, copy, dtor
	EXPECT_EQ(func(), 17ull);
	InPlaceFunction<size_t()> func2{func};
	EXPECT_EQ(record, Record(0, 2, 0)); // move, copy, dtor
	EXPECT_EQ(func2(), 17ull);
	}
	Record record;
	Noisy noisy{record, 13};
	InPlaceFunction<size_t()> func{noisy};
	EXPECT_EQ(record, Record(0, 1, 0)); // move, copy, dtor
	EXPECT_EQ(func(), 13ull);
	InPlaceFunction<size_t()> func2{std::move(func)};
	EXPECT_EQ(record, Record(1, 1, 0)); // move, copy, dtor
	EXPECT_EQ(func2(), 13ull);
	// We expect moved from functions to still be valid
	EXPECT_TRUE(!(!func));
	EXPECT_EQ(static_cast<bool>(func), static_cast<bool>(func2));
	EXPECT_EQ(func(), 13ull);
	}

	TEST(InPlaceFunctionTests, Dtor) {
	Record record;
	{
	InPlaceFunction<size_t()> func;
	{
	Noisy noisy{record, 17};
	func = noisy;
	}
	EXPECT_EQ(func(), 17ull);
	EXPECT_EQ(record.dtor_called, 1ull);
	}
	EXPECT_EQ(record.dtor_called, 2ull);
	}

	TEST(InPlaceFunctionTests, Assignment) {
	{
	Record record;
	Record record2;
	Noisy noisy{record, 17};
	Noisy noisy2{record2, 5};
	InPlaceFunction<size_t()> func{noisy};
	EXPECT_EQ(func(), 17ull);
	EXPECT_EQ(record.dtor_called, 0ull);
	func = noisy2;
	EXPECT_EQ(record.dtor_called, 1ull);
	EXPECT_EQ(record2, Record(0, 1, 0)); // move, copy, dtor
	EXPECT_EQ(func(), 5ull);
	}
	{
	Record record;
	Record record2;
	Noisy noisy{record, 17};
	Noisy noisy2{record2, 5};
	InPlaceFunction<size_t()> func{noisy};
	EXPECT_EQ(func(), 17ull);
	EXPECT_EQ(record.dtor_called, 0ull);
	func = std::move(noisy2);
	EXPECT_EQ(record.dtor_called, 1ull);
	EXPECT_EQ(record2, Record(1, 0, 0)); // move, copy, dtor
	EXPECT_EQ(func(), 5ull);
	}

	{
	Record record;
	Record record2;
	Noisy noisy{record, 17};
	Noisy noisy2{record2, 13};
	{
	InPlaceFunction<size_t()> func{noisy};
	EXPECT_EQ(func(), 17ull);
	InPlaceFunction<size_t()> func2{noisy2};
	EXPECT_EQ(record2, Record(0, 1, 0)); // move, copy, dtor
	EXPECT_EQ(record.dtor_called, 0ull);
	func = func2;
	EXPECT_EQ(record.dtor_called, 1ull);
	EXPECT_EQ(func(), 13ull);
	EXPECT_EQ(record2, Record(0, 2, 0)); // move, copy, dtor
	EXPECT_TRUE(static_cast<bool>(func2));
	EXPECT_EQ(func2(), 13ull);
	}
	EXPECT_EQ(record2, Record(0, 2, 2)); // move, copy, dtor
	}

	{
	Record record;
	Record record2;
	Noisy noisy{record, 17};
	Noisy noisy2{record2, 13};
	{
	InPlaceFunction<size_t()> func{noisy};
	EXPECT_EQ(func(), 17ull);
	InPlaceFunction<size_t()> func2{noisy2};
	EXPECT_EQ(record.dtor_called, 0ull);
	EXPECT_EQ(record2, Record(0, 1, 0)); // move, copy, dtor
	func = std::move(func2);
	EXPECT_EQ(record.dtor_called, 1ull);
	EXPECT_EQ(func(), 13ull);
	EXPECT_EQ(record2, Record(1, 1, 0)); // move, copy, dtor
	// Moved from function is still valid
	EXPECT_TRUE(static_cast<bool>(func2));
	EXPECT_EQ(func2(), 13ull);
	}
	EXPECT_EQ(record2, Record(1, 1, 2)); // move, copy, dtor
	}
	}

	TEST(InPlaceFunctionTests, Swap) {
	Record record1;
	Record record2;
	InPlaceFunction<size_t()> func1 = Noisy{record1, 5};
	InPlaceFunction<size_t()> func2 = Noisy{record2, 7};
	EXPECT_EQ(record1, Record(1, 0, 1)); // move, copy, dtor
	EXPECT_EQ(record2, Record(1, 0, 1)); // move, copy, dtor
	EXPECT_EQ(func1(), 5ull);
	EXPECT_EQ(func2(), 7ull);
	func1.swap(func2);
	EXPECT_EQ(record1, Record(2, 0, 2)); // move, copy, dtor
	// An additional move and destroy into the temporary object
	EXPECT_EQ(record2, Record(3, 0, 3)); // move, copy, dtor
	EXPECT_EQ(func1(), 7ull);
	EXPECT_EQ(func2(), 5ull);
	}

	TEST(InPlaceFunctionTests, Conversion) {
	Record record;
	Noisy noisy{record, 15};
	{
	InPlaceFunction<size_t(), 16> func2 = noisy;
	EXPECT_EQ(record, Record(0, 1, 0)); // move, copy, dtor
	{
	InPlaceFunction<size_t(), 32> func{func2};
	EXPECT_EQ(record, Record(0, 2, 0)); // move, copy, dtor
	EXPECT_EQ(func2(), func());
	}
	EXPECT_EQ(record, Record(0, 2, 1)); // move, copy, dtor
	}
	EXPECT_EQ(record, Record(0, 2, 2)); // move, copy, dtor
	}

	TEST(InPlaceFunctionTests, ConversionMove) {
	Record record;
	Noisy noisy{record, 15};
	{
	InPlaceFunction<size_t(), 16> func2 = noisy;
	EXPECT_EQ(record, Record(0, 1, 0)); // move, copy, dtor
	{
	InPlaceFunction<size_t(), 32> func{std::move(func2)};
	EXPECT_EQ(record, Record(1, 1, 0)); // move, copy, dtor
	EXPECT_EQ(func2(), func());
	}
	EXPECT_EQ(record, Record(1, 1, 1)); // move, copy, dtor
	}
	EXPECT_EQ(record, Record(1, 1, 2)); // move, copy, dtor
	}

	TEST(InPlaceFunctionTests, ConversionAssign) {
	Record record;
	Noisy noisy{record, 15};
	{
	InPlaceFunction<size_t(), 32> func;
	{
	InPlaceFunction<size_t(), 16> func2 = noisy;
	EXPECT_EQ(record, Record(0, 1, 0)); // move, copy, dtor
	func = func2;
	EXPECT_EQ(record, Record(0, 2, 0)); // move, copy, dtor
	EXPECT_EQ(func2(), func());
	}
	EXPECT_EQ(record, Record(0, 2, 1)); // move, copy, dtor
	}
	EXPECT_EQ(record, Record(0, 2, 2)); // move, copy, dtor
	}

	TEST(InPlaceFunctionTests, ConversionAssignMove) {
	Record record;
	Noisy noisy{record, 15};
	{
	InPlaceFunction<size_t(), 32> func;
	{
	InPlaceFunction<size_t(), 16> func2 = noisy;
	EXPECT_EQ(record, Record(0, 1, 0)); // move, copy, dtor
	func = std::move(func2);
	EXPECT_EQ(record, Record(1, 1, 0)); // move, copy, dtor
	EXPECT_EQ(func2(), func());
	}
	EXPECT_EQ(record, Record(1, 1, 1)); // move, copy, dtor
	}
	EXPECT_EQ(record, Record(1, 1, 2)); // move, copy, dtor
	}

	struct NoMoveCopy {
	NoMoveCopy() = default;
	NoMoveCopy(const NoMoveCopy&) = delete;
	NoMoveCopy(NoMoveCopy&&) = delete;
	};
	struct TestCallable {
	NoMoveCopy& operator()(NoMoveCopy& x) { return x; }
	};

	TEST(InPlaceFunctionTests, ArgumentForwarding) {
	const auto lambd = [](NoMoveCopy& x) -> NoMoveCopy& { return x; };
	InPlaceFunction<NoMoveCopy&(NoMoveCopy&)> func = lambd;
	const auto lambd2 = [](NoMoveCopy&& x) -> NoMoveCopy&& { return std::move(x); };
	InPlaceFunction<NoMoveCopy && (NoMoveCopy &&)> func2 = lambd2;
	auto lvalue = NoMoveCopy{};
	func(lvalue);
	func2(NoMoveCopy{});
	InPlaceFunction<void(NoMoveCopy&)> func3 = [](const NoMoveCopy&) {};
	func3(lvalue);
	InPlaceFunction<void(NoMoveCopy &&)> func4 = [](const NoMoveCopy&) {};
	func4(std::move(lvalue));
	InPlaceFunction<void(const NoMoveCopy&)> func5 = [](const NoMoveCopy&) {};
	func5(lvalue);
	InPlaceFunction<void(const NoMoveCopy&&)> func6 = [](const NoMoveCopy&) {};
	func6(std::move(lvalue));
	InPlaceFunction<void(const NoMoveCopy&&)> func7 = [](const NoMoveCopy&&) {};
	func7(std::move(lvalue));
	InPlaceFunction<void(NoMoveCopy &&)> func8 = [](const NoMoveCopy&&) {};
	func8(std::move(lvalue));

	{
	Record record;
	Noisy noisy{record, 5};
	const auto lambd3 = [](Noisy) {};
	InPlaceFunction<void(Noisy)> func3{lambd3};
	EXPECT_EQ(record, Record(0, 0, 0)); // move, copy, dtor
	func3(std::move(noisy));
	EXPECT_EQ(record, Record(2, 0, 2)); // move, copy, dtor
	}

	{
	Record record;
	Noisy noisy{record, 5};
	const auto lambd3 = [](Noisy) {};
	InPlaceFunction<void(Noisy)> func3{lambd3};
	EXPECT_EQ(record, Record(0, 0, 0)); // move, copy, dtor
	func3(noisy);
	EXPECT_EQ(record, Record(1, 1, 2)); // move, copy, dtor
	}
	}

	TEST(InPlaceFunctionTests, VoidFunction) {
	InPlaceFunction<void(size_t)> func = [](size_t x) -> size_t { return x; };
	func(5);
	InPlaceFunction<void(void)> func2 = []() -> size_t { return 5; };
	func2();
	}
	NoMoveCopy foo() {
	return NoMoveCopy();
	}
	struct Test {
	NoMoveCopy operator()() { return NoMoveCopy{}; }
	};

	TEST(InPlaceFunctionTests, FullElision) {
	InPlaceFunction<NoMoveCopy()> func = foo;
	}

	TEST(InPlaceFunctionTests, ReturnConversion) {
	const auto lambd = [](int&& x) -> int&& { return std::move(x); };
	InPlaceFunction<int && (int&& x)> func = lambd;
	func(5);
	InPlaceFunction<void(int)> func3 = [](double) {};
	func3(5);
	InPlaceFunction<double()> func4 = []() -> int { return 5; };
	func4();
	}

	struct Overloaded {
	int operator()() & { return 2; }
	int operator()() const& { return 3; }
	int operator()() && { return 4; }
	int operator()() const&& { return 5; }
	};

	TEST(InPlaceFunctionTests, OverloadResolution) {
	InPlaceFunction<int()> func = Overloaded{};
	EXPECT_EQ(func(), 2);
	EXPECT_EQ(std::move(func()), 2);
	}

	template <class T, class U, class = void>
	struct can_assign : std::false_type {};

	template <class T, class U>
	struct can_assign<T, U, typename std::void_t<decltype(T().operator=(U()))>> : std::true_type {};

	template <class From, class To, bool Expected>
	static constexpr bool Convertible =
	(can_assign<To, From>::value ==
	std::is_constructible_v<To, From>)&&(std::is_constructible_v<To, From> == Expected);

	struct TooBig {
	std::array<uint64_t, 5> big = {1, 2, 3, 4, 5};
	size_t operator()() { return static_cast<size_t>(big[0] + big[1] + big[2] + big[3] + big[4]); }
	};
	static_assert(sizeof(TooBig) == 40);
	struct NotCallable {};
	struct WrongArg {
	void operator()(NotCallable) {}
	};
	struct WrongRet {
	NotCallable operator()(size_t) { return NotCallable{}; }
	};

	static_assert(Convertible<InPlaceFunction<size_t(), 32>, InPlaceFunction<size_t(), 32>, true>);
	static_assert(
	Convertible<InPlaceFunction<size_t(size_t), 32>, InPlaceFunction<size_t(), 32>, false>);
	static_assert(Convertible<InPlaceFunction<void(), 32>, InPlaceFunction<size_t(), 32>, false>);
	static_assert(Convertible<TooBig, InPlaceFunction<size_t(), 32>, false>);
	static_assert(Convertible<TooBig, InPlaceFunction<size_t(), 40>, true>);
	static_assert(Convertible<NotCallable, InPlaceFunction<size_t(), 40>, false>);
	static_assert(Convertible<WrongArg, InPlaceFunction<void(size_t), 40>, false>);
	static_assert(Convertible<WrongRet, InPlaceFunction<size_t(size_t), 40>, false>);
	// Void returning functions are modelled by any return type
	static_assert(Convertible<WrongRet, InPlaceFunction<void(size_t), 40>, true>);

	// Check constructibility/assignability from smaller function types
	static_assert(Convertible<InPlaceFunction<size_t(), 32>, InPlaceFunction<size_t(), 24>, false>);
	static_assert(Convertible<InPlaceFunction<size_t(), 32>, InPlaceFunction<size_t(), 40>, true>);
	static_assert(
	Convertible<InPlaceFunction<size_t(), 32>, InPlaceFunction<size_t(size_t), 40>, false>);
	static_assert(
	Convertible<InPlaceFunction<size_t(), 32>, InPlaceFunction<NotCallable(), 40>, false>);

	struct BadLambd {
	int operator()(int&& x) { return std::move(x); }
	};

	static_assert(Convertible<BadLambd, InPlaceFunction<int(int&&), 32>, true>);
	static_assert(Convertible<BadLambd, InPlaceFunction<int&(int&&), 32>, false>);
	static_assert(Convertible<BadLambd, InPlaceFunction<const int&(int&&), 32>, false>);
	static_assert(Convertible<BadLambd, InPlaceFunction<int && (int&&), 32>, false>);
	static_assert(Convertible<BadLambd, InPlaceFunction<const int && (int&&), 32>, false>);

	struct Base {};
	struct Derived : Base {};
	struct Converted {
	Converted(const Derived&) {}
	};

	struct ConvertCallable {
	Derived operator()() { return Derived{}; }
	Derived& operator()(Derived& x) { return x; }
	Derived&& operator()(Derived&& x) { return std::move(x); }
	const Derived& operator()(const Derived& x) { return x; }
	const Derived&& operator()(const Derived&& x) { return std::move(x); }
	};

	static_assert(Convertible<ConvertCallable, InPlaceFunction<Derived&()>, false>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<Base&()>, false>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<Derived()>, true>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<Base()>, true>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<Converted()>, true>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<Converted&()>, false>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<Converted && ()>, false>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<const Converted&()>, false>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<const Converted && ()>, false>);

	static_assert(Convertible<ConvertCallable, InPlaceFunction<Derived&(Derived&)>, true>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<Base&(Derived&)>, true>);

	static_assert(Convertible<ConvertCallable, InPlaceFunction<Derived && (Derived &&)>, true>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<Base && (Derived &&)>, true>);

	static_assert(Convertible<ConvertCallable, InPlaceFunction<const Derived&(const Derived&)>, true>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<const Base&(const Derived&)>, true>);

	static_assert(
	Convertible<ConvertCallable, InPlaceFunction<const Derived && (const Derived&&)>, true>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<const Base && (const Derived&&)>, true>);

	static_assert(Convertible<ConvertCallable, InPlaceFunction<const Derived&(Derived&)>, true>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<const Base&(Derived&)>, true>);

	static_assert(Convertible<ConvertCallable, InPlaceFunction<const Derived && (Derived &&)>, true>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<const Base && (Derived &&)>, true>);

	static_assert(Convertible<ConvertCallable, InPlaceFunction<const Derived&(Derived&&)>, true>);
	static_assert(Convertible<ConvertCallable, InPlaceFunction<const Base&(Derived&&)>, true>);