test_insert.h

/***********************************************************************************
        test_insert.h
        
 * Copyright (c) 1997
 * Mark of the Unicorn, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Mark of the Unicorn makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.

***********************************************************************************/
#ifndef test_insert_H_
#define test_insert_H_

# include "Prefix.h"
# if defined (EH_NEW_HEADERS)
#  include <utility>
#  include <vector>
#  include <cassert>
#  include <climits>
# else
#  include <vector.h>
#  include <assert.h>
#  include <limits.h>
# endif
#include "random_number.h"
#include "nc_alloc.h"
#include "ThrowCompare.h"

// A classification system for containers, for verification
struct container_tag {};
struct sequence_container_tag  {};
struct associative_container_tag  {}; 

struct set_tag  {};
struct multiset_tag  {};
struct map_tag {};
struct multimap_tag {};

template <class C, class Iter>
EH_STD::size_t CountNewItems( const C&, const Iter& firstNew, 
                      const Iter& lastNew, sequence_container_tag )
{
    EH_STD::size_t dist = 0;
#if 0 //def __SUNPRO_CC
    EH_DISTANCE( firstNew, lastNew, dist );
#else
    EH_DISTANCE( Iter(firstNew), Iter(lastNew), dist );
#endif
    return dist;
}

template <class C, class Iter>
EH_STD::size_t CountNewItems( const C& c, const Iter& firstNew, 
                      const Iter& lastNew, multimap_tag )
{
    return CountNewItems( c, firstNew, lastNew, sequence_container_tag() );
}

template <class C, class Iter>
EH_STD::size_t CountNewItems( const C& c, const Iter& firstNew, 
                      const Iter& lastNew, multiset_tag )
{
    return CountNewItems( c, firstNew, lastNew, sequence_container_tag() );
}


