X-Git-Url: https://oss.titaniummirror.com/gitweb/?a=blobdiff_plain;f=libstdc%2B%2B-v3%2Ftestsuite%2Futil%2Ftestsuite_rvalref.h;fp=libstdc%2B%2B-v3%2Ftestsuite%2Futil%2Ftestsuite_rvalref.h;h=4e2f59c48f4dbd3aea2b058664d06ed65ee1c979;hb=6fed43773c9b0ce596dca5686f37ac3fc0fa11c0;hp=0000000000000000000000000000000000000000;hpb=27b11d56b743098deb193d510b337ba22dc52e5c;p=msp430-gcc.git
diff --git a/libstdc++-v3/testsuite/util/testsuite_rvalref.h b/libstdc++-v3/testsuite/util/testsuite_rvalref.h
new file mode 100644
index 00000000..4e2f59c4
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_rvalref.h
@@ -0,0 +1,188 @@
+// -*- C++ -*-
+// Testing utilities for the rvalue reference.
+//
+// Copyright (C) 2005, 2007, 2009 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
+// .
+//
+
+#ifndef _GLIBCXX_TESTSUITE_RVALREF_H
+#define _GLIBCXX_TESTSUITE_RVALREF_H 1
+
+#include
+
+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 (although see note just below).
+ class rvalstruct
+ {
+ bool
+ operator=(const rvalstruct&);
+
+// Normally we don't define a copy constructor, as any use of it would
+// show an inefficency. In some cases we know it will be aliased away
+// by the compiler, but it still insists it is defined, so we provide
+// a way of making it public but not giving a body, so any usage would
+// instead fail at link-time.
+#ifdef _GLIBCXX_TESTSUITE_ALLOW_RVALREF_ALIASING
+ public:
+ rvalstruct(const rvalstruct&);
+#else
+ rvalstruct(const rvalstruct&);
+
+ public:
+#endif
+ int val;
+ bool valid;
+
+ rvalstruct() : valid(false)
+ { }
+
+ rvalstruct(int inval) : val(inval), valid(true)
+ { }
+
+ rvalstruct&
+ operator=(int newval)
+ {
+ VERIFY(valid == false);
+ val = newval;
+ valid = true;
+ return *this;
+ }
+
+ rvalstruct(rvalstruct&& in)
+ {
+ VERIFY(in.valid == true);
+ val = in.val;
+ in.valid = false;
+ valid = true;
+ }
+
+ rvalstruct&
+ operator=(rvalstruct&& in)
+ {
+ VERIFY(in.valid == true);
+ val = in.val;
+ in.valid = false;
+ valid = true;
+ return *this;
+ }
+ };
+
+ bool
+ operator==(const rvalstruct& lhs, const rvalstruct& rhs)
+ { return lhs.val == rhs.val; }
+
+ bool
+ operator<(const rvalstruct& lhs, const rvalstruct& rhs)
+ { return lhs.val < rhs.val; }
+
+ void
+ swap(rvalstruct& lhs, rvalstruct& rhs)
+ {
+ 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)
+ {
+ VERIFY(in.valid == true);
+ ++copycount;
+ }
+
+ copycounter(copycounter&& in)
+ {
+ 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)
+ {
+ VERIFY(in.valid == true);
+ ++copycount;
+ val = in.val;
+ valid = true;
+ return true;
+ }
+
+ copycounter&
+ operator=(copycounter&& in)
+ {
+ VERIFY(in.valid == true);
+ val = in.val;
+ in.valid = false;
+ valid = true;
+ return *this;
+ }
+
+ ~copycounter()
+ { valid = false; }
+ };
+
+ int copycounter::copycount = 0;
+
+ bool
+ operator==(const copycounter& lhs, const copycounter& rhs)
+ { return lhs.val == rhs.val; }
+
+ bool
+ operator<(const copycounter& lhs, const copycounter& rhs)
+ { return lhs.val < rhs.val; }
+
+ void
+ swap(copycounter& lhs, copycounter& rhs)
+ {
+ VERIFY(lhs.valid && rhs.valid);
+ int temp = lhs.val;
+ lhs.val = rhs.val;
+ rhs.val = temp;
+ }
+
+} // namespace __gnu_test
+
+#endif // _GLIBCXX_TESTSUITE_TR1_H