Ticket #68225: test.cpp

#include <optional>
#include <any>
#include <iostream>
#include <string_view>
#include <variant>
#include <type_traits>
#include <numeric>
#include <limits>
#include <string>
#include <cassert>
#include <cstdint>

namespace
{
  // func is enabled if all Ts... have the same type as T
  template < typename T, typename... Ts >
  std::enable_if_t< std::conjunction_v< std::is_same< T, Ts >... > > func( T, Ts... )
  {
    std::cout << "all types in pack are T\n";
  }
  // otherwise
  template < typename T, typename... Ts >
  std::enable_if_t< !std::conjunction_v< std::is_same< T, Ts >... > > func( T, Ts... )
  {
    std::cout << "not all types in pack are T\n";
  }
  struct S
  {
    mutable int x1 : 2;
    double      y1;
  };
  S f() { return S { 1, 2.3 }; }
} // namespace

void
test_structured_bindings()
{
  const auto [ x, y ] = f();          // x is an int lvalue identifying the 2-bit bit field
                                      // y is a const volatile double lvalue
  std::cout << x << ' ' << y << '\n'; // 1 2.3
  x = -2;                             // OK
                                      //  y = -2.;  // Error: y is const-qualified
  std::cout << x << ' ' << y << '\n'; // -2 2.3
}

void
test_conjuction()
{
  func( 1, 2, 3 );
  func( 1, 2.0, "test_conjuction" );
}

void
test_constexpr_lambda()
{
  auto Fwd = []( int ( *fp )( int ), auto a ) { return fp( a ); };
  auto C   = []( auto a ) { return a; };
  static_assert( Fwd( C, 3 ) == 3 ); // OK
}

void
test_variant()
{
  std::variant< int, float > v, w;
  v     = 42; // v contains int
  int i = std::get< int >( v );
  std::cout << "variant<int> = " << i << std::endl;
  assert( 42 == i ); // succeeds
  w = std::get< int >( v );
  w = std::get< 0 >( v ); // same effect as the previous line
  w = v;                  // same effect as the previous line

  try
  {
    std::get< float >( w ); // w contains int, not float: will throw
  }
  catch ( const std::bad_variant_access &ex )
  {
    std::cout << "test_variant: " << ex.what() << '\n';
  }

  using namespace std::literals;

  // converting constructors work when unambiguous
  std::variant< std::string > x( "abc" );
  // converting assignment also works when unambiguous
  x = "def";

  std::variant< std::string, void const * > y( "abc" );
  // casts to void const * when passed a char const *
  assert( std::holds_alternative< void const * >( y ) ); // succeeds
  y = "xyz"s;
  assert( std::holds_alternative< std::string >( y ) ); // succeeds
}

void
test_optional()
{
  std::optional< int > i = 321;
  std::cout << "optional i = " << i.value() << std::endl;
}

void
test_any()
{
  // any type
  std::any a = 1;
  std::cout << a.type().name() << ": " << std::any_cast< int >( a ) << '\n';
  a = 3.14;
  std::cout << a.type().name() << ": " << std::any_cast< double >( a ) << '\n';
  a = true;
  std::cout << a.type().name() << ": " << std::any_cast< bool >( a ) << '\n';
  a = "FooBar";
  std::cout << a.type().name() << ": " << std::any_cast< const char* >( a ) << '\n';
}

void
test_string_view()
{

  constexpr std::string_view unicode[] { "▀▄─", "▄▀─", "▀─▄", "▄─▀" };

  for ( int y {}, p {}; y != 6; ++y, p = ( ( p + 1 ) % 4 ) )
  {
    for ( int x {}; x != 16; ++x ) { std::cout << unicode[ p ]; }
    std::cout << '\n';
  }
}

void
test_limits()
{
  const auto l_int = std::numeric_limits< std::int32_t >::lowest();
  const auto h_int = std::numeric_limits< std::int32_t >::max();

  const auto l_short = (std::int16_t)l_int;
  const auto h_short = (std::int16_t)h_int;

  std::cout << l_int << " " << l_short << std::endl;
  std::cout << h_int << " " << h_short << std::endl;
}

int
main()
{
  test_variant();
  test_optional();
  test_any();
  test_string_view();
  test_constexpr_lambda();
  test_conjuction();
  test_structured_bindings();
  test_limits();
  return 0;
}