coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-04-30 19:09:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Added std::is_sorted checks to all map/set tests

Browse Source
This commit is contained in:
John Wellbelove 2026-03-01 11:08:48 +00:00
parent 3a9308a4a0
commit 398ef49124
4 changed files with 207 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
test/test_map.cpp
View File

@ -49,8 +49,8 @@ using Data = etl::map<std::string, int, MAX_SIZE, std::greater<std::stri
using IData = etl::imap<std::string, int, std::greater<std::string>>;
using Compare_Data = std::map<std::string, int, std::greater<std::string>>;
#else
using Data = etl::map<std::string, int, MAX_SIZE, std::less<std::string>>;
using IData = etl::imap<std::string, int, std::less<std::string>>;
using Data = etl::map<std::string, int, MAX_SIZE, std::less<std::string>>;
using IData = etl::imap<std::string, int, std::less<std::string>>;
using Compare_Data = std::map<std::string, int, std::less<std::string>>;
#endif
@ -233,6 +233,8 @@ namespace
CHECK_EQUAL(10U, data.capacity());
CHECK_EQUAL(10U, data.max_size());
CHECK(data == check);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
#endif
@ -257,6 +259,8 @@ namespace
data2.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
}
//*************************************************************************
@ -281,6 +285,8 @@ namespace
CHECK(2 == data2.at("2").value);
CHECK(3 == data2.at("3").value);
CHECK(4 == data2.at("4").value);
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
}
//*************************************************************************
@ -304,6 +310,7 @@ namespace
CHECK(d == MAX_SIZE);
CHECK(data.size() == MAX_SIZE);
CHECK(!data.empty());
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
#if ETL_HAS_INITIALIZER_LIST
@ -324,6 +331,8 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
#endif
@ -340,6 +349,8 @@ namespace
otherData.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(otherData.begin(), otherData.end(), data.value_comp()));
}
//*************************************************************************
@ -358,6 +369,8 @@ namespace
data2.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
}
//*************************************************************************
@ -399,6 +412,8 @@ namespace
CHECK(2 == data2.at("2").value);
CHECK(3 == data2.at("3").value);
CHECK(4 == data2.at("4").value);
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
}
//*************************************************************************
@ -633,6 +648,8 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -655,6 +672,8 @@ namespace
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -679,6 +698,8 @@ namespace
CHECK(2 == data.at("2").value);
CHECK(3 == data.at("3").value);
CHECK(4 == data.at("4").value);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -704,6 +725,8 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -723,18 +746,20 @@ namespace
// Check that elements in map are the same
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
data.insert(data_result.first, ETL_OR_STD::make_pair(std::string("1"), 1));
compare_data.insert(compare_result.first, ETL_OR_STD::make_pair(std::string("1"), 1));
isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -754,8 +779,8 @@ namespace
// Check that elements in map are the same
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
data.insert(Data::const_iterator(data_result.first),
@ -764,10 +789,12 @@ namespace
ETL_OR_STD::make_pair(std::string("1"), 1));
isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -792,6 +819,8 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -804,10 +833,12 @@ namespace
compare_data.insert(random_data.begin(), random_data.end());
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -887,8 +918,8 @@ namespace
CHECK(data_result.second->second == compare_result.second->second);
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
}
@ -932,6 +963,8 @@ namespace
bool isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -949,6 +982,8 @@ namespace
bool isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -973,6 +1008,8 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -993,10 +1030,12 @@ namespace
CHECK(i_compare1->second == i_data1->second);
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -1024,6 +1063,8 @@ namespace
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -1048,9 +1089,11 @@ namespace
data.erase(i_data, i_data_end);
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -1576,7 +1619,7 @@ namespace
#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST && !defined(ETL_TEMPLATE_DEDUCTION_GUIDE_TESTS_DISABLED)
TEST_FIXTURE(SetupFixture, test_map_template_deduction)
{
using Pair = std::pair<const etl::string<1>, int>;
using Pair = std::pair<const std::string, int>;
etl::map data { Pair{"0", 0}, Pair{"1", 1}, Pair{"2", 2}, Pair{"3", 3}, Pair{"4", 4}, Pair{"5", 5} };
@ -1590,6 +1633,8 @@ namespace
CHECK_EQUAL(3, data.at("3"));
CHECK_EQUAL(4, data.at("4"));
CHECK_EQUAL(5, data.at("5"));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
#endif
@ -1597,9 +1642,9 @@ namespace
#if ETL_HAS_INITIALIZER_LIST
TEST_FIXTURE(SetupFixture, test_make_map)
{
using Pair = ETL_OR_STD::pair<const etl::string<1>, int>;
using Pair = ETL_OR_STD::pair<const std::string, int>;
auto data = etl::make_map<const etl::string<1>, int, std::less<etl::string<1>>>(Pair{ "0", 0 }, Pair{ "1", 1 }, Pair{ "2", 2 }, Pair{ "3", 3 }, Pair{ "4", 4 }, Pair{ "5", 5 });
auto data = etl::make_map<const std::string, int, std::less<std::string>>(Pair{ "0", 0 }, Pair{ "1", 1 }, Pair{ "2", 2 }, Pair{ "3", 3 }, Pair{ "4", 4 }, Pair{ "5", 5 });
auto v = *data.begin();
using Type = decltype(v);
@ -1611,6 +1656,8 @@ namespace
CHECK_EQUAL(3, data.at("3"));
CHECK_EQUAL(4, data.at("4"));
CHECK_EQUAL(5, data.at("5"));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
#endif
@ -1657,8 +1704,14 @@ namespace
const std::vector<element> actual(data.begin(), data.end());
CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
CHECK_TRUE((std::equal(data.begin(), data.end(), expected.begin())));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
auto compare = [](const etl::map<int, int, 8>::value_type& lhs, const etl::map<int, int, 8>::value_type& rhs)
{
return (lhs.first == rhs.first) && (lhs.second == rhs.second);
};
CHECK_TRUE((std::equal(data.begin(), data.end(), expected.begin(), compare)));
} while (std::next_permutation(permutation.begin(), permutation.end()));
}

