libstdc++-v3/testsuite/experimental/scopeguard/uniqueres.cc

// { dg-options "-std=gnu++20" }
// { dg-do run { target c++20 } }

#include <experimental/scope>
#include <testsuite_hooks.h>

#ifndef __cpp_lib_experimental_scope
# error Feature-test macro is not defined.
#elif __cpp_lib_experimental_scope < 201902
# error Feature-test macro has bad value.
#endif

using std::experimental::unique_resource;

void
test_default_cons()
{
  struct val { int i; };

  struct del
  {
    void operator()(val) const { VERIFY(false); }
    int i;
  };

  static_assert( std::is_default_constructible_v<unique_resource<val, del>> );
  static_assert( !std::is_default_constructible_v<unique_resource<val&, del>> );
  // GCC extension:
  static_assert( std::is_nothrow_default_constructible_v<unique_resource<val, del>> );
  struct exval : val { exval() noexcept(false) { } };
  static_assert( !std::is_nothrow_default_constructible_v<unique_resource<exval, del>> );

  unique_resource<val, del> res;
  VERIFY( res.get().i == 0 ); // value-initialized
  VERIFY( res.get_deleter().i == 0 ); // value-initialized
}

void
test_cons()
{
  struct val { int i; };

  struct del
  {
    void operator()(val v) const { VERIFY(v.i == i); }
    int i;
  };

  auto r1 = unique_resource<val, del>(val{}, del{});
  VERIFY( r1.get().i == 0 );
  VERIFY( r1.get_deleter().i == 0 );

  auto r2 = unique_resource<val, del>(1, 2);
  VERIFY( r2.get().i == 1 );
  VERIFY( r2.get_deleter().i == 2 );
  r2.release();

  val v{3};
  auto r3 = unique_resource<val&, del>(v, 3);

  static_assert( !std::is_constructible_v<unique_resource<val&, del>, val, del> );
  static_assert( !std::is_constructible_v<unique_resource<val&, del>, int, del> );
  static_assert( !std::is_constructible_v<unique_resource<val&, del>, const val&, del> );

  del d4{4};
  auto r4 = unique_resource(std::ref(v), std::ref(d4));
  --d4.i;

  static_assert( std::is_same_v<decltype(r4),
				unique_resource<std::reference_wrapper<val>,
						std::reference_wrapper<del>>> );
  static_assert( !std::is_constructible_v<decltype(r4), val, del> );

  int counter = 0, dcounter = 99;
  {
    unique_resource r(std::ref(counter),
		      [&dcounter] (int& i) { ++dcounter; ++i; });
  }
  VERIFY( counter == 1 );
  VERIFY( dcounter == 100 );

  {
    struct NothrowMove
    {
      NothrowMove() noexcept { }
      NothrowMove(NothrowMove&&) noexcept(true) { }
      NothrowMove(const NothrowMove&) { throw 1; }
    };

    unique_resource r(NothrowMove{},
		      [&dcounter] (NothrowMove&) { ++dcounter; });
  }
  VERIFY( dcounter == 101 );

  {
    struct ThrowOnCopy
    {
      ThrowOnCopy() noexcept { }
      ThrowOnCopy(ThrowOnCopy&&) noexcept(false) { VERIFY(false); };
      ThrowOnCopy(const ThrowOnCopy&) { throw 1; }
      explicit ThrowOnCopy(val) noexcept(false) { VERIFY(false); }
      explicit ThrowOnCopy(val&) noexcept(false) { }
    };
    auto d = [&dcounter] (auto&) { ++dcounter; };

    unique_resource r(val(1), d); // uses ThrowOnCopy(val&)

    try {
      unique_resource r(ThrowOnCopy{}, d); // uses copy constructor
      VERIFY( false );
    } catch (int) {
      VERIFY( dcounter == 102 );
    }
  }
  VERIFY( dcounter == 103 );

  {
    struct CopyVal
    {
      explicit CopyVal(const val& v) : i(v.i) { }
      int i;
    };

    struct Del
    {
      void operator()(const val&) { VERIFY(false); }
      void operator()(const CopyVal& c) { ref = c.i; }
      int& ref;
    };

    struct CopyDel
    {
      explicit CopyDel(Del&&) noexcept(false) { VERIFY(false); }
      explicit CopyDel(const Del&) noexcept(false) { throw 1; }
      void operator()(const val&) = delete;
      void operator()(const CopyVal&) { VERIFY(false); }
    };

    try {
      // CopyVal is constructed from val(11), then initializing CopyDel throws.
      // The CopyVal member is passed to the Del argument to be freed.
      unique_resource<CopyVal, CopyDel> r(val(11), Del{dcounter});
      VERIFY( false );
    } catch (int) {
      VERIFY( dcounter == 11 );
    }
  }
}

