23.deque.special.cpp

Go to the documentation of this file.

 
#include <deque>        // for deque
 
#include <cstddef>      // for size_t
 
#include <rw_value.h>   // for UserClass
#include <rw_driver.h>  // for rw_test(), ...
 
 
struct DequeValueType { };
 
typedef std::allocator<DequeValueType>             DequeAllocator;
typedef std::deque<DequeValueType, DequeAllocator> DequeType;
 
 
int deque_swap_called;
 
_RWSTD_NAMESPACE (std) {
 
// define an explicit specialization of the deque::swap() member
// to verify tha the non-member swap function calls the member
 
_RWSTD_SPECIALIZED_FUNCTION
void DequeType::swap (DequeType&)
{
    ++deque_swap_called;
}
 
}   // namespace std
 
 
void test_std_swap ()
{
    rw_info (0, 0, 0, 
             "Testing std::swap (std::deque&, std::deque&) "
             "calls std::deque::swap");
 
    // verify the signature of the function specialization
    void (*pswap)(DequeType&, DequeType&) =
        &std::swap<DequeValueType, DequeAllocator>;
 
    _RWSTD_UNUSED (pswap);
 
    // verify that std::swap() calls std::deque::swap()
    DequeType d;
 
    std::swap (d, d);
 
    rw_assert (1 == deque_swap_called, 0, __LINE__,
               "std::swap (std::deque<T, A>&, std::deque<T, A>&) called "
               "std::deque<T, A>::swap (std::deque<T, A>&) exactly once; "
               "got %d times", deque_swap_called);
}
 
 
typedef std::deque<UserClass, std::allocator<UserClass> > Deque;
 
Deque::size_type new_capacity;
 
