Update copyright years.

[thirdparty/gcc.git] / libstdc++-v3 / testsuite / util / testsuite_tr1.h

// -*- C++ -*-
// Testing utilities for the tr1 testsuite.
//
// Copyright (C) 2004-2022 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3.  If not see
// <http://www.gnu.org/licenses/>.
//

#ifndef _GLIBCXX_TESTSUITE_TR1_H
#define _GLIBCXX_TESTSUITE_TR1_H

#include <ext/type_traits.h>
#include <testsuite_hooks.h>

namespace __gnu_test
{
  // For tr1/type_traits.
  template<template<typename> class Category, typename Type>
#if __cplusplus >= 201103L
    constexpr
#endif
    bool
    test_category(bool value)
    {
      return (Category<Type>::value == value
	      && Category<const Type>::value == value
	      && Category<volatile Type>::value == value
	      && Category<const volatile Type>::value == value
	      && Category<Type>::type::value == value
	      && Category<const Type>::type::value == value
	      && Category<volatile Type>::type::value == value
	      && Category<const volatile Type>::type::value == value);
    }

  // For testing tr1/type_traits/extent, which has a second template
  // parameter.
  template<template<typename, unsigned> class Property,
	   typename Type, unsigned Uint>
#if __cplusplus >= 201103L
    constexpr
#endif
    bool
    test_property(typename Property<Type, Uint>::value_type value)
    {
      return (Property<Type, Uint>::value == value
	      && Property<Type, Uint>::type::value == value);
    }

#if __cplusplus >= 201103L
  template<template<typename...> class Property,
	   typename Type1, typename... Types>
    constexpr bool
    test_property(typename Property<Type1, Types...>::value_type value)
    {
      return (Property<Type1, Types...>::value == value
	      && Property<Type1, Types...>::type::value == value);
    }
#else
  template<template<typename> class Property, typename Type>
    bool
    test_property(typename Property<Type>::value_type value)
    {
      return (Property<Type>::value == value
	      && Property<Type>::type::value == value);
    }
#endif

  template<template<typename, typename> class Relationship,
	   typename Type1, typename Type2>
#if __cplusplus >= 201103L
    constexpr
#endif
    bool
    test_relationship(bool value)
    {
      return (Relationship<Type1, Type2>::value == value
	      && Relationship<Type1, Type2>::type::value == value);
    }

  // Test types.
  class ClassType { };
  typedef const ClassType           cClassType;
  typedef volatile ClassType        vClassType;
  typedef const volatile ClassType  cvClassType;

  class DerivedType : public ClassType { };

#if __cplusplus >= 201103L
  class FinalType final : public DerivedType { };
#endif

  enum EnumType { e0 };

  struct ConvType
  { operator int() const; };

  class AbstractClass
  {
    virtual void rotate(int) = 0;
  };

  class PolymorphicClass
  {
    virtual void rotate(int);
  };

  class DerivedPolymorphic : public PolymorphicClass { };

  class VirtualDestructorClass
  {
    virtual ~VirtualDestructorClass();
  };

  union UnionType { };

  union IncompleteUnion;

  class IncompleteClass;

  struct ExplicitClass
  {
    ExplicitClass(double&);
    explicit ExplicitClass(int&);
    ExplicitClass(double&, int&, double&);
  };

  struct NothrowExplicitClass
  {
    NothrowExplicitClass(double&) throw();
    explicit NothrowExplicitClass(int&) throw();
    NothrowExplicitClass(double&, int&, double&) throw();
  };

  struct ThrowExplicitClass
  {
    ThrowExplicitClass(double&) THROW(int);
    explicit ThrowExplicitClass(int&) THROW(int);
    ThrowExplicitClass(double&, int&, double&) THROW(int);
  };

  struct ThrowDefaultClass
  {
    ThrowDefaultClass() THROW(int);
  };

  struct ThrowCopyConsClass
  {
    ThrowCopyConsClass(const ThrowCopyConsClass&) THROW(int);
  };

#if __cplusplus >= 201103L
  struct ThrowMoveConsClass
  {
    ThrowMoveConsClass(ThrowMoveConsClass&&) noexcept(false);
  };

  struct NoexceptExplicitClass
  {
    NoexceptExplicitClass(double&) noexcept(true);
    explicit NoexceptExplicitClass(int&) noexcept(true);
    NoexceptExplicitClass(double&, int&, double&) noexcept(true);
  };

  struct ExceptExplicitClass
  {
    ExceptExplicitClass(double&) noexcept(false);
    explicit ExceptExplicitClass(int&) noexcept(false);
    ExceptExplicitClass(double&, int&, double&) noexcept(false);
  };