106
test/test_multimap.cpp
View File

@ -47,20 +47,10 @@ static const size_t MAX_SIZE = 10UL;
using Data = etl::multimap<std::string, int, MAX_SIZE, std::greater<std::string>>;
using IData = etl::imultimap<std::string, int, std::greater<std::string>>;
using Compare_Data = std::multimap<std::string, int, std::greater<std::string>>;
auto key_comparator = [](const auto& lhs, const auto& rhs)
{
return std::greater<>{}(lhs.first, rhs.first);
};
#else
using Data = etl::multimap<std::string, int, MAX_SIZE, std::less<std::string>>;
using IData = etl::imultimap<std::string, int, std::less<std::string>>;
using Compare_Data = std::multimap<std::string, int, std::less<std::string>>;
auto key_comparator = [](const auto& lhs, const auto& rhs)
{
return std::less<>{}(lhs.first, rhs.first);
};
#endif
using ItemM = TestDataM<int>;
@ -244,7 +234,7 @@ namespace
CHECK_EQUAL(10U, data.capacity());
CHECK_EQUAL(10U, data.max_size());
CHECK(data == check);
CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
#endif
@ -269,7 +259,7 @@ namespace
data2.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
}
//*************************************************************************
@ -313,7 +303,7 @@ namespace
result = itr->second.value;
CHECK_EQUAL(4, result);
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end()));
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
}
//*************************************************************************
@ -354,7 +344,7 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
#endif
@ -389,7 +379,7 @@ namespace
data2.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
}
//*************************************************************************
@ -450,7 +440,7 @@ namespace
result = itr->second.value;
CHECK_EQUAL(4, result);
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end()));
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
}
//*************************************************************************
@ -506,7 +496,7 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -573,7 +563,7 @@ namespace
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -593,19 +583,19 @@ namespace
// Check that elements in map are the same
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
data.insert(data_result, ETL_OR_STD::make_pair(std::string("1"), 1));
compare_data.insert(compare_result, ETL_OR_STD::make_pair(std::string("1"), 1));
isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -625,8 +615,8 @@ namespace
// Check that elements in map are the same
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
data.insert(Data::const_iterator(data_result),
@ -635,11 +625,11 @@ namespace
ETL_OR_STD::make_pair(std::string("1"), 1));
isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -664,7 +654,7 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -677,8 +667,8 @@ namespace
compare_data.insert(random_data.begin(), random_data.end());
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
}
@ -753,8 +743,8 @@ namespace
CHECK(compare_result.second->second == data_result.second->second);
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
}
@ -779,8 +769,8 @@ namespace
CHECK(compare_result.second->second == data_result.second->second);
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
}
@ -812,11 +802,11 @@ namespace
CHECK(compare_count == data_count);
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -849,11 +839,12 @@ namespace
CHECK(compare_count == data_count);
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -875,7 +866,7 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -896,11 +887,11 @@ namespace
CHECK(i_compare1->second == i_data1->second);
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -928,7 +919,7 @@ namespace
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -941,10 +932,10 @@ namespace
data.erase(data.cbegin(), data.cend());
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -1651,7 +1642,8 @@ namespace
}
CHECK(pass);
CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
//*************************************************************************
@ -1680,7 +1672,7 @@ namespace
++itr;
CHECK_EQUAL(5, itr->second);
CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
#endif
@ -1710,7 +1702,7 @@ namespace
++itr;
CHECK_EQUAL(5, itr->second);
CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
}
#endif
@ -1749,8 +1741,14 @@ namespace
const std::vector<element> actual(data.begin(), data.end());
CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
CHECK_TRUE((std::equal(data.begin(), data.end(), expected.begin())));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
auto compare = [](const etl::multimap<int, int, 8>::value_type& lhs, const etl::multimap<int, int, 8>::value_type& rhs)
{
return (lhs.first == rhs.first) && (lhs.second == rhs.second);
};
CHECK_TRUE((std::equal(data.begin(), data.end(), expected.begin(), compare)));
} while (std::next_permutation(permutation.begin(), permutation.end()));
}

20
test/test_multiset.cpp
View File

