llvm-gcc-4.2/libstdc++-v3/testsuite/24_iterators/iterator.cc - llvm-archive - Git at Google

 // 24.1.5 Random access iterators
 // 24.3.1 Iterator traits
 // (basic_string and vector implementations)
 //
 // Copyright (C) 1999, 2003, 2004, 2005 Free Software Foundation, Inc.
 // This program 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 of the License, or
 // (at your option) any later version.
 //
 // This program 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 program; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
 // USA


 #include <string>
 #include <vector>
 #include <testsuite_hooks.h>

 int
 string_stuff()
 {
    int failures(0);

    std::string s("abcde");

    std::string::iterator i1(s.begin());
    if (*i1 != 'a')
       ++failures;

    ++i1;
    if (*i1 != 'b')
       ++failures;

    if (*i1++ != 'b')
        ++failures;
    if (*i1 != 'c')
       ++failures;

    ++ ++i1;
    if (*i1 != 'e')
       ++failures;

    --i1;
    if (*i1 != 'd')
       ++failures;

    if (*i1-- != 'd')
       ++failures;
    if (*i1 != 'c')
       ++failures;

    -- --i1;
    if (*i1 != 'a')
       ++failures;

    std::string::iterator i2;
    i2 = s.end();
    std::iterator_traits<std::string::iterator>::difference_type d1;
    d1 = i2 - i1;
    if (d1 != 5)
       ++failures;

    std::iterator_traits<std::string::iterator>::value_type v1;
    v1 = i1[0];
    if (v1 != 'a')
       ++failures;

    std::iterator_traits<std::string::iterator>::reference r1(i1[0]);
    if (r1 != 'a')
       ++failures;
    r1 = 'x';
    if (r1 != 'x')
       ++failures;
    r1 = 'a';

    if ((i1 != i2) != true)
       ++failures;
    if ((i1 == i2) != false)
       ++failures;
    if ((i1 <  i2) != true)
       ++failures;
    if ((i1 >  i2) != false)
       ++failures;
    if ((i1 <= i2) != true)
       ++failures;
    if ((i1 >= i2) != false)
       ++failures;

    std::string::iterator i3;
    i3 = i1;
    if ((i3 == i1) != true)
       ++failures;

    i3 += 5;
    if ((i3 == i2) != true)
       ++failures;

    i3 -= 5;
    if ((i3 == i1) != true)
       ++failures;

    if (i3 + 5 != i2)
       ++failures;

    if (5 + i3 != i2)
       ++failures;

    if (i2 - 5 != i3)
       ++failures;

    if (i1[0] != 'a')
       ++failures;

    i1[4] = 'x';
    if (i2[-1] != 'x')
       ++failures;
    i1[4] = 'e';

    i1[2] = 'x';
    if (i2[-3] != 'x')
       ++failures;
    i1[2] = 'c';

    std::string::const_iterator ci1(s.begin());
    if (*ci1 != 'a')
       ++failures;

    ++ci1;
    if (*ci1 != 'b')
       ++failures;

    if (*ci1++ != 'b')
       ++failures;
    if (*ci1 != 'c')
       ++failures;

    ++ ++ci1;
    if (*ci1 != 'e')
       ++failures;

    --ci1;
    if (*ci1 != 'd')
       ++failures;

    if (*ci1-- != 'd')
       ++failures;
    if (*ci1 != 'c')
       ++failures;

    -- --ci1;
    if (*ci1 != 'a')
       ++failures;

    std::string::const_iterator ci2;
    ci2 = s.end();
    std::iterator_traits<std::string::const_iterator>::difference_type d2;
    d2 = ci2 - ci1;
    if (d2 != 5)
      ++failures;

    std::iterator_traits<std::string::const_iterator>::value_type v2;
    v2 = ci1[0];
    if (v2 != 'a')
      ++failures;

    std::iterator_traits<std::string::const_iterator>::reference r2(ci1[0]);
    if (r2 != 'a')
       ++failures;

    if ((ci1 != ci2) != true)
       ++failures;
    if ((ci1 == ci2) != false)
       ++failures;
    if ((ci1 <  ci2) != true)
       ++failures;
    if ((ci1 >  ci2) != false)
       ++failures;
    if ((ci1 <= ci2) != true)
       ++failures;
    if ((ci1 >= ci2) != false)
       ++failures;

    std::string::const_iterator ci3;
    ci3 = ci1;
    if ((ci3 == ci1) != true)
       ++failures;

    ci3 += 5;
    if ((ci3 == ci2) != true)
       ++failures;

    ci3 -= 5;
    if ((ci3 == ci1) != true)
       ++failures;

    if (ci3 + 5 != ci2)
       ++failures;

    if (5 + ci3 != ci2)
       ++failures;

    if (ci2 - 5 != ci3)
       ++failures;

    if (ci1[2] != 'c')
       ++failures;

    if (ci2[-1] != 'e')
       ++failures;

    // iterator and const_iterator
    std::string::const_iterator ci4(i1);
    if ((ci4 == i1) != true)
       ++failures;
    if ((ci4 != i1) != false)
       ++failures;
    if ((ci4 < i1)  != false)
      ++failures;
    if ((ci4 > i1)  != false)
      ++failures;
    if ((ci4 <= i1) != true)
      ++failures;
    if ((ci4 >= i1) != true)
      ++failures;
    ci4 = i2;
    if ((i2 == ci4) != true)
      ++failures;
    if ((i2 < ci4)  != false)
      ++failures;
    if ((i2 > ci4)  != false)
      ++failures;
    if ((i2 <= ci4) != true)
      ++failures;
    if ((i2 >= ci4) != true)
      ++failures;

    const std::string cs("ABCDE");
    std::string::const_iterator ci5(cs.begin());
    if (ci5[0] != 'A')
       ++failures;

    return failures;
 }

 int
 vector_stuff()
 {
    int failures(0);

    std::vector<int> v;
    v.push_back(int(1));
    v.push_back(int(2));
    v.push_back(int(3));
    v.push_back(int(4));
    v.push_back(int(5));

    std::vector<int>::iterator i1(v.begin());
    if (*i1 != 1)
       ++failures;

    ++i1;
    if (*i1 != 2)
       ++failures;

    if (*i1++ != 2)
       ++failures;
    if (*i1 != 3)
       ++failures;

    ++ ++i1;
    if (*i1 != 5)
       ++failures;

    --i1;
    if (*i1 != 4)
       ++failures;

    if (*i1-- != 4)
       ++failures;
    if (*i1 != 3)
       ++failures;

    -- --i1;
    if (*i1 != 1)
       ++failures;

    std::vector<int>::iterator i2;
    i2 = v.end();
    std::iterator_traits<std::vector<int>::iterator>::difference_type d1;
    d1 = i2 - i1;
    if (d1 != 5)
       ++failures;

    std::iterator_traits<std::vector<int>::iterator>::value_type v1;
    v1 = i1[0];
    if (v1 != 1)
       ++failures;

    std::iterator_traits<std::vector<int>::iterator>::reference r1(i1[0]);
    if (r1 != 1)
       ++failures;
    r1 = 9;
    if (r1 != 9)
       ++failures;
    r1 = 1;

    if ((i1 != i2) != true)
       ++failures;
    if ((i1 == i2) != false)
       ++failures;
    if ((i1 <  i2) != true)
       ++failures;
    if ((i1 >  i2) != false)
       ++failures;
    if ((i1 <= i2) != true)
       ++failures;
    if ((i1 >= i2) != false)
       ++failures;

    std::vector<int>::iterator i3;
    i3 = i1;
    if ((i3 == i1) != true)
       ++failures;

    i3 += 5;
    if ((i3 == i2) != true)
       ++failures;

    i3 -= 5;
    if ((i3 == i1) != true)
       ++failures;

    if (i3 + 5 != i2)
       ++failures;

    if (5 + i3 != i2)
       ++failures;

    if (i2 - 5 != i3)
       ++failures;

    if (i1[0] != 1)
       ++failures;

    i1[4] = 9;
    if (i2[-1] != 9)
       ++failures;
    i1[4] = 5;

    i1[2] = 9;
    if (i2[-3] != 9)
       ++failures;
    i1[2] = 3;

    std::vector<int>::const_iterator ci1(v.begin());
    if (*ci1 != 1)
       ++failures;

    ++ci1;
    if (*ci1 != 2)
       ++failures;

    if (*ci1++ != 2)
       ++failures;
    if (*ci1 != 3)
       ++failures;

    ++ ++ci1;
    if (*ci1 != 5)
       ++failures;

    --ci1;
    if (*ci1 != 4)
       ++failures;

    if (*ci1-- != 4)
       ++failures;
    if (*ci1 != 3)
       ++failures;

    -- --ci1;
    if (*ci1 != 1)
       ++failures;

    std::vector<int>::const_iterator ci2;
    ci2 = v.end();
    std::iterator_traits<std::vector<int>::const_iterator>::difference_type d2;
    d2 = ci2 - ci1;
    if (d2 != 5)
       ++failures;

    std::iterator_traits<std::vector<int>::const_iterator>::value_type v2;
    v2 = ci1[0];
    if (v2 != 1)
       ++failures;

    std::iterator_traits<std::vector<int>::const_iterator>::reference
       r2(ci1[0]);
    if (r2 != 1)
       ++failures;

    if ((ci1 != ci2) != true)
       ++failures;
    if ((ci1 == ci2) != false)
       ++failures;
    if ((ci1 <  ci2) != true)
       ++failures;
    if ((ci1 >  ci2) != false)
       ++failures;
    if ((ci1 <= ci2) != true)
       ++failures;
    if ((ci1 >= ci2) != false)
       ++failures;

    std::vector<int>::const_iterator ci3;
    ci3 = ci1;
    if ((ci3 == ci1) != true)
       ++failures;

    ci3 += 5;
    if ((ci3 == ci2) != true)
       ++failures;

    ci3 -= 5;
    if ((ci3 == ci1) != true)
       ++failures;

    if (ci3 + 5 != ci2)
       ++failures;

    if (5 + ci3 != ci2)
       ++failures;

    if (ci2 - 5 != ci3)
       ++failures;

    if (ci1[2] != 3)
       ++failures;

    if (ci2[-1] != 5)
       ++failures;

    // iterator to const_iterator
    std::vector<int>::const_iterator ci4(i1);
    if ((ci4 == i1) != true)
       ++failures;
    if ((ci4 != i1) != false)
       ++failures;
    if ((ci4 < i1)  != false)
      ++failures;
    if ((ci4 > i1)  != false)
      ++failures;
    if ((ci4 <= i1) != true)
      ++failures;
    if ((ci4 >= i1) != true)
      ++failures;
    ci4 = i2;
    if ((i2 == ci4) != true)
      ++failures;
    if ((i2 < ci4)  != false)
      ++failures;
    if ((i2 > ci4)  != false)
      ++failures;
    if ((i2 <= ci4) != true)
      ++failures;
    if ((i2 >= ci4) != true)
      ++failures;

    const std::vector<int> cv(v);
    std::vector<int>::const_iterator ci5(cv.begin());
    if (ci5[0] != 1)
       ++failures;

    std::vector<std::string> vs;
    vs.push_back(std::string("abc"));
    std::vector<std::string>::iterator ivs(vs.begin());
    if (ivs->c_str()[1] != 'b')
       ++failures;

    return failures;
 }

 int
 reverse_stuff()
 {
    int failures(0);

    std::string s("abcde");

    std::string::reverse_iterator ri(s.rbegin());
    if (*ri != 'e')
       ++failures;

    std::iterator_traits<std::string::reverse_iterator>::difference_type d;
    d = s.rend() - ri;
    if (d != 5)
       ++failures;

    const std::string cs("abcde");
    std::string::const_reverse_iterator cri(cs.rend());
    if (cri - 5 != cs.rbegin())
       ++failures;

    return failures;
 }

 // the following should be compiler errors
 // flag runtime errors in case they slip through the compiler
 int
 wrong_stuff()
 {
    int failures(0);

 #ifdef ITER24_F1
    extern void f(std::vector<std::string*>::iterator);
    std::vector<std::string*> vs[2];
    f(vs);                       // address of array is not an iterator
    failures++;
 #endif

 #ifdef ITER24_F2
    std::string s;
    char *i = s.begin();         // begin() doesn't return a pointer
    failures++;
 #endif

 #ifdef ITER24_F3
    std::string::const_iterator ci;
    std::string::iterator i;
    if (i - ci)                  // remove const_ is a warning
       i++;
    // failures++;  only a warning
 #endif

 #ifdef ITER24_F4
    std::vector<char>::iterator iv;
    std::string::iterator is(iv);// vector<char> is not string
    failures++;
 #endif

 #ifdef ITER24_F5
    std::vector<char>::iterator iv;
    std::string::iterator is;
    if (iv == is)                // vector<char> is not string
       ++iv;
    failures++;
 #endif

 #ifdef ITER24_F6
    std::vector<char>::const_iterator ci;
    std::vector<char>::iterator i = ci;  // remove const_ is a warning
    ++i;
    // failures++; only a warning
 #endif

 #ifdef ITER24_F7
    std::vector<int> v(1);
    std::vector<int>::const_iterator ci(v.begin());
    *ci = 1;                     // cannot assign through const_iterator
    failures++;
 #endif

 #ifdef ITER24_F8
    std::vector<const int> v(1);
    std::vector<const int>::reference r(v.begin()[0]);
    r = 1;                       // cannot assign through reference to const
    failures++;
 #endif

    return failures;
 }

 // libstdc++/6642
 int
 test6642()
 {
    std::string s;
    std::string::iterator it = s.begin();
    std::string::const_iterator cit = s.begin();

    return it - cit;
 }

 int
 main()
 {
    int failures(0);

    failures += string_stuff();

    failures += vector_stuff();

    failures += reverse_stuff();

    failures += wrong_stuff();

    failures += test6642();

    VERIFY(failures == 0);
    return 0;
 }
	// 24.1.5 Random access iterators
	// 24.3.1 Iterator traits
	// (basic_string and vector implementations)
	//
	// Copyright (C) 1999, 2003, 2004, 2005 Free Software Foundation, Inc.
	// This program 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 of the License, or
	// (at your option) any later version.
	//
	// This program 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 program; if not, write to the Free Software
	// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
	// USA


	#include <string>
	#include <vector>
	#include <testsuite_hooks.h>

	int
	string_stuff()
	{
	int failures(0);

	std::string s("abcde");

	std::string::iterator i1(s.begin());
	if (*i1 != 'a')
	++failures;

	++i1;
	if (*i1 != 'b')
	++failures;

	if (*i1++ != 'b')
	++failures;
	if (*i1 != 'c')
	++failures;

	++ ++i1;
	if (*i1 != 'e')
	++failures;

	--i1;
	if (*i1 != 'd')
	++failures;

	if (*i1-- != 'd')
	++failures;
	if (*i1 != 'c')
	++failures;

	-- --i1;
	if (*i1 != 'a')
	++failures;

	std::string::iterator i2;
	i2 = s.end();
	std::iterator_traits<std::string::iterator>::difference_type d1;
	d1 = i2 - i1;
	if (d1 != 5)
	++failures;

	std::iterator_traits<std::string::iterator>::value_type v1;
	v1 = i1[0];
	if (v1 != 'a')
	++failures;

	std::iterator_traits<std::string::iterator>::reference r1(i1[0]);
	if (r1 != 'a')
	++failures;
	r1 = 'x';
	if (r1 != 'x')
	++failures;
	r1 = 'a';

	if ((i1 != i2) != true)
	++failures;
	if ((i1 == i2) != false)
	++failures;
	if ((i1 < i2) != true)
	++failures;
	if ((i1 > i2) != false)
	++failures;
	if ((i1 <= i2) != true)
	++failures;
	if ((i1 >= i2) != false)
	++failures;

	std::string::iterator i3;
	i3 = i1;
	if ((i3 == i1) != true)
	++failures;

	i3 += 5;
	if ((i3 == i2) != true)
	++failures;

	i3 -= 5;
	if ((i3 == i1) != true)
	++failures;

	if (i3 + 5 != i2)
	++failures;

	if (5 + i3 != i2)
	++failures;

	if (i2 - 5 != i3)
	++failures;

	if (i1[0] != 'a')
	++failures;

	i1[4] = 'x';
	if (i2[-1] != 'x')
	++failures;
	i1[4] = 'e';

	i1[2] = 'x';
	if (i2[-3] != 'x')
	++failures;
	i1[2] = 'c';

	std::string::const_iterator ci1(s.begin());
	if (*ci1 != 'a')
	++failures;

	++ci1;
	if (*ci1 != 'b')
	++failures;

	if (*ci1++ != 'b')
	++failures;
	if (*ci1 != 'c')
	++failures;

	++ ++ci1;
	if (*ci1 != 'e')
	++failures;

	--ci1;
	if (*ci1 != 'd')
	++failures;

	if (*ci1-- != 'd')
	++failures;
	if (*ci1 != 'c')
	++failures;

	-- --ci1;
	if (*ci1 != 'a')
	++failures;

	std::string::const_iterator ci2;
	ci2 = s.end();
	std::iterator_traits<std::string::const_iterator>::difference_type d2;
	d2 = ci2 - ci1;
	if (d2 != 5)
	++failures;

	std::iterator_traits<std::string::const_iterator>::value_type v2;
	v2 = ci1[0];
	if (v2 != 'a')
	++failures;

	std::iterator_traits<std::string::const_iterator>::reference r2(ci1[0]);
	if (r2 != 'a')
	++failures;

	if ((ci1 != ci2) != true)
	++failures;
	if ((ci1 == ci2) != false)
	++failures;
	if ((ci1 < ci2) != true)
	++failures;
	if ((ci1 > ci2) != false)
	++failures;
	if ((ci1 <= ci2) != true)
	++failures;
	if ((ci1 >= ci2) != false)
	++failures;

	std::string::const_iterator ci3;
	ci3 = ci1;
	if ((ci3 == ci1) != true)
	++failures;

	ci3 += 5;
	if ((ci3 == ci2) != true)
	++failures;

	ci3 -= 5;
	if ((ci3 == ci1) != true)
	++failures;

	if (ci3 + 5 != ci2)
	++failures;

	if (5 + ci3 != ci2)
	++failures;

	if (ci2 - 5 != ci3)
	++failures;

	if (ci1[2] != 'c')
	++failures;

	if (ci2[-1] != 'e')
	++failures;

	// iterator and const_iterator
	std::string::const_iterator ci4(i1);
	if ((ci4 == i1) != true)
	++failures;
	if ((ci4 != i1) != false)
	++failures;
	if ((ci4 < i1) != false)
	++failures;
	if ((ci4 > i1) != false)
	++failures;
	if ((ci4 <= i1) != true)
	++failures;
	if ((ci4 >= i1) != true)
	++failures;
	ci4 = i2;
	if ((i2 == ci4) != true)
	++failures;
	if ((i2 < ci4) != false)
	++failures;
	if ((i2 > ci4) != false)
	++failures;
	if ((i2 <= ci4) != true)
	++failures;
	if ((i2 >= ci4) != true)
	++failures;

	const std::string cs("ABCDE");
	std::string::const_iterator ci5(cs.begin());
	if (ci5[0] != 'A')
	++failures;

	return failures;
	}

	int
	vector_stuff()
	{
	int failures(0);

	std::vector<int> v;
	v.push_back(int(1));
	v.push_back(int(2));
	v.push_back(int(3));
	v.push_back(int(4));
	v.push_back(int(5));

	std::vector<int>::iterator i1(v.begin());
	if (*i1 != 1)
	++failures;

	++i1;
	if (*i1 != 2)
	++failures;

	if (*i1++ != 2)
	++failures;
	if (*i1 != 3)
	++failures;

	++ ++i1;
	if (*i1 != 5)
	++failures;

	--i1;
	if (*i1 != 4)
	++failures;

	if (*i1-- != 4)
	++failures;
	if (*i1 != 3)
	++failures;

	-- --i1;
	if (*i1 != 1)
	++failures;

	std::vector<int>::iterator i2;
	i2 = v.end();
	std::iterator_traits<std::vector<int>::iterator>::difference_type d1;
	d1 = i2 - i1;
	if (d1 != 5)
	++failures;

	std::iterator_traits<std::vector<int>::iterator>::value_type v1;
	v1 = i1[0];
	if (v1 != 1)
	++failures;

	std::iterator_traits<std::vector<int>::iterator>::reference r1(i1[0]);
	if (r1 != 1)
	++failures;
	r1 = 9;
	if (r1 != 9)
	++failures;
	r1 = 1;

	if ((i1 != i2) != true)
	++failures;
	if ((i1 == i2) != false)
	++failures;
	if ((i1 < i2) != true)
	++failures;
	if ((i1 > i2) != false)
	++failures;
	if ((i1 <= i2) != true)
	++failures;
	if ((i1 >= i2) != false)
	++failures;

	std::vector<int>::iterator i3;
	i3 = i1;
	if ((i3 == i1) != true)
	++failures;

	i3 += 5;
	if ((i3 == i2) != true)
	++failures;

	i3 -= 5;
	if ((i3 == i1) != true)
	++failures;

	if (i3 + 5 != i2)
	++failures;

	if (5 + i3 != i2)
	++failures;

	if (i2 - 5 != i3)
	++failures;

	if (i1[0] != 1)
	++failures;

	i1[4] = 9;
	if (i2[-1] != 9)
	++failures;
	i1[4] = 5;

	i1[2] = 9;
	if (i2[-3] != 9)
	++failures;
	i1[2] = 3;

	std::vector<int>::const_iterator ci1(v.begin());
	if (*ci1 != 1)
	++failures;

	++ci1;
	if (*ci1 != 2)
	++failures;

	if (*ci1++ != 2)
	++failures;
	if (*ci1 != 3)
	++failures;

	++ ++ci1;
	if (*ci1 != 5)
	++failures;

	--ci1;
	if (*ci1 != 4)
	++failures;

	if (*ci1-- != 4)
	++failures;
	if (*ci1 != 3)
	++failures;

	-- --ci1;
	if (*ci1 != 1)
	++failures;

	std::vector<int>::const_iterator ci2;
	ci2 = v.end();
	std::iterator_traits<std::vector<int>::const_iterator>::difference_type d2;
	d2 = ci2 - ci1;
	if (d2 != 5)
	++failures;

	std::iterator_traits<std::vector<int>::const_iterator>::value_type v2;
	v2 = ci1[0];
	if (v2 != 1)
	++failures;

	std::iterator_traits<std::vector<int>::const_iterator>::reference
	r2(ci1[0]);
	if (r2 != 1)
	++failures;

	if ((ci1 != ci2) != true)
	++failures;
	if ((ci1 == ci2) != false)
	++failures;
	if ((ci1 < ci2) != true)
	++failures;
	if ((ci1 > ci2) != false)
	++failures;
	if ((ci1 <= ci2) != true)
	++failures;
	if ((ci1 >= ci2) != false)
	++failures;

	std::vector<int>::const_iterator ci3;
	ci3 = ci1;
	if ((ci3 == ci1) != true)
	++failures;

	ci3 += 5;
	if ((ci3 == ci2) != true)
	++failures;

	ci3 -= 5;
	if ((ci3 == ci1) != true)
	++failures;

	if (ci3 + 5 != ci2)
	++failures;

	if (5 + ci3 != ci2)
	++failures;

	if (ci2 - 5 != ci3)
	++failures;

	if (ci1[2] != 3)
	++failures;

	if (ci2[-1] != 5)
	++failures;

	// iterator to const_iterator
	std::vector<int>::const_iterator ci4(i1);
	if ((ci4 == i1) != true)
	++failures;
	if ((ci4 != i1) != false)
	++failures;
	if ((ci4 < i1) != false)
	++failures;
	if ((ci4 > i1) != false)
	++failures;
	if ((ci4 <= i1) != true)
	++failures;
	if ((ci4 >= i1) != true)
	++failures;
	ci4 = i2;
	if ((i2 == ci4) != true)
	++failures;
	if ((i2 < ci4) != false)
	++failures;
	if ((i2 > ci4) != false)
	++failures;
	if ((i2 <= ci4) != true)
	++failures;
	if ((i2 >= ci4) != true)
	++failures;

	const std::vector<int> cv(v);
	std::vector<int>::const_iterator ci5(cv.begin());
	if (ci5[0] != 1)
	++failures;

	std::vector<std::string> vs;
	vs.push_back(std::string("abc"));
	std::vector<std::string>::iterator ivs(vs.begin());
	if (ivs->c_str()[1] != 'b')
	++failures;

	return failures;
	}

	int
	reverse_stuff()
	{
	int failures(0);

	std::string s("abcde");

	std::string::reverse_iterator ri(s.rbegin());
	if (*ri != 'e')
	++failures;

	std::iterator_traits<std::string::reverse_iterator>::difference_type d;
	d = s.rend() - ri;
	if (d != 5)
	++failures;

	const std::string cs("abcde");
	std::string::const_reverse_iterator cri(cs.rend());
	if (cri - 5 != cs.rbegin())
	++failures;

	return failures;
	}

	// the following should be compiler errors
	// flag runtime errors in case they slip through the compiler
	int
	wrong_stuff()
	{
	int failures(0);

	#ifdef ITER24_F1
	extern void f(std::vector<std::string*>::iterator);
	std::vector<std::string*> vs[2];
	f(vs); // address of array is not an iterator
	failures++;
	#endif

	#ifdef ITER24_F2
	std::string s;
	char *i = s.begin(); // begin() doesn't return a pointer
	failures++;
	#endif

	#ifdef ITER24_F3
	std::string::const_iterator ci;
	std::string::iterator i;
	if (i - ci) // remove const_ is a warning
	i++;
	// failures++; only a warning
	#endif

	#ifdef ITER24_F4
	std::vector<char>::iterator iv;
	std::string::iterator is(iv);// vector<char> is not string
	failures++;
	#endif

	#ifdef ITER24_F5
	std::vector<char>::iterator iv;
	std::string::iterator is;
	if (iv == is) // vector<char> is not string
	++iv;
	failures++;
	#endif

	#ifdef ITER24_F6
	std::vector<char>::const_iterator ci;
	std::vector<char>::iterator i = ci; // remove const_ is a warning
	++i;
	// failures++; only a warning
	#endif

	#ifdef ITER24_F7
	std::vector<int> v(1);
	std::vector<int>::const_iterator ci(v.begin());
	*ci = 1; // cannot assign through const_iterator
	failures++;
	#endif

	#ifdef ITER24_F8
	std::vector<const int> v(1);
	std::vector<const int>::reference r(v.begin()[0]);
	r = 1; // cannot assign through reference to const
	failures++;
	#endif

	return failures;
	}

	// libstdc++/6642
	int
	test6642()
	{
	std::string s;
	std::string::iterator it = s.begin();
	std::string::const_iterator cit = s.begin();

	return it - cit;
	}

	int
	main()
	{
	int failures(0);

	failures += string_stuff();

	failures += vector_stuff();

	failures += reverse_stuff();

	failures += wrong_stuff();

	failures += test6642();

	VERIFY(failures == 0);
	return 0;
	}