generic-library/cereal
1
0
Fork 0
mirror of https://github.com/USCiLab/cereal.git synced 2025-10-18 01:45:52 +02:00
Code Issues Projects Releases Wiki Activity

Unit tests for unordered_multimap

Browse Source
This commit is contained in:
Randolph Voorhies
2013-06-14 15:49:50 -07:00
parent 68ada7b613
commit 8a775ecdcb
1 changed files with 121 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
unittests.cpp
View File

@@ -1065,3 +1065,124 @@ BOOST_AUTO_TEST_CASE( binary_unordered_map )
}
}
}
// ######################################################################
BOOST_AUTO_TEST_CASE( binary_unordered_multimap )
{
std::random_device rd;
std::mt19937 gen(rd());
for(int i=0; i<100; ++i)
{
std::ostringstream os;
cereal::BinaryOutputArchive oar(os);
std::unordered_multimap<std::string, int> o_podunordered_multimap;
for(int j=0; j<100; ++j)
{
auto key = random_value<std::string>(gen);
o_podunordered_multimap.insert({key, random_value<int>(gen)});
o_podunordered_multimap.insert({key, random_value<int>(gen)});
}
std::unordered_multimap<double, StructInternalSerialize> o_iserunordered_multimap;
for(int j=0; j<100; ++j)
{
auto key = random_value<double>(gen);
o_iserunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
o_iserunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
}
std::unordered_multimap<float, StructInternalSplit> o_isplunordered_multimap;
for(int j=0; j<100; ++j)
{
auto key = random_value<float>(gen);
o_isplunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
o_isplunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
}
std::unordered_multimap<uint32_t, StructExternalSerialize> o_eserunordered_multimap;
for(int j=0; j<100; ++j)
{
auto key = random_value<uint32_t>(gen);
o_eserunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
o_eserunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
}
std::unordered_multimap<int8_t, StructExternalSplit> o_esplunordered_multimap;
for(int j=0; j<100; ++j)
{
auto key = random_value<char>(gen);
o_esplunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
o_esplunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
}
oar & o_podunordered_multimap;
oar & o_iserunordered_multimap;
oar & o_isplunordered_multimap;
oar & o_eserunordered_multimap;
oar & o_esplunordered_multimap;
std::istringstream is(os.str());
cereal::BinaryInputArchive iar(is);
std::unordered_multimap<std::string, int> i_podunordered_multimap;
std::unordered_multimap<double, StructInternalSerialize> i_iserunordered_multimap;
std::unordered_multimap<float, StructInternalSplit> i_isplunordered_multimap;
std::unordered_multimap<uint32_t, StructExternalSerialize> i_eserunordered_multimap;
std::unordered_multimap<int8_t, StructExternalSplit> i_esplunordered_multimap;
iar & i_podunordered_multimap;
iar & i_iserunordered_multimap;
iar & i_isplunordered_multimap;
iar & i_eserunordered_multimap;
iar & i_esplunordered_multimap;
BOOST_CHECK_EQUAL(i_podunordered_multimap.size(), o_podunordered_multimap.size());
BOOST_CHECK_EQUAL(i_iserunordered_multimap.size(), o_iserunordered_multimap.size());
BOOST_CHECK_EQUAL(i_isplunordered_multimap.size(), o_isplunordered_multimap.size());
BOOST_CHECK_EQUAL(i_eserunordered_multimap.size(), o_eserunordered_multimap.size());
BOOST_CHECK_EQUAL(i_esplunordered_multimap.size(), o_esplunordered_multimap.size());
for(auto const & p : i_podunordered_multimap)
{
size_t const bucket = o_podunordered_multimap.bucket(p.first);
auto bucket_begin = o_podunordered_multimap.begin(bucket);
auto bucket_end = o_podunordered_multimap.end(bucket);
BOOST_CHECK(std::find(bucket_begin, bucket_end, p) != bucket_end);
}
for(auto const & p : i_iserunordered_multimap)
{
size_t const bucket = o_iserunordered_multimap.bucket(p.first);
auto bucket_begin = o_iserunordered_multimap.begin(bucket);
auto bucket_end = o_iserunordered_multimap.end(bucket);
BOOST_CHECK(std::find(bucket_begin, bucket_end, p) != bucket_end);
}
for(auto const & p : i_isplunordered_multimap)
{
size_t const bucket = o_isplunordered_multimap.bucket(p.first);
auto bucket_begin = o_isplunordered_multimap.begin(bucket);
auto bucket_end = o_isplunordered_multimap.end(bucket);
BOOST_CHECK(std::find(bucket_begin, bucket_end, p) != bucket_end);
}
for(auto const & p : i_eserunordered_multimap)
{
size_t const bucket = o_eserunordered_multimap.bucket(p.first);
auto bucket_begin = o_eserunordered_multimap.begin(bucket);
auto bucket_end = o_eserunordered_multimap.end(bucket);
BOOST_CHECK(std::find(bucket_begin, bucket_end, p) != bucket_end);
}
for(auto const & p : i_esplunordered_multimap)
{
size_t const bucket = o_esplunordered_multimap.bucket(p.first);
auto bucket_begin = o_esplunordered_multimap.begin(bucket);
auto bucket_end = o_esplunordered_multimap.end(bucket);
BOOST_CHECK(std::find(bucket_begin, bucket_end, p) != bucket_end);
}
}
}