compile_time_tests.cpp

Go to the documentation of this file.

/*
 *  Created on: 27/02/2018
 *      Author: ricab
 */
 
#include "scope_guard.hpp"
#include <functional>
#include <stdexcept>
#include <tuple>
#include <utility>
 
using namespace sg;
 
/* --- first some test helpers --- */
 
namespace
{
  constexpr auto EMSG = "message in a bottle";
  void non_throwing() noexcept { }
  [[noreturn]] void throwing() { throw std::runtime_error{EMSG}; }
  void meh() { }
 
  int returning() noexcept { return 42; }
 
 
  using StdFun = std::function<void()>;
  const StdFun throwing_stdfun{throwing};
  const StdFun non_throwing_stdfun{non_throwing}; // drops noexcept
  const StdFun meh_stdfun{meh};
 
  const std::function<int()> returning_stdfun{returning}; // drops noexcept
 
 
  const auto throwing_lambda = []{ throwing(); };
  const auto non_throwing_lambda = []() noexcept { non_throwing(); };
  const auto meh_lambda = []{ meh(); };
 
  const auto returning_lambda = []() noexcept { return returning(); };
 
 
  const auto throwing_bound = std::bind(throwing);
  const auto non_throwing_bound = std::bind(non_throwing); // drops noexcept
  const auto meh_bound = std::bind(meh);
 
  const auto returning_bound = std::bind(returning); // drops noexcept
 
 
  struct throwing_struct
  {
    [[noreturn]] void operator()() { throwing(); }
  } throwing_functor;
  struct non_throwing_struct
  {
    void operator()() const noexcept { non_throwing(); }
  } non_throwing_functor;
  struct meh_struct
  {
    void operator()() const { meh(); }
  } meh_functor;
 
  struct returning_struct
  {
    int operator()() const noexcept { return returning(); }
  } returning_functor;
 
  struct nocopy_nomove // non-copyable and non-movable
  {
    void operator()() const noexcept { non_throwing(); }
 
    nocopy_nomove() noexcept = default;
    ~nocopy_nomove() noexcept = default;
 
    nocopy_nomove(const nocopy_nomove&) = delete;
    nocopy_nomove& operator=(const nocopy_nomove&) = delete;
    nocopy_nomove(nocopy_nomove&&) = delete;
    nocopy_nomove& operator=(nocopy_nomove&&) = delete;
  };
 
  struct potentially_throwing_dtor
  {
    void operator()() const noexcept { non_throwing(); }
 
    ~potentially_throwing_dtor() noexcept(false) {}
 
    potentially_throwing_dtor() noexcept = default;
    potentially_throwing_dtor(const potentially_throwing_dtor&) noexcept
      = default;
    potentially_throwing_dtor(potentially_throwing_dtor&&) noexcept = default;
  };
 
  struct throwing_copy
  {
    void operator()() const noexcept { non_throwing(); }
 
    throwing_copy(const throwing_copy&) noexcept(false) {}
 
    ~throwing_copy() noexcept = default;
    throwing_copy() noexcept = default;
    throwing_copy(throwing_copy&&) noexcept = default;
  };
 
  struct throwing_move
  {
    void operator()() const noexcept { non_throwing(); }
 
    throwing_move(throwing_move&&) noexcept(false) {}
 
    ~throwing_move() noexcept = default;
    throwing_move() noexcept = default;
    throwing_move(const throwing_move&) noexcept = default;
  };
 
  struct nomove_throwing_copy
  {
    void operator()() const noexcept { non_throwing(); }
 
    nomove_throwing_copy(const nomove_throwing_copy&) noexcept(false) {}
 
    /*
     * nomove_throwing_copy(nomove_throwing_copy&&) noexcept;
     *
     * not declared! move ctor absent but not deleted - does not participate in
     * overload resolution, so copy ctor can still be selected
     */
 
    ~nomove_throwing_copy() noexcept = default;
    nomove_throwing_copy() noexcept = default;
  };
 
  struct nothrow
  {
    void operator()() const noexcept { non_throwing(); }
 
    ~nothrow() noexcept = default;
    nothrow() noexcept = default;
    nothrow(const nothrow&) noexcept = default;
    nothrow(nothrow&&) noexcept = default;
  };
 
 
  /* --- tests that always succeed --- */
 
#ifdef test_1
    static_assert(noexcept(make_scope_guard(std::declval<void(*)()noexcept>())),
                  "make_scope_guard not noexcept");
#endif
 
#ifdef test_2
    static_assert(noexcept(make_scope_guard(std::declval<void(*)()noexcept>())
                           .~scope_guard()),
                  "scope_guard dtor not noexcept");
#endif
 
