20.meta.unary.nothrow.cpp

Go to the documentation of this file.

 
#include <rw_driver.h>
 
#ifndef _RWSTD_NO_EXT_CXX_0X
 
// only compele when C++ 0x extensions are enabled
 
#include <type_traits>
 
#define THROW   public: enum { value = 0 }
#define NOTHROW public: enum { value = 1 }
 
struct A {
    struct A1 { NOTHROW; /* trivial copy ctor */ };
    struct A2 { NOTHROW; A2 (A2&) throw (); };
    struct A3 { NOTHROW; A3 (const A3&) throw (); };
    struct A4 { NOTHROW; A4 (volatile A4&) throw (); };
    struct A5 { NOTHROW; A5 (const volatile A5&) throw (); };
 
#ifndef _RWSTD_NO_RVALUE_REFERENCES
 
    // move ctor overloads (move ctor is not a copy ctor)
    struct A6 { NOTHROW; A6 (A6&&) throw (); };
    struct A7 { NOTHROW; A7 (const A6&&) throw (); };
    struct A8 { NOTHROW; A8 (volatile A6&&) throw (); };
    struct A9 { NOTHROW; A9 (const volatile A6&&) throw (); };
 
#endif   // _RWSTD_NO_RVALUE_REFERENCES
 
};
 
 
struct B {
    struct B1 { THROW; B1 (B1&); };
    struct B2 { THROW; B2 (const B2&); };
    struct B3 { THROW; B3 (volatile B3&); };
    struct B4 { THROW; B4 (const volatile B4&); };
 
#ifndef _RWSTD_NO_RVALUE_REFERENCES
 
    // move ctor overloads (move ctor is not a copy ctor)
    struct B5 { NOTHROW; B5 (B5&&); };
    struct B6 { NOTHROW; B6 (const B6&&); };
    struct B7 { NOTHROW; B7 (volatile B7&&); };
    struct B8 { NOTHROW; B8 (const volatile B8&&); };
 
#endif   // _RWSTD_NO_RVALUE_REFERENCES
 
};
 
 
struct C {
    // same as A::A* but with inaccessible copy ctor
 
    class C1 { NOTHROW; private: /* trivial copy ctor */ };
    class C2 { NOTHROW; private: C2 (C2&) throw (); };
    class C3 { NOTHROW; private: C3 (const C3&) throw (); };
    class C4 { NOTHROW; private: C4 (volatile C4&) throw (); };
    class C5 { NOTHROW; private: C5 (const volatile C5&) throw (); };
 
#ifndef _RWSTD_NO_RVALUE_REFERENCES
 
    // move ctor overloads (move ctor is not a copy ctor)
    class C6 { NOTHROW; private: C6 (C6&&) throw (); };
    class C7 { NOTHROW; private: C7 (const C7&&) throw (); };
    class C8 { NOTHROW; private: C8 (volatile C8&&) throw (); };
    class C9 { NOTHROW; private: C9 (const volatile C9&&) throw (); };
 
#endif   // _RWSTD_NO_RVALUE_REFERENCES
 
};
 
 
struct D {
    // same as B::B* but with inaccessible copy ctor
 
    class D1 { NOTHROW; /* trivial copy ctor */ };
    class D2 { NOTHROW; D2 (D2&) throw (); };
    class D3 { NOTHROW; D3 (const D3&) throw (); };
    class D4 { NOTHROW; D4 (volatile D4&) throw (); };
    class D5 { NOTHROW; D5 (const volatile D5&) throw (); };
 
#ifndef _RWSTD_NO_RVALUE_REFERENCES
 
    // move ctor overloads (move ctor is not a copy ctor)
    class D6 { NOTHROW; D6 (D6&&) throw (); };
    class D7 { NOTHROW; D7 (const D7&&) throw (); };
    class D8 { NOTHROW; D8 (volatile D8&&) throw (); };
    class D9 { NOTHROW; D9 (const volatile D9&&) throw (); };
 
#endif   // _RWSTD_NO_RVALUE_REFERENCES
 
};
 
 
struct E {
    // both const and non-const copy ctors
 
    struct E1 {
        NOTHROW;
        E1 (E1&) throw () { }
        E1 (const E1&) throw () { }
    };
 
