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