    void test_throwing_dtor_throw_spec_good()
    {
#ifdef test_3
      potentially_throwing_dtor x;
      static_assert(noexcept(make_scope_guard(x)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue object whose dtor throws (should deduce "
                    "reference and avoid destruction entirely)");
#endif
#ifdef test_4
      potentially_throwing_dtor x;
      auto& r = x;
      static_assert(noexcept(make_scope_guard(r)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue reference to an object whose dtor throws "
                    "(should deduce reference and avoid destruction entirely)");
#endif
#ifdef test_5
      potentially_throwing_dtor x;
      const auto& cr = x;
      static_assert(noexcept(make_scope_guard(cr)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue reference to a const object whose dtor "
                    "throws (should deduce reference and avoid destruction "
                    "entirely)");
#endif
    }
 
    void test_throwing_copy_throw_spec()
    {
#ifdef test_6
      static_assert(noexcept(make_scope_guard(throwing_copy{})),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an rvalue object whose copy ctor throws");
#endif
#ifdef test_7
      throwing_copy x;
      static_assert(noexcept(make_scope_guard(x)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue object whose copy ctor throws (should "
                    "deduce reference and avoid copy entirely)");
#endif
#ifdef test_8
      throwing_copy x;
      static_assert(noexcept(make_scope_guard(std::move(x))),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an rvalue reference to an object whose copy ctor "
                    "throws");
#endif
#ifdef test_9
      throwing_copy x;
      auto& r = x;
      static_assert(noexcept(make_scope_guard(r)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue reference to an object whose copy ctor "
                    "throws (should deduce reference and avoid copy entirely)");
#endif
#ifdef test_10
      throwing_copy x;
      const auto& cr = x;
      static_assert(noexcept(make_scope_guard(cr)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue reference to a const object whose copy "
                    "ctor throws (should deduce reference and avoid copy "
                    "entirely)");
#endif
    }
 
    void test_throwing_move_throw_spec()
    {
#ifdef test_11
      static_assert(!noexcept(make_scope_guard(throwing_move{})),
                    "make_scope_guard wrongly declared noexcept when instanced "
                    "with an rvalue object whose move ctor throws");
#endif
#ifdef test_12
      throwing_move x;
      static_assert(noexcept(make_scope_guard(x)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue object whose move ctor throws");
#endif
#ifdef test_13
      throwing_move x;
      static_assert(!noexcept(make_scope_guard(std::move(x))),
                    "make_scope_guard wrongly declared noexcept when instanced "
                    "with an rvalue reference to an object whose move ctor "
                    "throws");
#endif
#ifdef test_14
      throwing_move x;
      auto& r = x;
      static_assert(noexcept(make_scope_guard(r)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue reference to an object whose move ctor "
                    "throws");
#endif
#ifdef test_15
      throwing_move x;
      const auto& cr = x;
      static_assert(noexcept(make_scope_guard(cr)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue reference to a const object whose move "
                    "ctor throws");
#endif
    }
 
    void test_nomove_throwing_copy_throw_spec()
    {
#ifdef test_16
      static_assert(!noexcept(make_scope_guard(nomove_throwing_copy{})),
                    "make_scope_guard wrongly declared noexcept when instanced "
                    "with an rvalue object whose copy ctor throws and without "
                    "a move ctor");
#endif
#ifdef test_17
      nomove_throwing_copy x;
      static_assert(noexcept(make_scope_guard(x)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue object whose copy ctor throws and without "
                    "a move ctor (should deduce reference and avoid copy "
                    "entirely)");
#endif
#ifdef test_18
      nomove_throwing_copy x;
      static_assert(!noexcept(make_scope_guard(std::move(x))),
                    "make_scope_guard wrongly declared noexcept when instanced "
                    "with an rvalue reference to an object whose copy ctor "
                    "throws and without a move ctor");
#endif
#ifdef test_19
      nomove_throwing_copy x;
      auto& r = x;
      static_assert(noexcept(make_scope_guard(r)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue reference to an object whose copy ctor "
                    "throws (should deduce reference and avoid copy entirely)");
#endif
#ifdef test_20
      nomove_throwing_copy x;
      const auto& cr = x;
      static_assert(noexcept(make_scope_guard(cr)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue reference to a const object whose copy "
                    "ctor throws (should deduce reference and avoid copy "
                    "entirely)");
#endif
    }
 
    void test_nothrow_throw_spec()
    {
#ifdef test_21
      static_assert(noexcept(make_scope_guard(nothrow{})),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an rvalue object whose ctors and dtor do not throw");
#endif
#ifdef test_22
      nothrow x;
      static_assert(noexcept(make_scope_guard(x)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue object whose ctors and dtor do not throw");
#endif
#ifdef test_23
      nothrow x;
      static_assert(noexcept(make_scope_guard(std::move(x))),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an rvalue reference to an object whose ctors and "
                    "dtor do not throw");
#endif
#ifdef test_24
      nothrow x;
      auto& r = x;
      static_assert(noexcept(make_scope_guard(r)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue reference to an object whose ctors and "
                    "dtor do not throw");
#endif
#ifdef test_25
      nothrow x;
      const auto& cr = x;
      static_assert(noexcept(make_scope_guard(cr)),
                    "make_scope_guard not declared noexcept when instanced "
                    "with an lvalue reference to a const object whose ctors "
                    "dtor do not throw");
#endif
    }
 
  void test_noncopyable_nonmovable_good()
  {
#ifdef test_26
    nocopy_nomove ncnm{};
    std::ignore = make_scope_guard(ncnm);
#endif
#ifdef test_27
    nocopy_nomove ncnm{};
    auto& ncnmr = ncnm;
    std::ignore = make_scope_guard(ncnmr);
#endif
#ifdef test_28
    nocopy_nomove ncnm{};
    const auto& ncnmcr = ncnm;
    std::ignore = make_scope_guard(ncnmcr);
#endif
  }
 
  void test_dismiss_is_noexcept()
  {
#ifdef test_29
    static_assert(noexcept(make_scope_guard(non_throwing).dismiss()),
                  "scope_guard::dismiss not noexcept");
#endif
#ifdef test_30
    static_assert(noexcept(make_scope_guard(non_throwing_lambda).dismiss()),
                  "scope_guard::dismiss not noexcept");
#endif
#ifdef test_31
    static_assert(noexcept(make_scope_guard(non_throwing_functor).dismiss()),
                  "scope_guard::dismiss not noexcept");
#endif
  }
 
  void test_noexcept_good()
  {
#ifdef test_32
    std::ignore = make_scope_guard(non_throwing);
#endif
#ifdef test_33
    std::ignore = make_scope_guard(non_throwing_lambda);
#endif
#ifdef test_34
    std::ignore = make_scope_guard(non_throwing_functor);
#endif
  }
 
  /* --- tests that fail iff nothrow_invocable is required --- */
 
  void test_noexcept_bad()
  {
#ifdef test_35
    std::ignore = make_scope_guard(throwing);
#endif
#ifdef test_36
    std::ignore = make_scope_guard(throwing_stdfun);
#endif
#ifdef test_37
    std::ignore = make_scope_guard(throwing_lambda);
#endif
#ifdef test_38
    std::ignore = make_scope_guard(throwing_bound);
#endif
#ifdef test_39
    std::ignore = make_scope_guard(throwing_functor);
#endif
  }
 
  void test_noexcept_fixable()
  {
#ifdef test_40
    std::ignore = make_scope_guard(meh);
#endif
#ifdef test_41
    std::ignore = make_scope_guard(meh_stdfun);
#endif
#ifdef test_42
    std::ignore = make_scope_guard(meh_lambda);
#endif
#ifdef test_43
    std::ignore = make_scope_guard(meh_bound);
#endif
#ifdef test_44
    std::ignore = make_scope_guard(meh_functor);
#endif
  }
 
  void test_noexcept_unfortunate()
  {
#ifdef test_45
    std::ignore = make_scope_guard(non_throwing_stdfun);
#endif
#ifdef test_46
    std::ignore = make_scope_guard(non_throwing_bound);
#endif
  }
 
  void test_dismiss_is_noexcept_even_if_bad_callable()
  {
#ifdef test_47
    static_assert(noexcept(make_scope_guard(throwing).dismiss()),
                  "scope_guard::dismiss not noexcept");
#endif
#ifdef test_48
    static_assert(noexcept(make_scope_guard(throwing_stdfun).dismiss()),
                  "scope_guard::dismiss not noexcept");
#endif
#ifdef test_49
    static_assert(noexcept(make_scope_guard(throwing_lambda).dismiss()),
                  "scope_guard::dismiss not noexcept");
#endif
#ifdef test_50
    static_assert(noexcept(make_scope_guard(throwing_bound).dismiss()),
                  "scope_guard::dismiss not noexcept");
#endif
#ifdef test_51
    static_assert(noexcept(make_scope_guard(throwing_functor).dismiss()),
                  "scope_guard::dismiss not noexcept");
#endif
  }
 
 
  /* --- tests that always fail --- */
 
  void test_throwing_dtor_throw_spec_bad()
  {
#ifdef test_52
    std::ignore = make_scope_guard(potentially_throwing_dtor{});
#endif
#ifdef test_53
    potentially_throwing_dtor x;
    std::ignore = make_scope_guard(std::move(x));
#endif
  }
 
  void test_disallowed_copy_construction()
  {
    const auto guard1 = make_scope_guard(non_throwing);
#ifdef test_54
    const auto guard2 = guard1;
#endif
  }
 
  void test_disallowed_copy_assignment()
  {
    const auto guard1 = make_scope_guard(non_throwing_lambda);
    auto guard2 = make_scope_guard(non_throwing_functor);
#ifdef test_55
    guard2 = guard1;
#endif
  }
 
  void test_disallowed_move_assignment()
  {
    auto guard = make_scope_guard(non_throwing);
#ifdef test_56
    guard = make_scope_guard(non_throwing_lambda);
#endif
  }
 
  void test_disallowed_return()
  {
#ifdef test_57
    std::ignore = make_scope_guard(returning);
#endif
#ifdef test_58
    std::ignore = make_scope_guard(returning_stdfun);
#endif
#ifdef test_59
    std::ignore = make_scope_guard(returning_lambda);
#endif
#ifdef test_60
    std::ignore = make_scope_guard(returning_bound);
#endif
#ifdef test_61
    std::ignore = make_scope_guard(returning_functor);
#endif
  }
 
  void test_noncopyable_nonmovable_bad()
  {
#ifdef test_62
    std::ignore = make_scope_guard(nocopy_nomove{});
#endif
#ifdef test_63
    nocopy_nomove ncnm{};
    std::ignore = make_scope_guard(std::move(ncnm));
#endif
  }
 
  void test_direct_construction_forbidden()
  {
#ifdef test_64
    detail::scope_guard{non_throwing};
#endif
#ifdef test_65
    auto x = detail::scope_guard(non_throwing);
#endif
#ifdef test_66
    auto x = detail::scope_guard<void(&)()noexcept>{non_throwing};
#endif
#ifdef test_67
    auto lambda = []() noexcept {};
    detail::scope_guard<decltype(lambda)>{std::move(lambda)};
#endif
  }
 
  void test_const_guard_cannot_do_everything()
  {
    const auto guard = make_scope_guard(non_throwing);
#ifdef test_68
    guard.dismiss();
#endif
#ifdef test_69
    auto another = std::move(guard);
#endif
  }
 
#ifdef test_70
  struct concrete_specialized_guard
    : detail::scope_guard<void(*)()noexcept>
  {};
#endif
#ifdef test_71
  template<typename T>
  struct specialized_guard : detail::scope_guard<T>
  {
    explicit specialized_guard(T&& t)
      : detail::scope_guard<T>{std::forward<T>(t)}
    {}
  };
 
  template<typename T>
  specialized_guard<T> make_specialized_guard(T&& t)
  {
    return specialized_guard<T>{std::forward<T>(t)};
  }
 
  auto special = make_specialized_guard([]()noexcept{});
#endif
 
}
 
int main()
{
  test_throwing_dtor_throw_spec_good();
  test_throwing_copy_throw_spec();
  test_throwing_move_throw_spec();
  test_nomove_throwing_copy_throw_spec();
  test_nothrow_throw_spec();
  test_noncopyable_nonmovable_good();
  test_dismiss_is_noexcept();
  test_noexcept_good();
 
  test_noexcept_bad(); // this results in a call to std::terminate
  test_noexcept_fixable();
  test_noexcept_unfortunate();
  test_dismiss_is_noexcept_even_if_bad_callable();
 
  test_throwing_dtor_throw_spec_bad();
  test_disallowed_copy_construction();
  test_disallowed_copy_assignment();
  test_disallowed_move_assignment();
  test_disallowed_return();
  test_noncopyable_nonmovable_bad();
  test_direct_construction_forbidden();
 
  return 0;
}