template <class C, class Iter, class KeyOfValue>
#ifdef __BORLANDC__
EH_STD::size_t CountUniqueItems_Aux( const C& original, const Iter& firstNew, 
#else
EH_STD::size_t CountUniqueItems_Aux( const C& original, Iter firstNew, 
#endif
                             Iter lastNew, const KeyOfValue& keyOfValue )
{
        typedef typename C::key_type key;
        typedef typename C::const_iterator const_iter;
        typedef EH_STD::vector<key> key_list;
        typedef typename key_list::iterator key_iterator;
        key_list keys;
        EH_STD::size_t dist = 0;
#ifdef __SUNPRO_CC
        EH_DISTANCE( firstNew, lastNew, dist );
#else
        EH_DISTANCE( Iter(firstNew), Iter(lastNew), dist );
#endif
        keys.reserve( dist );
        for ( Iter x = firstNew; x != lastNew; ++x )
                keys.push_back( keyOfValue(*x) );
                
        EH_STD::sort( keys.begin(), keys.end() );
        key_iterator last = EH_STD::unique( keys.begin(), keys.end() );
         
    EH_STD::size_t cnt = 0;
    for ( key_iterator tmp = keys.begin(); tmp != last; ++tmp )
    {
        if ( const_iter(original.find( *tmp )) == const_iter(original.end()) )
            ++cnt;
    }
    return cnt;
}

#if ! defined (__SGI_STL)
EH_BEGIN_NAMESPACE
template <class T>
struct identity
{
        const T& operator()( const T& x ) const { return x; }
};
# if ! defined (__KCC)
template <class _Pair>
struct select1st : public unary_function<_Pair, typename _Pair::first_type> {
  const typename _Pair::first_type& operator()(const _Pair& __x) const {
    return __x.first;
  }
};
# endif
EH_END_NAMESPACE
#endif

template <class C, class Iter>
EH_STD::size_t CountUniqueItems( const C& original, const Iter& firstNew, 
                         const Iter& lastNew, set_tag )
{
    typedef typename C::value_type value_type;
    return CountUniqueItems_Aux( original, firstNew, lastNew, 
                                 EH_STD::identity<value_type>() );
}

template <class C, class Iter>
EH_STD::size_t CountUniqueItems( const C& original, const Iter& firstNew, 
                         const Iter& lastNew, map_tag )
{
#ifdef EH_MULTI_CONST_TEMPLATE_ARG_BUG
    return CountUniqueItems_Aux( original, firstNew, lastNew, 
                                 EH_SELECT1ST_HINT<C::value_type, C::key_type>() );
#else
    typedef typename C::value_type value_type;
    return CountUniqueItems_Aux( original, firstNew, lastNew, 
                                 EH_STD::select1st<value_type>() );
#endif
}

template <class C, class Iter>
EH_STD::size_t CountNewItems( const C& original, const Iter& firstNew, 
                      const Iter& lastNew, map_tag )
{
    return CountUniqueItems( original, firstNew, lastNew, 
                             container_category( original ) );
}

template <class C, class Iter>
EH_STD::size_t CountNewItems( const C& original, const Iter& firstNew, 
                      const Iter& lastNew, set_tag )
{
    return CountUniqueItems( original, firstNew, lastNew, 
                             container_category( original ) );
}

template <class C, class SrcIter>
inline void VerifyInsertion( const C& original, const C& result, 
                             const SrcIter& firstNew, const SrcIter& lastNew, 
                             EH_STD::size_t, associative_container_tag )
{
    typedef typename C::const_iterator DstIter;
    DstIter first1 = original.begin();
    DstIter first2 = result.begin();

    DstIter* from_orig = new DstIter[original.size()];
    DstIter* last_from_orig = from_orig;
    
    // fbp : for hashed containers, the following is needed :
    while ( first2 != result.end() )
    {
        EH_STD::pair<DstIter, DstIter> p = EH_STD::mismatch( first1, original.end(), first2 );
        if ( p.second != result.end() )
        {
            SrcIter srcItem = EH_STD::find( SrcIter(firstNew), SrcIter(lastNew), *p.second );
                        
            if (srcItem == lastNew)
            {                           
                // not found in input range, probably re-ordered from the orig
                DstIter* tmp;
                tmp = EH_STD::find( from_orig, last_from_orig, p.first );
                
                // if already here, exclude
                if (tmp != last_from_orig)
                {
                    EH_STD::copy(tmp+1, last_from_orig, tmp);
                    last_from_orig--;
                }
                else
                {
                    // register re-ordered element
                    DstIter dstItem;
                    dstItem = EH_STD::find( first1, original.end(), *p.first );
                    EH_ASSERT( dstItem != original.end() );
                    *last_from_orig = dstItem;
                    last_from_orig++;
                    ++p.first;
                }
            }
            ++p.second;
        }
        first1 = p.first;
        first2 = p.second;
    }
        
    delete [] from_orig;
}

// VC++ 
template <class C, class SrcIter>
inline void VerifyInsertion(
    const C& original, const C& result, const SrcIter& firstNew, 
    const SrcIter& lastNew, EH_STD::size_t, set_tag )
{
    VerifyInsertion( original, result, firstNew, lastNew, 
                     EH_STD::size_t(0), associative_container_tag() );
}

template <class C, class SrcIter>
inline void VerifyInsertion(const C& original, const C& result, 
                            const SrcIter& firstNew, const SrcIter& lastNew, 
                            EH_STD::size_t, multiset_tag )
{
    VerifyInsertion( original, result, firstNew, lastNew, 
                     EH_STD::size_t(0), associative_container_tag() );
}

template <class C, class SrcIter>
inline void VerifyInsertion(
    const C& original, const C& result, const SrcIter& firstNew, 
    const SrcIter& lastNew, EH_STD::size_t, map_tag )
{
    VerifyInsertion( original, result, firstNew, lastNew, 
                     EH_STD::size_t(0), associative_container_tag() );
}

template <class C, class SrcIter>
inline void VerifyInsertion(
    const C& original, const C& result, const SrcIter& firstNew, 
    const SrcIter& lastNew, EH_STD::size_t, multimap_tag )
{
    VerifyInsertion( original, result, firstNew, lastNew, 
                     EH_STD::size_t(0), associative_container_tag() );
}

template <class C, class SrcIter>
void VerifyInsertion(
# if defined (_MSC_VER)  && !defined (__SYMBIAN32__)
    const C& original, const C& result, SrcIter firstNew, 
    SrcIter lastNew, EH_STD::size_t insPos, sequence_container_tag )
# else
    const C& original, const C& result, const SrcIter& firstNew, 
    const SrcIter& lastNew, EH_STD::size_t insPos, sequence_container_tag )
