Add static_cast<std::size_t> when comparing distance() to size().
These replacements were performed programmatically with regex_replace():
const vector<pair<regex, string>> reg_fmt = {
{ regex(R"(assert\((\w+)\.size\(\) == std::distance\((\w+, \w+)\)\))"),
"assert($1.size() == static_cast<std::size_t>(std::distance($2)))" },
{ regex(R"(assert\(distance\((\w+\.begin\(\), \w+\.end\(\))\) == (\w+)\.size\(\)\))"),
"assert(static_cast<std::size_t>(distance($1)) == $2.size())" },
{ regex(R"(assert\(std::distance\((\w+\.\w*begin\(\), \w+\.\w*end\(\))\) == (\w+)\.size\(\)\))"),
"assert(static_cast<std::size_t>(std::distance($1)) == $2.size())" },
};
Also, include <cstddef> when it wasn't already being included.
llvm-svn: 288745
V(8, 2)
};
std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
std::map<int, double>::iterator i;
i = m.begin();
std::map<int, double>::const_iterator k = i;
V(8, 2)
};
const std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.cbegin(), m.cend()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
- assert(std::distance(m.crbegin(), m.crend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
std::map<int, double>::const_iterator i;
i = m.begin();
for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
V(8, 2)
};
std::map<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
std::map<int, double, std::less<int>, min_allocator<V>>::iterator i;
i = m.begin();
std::map<int, double, std::less<int>, min_allocator<V>>::const_iterator k = i;
V(8, 2)
};
const std::map<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.cbegin(), m.cend()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
- assert(std::distance(m.crbegin(), m.crend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
std::map<int, double, std::less<int>, min_allocator<V>>::const_iterator i;
i = m.begin();
for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
#include <map>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "min_allocator.h"
V(8, 2)
};
std::multimap<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
std::multimap<int, double>::iterator i;
i = m.begin();
std::multimap<int, double>::const_iterator k = i;
V(8, 2)
};
const std::multimap<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.cbegin(), m.cend()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
- assert(std::distance(m.crbegin(), m.crend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
std::multimap<int, double>::const_iterator i;
i = m.begin();
for (int j = 1; j <= 8; ++j)
V(8, 2)
};
std::multimap<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
std::multimap<int, double, std::less<int>, min_allocator<V>>::iterator i;
i = m.begin();
std::multimap<int, double, std::less<int>, min_allocator<V>>::const_iterator k = i;
V(8, 2)
};
const std::multimap<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.cbegin(), m.cend()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
- assert(std::distance(m.crbegin(), m.crend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
std::multimap<int, double, std::less<int>, min_allocator<V>>::const_iterator i;
i = m.begin();
for (int j = 1; j <= 8; ++j)
#include <set>
#include <cassert>
+#include <cstddef>
#include "min_allocator.h"
C m = {10, 8};
m.insert({1, 2, 3, 4, 5, 6});
assert(m.size() == 8);
- assert(distance(m.begin(), m.end()) == m.size());
+ assert(static_cast<std::size_t>(distance(m.begin(), m.end())) == m.size());
C::const_iterator i = m.cbegin();
assert(*i == V(1));
assert(*++i == V(2));
C m = {10, 8};
m.insert({1, 2, 3, 4, 5, 6});
assert(m.size() == 8);
- assert(distance(m.begin(), m.end()) == m.size());
+ assert(static_cast<std::size_t>(distance(m.begin(), m.end())) == m.size());
C::const_iterator i = m.cbegin();
assert(*i == V(1));
assert(*++i == V(2));
#include <set>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "min_allocator.h"
8
};
std::multiset<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
std::multiset<int>::iterator i;
i = m.begin();
std::multiset<int>::const_iterator k = i;
8
};
const std::multiset<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.cbegin(), m.cend()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
- assert(std::distance(m.crbegin(), m.crend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
std::multiset<int>::const_iterator i;
i = m.begin();
for (int j = 1; j <= 8; ++j)
8
};
std::multiset<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
std::multiset<int, std::less<int>, min_allocator<int>>::iterator i;
i = m.begin();
std::multiset<int, std::less<int>, min_allocator<int>>::const_iterator k = i;
8
};
const std::multiset<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.cbegin(), m.cend()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
- assert(std::distance(m.crbegin(), m.crend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
std::multiset<int, std::less<int>, min_allocator<int>>::const_iterator i;
i = m.begin();
for (int j = 1; j <= 8; ++j)
#include <set>
#include <cassert>
+#include <cstddef>
#include "min_allocator.h"
C m = {10, 8};
m.insert({1, 2, 3, 4, 5, 6});
assert(m.size() == 8);
- assert(distance(m.begin(), m.end()) == m.size());
+ assert(static_cast<std::size_t>(distance(m.begin(), m.end())) == m.size());
C::const_iterator i = m.cbegin();
assert(*i == V(1));
assert(*++i == V(2));
C m = {10, 8};
m.insert({1, 2, 3, 4, 5, 6});
assert(m.size() == 8);
- assert(distance(m.begin(), m.end()) == m.size());
+ assert(static_cast<std::size_t>(distance(m.begin(), m.end())) == m.size());
C::const_iterator i = m.cbegin();
assert(*i == V(1));
assert(*++i == V(2));
8
};
std::set<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
std::set<int>::iterator i;
i = m.begin();
std::set<int>::const_iterator k = i;
8
};
const std::set<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.cbegin(), m.cend()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
- assert(std::distance(m.crbegin(), m.crend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
std::set<int>::const_iterator i;
i = m.begin();
for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
8
};
std::set<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
std::set<int, std::less<int>, min_allocator<int>>::iterator i;
i = m.begin();
std::set<int, std::less<int>, min_allocator<int>>::const_iterator k = i;
8
};
const std::set<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
- assert(std::distance(m.begin(), m.end()) == m.size());
- assert(std::distance(m.cbegin(), m.cend()) == m.size());
- assert(std::distance(m.rbegin(), m.rend()) == m.size());
- assert(std::distance(m.crbegin(), m.crend()) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+ assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
std::set<int, std::less<int>, min_allocator<int>>::const_iterator i;
i = m.begin();
for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
typename C::size_type c1_osize = c1.size();
c1.resize(size);
assert(c1.size() == size);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
CI i = c1.begin();
for (int j = 0; static_cast<std::size_t>(j) < std::min(c1_osize, c1.size()); ++j, ++i)
assert(*i == j);
typename C::size_type c1_osize = c1.size();
c1.resize(size, x);
assert(c1.size() == size);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
CI i = c1.begin();
for (int j = 0; static_cast<std::size_t>(j) < std::min(c1_osize, c1.size()); ++j, ++i)
assert(*i == j);
#include <deque>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
test(C& c1, const C& c2)
{
c1.assign(c2.begin(), c2.end());
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
assert(c1 == c2);
}
typedef typename C::const_iterator CI;
typedef input_iterator<CI> ICI;
c1.assign(ICI(c2.begin()), ICI(c2.end()));
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
assert(c1 == c2);
}
#include <deque>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
typedef typename C::const_iterator CI;
c1.assign(size, v);
assert(c1.size() == size);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
for (CI i = c1.begin(); i != c1.end(); ++i)
assert(*i == v);
}
#include <deque>
#include <cassert>
+#include <cstddef>
#include "test_allocator.h"
#include "test_iterators.h"
typedef std::deque<T, Allocator> C;
typedef typename C::const_iterator const_iterator;
C d(f, l);
- assert(d.size() == std::distance(f, l));
- assert(distance(d.begin(), d.end()) == d.size());
+ assert(d.size() == static_cast<std::size_t>(std::distance(f, l)));
+ assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
assert(*i == *f);
}
typedef std::deque<T, Allocator> C;
typedef typename C::const_iterator const_iterator;
C d(f, l);
- assert(d.size() == std::distance(f, l));
- assert(distance(d.begin(), d.end()) == d.size());
+ assert(d.size() == static_cast<std::size_t>(std::distance(f, l)));
+ assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
assert(*i == *f);
}
#include <deque>
#include <cassert>
+#include <cstddef>
#include "test_iterators.h"
#include "test_allocator.h"
typedef typename C::const_iterator const_iterator;
C d(f, l, a);
assert(d.get_allocator() == a);
- assert(d.size() == std::distance(f, l));
- assert(distance(d.begin(), d.end()) == d.size());
+ assert(d.size() == static_cast<std::size_t>(std::distance(f, l)));
+ assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
assert(*i == *f);
}
#include <deque>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "test_allocator.h"
C d(n, Allocator());
assert(DefaultOnly::count == n);
assert(d.size() == n);
- assert(distance(d.begin(), d.end()) == d.size());
+ assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
assert(*i == T());
C d(n);
assert(DefaultOnly::count == n);
assert(d.size() == n);
- assert(distance(d.begin(), d.end()) == d.size());
+ assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
assert(*i == T());
#include <deque>
#include <cassert>
+#include <cstddef>
#include "test_allocator.h"
#include "min_allocator.h"
typedef typename C::const_iterator const_iterator;
C d(n, x);
assert(d.size() == n);
- assert(distance(d.begin(), d.end()) == d.size());
+ assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
assert(*i == x);
}
#include <deque>
#include <cassert>
+#include <cstddef>
#include "min_allocator.h"
C d(n, x, a);
assert(d.get_allocator() == a);
assert(d.size() == n);
- assert(distance(d.begin(), d.end()) == d.size());
+ assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
assert(*i == x);
}
#include <deque>
#include <cassert>
+#include <cstddef>
#include "../../../Emplaceable.h"
#include "min_allocator.h"
CI i = c1.emplace(c1.begin() + P, Emplaceable(1, 2.5));
assert(i == c1.begin() + P);
assert(c1.size() == c1_osize + 1);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
assert(*i == Emplaceable(1, 2.5));
}
I i = c1.erase(c1.cbegin() + P);
assert(i == c1.begin() + P);
assert(c1.size() == c1_osize - 1);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
i = c1.begin();
int j = 0;
for (; j < P; ++j, ++i)
I i = c1.erase(c1.cbegin() + P, c1.cbegin() + (P + size));
assert(i == c1.begin() + P);
assert(c1.size() == c1_osize - size);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
i = c1.begin();
int j = 0;
for (; j < P; ++j, ++i)
CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
assert(i == c1.begin() + P);
assert(c1.size() == c1_osize + c2.size());
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
i = c1.begin();
for (int j = 0; j < P; ++j, ++i)
assert(*i == j);
CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
assert(i == c1.begin() + P);
assert(c1.size() == c1_osize + c2.size());
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
i = c1.begin();
for (int j = 0; j < P; ++j, ++i)
assert(*i == j);
CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
assert(i == c1.begin() + P);
assert(c1.size() == c1_osize + c2.size());
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
i = c1.begin();
for (int j = 0; j < P; ++j, ++i)
assert(*i == j);
CI i = c1.insert(c1.begin() + P, ICI(c2.begin()), ICI(c2.end()));
assert(i == c1.begin() + P);
assert(c1.size() == c1_osize + c2.size());
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
i = c1.begin();
for (int j = 0; j < P; ++j, ++i)
assert(*i == j);
CI i = c1.insert(c1.begin() + P, MoveOnly(x));
assert(i == c1.begin() + P);
assert(c1.size() == c1_osize + 1);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
i = c1.begin();
for (int j = 0; j < P; ++j, ++i)
assert(*i == MoveOnly(j));
CI i = c1.insert(c1.begin() + P, size, x);
assert(i == c1.begin() + P);
assert(c1.size() == c1_osize + size);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
i = c1.begin();
for (int j = 0; j < P; ++j, ++i)
assert(*i == j);
CI jt = c.cbegin() + j;
c.insert(it, 5, *jt);
assert(c.size() == 25);
- assert(distance(c.begin(), c.end()) == c.size());
+ assert(static_cast<std::size_t>(distance(c.begin(), c.end())) == c.size());
it = c.cbegin();
for (int k = 0; k < i; ++k, ++it)
assert(*it == k);
CI i = c1.insert(c1.begin() + P, x);
assert(i == c1.begin() + P);
assert(c1.size() == c1_osize + 1);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
i = c1.begin();
for (int j = 0; j < P; ++j, ++i)
assert(*i == j);
CI jt = c.cbegin() + j;
c.insert(it, *jt);
assert(c.size() == 21);
- assert(distance(c.begin(), c.end()) == c.size());
+ assert(static_cast<std::size_t>(distance(c.begin(), c.end())) == c.size());
it = c.cbegin();
for (int k = 0; k < i; ++k, ++it)
assert(*it == k);
std::size_t c1_osize = c1.size();
c1.pop_back();
assert(c1.size() == c1_osize - 1);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
I i = c1.begin();
for (int j = 0; static_cast<std::size_t>(j) < c1.size(); ++j, ++i)
assert(*i == j);
std::size_t c1_osize = c1.size();
c1.pop_front();
assert(c1.size() == c1_osize - 1);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
I i = c1.begin();
for (int j = 1; static_cast<std::size_t>(j) < c1.size(); ++j, ++i)
assert(*i == j);
std::size_t c1_osize = c1.size();
c1.push_front(x);
assert(c1.size() == c1_osize + 1);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
I i = c1.begin();
assert(*i == x);
++i;
std::size_t c1_osize = c1.size();
c1.push_front(MoveOnly(x));
assert(c1.size() == c1_osize + 1);
- assert(distance(c1.begin(), c1.end()) == c1.size());
+ assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
I i = c1.begin();
assert(*i == MoveOnly(x));
++i;
#include <vector>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
{
C c(first, last);
LIBCPP_ASSERT(c.__invariants());
- assert(c.size() == std::distance(first, last));
+ assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
assert(*i == *first);
}
#include <vector>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
{
C c(first, last, a);
LIBCPP_ASSERT(c.__invariants());
- assert(c.size() == std::distance(first, last));
+ assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
assert(*i == *first);
}
#include <vector>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
{
C c(first, last);
LIBCPP_ASSERT(c.__invariants());
- assert(c.size() == std::distance(first, last));
+ assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
assert(*i == *first);
#include <vector>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
{
C c(first, last, a);
LIBCPP_ASSERT(c.__invariants());
- assert(c.size() == std::distance(first, last));
+ assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
assert(*i == *first);
#include <unordered_map>
#include <string>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "min_allocator.h"
C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 5);
assert(c.size() == 4);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::iterator i;
}
{
const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 5);
assert(c.size() == 4);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::const_iterator i;
}
#if TEST_STD_VER >= 11
C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 5);
assert(c.size() == 4);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::iterator i;
}
{
const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 5);
assert(c.size() == 4);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::const_iterator i;
}
#endif
#include <unordered_map>
#include <string>
#include <cassert>
+#include <cstddef>
#include "../../test_compare.h"
#include "../../test_hash.h"
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#if TEST_STD_VER >= 11
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#endif
#include <string>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(4));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <string>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "../../../test_compare.h"
#include "../../../test_hash.h"
assert(c.at(2) == "two");
assert(c.at(3) == "three");
assert(c.at(4) == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.at(2) == "two");
assert(c.at(3) == "three");
assert(c.at(4) == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <string>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(4));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c0.size() == 0);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c0.size() == 0);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c0.size() == 0);
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10)));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(other_allocator<std::pair<const int, std::string> >(-2)));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(5)));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <string>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == a);
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == a);
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10)));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10)));
assert(c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10)));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(12));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
#include <string>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == Comp());
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == Comp());
assert(c.get_allocator() == a);
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10)));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <unordered_map>
#include <string>
#include <cassert>
+#include <cstddef>
#include "../../../test_compare.h"
#include "../../../test_hash.h"
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#if TEST_STD_VER >= 11
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#endif
#include <unordered_map>
#include <string>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "min_allocator.h"
C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::iterator i;
i = c.begin();
i->second = "ONE";
const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::const_iterator i;
}
#if TEST_STD_VER >= 11
C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::iterator i;
i = c.begin();
i->second = "ONE";
const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::const_iterator i;
}
#endif
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "min_allocator.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
}
#include <unordered_map>
#include <string>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "../../test_compare.h"
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#if TEST_STD_VER >= 11
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#endif
#include <string>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(4));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <string>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "../../../test_compare.h"
#include "../../../test_hash.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <string>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10)));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(other_allocator<std::pair<const int, std::string> >(-2)));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(5)));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A{});
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <string>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >());
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >());
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == HF());
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == hf);
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >());
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >());
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.get_allocator() ==
(test_allocator<std::pair<const int, std::string> >(10)));
assert(c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
assert(c.get_allocator() ==
(min_allocator<std::pair<const int, std::string> >()));
assert(c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
#include <string>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >());
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >());
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == HF());
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == hf);
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >());
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >());
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
i = eq.first;
assert(i->first == 4);
assert(i->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.hash_function() == test_hash<std::hash<int> >(8));
#include <unordered_map>
#include <string>
#include <cassert>
+#include <cstddef>
#include "min_allocator.h"
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
}
#if TEST_STD_VER >= 11
{
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
}
#endif
#if TEST_STD_VER >= 14
#include <unordered_map>
#include <string>
#include <cassert>
+#include <cstddef>
#include "min_allocator.h"
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(2) == 2);
assert(c.size() == 4);
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(2) == 0);
assert(c.size() == 4);
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(4) == 1);
assert(c.size() == 3);
k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(4) == 0);
assert(c.size() == 3);
k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(1) == 2);
assert(c.size() == 1);
k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(1) == 0);
assert(c.size() == 1);
k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(3) == 1);
assert(c.size() == 0);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 0);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(3) == 0);
assert(c.size() == 0);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 0);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
}
#if TEST_STD_VER >= 11
{
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(2) == 2);
assert(c.size() == 4);
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(2) == 0);
assert(c.size() == 4);
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(4) == 1);
assert(c.size() == 3);
k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(4) == 0);
assert(c.size() == 3);
k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(1) == 2);
assert(c.size() == 1);
k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(1) == 0);
assert(c.size() == 1);
k = eq.first;
assert(k->first == 3);
assert(k->second == "three");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(3) == 1);
assert(c.size() == 0);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 0);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.erase(3) == 0);
assert(c.size() == 0);
eq = c.equal_range(3);
assert(std::distance(eq.first, eq.second) == 0);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
}
{
typedef std::unordered_multimap<int, int> C;
#include <unordered_map>
#include <string>
#include <cassert>
+#include <cstddef>
#include "min_allocator.h"
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
k = c.erase(i, j);
assert(c.size() == 4);
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
k = c.erase(c.cbegin(), c.cend());
assert(c.size() == 0);
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
k = c.erase(i, j);
assert(c.size() == 4);
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
k = c.erase(c.cbegin(), c.cend());
assert(c.size() == 0);
#include <unordered_map>
#include <string>
#include <cassert>
+#include <cstddef>
#include "test_iterators.h"
#include "min_allocator.h"
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
}
#if TEST_STD_VER >= 11
{
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
}
#endif
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
#include <unordered_map>
#include <string>
#include <cassert>
+#include <cstddef>
#include "test_iterators.h"
#include "min_allocator.h"
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
}
#if TEST_STD_VER >= 11
{
k = eq.first;
assert(k->first == 4);
assert(k->second == "four");
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
}
#endif
}
#include <unordered_map>
#include <string>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#if TEST_STD_VER >= 11
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#endif
#include <unordered_set>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "min_allocator.h"
C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::iterator i;
}
{
const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::const_iterator i;
}
#if TEST_STD_VER >= 11
C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::iterator i;
}
{
const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 7);
assert(c.size() == 6);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::const_iterator i;
}
#endif
#include <unordered_set>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "../../test_compare.h"
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#if TEST_STD_VER >= 11
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#endif
#include <unordered_set>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(4));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <unordered_set>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "../../../test_compare.h"
#include "../../../test_hash.h"
assert(c.count(2) == 2);
assert(c.count(3) == 1);
assert(c.count(4) == 1);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.count(2) == 2);
assert(c.count(3) == 1);
assert(c.count(4) == 1);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <unordered_set>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(4));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == other_allocator<int>(-2));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(5));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <unordered_set>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() == a);
assert(!(c.get_allocator() == A()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() == a);
assert(!(c.get_allocator() == A()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10));
assert(c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(12));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
#include <unordered_set>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() == a);
assert(!(c.get_allocator() == A()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() == a);
assert(!(c.get_allocator() == A()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <unordered_set>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#if TEST_STD_VER >= 11
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 6);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#endif
#include <unordered_set>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "min_allocator.h"
C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 5);
assert(c.size() == 4);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::iterator i;
}
{
const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 5);
assert(c.size() == 4);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::const_iterator i;
}
#if TEST_STD_VER >= 11
C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 5);
assert(c.size() == 4);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::iterator i;
}
{
const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() >= 5);
assert(c.size() == 4);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
C::const_iterator i;
}
#endif
#include <unordered_set>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "../../test_compare.h"
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#if TEST_STD_VER >= 11
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#endif
#include <unordered_set>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(4));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <unordered_set>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "../../../test_compare.h"
#include "../../../test_hash.h"
assert(c.count(2) == 1);
assert(c.count(3) == 1);
assert(c.count(4) == 1);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.count(2) == 1);
assert(c.count(3) == 1);
assert(c.count(4) == 1);
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <unordered_set>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(4));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == other_allocator<int>(-2));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(5));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <unordered_set>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() == a);
assert(!(c.get_allocator() == A()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() == a);
assert(!(c.get_allocator() == A()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10));
assert(c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "../../../test_compare.h"
#include "../../../test_hash.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(12));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
#include <unordered_set>
#include <cassert>
#include <cfloat>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() == a);
assert(!(c.get_allocator() == A()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.get_allocator() == a);
assert(!(c.get_allocator() == A()));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <cassert>
#include <cfloat>
#include <cmath>
+#include <cstddef>
#include "test_macros.h"
#include "test_iterators.h"
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10));
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty());
- assert(std::distance(c.begin(), c.end()) == c.size());
- assert(std::distance(c.cbegin(), c.cend()) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+ assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
assert(c.max_load_factor() == 1);
}
#include <unordered_set>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "../../../test_compare.h"
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2));
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1));
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#if TEST_STD_VER >= 11
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
{
assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc());
- assert(std::distance(c1.begin(), c1.end()) == c1.size());
- assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+ assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() >= 4);
assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc());
- assert(std::distance(c2.begin(), c2.end()) == c2.size());
- assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+ assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1);
}
#endif
#include <string>
#include <iterator>
#include <cassert>
+#include <cstddef>
#include "test_macros.h"
#include "test_allocator.h"
typedef typename S::allocator_type A;
S s2(first, last);
LIBCPP_ASSERT(s2.__invariants());
- assert(s2.size() == std::distance(first, last));
+ assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
unsigned i = 0;
for (It it = first; it != last; ++it, ++i)
assert(s2[i] == *it);
typedef typename S::traits_type T;
S s2(first, last, a);
LIBCPP_ASSERT(s2.__invariants());
- assert(s2.size() == std::distance(first, last));
+ assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
unsigned i = 0;
for (It it = first; it != last; ++it, ++i)
assert(s2[i] == *it);