    struct E2 {
        THROW;
        E2 (E2&) throw () { }
        E2 (const E2&);
    };
 
    struct E3 {
        THROW;
        E3 (E3&);
        E3 (const E3&) throw () { }
    };
 
    struct E4 {
        THROW;
        E4 (E4&);
        E4 (const E4&);
    };
};
 
 
struct F {
    // non-const, const, and volatile copy ctors
 
    struct F1 {
        NOTHROW;
        F1 (F1&) throw () { }
        F1 (const F1&) throw () { }
        F1 (volatile F1&) throw () { }
    };
 
    struct F2 {
        THROW;
        F2 (F2&) throw () { }
        F2 (const F2&) throw () { }
        F2 (volatile F2&);
    };
 
    struct F3 {
        THROW;
        F3 (F3&) throw () { }
        F3 (const F3&);
        F3 (volatile F3&) throw () { }
    };
 
    struct F4 {
        THROW;
        F4 (F4&);
        F4 (const F4&) throw () { }
        F4 (volatile F4&) throw () { }
    };
};
 
 
struct G {
    // non-const, const, volatile, and const volatile copy ctors
 
    struct G1 {
        NOTHROW;
        G1 (G1&) throw ();
        G1 (const G1&) throw ();
        G1 (volatile G1&) throw ();
        G1 (const volatile G1&) throw ();
    };
 
    struct G2 {
        THROW;
        G2 (G2&) throw ();
        G2 (const G2&) throw ();
        G2 (volatile G2&) throw ();
        G2 (const volatile G2&);
    };
 
    struct G3 {
        THROW;
        G3 (G3&) throw ();
        G3 (const G3&) throw ();
        G3 (volatile G3&);
        G3 (const volatile G3&) throw ();
    };
 
    struct G4 {
        THROW;
        G4 (G4&) throw ();
        G4 (const G4&);
        G4 (volatile G4&) throw ();
        G4 (const volatile G4&) throw ();
    };
 
    struct G5 {
        THROW;
        G5 (G5&);
        G5 (const G5&) throw ();
        G5 (volatile G5&) throw ();
        G5 (const volatile G5&) throw ();
    };
};
 
 
struct H {
    // non-const, const, volatile, and const volatile copy ctors
 
    struct H1 {
        NOTHROW;
        H1 (H1&) throw ();
        H1 (const H1&) throw ();
        H1 (volatile H1&) throw ();
        H1 (const volatile H1&) throw ();
    };
 
    struct H2 {
        THROW;
        H2 (H2&) throw ();
        H2 (const H2&) throw ();
        H2 (volatile H2&) throw ();
        H2 (const volatile H2&);
    };
 
    struct H3 {
        THROW;
        H3 (H3&) throw ();
        H3 (const H3&) throw ();
        H3 (volatile H3&);
        H3 (const volatile H3&) throw ();
    };
 
    struct H4 {
        THROW;
        H4 (H4&) throw ();
        H4 (const H4&);
        H4 (volatile H4&) throw ();
        H4 (const volatile H4&) throw ();
    };
 
    struct H5 {
        THROW;
        H5 (H5&);
        H5 (const H5&) throw ();
        H5 (volatile H5&) throw ();
        H5 (const volatile H5&) throw ();
    };
};
 
 
struct I {
    // non-const, const, volatile, and const volatile copy ctors
    // all with second argument
 
    struct I1 {
        NOTHROW;
        I1 (I1&, int = 0) throw ();
        I1 (const I1&, int = 0) throw ();
        I1 (volatile I1&, int = 0) throw ();
        I1 (const volatile I1&, int = 0) throw ();
    };
 
    struct I2 {
        THROW;
        I2 (I2&, int = 0) throw ();
        I2 (const I2&, int = 0) throw ();
        I2 (volatile I2&, int = 0) throw ();
        I2 (const volatile I2&, int = 0);
    };
 
    struct I3 {
        THROW;
        I3 (I3&, int = 0) throw ();
        I3 (const I3&, int = 0) throw ();
        I3 (volatile I3&, int = 0);
        I3 (const volatile I3&, int = 0) throw ();
    };
 
    struct I4 {
        THROW;
        I4 (I4&, int = 0) throw ();
        I4 (const I4&, int = 0);
        I4 (volatile I4&, int = 0) throw ();
        I4 (const volatile I4&, int = 0) throw ();
    };
 
