diff options
Diffstat (limited to 'libstdc++-v3/testsuite/util/testsuite_rvalref.h')
| -rw-r--r-- | libstdc++-v3/testsuite/util/testsuite_rvalref.h | 267 |
1 files changed, 267 insertions, 0 deletions
diff --git a/libstdc++-v3/testsuite/util/testsuite_rvalref.h b/libstdc++-v3/testsuite/util/testsuite_rvalref.h new file mode 100644 index 000000000..7725e580a --- /dev/null +++ b/libstdc++-v3/testsuite/util/testsuite_rvalref.h @@ -0,0 +1,267 @@ +// -*- C++ -*- +// Testing utilities for the rvalue reference. +// +// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011 +// 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_RVALREF_H +#define _GLIBCXX_TESTSUITE_RVALREF_H 1 + +#include <testsuite_hooks.h> +#include <bits/functional_hash.h> + +namespace __gnu_test +{ + // This class is designed to test libstdc++'s template-based rvalue + // reference support. It should fail at compile-time if there is an + // attempt to copy it. + struct rvalstruct + { + int val; + bool valid; + + rvalstruct() : val(0), valid(true) + { } + + rvalstruct(int inval) : val(inval), valid(true) + { } + + rvalstruct& + operator=(int newval) + { + val = newval; + valid = true; + return *this; + } + + rvalstruct(const rvalstruct&) = delete; + + rvalstruct(rvalstruct&& in) + { + bool test __attribute__((unused)) = true; + VERIFY( in.valid == true ); + val = in.val; + in.valid = false; + valid = true; + } + + rvalstruct& + operator=(const rvalstruct&) = delete; + + rvalstruct& + operator=(rvalstruct&& in) + { + bool test __attribute__((unused)) = true; + VERIFY( this != &in ); + VERIFY( in.valid == true ); + val = in.val; + in.valid = false; + valid = true; + return *this; + } + }; + + inline bool + operator==(const rvalstruct& lhs, const rvalstruct& rhs) + { return lhs.val == rhs.val; } + + inline bool + operator<(const rvalstruct& lhs, const rvalstruct& rhs) + { return lhs.val < rhs.val; } + + void + swap(rvalstruct& lhs, rvalstruct& rhs) + { + bool test __attribute__((unused)) = true; + VERIFY( lhs.valid && rhs.valid ); + int temp = lhs.val; + lhs.val = rhs.val; + rhs.val = temp; + } + + // This is a moveable class which copies how many times it is copied. + // This is mainly of use in the containers, where the an element inserted + // into a container has to be copied once to get there, but we want to check + // nothing else is copied. + struct copycounter + { + static int copycount; + int val; + bool valid; + + copycounter() : val(0), valid(true) + { } + + copycounter(int inval) : val(inval), valid(true) + { } + + copycounter(const copycounter& in) : val(in.val), valid(true) + { + bool test __attribute__((unused)) = true; + VERIFY( in.valid == true ); + ++copycount; + } + + copycounter(copycounter&& in) + { + bool test __attribute__((unused)) = true; + VERIFY( in.valid == true ); + val = in.val; + in.valid = false; + valid = true; + } + + copycounter& + operator=(int newval) + { + val = newval; + valid = true; + return *this; + } + + bool + operator=(const copycounter& in) + { + bool test __attribute__((unused)) = true; + VERIFY( in.valid == true ); + ++copycount; + val = in.val; + valid = true; + return true; + } + + copycounter& + operator=(copycounter&& in) + { + bool test __attribute__((unused)) = true; + VERIFY(in.valid == true); + val = in.val; + in.valid = false; + valid = true; + return *this; + } + + ~copycounter() + { valid = false; } + }; + + int copycounter::copycount = 0; + + inline bool + operator==(const copycounter& lhs, const copycounter& rhs) + { return lhs.val == rhs.val; } + + inline bool + operator<(const copycounter& lhs, const copycounter& rhs) + { return lhs.val < rhs.val; } + + inline void + swap(copycounter& lhs, copycounter& rhs) + { + bool test __attribute__((unused)) = true; + VERIFY( lhs.valid && rhs.valid ); + int temp = lhs.val; + lhs.val = rhs.val; + rhs.val = temp; + } + + // In the occasion of libstdc++/48038. + struct rvalstruct_compare_by_value + { + int val; + bool ok; + + rvalstruct_compare_by_value(int v) + : val(v), ok(true) { } + + rvalstruct_compare_by_value(const rvalstruct_compare_by_value& rh) + : val(rh.val), ok(rh.ok) + { + bool test __attribute__((unused)) = true; + VERIFY(rh.ok); + } + + rvalstruct_compare_by_value& + operator=(const rvalstruct_compare_by_value& rh) + { + bool test __attribute__((unused)) = true; + VERIFY( rh.ok ); + val = rh.val; + ok = rh.ok; + return *this; + } + + rvalstruct_compare_by_value(rvalstruct_compare_by_value&& rh) + : val(rh.val), ok(rh.ok) + { + bool test __attribute__((unused)) = true; + VERIFY( rh.ok ); + rh.ok = false; + } + + rvalstruct_compare_by_value& + operator=(rvalstruct_compare_by_value&& rh) + { + bool test __attribute__((unused)) = true; + VERIFY( rh.ok ); + val = rh.val; + ok = rh.ok; + rh.ok = false; + return *this; + } + }; + + inline bool + operator<(rvalstruct_compare_by_value lh, + rvalstruct_compare_by_value rh) + { + bool test __attribute__((unused)) = true; + VERIFY( rh.ok ); + VERIFY( lh.ok ); + return lh.val < rh.val; + } + + inline bool + order(rvalstruct_compare_by_value lh, + rvalstruct_compare_by_value rh) + { + bool test __attribute__((unused)) = true; + VERIFY( rh.ok ); + VERIFY( lh.ok ); + return lh.val < rh.val; + } + +} // namespace __gnu_test + +namespace std +{ + /// std::hash specialization for __gnu_test::rvalstruct. + template<> + struct hash<__gnu_test::rvalstruct> + { + typedef size_t result_type; + typedef __gnu_test::rvalstruct argument_type; + + size_t + operator()(const __gnu_test::rvalstruct& __rvs) const + { return __rvs.val; } + }; +} + +#endif // _GLIBCXX_TESTSUITE_TR1_H |