ceph/src/boost/libs/unordered/test/unordered/equality_tests.cpp

   1
   2 // Copyright 2008-2009 Daniel James.
   3 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #include "../helpers/prefix.hpp"
   7 #include <boost/unordered_set.hpp>
   8 #include <boost/unordered_map.hpp>
   9 #include "../helpers/postfix.hpp"
  10
  11 #include <boost/preprocessor/seq.hpp>
  12 #include <list>
  13 #include "../helpers/test.hpp"
  14
  15 namespace equality_tests
  16 {
  17     struct mod_compare
  18     {
  19         bool alt_hash_;
  20
  21         explicit mod_compare(bool alt_hash = false) : alt_hash_(alt_hash) {}
  22
  23         bool operator()(int x, int y) const
  24         {
  25             return x % 1000 == y % 1000;
  26         }
  27
  28         std::size_t operator()(int x) const
  29         {
  30             return alt_hash_ ?
  31                 static_cast<std::size_t>(x % 250) :
  32                 static_cast<std::size_t>((x + 5) % 250);
  33         }
  34     };
  35
  36 #define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2)                         \
  37     {                                                                       \
  38         boost::unordered_set<int, mod_compare, mod_compare> set1, set2;     \
  39         BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)             \
  40         BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)             \
  41         BOOST_TEST(set1 op set2);                                           \
  42     }
  43
  44 #define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2)                    \
  45     {                                                                       \
  46         boost::unordered_multiset<int, mod_compare, mod_compare>            \
  47             set1, set2;                                                     \
  48         BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)             \
  49         BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)             \
  50         BOOST_TEST(set1 op set2);                                           \
  51     }
  52
  53 #define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2)                         \
  54     {                                                                       \
  55         boost::unordered_map<int, int, mod_compare, mod_compare>            \
  56             map1, map2;                                                     \
  57         BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)             \
  58         BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)             \
  59         BOOST_TEST(map1 op map2);                                           \
  60     }
  61
  62 #define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2)                    \
  63     {                                                                       \
  64         boost::unordered_multimap<int, int, mod_compare, mod_compare>       \
  65             map1, map2;                                                     \
  66         BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)             \
  67         BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)             \
  68         BOOST_TEST(map1 op map2);                                           \
  69     }
  70
  71 #define UNORDERED_SET_INSERT(r, set, item) set.insert(item);
  72 #define UNORDERED_MAP_INSERT(r, map, item) \
  73     map.insert(std::pair<int const, int> BOOST_PP_SEQ_TO_TUPLE(item));
  74
  75     UNORDERED_AUTO_TEST(equality_size_tests)
  76     {
  77         boost::unordered_set<int> x1, x2;
  78         BOOST_TEST(x1 == x2);
  79         BOOST_TEST(!(x1 != x2));
  80
  81         x1.insert(1);
  82         BOOST_TEST(x1 != x2);
  83         BOOST_TEST(!(x1 == x2));
  84         BOOST_TEST(x2 != x1);
  85         BOOST_TEST(!(x2 == x1));
  86
  87         x2.insert(1);
  88         BOOST_TEST(x1 == x2);
  89         BOOST_TEST(!(x1 != x2));
  90
  91         x2.insert(2);
  92         BOOST_TEST(x1 != x2);
  93         BOOST_TEST(!(x1 == x2));
  94         BOOST_TEST(x2 != x1);
  95         BOOST_TEST(!(x2 == x1));
  96     }
  97
  98     UNORDERED_AUTO_TEST(equality_key_value_tests)
  99     {
 100         UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2))
 101         UNORDERED_EQUALITY_SET_TEST((2), ==, (2))
 102         UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)))
 103     }
 104
 105     UNORDERED_AUTO_TEST(equality_collision_test)
 106     {
 107         UNORDERED_EQUALITY_MULTISET_TEST(
 108             (1), !=, (501))
 109         UNORDERED_EQUALITY_MULTISET_TEST(
 110             (1)(251), !=, (1)(501))
 111         UNORDERED_EQUALITY_MULTIMAP_TEST(
 112             ((251)(1))((1)(1)), !=, ((501)(1))((1)(1)))
 113         UNORDERED_EQUALITY_MULTISET_TEST(
 114             (1)(501), ==, (1)(501))
 115         UNORDERED_EQUALITY_SET_TEST(
 116             (1)(501), ==, (501)(1))
 117     }
 118
 119     UNORDERED_AUTO_TEST(equality_group_size_test)
 120     {
 121         UNORDERED_EQUALITY_MULTISET_TEST(
 122             (10)(20)(20), !=, (10)(10)(20))
 123         UNORDERED_EQUALITY_MULTIMAP_TEST(
 124             ((10)(1))((20)(1))((20)(1)), !=,
 125             ((10)(1))((20)(1))((10)(1)))
 126         UNORDERED_EQUALITY_MULTIMAP_TEST(
 127             ((20)(1))((10)(1))((10)(1)), ==,
 128             ((10)(1))((20)(1))((10)(1)))
 129     }
 130
 131     UNORDERED_AUTO_TEST(equality_map_value_test)
 132     {
 133         UNORDERED_EQUALITY_MAP_TEST(
 134             ((1)(1)), !=, ((1)(2)))
 135         UNORDERED_EQUALITY_MAP_TEST(
 136             ((1)(1)), ==, ((1)(1)))
 137         UNORDERED_EQUALITY_MULTIMAP_TEST(
 138             ((1)(1)), !=, ((1)(2)))
 139         UNORDERED_EQUALITY_MULTIMAP_TEST(
 140             ((1)(1))((1)(1)), !=, ((1)(1))((1)(2)))
 141         UNORDERED_EQUALITY_MULTIMAP_TEST(
 142             ((1)(2))((1)(1)), ==, ((1)(1))((1)(2)))
 143         UNORDERED_EQUALITY_MULTIMAP_TEST(
 144             ((1)(2))((1)(1)), !=, ((1)(1))((1)(3)))
 145     }
 146
 147     UNORDERED_AUTO_TEST(equality_predicate_test)
 148     {
 149         UNORDERED_EQUALITY_SET_TEST(
 150             (1), !=, (1001))
 151         UNORDERED_EQUALITY_MAP_TEST(
 152             ((1)(2))((1001)(1)), !=, ((1001)(2))((1)(1)))
 153     }
 154
 155     UNORDERED_AUTO_TEST(equality_multiple_group_test)
 156     {
 157         UNORDERED_EQUALITY_MULTISET_TEST(
 158             (1)(1)(1)(1001)(2001)(2001)(2)(1002)(3)(1003)(2003), ==,
 159             (3)(1003)(2003)(1002)(2)(2001)(2001)(1)(1001)(1)(1)
 160         );
 161     }
 162
 163     // Test that equality still works when the two containers have
 164     // different hash functions but the same equality predicate.
 165
 166     UNORDERED_AUTO_TEST(equality_different_hash_test)
 167     {
 168         typedef boost::unordered_set<int, mod_compare, mod_compare> set;
 169         set set1(0, mod_compare(false), mod_compare(false));
 170         set set2(0, mod_compare(true), mod_compare(true));
 171         BOOST_TEST(set1 == set2);
 172         set1.insert(1); set2.insert(2);
 173         BOOST_TEST(set1 != set2);
 174         set1.insert(2); set2.insert(1);
 175         BOOST_TEST(set1 == set2);
 176         set1.insert(10); set2.insert(20);
 177         BOOST_TEST(set1 != set2);
 178         set1.insert(20); set2.insert(10);
 179         BOOST_TEST(set1 == set2);
 180     }
 181 }
 182
 183 RUN_TESTS()