  struct NoexceptDefaultClass
  {
    NoexceptDefaultClass() noexcept(true);
  };

  struct ExceptDefaultClass
  {
    ExceptDefaultClass() noexcept(false);
  };

  struct NoexceptCopyConsClass
  {
    NoexceptCopyConsClass(const NoexceptCopyConsClass&) noexcept(true);
  };

  struct ExceptCopyConsClass
  {
    ExceptCopyConsClass(const ExceptCopyConsClass&) noexcept(false);
  };

  struct NoexceptMoveConsClass
  {
    NoexceptMoveConsClass(NoexceptMoveConsClass&&) noexcept(true);
    NoexceptMoveConsClass& operator=(NoexceptMoveConsClass&&) = default;
  };

  struct ExceptMoveConsClass
  {
    ExceptMoveConsClass(ExceptMoveConsClass&&) noexcept(false);
  };

  struct NoexceptCopyAssignClass
  {
    NoexceptCopyAssignClass&
    operator=(const NoexceptCopyAssignClass&) noexcept(true);
  };

  struct ExceptCopyAssignClass
  {
    ExceptCopyAssignClass&
    operator=(const ExceptCopyAssignClass&) noexcept(false);
  };

  struct NoexceptMoveAssignClass
  {
    NoexceptMoveAssignClass(NoexceptMoveAssignClass&&) = default;
    NoexceptMoveAssignClass&
    operator=(NoexceptMoveAssignClass&&) noexcept(true);
  };

  struct ExceptMoveAssignClass
  {
    ExceptMoveAssignClass&
    operator=(ExceptMoveAssignClass&&) noexcept(false);
  };

  struct DeletedCopyAssignClass
  {
    DeletedCopyAssignClass&
    operator=(const DeletedCopyAssignClass&) = delete;
  };

  struct DeletedMoveAssignClass
  {
    DeletedMoveAssignClass&
    operator=(DeletedMoveAssignClass&&) = delete;
  };

  struct NoexceptMoveConsNoexceptMoveAssignClass
  {
    NoexceptMoveConsNoexceptMoveAssignClass
    (NoexceptMoveConsNoexceptMoveAssignClass&&) noexcept(true);

    NoexceptMoveConsNoexceptMoveAssignClass&
    operator=(NoexceptMoveConsNoexceptMoveAssignClass&&) noexcept(true);
  };

  struct ExceptMoveConsNoexceptMoveAssignClass
  {
    ExceptMoveConsNoexceptMoveAssignClass
    (ExceptMoveConsNoexceptMoveAssignClass&&) noexcept(false);

    ExceptMoveConsNoexceptMoveAssignClass&
    operator=(ExceptMoveConsNoexceptMoveAssignClass&&) noexcept(true);
  };

  struct NoexceptMoveConsExceptMoveAssignClass
  {
    NoexceptMoveConsExceptMoveAssignClass
    (NoexceptMoveConsExceptMoveAssignClass&&) noexcept(true);

    NoexceptMoveConsExceptMoveAssignClass&
    operator=(NoexceptMoveConsExceptMoveAssignClass&&) noexcept(false);
  };

  struct ExceptMoveConsExceptMoveAssignClass
  {
    ExceptMoveConsExceptMoveAssignClass
    (ExceptMoveConsExceptMoveAssignClass&&) noexcept(false);

    ExceptMoveConsExceptMoveAssignClass&
    operator=(ExceptMoveConsExceptMoveAssignClass&&) noexcept(false);
  };
#endif

  struct NType   // neither trivial nor standard-layout
  {
    int i;
    int j;
    virtual ~NType();
  };

  struct TType   // trivial but not standard-layout
  {
    int i;
  private:
    int j;
  };

  struct SLType  // standard-layout but not trivial
  {
    int i;
    int j;
    ~SLType();
  };

  struct PODType // both trivial and standard-layout
  {
    int i;
    int j;
  };

#if __cplusplus >= 201103L
  struct LType // literal type
  {
    int _M_i;

    constexpr LType(int __i) : _M_i(__i) { }
  };

  struct LTypeDerived : public LType
  {
    constexpr LTypeDerived(int __i) : LType(__i) { }
  };

  struct NLType // not literal type
  {
    int _M_i;

    NLType() : _M_i(0) { }

    constexpr NLType(int __i) : _M_i(__i) { }

    NLType(const NLType& __other) : _M_i(__other._M_i) { }

    ~NLType() { _M_i = 0; }
  };
#endif

  int truncate_float(float x) { return (int)x; }
  long truncate_double(double x) { return (long)x; }

  struct do_truncate_float_t
  {
    do_truncate_float_t()
    {
      ++live_objects;
    }

    do_truncate_float_t(const do_truncate_float_t&)
    {
      ++live_objects;
    }