namespace __rw {
 
_RWSTD_SPECIALIZED_FUNCTION
inline Deque::size_type
__rw_new_capacity<Deque>(Deque::size_type n, const Deque*)
{
    if (n) {
        // non-zero size argument indicates a request for an increase
        // in the capacity of a deque object's dynamically sizable
        // vector of nodes
        return n * 2;
    }
 
    // zero size argument is a request for the initial size of a deque
    // object's dynamically sizable vector of nodes or for the size of
    // the objects's fixed-size buffer for elements
    return new_capacity;
}
 
}
 
 
template <class T, class Allocator>
void test_swap (const T *lhs_seq, std::size_t lhs_seq_len,
                const T *rhs_seq, std::size_t rhs_seq_len,
                std::deque<T, Allocator>*,
                const char *tname)
{
    typedef std::deque<T, Allocator>  Deque;
    typedef typename Deque::iterator  Iterator;
    typedef typename Deque::size_type SizeType;
 
    // create two containers from the provided sequences
    Deque lhs (lhs_seq, lhs_seq + lhs_seq_len);
    Deque rhs (rhs_seq, rhs_seq + rhs_seq_len);
 
    // save the begin and and iterators and the size
    // of each container before swapping the objects
    const Iterator lhs_begin_0 = lhs.begin ();
    const Iterator lhs_end_0   = lhs.end ();
    const SizeType lhs_size_0  = lhs.size ();
 
    const Iterator rhs_begin_0 = rhs.begin ();
    const Iterator rhs_end_0   = rhs.end ();
    const SizeType rhs_size_0  = rhs.size ();
 
    // swap the two containers
    lhs.swap (rhs);
 
    // compute the begin and and iterators and the size
    // of each container after swapping the objects
    const Iterator lhs_begin_1 = lhs.begin ();
    const Iterator lhs_end_1   = lhs.end ();
    const SizeType lhs_size_1  = lhs.size ();
 
    const Iterator rhs_begin_1 = rhs.begin ();
    const Iterator rhs_end_1   = rhs.end ();
    const SizeType rhs_size_1  = rhs.size ();
 
    static const int cwidth = sizeof (T);
 
    // verify that the iterators and sizes
    // of the two objects were swapped
    rw_assert (lhs_begin_0 == rhs_begin_1 && lhs_begin_1 == rhs_begin_0, 
               0, __LINE__,
               "begin() not swapped for \"%{X=*.*}\" and \"%{X=*.*}\"",
               cwidth, int (lhs_seq_len), -1, lhs_seq,
               cwidth, int (rhs_seq_len), -1, rhs_seq);
 
    rw_assert (lhs_end_0 == rhs_end_1 && lhs_end_1 == rhs_end_0, 
               0, __LINE__,
               "end() not swapped for \"%{X=*.*}\" and \"%{X=*.*}\"",
               cwidth, int (lhs_seq_len), -1, lhs_seq,
               cwidth, int (rhs_seq_len), -1, rhs_seq);
 
    rw_assert (lhs_size_0 == rhs_size_1 && lhs_size_1 == rhs_size_0, 
               0, __LINE__,
               "size() not swapped for \"%{X=*.*}\" and \"%{X=*.*}\"",
               cwidth, int (lhs_seq_len), -1, lhs_seq,
               cwidth, int (rhs_seq_len), -1, rhs_seq);
 
    // swap one of the containers with an empty unnamed temporary
    // container and verify that the object is empty
    { Deque ().swap (lhs); }
 
    const Iterator lhs_begin_2 = lhs.begin ();
    const Iterator lhs_end_2   = lhs.end ();
    const SizeType lhs_size_2  = lhs.size ();
 
    rw_assert (lhs_begin_2 == lhs_end_2, 0, __LINE__,
               "deque<%s>().begin() not swapped for \"%{X=*.*}\"",
               tname, cwidth, int (rhs_seq_len), -1, rhs_seq);
 
    rw_assert (0 == lhs_size_2, 0, __LINE__,
               "deque<%s>().size() not swapped for \"%{X=*.*}\"",
               tname, cwidth, int (rhs_seq_len), -1, rhs_seq);
}
 
 
template <class T>
void test_swap (const T*, const char* tname)
{
    rw_info (0, 0, 0, 
             "std::deque<%s>::swap(deque<%1$s>&)", tname);
 
    typedef std::deque<T, std::allocator<T> > MyDeque;
    typedef typename MyDeque::iterator        Iterator;
 
    // create two empty deque objects
    MyDeque empty [2];
 
    // save their begin and end iterators before calling swap
    const Iterator before [2][2] = {
        { empty [0].begin (), empty [0].end () },
        { empty [1].begin (), empty [1].end () }
    };
 
    // swap the two containers
    empty [0].swap (empty [1]);
 
    // get the new begin and end iterators
    const Iterator after [2][2] = {
        { empty [0].begin (), empty [0].end () },
        { empty [1].begin (), empty [1].end () }
    };
 
    // verify that the iterators have not been invalidated
    rw_assert (   before [0][0] == after [1][0] 
               && before [1][0] == after [0][0], 0, __LINE__, 
               "deque<%s>().begin() not swapped", tname);
    
    rw_assert (   before [0][1] == after [1][1] 
               && before [1][1] == after [0][1], 0, __LINE__, 
               "deque<%s>().end() not swapped", tname);
 
    // static to zero-initialize if T is a POD type
    static T seq [32];
 
    const std::size_t seq_len = sizeof seq / sizeof *seq;
 
    for (std::size_t i = 0; i != seq_len; ++i) {
        for (std::size_t j = 0; j != seq_len; ++j) {
            test_swap (seq, i, seq, j, (MyDeque*)0, tname);
        }
    }
}
 
 
void test_swap ()
{
    test_swap ((int*)0, "int");
    test_swap ((UserClass*)0, "UserClass");
}
 
 
int run_test (int, char**)
{
    // Test std::swap calling std::deque::swap
    test_std_swap ();
 
    static const Deque::size_type caps[] = {
        2, 3, 4, 5, 16, 32
    };
 
    for (std::size_t i = 0; i != sizeof caps / sizeof *caps; ++i) {
 
        new_capacity = caps [i];
 
        rw_info (0, 0, 0, 
                 "__rw::__rw_new_capacity<std::deque<UserClass> >(0) = %u",
                 _RW::__rw_new_capacity (0, (Deque*)0));
 
        test_swap ();
    }
 
    return 0;
}
 
 
int main (int argc, char** argv)
{
    return rw_test (argc, argv, __FILE__,
                    "lib.deque.special",
                    0 /* no comment */,
                    run_test,
                    0 /* co command line options */);
}