boost_unordered 0.1.0

Boost C++ library boost_unordered packaged using Zanbil
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133


// Copyright 2006-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)

#include "./containers.hpp"

#include "../helpers/invariants.hpp"
#include "../helpers/random_values.hpp"
#include "../helpers/strong.hpp"
#include "../helpers/tracker.hpp"
#include <string>

test::seed_t initialize_seed(3298597);

template <class T> struct rehash_test_base : public test::exception_base
{
  test::random_values<T> values;
  unsigned int n;
  rehash_test_base(unsigned int count = 100, unsigned int n_ = 0)
      : values(count, test::limited_range), n(n_)
  {
  }

  typedef T data_type;
  typedef test::strong<T> strong_type;

  data_type init() const
  {
    T x(values.begin(), values.end(), n);
    return x;
  }

  void check BOOST_PREVENT_MACRO_SUBSTITUTION(
    T const& x, strong_type const& strong) const
  {
    std::string scope(test::scope);

    if (scope.find("hash::operator()") == std::string::npos &&
        scope.find("equal_to::operator()") == std::string::npos &&
        scope != "operator==(object, object)")
      strong.test(x);

    test::check_equivalent_keys(x);
  }
};

template <class T> struct rehash_test0 : rehash_test_base<T>
{
  rehash_test0() : rehash_test_base<T>(0) {}
  void run(T& x) const
  {
    x.rehash(0);

    DISABLE_EXCEPTIONS;
    test::check_container(x, this->values);
    test::check_equivalent_keys(x);
  }
};

template <class T> struct rehash_test1 : rehash_test_base<T>
{
  rehash_test1() : rehash_test_base<T>(0) {}
  void run(T& x) const
  {
    x.rehash(200);

    DISABLE_EXCEPTIONS;
    test::check_container(x, this->values);
    test::check_equivalent_keys(x);
  }
};

template <class T> struct rehash_test2 : rehash_test_base<T>
{
  rehash_test2() : rehash_test_base<T>(0, 200) {}
  void run(T& x) const
  {
    x.rehash(0);

    DISABLE_EXCEPTIONS;
    test::check_container(x, this->values);
    test::check_equivalent_keys(x);
  }
};

template <class T> struct rehash_test3 : rehash_test_base<T>
{
  rehash_test3() : rehash_test_base<T>(10, 0) {}
  void run(T& x) const
  {
    x.rehash(200);

    DISABLE_EXCEPTIONS;
    test::check_container(x, this->values);
    test::check_equivalent_keys(x);
  }
};

template <class T> struct rehash_test4 : rehash_test_base<T>
{
  rehash_test4() : rehash_test_base<T>(10, 200) {}
  void run(T& x) const
  {
    x.rehash(0);

    DISABLE_EXCEPTIONS;
    test::check_container(x, this->values);
    test::check_equivalent_keys(x);
  }
};

template <class T> struct rehash_test5 : rehash_test_base<T>
{
  rehash_test5() : rehash_test_base<T>(200, 10) {}
  void run(T& x) const
  {
    x.rehash(0);

    DISABLE_EXCEPTIONS;
    test::check_container(x, this->values);
    test::check_equivalent_keys(x);
  }
};

// clang-format off
EXCEPTION_TESTS(
  (rehash_test0)(rehash_test1)(rehash_test2)(rehash_test3)(rehash_test4)
  (rehash_test5),
  CONTAINER_SEQ)
// clang-format on

RUN_TESTS()