Subversion Repositories openrisc

// Copyright (C) 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/>.
//
 
#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;
 
      value_type build()
      {
	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;
 
      pair_type build()
      {
	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.build());
      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.build());
      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.build());
      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.build());
      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.build());
      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.build());
      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.build());
      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.build());
      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.build());
      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
    }
 
  template<typename _Tp>
    void use_invalid_iterator()
    {
      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;
      generate_unique<val_type> gu;
 
      cont_type c;
      for (size_t i = 0; i != 5; ++i)
	c.insert(gu.build());
 
      typename cont_type::iterator it = c.begin();
      cont_val_type val = *it;
      c.clear();
      VERIFY( *it == val );
    }
}