libstdc++-v3/testsuite/testsuite_io.h

   1 // -*- C++ -*-
   2 // Testing filebuf for the C++ library testsuite.
   3 //
   4 // Copyright (C) 2003 Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 2, or (at your option)
  10 // any later version.
  11 //
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License along
  18 // with this library; see the file COPYING.  If not, write to the Free
  19 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20 // USA.
  21 //
  22 // As a special exception, you may use this file as part of a free software
  23 // library without restriction.  Specifically, if other files instantiate
  24 // templates or use macros or inline functions from this file, or you compile
  25 // this file and link it with other files to produce an executable, this
  26 // file does not by itself cause the resulting executable to be covered by
  27 // the GNU General Public License.  This exception does not however
  28 // invalidate any other reasons why the executable file might be covered by
  29 // the GNU General Public License.
  30
  31 #ifndef _GLIBCXX_TESTSUITE_IO_H
  32 #define _GLIBCXX_TESTSUITE_IO_H
  33
  34 #include <fstream>
  35
  36 namespace __gnu_test
  37 {
  38   // Used to verify the constraints/requirements on get and put areas
  39   // as defined in
  40   // 27.5.1 - Stream buffer requirements: get and put areas
  41   // 27.8.1.1 - Template class basic_filebuf p 3
  42   //   If the file is not open (ios_base::in) -> input seq. cannot be read
  43   //   If the file is not open (ios_base::out) -> output seq. cannot be written
  44   //   Joint file position
  45   // 27.8.1.4 - Overridden virtual functions p9
  46   //   If unbuffered, pbase == pptr == NULL
  47   class constraint_filebuf: public std::filebuf
  48   {
  49   public:
  50     bool
  51     write_position()
  52     {
  53       bool two = this->pptr() != NULL;
  54       bool one = this->pptr() < this->epptr();
  55       return one && two;
  56     }
  57
  58     bool
  59     read_position()
  60     {
  61       bool one = this->gptr() != NULL;
  62       bool two = this->gptr() < this->egptr();
  63
  64       return one && two;
  65     }
  66
  67     bool
  68     unbuffered()
  69     {
  70       bool one = this->pbase() == NULL;
  71       bool two = this->pptr() == NULL;
  72       return one && two;
  73     }
  74   };
  75
  76   // Used to check if basic_streambuf::pubsync() has been called.
  77   // This is useful for checking if a function creates [io]stream::sentry
  78   // objects, since the sentry constructors call tie()->flush().
  79   class sync_streambuf : public std::streambuf
  80   {
  81   private:
  82     bool m_sync_called;
  83
  84   public:
  85     sync_streambuf()
  86     : m_sync_called(false)
  87     { }
  88
  89     bool sync_called() const
  90     { return m_sync_called; }
  91
  92   protected:
  93     int sync()
  94     {
  95       m_sync_called = true;
  96       return 0;
  97     }
  98   };
  99
 100   // Throws on all overflow and underflow calls.
 101   struct underflow_error: std::exception { };
 102   struct overflow_error: std::exception { };
 103   struct positioning_error: std::exception { };
 104
 105   struct fail_streambuf : std::streambuf
 106   {
 107   private:
 108     char p[2];
 109
 110   public:
 111     fail_streambuf()
 112     {
 113       p[0] = 's';
 114       p[1] = char();
 115       setg(p, p, p + 1);
 116     }
 117
 118     virtual int_type underflow()
 119     {
 120       throw underflow_error();
 121       return -1;
 122     }
 123
 124     virtual int_type uflow()
 125     {
 126       throw underflow_error();
 127       return -1;
 128     }
 129
 130     virtual int_type
 131     overflow(int_type)
 132     {
 133       throw overflow_error();
 134       return -1;
 135     }
 136
 137     virtual pos_type
 138     seekoff(off_type, std::ios_base::seekdir, std::ios_base::openmode)
 139     {
 140       throw positioning_error();
 141       return pos_type(off_type(-1));
 142     }
 143
 144     virtual pos_type
 145     seekpos(pos_type, std::ios_base::openmode)
 146     {
 147       throw positioning_error();
 148       return pos_type(off_type(-1));
 149     }
 150
 151     virtual int
 152     sync()
 153     {
 154       throw positioning_error();
 155       return 0;
 156     }
 157   };
 158
 159   // Facets that throw an exception for every virtual function.
 160   struct facet_error: std::exception { };
 161
 162   class fail_num_get : public std::num_get<char>
 163   {
 164     typedef std::ios_base ios_base;
 165
 166   protected:
 167     iter_type
 168     do_get(iter_type a, iter_type, ios_base&, ios_base::iostate&, bool&) const
 169     { throw facet_error(); return iter_type(); }
 170
 171     virtual iter_type
 172     do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const
 173     { throw facet_error(); return iter_type(); }
 174
 175     virtual iter_type
 176     do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
 177            unsigned short&) const
 178     { throw facet_error(); return iter_type(); }
 179
 180     virtual iter_type
 181     do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
 182            unsigned int&) const
 183     { throw facet_error(); return iter_type(); }
 184
 185     virtual iter_type
 186     do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
 187            unsigned long&) const
 188     { throw facet_error(); return iter_type(); }
 189
 190 #ifdef _GLIBCXX_USE_LONG_LONG
 191     virtual iter_type
 192     do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
 193            long long&) const
 194     { throw facet_error(); return iter_type(); }
 195
 196     virtual iter_type
 197     do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
 198            unsigned long long&) const
 199     { throw facet_error(); return iter_type(); }
 200 #endif
 201
 202     virtual iter_type
 203     do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
 204            float&) const
 205     { throw facet_error(); return iter_type(); }
 206
 207     virtual iter_type
 208     do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
 209            double&) const
 210     { throw facet_error(); return iter_type(); }
 211
 212     virtual iter_type
 213     do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
 214            long double&) const
 215     { throw facet_error(); return iter_type(); }
 216
 217     virtual iter_type
 218     do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
 219            void*&) const
 220     { throw facet_error(); return iter_type(); }
 221   };
 222
 223   class fail_num_put : public std::num_put<char>
 224   {
 225     typedef std::ios_base ios_base;
 226
 227   protected:
 228     iter_type
 229     do_put(iter_type, ios_base&, char_type __fill, bool __v) const
 230     { throw facet_error(); return iter_type(NULL); }
 231
 232     virtual iter_type
 233     do_put(iter_type, ios_base&, char_type __fill, long __v) const
 234     { throw facet_error(); return iter_type(NULL); }
 235
 236     virtual iter_type
 237     do_put(iter_type, ios_base&, char_type __fill, unsigned long) const
 238     { throw facet_error(); return iter_type(NULL); }
 239
 240 #ifdef _GLIBCXX_USE_LONG_LONG
 241     virtual iter_type
 242     do_put(iter_type, ios_base&, char_type __fill, long long __v) const
 243     { throw facet_error(); return iter_type(NULL); }
 244
 245     virtual iter_type
 246     do_put(iter_type, ios_base&, char_type __fill, unsigned long long) const
 247     { throw facet_error(); return iter_type(NULL); }
 248 #endif
 249
 250     virtual iter_type
 251     do_put(iter_type, ios_base&, char_type __fill, double __v) const
 252     { throw facet_error(); return iter_type(NULL); }
 253
 254     virtual iter_type
 255     do_put(iter_type, ios_base&, char_type __fill, long double __v) const
 256     { throw facet_error(); return iter_type(NULL); }
 257
 258     virtual iter_type
 259     do_put(iter_type, ios_base&, char_type __fill, const void* __v) const
 260     { throw facet_error(); return iter_type(NULL); }
 261   };
 262 }; // namespace __gnu_test
 263
 264 #endif // _GLIBCXX_TESTSUITE_IO_H
 265