diff options
Diffstat (limited to 'libstdc++-v3/testsuite/util/testsuite_io.h')
| -rw-r--r-- | libstdc++-v3/testsuite/util/testsuite_io.h | 319 |
1 files changed, 319 insertions, 0 deletions
diff --git a/libstdc++-v3/testsuite/util/testsuite_io.h b/libstdc++-v3/testsuite/util/testsuite_io.h new file mode 100644 index 000000000..681448aa5 --- /dev/null +++ b/libstdc++-v3/testsuite/util/testsuite_io.h @@ -0,0 +1,319 @@ +// -*- C++ -*- +// Testing streambuf/filebuf/stringbuf for the C++ library testsuite. +// +// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 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/>. +// + +#ifndef _GLIBCXX_TESTSUITE_IO_H +#define _GLIBCXX_TESTSUITE_IO_H + +#include <ios> + +namespace __gnu_test +{ + // Used to verify the constraints/requirements on get and put areas + // as defined in + // 27.5.1 - Stream buffer requirements: get and put areas + // 27.8.1.1 - Template class basic_filebuf p 3 + // If the file is not open (ios_base::in) -> input seq. cannot be read + // If the file is not open (ios_base::out) -> output seq. cannot be written + // Joint file position + // 27.8.1.4 - Overridden virtual functions p9 + // If unbuffered, pbase == pptr == NULL + // 27.7.1.1 - Basic_stringbuf constructors p 1 + // 27.8.1.2 - Basic_filebuf constructors p 1 + // ... , initializing the base class with basic_streambuf() 27.5.2.1 + template<typename T> + class constraint_buf + : public T + { + public: + bool + write_position() + { + bool one = this->pptr() != 0; + bool two = this->pptr() < this->epptr(); + return one && two; + } + + bool + read_position() + { + bool one = this->gptr() != 0; + bool two = this->gptr() < this->egptr(); + return one && two; + } + + bool + unbuffered() + { + bool one = this->pbase() == 0; + bool two = this->pptr() == 0; + return one && two; + } + + bool + check_pointers() + { + bool one = this->eback() == 0; + bool two = this->gptr() == 0; + bool three = this->egptr() == 0; + + bool four = this->pbase() == 0; + bool five = this->pptr() == 0; + bool six = this->epptr() == 0; + return one && two && three && four && five && six; + } + }; + + typedef constraint_buf<std::streambuf> constraint_streambuf; + typedef constraint_buf<std::filebuf> constraint_filebuf; + typedef constraint_buf<std::stringbuf> constraint_stringbuf; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef constraint_buf<std::wstreambuf> constraint_wstreambuf; + typedef constraint_buf<std::wfilebuf> constraint_wfilebuf; + typedef constraint_buf<std::wstringbuf> constraint_wstringbuf; +#endif + + // Used to check if basic_streambuf::pubsync() has been called. + // This is useful for checking if a function creates [io]stream::sentry + // objects, since the sentry constructors call tie()->flush(). + template<typename T> + class sync_buf + : public T + { + private: + bool m_sync_called; + + public: + sync_buf() + : m_sync_called(false) + { } + + bool sync_called() const + { return m_sync_called; } + + protected: + int sync() + { + m_sync_called = true; + return 0; + } + }; + + typedef sync_buf<std::streambuf> sync_streambuf; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef sync_buf<std::wstreambuf> sync_wstreambuf; +#endif + + // Throws on all overflow and underflow calls. + struct underflow_error: std::exception { }; + struct overflow_error: std::exception { }; + struct positioning_error: std::exception { }; + + template<typename T> + struct fail_buf + : public T + { + typedef typename T::char_type char_type; + typedef typename T::int_type int_type; + typedef typename T::off_type off_type; + typedef typename T::pos_type pos_type; + + private: + char_type p[2]; + + public: + fail_buf() + { + p[0] = char_type('s'); + p[1] = char_type(); + setg(p, p, p + 1); + } + + virtual int_type underflow() + { + throw underflow_error(); + return int_type(); + } + + virtual int_type uflow() + { + throw underflow_error(); + return int_type(); + } + + virtual int_type + overflow(int_type) + { + throw overflow_error(); + return int_type(); + } + + virtual pos_type + seekoff(off_type, std::ios_base::seekdir, std::ios_base::openmode) + { + throw positioning_error(); + return pos_type(off_type(-1)); + } + + virtual pos_type + seekpos(pos_type, std::ios_base::openmode) + { + throw positioning_error(); + return pos_type(off_type(-1)); + } + + virtual int + sync() + { + throw positioning_error(); + return 0; + } + }; + + typedef fail_buf<std::streambuf> fail_streambuf; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef fail_buf<std::wstreambuf> fail_wstreambuf; +#endif + + // Facets that throw an exception for every virtual function. + struct facet_error: std::exception { }; + + template<typename T> + class fail_num_get + : public std::num_get<T> + { + typedef std::ios_base ios_base; + typedef typename std::num_get<T>::iter_type iter_type; + + protected: + iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const + { throw facet_error(); return iter_type(); } + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const + { throw facet_error(); return iter_type(); } + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + unsigned short&) const + { throw facet_error(); return iter_type(); } + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + unsigned int&) const + { throw facet_error(); return iter_type(); } + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + unsigned long&) const + { throw facet_error(); return iter_type(); } + +#ifdef _GLIBCXX_USE_LONG_LONG + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + long long&) const + { throw facet_error(); return iter_type(); } + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + unsigned long long&) const + { throw facet_error(); return iter_type(); } +#endif + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + float&) const + { throw facet_error(); return iter_type(); } + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + double&) const + { throw facet_error(); return iter_type(); } + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + long double&) const + { throw facet_error(); return iter_type(); } + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + void*&) const + { throw facet_error(); return iter_type(); } + }; + + typedef fail_num_get<char> fail_num_get_char; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef fail_num_get<wchar_t> fail_num_get_wchar_t; +#endif + + template<typename T> + class fail_num_put + : public std::num_put<T> + { + typedef std::ios_base ios_base; + typedef typename std::num_put<T>::iter_type iter_type; + typedef typename std::num_put<T>::char_type char_type; + + protected: + iter_type + do_put(iter_type, ios_base&, char_type, bool) const + { throw facet_error(); return iter_type(0); } + + virtual iter_type + do_put(iter_type, ios_base&, char_type, long) const + { throw facet_error(); return iter_type(0); } + + virtual iter_type + do_put(iter_type, ios_base&, char_type, unsigned long) const + { throw facet_error(); return iter_type(0); } + +#ifdef _GLIBCXX_USE_LONG_LONG + virtual iter_type + do_put(iter_type, ios_base&, char_type, long long) const + { throw facet_error(); return iter_type(0); } + + virtual iter_type + do_put(iter_type, ios_base&, char_type, unsigned long long) const + { throw facet_error(); return iter_type(0); } +#endif + + virtual iter_type + do_put(iter_type, ios_base&, char_type, double) const + { throw facet_error(); return iter_type(0); } + + virtual iter_type + do_put(iter_type, ios_base&, char_type, long double) const + { throw facet_error(); return iter_type(0); } + + virtual iter_type + do_put(iter_type, ios_base&, char_type, const void*) const + { throw facet_error(); return iter_type(0); } + }; + + typedef fail_num_put<char> fail_num_put_char; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef fail_num_put<wchar_t> fail_num_put_wchar_t; +#endif +} // namespace __gnu_test + +#endif // _GLIBCXX_TESTSUITE_IO_H + |