Author: sebor Date: Sat Jul 19 20:49:09 2008 New Revision: 678247 URL: http://svn.apache.org/viewvc?rev=678247&view=rev Log: 2008-07-19 Martin Sebor <[EMAIL PROTECTED]>
* tests/utilities/20.meta.unary.nothrow.cpp: New test exercising just the has_nothrow_xxx traits (so far has_nothrow_copy_constructor only). Added: stdcxx/branches/4.3.x/tests/utilities/20.meta.unary.nothrow.cpp (with props) Added: stdcxx/branches/4.3.x/tests/utilities/20.meta.unary.nothrow.cpp URL: http://svn.apache.org/viewvc/stdcxx/branches/4.3.x/tests/utilities/20.meta.unary.nothrow.cpp?rev=678247&view=auto ============================================================================== --- stdcxx/branches/4.3.x/tests/utilities/20.meta.unary.nothrow.cpp (added) +++ stdcxx/branches/4.3.x/tests/utilities/20.meta.unary.nothrow.cpp Sat Jul 19 20:49:09 2008 @@ -0,0 +1,727 @@ +/*************************************************************************** + * + * 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 +run_test (int, char*[]) +{ + // 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); + TEST (A::A6); + TEST (A::A7); + TEST (A::A8); + TEST (A::A9); + + TEST (B::B1); + TEST (B::B2); + TEST (B::B3); + TEST (B::B4); + TEST (B::B5); + TEST (B::B6); + TEST (B::B7); + TEST (B::B8); + + TEST (C::C1); + TEST (C::C2); + TEST (C::C3); + TEST (C::C4); + TEST (C::C5); + TEST (C::C6); + TEST (C::C7); + TEST (C::C8); + TEST (C::C9); + + TEST (D::D1); + TEST (D::D2); + TEST (D::D3); + TEST (D::D4); + TEST (D::D5); + TEST (D::D6); + TEST (D::D7); + TEST (D::D8); + TEST (D::D9); + + 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); + TEST (K::K2); + TEST (K::K3); + 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); + + 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); +} Propchange: stdcxx/branches/4.3.x/tests/utilities/20.meta.unary.nothrow.cpp ------------------------------------------------------------------------------ svn:eol-style = native Propchange: stdcxx/branches/4.3.x/tests/utilities/20.meta.unary.nothrow.cpp ------------------------------------------------------------------------------ svn:keywords = Id