MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/genericopenlibs/cppstdlib/stl/test/eh/test_hash_set.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 /***********************************************************************************

     2   test_hash_set.cpp

     3 

     4  * Copyright (c) 1997

     5  * Mark of the Unicorn, Inc.

     6  *

     7  * Permission to use, copy, modify, distribute and sell this software

     8  * and its documentation for any purpose is hereby granted without fee,

     9  * provided that the above copyright notice appear in all copies and

    10  * that both that copyright notice and this permission notice appear

    11  * in supporting documentation.  Mark of the Unicorn makes no

    12  * representations about the suitability of this software for any

    13  * purpose.  It is provided "as is" without express or implied warranty.

    14 

    15 ***********************************************************************************/

    16 #include "Tests.h"

    17 

    18 #if defined( EH_HASHED_CONTAINERS_IMPLEMENTED )

    19 

    20 #  include <hash_set>

    21 

    22 #include "TestClass.h"

    23 #include "LeakCheck.h"

    24 #include "test_construct.h"

    25 #include "test_assign_op.h"

    26 #include "test_push_back.h"

    27 #include "test_insert.h"

    28 #include "test_push_front.h"

    29 #include "ThrowCompare.h"

    30 #include "test_hash_resize.h"

    31 

    32 typedef EH_STD::__hash_multiset__<TestClass, ThrowHash, ThrowEqual,

    33   eh_allocator(TestClass) > TestMultiSet;

    34 

    35 inline multiset_tag

    36 container_category(const TestMultiSet&)

    37 {

    38   return multiset_tag();

    39 }

    40 

    41 void test_hash_multiset()

    42 {

    43 # if !(defined (_MSC_VER) && (_MSC_VER < 1100))

    44   TestMultiSet testMultiSet, testMultiSet2;

    45 

    46         const size_t hash_setSize = random_number(random_base);

    47 

    48   while ( testMultiSet.size() < hash_setSize )

    49   {

    50     TestMultiSet::value_type x;

    51     testMultiSet.insert( x );

    52     testMultiSet2.insert( TestMultiSet::value_type() );

    53   }

    54 

    55 #  if defined( EH_HASH_CONTAINERS_SUPPORT_RESIZE )

    56   WeakCheck( testMultiSet, test_hash_resize<TestMultiSet>() );

    57   // TestMultiSet == TestMultiSet: no such operator! - ptr

    58   // StrongCheck( testMultiSet, test_insert_noresize<TestMultiSet>(testMultiSet) );

    59 #  endif

    60   WeakCheck( testMultiSet, test_insert_value<TestMultiSet>(testMultiSet) );

    61 

    62   size_t insCnt = random_number(random_base);

    63   TestMultiSet::value_type *insFirst = new TestMultiSet::value_type[1+insCnt];

    64   WeakCheck( testMultiSet, insert_range_tester(testMultiSet, insFirst, insFirst+insCnt) );

    65   ConstCheck( 0, test_construct_pointer_range<TestMultiSet>(insFirst, insFirst+insCnt) );

    66   delete[] insFirst;

    67 

    68   WeakCheck( testMultiSet, insert_range_tester(testMultiSet, testMultiSet2.begin(), testMultiSet2.end() ) );

    69 

    70   ConstCheck( 0, test_default_construct<TestMultiSet>() );

    71 #  if EH_HASH_CONTAINERS_SUPPORT_ITERATOR_CONSTRUCTION

    72   ConstCheck( 0, test_construct_iter_range_n<TestMultiSet>( testMultiSet2 ) );

    73 #  endif

    74   ConstCheck( testMultiSet, test_copy_construct<TestMultiSet>() );

    75 

    76   WeakCheck( testMultiSet, test_assign_op<TestMultiSet>( testMultiSet2 ) );

    77 # endif

    78 }

    79 

    80 typedef EH_STD::__hash_set__<TestClass, ThrowHash, ThrowEqual, eh_allocator(TestClass) > TestSet;

    81 

    82 inline set_tag

    83 container_category(const TestSet&)

    84 {

    85   return set_tag();

    86 }

    87 

    88 void test_hash_set()

    89 {

    90 # if !(defined (_MSC_VER) && (_MSC_VER < 1100))

    91   TestSet testSet, testSet2;

    92 

    93         const size_t hash_setSize = random_number(random_base);

    94 

    95   while ( testSet.size() < hash_setSize )

    96   {

    97     TestSet::value_type x;

    98     testSet.insert( x );

    99     testSet2.insert( TestSet::value_type() );

   100   }

   101 

   102 #  if defined( EH_HASH_CONTAINERS_SUPPORT_RESIZE )

   103   WeakCheck( testSet, test_hash_resize<TestSet>() );

   104   // TestMultiSet == TestMultiSet: no such operator! - ptr

   105   // StrongCheck( testSet, test_insert_noresize<TestSet>(testSet) );

   106 #  endif

   107   WeakCheck( testSet, test_insert_value<TestSet>(testSet) );

   108 

   109   size_t insCnt = random_number(random_base);

   110   TestSet::value_type *insFirst = new TestSet::value_type[1+insCnt];

   111   WeakCheck( testSet, insert_range_tester(testSet, insFirst, insFirst+insCnt) );

   112   ConstCheck( 0, test_construct_pointer_range<TestSet>(insFirst, insFirst+insCnt) );

   113   delete[] insFirst;

   114 

   115   WeakCheck( testSet, insert_range_tester(testSet, testSet2.begin(), testSet2.end() ) );

   116 

   117   ConstCheck( 0, test_default_construct<TestSet>() );

   118 #  if EH_HASH_CONTAINERS_SUPPORT_ITERATOR_CONSTRUCTION

   119   ConstCheck( 0, test_construct_iter_range_n<TestSet>( testSet2 ) );

   120 #  endif

   121   ConstCheck( testSet, test_copy_construct<TestSet>() );

   122 

   123   WeakCheck( testSet, test_assign_op<TestSet>( testSet2 ) );

   124 # endif

   125 }

   126 

   127 #endif  // EH_HASHED_CONTAINERS_IMPLEMENTED
Symaptic