    struct I5 {
        THROW;
        I5 (I5&, int = 0);
        I5 (const I5&, int = 0) throw ();
        I5 (volatile I5&, int = 0) throw ();
        I5 (const volatile I5&, int = 0) throw ();
    };
};
 
 
struct J {
    // non-const, const, volatile, and const volatile copy ctors
    // plus a template ctor (a template ctor is never a copy ctor)
 
    struct J1 {
        NOTHROW;
        J1 (J1&) throw ();
        J1 (const J1&) throw ();
        J1 (volatile J1&) throw ();
        J1 (const volatile J1&) throw ();
        template <class T> J1 (T); // not a copy ctor
    };
 
    struct J2 {
        NOTHROW;
        J2 (J2&) throw ();
        J2 (const J2&) throw ();
        J2 (volatile J2&) throw ();
        J2 (const volatile J2&) throw ();
        template <class T> J2 (const T&); // not a copy ctor
    };
 
    struct J3 {
        NOTHROW;
        J3 (J3&) throw ();
        J3 (const J3&) throw ();
        J3 (volatile J3&) throw ();
        J3 (const volatile J3&) throw ();
        template <class T> J3 (volatile T&); // not a copy ctor
    };
 
    struct J4 {
        NOTHROW;
        J4 (J4&) throw ();
        J4 (const J4&) throw (){ }
        J4 (volatile J4&) throw ();
        J4 (const volatile J4&) throw ();
        template <class T> J4 (const volatile T&); // not a copy ctor
    };
};
 
 
struct K {
    // nothrow non-const, const, volatile, and const volatile copy
    // ctors plus a throwing non-copy ctor
 
    struct K1 {
        NOTHROW;
        K1 (K1&) throw ();
        K1 (const K1&) throw ();
        K1 (volatile K1&) throw ();
        K1 (const volatile K1&) throw ();
        template <class T> K1 (T) throw (); // not a copy ctor
    };
 
#ifndef _RWSTD_NO_VARIADIC_TEMPLATES
 
    struct K2 {
        NOTHROW;
        K2 (K2&) throw ();
        K2 (const K2&) throw ();
        K2 (volatile K2&) throw ();
        K2 (const volatile K2&) throw ();
        template <class ...T> K2 (T...); // not a copy ctor
    };
 
#endif   // _RWSTD_NO_VARIADIC_TEMPLATES
 
#ifndef _RWSTD_NO_RVALUE_REFERENCES
 
    struct K3 {
        NOTHROW;
        K3 (K3&) throw ();
        K3 (const K3&) throw ();
        K3 (volatile K3&) throw ();
        K3 (const volatile K3&) throw ();
        K3 (K3&&); // not a copy ctor
    };
 
#endif   // _RWSTD_NO_RVALUE_REFERENCES
 
    struct K4 {
        NOTHROW;
        K4 (K4&) throw ();
        K4 (const K4&) throw ();
        K4 (volatile K4&) throw ();
        K4 (const volatile K4&) throw ();
        K4 (...); // not a copy ctor
    };
 
    struct K5 {
        NOTHROW;
        K5 (K5&) throw ();
        K5 (const K5&) throw ();
        K5 (volatile K5&) throw ();
        K5 (const volatile K5&) throw ();
        K5 (int); // not a copy ctor
    };
};
 
struct L {
 
    struct L1 {
        THROW;
        // member non-const copy ctor may throw
        struct L1_1 { L1_1 (L1_1&); } l1_1;
    };
 
    struct L2 {
        THROW;
        // member const copy ctor may throw
        struct L2_1 { L2_1 (const L2_1&); } l2_1;
    };
 
    struct L3 {
        THROW;
        // member volatile copy ctor may throw
        struct L3_1 { L3_1 (volatile L3_1&); } l3_1;
    };
 
    struct L4 {
        THROW;
        // member const volatile copy ctor may throw
        struct L4_1 { L4_1 (const volatile L4_1&); } l4_1;
    };
 
    struct L5 {
        NOTHROW;
        // member non-const copy ctor may throw
        // but same copy ctor of parent class doesn't
        L5 (L5&) throw ();
        struct L5_1 { L5_1 (L5_1&); } l5_1;
    };
 
