obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 379 insertions, 0 deletions

diff --git a/libstdc++-v3/testsuite/util/debug/checks.h b/libstdc++-v3/testsuite/util/debug/checks.h
new file mode 100644
index 000000000..b42ef1a44
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/debug/checks.h
@@ -0,0 +1,379 @@
+// Copyright (C) 2010 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/>.
+//
+
+#include <vector>
+#include <deque>
+#include <list>
+#ifndef _GLIBCXX_DEBUG
+#  include <debug/vector>
+#  include <debug/deque>
+#  include <debug/list>
+#endif
+#include <testsuite_hooks.h>
+
+namespace __gnu_test
+{
+  template<typename _Tp>
+    struct CopyableValueType
+    {
+      typedef _Tp value_type;
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct CopyableValueType<std::pair<const _Tp1, _Tp2> >
+    {
+      typedef std::pair<_Tp1, _Tp2> value_type;
+    };
+
+  template<typename _Tp>
+    struct generate_unique
+    {
+      typedef _Tp value_type;
+
+      operator value_type()
+      {
+	static value_type _S_;
+	++_S_;
+	return _S_;
+      }
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct generate_unique<std::pair<_Tp1, _Tp2> >
+    {
+      typedef _Tp1 first_type;
+      typedef _Tp2 second_type;
+      typedef std::pair<_Tp1, _Tp2> pair_type;
+      
+      operator pair_type()
+      {
+	static first_type _S_1;
+	static second_type _S_2;
+	++_S_1;
+	++_S_2;
+	return pair_type(_S_1, _S_2);
+      }
+    };
+
+  // Check that invalid range of pointers is detected
+  template<typename _Tp>
+    void
+    check_assign1()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::vector<val_type> vector_type;
+
+      generate_unique<val_type> gu;
+
+      vector_type v;
+      for (int i = 0; i != 5; ++i)
+        v.push_back(gu);
+      VERIFY(v.size() == 5);
+
+      const val_type* first = &v.front() + 1;
+      const val_type* last = first + 2;
+
+      cont_type c1;
+      c1.assign(first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2;
+      c2.assign(last, first); // Expected failure
+    }
+
+  // Check that invalid range of debug random iterators is detected
+  template<typename _Tp>
+    void
+    check_assign2()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::vector<val_type> vector_type;
+
+      generate_unique<val_type> gu;
+
+      vector_type v;
+      for (int i = 0; i != 5; ++i)
+        v.push_back(gu);
+      VERIFY(v.size() == 5);
+
+      typename vector_type::iterator first = v.begin() + 1;
+      typename vector_type::iterator last = first + 2;
+      cont_type c1;
+      c1.assign(first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2;
+      c2.assign(last, first); // Expected failure
+    }
+
+  // Check that invalid range of debug !random debug iterators is detected
+  template<typename _Tp>
+    void
+    check_assign3()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::list<val_type> list_type;
+
+      generate_unique<val_type> gu;
+
+      list_type l;
+      for (int i = 0; i != 5; ++i)
+        l.push_back(gu);
+      VERIFY(l.size() == 5);
+
+      typename list_type::iterator first = l.begin(); ++first;
+      typename list_type::iterator last = first; ++last; ++last;
+      cont_type c1;
+      c1.assign(first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2;
+      c2.assign(last, first); // Expected failure
+    }
+
+  // Check that invalid range of pointers is detected
+  template<typename _Tp>
+    void
+    check_construct1()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::vector<val_type> vector_type;
+
+      generate_unique<val_type> gu;
+
+      vector_type v;
+      for (int i = 0; i != 5; ++i)
+        v.push_back(gu);
+      VERIFY(v.size() == 5);
+
+      val_type *first = &v.front() + 1;
+      val_type *last = first + 2;
+      cont_type c1(first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2(last, first); // Expected failure
+    } 
+
+  // Check that invalid range of debug random iterators is detected
+  template<typename _Tp>
+    void
+    check_construct2()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::vector<val_type> vector_type;
+
+      generate_unique<val_type> gu;
+
+      vector_type v;
+      for (int i = 0; i != 5; ++i)
+        v.push_back(gu);
+      VERIFY(v.size() == 5);
+
+      typename vector_type::iterator first = v.begin() + 1;
+      typename vector_type::iterator last = first + 2;
+      cont_type c1(first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2(last, first); // Expected failure
+    }
+
+  // Check that invalid range of debug not random iterators is detected
+  template<typename _Tp>
+    void
+    check_construct3()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::list<val_type> list_type;
+
+      generate_unique<val_type> gu;
+
+      list_type l;
+      for (int i = 0; i != 5; ++i)
+        l.push_back(gu);
+      VERIFY(l.size() == 5);
+
+      typename list_type::iterator first = l.begin(); ++first;
+      typename list_type::iterator last = first; ++last; ++last;
+      cont_type c1(first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2(last, first); // Expected failure
+    }
+
+  template <typename _Cont>
+    struct InsertRangeHelper
+    {
+      template <typename _It>
+        static void
+        Insert(_Cont& cont, _It first, _It last)
+	{ cont.insert(first, last); }
+    };
+
+  template <typename _Cont>
+    struct InsertRangeHelperAux
+    {
+      template <typename _It>
+        static void
+        Insert(_Cont& cont, _It first, _It last)
+	{ cont.insert(cont.begin(), first, last); }
+    };
+
+  template <typename _Tp1, typename _Tp2>
+    struct InsertRangeHelper<std::vector<_Tp1, _Tp2> >
+    : InsertRangeHelperAux<std::vector<_Tp1, _Tp2> >
+    { };
+
+  template <typename _Tp1, typename _Tp2>
+    struct InsertRangeHelper<std::deque<_Tp1, _Tp2> >
+    : InsertRangeHelperAux<std::deque<_Tp1, _Tp2> >
+    { };
+
+  template <typename _Tp1, typename _Tp2>
+    struct InsertRangeHelper<std::list<_Tp1, _Tp2> >
+    : InsertRangeHelperAux<std::list<_Tp1, _Tp2> >
+    { };
+
+#ifndef _GLIBCXX_DEBUG
+  template <typename _Tp1, typename _Tp2>
+    struct InsertRangeHelper<__gnu_debug::vector<_Tp1, _Tp2> >
+    : InsertRangeHelperAux<__gnu_debug::vector<_Tp1, _Tp2> >
+    { };
+
+  template <typename _Tp1, typename _Tp2>
+    struct InsertRangeHelper<__gnu_debug::deque<_Tp1, _Tp2> >
+    : InsertRangeHelperAux<__gnu_debug::deque<_Tp1, _Tp2> >
+    { };
+
+  template <typename _Tp1, typename _Tp2>
+    struct InsertRangeHelper<__gnu_debug::list<_Tp1, _Tp2> >
+    : InsertRangeHelperAux<__gnu_debug::list<_Tp1, _Tp2> >
+    { };
+#endif
+
+  template<typename _Tp>
+    void
+    check_insert1()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::vector<val_type> vector_type;
+
+      generate_unique<val_type> gu;
+
+      vector_type v;
+      for (int i = 0; i != 5; ++i)
+        v.push_back(gu);
+      VERIFY(v.size() == 5);
+
+      const val_type* first = &v.front() + 1;
+      const val_type* last = first + 2;
+
+      cont_type c1;
+      InsertRangeHelper<cont_type>::Insert(c1, first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2;
+      InsertRangeHelper<cont_type>::Insert(c2, last, first); // Expected failure
+    }
+
+  template<typename _Tp>
+    void
+    check_insert2()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::vector<val_type> vector_type;
+
+      generate_unique<val_type> gu;
+
+      vector_type v;
+      for (int i = 0; i != 5; ++i)
+        v.push_back(gu);
+      VERIFY(v.size() == 5);
+
+      typename vector_type::iterator first = v.begin() + 1;
+      typename vector_type::iterator last = first + 2;
+
+      cont_type c1;
+      InsertRangeHelper<cont_type>::Insert(c1, first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2;
+      InsertRangeHelper<cont_type>::Insert(c2, last, first); // Expected failure
+    }
+
+  template<typename _Tp>
+    void
+    check_insert3()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::list<val_type> list_type;
+
+      generate_unique<val_type> gu;
+
+      list_type l;
+      for (int i = 0; i != 5; ++i)
+        l.push_back(gu);
+      VERIFY(l.size() == 5);
+
+      typename list_type::iterator first = l.begin(); ++first;
+      typename list_type::iterator last = first; ++last; ++last;
+
+      cont_type c1;
+      InsertRangeHelper<cont_type>::Insert(c1, first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2;
+      InsertRangeHelper<cont_type>::Insert(c2, last, first); // Expected failure
+    }
+}
+