[ceph.git] / ceph / src / boost / libs / unordered / test / unordered / equality_tests.cpp


// Copyright 2008-2009 Daniel James.
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// clang-format off
#include "../helpers/prefix.hpp"
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
#include "../helpers/postfix.hpp"
// clang-format on

#include <boost/preprocessor/seq.hpp>
#include <list>
#include "../helpers/test.hpp"

namespace equality_tests {
  struct mod_compare
  {
    bool alt_hash_;

    explicit mod_compare(bool alt_hash = false) : alt_hash_(alt_hash) {}

    bool operator()(int x, int y) const { return x % 1000 == y % 1000; }

    std::size_t operator()(int x) const
    {
      return alt_hash_ ? static_cast<std::size_t>(x % 250)
                       : static_cast<std::size_t>((x + 5) % 250);
    }
  };

#define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2)                            \
  do {                                                                         \
    boost::unordered_set<int, mod_compare, mod_compare> set1, set2;            \
    BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)                    \
    BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)                    \
    BOOST_TEST(set1 op set2);                                                  \
  } while (0)

#define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2)                       \
  do {                                                                         \
    boost::unordered_multiset<int, mod_compare, mod_compare> set1, set2;       \
    BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)                    \
    BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)                    \
    BOOST_TEST(set1 op set2);                                                  \
  } while (0)

#define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2)                            \
  do {                                                                         \
    boost::unordered_map<int, int, mod_compare, mod_compare> map1, map2;       \
    BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)                    \
    BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)                    \
    BOOST_TEST(map1 op map2);                                                  \
  } while (0)

#define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2)                       \
  do {                                                                         \
    boost::unordered_multimap<int, int, mod_compare, mod_compare> map1, map2;  \
    BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)                    \
    BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)                    \
    BOOST_TEST(map1 op map2);                                                  \
  } while (0)

#define UNORDERED_SET_INSERT(r, set, item) set.insert(item);
#define UNORDERED_MAP_INSERT(r, map, item)                                     \
  map.insert(std::pair<int const, int> BOOST_PP_SEQ_TO_TUPLE(item));

  UNORDERED_AUTO_TEST (equality_size_tests) {
    boost::unordered_set<int> x1, x2;
    BOOST_TEST(x1 == x2);
    BOOST_TEST(!(x1 != x2));

    x1.insert(1);
    BOOST_TEST(x1 != x2);
    BOOST_TEST(!(x1 == x2));
    BOOST_TEST(x2 != x1);
    BOOST_TEST(!(x2 == x1));

    x2.insert(1);
    BOOST_TEST(x1 == x2);
    BOOST_TEST(!(x1 != x2));

    x2.insert(2);
    BOOST_TEST(x1 != x2);
    BOOST_TEST(!(x1 == x2));
    BOOST_TEST(x2 != x1);
    BOOST_TEST(!(x2 == x1));
  }

  UNORDERED_AUTO_TEST (equality_key_value_tests) {
    UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2));
    UNORDERED_EQUALITY_SET_TEST((2), ==, (2));
    UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)));
  }

  UNORDERED_AUTO_TEST (equality_collision_test) {
    UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (501));
    UNORDERED_EQUALITY_MULTISET_TEST((1)(251), !=, (1)(501));
    UNORDERED_EQUALITY_MULTIMAP_TEST(
      ((251)(1))((1)(1)), !=, ((501)(1))((1)(1)));
    UNORDERED_EQUALITY_MULTISET_TEST((1)(501), ==, (1)(501));
    UNORDERED_EQUALITY_SET_TEST((1)(501), ==, (501)(1));
  }

  UNORDERED_AUTO_TEST (equality_group_size_test) {
    UNORDERED_EQUALITY_MULTISET_TEST((10)(20)(20), !=, (10)(10)(20));
    UNORDERED_EQUALITY_MULTIMAP_TEST(
      ((10)(1))((20)(1))((20)(1)), !=, ((10)(1))((20)(1))((10)(1)));
    UNORDERED_EQUALITY_MULTIMAP_TEST(
      ((20)(1))((10)(1))((10)(1)), ==, ((10)(1))((20)(1))((10)(1)));
  }

  UNORDERED_AUTO_TEST (equality_map_value_test) {
    UNORDERED_EQUALITY_MAP_TEST(((1)(1)), !=, ((1)(2)));
    UNORDERED_EQUALITY_MAP_TEST(((1)(1)), ==, ((1)(1)));
    UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(1)), !=, ((1)(2)));
    UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(1))((1)(1)), !=, ((1)(1))((1)(2)));
    UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(2))((1)(1)), ==, ((1)(1))((1)(2)));
    UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(2))((1)(1)), !=, ((1)(1))((1)(3)));
  }

  UNORDERED_AUTO_TEST (equality_predicate_test) {
    UNORDERED_EQUALITY_SET_TEST((1), !=, (1001));
    UNORDERED_EQUALITY_MAP_TEST(((1)(2))((1001)(1)), !=, ((1001)(2))((1)(1)));
  }

  UNORDERED_AUTO_TEST (equality_multiple_group_test) {
    UNORDERED_EQUALITY_MULTISET_TEST(
      (1)(1)(1)(1001)(2001)(2001)(2)(1002)(3)(1003)(2003), ==,
      (3)(1003)(2003)(1002)(2)(2001)(2001)(1)(1001)(1)(1));
  }

  // Test that equality still works when the two containers have
  // different hash functions but the same equality predicate.

  UNORDERED_AUTO_TEST (equality_different_hash_test) {
    typedef boost::unordered_set<int, mod_compare, mod_compare> set;
    set set1(0, mod_compare(false), mod_compare(false));
    set set2(0, mod_compare(true), mod_compare(true));
    BOOST_TEST(set1 == set2);
    set1.insert(1);
    set2.insert(2);
    BOOST_TEST(set1 != set2);
    set1.insert(2);
    set2.insert(1);
    BOOST_TEST(set1 == set2);
    set1.insert(10);
    set2.insert(20);
    BOOST_TEST(set1 != set2);
    set1.insert(20);
    set2.insert(10);
    BOOST_TEST(set1 == set2);
  }
}

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