/***************************************************************************
 *
 * 20.meta.unary.prop.cpp - test exercising meta.unary.prop,
 *                          has_nothrow_xxx traits
 *
 * $Id$
 *
 ***************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 *
 **************************************************************************/

#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);
}