+2013-11-19 Jonathan Wakely <jwakely.gcc@gmail.com>
+
+ * testsuite/23_containers/forward_list/allocator/noexcept.cc: Change
+ to compile-only test. Adjust swap overload to handle rebound
+ allocators.
+ * testsuite/23_containers/map/allocator/noexcept.cc: Likewise.
+ * testsuite/23_containers/multimap/allocator/noexcept.cc: Likewise.
+ * testsuite/23_containers/multiset/allocator/noexcept.cc: Likewise.
+ * testsuite/23_containers/set/allocator/noexcept.cc: Likewise.
+ * testsuite/23_containers/unordered_map/allocator/noexcept.cc:
+ Likewise.
+ * testsuite/23_containers/unordered_multimap/allocator/noexcept.cc:
+ Likewise.
+ * testsuite/23_containers/unordered_multiset/allocator/noexcept.cc:
+ Likewise.
+ * testsuite/23_containers/unordered_set/allocator/noexcept.cc:
+ Likewise.
+ * testsuite/23_containers/vector/allocator/noexcept.cc: Likewise.
+ * testsuite/23_containers/vector/allocator/swap.cc: Add elements
+ before swapping.
+
2013-11-19 Paolo Carlini <paolo.carlini@oracle.com>
* include/experimental/string_view (_S_max_size): Remove.
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+// { dg-do compile }
// { dg-options "-std=gnu++0x" }
#include <forward_list>
-#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
struct T { int i; };
namespace __gnu_test
{
- inline void
- swap(propagating_allocator<T, true>& l, propagating_allocator<T, true>& r)
- noexcept(false)
- {
- typedef uneq_allocator<T> base_alloc;
- swap(static_cast<base_alloc&>(l), static_cast<base_alloc&>(r));
- }
+ template<typename U>
+ inline void
+ swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
+ noexcept(false)
+ { }
}
using __gnu_test::propagating_allocator;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
- // static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
-}
-
-int main()
-{
- test01();
- test02();
- test03();
- return 0;
+ static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+// { dg-do compile }
// { dg-options "-std=gnu++11" }
#include <map>
-#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
struct T { int i; };
namespace __gnu_test
{
- inline void
- swap(propagating_allocator<std::pair<const T, U>, true>& l,
- propagating_allocator<std::pair<const T, U>, true>& r)
- noexcept(false)
- {
- typedef uneq_allocator<std::pair<const T, U>> base_alloc;
- swap(static_cast<base_alloc&>(l), static_cast<base_alloc&>(r));
- }
+ template<typename U>
+ inline void
+ swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
+ noexcept(false)
+ { }
}
using __gnu_test::propagating_allocator;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
-
-int main()
-{
- test01();
- test02();
- test03();
- return 0;
-}
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+// { dg-do compile }
// { dg-options "-std=gnu++11" }
#include <map>
-#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
struct T { int i; };
namespace __gnu_test
{
- inline void
- swap(propagating_allocator<std::pair<const T, U>, true>& l,
- propagating_allocator<std::pair<const T, U>, true>& r)
- noexcept(false)
- {
- typedef uneq_allocator<std::pair<const T, U>> base_alloc;
- swap(static_cast<base_alloc&>(l), static_cast<base_alloc&>(r));
- }
+ template<typename U>
+ inline void
+ swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
+ noexcept(false)
+ { }
}
using __gnu_test::propagating_allocator;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
-
-int main()
-{
- test01();
- test02();
- test03();
- return 0;
-}
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+// { dg-do compile }
// { dg-options "-std=gnu++11" }
#include <set>
namespace __gnu_test
{
- inline void
- swap(propagating_allocator<T, true>& l,
- propagating_allocator<T, true>& r)
- noexcept(false)
- {
- typedef uneq_allocator<T> base_alloc;
- swap(static_cast<base_alloc&>(l), static_cast<base_alloc&>(r));
- }
+ template<typename U>
+ inline void
+ swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
+ noexcept(false)
+ { }
}
using __gnu_test::propagating_allocator;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
-
-int main()
-{
- test01();
- test02();
- test03();
- return 0;
-}
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+// { dg-do compile }
// { dg-options "-std=gnu++11" }
#include <set>
-#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
struct T { int i; };
namespace __gnu_test
{
- inline void
- swap(propagating_allocator<T, true>& l,
- propagating_allocator<T, true>& r)
- noexcept(false)
- {
- typedef uneq_allocator<T> base_alloc;
- swap(static_cast<base_alloc&>(l), static_cast<base_alloc&>(r));
- }
+ template<typename U>
+ inline void
+ swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
+ noexcept(false)
+ { }
}
using __gnu_test::propagating_allocator;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
-
-int main()
-{
- test01();
- test02();
- test03();
- return 0;
-}
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+// { dg-do compile }
// { dg-options "-std=c++11" }
#include <unordered_map>
-#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
struct T { int i; };
namespace __gnu_test
{
- inline void
- swap(propagating_allocator<T, true>& l, propagating_allocator<T, true>& r)
- noexcept(false)
- {
- typedef uneq_allocator<T> base_alloc;
- swap(static_cast<base_alloc&>(l), static_cast<base_alloc&>(r));
- }
+ template<typename U>
+ inline void
+ swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
+ noexcept(false)
+ { }
}
using __gnu_test::propagating_allocator;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
- // static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
-}
-
-int main()
-{
- test01();
- test02();
- test03();
- return 0;
+ static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+// { dg-do compile }
// { dg-options "-std=c++11" }
#include <unordered_map>
-#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
struct T { int i; };
namespace __gnu_test
{
- inline void
- swap(propagating_allocator<T, true>& l, propagating_allocator<T, true>& r)
- noexcept(false)
- {
- typedef uneq_allocator<T> base_alloc;
- swap(static_cast<base_alloc&>(l), static_cast<base_alloc&>(r));
- }
+ template<typename U>
+ inline void
+ swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
+ noexcept(false)
+ { }
}
using __gnu_test::propagating_allocator;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
- // static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
-}
-
-int main()
-{
- test01();
- test02();
- test03();
- return 0;
+ static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+// { dg-do compile }
// { dg-options "-std=c++11" }
#include <unordered_set>
-#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
struct T { int i; };
namespace __gnu_test
{
- inline void
- swap(propagating_allocator<T, true>& l, propagating_allocator<T, true>& r)
- noexcept(false)
- {
- typedef uneq_allocator<T> base_alloc;
- swap(static_cast<base_alloc&>(l), static_cast<base_alloc&>(r));
- }
+ template<typename U>
+ inline void
+ swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
+ noexcept(false)
+ { }
}
using __gnu_test::propagating_allocator;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
- // static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
-}
-
-int main()
-{
- test01();
- test02();
- test03();
- return 0;
+ static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+// { dg-do compile }
// { dg-options "-std=c++11" }
#include <unordered_set>
-#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
struct T { int i; };
namespace __gnu_test
{
- inline void
- swap(propagating_allocator<T, true>& l, propagating_allocator<T, true>& r)
- noexcept(false)
- {
- typedef uneq_allocator<T> base_alloc;
- swap(static_cast<base_alloc&>(l), static_cast<base_alloc&>(r));
- }
+ template<typename U>
+ inline void
+ swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
+ noexcept(false)
+ { }
}
using __gnu_test::propagating_allocator;
test_type v1(alloc_type(1));
test_type v2(alloc_type(2));
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
- // static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
-}
-
-int main()
-{
- test01();
- test02();
- test03();
- return 0;
+ static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+// { dg-do compile }
// { dg-options "-std=gnu++0x" }
#include <vector>
-#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
struct T { int i; };
namespace __gnu_test
{
- inline void
- swap(propagating_allocator<T, true>& l, propagating_allocator<T, true>& r)
- noexcept(false)
- {
- typedef uneq_allocator<T> base_alloc;
- swap(static_cast<base_alloc&>(l), static_cast<base_alloc&>(r));
- }
+ template<typename U>
+ inline void
+ swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
+ noexcept(false)
+ { }
}
using __gnu_test::propagating_allocator;
static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
}
-
-int main()
-{
- test01();
- test02();
- test03();
- return 0;
-}
typedef propagating_allocator<T, true> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
+ v1.push_back(T());
test_type v2(alloc_type(2));
+ v2.push_back(T());
std::swap(v1, v2);
VERIFY(2 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());