https://github.com/CGAL/cgal
Tip revision: 5220a1748908f06307974db093f33706159c2cac authored by Laurent Rineau on 21 October 2020, 07:27:10 UTC
Merge remote-tracking branch 'lrineau/Triangulation_2-improve_CDT_plus_2-GF' into releases/CGAL-5.0-branch
Merge remote-tracking branch 'lrineau/Triangulation_2-improve_CDT_plus_2-GF' into releases/CGAL-5.0-branch
Tip revision: 5220a17
test_circ1.cpp
// ============================================================================
//
// Copyright (c) 1997 The CGAL Consortium
//
// This software and related documentation is part of an INTERNAL release
// of the Computational Geometry Algorithms Library (CGAL). It is not
// intended for general use.
//
// ----------------------------------------------------------------------------
//
// release : $CGAL_Revision: $
// release_date : $CGAL_Date: $
//
// file : test_circ1.C
// chapter : $CGAL_Chapter: Circulators $
// package : $CGAL_Package: Circulator 3.4 (02 Sep 1999) $
// source : circulator.fw
// revision : $Id$
// revision_date : $Date$
// author(s) : Lutz Kettner <kettner@inf.ethz.ch>
//
// coordinator : INRIA, Sophia Antipolis
//
// Test circulator support and adaptor between circulator and iterator.
// ============================================================================
#include <cstddef>
#include <iterator>
#include <list>
#include <vector>
#include <cassert>
#include <CGAL/circulator.h>
// needed for test data structures
#include <CGAL/Circulator/Circulator_adapters.h>
using namespace CGAL;
// Global data structures.
std::list<int> L;
std::vector<int> V;
// int* C_array; // Gnu gcov produces a core here!
// Workaround
int* new_C_array() {
int* p = new int[5];
for ( int i = 1; i <= 5; i++) {
p[i-1] = i;
}
return p;
}
// Build a simple 'n'-element circular structure using struct's.
struct Node {
int key;
Node* next;
Node* prev;
Node() : key(0) { next = this; prev = this; }
Node( int n) : key(n) { next = this; prev = this; }
Node( Node* _nx, Node* _pv, int n)
: key(n), next(_nx), prev( _pv) {}
};
Node* new_node( Node* _nx, Node* _pv, int n) {
return new Node( _nx, _pv, n);
}
void append_node( Node* p, int n) {
Node* q = new_node( p, p->prev, n);
p->prev->next = q;
p->prev = q;
}
Node* generate_nodes( int n) {
assert( n > 0);
Node* p = new Node(1);
for ( int i = 2; i <= n; i++)
append_node( p, i);
return p;
}
void delete_nodes( Node* p) {
Node* end = p;
Node* q = p;
p = p->next;
while ( p != end) {
delete q;
q = p;
p = p->next;
}
delete q;
}
typedef CGAL::Forward_circulator_over_struct< Node>
Struct_circulator;
typedef CGAL::Forward_const_circulator_over_struct< Node>
Struct_const_circulator;
typedef CGAL::Bidirectional_circulator_over_struct< Node>
Struct_bi_circulator;
typedef CGAL::Bidirectional_const_circulator_over_struct< Node>
Struct_bi_const_circulator;
// Build a simple 'n'-element circular structure using struct's.
class CNode {
CNode* _next;
CNode* _prev;
public:
int key;
CNode* next() { return _next;}
const CNode* next() const { return _next;}
CNode* prev() { return _prev;}
const CNode* prev() const { return _prev;}
CNode() : key(0) { _next = this; _prev = this; }
CNode( int n) : key(n) { _next = this; _prev = this; }
CNode( CNode* _nx, CNode* _pv, int n)
: _next(_nx), _prev( _pv), key(n) {}
friend CNode* new_cnode( CNode* _nx, CNode* _pv, int n);
friend void append_cnode( CNode* p, int n);
friend void delete_cnodes( CNode* p);
};
CNode* new_cnode( CNode* _nx, CNode* _pv, int n) {
return new CNode( _nx, _pv, n);
}
void append_cnode( CNode* p, int n) {
CNode* q = new_cnode( p, p->_prev, n);
p->_prev->_next = q;
p->_prev = q;
}
CNode* generate_cnodes( int n) {
assert( n > 0);
CNode* p = new CNode(1);
for ( int i = 2; i <= n; i++)
append_cnode( p, i);
return p;
}
void delete_cnodes( CNode* p) {
CNode* end = p;
CNode* q = p;
p = p->_next;
while ( p != end) {
delete q;
q = p;
p = p->_next;
}
delete q;
}
typedef CGAL::Forward_circulator_over_class< CNode>
Class_circulator;
typedef CGAL::Forward_const_circulator_over_class< CNode>
Class_const_circulator;
typedef CGAL::Bidirectional_circulator_over_class< CNode>
Class_bi_circulator;
typedef CGAL::Bidirectional_const_circulator_over_class< CNode>
Class_bi_const_circulator;
void init_global_data() {
// C_array = new int[5];
for ( int i = 1; i <= 5; i++) {
L.push_back(i);
V.push_back(i);
// C_array[i-1] = i;
}
}
void clean_global_data() {
//delete[] C_array;
}
// Test value type and distance type.
int test_value_type( int*) { return 1;}
int test_value_type( Node*) { return 1;}
int test_value_type( CNode*) { return 1;}
int test_value_type( char*) { return 2;}
int test_value_type( double*) { return 3;}
int test_difference_type( std::ptrdiff_t*) { return 1;}
int test_difference_type( char*) { return 2;}
int test_difference_type( double*) { return 3;}
template< class T> inline
int foo3( T t, Forward_circulator_tag) {
Assert_circulator( t);
Assert_forward_category( t);
return 1;
}
template< class T> inline
int foo3( T t, Bidirectional_circulator_tag) {
Assert_circulator( t);
Assert_bidirectional_category( t);
return 2;
}
template< class T> inline
int foo3( T t, Random_access_circulator_tag) {
Assert_circulator( t);
Assert_random_access_category( t);
return 3;
}
template< class T> inline
int foo3( T /*t*/) { return -1; } // never used
template< class T> inline
int foo2( T t, Circulator_tag) {
Assert_circulator( t);
typedef std::iterator_traits<T> Traits;
typedef typename Traits::iterator_category iterator_category;
return foo3( t, iterator_category());
}
template< class T> inline
int foo2( T t, Iterator_tag) {
Assert_iterator( t);
return 4;
}
template< class T> inline
int foo2( T /*t*/) { return -1; } // never used
template< class T> inline
int foo( T t) {
typedef typename Circulator_traits<T>::category category;
return foo2( t, category());
}
int bar( std::size_t) { return 1;}
int bar( std::ptrdiff_t) { return 2;}
int bar( char) { return 3;}
int bar( double) { return 4;}
void test_tags() {
{
std::list<int> l;
assert( 4 == foo( l.begin()));
assert( 4 == foo( l.end()));
std::vector<int> v;
assert( 4 == foo( v.begin()));
assert( 4 == foo( v.end()));
int* p = NULL;
assert( 4 == foo( p));
{
typedef Forward_circulator_base<char,std::ptrdiff_t,std::size_t>
FC;
typedef Bidirectional_circulator_base<double,char,std::size_t>
BC;
typedef Random_access_circulator_base<std::size_t,char,std::size_t>
RC;
FC f_c = FC();
BC b_c = BC();
RC r_c = RC();
assert( 1 == foo( f_c));
assert( 2 == foo( b_c));
assert( 3 == foo( r_c));
assert( 3 == bar( std::iterator_traits<FC>::value_type()));
assert( 4 == bar( std::iterator_traits<BC>::value_type()));
assert( 1 == bar( std::iterator_traits<RC>::value_type()));
assert( 2 == bar( std::iterator_traits<FC>::
difference_type()));
assert( 3 == bar( std::iterator_traits<BC>::
difference_type()));
assert( 3 == bar( std::iterator_traits<RC>::
difference_type()));
}
{
typedef Forward_circulator_ptrbase<char,std::ptrdiff_t,std::size_t>
FC;
typedef Bidirectional_circulator_ptrbase<double,char,std::size_t>
BC;
typedef Random_access_circulator_ptrbase<std::size_t,char,
std::size_t> RC;
FC f_c = FC();
BC b_c = BC();
RC r_c = RC();
assert( 1 == foo( f_c));
assert( 2 == foo( b_c));
assert( 3 == foo( r_c));
assert( 3 == bar( std::iterator_traits<FC>::value_type()));
assert( 4 == bar( std::iterator_traits<BC>::value_type()));
assert( 1 == bar( std::iterator_traits<RC>::value_type()));
assert( 2 == bar( std::iterator_traits<FC>::
difference_type()));
assert( 3 == bar( std::iterator_traits<BC>::
difference_type()));
assert( 3 == bar( std::iterator_traits<RC>::
difference_type()));
}
// a bit more complicated cases.
typedef Random_access_circulator_from_iterator<
std::vector<int>::iterator,
int,
std::vector<int>::size_type,
std::vector<int>::difference_type
> Circulator;
typedef Random_access_container_from_circulator<Circulator> Container;
Circulator ci( v.begin(), v.end());
Container Co( ci);
assert( 3 == foo( ci));
assert( 4 == foo( Co.begin()));
assert( 4 == foo( Co.end()));
}
}
void test_functions_for_circulators() {
Node* data_struct = generate_nodes( 5);
Struct_circulator start1(data_struct);
Struct_const_circulator start2(data_struct);
Struct_bi_circulator start3(data_struct);
Struct_bi_const_circulator start4(data_struct);
assert( circulator_size(start1) == 5);
assert( circulator_size(start2) == 5);
assert( circulator_size(start3) == 5);
assert( circulator_size(start4) == 5);
Struct_circulator start1a(data_struct);
Struct_const_circulator start2a(data_struct);
Struct_bi_circulator start3a(data_struct);
Struct_bi_const_circulator start4a(data_struct);
assert( circulator_distance(start1, start1a) == 5);
assert( circulator_distance(start2, start2a) == 5);
assert( circulator_distance(start3, start3a) == 5);
assert( circulator_distance(start4, start4a) == 5);
assert( iterator_distance(start1, start1a) == 5);
assert( iterator_distance(start2, start2a) == 5);
assert( iterator_distance(start3, start3a) == 5);
assert( iterator_distance(start4, start4a) == 5);
++ start1a;
++ start2a;
++ start3a;
++ start4a;
assert( circulator_distance(start1, start1a) == 1);
assert( circulator_distance(start2, start2a) == 1);
assert( circulator_distance(start3, start3a) == 1);
assert( circulator_distance(start4, start4a) == 1);
assert( iterator_distance(start1, start1a) == 1);
assert( iterator_distance(start2, start2a) == 1);
assert( iterator_distance(start3, start3a) == 1);
assert( iterator_distance(start4, start4a) == 1);
++ start1a;
++ start2a;
++ start1a;
++ start2a;
++ start1a;
++ start2a;
-- start3a;
-- start4a;
-- start3a;
-- start4a;
assert( circulator_distance(start1, start1a) == 4);
assert( circulator_distance(start2, start2a) == 4);
assert( circulator_distance(start3, start3a) == 4);
assert( circulator_distance(start4, start4a) == 4);
assert( iterator_distance(start1, start1a) == 4);
assert( iterator_distance(start2, start2a) == 4);
assert( iterator_distance(start3, start3a) == 4);
assert( iterator_distance(start4, start4a) == 4);
delete_nodes(data_struct);
std::list<int> l;
assert( iterator_distance(l.begin(), l.end()) == 0);
l.push_back(3);
assert( iterator_distance(l.begin(), l.end()) == 1);
int* my_C_array = new_C_array();
assert( iterator_distance(my_C_array, my_C_array+5) == 5);
typedef Random_access_circulator_from_iterator<
int*, int, std::size_t, std::ptrdiff_t> Circulator1;
Circulator1 c1( my_C_array, my_C_array+5);
assert( circulator_size(c1) == 5);
Circulator1 c3 = c1;
++c3;
assert( c1 == c3.min_circulator());
--c3;
--c3;
assert( c1 == c3.min_circulator());
--c3;
assert( c1 == c3.min_circulator());
typedef Random_access_const_circulator_from_iterator<
int*, int, std::size_t, std::ptrdiff_t> Circulator2;
Circulator2 c2( my_C_array, my_C_array+5);
assert( circulator_size(c2) == 5);
c3 = c1;
Circulator2 c4(c2);
assert( circulator_distance(c1,c3) == 5);
assert( circulator_distance(c2,c4) == 5);
c3 ++;
c4 ++;
assert( circulator_distance(c1,c3) == 1);
assert( circulator_distance(c2,c4) == 1);
c3 --;
c4 --;
c3 --;
c4 --;
assert( circulator_distance(c1,c3) == 4);
assert( circulator_distance(c2,c4) == 4);
delete[] my_C_array;
assert( 2 == non_negative_mod( -4, 3));
assert( 0 == non_negative_mod( -3, 3));
assert( 1 == non_negative_mod( -2, 3));
assert( 2 == non_negative_mod( -1, 3));
assert( 0 == non_negative_mod( 0, 3));
assert( 1 == non_negative_mod( 1, 3));
assert( 2 == non_negative_mod( 2, 3));
assert( 0 == non_negative_mod( 3, 3));
assert( 1 == non_negative_mod( 4, 3));
}
void test_iterator_and_circulators() {
std::vector<int> v;
assert( is_empty_range( v.begin(), v.end()));
typedef Random_access_circulator_from_iterator<
std::vector<int>::iterator,
int,
std::vector<int>::size_type,
std::vector<int>::difference_type
> Circulator;
Circulator c( v.begin(), v.end());
assert( is_empty_range( c, c));
v.push_back( 5);
assert( is_empty_range( v.begin(), v.begin()));
assert( ! is_empty_range( v.begin(), v.end()));
Circulator d( v.begin(), v.end());
assert( ! is_empty_range( d, d));
std::vector<int>::iterator i = v.begin();
int j = 0;
{
assert( v.size() == 1);
CGAL_For_all( i, v.end()) {
assert( *i == 5);
j++;
}
assert( j == 1);
}{
CGAL_For_all( d, d) {
assert( *d == 5);
j++;
}
assert( j == 2);
}{
CGAL_For_all_backwards( d, d) {
assert( *d == 5);
j++;
}
assert( j == 3);
}
}
void test_container_from_circulator() {
Node* data_struct = generate_nodes( 5);
{
Struct_circulator start(data_struct);
typedef Forward_container_from_circulator<Struct_circulator>
Container;
Container X;
assert( X.begin() == X.end());
Container Y(X);
assert( Y.begin() == Y.end());
Container C( start);
typedef Container::iterator Iterator;
Iterator begin = C.begin();
Iterator end = C.end();
Assert_forward_category(begin);
Assert_forward_category(end);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Iterator z = Iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i).key == (*j).key);
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i).key == (*j).key + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Change three elements and check post-/pre-increment.
Iterator i = begin;
(*i++).key = 4;
assert( 4 == (*begin).key);
assert( 2 == (*i).key);
(*i++).key = 3;
assert( 3 == (*i).key);
(*++i).key = 7;
assert( 7 == (*i).key);
// Check the setting and reset these elements
// to their original values.
i = begin;
assert( 4 == (*i).key);
(*i).key = 1;
i++;
assert( 3 == (*i).key);
(*i++).key = 2;
assert( 3 == (*i).key);
i++;
assert( 7 == (*i).key);
(*i).key = 4;
// Check the resetting.
i = begin;
int k = 1;
do {
assert( k == (*i).key);
++i;
++k;
} while (i != end);
}
CGAL::Assert_iterator( begin);
CGAL::Assert_iterator( end);
begin++;
assert( (*(begin.current_circulator())).key == 2);
}
{
Struct_const_circulator start(data_struct);
typedef Forward_container_from_circulator<Struct_const_circulator>
Container;
const Container X;
assert( X.begin() == X.end());
const Container Y(X);
assert( Y.begin() == Y.end());
const Container C( start);
typedef Container::const_iterator Const_iterator;
Const_iterator begin = C.begin();
Const_iterator end = C.end();
Assert_forward_category(begin);
Assert_forward_category(end);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Const_iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Const_iterator z = Const_iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Const_iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Const_iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i).key == (*j).key);
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Const_iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i).key == (*j).key + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
CGAL::Assert_iterator( begin);
CGAL::Assert_iterator( end);
begin++;
assert( (*(begin.current_circulator())).key == 2);
}
{
Struct_bi_circulator start(data_struct);
typedef Bidirectional_container_from_circulator<
Struct_bi_circulator> Container;
Container X;
assert( X.begin() == X.end());
Container Y(X);
assert( Y.begin() == Y.end());
Container C( start);
typedef Container::iterator Iterator;
Iterator begin = C.begin();
Iterator end = C.end();
Assert_bidirectional_category(begin);
Assert_bidirectional_category(end);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Iterator z = Iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i).key == (*j).key);
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i).key == (*j).key + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Change three elements and check post-/pre-increment.
Iterator i = begin;
(*i++).key = 4;
assert( 4 == (*begin).key);
assert( 2 == (*i).key);
(*i++).key = 3;
assert( 3 == (*i).key);
(*++i).key = 7;
assert( 7 == (*i).key);
// Check the setting and reset these elements
// to their original values.
i = begin;
assert( 4 == (*i).key);
(*i).key = 1;
i++;
assert( 3 == (*i).key);
(*i++).key = 2;
assert( 3 == (*i).key);
i++;
assert( 7 == (*i).key);
(*i).key = 4;
// Check the resetting.
i = begin;
int k = 1;
do {
assert( k == (*i).key);
++i;
++k;
} while (i != end);
}
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Iterator z = Iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i).key == (*j).key);
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i).key == (*j).key + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(begin);
CGAL::Assert_is_at_least_bidirectional_category(end);
// Loop backwards and pre-decrement.
Iterator i = end;
int su = 0;
int k = 5;
do {
Iterator j = --i;
assert( i == j);
assert( (*i).key == (*j).key);
assert( k == (*i).key);
su += (*i).key;
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
// Assignment.
i = end;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Iterator j = i--;
assert( i != j);
if ( j != end) {
assert( (*i).key == (*j).key - 1);
}
assert( k == (*i).key);
su += (*i).key;
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
}
CGAL::Assert_iterator( begin);
CGAL::Assert_iterator( end);
begin++;
assert( (*(begin.current_circulator())).key == 2);
}
{
Struct_bi_const_circulator start(data_struct);
typedef Bidirectional_container_from_circulator<
Struct_bi_const_circulator> Container;
const Container X;
assert( X.begin() == X.end());
const Container Y(X);
assert( Y.begin() == Y.end());
const Container C( start);
typedef Container::const_iterator Const_iterator;
Const_iterator begin = C.begin();
Const_iterator end = C.end();
Assert_bidirectional_category(begin);
Assert_bidirectional_category(end);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Const_iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Const_iterator z = Const_iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Const_iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Const_iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i).key == (*j).key);
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Const_iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i).key == (*j).key + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(begin);
CGAL::Assert_is_at_least_bidirectional_category(end);
// Loop backwards and pre-decrement.
Const_iterator i = end;
int su = 0;
int k = 5;
do {
Const_iterator j = --i;
assert( i == j);
assert( (*i).key == (*j).key);
assert( k == (*i).key);
su += (*i).key;
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
// Assignment.
i = end;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Const_iterator j = i--;
assert( i != j);
if ( j != end) {
assert( (*i).key == (*j).key - 1);
}
assert( k == (*i).key);
su += (*i).key;
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
}
CGAL::Assert_iterator( begin);
CGAL::Assert_iterator( end);
begin++;
assert( (*(begin.current_circulator())).key == 2);
}
int* my_C_array = new_C_array();
{
typedef Random_access_circulator_from_iterator<
int*, int, std::size_t, std::ptrdiff_t> Circulator;
Circulator c( my_C_array, my_C_array+5);
typedef Random_access_container_from_circulator<Circulator>
Container;
Container X;
assert( X.begin() == X.end());
Container Y(X);
assert( Y.begin() == Y.end());
Container C( c);
typedef Container::iterator Iterator;
Iterator begin = C.begin();
Iterator end = C.end();
Assert_random_access_category(begin);
Assert_random_access_category(end);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Iterator z = Iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i) == (*j));
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i) == (*j) + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Change three elements and check post-/pre-increment.
Iterator i = begin;
(*i++) = 4;
assert( 4 == (*begin));
assert( 2 == (*i));
(*i++) = 3;
assert( 3 == (*i));
(*++i) = 7;
assert( 7 == (*i));
// Check the setting and reset these elements
// to their original values.
i = begin;
assert( 4 == (*i));
(*i) = 1;
i++;
assert( 3 == (*i));
(*i++) = 2;
assert( 3 == (*i));
i++;
assert( 7 == (*i));
(*i) = 4;
// Check the resetting.
i = begin;
int k = 1;
do {
assert( k == (*i));
++i;
++k;
} while (i != end);
}
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Iterator z = Iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i) == (*j));
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i) == (*j) + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(begin);
CGAL::Assert_is_at_least_bidirectional_category(end);
// Loop backwards and pre-decrement.
Iterator i = end;
int su = 0;
int k = 5;
do {
Iterator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
// Assignment.
i = end;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Iterator j = i--;
assert( i != j);
if ( j != end) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Iterator z = Iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i) == (*j));
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i) == (*j) + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(begin);
CGAL::Assert_is_at_least_bidirectional_category(end);
// Loop backwards and pre-decrement.
Iterator i = end;
int su = 0;
int k = 5;
do {
Iterator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
// Assignment.
i = end;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Iterator j = i--;
assert( i != j);
if ( j != end) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_random_access_category(begin);
CGAL::Assert_is_at_least_random_access_category(end);
// Random access.
int k;
for( k = 0; k < 5; k++) {
assert( 1+k == begin[k]);
}
int su = begin[0]
+ begin[1]
+ begin[2]
+ begin[3]
+ begin[4];
assert( su == 15);
// Jump around.
Iterator i = begin;
i += 3;
assert( 4 == (*i));
i -= 2;
assert( 2 == (*i));
i += 3;
assert( 5 == (*i));
i -= 4;
assert( 1 == (*i));
assert( i == begin);
Iterator j = i + 3;
assert( 4 == (*j));
Iterator jj = j - 2;
assert( 2 == (*jj));
jj = 4 + jj;
assert( jj == end);
Iterator ij = jj - 5;
assert( ij == begin);
// Difference test.
assert( jj - i == 5 || jj - i == 0);
assert( i + (j-i) == j);
assert( (j-i) + i == j);
}
{ // Open own scope to hide local variables.
Iterator i = begin;
i[2] = 18;
i[4] = 9;
i[3] = 12;
assert( i[2] == 18);
assert( i[4] == 9);
assert( i[3] == 12);
i[2] = 3;
i[3] = 4;
i[4] = 5;
// Check the resetting.
i = begin;
int k = 1;
do {
assert( k == (*i));
++i;
++k;
} while (i != end);
}
CGAL::Assert_iterator( begin);
CGAL::Assert_iterator( end);
{ // Open own scope to hide local variables.
assert( end - begin == 5);
assert( begin - end == -5);
// Relational operator.
Iterator i = begin;
++i;
Iterator j = i;
++j;
assert( begin < i);
assert( i < j);
assert( j < end);
assert( j > i);
assert( i <= j);
assert( j >= i);
assert( i <= i);
assert( i >= i);
assert( !( i >= j));
assert( !( j <= i));
assert( !( i > j));
assert( !( j < i));
assert( !( i > i));
assert( !( i < i));
}
begin++;
assert( (*(begin.current_circulator())) == 2);
}
{
typedef Random_access_const_circulator_from_iterator<
int*, int, std::size_t, std::ptrdiff_t> Circulator;
Circulator c( my_C_array, my_C_array+5);
typedef Random_access_container_from_circulator<Circulator>
Container;
const Container X;
assert( X.begin() == X.end());
const Container Y(X);
assert( Y.begin() == Y.end());
const Container C( c);
typedef Container::const_iterator Const_iterator;
Const_iterator begin = C.begin();
Const_iterator end = C.end();
Assert_random_access_category(begin);
Assert_random_access_category(end);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Const_iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Const_iterator z = Const_iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Const_iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Const_iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i) == (*j));
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Const_iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i) == (*j) + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(begin);
CGAL::Assert_is_at_least_bidirectional_category(end);
// Loop backwards and pre-decrement.
Const_iterator i = end;
int su = 0;
int k = 5;
do {
Const_iterator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
// Assignment.
i = end;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Const_iterator j = i--;
assert( i != j);
if ( j != end) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_random_access_category(begin);
CGAL::Assert_is_at_least_random_access_category(end);
// Random access.
int k;
for( k = 0; k < 5; k++) {
assert( 1+k == begin[k]);
}
int su = begin[0]
+ begin[1]
+ begin[2]
+ begin[3]
+ begin[4];
assert( su == 15);
// Jump around.
Const_iterator i = begin;
i += 3;
assert( 4 == (*i));
i -= 2;
assert( 2 == (*i));
i += 3;
assert( 5 == (*i));
i -= 4;
assert( 1 == (*i));
assert( i == begin);
Const_iterator j = i + 3;
assert( 4 == (*j));
Const_iterator jj = j - 2;
assert( 2 == (*jj));
jj = 4 + jj;
assert( jj == end);
Const_iterator ij = jj - 5;
assert( ij == begin);
// Difference test.
assert( jj - i == 5 || jj - i == 0);
assert( i + (j-i) == j);
assert( (j-i) + i == j);
}
CGAL::Assert_iterator( begin);
CGAL::Assert_iterator( end);
{ // Open own scope to hide local variables.
assert( end - begin == 5);
assert( begin - end == -5);
// Relational operator.
Const_iterator i = begin;
++i;
Const_iterator j = i;
++j;
assert( begin < i);
assert( i < j);
assert( j < end);
assert( j > i);
assert( i <= j);
assert( j >= i);
assert( i <= i);
assert( i >= i);
assert( !( i >= j));
assert( !( j <= i));
assert( !( i > j));
assert( !( j < i));
assert( !( i > i));
assert( !( i < i));
}
begin++;
assert( (*(begin.current_circulator())) == 2);
}
{
Struct_bi_circulator start(data_struct);
typedef Container_from_circulator< Struct_bi_circulator> Container;
Container X;
assert( X.begin() == X.end());
Container Y(X);
assert( Y.begin() == Y.end());
Container C( start);
typedef Container::iterator Iterator;
Iterator begin = C.begin();
Iterator end = C.end();
Assert_bidirectional_category(begin);
Assert_bidirectional_category(end);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Iterator z = Iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i).key == (*j).key);
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i).key == (*j).key + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Change three elements and check post-/pre-increment.
Iterator i = begin;
(*i++).key = 4;
assert( 4 == (*begin).key);
assert( 2 == (*i).key);
(*i++).key = 3;
assert( 3 == (*i).key);
(*++i).key = 7;
assert( 7 == (*i).key);
// Check the setting and reset these elements
// to their original values.
i = begin;
assert( 4 == (*i).key);
(*i).key = 1;
i++;
assert( 3 == (*i).key);
(*i++).key = 2;
assert( 3 == (*i).key);
i++;
assert( 7 == (*i).key);
(*i).key = 4;
// Check the resetting.
i = begin;
int k = 1;
do {
assert( k == (*i).key);
++i;
++k;
} while (i != end);
}
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Iterator z = Iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i).key == (*j).key);
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i).key == (*j).key + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(begin);
CGAL::Assert_is_at_least_bidirectional_category(end);
// Loop backwards and pre-decrement.
Iterator i = end;
int su = 0;
int k = 5;
do {
Iterator j = --i;
assert( i == j);
assert( (*i).key == (*j).key);
assert( k == (*i).key);
su += (*i).key;
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
// Assignment.
i = end;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Iterator j = i--;
assert( i != j);
if ( j != end) {
assert( (*i).key == (*j).key - 1);
}
assert( k == (*i).key);
su += (*i).key;
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
}
CGAL::Assert_iterator( begin);
CGAL::Assert_iterator( end);
begin++;
assert( (*(begin.current_circulator())).key == 2);
}
{
Struct_bi_const_circulator start(data_struct);
typedef Container_from_circulator<
Struct_bi_const_circulator> Container;
const Container X;
assert( X.begin() == X.end());
const Container Y(X);
assert( Y.begin() == Y.end());
const Container C( start);
typedef Container::const_iterator Const_iterator;
Const_iterator begin = C.begin();
Const_iterator end = C.end();
Assert_bidirectional_category(begin);
Assert_bidirectional_category(end);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Const_iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Const_iterator z = Const_iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Const_iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Const_iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i).key == (*j).key);
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i).key);
su += (*i).key;
++k;
Const_iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i).key == (*j).key + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(begin);
CGAL::Assert_is_at_least_bidirectional_category(end);
// Loop backwards and pre-decrement.
Const_iterator i = end;
int su = 0;
int k = 5;
do {
Const_iterator j = --i;
assert( i == j);
assert( (*i).key == (*j).key);
assert( k == (*i).key);
su += (*i).key;
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
// Assignment.
i = end;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Const_iterator j = i--;
assert( i != j);
if ( j != end) {
assert( (*i).key == (*j).key - 1);
}
assert( k == (*i).key);
su += (*i).key;
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
}
CGAL::Assert_iterator( begin);
CGAL::Assert_iterator( end);
begin++;
assert( (*(begin.current_circulator())).key == 2);
}
{
typedef Random_access_circulator_from_iterator<
int*, int, std::size_t, std::ptrdiff_t> Circulator;
Circulator c( my_C_array, my_C_array+5);
typedef Container_from_circulator<Circulator>
Container;
Container X;
assert( X.begin() == X.end());
Container Y(X);
assert( Y.begin() == Y.end());
Container C( c);
typedef Container::iterator Iterator;
Iterator begin = C.begin();
Iterator end = C.end();
Assert_random_access_category(begin);
Assert_random_access_category(end);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Iterator z = Iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i) == (*j));
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i) == (*j) + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Change three elements and check post-/pre-increment.
Iterator i = begin;
(*i++) = 4;
assert( 4 == (*begin));
assert( 2 == (*i));
(*i++) = 3;
assert( 3 == (*i));
(*++i) = 7;
assert( 7 == (*i));
// Check the setting and reset these elements
// to their original values.
i = begin;
assert( 4 == (*i));
(*i) = 1;
i++;
assert( 3 == (*i));
(*i++) = 2;
assert( 3 == (*i));
i++;
assert( 7 == (*i));
(*i) = 4;
// Check the resetting.
i = begin;
int k = 1;
do {
assert( k == (*i));
++i;
++k;
} while (i != end);
}
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Iterator z = Iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i) == (*j));
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i) == (*j) + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(begin);
CGAL::Assert_is_at_least_bidirectional_category(end);
// Loop backwards and pre-decrement.
Iterator i = end;
int su = 0;
int k = 5;
do {
Iterator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
// Assignment.
i = end;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Iterator j = i--;
assert( i != j);
if ( j != end) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(begin);
CGAL::Assert_circulator_or_iterator(end);
CGAL::Assert_is_at_least_forward_category(begin);
CGAL::Assert_is_at_least_forward_category(end);
typedef std::iterator_traits<Iterator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Iterator z = Iterator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Iterator i = begin;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, end));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Iterator j = ++i;
assert( i == j);
if ( i != end) {
assert( (*i) == (*j));
}
} while (i != end); // Inequality and equality checked.
}
assert( i == end); // Equality checked.
assert( su == 15);
// Assignment.
i = begin;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, end)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Iterator j = i++;
assert( i != j);
if ( i != end) {
assert( (*i) == (*j) + 1);
}
} while (i != end);
}
assert( i == end);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(begin);
CGAL::Assert_is_at_least_bidirectional_category(end);
// Loop backwards and pre-decrement.
Iterator i = end;
int su = 0;
int k = 5;
do {
Iterator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
// Assignment.
i = end;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Iterator j = i--;
assert( i != j);
if ( j != end) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != begin);
assert( i == begin);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_random_access_category(begin);
CGAL::Assert_is_at_least_random_access_category(end);
// Random access.
int k;
for( k = 0; k < 5; k++) {
assert( 1+k == begin[k]);
}
int su = begin[0]
+ begin[1]
+ begin[2]
+ begin[3]
+ begin[4];
assert( su == 15);
// Jump around.
Iterator i = begin;
i += 3;
assert( 4 == (*i));
i -= 2;
assert( 2 == (*i));
i += 3;
assert( 5 == (*i));
i -= 4;
assert( 1 == (*i));
assert( i == begin);
Iterator j = i + 3;
assert( 4 == (*j));
Iterator jj = j - 2;
assert( 2 == (*jj));
jj = 4 + jj;
assert( jj == end);
Iterator ij = jj - 5;
assert( ij == begin);
// Difference test.
assert( jj - i == 5 || jj - i == 0);
assert( i + (j-i) == j);
assert( (j-i) + i == j);
}
{ // Open own scope to hide local variables.
Iterator i = begin;
i[2] = 18;
i[4] = 9;
i[3] = 12;
assert( i[2] == 18);
assert( i[4] == 9);
assert( i[3] == 12);
i[2] = 3;
i[3] = 4;
i[4] = 5;
// Check the resetting.
i = begin;
int k = 1;
do {
assert( k == (*i));
++i;
++k;
} while (i != end);
}
CGAL::Assert_iterator( begin);
CGAL::Assert_iterator( end);
{ // Open own scope to hide local variables.
assert( end - begin == 5);
assert( begin - end == -5);
// Relational operator.
Iterator i = begin;
++i;
Iterator j = i;
++j;
assert( begin < i);
assert( i < j);
assert( j < end);
assert( j > i);
assert( i <= j);
assert( j >= i);
assert( i <= i);
assert( i >= i);
assert( !( i >= j));
assert( !( j <= i));
assert( !( i > j));
assert( !( j < i));
assert( !( i > i));
assert( !( i < i));
}
begin++;
assert( (*(begin.current_circulator())) == 2);
}
delete_nodes(data_struct);
delete[] my_C_array;
}
#include <algorithm>
void test_circulator_from_iterator() {
int* my_C_array = new_C_array();
{
typedef Forward_circulator_from_iterator<
int*, int, std::size_t, std::ptrdiff_t> Circulator;
Circulator c( my_C_array, my_C_array+5);
Assert_forward_category(c);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Change three elements and check post-/pre-increment.
Circulator i = c;
(*i++) = 4;
assert( 4 == (*c));
assert( 2 == (*i));
(*i++) = 3;
assert( 3 == (*i));
(*++i) = 7;
assert( 7 == (*i));
// Check the setting and reset these elements
// to their original values.
i = c;
assert( 4 == (*i));
(*i) = 1;
i++;
assert( 3 == (*i));
(*i++) = 2;
assert( 3 == (*i));
i++;
assert( 7 == (*i));
(*i) = 4;
// Check the resetting.
i = c;
int k = 1;
do {
assert( k == (*i));
++i;
++k;
} while (i != c);
}
{ // Open own scope to hide local variables.
CGAL::Assert_circulator( c);
CGAL::Assert_circulator( c);
// Check the local type parameters.
Circulator::value_type k1;
k1 = 1;
Circulator::reference k2 = k1;
(void)k2;
assert( k2 == 1);
Circulator::pointer p1 = &k1;
(void)p1;
assert( (*p1) == 1);
k1 = 3;
assert( k1 == 3);
assert( k2 == 3);
assert( (*p1) == 3);
k1 = 6;
assert( k1 == 6);
assert( k2 == 6);
assert( (*p1) == 6);
Circulator::size_type s = 5;
assert( s == 5);
Circulator::difference_type d = -5;
assert( d == -5);
// Check tests for empty data structures.
Circulator z = Circulator();
assert( z == NULL);
assert( ! (z != NULL));
Circulator i = c;
assert( ! (i == NULL));
assert( i != NULL);
assert( i == c);
assert( i == c);
// Do I reach myself.
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
++i;
} while( i != j);
assert( k == 5);
}
c++;
assert( (*(c.current_iterator())) == 2);
}{
typedef Forward_const_circulator_from_iterator<
int*, int, std::size_t, std::ptrdiff_t> Circulator;
Circulator c( my_C_array, my_C_array+5);
Assert_forward_category(c);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_circulator( c);
CGAL::Assert_circulator( c);
// Check the local type parameters.
Circulator::value_type k1;
k1 = 1;
Circulator::reference k2 = k1;
(void)k2;
assert( k2 == 1);
Circulator::pointer p1 = &k1;
(void)p1;
assert( (*p1) == 1);
k1 = 3;
assert( k1 == 3);
assert( k2 == 3);
assert( (*p1) == 3);
k1 = 6;
assert( k1 == 6);
assert( k2 == 6);
assert( (*p1) == 6);
Circulator::size_type s = 5;
assert( s == 5);
Circulator::difference_type d = -5;
assert( d == -5);
// Check tests for empty data structures.
Circulator z = Circulator();
assert( z == NULL);
assert( ! (z != NULL));
Circulator i = c;
assert( ! (i == NULL));
assert( i != NULL);
assert( i == c);
assert( i == c);
// Do I reach myself.
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
++i;
} while( i != j);
assert( k == 5);
}
c++;
assert( (*(c.current_iterator())) == 2);
}{
typedef Bidirectional_circulator_from_iterator<
int*, int, std::size_t, std::ptrdiff_t> Circulator;
Circulator c( my_C_array, my_C_array+5);
Assert_bidirectional_category(c);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Change three elements and check post-/pre-increment.
Circulator i = c;
(*i++) = 4;
assert( 4 == (*c));
assert( 2 == (*i));
(*i++) = 3;
assert( 3 == (*i));
(*++i) = 7;
assert( 7 == (*i));
// Check the setting and reset these elements
// to their original values.
i = c;
assert( 4 == (*i));
(*i) = 1;
i++;
assert( 3 == (*i));
(*i++) = 2;
assert( 3 == (*i));
i++;
assert( 7 == (*i));
(*i) = 4;
// Check the resetting.
i = c;
int k = 1;
do {
assert( k == (*i));
++i;
++k;
} while (i != c);
}
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(c);
CGAL::Assert_is_at_least_bidirectional_category(c);
// Loop backwards and pre-decrement.
Circulator i = c;
int su = 0;
int k = 5;
do {
Circulator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Circulator j = i--;
assert( i != j);
if ( j != c) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_circulator( c);
CGAL::Assert_circulator( c);
// Check the local type parameters.
Circulator::value_type k1;
k1 = 1;
Circulator::reference k2 = k1;
(void)k2;
assert( k2 == 1);
Circulator::pointer p1 = &k1;
(void)p1;
assert( (*p1) == 1);
k1 = 3;
assert( k1 == 3);
assert( k2 == 3);
assert( (*p1) == 3);
k1 = 6;
assert( k1 == 6);
assert( k2 == 6);
assert( (*p1) == 6);
Circulator::size_type s = 5;
assert( s == 5);
Circulator::difference_type d = -5;
assert( d == -5);
// Check tests for empty data structures.
Circulator z = Circulator();
assert( z == NULL);
assert( ! (z != NULL));
Circulator i = c;
assert( ! (i == NULL));
assert( i != NULL);
assert( i == c);
assert( i == c);
// Do I reach myself.
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
++i;
} while( i != j);
assert( k == 5);
}
{ // Open own scope to hide local variables.
// Do I reach myself backwards.
Circulator i = c;
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
--i;
} while( i != j);
assert( k == 5);
}
c++;
assert( (*(c.current_iterator())) == 2);
}{
typedef Bidirectional_const_circulator_from_iterator<
int*, int, std::size_t, std::ptrdiff_t> Circulator;
Circulator c( my_C_array, my_C_array+5);
Assert_bidirectional_category(c);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(c);
CGAL::Assert_is_at_least_bidirectional_category(c);
// Loop backwards and pre-decrement.
Circulator i = c;
int su = 0;
int k = 5;
do {
Circulator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Circulator j = i--;
assert( i != j);
if ( j != c) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_circulator( c);
CGAL::Assert_circulator( c);
// Check the local type parameters.
Circulator::value_type k1;
k1 = 1;
Circulator::reference k2 = k1;
(void)k2;
assert( k2 == 1);
Circulator::pointer p1 = &k1;
(void)p1;
assert( (*p1) == 1);
k1 = 3;
assert( k1 == 3);
assert( k2 == 3);
assert( (*p1) == 3);
k1 = 6;
assert( k1 == 6);
assert( k2 == 6);
assert( (*p1) == 6);
Circulator::size_type s = 5;
assert( s == 5);
Circulator::difference_type d = -5;
assert( d == -5);
// Check tests for empty data structures.
Circulator z = Circulator();
assert( z == NULL);
assert( ! (z != NULL));
Circulator i = c;
assert( ! (i == NULL));
assert( i != NULL);
assert( i == c);
assert( i == c);
// Do I reach myself.
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
++i;
} while( i != j);
assert( k == 5);
}
{ // Open own scope to hide local variables.
// Do I reach myself backwards.
Circulator i = c;
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
--i;
} while( i != j);
assert( k == 5);
}
c++;
assert( (*(c.current_iterator())) == 2);
}{
typedef Random_access_circulator_from_iterator<
int*, int, std::size_t, std::ptrdiff_t> Circulator;
Circulator c( my_C_array, my_C_array+5);
Assert_random_access_category(c);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Change three elements and check post-/pre-increment.
Circulator i = c;
(*i++) = 4;
assert( 4 == (*c));
assert( 2 == (*i));
(*i++) = 3;
assert( 3 == (*i));
(*++i) = 7;
assert( 7 == (*i));
// Check the setting and reset these elements
// to their original values.
i = c;
assert( 4 == (*i));
(*i) = 1;
i++;
assert( 3 == (*i));
(*i++) = 2;
assert( 3 == (*i));
i++;
assert( 7 == (*i));
(*i) = 4;
// Check the resetting.
i = c;
int k = 1;
do {
assert( k == (*i));
++i;
++k;
} while (i != c);
}
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(c);
CGAL::Assert_is_at_least_bidirectional_category(c);
// Loop backwards and pre-decrement.
Circulator i = c;
int su = 0;
int k = 5;
do {
Circulator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Circulator j = i--;
assert( i != j);
if ( j != c) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(c);
CGAL::Assert_is_at_least_bidirectional_category(c);
// Loop backwards and pre-decrement.
Circulator i = c;
int su = 0;
int k = 5;
do {
Circulator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Circulator j = i--;
assert( i != j);
if ( j != c) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_random_access_category(c);
CGAL::Assert_is_at_least_random_access_category(c);
// Random access.
int k;
for( k = 0; k < 5; k++) {
assert( 1+k == c[k]);
}
int su = c[0]
+ c[1]
+ c[2]
+ c[3]
+ c[4];
assert( su == 15);
// Jump around.
Circulator i = c;
i += 3;
assert( 4 == (*i));
i -= 2;
assert( 2 == (*i));
i += 3;
assert( 5 == (*i));
i -= 4;
assert( 1 == (*i));
assert( i == c);
Circulator j = i + 3;
assert( 4 == (*j));
Circulator jj = j - 2;
assert( 2 == (*jj));
jj = 4 + jj;
assert( jj == c);
Circulator ij = jj - 5;
assert( ij == c);
// Difference test.
assert( jj - i == 5 || jj - i == 0);
assert( i + (j-i) == j);
assert( (j-i) + i == j);
}
{ // Open own scope to hide local variables.
Circulator i = c;
i[2] = 18;
i[4] = 9;
i[3] = 12;
assert( i[2] == 18);
assert( i[4] == 9);
assert( i[3] == 12);
i[2] = 3;
i[3] = 4;
i[4] = 5;
// Check the resetting.
i = c;
int k = 1;
do {
assert( k == (*i));
++i;
++k;
} while (i != c);
}
{ // Open own scope to hide local variables.
CGAL::Assert_circulator( c);
CGAL::Assert_circulator( c);
// Check the local type parameters.
Circulator::value_type k1;
k1 = 1;
Circulator::reference k2 = k1;
(void)k2;
assert( k2 == 1);
Circulator::pointer p1 = &k1;
(void)p1;
assert( (*p1) == 1);
k1 = 3;
assert( k1 == 3);
assert( k2 == 3);
assert( (*p1) == 3);
k1 = 6;
assert( k1 == 6);
assert( k2 == 6);
assert( (*p1) == 6);
Circulator::size_type s = 5;
assert( s == 5);
Circulator::difference_type d = -5;
assert( d == -5);
// Check tests for empty data structures.
Circulator z = Circulator();
assert( z == NULL);
assert( ! (z != NULL));
Circulator i = c;
assert( ! (i == NULL));
assert( i != NULL);
assert( i == c);
assert( i == c);
// Do I reach myself.
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
++i;
} while( i != j);
assert( k == 5);
}
{ // Open own scope to hide local variables.
// Do I reach myself backwards.
Circulator i = c;
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
--i;
} while( i != j);
assert( k == 5);
}
{ // Open own scope to hide local variables.
Circulator::difference_type d = c - c;
assert( d == 0);
d = c - c;
assert( d == 0);
Circulator i = c + 1;
assert( c - i == 1 || c - i == -1);
assert( i - c == 1 || i - c == -1);
// Check minimal circulator properties.
i = i.min_circulator();
Circulator j = i;
assert( j - i == 0);
j++;
assert( j - i == 1);
j++;
assert( j - i == 2);
j++;
assert( j - i == 3);
j++;
assert( j - i == 4);
j++;
assert( j - i == 0);
}
c++;
assert( (*(c.current_iterator())) == 2);
}{
typedef Random_access_const_circulator_from_iterator<
int*, int, std::size_t, std::ptrdiff_t> Circulator;
Circulator c( my_C_array, my_C_array+5);
Assert_random_access_category(c);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(c);
CGAL::Assert_is_at_least_bidirectional_category(c);
// Loop backwards and pre-decrement.
Circulator i = c;
int su = 0;
int k = 5;
do {
Circulator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Circulator j = i--;
assert( i != j);
if ( j != c) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_random_access_category(c);
CGAL::Assert_is_at_least_random_access_category(c);
// Random access.
int k;
for( k = 0; k < 5; k++) {
assert( 1+k == c[k]);
}
int su = c[0]
+ c[1]
+ c[2]
+ c[3]
+ c[4];
assert( su == 15);
// Jump around.
Circulator i = c;
i += 3;
assert( 4 == (*i));
i -= 2;
assert( 2 == (*i));
i += 3;
assert( 5 == (*i));
i -= 4;
assert( 1 == (*i));
assert( i == c);
Circulator j = i + 3;
assert( 4 == (*j));
Circulator jj = j - 2;
assert( 2 == (*jj));
jj = 4 + jj;
assert( jj == c);
Circulator ij = jj - 5;
assert( ij == c);
// Difference test.
assert( jj - i == 5 || jj - i == 0);
assert( i + (j-i) == j);
assert( (j-i) + i == j);
}
{ // Open own scope to hide local variables.
CGAL::Assert_circulator( c);
CGAL::Assert_circulator( c);
// Check the local type parameters.
Circulator::value_type k1;
k1 = 1;
Circulator::reference k2 = k1;
(void)k2;
assert( k2 == 1);
Circulator::pointer p1 = &k1;
(void)p1;
assert( (*p1) == 1);
k1 = 3;
assert( k1 == 3);
assert( k2 == 3);
assert( (*p1) == 3);
k1 = 6;
assert( k1 == 6);
assert( k2 == 6);
assert( (*p1) == 6);
Circulator::size_type s = 5;
assert( s == 5);
Circulator::difference_type d = -5;
assert( d == -5);
// Check tests for empty data structures.
Circulator z = Circulator();
assert( z == NULL);
assert( ! (z != NULL));
Circulator i = c;
assert( ! (i == NULL));
assert( i != NULL);
assert( i == c);
assert( i == c);
// Do I reach myself.
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
++i;
} while( i != j);
assert( k == 5);
}
{ // Open own scope to hide local variables.
// Do I reach myself backwards.
Circulator i = c;
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
--i;
} while( i != j);
assert( k == 5);
}
{ // Open own scope to hide local variables.
Circulator::difference_type d = c - c;
assert( d == 0);
d = c - c;
assert( d == 0);
Circulator i = c + 1;
assert( c - i == 1 || c - i == -1);
assert( i - c == 1 || i - c == -1);
// Check minimal circulator properties.
i = i.min_circulator();
Circulator j = i;
assert( j - i == 0);
j++;
assert( j - i == 1);
j++;
assert( j - i == 2);
j++;
assert( j - i == 3);
j++;
assert( j - i == 4);
j++;
assert( j - i == 0);
}
c++;
assert( (*(c.current_iterator())) == 2);
}
delete[] my_C_array;
{
// the example program `circulator_prog1.C'
typedef Random_access_circulator_from_iterator<
std::vector<int>::iterator,
std::vector<int>::value_type,
std::vector<int>::size_type,
std::vector<int>::difference_type
> Circulator;
typedef Random_access_container_from_circulator<Circulator>
Container;
std::vector<int> W;
W.push_back(5);
W.push_back(2);
W.push_back(9);
Circulator ci( W.begin(), W.end());
Container Co( ci);
std::sort( Co.begin(), Co.end());
assert( W.begin()[0] == 2);
assert( W.begin()[1] == 5);
assert( W.begin()[2] == 9);
}
}
#include <algorithm>
void test_circulator_from_container() {
{
typedef Forward_circulator_from_container< std::vector<int> >
Circulator;
Circulator c( &V);
Assert_forward_category(c);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Change three elements and check post-/pre-increment.
Circulator i = c;
(*i++) = 4;
assert( 4 == (*c));
assert( 2 == (*i));
(*i++) = 3;
assert( 3 == (*i));
(*++i) = 7;
assert( 7 == (*i));
// Check the setting and reset these elements
// to their original values.
i = c;
assert( 4 == (*i));
(*i) = 1;
i++;
assert( 3 == (*i));
(*i++) = 2;
assert( 3 == (*i));
i++;
assert( 7 == (*i));
(*i) = 4;
// Check the resetting.
i = c;
int k = 1;
do {
assert( k == (*i));
++i;
++k;
} while (i != c);
}
{ // Open own scope to hide local variables.
CGAL::Assert_circulator( c);
CGAL::Assert_circulator( c);
// Check the local type parameters.
Circulator::value_type k1;
k1 = 1;
Circulator::reference k2 = k1;
(void)k2;
assert( k2 == 1);
Circulator::pointer p1 = &k1;
(void)p1;
assert( (*p1) == 1);
k1 = 3;
assert( k1 == 3);
assert( k2 == 3);
assert( (*p1) == 3);
k1 = 6;
assert( k1 == 6);
assert( k2 == 6);
assert( (*p1) == 6);
Circulator::size_type s = 5;
assert( s == 5);
Circulator::difference_type d = -5;
assert( d == -5);
// Check tests for empty data structures.
Circulator z = Circulator();
assert( z == NULL);
assert( ! (z != NULL));
Circulator i = c;
assert( ! (i == NULL));
assert( i != NULL);
assert( i == c);
assert( i == c);
// Do I reach myself.
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
++i;
} while( i != j);
assert( k == 5);
}
c++;
assert( (*(c.current_iterator())) == 2);
}{
typedef Forward_const_circulator_from_container<std::vector<int> >
Circulator;
Circulator c( &V);
Assert_forward_category(c);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_circulator( c);
CGAL::Assert_circulator( c);
// Check the local type parameters.
Circulator::value_type k1;
k1 = 1;
Circulator::reference k2 = k1;
(void)k2;
assert( k2 == 1);
Circulator::pointer p1 = &k1;
(void)p1;
assert( (*p1) == 1);
k1 = 3;
assert( k1 == 3);
assert( k2 == 3);
assert( (*p1) == 3);
k1 = 6;
assert( k1 == 6);
assert( k2 == 6);
assert( (*p1) == 6);
Circulator::size_type s = 5;
assert( s == 5);
Circulator::difference_type d = -5;
assert( d == -5);
// Check tests for empty data structures.
Circulator z = Circulator();
assert( z == NULL);
assert( ! (z != NULL));
Circulator i = c;
assert( ! (i == NULL));
assert( i != NULL);
assert( i == c);
assert( i == c);
// Do I reach myself.
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
++i;
} while( i != j);
assert( k == 5);
}
c++;
assert( (*(c.current_iterator())) == 2);
}{
typedef Bidirectional_circulator_from_container< std::vector<int> >
Circulator;
Circulator c( &V);
Assert_bidirectional_category(c);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Change three elements and check post-/pre-increment.
Circulator i = c;
(*i++) = 4;
assert( 4 == (*c));
assert( 2 == (*i));
(*i++) = 3;
assert( 3 == (*i));
(*++i) = 7;
assert( 7 == (*i));
// Check the setting and reset these elements
// to their original values.
i = c;
assert( 4 == (*i));
(*i) = 1;
i++;
assert( 3 == (*i));
(*i++) = 2;
assert( 3 == (*i));
i++;
assert( 7 == (*i));
(*i) = 4;
// Check the resetting.
i = c;
int k = 1;
do {
assert( k == (*i));
++i;
++k;
} while (i != c);
}
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(c);
CGAL::Assert_is_at_least_bidirectional_category(c);
// Loop backwards and pre-decrement.
Circulator i = c;
int su = 0;
int k = 5;
do {
Circulator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Circulator j = i--;
assert( i != j);
if ( j != c) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_circulator( c);
CGAL::Assert_circulator( c);
// Check the local type parameters.
Circulator::value_type k1;
k1 = 1;
Circulator::reference k2 = k1;
(void)k2;
assert( k2 == 1);
Circulator::pointer p1 = &k1;
(void)p1;
assert( (*p1) == 1);
k1 = 3;
assert( k1 == 3);
assert( k2 == 3);
assert( (*p1) == 3);
k1 = 6;
assert( k1 == 6);
assert( k2 == 6);
assert( (*p1) == 6);
Circulator::size_type s = 5;
assert( s == 5);
Circulator::difference_type d = -5;
assert( d == -5);
// Check tests for empty data structures.
Circulator z = Circulator();
assert( z == NULL);
assert( ! (z != NULL));
Circulator i = c;
assert( ! (i == NULL));
assert( i != NULL);
assert( i == c);
assert( i == c);
// Do I reach myself.
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
++i;
} while( i != j);
assert( k == 5);
}
{ // Open own scope to hide local variables.
// Do I reach myself backwards.
Circulator i = c;
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
--i;
} while( i != j);
assert( k == 5);
}
c++;
assert( (*(c.current_iterator())) == 2);
}{
typedef
Bidirectional_const_circulator_from_container<std::vector<int> >
Circulator;
Circulator c( &V);
Assert_bidirectional_category(c);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(c);
CGAL::Assert_is_at_least_bidirectional_category(c);
// Loop backwards and pre-decrement.
Circulator i = c;
int su = 0;
int k = 5;
do {
Circulator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Circulator j = i--;
assert( i != j);
if ( j != c) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_circulator( c);
CGAL::Assert_circulator( c);
// Check the local type parameters.
Circulator::value_type k1;
k1 = 1;
Circulator::reference k2 = k1;
(void)k2;
assert( k2 == 1);
Circulator::pointer p1 = &k1;
(void)p1;
assert( (*p1) == 1);
k1 = 3;
assert( k1 == 3);
assert( k2 == 3);
assert( (*p1) == 3);
k1 = 6;
assert( k1 == 6);
assert( k2 == 6);
assert( (*p1) == 6);
Circulator::size_type s = 5;
assert( s == 5);
Circulator::difference_type d = -5;
assert( d == -5);
// Check tests for empty data structures.
Circulator z = Circulator();
assert( z == NULL);
assert( ! (z != NULL));
Circulator i = c;
assert( ! (i == NULL));
assert( i != NULL);
assert( i == c);
assert( i == c);
// Do I reach myself.
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
++i;
} while( i != j);
assert( k == 5);
}
{ // Open own scope to hide local variables.
// Do I reach myself backwards.
Circulator i = c;
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
--i;
} while( i != j);
assert( k == 5);
}
c++;
assert( (*(c.current_iterator())) == 2);
}{
typedef Random_access_circulator_from_container< std::vector<int> >
Circulator;
Circulator c( &V);
Assert_random_access_category(c);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Change three elements and check post-/pre-increment.
Circulator i = c;
(*i++) = 4;
assert( 4 == (*c));
assert( 2 == (*i));
(*i++) = 3;
assert( 3 == (*i));
(*++i) = 7;
assert( 7 == (*i));
// Check the setting and reset these elements
// to their original values.
i = c;
assert( 4 == (*i));
(*i) = 1;
i++;
assert( 3 == (*i));
(*i++) = 2;
assert( 3 == (*i));
i++;
assert( 7 == (*i));
(*i) = 4;
// Check the resetting.
i = c;
int k = 1;
do {
assert( k == (*i));
++i;
++k;
} while (i != c);
}
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(c);
CGAL::Assert_is_at_least_bidirectional_category(c);
// Loop backwards and pre-decrement.
Circulator i = c;
int su = 0;
int k = 5;
do {
Circulator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Circulator j = i--;
assert( i != j);
if ( j != c) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(c);
CGAL::Assert_is_at_least_bidirectional_category(c);
// Loop backwards and pre-decrement.
Circulator i = c;
int su = 0;
int k = 5;
do {
Circulator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Circulator j = i--;
assert( i != j);
if ( j != c) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_random_access_category(c);
CGAL::Assert_is_at_least_random_access_category(c);
// Random access.
int k;
for( k = 0; k < 5; k++) {
assert( 1+k == c[k]);
}
int su = c[0]
+ c[1]
+ c[2]
+ c[3]
+ c[4];
assert( su == 15);
// Jump around.
Circulator i = c;
i += 3;
assert( 4 == (*i));
i -= 2;
assert( 2 == (*i));
i += 3;
assert( 5 == (*i));
i -= 4;
assert( 1 == (*i));
assert( i == c);
Circulator j = i + 3;
assert( 4 == (*j));
Circulator jj = j - 2;
assert( 2 == (*jj));
jj = 4 + jj;
assert( jj == c);
Circulator ij = jj - 5;
assert( ij == c);
// Difference test.
assert( jj - i == 5 || jj - i == 0);
assert( i + (j-i) == j);
assert( (j-i) + i == j);
}
{ // Open own scope to hide local variables.
Circulator i = c;
i[2] = 18;
i[4] = 9;
i[3] = 12;
assert( i[2] == 18);
assert( i[4] == 9);
assert( i[3] == 12);
i[2] = 3;
i[3] = 4;
i[4] = 5;
// Check the resetting.
i = c;
int k = 1;
do {
assert( k == (*i));
++i;
++k;
} while (i != c);
}
{ // Open own scope to hide local variables.
CGAL::Assert_circulator( c);
CGAL::Assert_circulator( c);
// Check the local type parameters.
Circulator::value_type k1;
k1 = 1;
Circulator::reference k2 = k1;
(void)k2;
assert( k2 == 1);
Circulator::pointer p1 = &k1;
(void)p1;
assert( (*p1) == 1);
k1 = 3;
assert( k1 == 3);
assert( k2 == 3);
assert( (*p1) == 3);
k1 = 6;
assert( k1 == 6);
assert( k2 == 6);
assert( (*p1) == 6);
Circulator::size_type s = 5;
assert( s == 5);
Circulator::difference_type d = -5;
assert( d == -5);
// Check tests for empty data structures.
Circulator z = Circulator();
assert( z == NULL);
assert( ! (z != NULL));
Circulator i = c;
assert( ! (i == NULL));
assert( i != NULL);
assert( i == c);
assert( i == c);
// Do I reach myself.
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
++i;
} while( i != j);
assert( k == 5);
}
{ // Open own scope to hide local variables.
// Do I reach myself backwards.
Circulator i = c;
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
--i;
} while( i != j);
assert( k == 5);
}
{ // Open own scope to hide local variables.
Circulator::difference_type d = c - c;
assert( d == 0);
d = c - c;
assert( d == 0);
Circulator i = c + 1;
assert( c - i == 1 || c - i == -1);
assert( i - c == 1 || i - c == -1);
// Check minimal circulator properties.
i = i.min_circulator();
Circulator j = i;
assert( j - i == 0);
j++;
assert( j - i == 1);
j++;
assert( j - i == 2);
j++;
assert( j - i == 3);
j++;
assert( j - i == 4);
j++;
assert( j - i == 0);
}
c++;
assert( (*(c.current_iterator())) == 2);
}{
typedef
Random_access_const_circulator_from_container<std::vector<int> >
Circulator;
Circulator c( &V);
Assert_random_access_category(c);
{ // Open own scope to hide local variables.
// Check generally correct parameter properties.
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_circulator_or_iterator(c);
CGAL::Assert_is_at_least_forward_category(c);
CGAL::Assert_is_at_least_forward_category(c);
typedef std::iterator_traits<Circulator> I_Traits;
typedef I_Traits::value_type I_value_type;
typedef I_Traits::difference_type I_difference_type;
assert(1==test_value_type( (I_value_type*)(0)));
assert(1==test_difference_type( (I_difference_type*)(0)));
// Default constructor.
Circulator z = Circulator();
CGAL::Assert_circulator_or_iterator(z);
// Copy constructor.
Circulator i = c;
// Check general support for circulators and iterators.
assert( CGAL::is_empty_range( z, z));
assert( ! CGAL::is_empty_range( i, c));
int su = 0;
int k = 1;
// Check general loop, pre-increment, dereference.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = ++i;
assert( i == j);
if ( i != c) {
assert( (*i) == (*j));
}
} while (i != c); // Inequality and equality checked.
}
assert( i == c); // Equality checked.
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 1;
// Loop with post increment.
if (! CGAL::is_empty_range( i, c)) { // superfluous
do {
assert( k == (*i));
su += (*i);
++k;
Circulator j = i++;
assert( i != j);
if ( i != c) {
assert( (*i) == (*j) + 1);
}
} while (i != c);
}
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_bidirectional_category(c);
CGAL::Assert_is_at_least_bidirectional_category(c);
// Loop backwards and pre-decrement.
Circulator i = c;
int su = 0;
int k = 5;
do {
Circulator j = --i;
assert( i == j);
assert( (*i) == (*j));
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
// Assignment.
i = c;
su = 0;
k = 5;
// Loop with post-decrement.
do {
Circulator j = i--;
assert( i != j);
if ( j != c) {
assert( (*i) == (*j) - 1);
}
assert( k == (*i));
su += (*i);
--k;
} while (i != c);
assert( i == c);
assert( su == 15);
}
{ // Open own scope to hide local variables.
CGAL::Assert_is_at_least_random_access_category(c);
CGAL::Assert_is_at_least_random_access_category(c);
// Random access.
int k;
for( k = 0; k < 5; k++) {
assert( 1+k == c[k]);
}
int su = c[0]
+ c[1]
+ c[2]
+ c[3]
+ c[4];
assert( su == 15);
// Jump around.
Circulator i = c;
i += 3;
assert( 4 == (*i));
i -= 2;
assert( 2 == (*i));
i += 3;
assert( 5 == (*i));
i -= 4;
assert( 1 == (*i));
assert( i == c);
Circulator j = i + 3;
assert( 4 == (*j));
Circulator jj = j - 2;
assert( 2 == (*jj));
jj = 4 + jj;
assert( jj == c);
Circulator ij = jj - 5;
assert( ij == c);
// Difference test.
assert( jj - i == 5 || jj - i == 0);
assert( i + (j-i) == j);
assert( (j-i) + i == j);
}
{ // Open own scope to hide local variables.
CGAL::Assert_circulator( c);
CGAL::Assert_circulator( c);
// Check the local type parameters.
Circulator::value_type k1;
k1 = 1;
Circulator::reference k2 = k1;
(void)k2;
assert( k2 == 1);
Circulator::pointer p1 = &k1;
(void)p1;
assert( (*p1) == 1);
k1 = 3;
assert( k1 == 3);
assert( k2 == 3);
assert( (*p1) == 3);
k1 = 6;
assert( k1 == 6);
assert( k2 == 6);
assert( (*p1) == 6);
Circulator::size_type s = 5;
assert( s == 5);
Circulator::difference_type d = -5;
assert( d == -5);
// Check tests for empty data structures.
Circulator z = Circulator();
assert( z == NULL);
assert( ! (z != NULL));
Circulator i = c;
assert( ! (i == NULL));
assert( i != NULL);
assert( i == c);
assert( i == c);
// Do I reach myself.
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
++i;
} while( i != j);
assert( k == 5);
}
{ // Open own scope to hide local variables.
// Do I reach myself backwards.
Circulator i = c;
++i;
Circulator j = i;
int k = 0;
do {
assert( k < 5);
++k;
--i;
} while( i != j);
assert( k == 5);
}
{ // Open own scope to hide local variables.
Circulator::difference_type d = c - c;
assert( d == 0);
d = c - c;
assert( d == 0);
Circulator i = c + 1;
assert( c - i == 1 || c - i == -1);
assert( i - c == 1 || i - c == -1);
// Check minimal circulator properties.
i = i.min_circulator();
Circulator j = i;
assert( j - i == 0);
j++;
assert( j - i == 1);
j++;
assert( j - i == 2);
j++;
assert( j - i == 3);
j++;
assert( j - i == 4);
j++;
assert( j - i == 0);
}
c++;
assert( (*(c.current_iterator())) == 2);
}{
// the example program `circulator_prog2.C'.
typedef Random_access_circulator_from_container< std::vector<int> >
Circulator;
typedef Random_access_container_from_circulator<Circulator>
Container;
typedef Container::iterator Iterator;
std::vector<int> v;
v.push_back(5);
v.push_back(2);
v.push_back(9);
Circulator c( &v);
Container container( c);
std::sort( container.begin(), container.end());
Iterator i = container.begin();
assert( *i == 2);
i++;
assert( *i == 5);
i++;
assert( *i == 9);
i++;
assert( i == container.end());
}{
// An example program applying sort() through two adaptors.
typedef Random_access_circulator_from_container< std::vector<int> >
Circulator;
typedef Random_access_container_from_circulator<Circulator>
Container;
std::vector<int> v;
v.push_back(5);
v.push_back(2);
v.push_back(9);
Circulator c( &v);
Container container( c);
std::sort( container.begin(), container.end());
assert( v.begin()[0] == 2);
assert( v.begin()[1] == 5);
assert( v.begin()[2] == 9);
}
}
int main(){
init_global_data();
test_tags();
test_iterator_and_circulators();
test_functions_for_circulators();
test_container_from_circulator();
test_circulator_from_iterator();
test_circulator_from_container();
clean_global_data();
return 0;
}
// EOF //
