mirror of https://gitee.com/bigwinds/arangodb
741 lines
17 KiB
C++
741 lines
17 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite for HashSet class
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2004-2012 triagens GmbH, Cologne, Germany
|
|
///
|
|
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|
/// you may not use this file except in compliance with the License.
|
|
/// You may obtain a copy of the License at
|
|
///
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
/// Unless required by applicable law or agreed to in writing, software
|
|
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
/// See the License for the specific language governing permissions and
|
|
/// limitations under the License.
|
|
///
|
|
/// Copyright holder is triAGENS GmbH, Cologne, Germany
|
|
///
|
|
/// @author Jan Steemann
|
|
/// @author Copyright 2007-2012, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "Basics/Common.h"
|
|
#include "Basics/HashSet.h"
|
|
|
|
#include "catch.hpp"
|
|
|
|
TEST_CASE("HashSetTest", "[HashSet]") {
|
|
|
|
/// @brief test size
|
|
SECTION("test_size") {
|
|
arangodb::HashSet<size_t> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (size_t i = 0; i < 1000; ++i) {
|
|
CHECK(values.size() == i);
|
|
values.insert(i);
|
|
CHECK(values.size() == i + 1);
|
|
CHECK(!values.empty());
|
|
}
|
|
|
|
// insert same values again
|
|
for (size_t i = 0; i < 1000; ++i) {
|
|
CHECK(values.size() == 1000);
|
|
values.insert(i);
|
|
CHECK(values.size() == 1000);
|
|
CHECK(!values.empty());
|
|
}
|
|
|
|
for (size_t i = 0; i < 1000; ++i) {
|
|
CHECK(values.size() == 1000 - i);
|
|
CHECK(!values.empty());
|
|
values.erase(i);
|
|
CHECK(values.size() == 999 - i);
|
|
}
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (size_t i = 0; i < 1000; ++i) {
|
|
CHECK(values.size() == i);
|
|
values.insert(i);
|
|
CHECK(values.size() == i + 1);
|
|
CHECK(!values.empty());
|
|
}
|
|
|
|
values.clear();
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
}
|
|
|
|
/// @brief test with int
|
|
SECTION("test_int") {
|
|
arangodb::HashSet<int> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.size() == i);
|
|
values.insert(i);
|
|
CHECK(values.size() == i + 1);
|
|
CHECK(!values.empty());
|
|
}
|
|
|
|
CHECK(values.size() == 100);
|
|
CHECK(!values.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(i) != values.end());
|
|
}
|
|
|
|
CHECK(values.find(123) == values.end());
|
|
CHECK(values.find(999) == values.end());
|
|
CHECK(values.find(100) == values.end());
|
|
CHECK(values.find(-1) == values.end());
|
|
}
|
|
|
|
/// @brief test with std::string
|
|
SECTION("test_string") {
|
|
arangodb::HashSet<std::string> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (size_t i = 0; i < 100; ++i) {
|
|
CHECK(values.size() == i);
|
|
values.insert(std::string("test") + std::to_string(i));
|
|
CHECK(values.size() == i + 1);
|
|
CHECK(!values.empty());
|
|
}
|
|
|
|
CHECK(values.size() == 100);
|
|
CHECK(!values.empty());
|
|
|
|
for (size_t i = 0; i < 100; ++i) {
|
|
std::string value = std::string("test") + std::to_string(i);
|
|
CHECK(values.find(value) != values.end());
|
|
}
|
|
|
|
CHECK(values.find(std::string("test")) == values.end());
|
|
CHECK(values.find(std::string("foo")) == values.end());
|
|
CHECK(values.find(std::string("test100")) == values.end());
|
|
CHECK(values.find(std::string("")) == values.end());
|
|
}
|
|
|
|
/// @brief test with std::string
|
|
SECTION("test_long_string") {
|
|
arangodb::HashSet<std::string> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (size_t i = 0; i < 100; ++i) {
|
|
CHECK(values.size() == i);
|
|
values.insert(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i));
|
|
CHECK(values.size() == i + 1);
|
|
CHECK(!values.empty());
|
|
}
|
|
|
|
CHECK(values.size() == 100);
|
|
CHECK(!values.empty());
|
|
|
|
for (size_t i = 0; i < 100; ++i) {
|
|
std::string value = std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i);
|
|
CHECK(values.find(value) != values.end());
|
|
}
|
|
|
|
CHECK(values.find(std::string("test")) == values.end());
|
|
CHECK(values.find(std::string("foo")) == values.end());
|
|
CHECK(values.find(std::string("test100")) == values.end());
|
|
CHECK(values.find(std::string("")) == values.end());
|
|
}
|
|
|
|
/// @brief test with std::string
|
|
SECTION("test_string_duplicates") {
|
|
arangodb::HashSet<std::string> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (size_t i = 0; i < 100; ++i) {
|
|
CHECK(values.size() == i);
|
|
auto res = values.emplace(std::string("test") + std::to_string(i));
|
|
CHECK(res.first != values.end());
|
|
CHECK(res.second);
|
|
CHECK(values.size() == i + 1);
|
|
CHECK(!values.empty());
|
|
}
|
|
|
|
CHECK(values.size() == 100);
|
|
CHECK(!values.empty());
|
|
|
|
for (size_t i = 0; i < 100; ++i) {
|
|
CHECK(values.size() == 100);
|
|
auto res = values.emplace(std::string("test") + std::to_string(i));
|
|
CHECK(res.first != values.end());
|
|
CHECK(!res.second);
|
|
CHECK(values.size() == 100);
|
|
CHECK(!values.empty());
|
|
}
|
|
|
|
for (size_t i = 0; i < 100; ++i) {
|
|
std::string value = std::string("test") + std::to_string(i);
|
|
CHECK(values.find(value) != values.end());
|
|
}
|
|
|
|
CHECK(values.find(std::string("test")) == values.end());
|
|
CHECK(values.find(std::string("foo")) == values.end());
|
|
CHECK(values.find(std::string("test100")) == values.end());
|
|
CHECK(values.find(std::string("")) == values.end());
|
|
}
|
|
|
|
/// @brief test erase
|
|
SECTION("test_erase") {
|
|
arangodb::HashSet<int> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
CHECK(values.erase(1234) == 0);
|
|
CHECK(values.erase(0) == 0);
|
|
|
|
for (int i = 0; i < 1000; ++i) {
|
|
values.insert(i);
|
|
}
|
|
|
|
CHECK(values.erase(1234) == 0);
|
|
CHECK(values.erase(0) == 1);
|
|
|
|
CHECK(values.find(0) == values.end());
|
|
for (int i = 1; i < 100; ++i) {
|
|
CHECK(values.find(i) != values.end());
|
|
CHECK(values.erase(i) == 1);
|
|
CHECK(values.find(i) == values.end());
|
|
}
|
|
|
|
CHECK(values.size() == 900);
|
|
|
|
for (int i = 100; i < 1000; ++i) {
|
|
CHECK(values.find(i) != values.end());
|
|
CHECK(values.erase(i) == 1);
|
|
CHECK(values.find(i) == values.end());
|
|
}
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
}
|
|
|
|
/// @brief test reserve
|
|
SECTION("test_reserve") {
|
|
arangodb::HashSet<size_t> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
values.reserve(10000);
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (size_t i = 0; i < 32; ++i) {
|
|
values.insert(i);
|
|
}
|
|
|
|
CHECK(values.size() == 32);
|
|
CHECK(!values.empty());
|
|
|
|
values.reserve(10);
|
|
CHECK(values.size() == 32);
|
|
CHECK(!values.empty());
|
|
|
|
values.reserve(20000);
|
|
CHECK(values.size() == 32);
|
|
CHECK(!values.empty());
|
|
|
|
for (size_t i = 0; i < 32; ++i) {
|
|
CHECK(values.find(i) != values.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test few values
|
|
SECTION("test_few") {
|
|
arangodb::HashSet<size_t> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (size_t i = 0; i < 32; ++i) {
|
|
CHECK(values.size() == i);
|
|
values.insert(i);
|
|
CHECK(values.size() == i + 1);
|
|
CHECK(!values.empty());
|
|
}
|
|
|
|
CHECK(values.size() == 32);
|
|
CHECK(!values.empty());
|
|
|
|
for (size_t i = 0; i < 32; ++i) {
|
|
CHECK(values.find(i) != values.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test many values
|
|
SECTION("test_many") {
|
|
arangodb::HashSet<size_t> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (size_t i = 0; i < 200000; ++i) {
|
|
CHECK(values.size() == i);
|
|
values.insert(i);
|
|
CHECK(values.size() == i + 1);
|
|
CHECK(!values.empty());
|
|
}
|
|
|
|
CHECK(values.size() == 200000);
|
|
CHECK(!values.empty());
|
|
|
|
for (size_t i = 0; i < 200000; ++i) {
|
|
CHECK(values.find(i) != values.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test copying
|
|
SECTION("test_copy_construct_local") {
|
|
arangodb::HashSet<int> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
values.insert(i);
|
|
}
|
|
|
|
// copy
|
|
arangodb::HashSet<int> copy(values);
|
|
|
|
CHECK(values.size() == 2);
|
|
CHECK(!values.empty());
|
|
|
|
CHECK(copy.size() == 2);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
CHECK(values.find(i) != values.end());
|
|
CHECK(copy.find(i) != copy.end());
|
|
}
|
|
|
|
values.clear();
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
CHECK(copy.size() == 2);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
CHECK(values.find(i) == values.end());
|
|
CHECK(copy.find(i) != copy.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test copying
|
|
SECTION("test_copy_construct_heap") {
|
|
arangodb::HashSet<int> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
values.insert(i);
|
|
}
|
|
|
|
// copy
|
|
arangodb::HashSet<int> copy(values);
|
|
|
|
CHECK(values.size() == 100);
|
|
CHECK(!values.empty());
|
|
|
|
CHECK(copy.size() == 100);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(i) != values.end());
|
|
CHECK(copy.find(i) != copy.end());
|
|
}
|
|
|
|
values.clear();
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
CHECK(copy.size() == 100);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(i) == values.end());
|
|
CHECK(copy.find(i) != copy.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test copying
|
|
SECTION("test_copy_construct_heap_huge") {
|
|
arangodb::HashSet<std::string> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
values.insert(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i));
|
|
}
|
|
|
|
// copy
|
|
arangodb::HashSet<std::string> copy(values);
|
|
|
|
CHECK(values.size() == 100);
|
|
CHECK(!values.empty());
|
|
|
|
CHECK(copy.size() == 100);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i)) != values.end());
|
|
CHECK(copy.find(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i)) != copy.end());
|
|
}
|
|
|
|
values.clear();
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
CHECK(copy.size() == 100);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i)) == values.end());
|
|
CHECK(copy.find(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i)) != copy.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test copying
|
|
SECTION("test_copy_assign_local") {
|
|
arangodb::HashSet<int> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
values.insert(i);
|
|
}
|
|
|
|
// copy
|
|
arangodb::HashSet<int> copy = values;
|
|
|
|
CHECK(values.size() == 2);
|
|
CHECK(!values.empty());
|
|
|
|
CHECK(copy.size() == 2);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
CHECK(values.find(i) != values.end());
|
|
CHECK(copy.find(i) != copy.end());
|
|
}
|
|
|
|
values.clear();
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
CHECK(copy.size() == 2);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
CHECK(values.find(i) == values.end());
|
|
CHECK(copy.find(i) != copy.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test copying
|
|
SECTION("test_copy_assign_heap") {
|
|
arangodb::HashSet<int> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
values.insert(i);
|
|
}
|
|
|
|
// copy
|
|
arangodb::HashSet<int> copy = values;
|
|
|
|
CHECK(values.size() == 100);
|
|
CHECK(!values.empty());
|
|
|
|
CHECK(copy.size() == 100);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(i) != values.end());
|
|
CHECK(copy.find(i) != copy.end());
|
|
}
|
|
|
|
values.clear();
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
CHECK(copy.size() == 100);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(i) == values.end());
|
|
CHECK(copy.find(i) != copy.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test copying
|
|
SECTION("test_copy_assign_heap_huge") {
|
|
arangodb::HashSet<std::string> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
values.insert(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i));
|
|
}
|
|
|
|
// copy
|
|
arangodb::HashSet<std::string> copy = values;
|
|
|
|
CHECK(values.size() == 100);
|
|
CHECK(!values.empty());
|
|
|
|
CHECK(copy.size() == 100);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i)) != values.end());
|
|
CHECK(copy.find(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i)) != copy.end());
|
|
}
|
|
|
|
values.clear();
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
CHECK(copy.size() == 100);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i)) == values.end());
|
|
CHECK(copy.find(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i)) != copy.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test moving
|
|
SECTION("test_move_construct_local") {
|
|
arangodb::HashSet<int> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
values.insert(i);
|
|
}
|
|
|
|
// move
|
|
arangodb::HashSet<int> copy(std::move(values));
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
CHECK(copy.size() == 2);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
CHECK(values.find(i) == values.end());
|
|
CHECK(copy.find(i) != copy.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test moving
|
|
SECTION("test_move_construct_heap") {
|
|
arangodb::HashSet<int> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
values.insert(i);
|
|
}
|
|
|
|
// move
|
|
arangodb::HashSet<int> copy(std::move(values));
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
CHECK(copy.size() == 100);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(i) == values.end());
|
|
CHECK(copy.find(i) != copy.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test moving
|
|
SECTION("test_move_construct_heap_huge") {
|
|
arangodb::HashSet<std::string> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
values.insert(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i));
|
|
}
|
|
|
|
// move
|
|
arangodb::HashSet<std::string> copy(std::move(values));
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
CHECK(copy.size() == 100);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i)) == values.end());
|
|
CHECK(copy.find(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i)) != copy.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test moving
|
|
SECTION("test_move_assign_local") {
|
|
arangodb::HashSet<int> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
values.insert(i);
|
|
}
|
|
|
|
// move
|
|
arangodb::HashSet<int> copy = std::move(values);
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
CHECK(copy.size() == 2);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
CHECK(values.find(i) == values.end());
|
|
CHECK(copy.find(i) != copy.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test moving
|
|
SECTION("test_move_assign_heap") {
|
|
arangodb::HashSet<int> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
values.insert(i);
|
|
}
|
|
|
|
// move
|
|
arangodb::HashSet<int> copy = std::move(values);
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
CHECK(copy.size() == 100);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(i) == values.end());
|
|
CHECK(copy.find(i) != copy.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test moving
|
|
SECTION("test_move_assign_heap_huge") {
|
|
arangodb::HashSet<std::string> values;
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
values.insert(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i));
|
|
}
|
|
|
|
// move
|
|
arangodb::HashSet<std::string> copy = std::move(values);
|
|
|
|
CHECK(values.size() == 0);
|
|
CHECK(values.empty());
|
|
|
|
CHECK(copy.size() == 100);
|
|
CHECK(!copy.empty());
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
CHECK(values.find(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i)) == values.end());
|
|
CHECK(copy.find(std::string("test-this-will-hopefully-disable-sso-everywhere") + std::to_string(i)) != copy.end());
|
|
}
|
|
}
|
|
|
|
/// @brief test iterator
|
|
SECTION("test_iterator") {
|
|
arangodb::HashSet<int> values;
|
|
|
|
CHECK(values.begin() == values.end());
|
|
|
|
for (int i = 0; i < 1000; ++i) {
|
|
values.insert(i);
|
|
CHECK(values.begin() != values.end());
|
|
CHECK(values.find(i) != values.end());
|
|
CHECK(values.find(i + 1000) == values.end());
|
|
}
|
|
|
|
size_t count;
|
|
|
|
count = 0;
|
|
for (auto const& it : values) {
|
|
CHECK(it >= 0);
|
|
CHECK(it < 1000);
|
|
++count;
|
|
}
|
|
CHECK(count == 1000);
|
|
|
|
count = 0;
|
|
for (auto it = values.begin(); it != values.end(); ++it) {
|
|
CHECK(it != values.end());
|
|
auto i = (*it);
|
|
CHECK(i >= 0);
|
|
CHECK(i < 1000);
|
|
++count;
|
|
}
|
|
CHECK(count == 1000);
|
|
|
|
count = 0;
|
|
for (auto it = values.cbegin(); it != values.cend(); ++it) {
|
|
CHECK(it != values.end());
|
|
auto i = (*it);
|
|
CHECK(i >= 0);
|
|
CHECK(i < 1000);
|
|
++count;
|
|
}
|
|
CHECK(count == 1000);
|
|
}
|
|
|
|
}
|