    struct L6 {
        NOTHROW;
        // member const copy ctor may throw
        // but same copy ctor of parent class doesn't
        L6 (const L6&) throw ();
        struct L6_1 { L6_1 (const L6_1&); } l6_1;
    };
 
    struct L7 {
        NOTHROW;
        // member volatile copy ctor may throw
        // but same copy ctor of parent class doesn't
        L7 (volatile L7&) throw ();
        struct L7_1 { L7_1 (volatile L7_1&); } l7_1;
    };
 
    struct L8 {
        NOTHROW;
        // member const volatile copy ctor may throw
        // but same copy ctor of parent class doesn't
        L8 (const volatile L8&) throw ();
        struct L8_1 { L8_1 (const volatile L8_1&); } l8_1;
    };
 
    struct L9 {
        NOTHROW;
        // member const copy ctor may throw
        // but non-const copy ctor of parent class doesn't
        L9 (L9&) throw ();
        struct L9_1 { L9_1 (const L9_1&); } l9_1;
    };
 
    struct L10 {
        NOTHROW;
        // member non-const copy ctor may throw
        // but const copy ctor of parent class doesn't
        L10 (const L10&) throw ();
        struct L10_1 { L10_1 (L10_1&); } l10_1;
    };
 
    struct L11 {
        NOTHROW;
        L11 (L11&) throw ();
        L11 (const L11&) throw ();
 
        struct L11_1 {
            L11_1 (L11_1&) throw (int);
            L11_1 (const L11_1&) throw (int);
        } l11_1;
    };
 
    struct L12 {
        NOTHROW;
        L12 (const L12&) throw ();
 
        struct L12_1 {
            L12_1 (L12_1&) throw (int);
            L12_1 (const L12_1&) throw (int);
            L12_1 (volatile L12_1&) throw (int);
            L12_1 (const volatile L12_1&) throw (int);
        } l12_1;
    };
 
    struct L13 {
        NOTHROW;
        L13 (const L13&) throw ();
 
        struct L13_1 {
            L13_1 (L13_1&) throw ();
            L13_1 (const L13_1&) throw ();
            L13_1 (volatile L13_1&) throw ();
            L13_1 (const volatile L13_1&) throw ();
        } l13_1;
 
        struct L13_2 {
            L13_2 (L13_2&) throw ();
            L13_2 (const L13_2&) throw ();
            L13_2 (volatile L13_2&) throw ();
            L13_2 (const volatile L13_2&) throw (int);   // may throw
        } l13_2;
    };
 
    struct L14 {
        NOTHROW;
        L14 (const L14&) throw ();
 
        struct L14_1 {
            L14_1 (L14_1&) throw ();
            L14_1 (const L14_1&) throw ();
            L14_1 (volatile L14_1&) throw ();
            L14_1 (const volatile L14_1&) throw ();
        } l14_1;
 
        struct L14_2 {
            L14_2 (L14_2&) throw ();
            L14_2 (const L14_2&) throw ();
            L14_2 (volatile L14_2&) throw (int);    // may throw
            L14_2 (const volatile L14_2&) throw ();
        } l14_2;
    };
 
    struct L15 {
        NOTHROW;
        L15 (const L15&) throw ();
 
        struct L15_1 {
            L15_1 (L15_1&) throw ();
            L15_1 (const L15_1&) throw ();
            L15_1 (volatile L15_1&) throw ();
            L15_1 (const volatile L15_1&) throw ();
        } l15_1;
 
        struct L15_2 {
            L15_2 (L15_2&) throw ();
            L15_2 (const L15_2&) throw (int);   // may throw
            L15_2 (volatile L15_2&) throw ();
            L15_2 (const volatile L15_2&) throw ();
        } l15_2;
    };
 
    struct L16 {
        NOTHROW;
        L16 (const L16&) throw ();
 
        struct L16_1 {
            L16_1 (L16_1&) throw ();
            L16_1 (const L16_1&) throw ();
            L16_1 (volatile L16_1&) throw ();
            L16_1 (const volatile L16_1&) throw ();
        } l16_1;
 