@ -536,16 +536,16 @@ namespace
// Check that elements in multiset are the same
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
data.insert(data_result, 1);
compare_data.insert(compare_result, 1);
isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
@ -615,8 +615,8 @@ namespace
compare_data.insert(random_data.begin(), random_data.end());
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
@ -799,8 +799,8 @@ namespace
CHECK_EQUAL(*i_compare1, *i_data1);
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
@ -844,8 +844,8 @@ namespace
data.erase(data.cbegin(), data.cend());
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));

124
test/test_set.cpp
View File

@ -204,6 +204,7 @@ namespace
CHECK_EQUAL(10U, data.capacity());
CHECK_EQUAL(10U, data.max_size());
CHECK(data == check);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
#endif
@ -228,6 +229,8 @@ namespace
data2.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.key_comp()));
}
//*************************************************************************
@ -252,6 +255,8 @@ namespace
CHECK(data2.find(ItemM(2)) != data2.end());
CHECK(data2.find(ItemM(3)) != data2.end());
CHECK(data2.find(ItemM(4)) != data2.end());
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.key_comp()));
}
//*************************************************************************
@ -275,6 +280,8 @@ namespace
bool isEqual = std::equal(data.begin(), data.end(), compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
#if ETL_HAS_INITIALIZER_LIST
@ -290,6 +297,8 @@ namespace
bool isEqual = std::equal(data.begin(), data.end(), compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
#endif
@ -306,6 +315,8 @@ namespace
otherData.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(otherData.begin(), otherData.end(), otherData.key_comp()));
}
//*************************************************************************
@ -324,6 +335,8 @@ namespace
data2.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.key_comp()));
}
//*************************************************************************
@ -341,6 +354,8 @@ namespace
otherData.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -363,6 +378,8 @@ namespace
data2 = std::move(data1);
CHECK(!data1.empty()); // Move does not clear the source.
CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.key_comp()));
}
//*************************************************************************
@ -418,6 +435,8 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -464,6 +483,8 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -480,18 +501,20 @@ namespace
// Check that elements in set are the same
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
data.insert(data_result.first, 1);
compare_data.insert(compare_result.first, 1);
isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -510,18 +533,20 @@ namespace
// Check that elements in set are the same
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
data.insert(data_result.first, 1);
compare_data.insert(compare_result.first, 1);
isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -546,6 +571,8 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -558,10 +585,12 @@ namespace
compare_data.insert(random_data.begin(), random_data.end());
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -594,6 +623,8 @@ namespace
CHECK_EQUAL(2, data.find(ItemM(2))->value);
CHECK_EQUAL(3, data.find(ItemM(3))->value);
CHECK_EQUAL(4, data.find(ItemM(4))->value);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -634,46 +665,9 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
////*************************************************************************
//TEST_FIXTURE(SetupFixture, test_emplace_value)
//{
// Compare_Data compare_data;
// Data data;
// ETL_OR_STD::pair<Data::iterator, bool> data_result = data.emplace(0);
// ETL_OR_STD::pair<Compare_Data::iterator, bool> compare_result = compare_data.emplace(0);
// // Check that both return successful return results
// CHECK_EQUAL(*data_result.first, *compare_result.first);
// // Try adding a duplicate (should return iterator pointing to duplicate)
// data_result = data.insert(0);
// compare_result = compare_data.insert(0);
// // Check that both return successful return results
// CHECK_EQUAL(*data_result.first, *compare_result.first);
// // Check that elements in set are the same
// bool isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
// CHECK(isEqual);
// data.insert(2);
// compare_data.insert(2);
// isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
// CHECK(isEqual);
// data.insert(1);
// compare_data.insert(1);
// isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
// CHECK(isEqual);
//}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_equal_range)
{
@ -693,6 +687,8 @@ namespace
bool isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -711,10 +707,12 @@ namespace
CHECK_EQUAL(*data_result.second, *compare_result.second);
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -729,6 +727,8 @@ namespace
bool isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -746,6 +746,8 @@ namespace
bool isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -770,6 +772,8 @@ namespace
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -790,10 +794,12 @@ namespace
CHECK_EQUAL(*i_compare1, *i_data1);
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -821,6 +827,8 @@ namespace
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -845,9 +853,11 @@ namespace
data.erase(i_data, i_data_end);
bool isEqual = Check_Equal(data.begin(),
data.end(),
compare_data.begin());
data.end(),
compare_data.begin());
CHECK(isEqual);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
//*************************************************************************
@ -1417,6 +1427,8 @@ namespace
CHECK_EQUAL("E", *itr);
++itr;
CHECK_EQUAL("F", *itr);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
#endif
@ -1443,6 +1455,8 @@ namespace
CHECK_EQUAL("E", *itr);
++itr;
CHECK_EQUAL("F", *itr);
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
}
#endif
@ -1487,7 +1501,7 @@ namespace
auto it = data.find(2);
data.erase(it);
CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
CHECK_TRUE((std::equal(data.begin(), data.end(), expected.begin())));
} while (std::next_permutation(permutation.begin(), permutation.end()));