| /*************************************************************************** |
| * |
| * 27.stringbuf.virtuals.cpp - test exercising lib.stringbuf.virtuals |
| * |
| * $Id$ |
| * |
| *************************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| * |
| **************************************************************************/ |
| |
| #include <sstream> // for stringbuf |
| #include <cstring> // for size_t, strchr() |
| |
| #include <rw_cmdopt.h> // for rw_enabled() |
| #include <rw_driver.h> // for rw_assert(), ... |
| #include <rw_char.h> // for rw_expand(), rw_match() |
| |
| /**************************************************************************/ |
| |
| #undef EOF |
| #define EOF (_RWSTD_INT_MIN + 2) |
| |
| #undef NOT_EOF |
| #define NOT_EOF (_RWSTD_INT_MIN + 1) |
| |
| #undef IGN |
| #define IGN _RWSTD_INT_MIN |
| |
| #undef NPOS |
| #define NPOS -1 // invalid position (post_type(off_type(-1)) |
| |
| #define MAYBE_1 0 // 0 or more write positions available |
| #define AT_LEAST_1 1 // at least one write position available |
| |
| /**************************************************************************/ |
| |
| template <class charT, class Traits> |
| struct PubBuf: std::basic_stringbuf<charT, Traits> |
| { |
| typedef std::basic_stringbuf<charT> Base; |
| typedef typename Base::char_type char_type; |
| typedef typename Base::int_type int_type; |
| typedef typename Base::off_type off_type; |
| typedef typename Base::pos_type pos_type; |
| |
| char_type* Eback () const { return this->eback (); } |
| char_type* Gptr () const { return this->gptr (); } |
| char_type* Egptr () const { return this->egptr (); } |
| |
| void Gbump (int n) { this->gbump (n); } |
| |
| char_type* Pbase () const { return this->pbase (); } |
| char_type* Pptr () const { return this->pptr (); } |
| char_type* Epptr () const { return this->epptr (); } |
| |
| int_type Pbackfail () { return this->pbackfail (); } |
| int_type Pbackfail (int_type c) { return this->pbackfail (c); } |
| |
| int_type Overflow () { return this->overflow (); } |
| int_type Overflow (int_type c) { return this->overflow (c); } |
| |
| int_type Underflow () { return this->underflow (); } |
| |
| pos_type Seekoff (off_type off, std::ios_base::seekdir way) { |
| return this->seekoff (off, way); |
| } |
| |
| pos_type Seekoff (off_type off, std::ios_base::seekdir way, |
| std::ios_base::openmode which) { |
| return this->seekoff (off, way, which); |
| } |
| |
| pos_type Seekpos (pos_type pos) { |
| return this->seekpos (pos); |
| } |
| |
| pos_type Seekpos (pos_type pos, std::ios_base::openmode which) { |
| return this->seekpos (pos, which); |
| } |
| |
| static int capacity (int n) { |
| Base buf (std::ios::out); |
| while (n--) |
| buf.sputc ('c'); |
| return int (((PubBuf&)buf).Epptr () - ((PubBuf&)buf).Pbase ()); |
| } |
| }; |
| |
| |
| int traits_eof = -1; |
| |
| template <class charT> |
| struct CharTraits: std::char_traits<charT> |
| { |
| typedef std::char_traits<charT> Base; |
| typedef typename Base::int_type int_type; |
| |
| // override eof() to detect bad assumptions |
| static int_type eof () { return traits_eof; } |
| static int_type not_eof (int_type c) { |
| return c == eof () ? int_type (!c) : c; |
| } |
| }; |
| |
| /**************************************************************************/ |
| |
| struct VFun |
| { |
| enum charT { Char, WChar }; |
| enum Traits { DefaultTraits, UserTraits }; |
| enum VirtualTag { |
| // which virtual function to exercise |
| xsputn, pbackfail, overflow, underflow, seekoff, seekpos |
| }; |
| |
| VFun (charT cid, const char *cname, |
| Traits tid, const char *tname) |
| : cid_ (cid), tid_ (tid), vfun_ (), |
| cname_ (cname), tname_ (tname), fname_ (0), |
| strarg_ (0), sequence_ (0) { /* empty */ } |
| |
| charT cid_; |
| Traits tid_; |
| VirtualTag vfun_; |
| const char *cname_; // character type name |
| const char *tname_; // traits name |
| const char *fname_; // function name |
| |
| const char *strarg_; // string argument |
| const char *sequence_; // final sequence |
| }; |
| |
| |
| static int stringbuf_capacity; |
| static char long_string [4096]; |
| |
| /**************************************************************************/ |
| |
| template <class charT, class Traits> |
| void test_virtual (charT, Traits, const VFun *pfid, |
| int line, // line number |
| const char *str, // ctor string argument |
| std::size_t, // length of string |
| int mode, // ctor mode argument |
| int gbump, // initial gptr offset |
| int arg0, // first argument |
| int arg1, // second argument |
| int arg2, // third argument |
| int ret_expect, // expected return value |
| int pback_expect, // ... size of putback area |
| int read_expect, // ... size of read area |
| int write_expect) // ... size of write area |
| { |
| typedef std::allocator<charT> Allocator; |
| typedef std::basic_stringbuf<charT, Traits, Allocator> Stringbuf; |
| |
| typedef typename Stringbuf::int_type int_type; |
| typedef typename Stringbuf::off_type off_type; |
| typedef typename Stringbuf::pos_type pos_type; |
| |
| if (!rw_enabled (line)) { |
| rw_note (0, 0, 0, "test on line %d disabled", line); |
| return; |
| } |
| |
| if (EOF == arg0) |
| arg0 = Traits::eof (); |
| |
| if (EOF == ret_expect) |
| ret_expect = Traits::eof (); |
| |
| // widen the source sequence into the (possibly wide) character buffer |
| static charT wstr [4096]; |
| static charT warg [4096]; |
| |
| std::size_t wstr_len = sizeof wstr / sizeof *wstr; |
| std::size_t warg_len = sizeof warg / sizeof *warg; |
| |
| wstr [0] = charT (); |
| rw_expand (wstr, str, _RWSTD_SIZE_MAX, &wstr_len); |
| |
| const std::ios_base::openmode openmode = std::ios_base::openmode (mode); |
| |
| // construct three stringbuf objects but use only the one that |
| // matches the provided arguments |
| Stringbuf sb_0; |
| Stringbuf sb_m (openmode); |
| Stringbuf sb_s (wstr); |
| Stringbuf sb_s_m (wstr, openmode); |
| |
| PubBuf<charT, Traits>* const pbuf = (PubBuf<charT, Traits>*) |
| (str ? -1 < mode ? &sb_s_m : &sb_s : -1 < mode ? &sb_m : &sb_0); |
| |
| if (stringbuf_capacity < 0) |
| stringbuf_capacity = |
| PubBuf<charT, Traits>::capacity (-stringbuf_capacity); |
| |
| if (gbump && IGN != gbump) { |
| // make sure gbump is valid |
| RW_ASSERT (gbump <= pbuf->Egptr () - pbuf->Eback ()); |
| |
| // advance gptr() as requested |
| pbuf->Gbump (gbump); |
| } |
| |
| // create the argument to overflow |
| const int_type arg_int = int_type (arg0); |
| const off_type arg_off = off_type (arg0); |
| const pos_type arg_pos = arg_off; |
| |
| const std::ios_base::seekdir arg_way = std::ios_base::seekdir (arg1); |
| const std::ios_base::openmode arg_which = std::ios_base::openmode (arg2); |
| |
| int ret = EOF; |
| |
| // invoke the virtual function with the expected argument (if any) |
| switch (pfid->vfun_) { |
| case VFun::xsputn: { |
| |
| if (pfid->strarg_) { |
| rw_expand (warg, pfid->strarg_, _RWSTD_SIZE_MAX, &warg_len); |
| if (std::strchr (pfid->strarg_, '@')) |
| arg0 = int (warg_len); |
| |
| RW_ASSERT (std::size_t (arg0) < sizeof wstr / sizeof *wstr); |
| ret = int (pbuf->sputn (warg, std::streamsize (arg0))); |
| } |
| else { |
| // invoke sputn() with pbase as an argument |
| ret = int (pbuf->sputn (pbuf->Pbase (), std::streamsize (arg0))); |
| } |
| |
| break; |
| } |
| |
| case VFun::pbackfail: |
| ret = IGN == arg0 ? pbuf->Pbackfail () |
| : pbuf->Pbackfail (arg_int); |
| break; |
| |
| case VFun::overflow: |
| ret = IGN == arg0 ? pbuf->Overflow () |
| : pbuf->Overflow (arg_int); |
| break; |
| |
| case VFun::underflow: |
| ret = pbuf->Underflow (); |
| break; |
| |
| case VFun::seekoff: |
| ret = IGN == arg2 ? pbuf->Seekoff (arg_off, arg_way) |
| : pbuf->Seekoff (arg_off, arg_way, arg_which); |
| break; |
| |
| case VFun::seekpos: |
| ret = IGN == arg2 ? pbuf->Seekpos (arg_pos) |
| : pbuf->Seekpos (arg_pos, arg_which); |
| break; |
| } |
| |
| // compute the number of putback positions available |
| // see 27.5.1, p3, bullet 3 |
| const int pback_pos = int (pbuf->Gptr () - pbuf->Eback ()); |
| |
| // compute the number of read positions available |
| // see 27.5.1, p3, bullet 4 |
| const int read_pos = int (pbuf->Egptr () - pbuf->Gptr ()); |
| |
| // compute the number of write positions available |
| // see 27.5.1, p3, bullet 2 |
| const int write_pos = int (pbuf->Epptr () - pbuf->Pptr ()); |
| |
| // set up a format string with the name of the class and member |
| // function being called and describing the function arguments |
| // basic_stringbuf<char> is formatted as stringbuf |
| // basic_stringbuf<wchar_t> is formatted as wstringbuf |
| // all other specializations are fully spelled out |
| #define CALLFMT \ |
| "line %d. " \ |
| "%{?}basic_%{:}%{?}w%{;}%{;}stringbuf%{?}<%s%{?}, %s%{;}>%{;}" \ |
| "(%{?}%{*Ac}%{?}, %{Io}%{;}%{:}%{?}%{Io}%{;}%{;})" \ |
| ".%s (%{?}%{?}%{*Ac}%{:}pptr()%{;}, %d" /* xsputn */ \ |
| "%{:}%{?}" /* pbackfail, over/underflow argument */ \ |
| "%{?}%{#lc}%{;}" \ |
| "%{:}" /* seekoff and seekpos */ \ |
| "%d%{?}, %{Iw}%{?}, %{Io}%{;}" \ |
| "%{:}%{?}, %{Io}%{;}%{;}" \ |
| "%{;}%{;})" |
| |
| // is the tested virtual function seekoff or seekpos? |
| const bool is_seek = VFun::seekoff <= pfid->vfun_; |
| |
| // arguments corresponding to CALLFMT |
| #define CALLARGS \ |
| __LINE__, \ |
| 0 != pfid->tname_, 'w' == *pfid->cname_, 0 != pfid->tname_, \ |
| pfid->cname_, 0 != pfid->tname_, pfid->tname_, \ |
| 0 != str, int (sizeof *wstr), wstr, -1 < mode, mode, -1 < mode, mode, \ |
| pfid->fname_, pfid->vfun_ == VFun::xsputn, 0 != pfid->strarg_, \ |
| int (sizeof *warg), warg, arg0, \ |
| !is_seek, \ |
| IGN != arg0, arg_int, \ |
| arg0, VFun::seekoff == pfid->vfun_, arg1, IGN != arg2, arg2, \ |
| IGN != arg1, arg1 |
| |
| const int_type not_eof = Traits::not_eof (arg_int); |
| |
| int success = ret == (NOT_EOF == ret_expect ? int (not_eof) : ret_expect); |
| |
| // verify the expected return value |
| if (pfid->vfun_ == VFun::xsputn || is_seek) { |
| rw_assert (success, 0, line, |
| CALLFMT " == %d, got %d", |
| CALLARGS, ret_expect, ret); |
| } |
| else { |
| rw_assert (success, 0, line, |
| CALLFMT " == %{?}not EOF%{:}%{#lc}%{;}, got %{#lc}", |
| CALLARGS, NOT_EOF == ret_expect, ret_expect, ret); |
| } |
| |
| // verify the expected size of the putback area |
| if (IGN != pback_expect) |
| rw_assert (pback_pos == pback_expect, 0, line, |
| CALLFMT ": putback positions (gptr - eback) == %d, got %d" |
| "%{?}: gptr = NULL%{;}", |
| CALLARGS, pback_expect, pback_pos, |
| 0 == pbuf->Gptr ()); |
| |
| // verify the expected size of the read area |
| if (IGN != read_expect) |
| rw_assert (read_pos == read_expect, 0, line, |
| CALLFMT ": read positions (egptr - gptr) == %d, got %d: " |
| "gptr = %{?}NULL%{:}eback + %td%{;}", |
| CALLARGS, read_expect, read_pos, |
| 0 == pbuf->Gptr (), pbuf->Gptr () - pbuf->Eback ()); |
| |
| // verify the expected size of the write area |
| if (IGN != write_expect) { |
| |
| // at least as many write positions as expected |
| success = -1 < write_expect ? |
| write_expect <= write_pos : 0 == write_pos; |
| |
| rw_assert (success, 0, line, |
| CALLFMT ": write positions (epptr - pptr) " |
| "%{?}==%{:}>=%{;} %d, got %d: " |
| "pptr = %{?}NULL%{:}pbase + %td%{;}", |
| CALLARGS, 1 < write_expect, write_expect, write_pos, |
| 0 == pbuf->Pptr (), pbuf->Pptr () - pbuf->Pbase ()); |
| } |
| |
| if (pfid->sequence_) { |
| |
| // verify that the put area matches the expected sequence |
| const std::size_t len = pbuf->Pptr () - pbuf->Pbase (); |
| const std::size_t xmatch = |
| rw_match (pfid->sequence_, pbuf->Pbase (), len); |
| |
| rw_assert (xmatch == len, 0, line, |
| CALLFMT ": put area mismatch (pbase + %zu)", |
| CALLARGS, xmatch); |
| } |
| } |
| |
| /**************************************************************************/ |
| |
| // dispatches to the appropriate specialization of the function template |
| void test_virtual (VFun *pfid, |
| int line, |
| const char *str, |
| std::size_t str_len, |
| int mode, |
| int gbump, |
| int arg0, |
| int arg1, |
| int arg2, |
| int ret_expect, |
| int pback_expect, |
| int read_expect, |
| int write_expect) |
| { |
| #undef TEST |
| #define TEST(charT, Traits) \ |
| test_virtual (charT (), Traits (), pfid, line, \ |
| str, str_len, mode, gbump, \ |
| arg0, arg1, arg2, ret_expect, \ |
| pback_expect, read_expect, write_expect) |
| |
| static const char* const fnames[] = { |
| "xsputn", "pbackfail", "overflow", "underflow", "seekoff", "seekpos" |
| }; |
| |
| if (!rw_enabled (line)) { |
| rw_note (0, 0, __LINE__, "test on line %d disabled", line); |
| return; |
| } |
| |
| pfid->fname_ = fnames [pfid->vfun_]; |
| |
| if (VFun:: DefaultTraits == pfid->tid_) { |
| if (VFun::Char == pfid->cid_) |
| TEST (char, std::char_traits<char>); |
| #ifndef _RWSTD_NO_WCHAR_T |
| else |
| TEST (wchar_t, std::char_traits<wchar_t>); |
| #endif // _RWSTD_NO_WCHAR_T |
| } |
| else { |
| if (VFun::Char == pfid->cid_) |
| TEST (char, CharTraits<char>); |
| |
| #ifndef _RWSTD_NO_WCHAR_T |
| else |
| TEST (wchar_t, CharTraits<wchar_t>); |
| #endif // _RWSTD_NO_WCHAR_T |
| } |
| |
| pfid->strarg_ = 0; |
| pfid->sequence_ = 0; |
| } |
| |
| /**************************************************************************/ |
| |
| // convenience constants |
| const int in = std::ios::in; |
| const int out = std::ios::out; |
| const int ate = std::ios::ate; |
| |
| const int cur = std::ios::cur; |
| const int end = std::ios::end; |
| |
| static int rw_opt_max_size = 1024; |
| |
| /**************************************************************************/ |
| |
| static void |
| test_xsputn (VFun *pfid) |
| { |
| rw_info (0, 0, 0, "basic_stringbuf<%s%{?}, %s%{;}>::xsputn" |
| "(const char_type*, streamsize)", |
| pfid->cname_, 0 != pfid->tname_, pfid->tname_); |
| |
| pfid->vfun_ = VFun::xsputn; |
| |
| #undef TEST |
| #define TEST(str, mode, gbump, sarg, result, pback, read, write) \ |
| pfid->strarg_ = sarg; \ |
| test_virtual (pfid, __LINE__, str, sizeof str - 1, mode, \ |
| gbump, int (sizeof sarg - 1), IGN, IGN, result, \ |
| pback, read, write) |
| |
| // +-------------------------------------------- initial sequence |
| // | +------------------------------------- open mode |
| // | | +--------------------- gbump (gptr offset) |
| // | | | +----------------- xsputn argument |
| // | | | | +----------- expected return value |
| // | | | | | +-------- putback positions |
| // | | | | | | +----- read positions |
| // | | | | | | | +-- write positions |
| // | | | | | | | | |
| // V V V V V V V V |
| TEST (0, 0, 0, "", 0, 0, 0, -1); |
| TEST (0, 0, 0, "a", 0, 0, 0, -1); |
| TEST (0, in, 0, "a", 0, 0, 0, -1); |
| TEST (0, out, 0, "a", 1, 0, 0, MAYBE_1); |
| TEST (0, out, 0, "ab", 2, 0, 0, MAYBE_1); |
| TEST (0, out, 0, "abc", 3, 0, 0, MAYBE_1); |
| TEST (0, in | out, 0, "abc", 3, 0, 3, MAYBE_1); |
| TEST (0, in | out | ate, 0, "abc", 3, 0, 3, MAYBE_1); |
| |
| TEST ("abc", in | out, 0, "def", 3, 0, 6, MAYBE_1); |
| TEST ("abc", in | out | ate, 0, "def", 3, 0, 6, MAYBE_1); |
| |
| TEST ( 0, in | out, 0, "a@1000", 1000, 0, 1000, MAYBE_1); |
| TEST ( 0, in | out, 0, "a@1000", 1000, 0, 1000, MAYBE_1); |
| |
| TEST ( 0, in | out, 0, "a@1001", 1001, 0, 1001, MAYBE_1); |
| TEST ( "a@1", in | out, 0, "a@1002", 1002, 0, 1003, MAYBE_1); |
| TEST ( "a@2", in | out, 0, "a@1003", 1003, 0, 1005, MAYBE_1); |
| TEST ( "a@3", in | out, 0, "a@1004", 1004, 0, 1007, MAYBE_1); |
| |
| TEST ( 0, in | out | ate, 0, "a@1000", 1000, 0, 1000, MAYBE_1); |
| TEST ( 0, in | out | ate, 0, "a@1001", 1001, 0, 1001, MAYBE_1); |
| TEST ( "a@1", in | out | ate, 0, "a@1002", 1002, 0, 1003, MAYBE_1); |
| TEST ( "a@2", in | out | ate, 0, "a@1003", 1003, 0, 1005, MAYBE_1); |
| TEST ( "a@3", in | out | ate, 0, "a@1004", 1004, 0, 1007, MAYBE_1); |
| TEST ( "a@127", in | out | ate, 0, "a@1005", 1005, 0, 1132, MAYBE_1); |
| |
| TEST ("a@1000", in | out | ate, 0, "a@1006", 1006, 0, 2006, MAYBE_1); |
| TEST ("a@2000", in | out | ate, 0, "a@1007", 1007, 0, 3007, MAYBE_1); |
| TEST ("a@2001", in | out | ate, 0, "a@1008", 1008, 0, 3009, MAYBE_1); |
| |
| ////////////////////////////////////////////////////////////////// |
| // exercise calling sputn() with pptr() as the first argument |
| #undef TEST |
| #define TEST(str, mode, len, result, seq, read) \ |
| pfid->strarg_ = 0; pfid->sequence_ = seq; \ |
| test_virtual (pfid, __LINE__, str, sizeof str - 1, mode, \ |
| 0, len, IGN, IGN, result, \ |
| 0, read, MAYBE_1) |
| |
| // +---------------------------------------------- initial sequence |
| // | +------------------------------------ open mode |
| // | | +-------------------- xsputn 2nd argument |
| // | | | +-------------- return value |
| // | | | | +-------- sequence at pbase() |
| // | | | | | +-- read positions |
| // | | | | | | |
| // | | | | | +---------+ |
| // | | | | | | |
| // V V V V V V |
| TEST ( "a@500b", in | out | ate, 11, 11, "a@500ba@11", 512); |
| TEST ( "a@500b", in | out | ate, 12, 12, "a@500ba@12", 513); |
| TEST ( "a@500b", in | out | ate, 13, 13, "a@500ba@13", 514); |
| TEST ( "a@500b", in | out | ate, 500, 500, "a@500ba@500", 1001); |
| TEST ( "a@500b", in | out | ate, 501, 501, "a@500ba@500b", 1002); |
| TEST ("a@1022b", in | out | ate, 1, 1, "a@1022ba", 1024); |
| TEST ("a@1023b", in | out | ate, 1, 1, "a@1023ba", 1025); |
| |
| ////////////////////////////////////////////////////////////////// |
| // exercise multiples of stringbuf capacity |
| #undef TEST |
| #define TEST(len, mode, gbump, arg_len, result, pback, read, write) \ |
| pfid->strarg_ = long_string + (sizeof long_string - 1 - len), \ |
| test_virtual (pfid, __LINE__, pfid->strarg_, \ |
| len, mode, gbump, arg_len, IGN, IGN, \ |
| result, pback, read, write) |
| |
| // for convenience |
| #define CAP stringbuf_capacity |
| |
| // compute the minimum buffer capacity |
| stringbuf_capacity = -1; |
| TEST ( 0, in | out, 0, 0, 0, 0, 0, -1); |
| |
| // +----------------------------------------------- length of sequence |
| // | +------------------------------------------ open mode |
| // | | +-------------------------- gbump (gptr offset) |
| // | | | +-------------------- xsputn 2nd argument |
| // | | | | +-------------- expected return value |
| // | | | | | +-------- putback positions |
| // | | | | | | +----- read positions |
| // | | | | | | | +-- write positions |
| // | | | | | | | | |
| // | | | | | | | +--------+ |
| // | | | | | | | | |
| // V V V V V V V V |
| TEST (CAP, in | out, 0, 1, 1, 0, CAP + 1, MAYBE_1); |
| TEST (CAP, in | out, 0, 2, 2, 0, CAP + 2, MAYBE_1); |
| TEST (CAP, in | out, 0, 3, 3, 0, CAP + 3, MAYBE_1); |
| TEST (CAP, in | out, 0, 127, 127, 0, CAP + 127, MAYBE_1); |
| TEST (CAP, in | out, 0, 1023, 1023, 0, CAP + 1023, MAYBE_1); |
| TEST (CAP, in | out, 0, 1024, 1024, 0, CAP + 1024, MAYBE_1); |
| TEST (CAP, in | out, 0, CAP, CAP, 0, CAP + CAP, MAYBE_1); |
| |
| TEST (CAP, in | out | ate, 0, 1, 1, 0, CAP + 1, MAYBE_1); |
| TEST (CAP, in | out | ate, 0, 2, 2, 0, CAP + 2, MAYBE_1); |
| TEST (CAP, in | out | ate, 0, 3, 3, 0, CAP + 3, MAYBE_1); |
| TEST (CAP, in | out | ate, 0, CAP, CAP, 0, CAP + CAP, MAYBE_1); |
| TEST (CAP, in | out | ate, 0, 127, 127, 0, CAP + 127, MAYBE_1); |
| TEST (CAP, in | out | ate, 0, 1023, 1023, 0, CAP + 1023, MAYBE_1); |
| TEST (CAP, in | out | ate, 0, 1024, 1024, 0, CAP + 1024, MAYBE_1); |
| TEST (CAP, in | out | ate, 0, 1025, 1025, 0, CAP + 1025, MAYBE_1); |
| |
| for (int i = 0; i != rw_opt_max_size; ++i) { |
| TEST ( 0, in | out, 0, i, i, 0, i + 0, MAYBE_1); |
| TEST ( 1, in | out, 0, i, i, 0, i + 1, MAYBE_1); |
| TEST ( 32, in | out, 0, i, i, 0, i + 32, MAYBE_1); |
| TEST (127, in | out, 0, i, i, 0, i + 127, MAYBE_1); |
| TEST (CAP, in | out, 0, i, i, 0, i + CAP, MAYBE_1); |
| } |
| } |
| |
| /**************************************************************************/ |
| |
| static void |
| test_pbackfail (VFun *pfid) |
| { |
| rw_info (0, 0, 0, "basic_stringbuf<%s%{?}, %s%{;}>::pbackfail(int_type)", |
| pfid->cname_, 0 != pfid->tname_, pfid->tname_); |
| |
| pfid->vfun_ = VFun::pbackfail; |
| |
| #undef TEST |
| #define TEST(str, mode, gbump, arg, result, pback, read, write) \ |
| test_virtual (pfid, __LINE__, str, sizeof str - 1, mode, \ |
| gbump, arg, IGN, IGN, result, pback, read, write) |
| |
| /////////////////////////////////////////////////////////////////////// |
| // 27.7.1.3 |
| // |
| // -2- Effects: Puts back the character designated by c to the input |
| // sequence, if possible, in one of three ways: |
| // -- If traits::eq_int_type(c,traits::eof()) returns false and |
| // if the input sequence has a putback position available, |
| // and if traits::eq(to_char_type(c),gptr()[-1]) returns true, |
| // assigns gptr() - 1 to gptr(). |
| // Returns: c. |
| // -- If traits::eq_int_type(c,traits::eof()) returns false and |
| // if the input sequence has a putback position available, and |
| // if mode & ios_base::out is nonzero, assigns c to *--gptr(). |
| // Returns: c. |
| // -- If traits::eq_int_type(c,traits::eof()) returns true and if |
| // the input sequence has a putback position available, assigns |
| // gptr() - 1 to gptr(). |
| // Returns: traits::not_eof(c). |
| // -3- Returns: traits::eof() to indicate failure. |
| // -4- Notes: If the function can succeed in more than one of these ways, |
| // it is unspecified which way is chosen. |
| |
| // +----------------------------------------- initial sequence (if any) |
| // | +---------------------------------- open mode |
| // | | +------------------------ gbump (gptr offset) |
| // | | | +-------------------- pbackfail argument |
| // | | | | +---------------- expected return value |
| // | | | | | +----------- number of putback positions |
| // | | | | | | +-------- number of read positions |
| // | | | | | | | +----- number of write positions |
| // | | | | | | | | |
| // V V V V V V V V |
| TEST (0, 0, 0, 'c', EOF, 0, 0, -1); |
| TEST (0, 0, 0, EOF, EOF, 0, 0, -1); |
| |
| TEST (0, in, 0, 'c', EOF, 0, 0, -1); |
| TEST (0, out, 0, EOF, EOF, 0, 0, -1); |
| TEST (0, ate, 0, EOF, EOF, 0, 0, -1); |
| TEST (0, in | out, 0, 'c', EOF, 0, 0, -1); |
| TEST (0, in | out, 0, EOF, EOF, 0, 0, -1); |
| |
| TEST ("a", 0, 0, 'c', EOF, 0, 0, -1); |
| TEST ("a", in, 0, 'c', EOF, 0, 1, -1); |
| TEST ("a", in, 1, 'c', EOF, 1, 0, -1); |
| TEST ("a", in, 1, 'a', 'a', 0, 1, -1); |
| TEST ("a", out, 0, 'c', EOF, 0, 0, AT_LEAST_1); |
| TEST ("a", ate, 0, 'c', EOF, 0, 0, -1); |
| |
| TEST ("abc", in, 1, 'c', EOF, 1, 2, -1); |
| TEST ("abc", in, 2, 'c', EOF, 2, 1, -1); |
| TEST ("abc", in, 3, 'c', 'c', 2, 1, -1); |
| |
| TEST ("abc", in | out, 0, 'c', EOF, 0, 3, AT_LEAST_1); |
| TEST ("abc", in | out, 1, 'c', 'c', 0, 3, AT_LEAST_1); |
| TEST ("abc", in | out, 2, 'c', 'c', 1, 2, AT_LEAST_1); |
| TEST ("abc", in | out, 3, 'c', 'c', 2, 1, AT_LEAST_1); |
| } |
| |
| /**************************************************************************/ |
| |
| static void |
| test_overflow (VFun *pfid) |
| { |
| rw_info (0, 0, 0, "basic_stringbuf<%s%{?}, %s%{;}>::overflow(int_type)", |
| pfid->cname_, 0 != pfid->tname_, pfid->tname_); |
| |
| pfid->vfun_ = VFun::overflow; |
| |
| #undef TEST |
| #define TEST(str, mode, gbump, arg, result, pback, read, write) \ |
| test_virtual (pfid, __LINE__, str, sizeof str - 1, mode, gbump, \ |
| arg, IGN, IGN, result, pback, read, write); |
| |
| /////////////////////////////////////////////////////////////////////// |
| // 27.7.1.3 + LWG issues 169 and 432 |
| // |
| // -5- Effects: Appends the character designated by c to the output |
| // sequence, if possible, in one of two ways: |
| // -- If traits::eq_int_type(c,traits::eof()) returns false and |
| // if either the output sequence has a write position available |
| // or the function makes a write position available (as described |
| // below), the function calls sputc(c). |
| // Signals success by returning c. |
| // -- If traits::eq_int_type(c,traits::eof()) returns true, there |
| // is no character to append. |
| // Signals success by returning a value other than traits::eof(). |
| // -6- Notes: The function can alter the number of write positions |
| // available as a result of any call. |
| // -7- Returns: traits::eof() to indicate failure. |
| // -8- (blank) |
| // -9- Notes: The function can make a write position available only if |
| // (mode & ios_base::out) != 0. To make a write position available, |
| // the function reallocates (or initially allocates) an array object |
| // with a sufficient number of elements to hold the current array |
| // object (if any), plus one additional write position. If |
| // (mode & ios_base::in) != 0, the function alters the read end |
| // pointer egptr() to point just past the new write position. |
| /////////////////////////////////////////////////////////////////////// |
| |
| // +-------------------------------------- initial sequence (if any) |
| // | +---------------------------------- open mode |
| // | | +------------------------ gbump |
| // | | | +-------------------- overflow argument |
| // | | | | +---------------- result of call |
| // | | | | | +---------- putback positions after call |
| // | | | | | | +------ read positions after call |
| // | | | | | | | +-- write positions after call |
| // | | | | | | | | |
| // | | | | | | | | |
| // V V V V V V V V |
| TEST (0, 0, 0, 'c', EOF, 0, 0, -1); |
| TEST (0, in, 0, 'c', EOF, 0, 0, -1); |
| TEST (0, out, 0, 'c', 'c', 0, 0, AT_LEAST_1); |
| TEST (0, in | out, 0, 'c', 'c', 0, 1, AT_LEAST_1); |
| |
| TEST (0, in | ate, 0, 'c', EOF, 0, 0, -1); |
| TEST (0, out | ate, 0, 'c', 'c', 0, 0, AT_LEAST_1); |
| TEST (0, in | out | ate, 0, 'c', 'c', 0, 1, AT_LEAST_1); |
| |
| TEST ("", 0, 0, 'c', EOF, 0, 0, -1); |
| TEST ("", in, 0, 'c', EOF, 0, 0, -1); |
| TEST ("", out, 0, 'c', 'c', 0, 0, AT_LEAST_1); |
| TEST ("", in | out, 0, 'c', 'c', 0, 1, AT_LEAST_1); |
| |
| TEST ("a", 0, 0, 'c', EOF, 0, 0, -1); |
| TEST ("a", in, 0, 'c', EOF, 0, 1, -1); |
| TEST ("a", out, 0, 'c', 'c', 0, 0, AT_LEAST_1); |
| TEST ("a", in | out, 0, 'c', 'c', 0, 2, AT_LEAST_1); |
| |
| TEST ("a", in | ate, 0, 'c', EOF, 0, 1, -1); |
| TEST ("a", out | ate, 0, 'c', 'c', 0, 0, MAYBE_1); |
| TEST ("a", in | out | ate, 0, 'c', 'c', 0, 2, MAYBE_1); |
| |
| TEST ("ab", 0, 0, 'c', EOF, 0, 0, -1); |
| TEST ("ab", in, 0, 'c', EOF, 0, 2, -1); |
| TEST ("ab", out, 0, 'c', 'c', 0, 0, AT_LEAST_1); |
| TEST ("ab", in | out, 0, 'c', 'c', 0, 3, AT_LEAST_1); |
| |
| TEST ("ab", in | ate, 0, 'c', EOF, 0, 2, -1); |
| TEST ("ab", out | ate, 0, 'c', 'c', 0, 0, AT_LEAST_1); |
| TEST ("ab", in | out | ate, 0, 'c', 'c', 0, 3, AT_LEAST_1); |
| |
| // verify that when the argument is EOF the function returns a value |
| // other than traits::eof() regardless of the streambuf open mode |
| TEST (0, 0, 0, EOF, NOT_EOF, 0, 0, -1); |
| TEST (0, in, 0, EOF, NOT_EOF, 0, 0, -1); |
| TEST (0, out, 0, EOF, NOT_EOF, 0, 0, -1); |
| TEST (0, in | out, 0, EOF, NOT_EOF, 0, 0, -1); |
| TEST (0, in | ate, 0, EOF, NOT_EOF, 0, 0, -1); |
| TEST (0, out | ate, 0, EOF, NOT_EOF, 0, 0, -1); |
| TEST (0, in | out | ate, 0, EOF, NOT_EOF, 0, 0, -1); |
| |
| TEST ("abc", 0, 0, EOF, NOT_EOF, 0, 0, -1); |
| TEST ("abc", in, 0, EOF, NOT_EOF, 0, 3, -1); |
| TEST ("abc", out, 0, EOF, NOT_EOF, 0, 0, AT_LEAST_1); |
| TEST ("abc", in | out, 0, EOF, NOT_EOF, 0, 3, AT_LEAST_1); |
| TEST ("abc", in | ate, 0, EOF, NOT_EOF, 0, 3, -1); |
| TEST ("abc", out | ate, 0, EOF, NOT_EOF, 0, 0, MAYBE_1); |
| TEST ("abc", in | out | ate, 0, EOF, NOT_EOF, 0, 3, MAYBE_1); |
| } |
| |
| /**************************************************************************/ |
| |
| static void |
| test_underflow (VFun *pfid) |
| { |
| rw_info (0, 0, 0, "basic_stringbuf<%s%{?}, %s%{;}>::underflow()", |
| pfid->cname_, 0 != pfid->tname_, pfid->tname_); |
| |
| pfid->vfun_ = VFun::underflow; |
| |
| #undef TEST |
| #define TEST(str, mode, gbump, result, pback, read, write) \ |
| test_virtual (pfid, __LINE__, str, sizeof str - 1, mode, gbump, \ |
| IGN, IGN, IGN, result, pback, read, write); |
| |
| |
| /////////////////////////////////////////////////////////////////////// |
| // 27.7.1.3 + LWG issue 432 |
| // |
| // int_type undeflow () |
| // |
| // -1- If the input sequence has a read position available, returns |
| // traits::to_int_type(*gptr()). Otherwise, returns traits::eof(). |
| // Any character in the underlying buffer which has been initialized |
| // is considered to be part of the input sequence. |
| |
| // +------------------------------------------ initial sequence |
| // | +----------------------------------- open mode |
| // | | +------------------- gbump |
| // | | | +---------------- underflow result |
| // | | | | +----------- putback positions |
| // | | | | | +-------- read positions |
| // | | | | | | +---- write positions |
| // | | | | | | | |
| // | | | | | | | |
| // | | | | | | | |
| // V V V V V V V |
| TEST (0, 0, 0, EOF, 0, 0, -1); |
| TEST (0, in, 0, EOF, 0, 0, -1); |
| TEST (0, out, 0, EOF, 0, 0, -1); |
| TEST (0, in | out, 0, EOF, 0, 0, -1); |
| TEST (0, in | out | ate, 0, EOF, 0, 0, -1); |
| |
| TEST ("", 0, 0, EOF, 0, 0, -1); |
| TEST ("", in, 0, EOF, 0, 0, -1); |
| TEST ("", out, 0, EOF, 0, 0, -1); |
| TEST ("", in | out, 0, EOF, 0, 0, -1); |
| TEST ("", in | out | ate, 0, EOF, 0, 0, -1); |
| |
| TEST ("abc", 0, 0, EOF, 0, 0, -1); |
| TEST ("abc", in, 0, 'a', 0, 3, -1); |
| TEST ("abc", in, 1, 'b', 1, 2, -1); |
| TEST ("abc", in, 2, 'c', 2, 1, -1); |
| TEST ("abc", in, 3, EOF, 3, 0, -1); |
| TEST ("abc", out, 0, EOF, 0, 0, AT_LEAST_1); |
| TEST ("abc", in | out, 0, 'a', 0, 3, AT_LEAST_1); |
| TEST ("abc", in | out, 1, 'b', 1, 2, AT_LEAST_1); |
| TEST ("abc", in | out, 2, 'c', 2, 1, AT_LEAST_1); |
| TEST ("abc", in | out, 3, EOF, 3, 0, AT_LEAST_1); |
| TEST ("abc", in | out | ate, 0, 'a', 0, 3, MAYBE_1); |
| TEST ("abc", in | out | ate, 1, 'b', 1, 2, MAYBE_1); |
| TEST ("abc", in | out | ate, 2, 'c', 2, 1, MAYBE_1); |
| TEST ("abc", in | out | ate, 3, EOF, 3, 0, MAYBE_1); |
| |
| ////////////////////////////////////////////////////////////////// |
| // exercise UserTraits with an unusual eof |
| |
| if (0 == pfid->tname_) |
| return; |
| |
| TEST ("a$c", in, 0, 'a', 0, 3, -1); |
| TEST ("a$c", in, 1, EOF, 1, 2, -1); |
| } |
| |
| /**************************************************************************/ |
| |
| // exercises both seekoff (seeking from the beginning) and seekpos |
| static void |
| test_seek (VFun *pfid) |
| { |
| RW_ASSERT ( VFun::seekoff == pfid->vfun_ |
| || VFun::seekpos == pfid->vfun_); |
| |
| #undef TEST |
| #define TEST(str, mode, gbump, off, which, res, pback, read, write) \ |
| test_virtual (pfid, __LINE__, str, sizeof str - 1, mode, gbump, \ |
| off, std::ios::beg, which, res, pback, read, write) |
| |
| ////////////////////////////////////////////////////////////////// |
| // |
| // 27.7.1.3, p10 + LWG issue 432 |
| // |
| // pos_type seekoff (off_type off, ios_base::seekdir way, |
| // ios_base::openmode which = in | out); |
| // |
| // -10- Effects: Alters the stream position within one of the controlled |
| // sequences, if possible, as indicated in Table 90: |
| // |
| // Table 90 -- seekoff positioning |
| // ------------------------------- |
| // Conditions Result |
| // --------------- --------------- |
| // (which & in) positions the input sequence |
| // (which & out) positions the output sequence |
| // (which & (in | out)) == (in & out) && (way == beg || way == end) |
| // positions both sequences |
| // otherwise fails |
| // ------------------------------- |
| // |
| // -11- For a sequence to be positioned, if its next pointer (either |
| // gptr() or pptr()) is a null pointer, the positioning operation |
| // fails. Otherwise, the function determines newoff as indicated |
| // in Table 91: |
| // |
| // Table 91 -- newoff values |
| // ---------------------------- |
| // |
| // Condition Newoff value |
| // --------------- ------------ |
| // (way == beg) 0 |
| // (way == cur) xnext - xbeg |
| // (way == end) xend - xbeg |
| // ---------------------------- |
| // |
| // -12- If (newoff + off) < 0, or if (newoff + off) refers to an |
| // uninitialized character (as defined in 27.7.1.2 |
| // [lib.stringbuf.members] paragraph 1), the positioning operation |
| // fails. Otherwise, the function assigns (xbeg + newoff + off) to |
| // the next pointer xnext. |
| |
| // -13- Returns: pos_type(newoff), constructed from the resultant offset |
| // newoff (of type off_type), that stores the resultant stream |
| // position, if possible. If the positioning operation fails, or |
| // if the constructed object cannot represent the resultant stream |
| // position, the return value is pos_type(off_type(-1)). |
| // |
| ////////////////////////////////////////////////////////////////// |
| |
| // +-- initial sequence |
| // | +-- open mode (in, out, ate) |
| // | | +-- gbump |
| // | | | +-- offset |
| // | | | | +-- which (in, out) |
| // | | | | | +--- resulting position |
| // | | | | | | +-- putback positions |
| // | | | | | | | +-- read positions |
| // | | | | | | | | +-- write pos. |
| // | | | | | | | | | |
| // | | | | | | | | | |
| // | | | | | | | | | |
| // V V V V V V V V V |
| TEST (0, 0, 0, 0, 0, NPOS, 0, 0, -1); |
| TEST (0, in, 0, 0, 0, NPOS, 0, 0, -1); |
| TEST (0, out, 0, 0, 0, NPOS, 0, 0, -1); |
| TEST (0, ate, 0, 0, 0, NPOS, 0, 0, -1); |
| TEST (0, in | out, 0, 0, 0, NPOS, 0, 0, -1); |
| TEST (0, in | out | ate, 0, 0, 0, NPOS, 0, 0, -1); |
| |
| TEST (0, 0, 0, 0, 0, NPOS, 0, 0, -1); |
| |
| TEST ("abc", 0, 0, 0, 0, NPOS, 0, 0, -1); |
| TEST ("abc", 0, 0, 1, 0, NPOS, 0, 0, -1); |
| TEST ("abc", 0, 0, -1, 0, NPOS, 0, 0, -1); |
| |
| // seek within the input sequence from the beginning |
| TEST ("abc", in, 0, 0, in, 0, 0, 3, -1); |
| TEST ("abc", in, 0, 1, in, 1, 1, 2, -1); |
| TEST ("abc", in, 0, 2, in, 2, 2, 1, -1); |
| TEST ("abc", in, 0, 3, in, 3, 3, 0, -1); |
| TEST ("abc", in, 0, 4, in, NPOS, 0, 3, -1); |
| |
| // advance gptr by one and seek within the input sequence |
| TEST ("abc", in, 1, 0, in, 0, 0, 3, -1); |
| TEST ("abc", in, 1, 1, in, 1, 1, 2, -1); |
| TEST ("abc", in, 1, 2, in, 2, 2, 1, -1); |
| TEST ("abc", in, 1, 3, in, 3, 3, 0, -1); |
| TEST ("abc", in, 1, 4, in, NPOS, 1, 2, -1); |
| |
| // advance gptr by two and seek within the input sequence |
| TEST ("abc", in, 2, 0, in, 0, 0, 3, -1); |
| TEST ("abc", in, 2, 1, in, 1, 1, 2, -1); |
| TEST ("abc", in, 2, 2, in, 2, 2, 1, -1); |
| TEST ("abc", in, 2, 3, in, 3, 3, 0, -1); |
| TEST ("abc", in, 2, 4, in, NPOS, 2, 1, -1); |
| |
| // exercise seeking within the output sequence |
| TEST ("abc", out, 0, 0, out, 0, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, 1, out, 1, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, -1, out, NPOS, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, 2, out, 2, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, 3, out, 3, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, 4, out, NPOS, 0, 0, MAYBE_1); |
| |
| // seeking withing both input and output |
| TEST ("abc", in | out, 0, 0, in | out, 0, 0, 3, MAYBE_1); |
| TEST ("abc", in | out, 0, 1, in | out, 1, 1, 2, MAYBE_1); |
| TEST ("abc", in | out, 0, -1, in | out, NPOS, 0, 3, MAYBE_1); |
| TEST ("abc", in | out, 0, 2, in | out, 2, 2, 1, MAYBE_1); |
| TEST ("abc", in | out, 0, 3, in | out, 3, 3, 0, MAYBE_1); |
| TEST ("abc", in | out, 0, 4, in | out, NPOS, 0, 3, MAYBE_1); |
| } |
| |
| /**************************************************************************/ |
| |
| static void |
| test_seekoff (VFun *pfid) |
| { |
| rw_info (0, 0, 0, "basic_stringbuf<%s%{?}, %s%{;}>::seekoff(off_type, " |
| "ios_base::seekdir, ios_base::openmode)", |
| pfid->cname_, 0 != pfid->tname_, pfid->tname_); |
| |
| pfid->vfun_ = VFun::seekoff; |
| |
| test_seek (pfid); |
| |
| #undef TEST |
| #define TEST(str, mode, gbump, off, way, which, res, pback, read, write) \ |
| test_virtual (pfid, __LINE__, str, sizeof str - 1, mode, gbump, \ |
| off, way, which, res, pback, read, write) |
| |
| // exercise seeking from the current position and from end |
| |
| // +-- initial sequence |
| // | +-- open mode (in, out, ate) |
| // | | +-- gbump |
| // | | | +-- offset |
| // | | | | +-- way (cur or end) |
| // | | | | | +-- which (in, out) |
| // | | | | | | +--- resulting position |
| // | | | | | | | +-- putback positions |
| // | | | | | | | | +-- read positions |
| // | | | | | | | | | +-- write pos. |
| // | | | | | | | | | | |
| // | | | | | | | | | | |
| // | | | | | | | | | | |
| // V V V V V V V V V V |
| TEST (0, 0, 0, 0, cur, 0, NPOS, 0, 0, -1); |
| TEST (0, in, 0, 0, cur, 0, NPOS, 0, 0, -1); |
| TEST (0, out, 0, 0, cur, 0, NPOS, 0, 0, -1); |
| TEST (0, ate, 0, 0, cur, 0, NPOS, 0, 0, -1); |
| TEST (0, in | out, 0, 0, cur, 0, NPOS, 0, 0, -1); |
| TEST (0, in | out | ate, 0, 0, cur, 0, NPOS, 0, 0, -1); |
| |
| TEST (0, 0, 0, 0, end, 0, NPOS, 0, 0, -1); |
| TEST (0, in, 0, 0, end, 0, NPOS, 0, 0, -1); |
| TEST (0, out, 0, 0, end, 0, NPOS, 0, 0, -1); |
| TEST (0, ate, 0, 0, end, 0, NPOS, 0, 0, -1); |
| TEST (0, in | out, 0, 0, end, 0, NPOS, 0, 0, -1); |
| TEST (0, in | out | ate, 0, 0, end, 0, NPOS, 0, 0, -1); |
| |
| // exercise seeking within the output sequence |
| // (if (mode & in) == 0 then (pptr() == pbase()) is a postcondition |
| // of the constructor -- see also lwg issue 562) |
| TEST ("abc", out, 0, 0, cur, out, 0, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, 1, cur, out, 1, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, -1, cur, out, NPOS, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, 2, cur, out, 2, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, 3, cur, out, 3, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, 4, cur, out, NPOS, 0, 0, MAYBE_1); |
| |
| // seek within the input sequence from the current position |
| TEST ("abc", in, 0, 0, cur, in, 0, 0, 3, -1); |
| TEST ("abc", in, 0, 1, cur, in, 1, 1, 2, -1); |
| TEST ("abc", in, 0, 2, cur, in, 2, 2, 1, -1); |
| TEST ("abc", in, 0, 3, cur, in, 3, 3, 0, -1); |
| TEST ("abc", in, 0, 4, cur, in, NPOS, 0, 3, -1); |
| |
| // seek within the input sequence from the end |
| TEST ("abc", in, 0, 0, end, in, 3, 3, 0, -1); |
| TEST ("abc", in, 0, -1, end, in, 2, 2, 1, -1); |
| TEST ("abc", in, 0, -2, end, in, 1, 1, 2, -1); |
| TEST ("abc", in, 0, -3, end, in, 0, 0, 3, -1); |
| TEST ("abc", in, 0, -4, end, in, NPOS, 0, 3, -1); |
| |
| // exercise positioning from the end: this behavior is not |
| // correctly specified even in LWG issue 432 (see the post |
| // in c++std-lib-16390) |
| |
| // the implemented behavior considers end to be the "high |
| // mark" mentioned in DR 432 rather than epptr() |
| |
| // see LWG issue 563: |
| // http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563 |
| TEST ("abc", out, 0, 0, end, out, 3, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, 1, end, out, NPOS, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, -1, end, out, 2, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, -2, end, out, 1, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, -3, end, out, 0, 0, 0, MAYBE_1); |
| TEST ("abc", out, 0, -4, end, out, NPOS, 0, 0, MAYBE_1); |
| |
| TEST ("abc", out | ate, 0, 0, cur, out, 3, 0, 0, MAYBE_1); |
| TEST ("abc", out | ate, 0, 1, cur, out, NPOS, 0, 0, MAYBE_1); |
| TEST ("abc", out | ate, 0, -1, cur, out, 2, 0, 0, MAYBE_1); |
| TEST ("abc", out | ate, 0, -2, cur, out, 1, 0, 0, MAYBE_1); |
| TEST ("abc", out | ate, 0, -3, cur, out, 0, 0, 0, MAYBE_1); |
| TEST ("abc", out | ate, 0, -4, cur, out, NPOS, 0, 0, MAYBE_1); |
| |
| // seeking within both input and output from the end |
| TEST ("abc", in | out, 0, 0, end, in | out, 3, 3, 0, MAYBE_1); |
| TEST ("abc", in | out, 0, 1, end, in | out, NPOS, 0, 3, MAYBE_1); |
| TEST ("abc", in | out, 0, -1, end, in | out, 2, 2, 1, MAYBE_1); |
| TEST ("abc", in | out, 0, -2, end, in | out, 1, 1, 2, MAYBE_1); |
| TEST ("abc", in | out, 0, -3, end, in | out, 0, 0, 3, MAYBE_1); |
| TEST ("abc", in | out, 0, -4, end, in | out, NPOS, 0, 3, MAYBE_1); |
| |
| TEST ("abc", in, 0, 0, cur, in | out, NPOS, 0, 3, MAYBE_1); |
| TEST ("abc", out, 0, 0, cur, in | out, NPOS, 0, 0, MAYBE_1); |
| TEST ("abc", in | out, 0, 0, cur, in | out, NPOS, 0, 3, MAYBE_1); |
| TEST ("abc", in | out | ate, 0, 0, cur, in | out, NPOS, 0, 3, MAYBE_1); |
| |
| TEST ("abc", in | out | ate, 1, -1, end, in, 2, 2, 1, MAYBE_1); |
| TEST ("abc", in | out | ate, 1, -1, end, out, 2, 1, 2, MAYBE_1); |
| |
| TEST ("abc", in | out | ate, 1, -1, end, in | out, 2, 2, 1, MAYBE_1); |
| TEST ("abc", in | out | ate, 2, -1, end, in | out, 2, 2, 1, MAYBE_1); |
| TEST ("abc", in | out | ate, 3, -1, end, in | out, 2, 2, 1, MAYBE_1); |
| } |
| |
| /**************************************************************************/ |
| |
| static void |
| test_seekpos (VFun *pfid) |
| { |
| rw_info (0, 0, 0, "basic_stringbuf<%s%{?}, %s%{;}>::seekpos(pos_type, " |
| "ios_base::openmode)", |
| pfid->cname_, 0 != pfid->tname_, pfid->tname_); |
| |
| pfid->vfun_ = VFun::seekpos; |
| |
| test_seek (pfid); |
| } |
| |
| /**************************************************************************/ |
| |
| static int rw_opt_no_xsputn; // for --no-xsputn |
| static int rw_opt_no_pbackfail; // for --no-pbackfail |
| static int rw_opt_no_overflow; // for --no-overflow |
| static int rw_opt_no_underflow; // for --no-underflow |
| static int rw_opt_no_seekoff; // for --no-seekoff |
| static int rw_opt_no_seekpos; // for --no-seekpos |
| static int rw_opt_no_seek; // for --no-seek |
| static int rw_opt_no_char_traits; // for --no-char_traits |
| static int rw_opt_no_user_traits; // for --no-user_traits |
| |
| static void |
| run_test (VFun *pfid) |
| { |
| #undef TEST |
| #define TEST(function) \ |
| if (rw_opt_no_ ## function) \ |
| rw_note (1 < rw_opt_no_ ## function++, 0, 0, \ |
| "%s test disabled", #function); \ |
| else \ |
| test_ ## function (pfid) |
| |
| if (pfid->tname_ && rw_opt_no_user_traits) { |
| rw_note (1 < rw_opt_no_user_traits++, 0, 0, |
| "user defined traits test disabled"); |
| } |
| else if (!pfid->tname_ && rw_opt_no_char_traits) { |
| rw_note (1 < rw_opt_no_char_traits++, 0, 0, |
| "char_traits test disabled"); |
| } |
| else { |
| TEST (xsputn); |
| TEST (pbackfail); |
| TEST (overflow); |
| TEST (underflow); |
| TEST (seekoff); |
| TEST (seekpos); |
| } |
| } |
| |
| /**************************************************************************/ |
| |
| static int |
| run_test (int, char*[]) |
| { |
| if ('\0' == long_string [0]) { |
| // initialize long_string |
| for (std::size_t i = 0; i != sizeof long_string - 1; ++i) |
| long_string [i] = 'x'; |
| } |
| |
| if (rw_opt_no_seek) { |
| rw_opt_no_seekoff = 1; |
| rw_opt_no_seekpos = 1; |
| } |
| |
| if (rw_enabled ("char")) { |
| |
| VFun fid (VFun::Char, "char", VFun::DefaultTraits, 0); |
| |
| traits_eof = -1; |
| |
| run_test (&fid); |
| |
| fid.tid_ = VFun::UserTraits; |
| fid.tname_ = "UserTraits"; |
| traits_eof = '$'; |
| |
| run_test (&fid); |
| } |
| else |
| rw_note (0, 0, 0, "char tests disabled"); |
| |
| if (rw_enabled ("wchar_t")) { |
| VFun fid (VFun::WChar, "wchar_t", VFun::DefaultTraits, 0); |
| |
| traits_eof = -1; |
| |
| run_test (&fid); |
| |
| fid.tid_ = VFun::UserTraits; |
| fid.tname_ = "UserTraits"; |
| traits_eof = '$'; |
| |
| run_test (&fid); |
| } |
| else |
| rw_note (0, 0, 0, "char tests disabled"); |
| |
| return 0; |
| } |
| |
| /**************************************************************************/ |
| |
| int main (int argc, char *argv[]) |
| { |
| return rw_test (argc, argv, __FILE__, |
| "lib.stringbuf.virtuals", |
| 0, // no comment |
| run_test, |
| "|-no-xsputn# " |
| "|-no-pbackfail# " |
| "|-no-overflow# " |
| "|-no-underflow# " |
| "|-no-seekoff# " |
| "|-no-seekpos# " |
| "|-no-seek# " |
| "|-no-char_traits# " |
| "|-no-user_traits# " |
| "|-max_buf_size#0-*", |
| &rw_opt_no_xsputn, |
| &rw_opt_no_pbackfail, |
| &rw_opt_no_overflow, |
| &rw_opt_no_underflow, |
| &rw_opt_no_seekoff, |
| &rw_opt_no_seekpos, |
| &rw_opt_no_seek, |
| &rw_opt_no_char_traits, |
| &rw_opt_no_user_traits, |
| int (sizeof long_string) - 1, |
| &rw_opt_max_size); |
| } |