# endif
{
    typename C::const_iterator p1 = original.begin();
    typename C::const_iterator p2 = result.begin();
    SrcIter tmp(firstNew);
    
    for ( EH_STD::size_t n = 0; n < insPos; n++, ++p1, ++p2)
        EH_ASSERT( *p1 == *p2 );

    for (; tmp != lastNew; ++p2, ++tmp ) {
        EH_ASSERT(p2 != result.end());
        EH_ASSERT(*p2 == *tmp);
    }

    for (;  p2 != result.end(); ++p1, ++p2 )
        EH_ASSERT( *p1 == *p2 );
    EH_ASSERT( p1 == original.end() );
}

template <class C, class SrcIter>
inline void VerifyInsertion( const C& original, const C& result, 
                             const SrcIter& firstNew, 
                             const SrcIter& lastNew, EH_STD::size_t insPos )
{
    EH_ASSERT( result.size() == original.size() + 
            CountNewItems( original, firstNew, lastNew, 
                           container_category(original) ) );
    VerifyInsertion( original, result, firstNew, lastNew, insPos, 
                     container_category(original) );
}

template <class C, class Value>
void VerifyInsertN( const C& original, const C& result, EH_STD::size_t insCnt, 
                    const Value& val, EH_STD::size_t insPos )
{
    typename C::const_iterator p1 = original.begin();
    typename C::const_iterator p2 = result.begin();
        (void)val;              //*TY 02/06/2000 - to suppress unused variable warning under nondebug build

    for ( EH_STD::size_t n = 0; n < insPos; n++ )
        EH_ASSERT( *p1++ == *p2++ );

    while ( insCnt-- > 0 )
    {
        EH_ASSERT(p2 != result.end());
        EH_ASSERT(*p2 == val );
        ++p2;
    }
        
    while ( p2 != result.end() ) {
        EH_ASSERT( *p1 == *p2 );
        ++p1; ++p2;
    }
    EH_ASSERT( p1 == original.end() );
}

template <class C>
void prepare_insert_n( C&, EH_STD::size_t ) {}

// Metrowerks 1.8 compiler requires that specializations appear first (!!)
// or it won't call them. Fixed in 1.9, though.
inline void MakeRandomValue(bool& b) { b = bool(random_number(2)); }

template<class T>
inline void MakeRandomValue(T&) {}

template <class C>
struct test_insert_one
{
    test_insert_one( const C& orig, int pos =-1 )
        : original( orig ), fPos( random_number( orig.size() ))
    {
        MakeRandomValue( fInsVal );
        if ( pos != -1 )
        {
            fPos = EH_STD::size_t(pos);
            if ( pos == 0 )
                gTestController.SetCurrentTestName("single insertion at begin()");
            else
                gTestController.SetCurrentTestName("single insertion at end()");
        }
        else
            gTestController.SetCurrentTestName("single insertion at random position");
    }
        
    void operator()( C& c ) const
    {
        prepare_insert_n( c, (EH_STD::size_t)1 );
        typename C::iterator pos = c.begin();
        EH_STD::advance( pos, EH_STD::size_t(fPos) );
        c.insert( pos, fInsVal );
                
        // Prevent simulated failures during verification
        gTestController.CancelFailureCountdown();
        // Success. Check results.
        VerifyInsertion( original, c, &fInsVal, 1+&fInsVal, fPos );
    }
private:
    typename C::value_type fInsVal;
    const C& original;
    EH_STD::size_t fPos;
};

template <class C>
struct test_insert_n
{
    test_insert_n( const C& orig, EH_STD::size_t insCnt, int pos =-1 )
        : original( orig ), fPos( random_number( orig.size() )), fInsCnt(insCnt)
    {
        MakeRandomValue( fInsVal );
        if (pos!=-1)
        {
            fPos=EH_STD::size_t(pos);
            if (pos==0)
                gTestController.SetCurrentTestName("n-ary insertion at begin()");
            else
                gTestController.SetCurrentTestName("n-ary insertion at end()");
        }
        else
            gTestController.SetCurrentTestName("n-ary insertion at random position");
    }
        
    void operator()( C& c ) const
    {
        prepare_insert_n( c, fInsCnt );
        typename C::iterator pos = c.begin();
        EH_STD::advance( pos, fPos );
        c.insert( pos, fInsCnt, fInsVal );
                
        // Prevent simulated failures during verification
        gTestController.CancelFailureCountdown();
        // Success. Check results.
        VerifyInsertN( original, c, fInsCnt, fInsVal, fPos );
    }
private:
    typename C::value_type fInsVal;
    const C& original;
    EH_STD::size_t fPos;
    EH_STD::size_t fInsCnt;
};

