'gcc-3_2-branch'.
From-SVN: r55785
--- /dev/null
+// Red Hat bugzilla 64535
+// Bug: We are allocationg stuff into the tail padding of POD class "A".
+// { dg-do run }
+
+struct A
+{
+ int x;
+ char y;
+};
+
+struct B : public A {
+ virtual void f () {}
+ char z;
+};
+
+A a = { 21, 42 };
+B b;
+
+int
+main (void)
+{
+ b.x = 12;
+ b.y = 24;
+ b.z = 36;
+
+ A *ap = &b;
+
+ *ap = a;
+
+ return (b.z != 36);
+}
--- /dev/null
+// Red Hat bugzilla 65210
+// { dg-do run }
+
+struct A {
+ int a;
+};
+
+struct B : public virtual A {};
+
+struct C {
+ long double c;
+};
+
+struct D : public virtual C {
+ int d;
+};
+
+struct E : public B, public D {
+ int e;
+};
+
+E e;
+
+/* The layout of E should begin with the B-in-E vtable pointer, followed by
+ the D-in-E vtable pointer. The bug was that we used to pad out the D
+ fields for long double alignment. */
+
+int main ()
+{
+ D* dp = &e;
+ unsigned long d_offset = ((char*)dp) - ((char*) &e);
+ return (d_offset != sizeof(void *));
+}
--- /dev/null
+// Red Hat bugzilla 65035
+// Bug: We were encoding the name of the instantiation as 'operator int'
+// rather than 'operator T'.
+// { dg-do compile }
+
+struct C {
+ template <class T>
+ operator T ();
+};
+
+template <class T>
+C::operator T () { return 0; }
+
+template C::operator int ();
+
+// { dg-final { scan-assembler _ZN1CcvT_IiEEv } }
--- /dev/null
+// Test that we don't emit the type_info for a polymorphic class other than
+// with the vtable.
+
+struct A {
+ virtual ~A();
+};
+
+void f ()
+{
+ throw A();
+}
+
+// { dg-final { scan-assembler-dem-not {\ntypeinfo for A[: \t\n]} } }
--- /dev/null
+/* Copyright (C) 2002 Free Software Foundation.
+
+ Test memset with various combinations of constant pointer alignments and
+ lengths to make sure any optimizations in the compiler are correct.
+
+ Written by Roger Sayle, July 22, 2002. */
+
+#ifndef MAX_OFFSET
+#define MAX_OFFSET (sizeof (long long))
+#endif
+
+#ifndef MAX_COPY
+#define MAX_COPY 15
+#endif
+
+#ifndef MAX_EXTRA
+#define MAX_EXTRA (sizeof (long long))
+#endif
+
+#define MAX_LENGTH (MAX_OFFSET + MAX_COPY + MAX_EXTRA)
+
+static union {
+ char buf[MAX_LENGTH];
+ long long align_int;
+ long double align_fp;
+} u;
+
+char A = 'A';
+
+void reset ()
+{
+ int i;
+
+ for (i = 0; i < MAX_LENGTH; i++)
+ u.buf[i] = 'a';
+}
+
+void check (int off, int len, int ch)
+{
+ char *q;
+ int i;
+
+ q = u.buf;
+ for (i = 0; i < off; i++, q++)
+ if (*q != 'a')
+ abort ();
+
+ for (i = 0; i < len; i++, q++)
+ if (*q != ch)
+ abort ();
+
+ for (i = 0; i < MAX_EXTRA; i++, q++)
+ if (*q != 'a')
+ abort ();
+}
+
+int main ()
+{
+ int len;
+ char *p;
+
+ /* off == 0 */
+ for (len = 0; len < MAX_COPY; len++)
+ {
+ reset ();
+
+ p = memset (u.buf, '\0', len);
+ if (p != u.buf) abort ();
+ check (0, len, '\0');
+
+ p = memset (u.buf, A, len);
+ if (p != u.buf) abort ();
+ check (0, len, 'A');
+
+ p = memset (u.buf, 'B', len);
+ if (p != u.buf) abort ();
+ check (0, len, 'B');
+ }
+
+ /* off == 1 */
+ for (len = 0; len < MAX_COPY; len++)
+ {
+ reset ();
+
+ p = memset (u.buf+1, '\0', len);
+ if (p != u.buf+1) abort ();
+ check (1, len, '\0');
+
+ p = memset (u.buf+1, A, len);
+ if (p != u.buf+1) abort ();
+ check (1, len, 'A');
+
+ p = memset (u.buf+1, 'B', len);
+ if (p != u.buf+1) abort ();
+ check (1, len, 'B');
+ }
+
+ /* off == 2 */
+ for (len = 0; len < MAX_COPY; len++)
+ {
+ reset ();
+
+ p = memset (u.buf+2, '\0', len);
+ if (p != u.buf+2) abort ();
+ check (2, len, '\0');
+
+ p = memset (u.buf+2, A, len);
+ if (p != u.buf+2) abort ();
+ check (2, len, 'A');
+
+ p = memset (u.buf+2, 'B', len);
+ if (p != u.buf+2) abort ();
+ check (2, len, 'B');
+ }
+
+ /* off == 3 */
+ for (len = 0; len < MAX_COPY; len++)
+ {
+ reset ();
+
+ p = memset (u.buf+3, '\0', len);
+ if (p != u.buf+3) abort ();
+ check (3, len, '\0');
+
+ p = memset (u.buf+3, A, len);
+ if (p != u.buf+3) abort ();
+ check (3, len, 'A');
+
+ p = memset (u.buf+3, 'B', len);
+ if (p != u.buf+3) abort ();
+ check (3, len, 'B');
+ }
+
+ /* off == 4 */
+ for (len = 0; len < MAX_COPY; len++)
+ {
+ reset ();
+
+ p = memset (u.buf+4, '\0', len);
+ if (p != u.buf+4) abort ();
+ check (4, len, '\0');
+
+ p = memset (u.buf+4, A, len);
+ if (p != u.buf+4) abort ();
+ check (4, len, 'A');
+
+ p = memset (u.buf+4, 'B', len);
+ if (p != u.buf+4) abort ();
+ check (4, len, 'B');
+ }
+
+ /* off == 5 */
+ for (len = 0; len < MAX_COPY; len++)
+ {
+ reset ();
+
+ p = memset (u.buf+5, '\0', len);
+ if (p != u.buf+5) abort ();
+ check (5, len, '\0');
+
+ p = memset (u.buf+5, A, len);
+ if (p != u.buf+5) abort ();
+ check (5, len, 'A');
+
+ p = memset (u.buf+5, 'B', len);
+ if (p != u.buf+5) abort ();
+ check (5, len, 'B');
+ }
+
+ /* off == 6 */
+ for (len = 0; len < MAX_COPY; len++)
+ {
+ reset ();
+
+ p = memset (u.buf+6, '\0', len);
+ if (p != u.buf+6) abort ();
+ check (6, len, '\0');
+
+ p = memset (u.buf+6, A, len);
+ if (p != u.buf+6) abort ();
+ check (6, len, 'A');
+
+ p = memset (u.buf+6, 'B', len);
+ if (p != u.buf+6) abort ();
+ check (6, len, 'B');
+ }
+
+ /* off == 7 */
+ for (len = 0; len < MAX_COPY; len++)
+ {
+ reset ();
+
+ p = memset (u.buf+7, '\0', len);
+ if (p != u.buf+7) abort ();
+ check (7, len, '\0');
+
+ p = memset (u.buf+7, A, len);
+ if (p != u.buf+7) abort ();
+ check (7, len, 'A');
+
+ p = memset (u.buf+7, 'B', len);
+ if (p != u.buf+7) abort ();
+ check (7, len, 'B');
+ }
+
+ exit (0);
+}
+
--- /dev/null
+/* Test whether __compound_literal.* objects are not emitted unless
+ they are actually needed. */
+/* Origin: Jakub Jelinek <jakub@redhat.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=gnu89 -O2" } */
+/* { dg-final { scan-assembler-not "__compound_literal" } } */
+
+struct A { int i; int j; int k[4]; };
+struct B { };
+struct C { int i; };
+struct D { int i; struct C j; };
+
+struct A a = (struct A) { .j = 6, .k[2] = 12 };
+struct B b = (struct B) { };
+int c[] = (int []) { [2] = 6, 7, 8 };
+int d[] = (int [3]) { 1 };
+int e[2] = (int []) { 1, 2 };
+int f[2] = (int [2]) { 1 };
+struct C g[3] = { [2] = (struct C) { 13 }, [1] = (const struct C) { 12 } };
+struct D h = { .j = (struct C) { 15 }, .i = 14 };
+struct D i[2] = { [1].j = (const struct C) { 17 },
+ [0] = { 0, (struct C) { 16 } } };
+static const int *j = 1 ? (const int *) 0 : & (const int) { 26 };
+int k = (int) sizeof ((int [6]) { 1, 2, 3, 4, 5, 6 }) + 4;
+int l = (int) sizeof ((struct C) { 16 });
--- /dev/null
+// 2002-07-24 Benjamin Kosnik
+
+// Copyright (C) 2002 Free Software Foundation
+//
+// 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 2, 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 COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// 18.4.1.3 - Placement forms
+
+#include <new>
+#include <testsuite_hooks.h>
+
+// libstdc++/7286
+void test01()
+{
+ void* pc = new char;
+ void* pa = new char[10];
+ void* tmp;
+ operator delete(pc, tmp);
+ operator delete[](pa, tmp);
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// 2002-05-18 Paolo Carlini <pcarlini@unitus.it>
+
+// Copyright (C) 2002 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 2, 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 COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// 23.2.1 deque operators
+
+#include <deque>
+#include <testsuite_hooks.h>
+
+// libstdc++/6503
+void test01()
+{
+ bool test = true;
+
+ std::deque<int> d(2);
+ typedef std::deque<int>::iterator iter;
+ typedef std::deque<int>::const_iterator constiter;
+
+ iter beg = d.begin();
+ iter end = d.end();
+ constiter constbeg = d.begin();
+ constiter constend = d.end();
+
+ VERIFY( beg == constbeg );
+ VERIFY( constend == end );
+
+ VERIFY( beg != constend );
+ VERIFY( constbeg != end );
+
+ VERIFY( beg < constend );
+ VERIFY( constbeg < end );
+
+ VERIFY( end > constbeg );
+ VERIFY( constend > beg );
+
+ VERIFY( end >= constend );
+ VERIFY( constbeg >= beg );
+
+ VERIFY( beg <= constbeg );
+ VERIFY( constend <= end );
+}
+
+// libstdc++/7186
+void test02()
+{
+ bool test = true;
+
+ std::deque<int> d(2);
+ typedef std::deque<int>::iterator iter;
+ typedef std::deque<int>::const_iterator constiter;
+
+ iter beg = d.begin();
+ iter end = d.end();
+ constiter constbeg = d.begin();
+ constiter constend = d.end();
+
+ VERIFY( beg - constbeg == 0 );
+ VERIFY( constend - end == 0 );
+
+ VERIFY( end - constbeg > 0 );
+ VERIFY( constend - beg > 0 );
+}
+
+int main()
+{
+ test01();
+ test02();
+ return 0;
+}
--- /dev/null
+// 2002-07-25 Benjamin Kosnik <bkoz@redhat.com>
+
+// Copyright (C) 2002 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 2, 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 COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// 27.8.1.11 - Template class basic_fstream
+// NB: This file is for testing basic_fstream with NO OTHER INCLUDES.
+
+#include <fstream>
+
+// { dg-do compile }
+
+// libstdc++/7216
+void test01()
+{
+ // Check for required typedefs
+ typedef std::fstream test_type;
+ typedef test_type::char_type char_type;
+ typedef test_type::traits_type traits_type;
+ typedef test_type::int_type int_type;
+ typedef test_type::pos_type pos_type;
+ typedef test_type::off_type off_type;
+}
+
+namespace test
+{
+ using namespace std;
+ typedef short type_t;
+ template class basic_fstream<type_t, char_traits<type_t> >;
+} // test
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// 2002-07-25 Benjamin Kosnik <bkoz@redhat.com>
+
+// Copyright (C) 2002 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 2, 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 COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// 27.8.1.5 - Template class basic_ifstream
+// NB: This file is for testing basic_ifstream with NO OTHER INCLUDES.
+
+#include <fstream>
+
+// { dg-do compile }
+
+// libstdc++/7216
+void test01()
+{
+ // Check for required typedefs
+ typedef std::ifstream test_type;
+ typedef test_type::char_type char_type;
+ typedef test_type::traits_type traits_type;
+ typedef test_type::int_type int_type;
+ typedef test_type::pos_type pos_type;
+ typedef test_type::off_type off_type;
+}
+
+namespace test
+{
+ using namespace std;
+ typedef short type_t;
+ template class basic_ifstream<type_t, char_traits<type_t> >;
+} // test
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// 2002-07-25 Benjamin Kosnik <bkoz@redhat.com>
+
+// Copyright (C) 2002 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 2, 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 COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// 27.4.4 - Template class basic_ios
+// NB: This file is for testing basic_ios with NO OTHER INCLUDES.
+
+#include <ios>
+
+// { dg-do compile }
+
+// libstdc++/7216
+void test01()
+{
+ // Check for required typedefs
+ typedef std::ios test_type;
+ typedef test_type::char_type char_type;
+ typedef test_type::traits_type traits_type;
+ typedef test_type::int_type int_type;
+ typedef test_type::pos_type pos_type;
+ typedef test_type::off_type off_type;
+}
+
+namespace test
+{
+ using namespace std;
+ typedef short type_t;
+ template class basic_ios<type_t, char_traits<type_t> >;
+} // test
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// 2002-07-25 Benjamin Kosnik <bkoz@redhat.com>
+
+// Copyright (C) 2002 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 2, 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 COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// 27.7.2 - Template class basic_istringstream
+// NB: This file is for testing basic_istringstream with NO OTHER INCLUDES.
+
+#include <sstream>
+
+// { dg-do compile }
+
+// libstdc++/7216
+void test01()
+{
+ // Check for required typedefs
+ typedef std::istringstream test_type;
+ typedef test_type::char_type char_type;
+ typedef test_type::traits_type traits_type;
+ typedef test_type::int_type int_type;
+ typedef test_type::pos_type pos_type;
+ typedef test_type::off_type off_type;
+}
+
+namespace test
+{
+ using namespace std;
+ typedef short type_t;
+ template class basic_istringstream<type_t, char_traits<type_t> >;
+} // test
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// 2002-07-25 Benjamin Kosnik <bkoz@redhat.com>
+
+// Copyright (C) 2002 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 2, 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 COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// 27.8.1.8 - Template class basic_ofstream
+// NB: This file is for testing basic_ofstream with NO OTHER INCLUDES.
+
+#include <fstream>
+
+// { dg-do compile }
+
+// libstdc++/7216
+void test01()
+{
+ // Check for required typedefs
+ typedef std::ifstream test_type;
+ typedef test_type::char_type char_type;
+ typedef test_type::traits_type traits_type;
+ typedef test_type::int_type int_type;
+ typedef test_type::pos_type pos_type;
+ typedef test_type::off_type off_type;
+}
+
+namespace test
+{
+ using namespace std;
+ typedef short type_t;
+ template class basic_ifstream<type_t, char_traits<type_t> >;
+} // test
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// 2002-07-25 Benjamin Kosnik <bkoz@redhat.com>
+
+// Copyright (C) 2002 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 2, 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 COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// 27.7.3 - Class basic_ostringstream
+// NB: This file is for testing basic_ostringstream with NO OTHER INCLUDES.
+
+#include <sstream>
+
+// { dg-do compile }
+
+// libstdc++/7216
+void test01()
+{
+ // Check for required typedefs
+ typedef std::ostringstream test_type;
+ typedef test_type::char_type char_type;
+ typedef test_type::traits_type traits_type;
+ typedef test_type::int_type int_type;
+ typedef test_type::pos_type pos_type;
+ typedef test_type::off_type off_type;
+}
+
+namespace test
+{
+ using namespace std;
+ typedef short type_t;
+ template class basic_ostringstream<type_t, char_traits<type_t> >;
+} // test
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// 1999-10-11 bkoz
+
+// Copyright (C) 1999, 2000, 2001, 2002 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 2, 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 COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+// 27.5.2 template class basic_streambuf
+
+#include <cstring> // for memset, memcmp
+#include <streambuf>
+#include <string>
+#include <ostream>
+#include <testsuite_hooks.h>
+
+class testbuf : public std::streambuf
+{
+public:
+
+ // Typedefs:
+ typedef std::streambuf::traits_type traits_type;
+ typedef std::streambuf::char_type char_type;
+
+ testbuf(): std::streambuf()
+ { _M_mode = (std::ios_base::in | std::ios_base::out); }
+
+ bool
+ check_pointers()
+ {
+ bool test = true;
+ VERIFY( this->eback() == NULL );
+ VERIFY( this->gptr() == NULL );
+ VERIFY( this->egptr() == NULL );
+ VERIFY( this->pbase() == NULL );
+ VERIFY( this->pptr() == NULL );
+ VERIFY( this->epptr() == NULL );
+ return test;
+ }
+
+ int_type
+ pub_uflow()
+ { return (this->uflow()); }
+
+ int_type
+ pub_overflow(int_type __c = traits_type::eof())
+ { return (this->overflow(__c)); }
+
+ int_type
+ pub_pbackfail(int_type __c)
+ { return (this->pbackfail(__c)); }
+
+ void
+ pub_setg(char* beg, char* cur, char *end)
+ { this->setg(beg, cur, end); }
+
+ void
+ pub_setp(char* beg, char* end)
+ { this->setp(beg, end); }
+
+protected:
+ int_type
+ underflow()
+ {
+ int_type __retval = traits_type::eof();
+ if (this->gptr() < this->egptr())
+ __retval = traits_type::not_eof(0);
+ return __retval;
+ }
+};
+
+void test01()
+{
+ typedef testbuf::traits_type traits_type;
+ typedef testbuf::int_type int_type;
+
+ bool test = true;
+ char* lit01 = "chicago underground trio/possible cube on delmark";
+ testbuf buf01;
+
+ // 27.5.2.1 basic_streambuf ctors
+ // default ctor initializes
+ // - all pointer members to null pointers
+ // - locale to current global locale
+ VERIFY( buf01.check_pointers() );
+ VERIFY( buf01.getloc() == std::locale() );
+
+ // 27.5.2.3.1 get area
+ // 27.5.2.2.3 get area
+ // 27.5.2.4.3 get area
+ int i01 = 3;
+ buf01.pub_setg(lit01, lit01, (lit01 + i01));
+ VERIFY( i01 == buf01.in_avail() );
+
+ VERIFY( buf01.pub_uflow() == lit01[0] );
+ VERIFY( buf01.sgetc() == traits_type::to_int_type(lit01[1]) );
+ VERIFY( buf01.pub_uflow() == lit01[1] );
+ VERIFY( buf01.sgetc() == traits_type::to_int_type(lit01[2]) );
+ VERIFY( buf01.pub_uflow() == lit01[2] );
+ VERIFY( buf01.sgetc() == traits_type::eof() );
+
+ // pbackfail
+ buf01.pub_setg(lit01, lit01, (lit01 + i01));
+ VERIFY( i01 == buf01.in_avail() );
+ int_type intt01 = traits_type::to_int_type('b');
+ VERIFY( traits_type::eof() == buf01.pub_pbackfail(intt01) );
+
+ // overflow
+ VERIFY( traits_type::eof() == buf01.pub_overflow(intt01) );
+ VERIFY( traits_type::eof() == buf01.pub_overflow() );
+ VERIFY( buf01.sgetc() == traits_type::to_int_type(lit01[0]) );
+
+ // sputn/xsputn
+ char* lit02 = "isotope 217: the unstable molecule on thrill jockey";
+ int i02 = std::strlen(lit02);
+ char carray[i02 + 1];
+ std::memset(carray, 0, i02 + 1);
+
+ buf01.pub_setp(carray, (carray + i02));
+ buf01.sputn(lit02, 0);
+ VERIFY( carray[0] == 0 );
+ VERIFY( lit02[0] == 'i' );
+ buf01.sputn(lit02, 1);
+ VERIFY( lit02[0] == carray[0] );
+ VERIFY( lit02[1] == 's' );
+ VERIFY( carray[1] == 0 );
+ buf01.sputn(lit02 + 1, 10);
+ VERIFY( std::memcmp(lit02, carray, 10) == 0 );
+ buf01.sputn(lit02 + 11, 20);
+ VERIFY( std::memcmp(lit02, carray, 30) == 0 );
+
+#ifdef DEBUG_ASSERT
+ assert(test);
+#endif
+}
+
+void test02()
+{
+ typedef testbuf::traits_type traits_type;
+ typedef testbuf::int_type int_type;
+
+ bool test = true;
+ char* lit01 = "chicago underground trio/possible cube on delmark";
+ testbuf buf01;
+
+ // 27.5.2.1 basic_streambuf ctors
+ // default ctor initializes
+ // - all pointer members to null pointers
+ // - locale to current global locale
+ VERIFY( buf01.check_pointers() );
+ VERIFY( buf01.getloc() == std::locale() );
+
+ // 27.5.2.2.5 Put area
+ size_t i01 = traits_type::length(lit01);
+ char carray01[i01];
+ std::memset(carray01, 0, i01);
+
+ buf01.pub_setg(lit01, lit01, lit01 + i01);
+ buf01.sgetn(carray01, 0);
+ VERIFY( carray01[0] == 0 );
+ buf01.sgetn(carray01, 1);
+ VERIFY( carray01[0] == 'c' );
+ buf01.sgetn(carray01 + 1, i01 - 1);
+ VERIFY( carray01[0] == 'c' );
+ VERIFY( carray01[1] == 'h' );
+ VERIFY( carray01[i01 - 1] == 'k' );
+
+#ifdef DEBUG_ASSERT
+ assert(test);
+#endif
+}
+
+// test03
+// http://gcc.gnu.org/ml/libstdc++/2000-q1/msg00151.html
+template<typename charT, typename traits = std::char_traits<charT> >
+ class basic_nullbuf : public std::basic_streambuf<charT, traits>
+ {
+ protected:
+ typedef typename
+ std::basic_streambuf<charT, traits>::int_type int_type;
+ virtual int_type
+ overflow(int_type c)
+ { return traits::not_eof(c); }
+ };
+
+typedef basic_nullbuf<char> nullbuf;
+typedef basic_nullbuf<wchar_t> wnullbuf;
+
+template<typename T>
+ char
+ print(const T& x)
+ {
+ nullbuf ob;
+ std::ostream out(&ob);
+ out << x << std::endl;
+ return (!out ? '0' : '1');
+ }
+
+void test03()
+{
+ bool test = true;
+ const std::string control01("11111");
+ std::string test01;
+
+ test01 += print(true);
+ test01 += print(3.14159);
+ test01 += print(10);
+ test01 += print('x');
+ test01 += print("pipo");
+
+ VERIFY( test01 == control01 );
+#ifdef DEBUG_ASSERT
+ assert(test);
+#endif
+}
+
+class setpbuf : public std::streambuf
+{
+ char buffer[4];
+ std::string result;
+
+public:
+
+ std::string&
+ get_result()
+ { return result; }
+
+ setpbuf()
+ {
+ char foo [32];
+ setp(foo, foo + 32);
+ setp(buffer, buffer + 4);
+ }
+
+ ~setpbuf()
+ { sync(); }
+
+ virtual int_type
+ overflow(int_type n)
+ {
+ if (sync() != 0)
+ return traits_type::eof();
+
+ result += traits_type::to_char_type(n);
+
+ return n;
+ }
+
+ virtual int
+ sync()
+ {
+ result.append(pbase(), pptr());
+ setp(buffer, buffer + 4);
+ return 0;
+ }
+};
+
+// libstdc++/1057
+void test04()
+{
+ bool test = true;
+ std::string text = "abcdefghijklmn";
+
+ // 01
+ setpbuf sp1;
+ // Here xsputn writes over sp1.result
+ sp1.sputn(text.c_str(), text.length());
+
+ // This crashes when result is accessed
+ sp1.pubsync();
+ VERIFY( sp1.get_result() == text );
+
+
+ // 02
+ setpbuf sp2;
+ for (std::string::size_type i = 0; i < text.length(); ++i)
+ {
+ // sputc also writes over result
+ sp2.sputc(text[i]);
+ }
+
+ // Crash here
+ sp2.pubsync();
+ VERIFY( sp2.get_result() == text );
+}
+
+class nullsetpbuf : public std::streambuf
+{
+ char foo[64];
+public:
+ nullsetpbuf()
+ {
+ setp(foo, foo + 64);
+ setp(NULL, NULL);
+ }
+};
+
+// libstdc++/1057
+void test05()
+{
+ std::string text1 = "abcdefghijklmn";
+
+ nullsetpbuf nsp;
+ // Immediate crash as xsputn writes to null pointer
+ nsp.sputn(text1.c_str(), text1.length());
+ // ditto
+ nsp.sputc('a');
+}
+
+// test06
+namespace gnu
+{
+ class something_derived;
+}
+
+class gnu::something_derived : std::streambuf { };
+
+// libstdc++/3599
+class testbuf2 : public std::streambuf
+{
+public:
+ typedef std::streambuf::traits_type traits_type;
+
+ testbuf2() : std::streambuf() { }
+
+protected:
+ int_type
+ overflow(int_type c = traits_type::eof())
+ { return traits_type::not_eof(0); }
+};
+
+void
+test07()
+{
+ bool test = true;
+ testbuf2 ob;
+ std::ostream out(&ob);
+
+ out << "gasp";
+ VERIFY(out.good());
+
+ out << std::endl;
+ VERIFY(out.good());
+}
+
+int main()
+{
+ test01();
+ test02();
+ test03();
+
+ test04();
+ test05();
+
+ test07();
+ return 0;
+}
--- /dev/null
+// 981208 bkoz test functionality of basic_stringbuf for char_type == char
+
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
+// 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 2, 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 COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#include <sstream>
+#include <testsuite_hooks.h>
+
+std::string str_01("mykonos. . . or what?");
+std::string str_02("paris, or sainte-maxime?");
+std::string str_03;
+std::stringbuf strb_01(str_01);
+std::stringbuf strb_02(str_02, std::ios_base::in);
+std::stringbuf strb_03(str_03, std::ios_base::out);
+
+
+// test the underlying allocator
+bool test01() {
+ bool test = false;
+ std::allocator<char> alloc_01;
+ std::allocator<char>::size_type size_01 = alloc_01.max_size();
+ std::allocator<char>::pointer p_01 = alloc_01.allocate(32);
+
+ return true;
+}
+
+
+// test the streambuf/stringbuf locale settings
+bool test02() {
+ std::locale loc_tmp;
+ loc_tmp = strb_01.getloc();
+ strb_01.pubimbue(loc_tmp); //This should initialize _M_init to true
+ strb_01.getloc(); //This should just return _M_locale
+
+ return true;
+}
+
+
+// test member functions
+bool test03() {
+ bool test = true;
+
+ //stringbuf::str()
+ VERIFY( strb_01.str() == str_01 );
+ VERIFY( strb_02.str() == str_02 );
+ VERIFY( strb_03.str() == str_03 );
+
+ //stringbuf::str(string&)
+ strb_03.str("none of the above, go to the oberoi in cairo, egypt.");
+ strb_03.str(str_01);
+ std::streamsize d1 = strb_01.in_avail();
+ std::streamsize d2 = strb_03.in_avail();
+ VERIFY( d1 ); // non-zero
+ VERIFY( !d2 ); // zero, cuz ios_base::out
+ VERIFY( d1 != d2 ); //these should be the same
+ VERIFY( str_01.length() == d1 );
+ VERIFY( strb_01.str() == strb_03.str() ); //ditto
+
+ // stringbuf::str(string&) and stringbuf::stringbuf(string&), where the
+ // string in question contains embedded NUL characters. Note that in this
+ // embedded-NUL situation, the size must be passed to the string ctor.
+ std::string str_nulls ("eschew \0 obfuscation", 20); // tested in 21_strings
+ std::stringbuf strb_normal (str_01);
+ std::stringbuf strb_nulls (str_nulls);
+ strb_normal.str(str_nulls); // tried using 'strb_01' rather than declaring
+ // another variable, but then test04 broke!
+ VERIFY( strb_nulls.in_avail() == str_nulls.size() );
+ VERIFY( strb_nulls.str().size() == 20 );
+ VERIFY( strb_normal.in_avail() == str_nulls.size() );
+
+#ifdef DEBUG_ASSERT
+ assert(test);
+#endif
+
+ return test;
+}
+
+
+// test overloaded virtual functions
+bool test04() {
+ bool test = true;
+ std::string str_tmp;
+ std::stringbuf strb_tmp;
+ std::streamsize strmsz_1, strmsz_2;
+ std::streamoff strmof_1(-1), strmof_2;
+ typedef std::stringbuf::int_type int_type;
+ typedef std::stringbuf::traits_type traits_type;
+ typedef std::stringbuf::pos_type pos_type;
+ typedef std::stringbuf::off_type off_type;
+
+ // GET
+ // int in_avail()
+ strmof_1 = strb_01.in_avail();
+ strmof_2 = strb_02.in_avail();
+ VERIFY( strmof_1 != strmof_2 );
+ VERIFY( strmof_1 == str_01.length() );
+ VERIFY( strmof_2 == str_02.length() );
+ strmof_1 = strb_03.in_avail();
+ VERIFY( strmof_1 == 0 ); // zero cuz write-only, or eof()? zero, from showmany
+
+ // int_type sbumpc()
+ // if read_cur not avail, return uflow(), else return *read_cur & increment
+ int_type c1 = strb_01.sbumpc();
+ int_type c2 = strb_02.sbumpc();
+ VERIFY( c1 != c2 );
+ VERIFY( c1 == str_01[0] );
+ VERIFY( c2 == str_02[0] ); //should equal first letter at this point
+ int_type c3 = strb_01.sbumpc();
+ int_type c4 = strb_02.sbumpc();
+ VERIFY( c1 != c2 );
+ VERIFY( c1 != c3 );
+ VERIFY( c2 != c4 );
+ int_type c5 = strb_03.sbumpc();
+ VERIFY( c5 == traits_type::eof() );
+
+ // int_type sgetc()
+ // if read_cur not avail, return uflow(), else return *read_cur
+ int_type c6 = strb_01.sgetc();
+ int_type c7 = strb_02.sgetc();
+ VERIFY( c6 != c3 );
+ VERIFY( c7 != c4 );
+ int_type c8 = strb_01.sgetc();
+ int_type c9 = strb_02.sgetc();
+ VERIFY( c6 == c8 );
+ VERIFY( c7 == c9 );
+ c5 = strb_03.sgetc();
+ VERIFY( c5 == traits_type::eof() );
+
+ // int_type snextc()
+ // calls sbumpc and if sbumpc != eof, return sgetc
+ c6 = strb_01.snextc();
+ c7 = strb_02.snextc();
+ VERIFY( c6 != c8 );
+ VERIFY( c7 != c9 );
+ VERIFY( c6 == str_01[3] );
+ VERIFY( c7 == str_02[3] ); //should equal fourth letter at this point
+ c5 = strb_03.snextc();
+ VERIFY( c5 == traits_type::eof() );
+
+ // int showmanyc
+ // streamsize sgetn(char_type *s, streamsize n)
+ // streamsize xsgetn(char_type *s, streamsize n)
+ // assign up to n chars to s from input sequence, indexing in_cur as
+ // approp and returning the number of chars assigned
+ strmsz_1 = strb_01.in_avail();
+ strmsz_2 = strb_02.in_avail();
+ test = strmsz_1 != strmsz_2;
+ VERIFY( strmsz_1 != str_01.length() );
+ VERIFY( strmsz_2 != str_02.length() ); //because now we've moved into string
+ char carray1[11] = "";
+ strmsz_1 = strb_01.sgetn(carray1, 10);
+ char carray2[20] = "";
+ strmsz_2 = strb_02.sgetn(carray2, 10);
+ VERIFY( strmsz_1 == strmsz_2 );
+ VERIFY( strmsz_1 == 10 );
+ c1 = strb_01.sgetc();
+ c2 = strb_02.sgetc();
+ VERIFY( c6 == c1 ); //just by co-incidence both o's
+ VERIFY( c7 != c2 ); // n != i
+ VERIFY( c1 == str_01[13] );
+ VERIFY( c2 == str_02[13] ); //should equal fourteenth letter at this point
+ strmsz_1 = strb_03.sgetn(carray1, 10);
+ VERIFY( !strmsz_1 ); //zero
+ strmsz_1 = strb_02.in_avail();
+ strmsz_2 = strb_02.sgetn(carray2, strmsz_1 + 5);
+ VERIFY( strmsz_1 == strmsz_2 ); //write off the end
+ c4 = strb_02.sgetc(); // should be EOF
+ VERIFY( c4 == traits_type::eof() );
+
+ // PUT
+ // int_type sputc(char_type c)
+ // if out_cur not avail, return overflow. Else, stores c at out_cur,
+ // increments out_cur, and returns c as int_type
+ strb_03.str(str_01); //reset
+ std::string::size_type sz1 = strb_03.str().length();
+ c1 = strb_03.sputc('a');
+ std::string::size_type sz2 = strb_03.str().length();
+ VERIFY( sz1 == sz2 ); //cuz inserting at out_cur, which is at beg to start
+ c2 = strb_03.sputc('b');
+ VERIFY( c1 != c2 );
+ VERIFY( strb_03.str() != str_01 );
+ c3 = strb_02.sputc('a'); // should be EOF because this is read-only
+ VERIFY( c3 == traits_type::eof() );
+
+ // streamsize sputn(const char_typs* s, streamsize n)
+ // write up to n chars to out_cur from s, returning number assigned
+ // NB *sputn will happily put '\0' into your stream if you give it a chance*
+ str_tmp = strb_03.str();
+ sz1 = str_tmp.length();
+ strmsz_1 = strb_03.sputn("racadabras", 10);//"abracadabras or what?"
+ sz2 = strb_03.str().length();
+ VERIFY( sz1 == sz2 ); //shouldn't have changed length
+ VERIFY( strmsz_1 == 10 );
+ VERIFY( str_tmp != strb_03.str() );
+ strmsz_2 = strb_03.sputn(", i wanna reach out and", 10);
+ VERIFY( strmsz_1 == strmsz_2 ); // should re-allocate, copy 10 chars.
+ VERIFY( strmsz_1 == 10 );
+ VERIFY( strmsz_2 == 10 );
+ sz2 = strb_03.str().length();
+ VERIFY( sz1 != sz2 ); // need to change length
+ VERIFY( str_tmp != strb_03.str() );
+ str_tmp = strb_02.str();
+ strmsz_1 = strb_02.sputn("racadabra", 10);
+ VERIFY( strmsz_1 == 0 );
+ VERIFY( str_tmp == strb_02.str() );
+
+ // PUTBACK
+ // int_type pbfail(int_type c)
+ // called when gptr() null, gptr() == eback(), or traits::eq(*gptr, c) false
+ // "pending sequence" is:
+ // 1) everything as defined in underflow
+ // 2) + if (traits::eq_int_type(c, traits::eof()), then input
+ // sequence is backed up one char before the pending sequence is
+ // determined.
+ // 3) + if (not 2) then c is prepended. Left unspecified is
+ // whether the input sequence is backedup or modified in any way
+ // returns traits::eof() for failure, unspecified other value for success
+
+ // int_type sputbackc(char_type c)
+ // if in_cur not avail || ! traits::eq(c, gptr() [-1]), return pbfail
+ // otherwise decrements in_cur and returns *gptr()
+ strmsz_1 = strb_01.in_avail();
+ str_tmp = strb_01.str();
+ c1 = strb_01.sgetc(); //"mykonos. . . 'o'r what?"
+ c2 = strb_01.sputbackc('z');//"mykonos. . .zor what?"
+ c3 = strb_01.sgetc();
+ VERIFY( c1 != c2 );
+ VERIFY( c3 == c2 );
+ VERIFY( strb_01.str() == std::string("mykonos. . .zor what?") );
+ VERIFY( str_tmp.size() == strb_01.str().size() );
+ //test for _in_cur == _in_beg
+ strb_01.str(str_tmp);
+ strmsz_1 = strb_01.in_avail();
+ c1 = strb_01.sgetc(); //"'m'ykonos. . . or what?"
+ c2 = strb_01.sputbackc('z');//"mykonos. . . or what?"
+ c3 = strb_01.sgetc();
+ VERIFY( c1 != c2 );
+ VERIFY( c3 != c2 );
+ VERIFY( c1 == c3 );
+ VERIFY( c2 == traits_type::eof() );
+ VERIFY( strb_01.str() == str_tmp );
+ VERIFY( str_tmp.size() == strb_01.str().size() );
+ // test for replacing char with identical one
+ strb_01.str(str_01); //reset
+ strmsz_1 = strb_01.in_avail();
+ strb_01.sbumpc();
+ strb_01.sbumpc();
+ c1 = strb_01.sgetc(); //"my'k'onos. . . or what?"
+ c2 = strb_01.sputbackc('y');//"mykonos. . . or what?"
+ c3 = strb_01.sgetc();
+ VERIFY( c1 != c2 );
+ VERIFY( c3 == c2 );
+ VERIFY( c1 != c3 );
+ VERIFY( strb_01.str() == str_01 );
+ VERIFY( str_01.size() == strb_01.str().size() );
+ //test for ios_base::out
+ strmsz_2 = strb_03.in_avail();
+ c4 = strb_03.sputbackc('x');
+ VERIFY( c4 == traits_type::eof() );
+
+ // int_type sungetc()
+ // if in_cur not avail, return pbackfail(), else decrement and
+ // return to_int_type(*gptr())
+ for (int i = 0; i<12; ++i)
+ strb_01.sbumpc();
+ strmsz_1 = strb_01.in_avail();
+ str_tmp = strb_01.str();
+ c1 = strb_01.sgetc(); //"mykonos. . . 'o'r what?"
+ c2 = strb_01.sungetc();//"mykonos. . . or what?"
+ c3 = strb_01.sgetc();
+ VERIFY( c1 != c2 );
+ VERIFY( c3 == c2 );
+ VERIFY( c1 != c3 );
+ VERIFY( c2 == ' ' );
+ VERIFY( strb_01.str() == str_01 );
+ VERIFY( str_01.size() == strb_01.str().size() );
+ //test for _in_cur == _in_beg
+ strb_01.str(str_tmp);
+ strmsz_1 = strb_01.in_avail();
+ c1 = strb_01.sgetc(); //"'m'ykonos. . . or what?"
+ c2 = strb_01.sungetc();//"mykonos. . . or what?"
+ c3 = strb_01.sgetc();
+ VERIFY( c1 != c2 );
+ VERIFY( c3 != c2 );
+ VERIFY( c1 == c3 );
+ VERIFY( c2 == traits_type::eof() );
+ VERIFY( strb_01.str() == str_01 );
+ VERIFY( str_01.size() == strb_01.str().size() );
+ // test for replacing char with identical one
+ strb_01.str(str_01); //reset
+ strmsz_1 = strb_01.in_avail();
+ strb_01.sbumpc();
+ strb_01.sbumpc();
+ c1 = strb_01.sgetc(); //"my'k'onos. . . or what?"
+ c2 = strb_01.sungetc();//"mykonos. . . or what?"
+ c3 = strb_01.sgetc();
+ VERIFY( c1 != c2 );
+ VERIFY( c3 == c2 );
+ VERIFY( c1 != c3 );
+ VERIFY( strb_01.str() == str_01 );
+ VERIFY( str_01.size() == strb_01.str().size() );
+ //test for ios_base::out
+ strmsz_2 = strb_03.in_avail();
+ c4 = strb_03.sungetc();
+ VERIFY( c4 == traits_type::eof() );
+
+ // BUFFER MANAGEMENT & POSITIONING
+ // sync
+ // pubsync
+ strb_01.pubsync();
+ strb_02.pubsync();
+ strb_03.pubsync();
+
+ // setbuf
+ // pubsetbuf(char_type* s, streamsize n)
+ str_tmp = std::string("naaaah, go to cebu");
+ strb_01.pubsetbuf(const_cast<char*> (str_tmp.c_str()), str_tmp.size());
+ VERIFY( strb_01.str() == str_tmp );
+ strb_01.pubsetbuf(0,0);
+ VERIFY( strb_01.str() == str_tmp );
+
+ // seekoff
+ // pubseekoff(off_type off, ios_base::seekdir way, ios_base::openmode which)
+ // alters the stream position to off
+ pos_type pt_1(off_type(-1));
+ pos_type pt_2(off_type(0));
+ off_type off_1 = 0;
+ off_type off_2 = 0;
+ strb_01.str(str_01); //in|out ("mykonos. . . or what?");
+ strb_02.str(str_02); //in ("paris, or sainte-maxime?");
+ strb_03.str(str_03); //out ("")
+ //IN|OUT
+ //beg
+ pt_1 = strb_01.pubseekoff(2, std::ios_base::beg);
+ off_1 = pt_1;
+ VERIFY( off_1 >= 0 );
+ c1 = strb_01.snextc(); //current in pointer +1
+ VERIFY( c1 == 'o' );
+ c2 = strb_01.sputc('x'); //test current out pointer
+ str_tmp = std::string("myxonos. . . or what?");
+ VERIFY( strb_01.str() == str_tmp );
+ //cur
+ pt_1 = strb_01.pubseekoff(2, std::ios_base::cur);
+ off_1 = pt_1;
+ VERIFY( off_1 == -1 ); // can't seekoff for in and out + cur in sstreams
+ pt_1 = strb_01.pubseekoff(2, std::ios_base::cur, std::ios_base::in);
+ off_1 = pt_1;
+ pt_2 = strb_01.pubseekoff(2, std::ios_base::cur, std::ios_base::in);
+ off_2 = pt_2;
+ VERIFY( off_2 == off_1 + 2 );
+ c1 = strb_01.snextc(); //current in pointer + 1
+ VERIFY( c1 == ' ' );
+ c2 = strb_01.sputc('x'); //test current out pointer
+ str_tmp = std::string("myxxnos. . . or what?");
+ VERIFY( strb_01.str() == str_tmp );
+ //end
+ pt_2 = strb_01.pubseekoff(2, std::ios_base::end);
+ off_1 = pt_2;
+ VERIFY( off_1 == -1 ); // not a valid position
+ VERIFY( strb_01.str() == str_tmp );
+ // end part two (from the filebuf tests)
+ strb_01.pubseekoff(0, std::ios_base::end);
+ strmsz_1 = strb_01.in_avail(); // 0 cuz at the end
+ c1 = strb_01.sgetc();
+ c2 = strb_01.sungetc();
+ strmsz_2 = strb_01.in_avail(); // 1
+ c3 = strb_01.sgetc();
+ VERIFY( c1 != c2 );
+ VERIFY( strmsz_2 != strmsz_1 );
+ VERIFY( strmsz_2 == 1 );
+ // end part three
+ strmsz_1 = strb_01.str().size();
+ strmsz_2 = strb_01.sputn(" ravi shankar meets carlos santana in LoHa", 90);
+ strb_01.pubseekoff(0, std::ios_base::end);
+ strb_01.sputc('<');
+ str_tmp = strb_01.str();
+ VERIFY( str_tmp.size() == strmsz_1 + strmsz_2 + 1 );
+ // IN
+ // OUT
+
+ // seekpos
+ // pubseekpos(pos_type sp, ios_base::openmode)
+ // alters the stream position to sp
+ strb_01.str(str_01); //in|out ("mykonos. . . or what?");
+ strb_02.str(str_02); //in ("paris, or sainte-maxime?");
+ strb_03.str(str_03); //out ("")
+ //IN|OUT
+ //beg
+ pt_1 = strb_01.pubseekoff(2, std::ios_base::beg);
+ off_1 = pt_1;
+ VERIFY( off_1 >= 0 );
+ pt_1 = strb_01.pubseekoff(0, std::ios_base::cur, std::ios_base::out);
+ off_1 = pt_1;
+ c1 = strb_01.snextc(); //current in pointer +1
+ VERIFY( c1 == 'o' );
+ c2 = strb_01.sputc('x'); //test current out pointer
+ str_tmp = std::string("myxonos. . . or what?");
+ VERIFY( strb_01.str() == str_tmp );
+ strb_01.pubsync(); //resets pointers
+ pt_2 = strb_01.pubseekpos(pt_1, std::ios_base::in|std::ios_base::out);
+ off_2 = pt_2;
+ VERIFY( off_1 == off_2 );
+ c3 = strb_01.snextc(); //current in pointer +1
+ VERIFY( c1 == c3 );
+ c2 = strb_01.sputc('x'); //test current out pointer
+ str_tmp = std::string("myxonos. . . or what?");
+ VERIFY( strb_01.str() == str_tmp );
+
+ // VIRTUALS (indirectly tested)
+ // underflow
+ // if read position avail, returns *gptr()
+
+ // pbackfail(int_type c)
+ // put c back into input sequence
+
+ // overflow
+ // appends c to output seq
+
+#ifdef DEBUG_ASSERT
+ assert(test);
+#endif
+
+ return test;
+}
+
+
+// libstdc++/3955 -- ios_base::app overwrites from the beginning
+bool test05()
+{
+ bool test = true;
+
+ std::ostringstream os ("foo");
+ os << "bar";
+
+ test = os.str() == "bar";
+
+#ifdef DEBUG_ASSERT
+ assert(test);
+#endif
+
+ return test;
+}
+
+bool test06()
+{
+ bool test = true;
+
+ std::ostringstream os ("foo", std::ios_base::app);
+ os << "bar";
+
+ test = os.str() == "foobar";
+
+#ifdef DEBUG_ASSERT
+ assert(test);
+#endif
+
+ return test;
+}
+
+int main()
+{
+ test01();
+ test02();
+ test03();
+ test04();
+ test05();
+ test06();
+
+ return 0;
+}
+
+
+
+// more candy!!!
projects / thirdparty / gcc.git / commitdiff
