libstdc++-v3/testsuite/20_util/expected/swap.cc

   1 // { dg-options "-std=gnu++23" }
   2 // { dg-do run { target c++23 } }
   3
   4 #include <expected>
   5 #include <testsuite_hooks.h>
   6
   7 struct NonTrivial
   8 {
   9   constexpr NonTrivial(int i) : i(i) { }
  10   constexpr NonTrivial(const NonTrivial& x) noexcept(false): i(x.i) { }
  11   constexpr ~NonTrivial() { }
  12   int i;
  13
  14   constexpr bool operator==(const NonTrivial&) const = default;
  15 };
  16
  17 constexpr bool
  18 test_swap_obj()
  19 {
  20   std::expected<int, int> e1(1), e2(2);
  21   std::expected<int, int> e3(std::unexpect, 3), e4(std::unexpect, 4);
  22
  23   swap(e1, e2);
  24   VERIFY( e1.value() == 2 );
  25   VERIFY( e2.value() == 1 );
  26   swap(e1, e3);
  27   VERIFY( ! e1.has_value() );
  28   VERIFY( e1.error() == 3 );
  29   VERIFY( e3.value() == 2 );
  30   swap(e1, e3);
  31   VERIFY( ! e3.has_value() );
  32   VERIFY( e1.value() == 2 );
  33   VERIFY( e3.error() == 3 );
  34   swap(e3, e4);
  35   VERIFY( ! e3.has_value() );
  36   VERIFY( ! e4.has_value() );
  37   VERIFY( e3.error() == 4 );
  38   VERIFY( e4.error() == 3 );
  39
  40   std::expected<int, NonTrivial> e5(1), e6(2);
  41   std::expected<int, NonTrivial> e7(std::unexpect, 3), e8(std::unexpect, 4);
  42
  43   swap(e5, e6);
  44   VERIFY( e5.value() == 2 );
  45   VERIFY( e6.value() == 1 );
  46   swap(e5, e7);
  47   VERIFY( ! e5.has_value() );
  48   VERIFY( e5.error() == 3 );
  49   VERIFY( e7.value() == 2 );
  50   swap(e5, e7);
  51   VERIFY( ! e7.has_value() );
  52   VERIFY( e5.value() == 2 );
  53   VERIFY( e7.error() == 3 );
  54   swap(e7, e8);
  55   VERIFY( ! e7.has_value() );
  56   VERIFY( ! e8.has_value() );
  57   VERIFY( e7.error() == 4 );
  58   VERIFY( e8.error() == 3 );
  59
  60   std::expected<NonTrivial, int> e9(1), e10(2);
  61   std::expected<NonTrivial, int> e11(std::unexpect, 3), e12(std::unexpect, 4);
  62
  63   swap(e9, e10);
  64   VERIFY( e9.value() == 2 );
  65   VERIFY( e10.value() == 1 );
  66   swap(e9, e11);
  67   VERIFY( ! e9.has_value() );
  68   VERIFY( e9.error() == 3 );
  69   VERIFY( e11.value() == 2 );
  70   swap(e9, e11);
  71   VERIFY( ! e11.has_value() );
  72   VERIFY( e9.value() == 2 );
  73   VERIFY( e11.error() == 3 );
  74   swap(e11, e12);
  75   VERIFY( ! e11.has_value() );
  76   VERIFY( ! e12.has_value() );
  77   VERIFY( e11.error() == 4 );
  78   VERIFY( e12.error() == 3 );
  79
  80   return true;
  81 }
  82
  83 constexpr bool
  84 test_swap_void()
  85 {
  86   std::expected<void, int> v1, v2;
  87   std::expected<void, int> v3(std::unexpect, 3), v4(std::unexpect, 4);
  88
  89   swap(v1, v2);
  90   VERIFY( v1.has_value() );
  91   VERIFY( v2.has_value() );
  92   swap(v1, v3);
  93   VERIFY( ! v1.has_value() );
  94   VERIFY( v1.error() == 3 );
  95   VERIFY( v3.has_value() );
  96   swap(v1, v3);
  97   VERIFY( ! v3.has_value() );
  98   VERIFY( v1.has_value() );
  99   VERIFY( v3.error() == 3 );
 100   swap(v3, v4);
 101   VERIFY( ! v3.has_value() );
 102   VERIFY( ! v4.has_value() );
 103   VERIFY( v3.error() == 4 );
 104   VERIFY( v4.error() == 3 );
 105
 106   std::expected<void, NonTrivial> v5, v6;
 107   std::expected<void, NonTrivial> v7(std::unexpect, 3), v8(std::unexpect, 4);
 108
 109   swap(v5, v6);
 110   VERIFY( v5.has_value() );
 111   VERIFY( v6.has_value() );
 112   swap(v5, v7);
 113   VERIFY( ! v5.has_value() );
 114   VERIFY( v5.error() == 3 );
 115   VERIFY( v7.has_value() );
 116   swap(v5, v7);
 117   VERIFY( ! v7.has_value() );
 118   VERIFY( v5.has_value() );
 119   VERIFY( v7.error() == 3 );
 120   swap(v7, v8);
 121   VERIFY( ! v7.has_value() );
 122   VERIFY( ! v8.has_value() );
 123   VERIFY( v7.error() == 4 );
 124   VERIFY( v8.error() == 3 );
 125
 126   return true;
 127 }
 128
 129 static_assert( std::is_swappable_v<std::expected<int, int>> );
 130 static_assert( std::is_swappable_v<std::expected<void, int>> );
 131
 132 struct A { A& operator=(A&&) = delete; };
 133 static_assert( ! std::is_swappable_v<std::expected<A, int>> );
 134 static_assert( ! std::is_swappable_v<std::expected<int, A>> );
 135 static_assert( ! std::is_swappable_v<std::expected<void, A>> );
 136
 137 int main()
 138 {
 139   static_assert( test_swap_obj() );
 140   test_swap_obj();
 141   static_assert( test_swap_void() );
 142   test_swap_void();
 143 }