    ~do_truncate_float_t()
    {
      --live_objects;
    }

    int operator()(float x) { return (int)x; }

    static int live_objects;
  };

  int do_truncate_float_t::live_objects = 0;

  struct do_truncate_double_t
  {
    do_truncate_double_t()
    {
     ++live_objects;
    }

    do_truncate_double_t(const do_truncate_double_t&)
    {
      ++live_objects;
    }

    ~do_truncate_double_t()
    {
      --live_objects;
    }

    long operator()(double x) { return (long)x; }

    static int live_objects;
  };

  int do_truncate_double_t::live_objects = 0;

  struct X
  {
    int bar;

    int foo()                   { return 1; }
    int foo_c() const           { return 2; }
    int foo_v()  volatile       { return 3; }
    int foo_cv() const volatile { return 4; }
  };

  // For use in 8_c_compatibility.
  template<typename R, typename T>
    typename __gnu_cxx::__enable_if<std::__are_same<R, T>::__value,
				    bool>::__type
    check_ret_type(T)
    { return true; }

#if __cplusplus >= 201103L
  namespace construct
  {
    struct Empty {};

    struct B { int i; B(){} };
    struct D : B {};

    enum E { ee1 };
    enum E2 { ee2 };
    enum class SE { e1 };
    enum class SE2 { e2 };

    enum OpE : int;
    enum class OpSE : bool;

    union U { int i; Empty b; };

    struct Abstract
    {
      virtual ~Abstract() = 0;
    };

    struct AbstractDelDtor
    {
      ~AbstractDelDtor() = delete;
      virtual void foo() = 0;
    };

    struct Ukn;

    template<class To>
      struct ImplicitTo
      {
	operator To();
      };

    template<class To>
      struct DelImplicitTo
      {
	operator To() = delete;
      };

    template<class To>
      struct ExplicitTo
      {
	explicit operator To();
      };

    struct Ellipsis
    {
      Ellipsis(...){}
    };

    struct DelEllipsis
    {
      DelEllipsis(...) = delete;
    };

    struct Any
    {
      template<class T>
      Any(T&&){}
    };

    struct nAny
    {
      template<class... T>
      nAny(T&&...){}
    };

    struct DelnAny
    {
      template<class... T>
        DelnAny(T&&...) = delete;
    };

    template<class... Args>
      struct FromArgs
      {
	FromArgs(Args...);
      };

    struct DelDef
    {
      DelDef() = delete;
    };

    struct DelCopy
    {
      DelCopy(const DelCopy&) = delete;
    };

    struct DelDtor
    {
      DelDtor() = default;
      DelDtor(const DelDtor&) = default;
      DelDtor(DelDtor&&) = default;
      DelDtor(int);
      DelDtor(int, B, U);
      ~DelDtor() = delete;
    };

    struct Nontrivial
    {
      Nontrivial();
      Nontrivial(const Nontrivial&);
      Nontrivial& operator=(const Nontrivial&);
      ~Nontrivial();
    };

    union NontrivialUnion
    {
      int i;
      Nontrivial n;
    };

    struct UnusualCopy
    {
      UnusualCopy(UnusualCopy&);
    };
  }

  namespace destruct
  {
    struct E
    {};

    struct NTD1
    {
      ~NTD1() = default;
    };

    struct NTD2
    {
      ~NTD2();
    };

    struct NTD3
    {
      ~NTD3() throw();
    };

    struct TD1
    {
      ~TD1() noexcept(false);
    };

    struct TD2
    {
      ~TD2() THROW(int);
    };

    struct Aggr
    {
      int i;
      bool b;
      E e;
    };

    struct Aggr2
    {
      int i;
      bool b;
      TD1 r;
    };

    struct Del
    {
      ~Del() = delete;
    };

    struct Del2
    {
      ~Del2() noexcept = delete;
    };

    struct Del3
    {
      ~Del3() noexcept(false) = delete;
    };

    struct Der : Aggr
    {};

    struct Der2 : Aggr2
    {};

    union U1
    {
      int i;
      double d;
      void* p;
      TD1* pt;
    };

    union Ut
    {
      int i;
      double d;
      void* p;
      TD1 pt;
    };

    enum class En { a, b, c, d };
    enum En2 { En2a, En2b, En2c, En2d };

    enum OpE : int;
    enum class OpSE : bool;

    struct Abstract1
    {
      virtual ~Abstract1() = 0;
    };

    struct AbstractDelDtor
    {
      ~AbstractDelDtor() = delete;
      virtual void foo() = 0;
    };

    struct Abstract2
    {
      virtual ~Abstract2() noexcept(false) = 0;
    };

