text
stringlengths 0
2.2M
|
|---|
bsl::reverse_iterator<const int *> XCREIt1 = bsl::crend ( X1);
|
bsl::reverse_iterator<const int *> mXCRBIt2 = bsl::crbegin(mX2);
|
bsl::reverse_iterator<const int *> XCRBIt2 = bsl::crbegin( X2);
|
bsl::reverse_iterator<const int *> mXCREIt2 = bsl::crend (mX2);
|
bsl::reverse_iterator<const int *> XCREIt2 = bsl::crend ( X2);
|
bsl::reverse_iterator<const int *> mXCRBIt3 = bsl::crbegin(mX3);
|
bsl::reverse_iterator<const int *> XCRBIt3 = bsl::crbegin( X3);
|
bsl::reverse_iterator<const int *> mXCREIt3 = bsl::crend (mX3);
|
bsl::reverse_iterator<const int *> XCREIt3 = bsl::crend ( X3);
|
bsl::reverse_iterator<const int *> mXCRBIt4 = bsl::crbegin(mX4);
|
bsl::reverse_iterator<const int *> XCRBIt4 = bsl::crbegin( X4);
|
bsl::reverse_iterator<const int *> mXCREIt4 = bsl::crend (mX4);
|
bsl::reverse_iterator<const int *> XCREIt4 = bsl::crend ( X4);
|
bsl::reverse_iterator<const int *> mXCRBIt5 = bsl::crbegin(mX5);
|
bsl::reverse_iterator<const int *> XCRBIt5 = bsl::crbegin( X5);
|
bsl::reverse_iterator<const int *> mXCREIt5 = bsl::crend (mX5);
|
bsl::reverse_iterator<const int *> XCREIt5 = bsl::crend ( X5);
|
// Moving iterators to the first element.
|
--mXCREIt1;
|
--XCREIt1;
|
--mXCREIt2;
|
--XCREIt2;
|
--mXCREIt3;
|
--XCREIt3;
|
--mXCREIt4;
|
--XCREIt4;
|
--mXCREIt5;
|
--XCREIt5;
|
ASSERTV(mX1[0], *mXCRBIt1, mX1[0] == *mXCRBIt1);
|
ASSERTV( X1[0], *XCRBIt1, X1[0] == *XCRBIt1);
|
ASSERTV(mX1[0], *mXCREIt1, mX1[0] == *mXCREIt1);
|
ASSERTV( X1[0], *XCREIt1, X1[0] == *XCREIt1);
|
ASSERTV(mX2[1], *mXCRBIt2, mX2[1] == *mXCRBIt2);
|
ASSERTV( X2[1], *XCRBIt2, X2[1] == *XCRBIt2);
|
ASSERTV(mX2[0], *mXCREIt2, mX2[0] == *mXCREIt2);
|
ASSERTV( X2[0], *XCREIt2, X2[0] == *XCREIt2);
|
ASSERTV(mX3[2], *mXCRBIt3, mX3[2] == *mXCRBIt3);
|
ASSERTV( X3[2], *XCRBIt3, X3[2] == *XCRBIt3);
|
ASSERTV(mX3[0], *mXCREIt3, mX3[0] == *mXCREIt3);
|
ASSERTV( X3[0], *XCREIt3, X3[0] == *XCREIt3);
|
ASSERTV(mX4[3], *mXCRBIt4, mX4[3] == *mXCRBIt4);
|
ASSERTV( X4[3], *XCRBIt4, X4[3] == *XCRBIt4);
|
ASSERTV(mX4[0], *mXCREIt4, mX4[0] == *mXCREIt4);
|
ASSERTV( X4[0], *XCREIt4, X4[0] == *XCREIt4);
|
ASSERTV(mX5[4], *mXCRBIt5, mX5[4] == *mXCRBIt5);
|
ASSERTV( X5[4], *XCRBIt5, X5[4] == *XCRBIt5);
|
ASSERTV(mX5[0], *mXCREIt5, mX5[0] == *mXCREIt5);
|
ASSERTV( X5[0], *XCREIt5, X5[0] == *XCREIt5);
|
}
|
#if defined(BSLS_COMPILERFEATURES_SUPPORT_GENERALIZED_INITIALIZERS)
|
if (verbose) printf("\tTest initializer lists.\n");
|
{
|
typedef bsl::reverse_iterator<const int *> reverse_iterator;
|
std::initializer_list<int> mX1 = {1};
|
std::initializer_list<int> mX2 = {1, 2};
|
std::initializer_list<int> mX3 = {1, 2, 3};
|
std::initializer_list<int> mX4 = {1, 2, 3, 4};
|
std::initializer_list<int> mX5 = {1, 2, 3, 4, 5};
|
// Testing 'rbegin' and 'rend'.
|
reverse_iterator mXRBIt1 = bsl::rbegin(mX1);
|
reverse_iterator mXREIt1 = bsl::rend (mX1);
|
reverse_iterator mXRBIt2 = bsl::rbegin(mX2);
|
reverse_iterator mXREIt2 = bsl::rend (mX2);
|
reverse_iterator mXRBIt3 = bsl::rbegin(mX3);
|
reverse_iterator mXREIt3 = bsl::rend (mX3);
|
reverse_iterator mXRBIt4 = bsl::rbegin(mX4);
|
reverse_iterator mXREIt4 = bsl::rend (mX4);
|
reverse_iterator mXRBIt5 = bsl::rbegin(mX5);
|
reverse_iterator mXREIt5 = bsl::rend (mX5);
|
ASSERTV(reverse_iterator(mX1.end() ) == mXRBIt1);
|
ASSERTV(reverse_iterator(mX1.begin()) == mXREIt1);
|
ASSERTV(reverse_iterator(mX2.end() ) == mXRBIt2);
|
ASSERTV(reverse_iterator(mX2.begin()) == mXREIt2);
|
ASSERTV(reverse_iterator(mX3.end() ) == mXRBIt3);
|
ASSERTV(reverse_iterator(mX3.begin()) == mXREIt3);
|
ASSERTV(reverse_iterator(mX4.end() ) == mXRBIt4);
|
ASSERTV(reverse_iterator(mX4.begin()) == mXREIt4);
|
ASSERTV(reverse_iterator(mX5.end() ) == mXRBIt5);
|
ASSERTV(reverse_iterator(mX5.begin()) == mXREIt5);
|
ASSERT(mXREIt5 - mXRBIt5 == bsl::ssize(mX5));
|
}
|
#else
|
if (verbose) printf("\tInitializer lists are not supported.\n");
|
#endif // BSLS_COMPILERFEATURES_SUPPORT_GENERALIZED_INITIALIZERS
|
} break;
|
case 13: {
|
// --------------------------------------------------------------------
|
// TESTING FREE FUNCTIONS
|
//
|
// Concerns:
|
//: 1 'operator<' returns the lexicographic comparison on two objects.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.