286 iterator_type1& begin, iterator_type2& end)
288 printf(
"**** test_iterator_arithmetic:\n");
296 iterator_type1 citer1 = begin;
297 iterator_type1 citer2 = begin;
315 REQUIRE( *citer2 == begin[0] );
320 REQUIRE( *citer2 == *(begin+1) );
321 REQUIRE( *citer2 == begin[1] );
326 REQUIRE( *citer2 == *(begin+2) );
327 REQUIRE( *citer2 == begin[2] );
332 REQUIRE( *citer2 == *(begin+3) );
333 REQUIRE( *citer2 == begin[3] );
340 REQUIRE( *citer2 == *(begin+0) );
341 REQUIRE( *citer2 == begin[0] );
359 iterator_type1 citer1 = begin;
360 iterator_type1 citer2 = begin;
362 REQUIRE( citer1 == citer1 );
363 REQUIRE( citer2 == citer1 );
366 REQUIRE( citer2 != citer1 );
367 REQUIRE( citer1 != citer2 );
368 REQUIRE( citer2 > citer1 );
369 REQUIRE( citer2 >= citer1 );
370 REQUIRE( citer1 < citer2 );
371 REQUIRE( citer1 <= citer2 );
372 REQUIRE( ( citer2 - citer1 ) == 1);
373 REQUIRE( ( citer1 - citer2 ) == -1);
458 typedef typename T::size_type size_type;
459 typedef typename T::const_iterator citer_type;
460 typedef typename T::iterator iter_type;
461 typedef typename T::difference_type diff_type;
462 typedef typename T::value_type value_type;
463 typedef typename T::storage_t storage_t;
465 printf(
"**** test_mutable_iterator_ops(CoW): %s\n", type_id.c_str());
469 iter_type begin = data.begin();
470 iter_type end = begin.end();
471 diff_type data_size =
static_cast<diff_type
>(data.size());
472 diff_type begin_size =
static_cast<diff_type
>(begin.size());
473 diff_type end_size =
static_cast<diff_type
>(end.size());
474 REQUIRE( begin_size == data_size );
475 REQUIRE( end_size == data_size );
476 REQUIRE( end - begin == data_size );
477 REQUIRE( end - end_size == begin );
478 REQUIRE( begin + begin_size == end );
479 REQUIRE( *( end - end_size ) == *begin );
480 REQUIRE( *( begin + begin_size - 1 ) == *( end - 1 ) );
481 REQUIRE( end[-end_size] == begin[0] );
482 REQUIRE( begin[begin_size - 1] == end[-1] );
491 iter_type begin = data.begin();
492 iter_type end = begin.end();
493 citer_type cbegin = begin.immutable();
494 citer_type cend = cbegin.cend();
519 citer_type citer0 = data.cbegin();
521 T data_exp = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
522 REQUIRE(data == data_exp);
524 REQUIRE( *data.snapshot() == citer0.storage() );
526 iter_type iter = data.begin();
527 size_type size_pre = iter.size();
528 value_type elem = iter.end()[-2];
530 REQUIRE( iter != citer0 );
531 REQUIRE( iter.storage() == citer0.storage() );
532 REQUIRE( iter.storage() == *data.snapshot() );
534 REQUIRE( iter.dist_begin() == 0 );
535 REQUIRE( iter.dist_end() ==
static_cast<diff_type
>(size_pre));
541 REQUIRE( iter.size() == size_pre-1 );
542 REQUIRE( iter == iter.end() );
543 REQUIRE( iter == iter.begin()+size_pre-1 );
544 REQUIRE( iter.dist_begin() ==
static_cast<diff_type
>(size_pre)-1 );
545 REQUIRE( iter.dist_end() == 0 );
546 REQUIRE( iter[-1] == elem );
548 storage_t data_exp = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
549 REQUIRE(iter.storage() == data_exp);
551 REQUIRE(iter.storage() != citer0.storage());
552 REQUIRE(iter.storage() != *data.snapshot());
555 REQUIRE( iter == iter.end() );
556 size_pre = iter.size();
557 REQUIRE( iter.dist_begin() ==
static_cast<diff_type
>(size_pre));
558 REQUIRE( iter.dist_end() == 0);
563 iter.insert(data2.cbegin(), data2.cbegin()+data2.size());
565 REQUIRE( iter.size() == size_pre+10 );
566 REQUIRE( iter == iter.end()-10 );
567 REQUIRE( iter.dist_begin() ==
static_cast<diff_type
>(size_pre));
568 REQUIRE( iter.dist_end() == 10);
570 storage_t data_exp = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
571 REQUIRE(iter.storage() == data_exp);
575 REQUIRE( iter == iter.end()-10 );
576 size_pre = iter.size();
580 REQUIRE( iter.size() == size_pre-10 );
581 REQUIRE( iter == iter.end() );
583 storage_t data_exp = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
584 REQUIRE(iter.storage() == data_exp);
588 size_pre = iter.size();
590 REQUIRE( iter == iter.begin() );
591 elem = iter.begin()[1];
593 REQUIRE( iter.size() == size_pre-1 );
594 REQUIRE( iter == iter.begin() );
595 REQUIRE( *iter == elem );
597 storage_t data_exp = { 2, 3, 4, 5, 6, 7, 8, 9 };
598 REQUIRE(iter.storage() == data_exp);
602 size_pre = iter.size();
603 REQUIRE( iter == iter.begin() );
604 elem = iter.end()[-1];
608 citer_type data2_iter = data2.cbegin();
609 iter.push_back(data2_iter[0]);
610 iter.push_back(data2_iter[1]);
611 iter.push_back(data2_iter[2]);
612 REQUIRE( iter.size() == size_pre+3 );
613 REQUIRE( iter == iter.end() );
614 REQUIRE( iter[-3] == data2_iter[0] );
615 REQUIRE( iter[-2] == data2_iter[1] );
616 REQUIRE( iter[-1] == data2_iter[2] );
619 storage_t data_exp = { 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3 };
620 REQUIRE(iter.storage() == data_exp);
624 size_pre = iter.size();
625 REQUIRE( iter == iter.end() );
628 REQUIRE( iter.size() == size_pre-3 );
629 REQUIRE( iter == iter.end() );
631 storage_t data_exp = { 2, 3, 4, 5, 6, 7, 8, 9 };
632 REQUIRE(iter.storage() == data_exp);
636 size_pre = iter.size();
637 REQUIRE( iter == iter.end() );
639 value_type elem0 = iter.begin()[0];
640 iter.push_back( std::move(elem0));
643 value_type elem0 = iter.begin()[1];
644 iter.push_back( std::move(elem0));
647 value_type elem0 = iter.begin()[2];
648 iter.push_back( std::move(elem0));
650 REQUIRE( iter.size() == size_pre+3 );
651 REQUIRE( iter == iter.end() );
652 REQUIRE( iter[-3] == iter.begin()[0] );
653 REQUIRE( iter[-2] == iter.begin()[1] );
654 REQUIRE( iter[-1] == iter.begin()[2] );
656 storage_t data_exp = { 2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4 };
657 REQUIRE(iter.storage() == data_exp);
661 REQUIRE( iter == iter.end() );
666 REQUIRE( iter == iter.end() );
668 storage_t data_exp = { 2, 3, 4, 5, 6, 7, 8, 9 };
669 REQUIRE(iter.storage() == data_exp);
675 REQUIRE( iter == iter.begin()+5 );
676 REQUIRE( iter.dist_begin() == 5 );
678 size_pre = iter.size();
682 citer_type data2_iter = data2.cbegin();
683 iter.insert(data2_iter[0]);
684 iter.insert(data2_iter[1]);
685 iter.insert(data2_iter[2]);
686 REQUIRE( iter.size() == size_pre+3 );
687 REQUIRE( iter == iter.begin()+5 );
689 REQUIRE( iter[5] == data2_iter[2] );
690 REQUIRE( iter[6] == data2_iter[1] );
691 REQUIRE( iter[7] == data2_iter[0] );
694 storage_t data_exp = { 2, 3, 4, 5, 6, 3, 2, 1, 7, 8, 9 };
695 REQUIRE(iter.storage() == data_exp);
700 REQUIRE( iter == iter.begin()+5 );
701 size_pre = iter.size();
705 iter.insert(data2.cbegin(), data2.cbegin()+3);
707 REQUIRE( iter.size() == size_pre+3 );
708 REQUIRE( iter == iter.begin()+5 );
710 storage_t data_exp = { 2, 3, 4, 5, 6, 1, 2, 3, 3, 2, 1, 7, 8, 9 };
711 REQUIRE(iter.storage() == data_exp);
715 REQUIRE( iter == iter.begin()+5 );
716 size_pre = iter.size();
718 REQUIRE( iter.size() == size_pre-6 );
719 REQUIRE( iter == iter.begin()+5 );
721 storage_t data_exp = { 2, 3, 4, 5, 6, 7, 8, 9 };
722 REQUIRE(iter.storage() == data_exp);
726 size_pre = iter.size();
727 REQUIRE( iter == iter.begin()+5 );
728 iter.emplace(
static_cast<uint64_t
>(2) );
729 iter.emplace(
static_cast<uint64_t
>(3) );
730 iter.emplace(
static_cast<uint64_t
>(4) );
731 REQUIRE( iter == iter.begin()+5 );
732 REQUIRE( iter[0] == 4 );
733 REQUIRE( iter[1] == 3 );
734 REQUIRE( iter[2] == 2 );
736 storage_t data_exp = { 2, 3, 4, 5, 6, 4, 3, 2, 7, 8, 9 };
737 REQUIRE(iter.storage() == data_exp);
741 size_pre = iter.size();
742 REQUIRE( iter == iter.begin()+5 );
743 iter.emplace_back(
static_cast<uint64_t
>(2) );
744 iter.emplace_back(
static_cast<uint64_t
>(3) );
745 iter.emplace_back(
static_cast<uint64_t
>(4) );
746 REQUIRE( iter == iter.end() );
747 REQUIRE( iter[-1] == 4 );
748 REQUIRE( iter[-2] == 3 );
749 REQUIRE( iter[-3] == 2 );
751 storage_t data_exp = { 2, 3, 4, 5, 6, 4, 3, 2, 7, 8, 9, 2, 3, 4 };
752 REQUIRE(iter.storage() == data_exp);
756 size_pre = iter.size();
757 REQUIRE( iter == iter.end() );
759 REQUIRE( iter == iter.end()-10 );
761 while( iter != iter.end() ) {
764 REQUIRE( iter.size() == size_pre - 10 );
767 storage_t data_exp = { 2, 3, 4, 5 };
768 REQUIRE(iter.storage() == data_exp);
773 REQUIRE( iter != data.cbegin() );
774 REQUIRE( iter.storage() != *data.snapshot() );
776 T data_exp = { 2, 3, 4, 5 };
777 REQUIRE(data != data_exp);
781 T data_exp = { 2, 3, 4, 5 };
782 REQUIRE(data == data_exp);
793 typedef typename T::iterator iter_type;
794 typedef typename T::const_iterator citer_type;
795 typedef typename T::difference_type diff_type;
797 printf(
"**** test_mutable_iterator_ops(___): %s\n", type_id.c_str());
801 iter_type begin = data.begin();
802 iter_type end = data.end();
803 diff_type data_size =
static_cast<diff_type
>(data.size());
804 REQUIRE( end - begin == data_size );
805 REQUIRE( end - data_size == begin );
806 REQUIRE( begin + data_size == end );
807 REQUIRE( *( end - data_size ) == *begin );
808 REQUIRE( *( begin + data_size - 1 ) == *(end -1) );
817 iter_type begin = data.begin();
818 iter_type end = data.end();
819 citer_type cend = data.cend();
820 citer_type cbegin = data.cbegin();
845 T data_exp = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
846 REQUIRE(data == data_exp);
849 iter_type iter = data.end();
850 typename T::size_type size_pre = data.size();
851 typename T::value_type elem = iter[-2];
858 REQUIRE( data.size() == size_pre-1 );
859 REQUIRE( iter == data.end() );
860 REQUIRE( iter == data.begin()+size_pre-1 );
861 REQUIRE( iter[-1] == elem );
863 T data_exp = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
864 REQUIRE(data == data_exp);
868 REQUIRE( iter == data.end() );
869 size_pre = data.size();
873 iter = data.insert(iter, data2.cbegin(), data2.cbegin()+data2.size());
875 REQUIRE( data.size() == size_pre+10 );
876 REQUIRE( iter == data.end()-10 );
878 T data_exp = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
879 REQUIRE(data == data_exp);
883 REQUIRE( iter == data.end()-10 );
884 size_pre = data.size();
886 iter = data.erase(iter, iter+10);
888 REQUIRE( data.size() == size_pre-10 );
889 REQUIRE( iter == data.end() );
891 T data_exp = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
892 REQUIRE(data == data_exp);
896 size_pre = data.size();
898 REQUIRE( iter == data.begin() );
900 iter = data.erase(iter);
901 REQUIRE( data.size() == size_pre-1 );
902 REQUIRE( iter == data.begin() );
903 REQUIRE( *iter == elem );
905 T data_exp = { 2, 3, 4, 5, 6, 7, 8, 9 };
906 REQUIRE(data == data_exp);
910 size_pre = data.size();
911 REQUIRE( iter == data.begin() );
912 elem = data.end()[-1];
916 data.push_back(data2[0]);
917 data.push_back(data2[1]);
918 data.push_back(data2[2]);
920 REQUIRE( data.size() == size_pre+3 );
921 REQUIRE( iter == data.end() );
922 REQUIRE( iter[-3] == data2[0] );
923 REQUIRE( iter[-2] == data2[1] );
924 REQUIRE( iter[-1] == data2[2] );
927 T data_exp = { 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3 };
928 REQUIRE(data == data_exp);
932 size_pre = data.size();
933 REQUIRE( iter == data.end() );
935 iter = data.erase(iter, iter+3);
936 REQUIRE( data.size() == size_pre-3 );
937 REQUIRE( iter == data.end() );
939 T data_exp = { 2, 3, 4, 5, 6, 7, 8, 9 };
940 REQUIRE(data == data_exp);
944 size_pre = data.size();
945 REQUIRE( iter == data.end() );
947 typename T::value_type elem0 = data.begin()[0];
948 data.push_back( std::move(elem0));
951 typename T::value_type elem0 = data.begin()[1];
952 data.push_back( std::move(elem0));
955 typename T::value_type elem0 = data.begin()[2];
956 data.push_back( std::move(elem0));
959 REQUIRE( data.size() == size_pre+3 );
960 REQUIRE( iter == data.end() );
961 REQUIRE( iter[-3] == data.begin()[0] );
962 REQUIRE( iter[-2] == data.begin()[1] );
963 REQUIRE( iter[-1] == data.begin()[2] );
965 T data_exp = { 2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4 };
966 REQUIRE(data == data_exp);
970 REQUIRE( iter == data.end() );
972 iter = data.erase(iter);
973 iter = data.erase(iter);
974 iter = data.erase(iter);
975 REQUIRE( iter == data.end() );
977 T data_exp = { 2, 3, 4, 5, 6, 7, 8, 9 };
978 REQUIRE(data == data_exp);
984 REQUIRE( iter == data.begin()+5 );
985 size_pre = data.size();
989 iter = data.insert(iter, data2[0]);
990 iter = data.insert(iter, data2[1]);
991 iter = data.insert(iter, data2[2]);
992 REQUIRE( data.size() == size_pre+3 );
993 REQUIRE( iter == data.begin()+5 );
995 REQUIRE( iter[5] == data2[2] );
996 REQUIRE( iter[6] == data2[1] );
997 REQUIRE( iter[7] == data2[0] );
1000 T data_exp = { 2, 3, 4, 5, 6, 3, 2, 1, 7, 8, 9 };
1001 REQUIRE(data == data_exp);
1006 REQUIRE( iter == data.begin()+5 );
1007 size_pre = data.size();
1011 iter = data.insert(iter, data2.cbegin(), data2.cbegin()+3);
1013 REQUIRE( data.size() == size_pre+3 );
1014 REQUIRE( iter == data.begin()+5 );
1016 T data_exp = { 2, 3, 4, 5, 6, 1, 2, 3, 3, 2, 1, 7, 8, 9 };
1017 REQUIRE(data == data_exp);
1021 REQUIRE( iter == data.begin()+5 );
1022 size_pre = data.size();
1023 iter = data.erase(iter, iter+6);
1024 REQUIRE( data.size() == size_pre-6 );
1025 REQUIRE( iter == data.begin()+5 );
1027 T data_exp = { 2, 3, 4, 5, 6, 7, 8, 9 };
1028 REQUIRE(data == data_exp);
1032 size_pre = data.size();
1033 REQUIRE( iter == data.begin()+5 );
1034 iter = data.emplace(iter,
static_cast<uint64_t
>(2) );
1035 iter = data.emplace(iter,
static_cast<uint64_t
>(3) );
1036 iter = data.emplace(iter,
static_cast<uint64_t
>(4) );
1038 REQUIRE( iter == data.begin()+5 );
1039 REQUIRE( iter[0] == 4 );
1040 REQUIRE( iter[1] == 3 );
1041 REQUIRE( iter[2] == 2 );
1043 T data_exp = { 2, 3, 4, 5, 6, 4, 3, 2, 7, 8, 9 };
1044 REQUIRE(data == data_exp);
1048 size_pre = data.size();
1049 REQUIRE( iter == data.begin()+5 );
1050 data.emplace_back(
static_cast<uint64_t
>(2) );
1051 data.emplace_back(
static_cast<uint64_t
>(3) );
1052 data.emplace_back(
static_cast<uint64_t
>(4) );
1054 REQUIRE( iter == data.end() );
1055 REQUIRE( iter[-1] == 4 );
1056 REQUIRE( iter[-2] == 3 );
1057 REQUIRE( iter[-3] == 2 );
1059 T data_exp = { 2, 3, 4, 5, 6, 4, 3, 2, 7, 8, 9, 2, 3, 4 };
1060 REQUIRE(data == data_exp);
1064 size_pre = data.size();
1065 REQUIRE( iter == data.end() );
1067 REQUIRE( iter == data.end()-10 );
1069 while( iter != data.end() ) {
1070 iter = data.erase(iter);
1072 REQUIRE( data.size() == size_pre - 10 );
1073 REQUIRE( iter == data.end() );
1076 T data_exp = { 2, 3, 4, 5 };
1077 REQUIRE(data == data_exp);
1088 REQUIRE(data == data2);
1089 REQUIRE(data == data3);
1109 typedef typename T::size_type size_type;
1110 typedef typename T::const_iterator citer_type;
1111 typedef typename T::iterator iter_type;
1113 printf(
"**** test_cow_iterator_properties: %s\n", type_id.c_str());
1117 const size_type size0 = 100;
1120 REQUIRE(0 == data.get_allocator().memory_usage);
1121 REQUIRE(data.size() == 0);
1122 REQUIRE(data.capacity() == 0);
1123 REQUIRE(data.empty() ==
true);
1126 REQUIRE(0 != data.get_allocator().memory_usage);
1127 REQUIRE(data.size() == size0);
1128 REQUIRE(data.size() <= data.capacity());
1133 iter_type iter1 = data.begin();
1134 citer_type citer2 = iter1.immutable();
1135 citer_type citer3 = iter1.immutable().to_end();
1137 REQUIRE( iter1.is_begin() );
1138 REQUIRE( citer2.is_begin() );
1139 REQUIRE( citer3.is_end() );
1141 REQUIRE( iter1.dist_begin() == 0);
1142 REQUIRE( iter1.dist_end() == size0);
1143 REQUIRE( citer2.dist_begin() == 0);
1144 REQUIRE( citer2.dist_end() == size0);
1145 REQUIRE( citer3.dist_begin() == size0);
1146 REQUIRE( citer3.dist_end() == 0);
1148 REQUIRE( ( iter1 == citer2 ) ==
true);
1149 REQUIRE( ( citer2 == iter1 ) ==
true);
1152 REQUIRE( ( citer2 != iter1 ) ==
true);
1153 REQUIRE( ( iter1 != citer2 ) ==
true);
1154 REQUIRE( ( citer2 > iter1 ) ==
true);
1155 REQUIRE( ( citer2 >= iter1 ) ==
true);
1156 REQUIRE( ( iter1 < citer2 ) ==
true);
1157 REQUIRE( ( iter1 <= citer2 ) ==
true);
1158 REQUIRE( ( citer2 - iter1 ) == 1);
1159 REQUIRE( ( iter1 - citer2 ) == -1);
1160 REQUIRE( citer2.dist_begin() == 1);
1161 REQUIRE( citer2.dist_end() == size0-1);
1165 REQUIRE( ( iter1 != citer2 ) ==
true);
1166 REQUIRE( ( citer2 != iter1 ) ==
true);
1167 REQUIRE( ( iter1 > citer2 ) ==
true);
1168 REQUIRE( ( iter1 >= citer2 ) ==
true);
1169 REQUIRE( ( citer2 < iter1 ) ==
true);
1170 REQUIRE( ( citer2 <= iter1 ) ==
true);
1171 REQUIRE( ( iter1 - citer2 ) == 1);
1172 REQUIRE( ( citer2 - iter1 ) == -1);
1173 REQUIRE( iter1.dist_begin() == 1);
1174 REQUIRE( iter1.dist_end() == size0-1);
1175 REQUIRE( citer2.dist_begin() == 0);
1176 REQUIRE( citer2.dist_end() == size0);
1178 REQUIRE( ( iter1.end() == citer3 ) ==
true);
1179 REQUIRE( ( iter1.to_end() == citer3 ) ==
true);
1180 REQUIRE( iter1.is_end() );
1181 REQUIRE( citer3.is_end() );
1182 REQUIRE( iter1.dist_begin() == size0);
1183 REQUIRE( iter1.dist_end() == 0);
1187 citer_type c_begin0 = data.cbegin();
1193 printf(
"testing mutable non-const behavior.\n");
1194 citer_type c_begin1;
1196 iter_type m_begin1 = data.begin();
1197 c_begin1 = m_begin1.immutable();
1199 REQUIRE(*c_begin1 == *m_begin1);
1200 REQUIRE( c_begin1 == m_begin1);
1201 REQUIRE( ( c_begin1 - m_begin1 ) == 0);
1202 printf(
" 1st store: %s == %s, dist %u\n",
1203 to_decstring(*c_begin1,
',', 2).c_str(),
to_decstring(*m_begin1,
',', 2).c_str(), (
unsigned int)(c_begin1 - m_begin1));
1204 citer_type c_begin2;
1206 iter_type m_begin2 = data.begin();
1207 c_begin2 = m_begin2.immutable();
1209 REQUIRE(*c_begin2 == *m_begin2);
1210 REQUIRE( c_begin2 == m_begin2);
1211 REQUIRE( ( c_begin2 - m_begin2 ) == 0);
1212 printf(
" 2nd store: %s == %s, dist %u\n",
1213 to_decstring(*c_begin2,
',', 2).c_str(),
to_decstring(*m_begin2,
',', 2).c_str(), (
unsigned int)(c_begin2 - m_begin2));
1215 REQUIRE(*c_begin2 == *c_begin1);
1216 REQUIRE( c_begin2 != c_begin1);
1217 REQUIRE( ( c_begin2 - c_begin1 ) != 0);
1218 printf(
"2nd -> 1st store: %s == %s, dist %u\n",
1219 to_decstring(*c_begin2,
',', 2).c_str(),
to_decstring(*c_begin1,
',', 2).c_str(), (
unsigned int)(c_begin2 - c_begin1));
1221 m_begin2.write_back();
1224 citer_type c_begin2b = data.cbegin();
1225 REQUIRE(*c_begin2 == *c_begin2b);
1226 REQUIRE( c_begin2 == c_begin2b);
1227 REQUIRE( ( c_begin2 - c_begin2b ) == 0);
1228 printf(
"2nd -> cow == cbegin: %s == %s, dist %u\n",
1229 to_decstring(*c_begin2,
',', 2).c_str(),
to_decstring(*c_begin2b,
',', 2).c_str(), (
unsigned int)(c_begin2 - c_begin2b));
1230 printf(
"2nd -> 1st : %s == %s, dist %u\n",
1231 to_decstring(*c_begin1,
',', 2).c_str(),
to_decstring(*c_begin2,
',', 2).c_str(), (
unsigned int)(c_begin1 - c_begin2));
1233 m_begin1.write_back();
1236 citer_type c_begin1b = data.cbegin();
1237 printf(
"1st -> cow == cbegin: %s == %s, dist %u\n",
1238 to_decstring(*c_begin1,
',', 2).c_str(),
to_decstring(*c_begin1b,
',', 2).c_str(), (
unsigned int)(c_begin1 - c_begin1b));
1239 REQUIRE(*c_begin1 == *c_begin1b);
1240 REQUIRE( c_begin1 == c_begin1b);
1241 REQUIRE( ( c_begin1 - c_begin1b ) == 0);