    struct Abstract3
    {
      ~Abstract3() noexcept(false);
      virtual void foo() noexcept = 0;
    };

    struct Nontrivial
    {
      Nontrivial();
      Nontrivial(const Nontrivial&);
      Nontrivial& operator=(const Nontrivial&);
      ~Nontrivial();
    };

    union NontrivialUnion
    {
      int i;
      Nontrivial n;
    };

    struct UnusualCopy
    {
      UnusualCopy(UnusualCopy&);
    };

    struct Ellipsis
    {
      Ellipsis(...){}
    };

    struct DelEllipsis
    {
      DelEllipsis(...) = delete;
    };

    struct DelDef
    {
      DelDef() = delete;
    };

    struct DelCopy
    {
      DelCopy(const DelCopy&) = delete;
    };
  }

  namespace assign
  {
    struct Empty {};

    struct B { int i; B(){} };
    struct D : B {};

    enum E { ee1 };
    enum E2 { ee2 };
    enum class SE { e1 };
    enum class SE2 { e2 };

    enum OpE : int;
    enum class OpSE : bool;

    union U { int i; Empty b; };

    union UAssignAll
    {
      bool b;
      char c;
      template<class T>
      void operator=(T&&);
    };

    union UDelAssignAll
    {
      bool b;
      char c;
      template<class T>
      void operator=(T&&) = delete;
    };

    struct Abstract
    {
      virtual ~Abstract() = 0;
    };

    struct AbstractDelDtor
    {
      ~AbstractDelDtor() = delete;
      virtual void foo() = 0;
    };

    struct Ukn;

    template<class To>
      struct ImplicitTo
      {
	operator To();
      };

    template<class To>
      struct ExplicitTo
      {
	explicit operator To();
      };

    template<class To>
      struct DelImplicitTo
      {
	operator To() = delete;
      };

    template<class To>
      struct DelExplicitTo
      {
	explicit operator To() = delete;
      };

    struct Ellipsis
    {
      Ellipsis(...){}
    };

    struct DelEllipsis
    {
      DelEllipsis(...) = delete;
    };

    struct Any
    {
      template<class T>
        Any(T&&){}
    };

    struct nAny
    {
      template<class... T>
        nAny(T&&...){}
    };

    struct DelnAny
    {
      template<class... T>
        DelnAny(T&&...) = delete;
    };

    template<class... Args>
      struct FromArgs
      {
	FromArgs(Args...);
      };

    template<class... Args>
      struct DelFromArgs
      {
	DelFromArgs(Args...) = delete;
      };

    struct DelDef
    {
      DelDef() = delete;
    };

    struct DelCopy
    {
      DelCopy(const DelCopy&) = delete;
    };

    struct DelDtor
    {
      DelDtor() = default;
      DelDtor(const DelDtor&) = default;
      DelDtor(DelDtor&&) = default;
      DelDtor(int);
      DelDtor(int, B, U);
      ~DelDtor() = delete;
    };

    struct Nontrivial
    {
      Nontrivial();
      Nontrivial(const Nontrivial&);
      Nontrivial& operator=(const Nontrivial&);
      ~Nontrivial();
    };

    union NontrivialUnion
    {
      int i;
      Nontrivial n;
    };

    struct UnusualCopy
    {
      UnusualCopy(UnusualCopy&);
    };

    struct AnyAssign
    {
      template<class T>
        void operator=(T&&);
    };

    struct DelAnyAssign
    {
      template<class T>
        void operator=(T&&) = delete;
    };

    struct DelCopyAssign
    {
      DelCopyAssign& operator=(const DelCopyAssign&) = delete;
      DelCopyAssign& operator=(DelCopyAssign&&) = default;
    };

    struct MO
    {
      MO(MO&&) = default;
      MO& operator=(MO&&) = default;
    };
  }

  struct CopyConsOnlyType
  {
    CopyConsOnlyType(int) { }
    CopyConsOnlyType(CopyConsOnlyType&&) = delete;
    CopyConsOnlyType(const CopyConsOnlyType&) = default;
    CopyConsOnlyType& operator=(const CopyConsOnlyType&) = delete;
    CopyConsOnlyType& operator=(CopyConsOnlyType&&) = delete;
  };

  struct MoveConsOnlyType
  {
    MoveConsOnlyType(int) { }
    MoveConsOnlyType(const MoveConsOnlyType&) = delete;
    MoveConsOnlyType(MoveConsOnlyType&&) = default;
    MoveConsOnlyType& operator=(const MoveConsOnlyType&) = delete;
    MoveConsOnlyType& operator=(MoveConsOnlyType&&) = delete;
  };
#endif

} // namespace __gnu_test

#endif // _GLIBCXX_TESTSUITE_TR1_H