Imported gcc-4.4.3

[msp430-gcc.git] / libstdc++-v3 / testsuite / util / testsuite_rvalref.h

diff --git a/libstdc++-v3/testsuite/util/testsuite_rvalref.h b/libstdc++-v3/testsuite/util/testsuite_rvalref.h
new file mode 100644 (file)
index 0000000..4e2f59c
--- /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
+// <http://www.gnu.org/licenses/>.
+//
+
+#ifndef _GLIBCXX_TESTSUITE_RVALREF_H
+#define _GLIBCXX_TESTSUITE_RVALREF_H 1
+
+#include <testsuite_hooks.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 (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