void
test_move_cons()
{
  {
    struct Del
    {
      void operator()(int) const { VERIFY(false); }
    };

    unique_resource<int, Del> r0;
    auto rr0 = std::move(r0);
    VERIFY( r0.get() == 0 );
    VERIFY( rr0.get() == 0 );

    struct DelThrowingCopy
    {
      DelThrowingCopy() = default;
      DelThrowingCopy(const DelThrowingCopy&) { throw 1; }
      void operator()(int) const { VERIFY(false); }
    };

    unique_resource<int, DelThrowingCopy> r1;
    try {
      auto rr1 = std::move(r1); // Initializing deleter throws.
      VERIFY( false );
    } catch (int) {
    }
  }

  {
    struct Res
    {
      Res() = default;
      Res(Res&& r) noexcept : moved(r.moved) { r.moved = true; }
      Res(Res& r) : moved(r.moved) { }
      bool moved = false;
    };

    unique_resource r(Res{}, [](const auto&) { });
    auto rr = std::move(r);
    VERIFY( r.get().moved == true );
    VERIFY( rr.get().moved == false );
  }

  {
    struct Res2
    {
      Res2() = default;
      Res2(Res2&& r) noexcept(false) : moved(r.moved) { r.moved = false; }
      Res2(Res2& r) : moved(r.moved) { }
      bool moved = false;
    };

    unique_resource r2(Res2{}, [](const auto&) { });
    auto rr2 = std::move(r2);
    VERIFY( r2.get().moved == false );
    VERIFY( rr2.get().moved == false );
  }

  {
    struct ThrowingCopy
    {
      ThrowingCopy(int) { }
      ThrowingCopy(const ThrowingCopy&) { throw 1; }
    };

    int dcounter = 0;
    {
      auto d = [&dcounter] (const auto&) { ++dcounter; };
      unique_resource<ThrowingCopy, decltype(d)> r(1, d);
      try {
	auto rr = std::move(r); // Ownership of resource left with 'r'
	VERIFY(false);
      } catch (int) {
	VERIFY( dcounter == 0 );
      }
    }
    VERIFY( dcounter == 1 );
  }
}

int called1 = 0;

void
test_assign()
{
  struct ThrowingDel
  {
    ThrowingDel() = default;
    ThrowingDel(int& called) : called(called) { }
    ThrowingDel(const ThrowingDel&) = default;
    ThrowingDel& operator=(const ThrowingDel&) { throw 1; }

    void operator()(int i) const noexcept { ++called; }
    int& called = called1;
  };

  int called2 = 0;
  {
    unique_resource<int, ThrowingDel> r1;
    VERIFY( r1.get() == 0 );
    unique_resource<int, ThrowingDel> r2(2, ThrowingDel{called2});
    VERIFY( r2.get() == 2 );
    try
    {
      r1 = std::move(r2);
      VERIFY( false );
    }
    catch (int)
    {
    }
    VERIFY( called1 == 0 ); // r1.reset() was called, but did nothing.
    VERIFY( called2 == 0 ); // r2.reset() not called.
    VERIFY( r1.get() == 0 );
    VERIFY( r2.get() == 2 );
  }
  VERIFY( called1 == 0 ); // r1.reset() was called, but did nothing.
  VERIFY( called2 == 1 ); // r2 destructor invoked its deleter.
}

void
test_modifiers()
{
  int dcounter = 0;
  auto d = [&dcounter] (int i) { dcounter += i; };
  unique_resource<int, decltype(d)> r(1, d);
  r.reset();
  VERIFY( dcounter == 1 );
  r.reset(2);
  VERIFY( dcounter == 1 );
  r.release();
  VERIFY( dcounter == 1 );
  r.release();
  VERIFY( dcounter == 1 );
  r.reset(3);
  VERIFY( dcounter == 1 );
  r.reset(4);
  VERIFY( dcounter == 4 );
}

template<typename T> concept has_star = requires (T& t) { *t; };
template<typename T> concept has_arrow = requires (T& t) { t.operator->(); };

void
test_observers()
{
  struct D { void operator()(int* p) const noexcept { delete p; } };
  int* p = new int(3);
  unique_resource<int*, D> r(p, D{});
  VERIFY( r.get() == p );
  VERIFY( *r == 3 );
  VERIFY( r.operator->() == p );
  (void) r.get_deleter();

  using R1 = unique_resource<int, void(*)(int)>;
  static_assert( ! has_star<R1> );
  static_assert( ! has_arrow<R1> );
  using R2 = unique_resource<const void*, void(*)(const void*)>;
  static_assert( ! has_star<R2> );
  static_assert( has_arrow<R2> );
}

void
test_make_checked()
{
  struct Boolish {
    explicit operator bool() const noexcept { return val; }
    bool val;
  };

  using std::experimental::make_unique_resource_checked;

  {
    struct ThrowingCopy
    {
      ThrowingCopy(int i) : val(i) { }
      ThrowingCopy(const ThrowingCopy&) { throw 1; }
      Boolish operator==(int i) const noexcept { return {i == val}; }
      int val;
    };

    int dcounter = 0;
    auto d = [&dcounter] (const auto&) { ++dcounter; };

    try
    {
      (void) make_unique_resource_checked(ThrowingCopy(1), 0, d);
      VERIFY(false);
    }
    catch (int)
    {
      VERIFY(dcounter == 1);
    }

    dcounter = 0;
    try
    {
      (void) make_unique_resource_checked(ThrowingCopy(1), 1, d);
      VERIFY(false);
    }
    catch (int)
    {
      VERIFY(dcounter == 0);
    }
  }
}

int main()
{
  test_default_cons();
  test_cons();
  test_move_cons();
  test_assign();
  test_modifiers();
  test_observers();
  test_make_checked();
}