template <class C>
struct test_insert_value
{
    test_insert_value( const C& orig )
        : original( orig )
    {
        MakeRandomValue( fInsVal );
        gTestController.SetCurrentTestName("insertion or random value");
    }
        
    void operator()( C& c ) const
    {
        c.insert( fInsVal );
                
        // Prevent simulated failures during verification
        gTestController.CancelFailureCountdown();
        // Success. Check results.
        VerifyInsertion( original, c, &fInsVal, 1+&fInsVal, EH_STD::size_t(0) );
    }
private:
    typename C::value_type fInsVal;
    const C& original;
};

template <class C>
struct test_insert_noresize
{
    test_insert_noresize( const C& orig )
        : original( orig )
    {
        MakeRandomValue( fInsVal );
        gTestController.SetCurrentTestName("insertion of random value without resize");
    }

    void operator()( C& c ) const
    {
        c.insert_noresize( fInsVal );

        // Prevent simulated failures during verification
        gTestController.CancelFailureCountdown();
        // Success. Check results.
        VerifyInsertion( original, c, &fInsVal, 1+&fInsVal, EH_STD::size_t(0) );
    }
private:
    typename C::value_type fInsVal;
    const C& original;
};

template <class C, class Position, class Iter>
void do_insert_range( C& c_inst, Position offset, 
                      Iter first, Iter last, sequence_container_tag )
{
    typedef typename C::iterator CIter;
    CIter pos = c_inst.begin();
    EH_STD::advance( pos, offset );
    c_inst.insert( pos, first, last );
}

template <class C, class Position, class Iter>
void do_insert_range( C& c, Position, 
                      Iter first, Iter last, associative_container_tag )
{
    c.insert( first, last );
}

template <class C, class Position, class Iter>
void do_insert_range( C& c, Position, Iter first, Iter last, multiset_tag )
{
    c.insert( first, last );
}

template <class C, class Position, class Iter>
void do_insert_range( C& c, Position, Iter first, Iter last, multimap_tag )
{
    c.insert( first, last );
}

template <class C, class Position, class Iter>
void do_insert_range( C& c, Position, Iter first, Iter last, set_tag )
{
    c.insert( first, last );
}

template <class C, class Position, class Iter>
void do_insert_range( C& c, Position, Iter first, Iter last, map_tag )
{
    c.insert( first, last );
}

/*
template <class C, class Iter>
void prepare_insert_range( C&, size_t, Iter, Iter) {}
*/

template <class C, class Iter>
struct test_insert_range
{
    test_insert_range( const C& orig, Iter first, Iter last, int pos=-1 )
        : fFirst( first ),
          fLast( last ),
          original( orig ),
          fPos( random_number( orig.size() ))
    {
        gTestController.SetCurrentTestName("range insertion");
        if ( pos != -1 )
        {
            fPos = EH_STD::size_t(pos);
            if ( pos == 0 )
                gTestController.SetCurrentTestName("range insertion at begin()");
            else
                gTestController.SetCurrentTestName("range insertion at end()");
        }
        else
            gTestController.SetCurrentTestName("range insertion at random position");
    }

    void operator()( C& c ) const
    {
//        prepare_insert_range( c, fPos, fFirst, fLast );
        do_insert_range( c, fPos, fFirst, fLast, container_category(c) );
                
        // Prevent simulated failures during verification
        gTestController.CancelFailureCountdown();
        // Success. Check results.
        VerifyInsertion( original, c, fFirst, fLast, fPos );
    }
private:
    Iter fFirst, fLast;
    const C& original;
    size_t fPos;
};

template <class C, class Iter>
test_insert_range<C, Iter> insert_range_tester( const C& orig, const Iter& first, const Iter& last )
{
    return test_insert_range<C, Iter>( orig, first, last );
}

template <class C, class Iter>
test_insert_range<C, Iter> insert_range_at_begin_tester( const C& orig, const Iter& first, const Iter& last )
{
        return test_insert_range<C, Iter>( orig, first, last , 0);
}

template <class C, class Iter>
test_insert_range<C, Iter> insert_range_at_end_tester( const C& orig, const Iter& first, const Iter& last )
{
        return test_insert_range<C, Iter>( orig, first, last , (int)orig.size());
}
#endif // test_insert_H_

---