        struct L16_2 {
            L16_2 (L16_2&) throw (int);   // may throw
            L16_2 (const L16_2&) throw ();
            L16_2 (volatile L16_2&) throw ();
            L16_2 (const volatile L16_2&) throw ();
        } l16_2;
    };
};
 
 
static int
test_has_nothrow_copy ()
{
#ifndef _RWSTD_TT_HAS_NOTHROW_COPY
 
    rw_warn (0, 0, __LINE__,
             "test_has_nothrow_copy() disabled because "
             "_RWSTD_TT_HAS_NOTHROW_COPY is not defined");
 
#else
 
    // exercise the has_nothrow_copy_constructor trait
#define TEST(T)                                                         \
    rw_assert (std::has_nothrow_copy_constructor<T>::value == T::value, \
               0, __LINE__,                                             \
               "std::has_nothrow_copy_constructor<%s>::value == %d", #T, \
               std::has_nothrow_copy_constructor<T>::value)
 
    TEST (A::A1);
    TEST (A::A2);
    TEST (A::A3);
    TEST (A::A4);
    TEST (A::A5);
#ifndef _RWSTD_NO_RVALUE_REFERENCES
    TEST (A::A6);
    TEST (A::A7);
    TEST (A::A8);
    TEST (A::A9);
#endif
 
    TEST (B::B1);
    TEST (B::B2);
    TEST (B::B3);
    TEST (B::B4);
#ifndef _RWSTD_NO_RVALUE_REFERENCES
    TEST (B::B5);
    TEST (B::B6);
    TEST (B::B7);
    TEST (B::B8);
#endif
 
    TEST (C::C1);
    TEST (C::C2);
    TEST (C::C3);
    TEST (C::C4);
    TEST (C::C5);
#ifndef _RWSTD_NO_RVALUE_REFERENCES
    TEST (C::C6);
    TEST (C::C7);
    TEST (C::C8);
    TEST (C::C9);
#endif
 
    TEST (D::D1);
    TEST (D::D2);
    TEST (D::D3);
    TEST (D::D4);
    TEST (D::D5);
#ifndef _RWSTD_NO_RVALUE_REFERENCES
    TEST (D::D6);
    TEST (D::D7);
    TEST (D::D8);
    TEST (D::D9);
#endif
 
    TEST (E::E1);
    TEST (E::E2);
    TEST (E::E3);
    TEST (E::E4);
 
    TEST (F::F1);
    TEST (F::F2);
    TEST (F::F3);
    TEST (F::F4);
 
    TEST (G::G1);
    TEST (G::G2);
    TEST (G::G3);
    TEST (G::G4);
    TEST (G::G5);
 
    TEST (H::H1);
    TEST (H::H2);
    TEST (H::H3);
    TEST (H::H4);
    TEST (H::H5);
 
    TEST (I::I1);
    TEST (I::I2);
    TEST (I::I3);
    TEST (I::I4);
    TEST (I::I5);
 
    TEST (J::J1);
    TEST (J::J2);
    TEST (J::J3);
    TEST (J::J4);
 
    TEST (K::K1);
#  ifndef _RWSTD_NO_VARIADIC_TEMPLATES
    TEST (K::K2);
#  endif
#  ifndef _RWSTD_NO_RVALUE_REFERENCES
    TEST (K::K3);
#  endif
    TEST (K::K4);
    TEST (K::K5);
 
    TEST (L::L1);
    TEST (L::L2);
    TEST (L::L3);
    TEST (L::L4);
    TEST (L::L5);
    TEST (L::L6);
    TEST (L::L7);
    TEST (L::L8);
    TEST (L::L9);
    TEST (L::L10);
    TEST (L::L11);
    TEST (L::L12);
    TEST (L::L13);
    TEST (L::L14);
    TEST (L::L15);
    TEST (L::L16);
 
#endif
 
    return 0;
}
 
static int
run_test (int, char*[])
{
    test_has_nothrow_copy ();
 
    return 0;
}
 
 
#else // _RWSTD_NO_EXT_CXX_0X
 
 
static int run_test (int, char*[])
{
    rw_warn (0, 0, __LINE__,
             "test disabled because _RWSTD_NO_EXT_CXX_0X is defined");
    return 0;
}
 
#endif // !_RWSTD_NO_EXT_CXX_0X
 
 
int main (int argc, char*argv[])
{
    return rw_test (argc, argv, __FILE__,
                    "meta.unary.prop",
                    "std::has_nothrow_xxx traits",
                    run_test,
                    0);
}