Changeset 44833


Ignore:
Timestamp:
Apr 28, 2008, 7:03:43 AM (11 years ago)
Author:
Daniel James
Message:

Better equality tests.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/unordered/trunk/libs/unordered/test/unordered/equality_tests.cpp

    r44779 r44833  
    66#include <boost/unordered_set.hpp>
    77#include <boost/unordered_map.hpp>
     8#include <boost/preprocessor/seq.hpp>
     9#include <list>
    810#include "../helpers/test.hpp"
    9 #include "../objects/test.hpp"
    10 #include "../helpers/random_values.hpp"
    11 #include <list>
    1211
    13 namespace equality_tests {
    14     test::seed_t seed(78634);
     12namespace equality_tests
     13{
     14    struct mod_compare
     15    {
     16        bool operator()(int x, int y) const
     17        {
     18            return x % 1000 == y % 1000;
     19        }
    1520
    16     template<class T>
    17     struct container_holder {
    18         test::random_values<T> values;
    19         T container;
    20 
    21         container_holder()
    22             : values(0), container()
    23         {}
    24 
    25         container_holder(int count, test::random_generator const& generator)
    26             : values(count, generator),
    27             container(values.begin(), values.end())
     21        int operator()(int x) const
    2822        {
     23            return x % 250;
    2924        }
    3025    };
    3126
    32     template <class T>
    33     void equality_tests1(T*, test::random_generator generator
    34             = test::default_generator)
     27#define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2) \
     28        do { \
     29                boost::unordered_set<int, mod_compare, mod_compare> set1, set2; \
     30                BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1) \
     31                BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2) \
     32                BOOST_CHECK(set1 op set2); \
     33        } while(false)
     34
     35#define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2) \
     36        do { \
     37                boost::unordered_multiset<int, mod_compare, mod_compare> set1, set2; \
     38                BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1) \
     39                BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2) \
     40                BOOST_CHECK(set1 op set2); \
     41        } while(false)
     42
     43#define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2) \
     44        do { \
     45                boost::unordered_map<int, int, mod_compare, mod_compare> map1, map2; \
     46                BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1) \
     47                BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2) \
     48                BOOST_CHECK(map1 op map2); \
     49        } while(false)
     50
     51#define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2) \
     52        do { \
     53                boost::unordered_multimap<int, int, mod_compare, mod_compare> map1, map2; \
     54                BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1) \
     55                BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2) \
     56                BOOST_CHECK(map1 op map2); \
     57        } while(false)
     58
     59#define UNORDERED_SET_INSERT(r, set, item) set.insert(item);
     60#define UNORDERED_MAP_INSERT(r, map, item) \
     61        map.insert(std::pair<int const, int> BOOST_PP_SEQ_TO_TUPLE(item));
     62
     63        UNORDERED_AUTO_TEST(equality_size_tests)
     64        {
     65                boost::unordered_set<int> x1, x2;
     66                BOOST_CHECK(x1 == x2);
     67                BOOST_CHECK(!(x1 != x2));
     68
     69                x1.insert(1);
     70                BOOST_CHECK(x1 != x2);
     71                BOOST_CHECK(!(x1 == x2));
     72                BOOST_CHECK(x2 != x1);
     73                BOOST_CHECK(!(x2 == x1));
     74               
     75                x2.insert(1);
     76                BOOST_CHECK(x1 == x2);
     77                BOOST_CHECK(!(x1 != x2));
     78               
     79                x2.insert(2);
     80                BOOST_CHECK(x1 != x2);
     81                BOOST_CHECK(!(x1 == x2));
     82                BOOST_CHECK(x2 != x1);
     83                BOOST_CHECK(!(x2 == x1));
     84        }
     85       
     86        UNORDERED_AUTO_TEST(equality_key_value_tests)
     87        {
     88                UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2));
     89                UNORDERED_EQUALITY_SET_TEST((2), ==, (2));
     90                UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)));
     91        }
     92       
     93    UNORDERED_AUTO_TEST(equality_collision_test)
    3594    {
    36         const std::size_t num_containers = 100;
    37 
    38         std::list<container_holder<T> > containers;
    39         container_holder<T> empty;
    40         containers.push_back(container_holder<T>());
    41         BOOST_CHECK(empty.values == empty.values);
    42         BOOST_CHECK(empty.values == containers.back().values);
    43         BOOST_CHECK(empty.container == empty.container);
    44         BOOST_CHECK(empty.container == containers.back().container);
    45 
    46         container_holder<T> one(1, generator);
    47         containers.push_back(one);
    48        
    49         BOOST_CHECK(empty.values != one.values);
    50         BOOST_CHECK(one.values == one.values);
    51         BOOST_CHECK(one.values == containers.back().values);
    52         BOOST_CHECK(empty.container != one.container);
    53         BOOST_CHECK(one.container == one.container);
    54         BOOST_CHECK(one.container == containers.back().container);
    55 
    56         container_holder<T> hundred(100, generator);
    57         container_holder<T> hundred2(100, generator);
    58         BOOST_CHECK(hundred.values != hundred2.values);
    59 
    60         containers.push_back(hundred);
    61         containers.push_back(hundred2);
    62        
    63         BOOST_CHECK(empty.values != hundred.values);
    64         BOOST_CHECK(one.values != hundred.values);
    65         BOOST_CHECK(hundred.values == hundred.values);
    66         BOOST_CHECK(hundred2.values != hundred.values);
    67         BOOST_CHECK(hundred.values == hundred.values);
    68         BOOST_CHECK(hundred2.values == containers.back().values);
    69 
    70         BOOST_CHECK(empty.container != hundred.container);
    71         BOOST_CHECK(one.container != hundred.container);
    72         BOOST_CHECK(hundred.container == hundred.container);
    73         BOOST_CHECK(hundred2.container != hundred.container);
    74         BOOST_CHECK(hundred.container == hundred.container);
    75         BOOST_CHECK(hundred2.container == containers.back().container);
    76 
    77         for(std::size_t i = containers.size(); i < num_containers; ++i) {
    78             using namespace std;
    79             containers.push_back(
    80                 container_holder<T>(rand() % 150, generator));
    81         }
    82 
    83         std::size_t count1, count2;
    84         typename std::list<container_holder<T> >::const_iterator it1, it2;
    85         for(it1 = containers.begin(), count1 = 0; it1 != containers.end(); ++it1, ++count1) {
    86             for(it2 = it1, count2 = count1; it2 != containers.end(); ++it2, ++count2) {
    87                 if(it1 == it2) {
    88                     if(it1->container != it2->container ||
    89                         !(it1->container == it2->container))
    90                     {
    91                         std::cerr<<"Container "<<count1<<":\n";
    92                         BOOST_ERROR("Not equal to itself!");
    93                     }
    94                 }
    95                 else if(it1->values == it2->values) {
    96                     if(it1->container != it2->container ||
    97                         !(it1->container == it2->container))
    98                     {
    99                         std::cerr<<"Containers "<<count1<<","<<count2<<":\n";
    100                         BOOST_ERROR("Should be equal");
    101                     }
    102                 }
    103                 else {
    104                     if(it1->container == it2->container ||
    105                         !(it1->container != it2->container))
    106                     {
    107                         std::cerr<<"Containers "<<count1<<","<<count2<<":\n";
    108                         BOOST_ERROR("Should not be equal");
    109                     }
    110                 }
    111             }
    112         }
     95        UNORDERED_EQUALITY_MULTISET_TEST(
     96                (1), !=, (501));
     97        UNORDERED_EQUALITY_MULTISET_TEST(
     98                (1)(251), !=, (1)(501));
     99        UNORDERED_EQUALITY_MULTIMAP_TEST(
     100                ((251)(1))((1)(1)), !=, ((501)(1))((1)(1)));
     101        UNORDERED_EQUALITY_MULTISET_TEST(
     102                (1)(501), ==, (1)(501));
     103        UNORDERED_EQUALITY_SET_TEST(
     104                (1)(501), ==, (501)(1));
    113105    }
    114106
    115     boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
    116     boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
    117     boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
    118     boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
     107        UNORDERED_AUTO_TEST(equality_group_size_test)
     108        {
     109        UNORDERED_EQUALITY_MULTISET_TEST(
     110                (10)(20)(20), !=, (10)(10)(20));
     111        UNORDERED_EQUALITY_MULTIMAP_TEST(
     112                ((10)(1))((20)(1))((20)(1)), !=,
     113                ((10)(1))((20)(1))((10)(1)));
     114        UNORDERED_EQUALITY_MULTIMAP_TEST(
     115                ((20)(1))((10)(1))((10)(1)), ==,
     116                ((10)(1))((20)(1))((10)(1)));
     117    }
     118   
     119    UNORDERED_AUTO_TEST(equality_map_value_test)
     120    {
     121        UNORDERED_EQUALITY_MAP_TEST(
     122                ((1)(1)), !=, ((1)(2)));
     123        UNORDERED_EQUALITY_MAP_TEST(
     124                ((1)(1)), ==, ((1)(1)));
     125        UNORDERED_EQUALITY_MULTIMAP_TEST(
     126                ((1)(1)), !=, ((1)(2)));
     127        UNORDERED_EQUALITY_MULTIMAP_TEST(
     128                ((1)(1))((1)(1)), !=, ((1)(1))((1)(2)));
     129        UNORDERED_EQUALITY_MULTIMAP_TEST(
     130                ((1)(2))((1)(1)), !=, ((1)(1))((1)(2)));
     131        }
    119132
    120     using test::default_generator;
    121     using test::generate_collisions;
     133    UNORDERED_AUTO_TEST(equality_predicate_test)
     134    {
     135        UNORDERED_EQUALITY_SET_TEST(
     136                (1), ==, (1001));
     137        UNORDERED_EQUALITY_MAP_TEST(
     138                ((1)(2))((1001)(1)), ==, ((1001)(2))((1)(1)));
     139        }
    122140
    123     UNORDERED_TEST(equality_tests1,
    124         ((test_set)(test_multiset)(test_map)(test_multimap))
    125         ((default_generator)(generate_collisions))
    126     )
    127141}
    128142
Note: See TracChangeset for help on using the changeset viewer.