mirror of
https://github.com/textmate/textmate.git
synced 2026-02-14 16:34:57 -05:00
376 lines
11 KiB
C++
376 lines
11 KiB
C++
#include <buffer/indexed_map.h>
|
|
#include <oak/oak.h>
|
|
|
|
static ssize_t const TestKeys[5][3] =
|
|
{
|
|
{ 10, 20, 30 },
|
|
{ 20, 30, 40 },
|
|
{ 30, 40, 50 },
|
|
{ 40, 50, 60 },
|
|
{ 50, 60, 70 }
|
|
};
|
|
|
|
template <typename T>
|
|
void seed_map (T& map)
|
|
{
|
|
for(size_t i = 1; i < 6; ++i)
|
|
map.set(i, i);
|
|
}
|
|
|
|
template <typename T>
|
|
std::vector< std::pair<ssize_t, size_t> > values (T const& map)
|
|
{
|
|
return std::vector< std::pair<ssize_t, size_t> >(map.begin(), map.end());
|
|
}
|
|
|
|
struct value_pair
|
|
{
|
|
size_t first; ssize_t second;
|
|
};
|
|
|
|
template <int N>
|
|
std::vector< std::pair<ssize_t, size_t> > expected (value_pair(&array)[N])
|
|
{
|
|
std::vector< std::pair<ssize_t, size_t> > res;
|
|
iterate(pair, array)
|
|
res.push_back(std::make_pair(pair->first, pair->second));
|
|
return res;
|
|
}
|
|
|
|
class IndexedMapTests : public CxxTest::TestSuite
|
|
{
|
|
public:
|
|
void test_basic ()
|
|
{
|
|
indexed_map_t<bool> map;
|
|
|
|
std::set<ssize_t> tmp;
|
|
while(tmp.size() < 2000)
|
|
tmp.insert((random() & 0xFFFFFF) - 0x7FFFFF);
|
|
|
|
std::vector<ssize_t> keys(tmp.begin(), tmp.end());
|
|
std::random_shuffle(beginof(keys), endof(keys));
|
|
iterate(key, keys)
|
|
map.set(*key, true);
|
|
|
|
std::vector<ssize_t> sorted;
|
|
std::transform(map.begin(), map.end(), back_inserter(sorted), [](std::pair<ssize_t, bool> const& p){ return p.first; });
|
|
TS_ASSERT_EQUALS(tmp.size(), sorted.size());
|
|
TS_ASSERT(std::equal(tmp.begin(), tmp.end(), sorted.begin()));
|
|
|
|
std::random_shuffle(beginof(keys), endof(keys));
|
|
for(size_t i = keys.size() >> 1; i < keys.size(); ++i)
|
|
{
|
|
map.remove(keys[i]);
|
|
|
|
tmp.erase(keys[i]);
|
|
sorted.clear();
|
|
iterate(pair, map)
|
|
sorted.push_back(pair->first);
|
|
TS_ASSERT_EQUALS(tmp.size(), sorted.size());
|
|
TS_ASSERT(std::equal(tmp.begin(), tmp.end(), sorted.begin()));
|
|
}
|
|
keys.resize(keys.size() >> 1);
|
|
std::sort(keys.begin(), keys.end());
|
|
|
|
sorted.clear();
|
|
iterate(pair, map)
|
|
sorted.push_back(pair->first);
|
|
TS_ASSERT_EQUALS(keys.size(), sorted.size());
|
|
TS_ASSERT(std::equal(keys.begin(), keys.end(), sorted.begin()));
|
|
|
|
std::random_shuffle(beginof(sorted), endof(sorted));
|
|
iterate(key, sorted)
|
|
map.remove(*key);
|
|
TS_ASSERT(map.empty());
|
|
}
|
|
|
|
static void test_child_count ()
|
|
{
|
|
static ssize_t const TestKeys[] = { 10, 20, 30, 40, 50 };
|
|
std::vector<ssize_t> keys(beginof(TestKeys), endof(TestKeys));
|
|
do {
|
|
|
|
std::next_permutation(keys.begin(), keys.end());
|
|
indexed_map_t<bool> map;
|
|
iterate(key, keys)
|
|
map.set(*key, true);
|
|
|
|
TS_ASSERT_EQUALS(map.size(), 5);
|
|
|
|
TS_ASSERT_EQUALS(map.nth(0)->first, 10);
|
|
TS_ASSERT_EQUALS(map.nth(1)->first, 20);
|
|
TS_ASSERT_EQUALS(map.nth(2)->first, 30);
|
|
TS_ASSERT_EQUALS(map.nth(3)->first, 40);
|
|
TS_ASSERT_EQUALS(map.nth(4)->first, 50);
|
|
|
|
TS_ASSERT_EQUALS(map.nth(0).index(), 0);
|
|
TS_ASSERT_EQUALS(map.nth(1).index(), 1);
|
|
TS_ASSERT_EQUALS(map.nth(2).index(), 2);
|
|
TS_ASSERT_EQUALS(map.nth(3).index(), 3);
|
|
TS_ASSERT_EQUALS(map.nth(4).index(), 4);
|
|
|
|
TS_ASSERT_EQUALS(map.find(10).index(), 0);
|
|
TS_ASSERT_EQUALS(map.find(20).index(), 1);
|
|
TS_ASSERT_EQUALS(map.find(30).index(), 2);
|
|
TS_ASSERT_EQUALS(map.find(40).index(), 3);
|
|
TS_ASSERT_EQUALS(map.find(50).index(), 4);
|
|
|
|
map.remove(30);
|
|
|
|
TS_ASSERT_EQUALS(map.size(), 4);
|
|
|
|
TS_ASSERT_EQUALS(map.nth(0)->first, 10);
|
|
TS_ASSERT_EQUALS(map.nth(1)->first, 20);
|
|
TS_ASSERT_EQUALS(map.nth(2)->first, 40);
|
|
TS_ASSERT_EQUALS(map.nth(3)->first, 50);
|
|
|
|
TS_ASSERT_EQUALS(map.nth(0).index(), 0);
|
|
TS_ASSERT_EQUALS(map.nth(1).index(), 1);
|
|
TS_ASSERT_EQUALS(map.nth(2).index(), 2);
|
|
TS_ASSERT_EQUALS(map.nth(3).index(), 3);
|
|
|
|
TS_ASSERT_EQUALS(map.find(10).index(), 0);
|
|
TS_ASSERT_EQUALS(map.find(20).index(), 1);
|
|
TS_ASSERT_EQUALS(map.find(40).index(), 2);
|
|
TS_ASSERT_EQUALS(map.find(50).index(), 3);
|
|
|
|
} while(!std::equal(keys.begin(), keys.end(), beginof(TestKeys)));
|
|
}
|
|
|
|
static void test_find ()
|
|
{
|
|
static ssize_t const TestKeys[] = { 10, 20, 30, 40, 50 };
|
|
std::vector<ssize_t> keys(beginof(TestKeys), endof(TestKeys));
|
|
do {
|
|
|
|
std::next_permutation(keys.begin(), keys.end());
|
|
indexed_map_t<bool> map;
|
|
iterate(key, TestKeys)
|
|
map.set(*key, true);
|
|
|
|
TS_ASSERT_EQUALS(map.find(10-1).index(), 5);
|
|
TS_ASSERT_EQUALS(map.find(20-1).index(), 5);
|
|
TS_ASSERT_EQUALS(map.find(30-1).index(), 5);
|
|
TS_ASSERT_EQUALS(map.find(40-1).index(), 5);
|
|
TS_ASSERT_EQUALS(map.find(50-1).index(), 5);
|
|
|
|
TS_ASSERT_EQUALS(map.find(10).index(), 0);
|
|
TS_ASSERT_EQUALS(map.find(20).index(), 1);
|
|
TS_ASSERT_EQUALS(map.find(30).index(), 2);
|
|
TS_ASSERT_EQUALS(map.find(40).index(), 3);
|
|
TS_ASSERT_EQUALS(map.find(50).index(), 4);
|
|
|
|
TS_ASSERT_EQUALS(map.find(10+1).index(), 5);
|
|
TS_ASSERT_EQUALS(map.find(20+1).index(), 5);
|
|
TS_ASSERT_EQUALS(map.find(30+1).index(), 5);
|
|
TS_ASSERT_EQUALS(map.find(40+1).index(), 5);
|
|
TS_ASSERT_EQUALS(map.find(50+1).index(), 5);
|
|
|
|
} while(!std::equal(keys.begin(), keys.end(), beginof(TestKeys)));
|
|
}
|
|
|
|
static void test_lower_bound ()
|
|
{
|
|
static ssize_t const TestKeys[] = { 10, 20, 30, 40, 50 };
|
|
std::vector<ssize_t> keys(beginof(TestKeys), endof(TestKeys));
|
|
do {
|
|
|
|
std::next_permutation(keys.begin(), keys.end());
|
|
indexed_map_t<bool> map;
|
|
iterate(key, TestKeys)
|
|
map.set(*key, true);
|
|
|
|
TS_ASSERT_EQUALS(map.lower_bound(10-1).index(), 0);
|
|
TS_ASSERT_EQUALS(map.lower_bound(20-1).index(), 1);
|
|
TS_ASSERT_EQUALS(map.lower_bound(30-1).index(), 2);
|
|
TS_ASSERT_EQUALS(map.lower_bound(40-1).index(), 3);
|
|
TS_ASSERT_EQUALS(map.lower_bound(50-1).index(), 4);
|
|
|
|
TS_ASSERT_EQUALS(map.lower_bound(10).index(), 0);
|
|
TS_ASSERT_EQUALS(map.lower_bound(20).index(), 1);
|
|
TS_ASSERT_EQUALS(map.lower_bound(30).index(), 2);
|
|
TS_ASSERT_EQUALS(map.lower_bound(40).index(), 3);
|
|
TS_ASSERT_EQUALS(map.lower_bound(50).index(), 4);
|
|
|
|
TS_ASSERT_EQUALS(map.lower_bound(10+1).index(), 1);
|
|
TS_ASSERT_EQUALS(map.lower_bound(20+1).index(), 2);
|
|
TS_ASSERT_EQUALS(map.lower_bound(30+1).index(), 3);
|
|
TS_ASSERT_EQUALS(map.lower_bound(40+1).index(), 4);
|
|
TS_ASSERT_EQUALS(map.lower_bound(50+1).index(), 5);
|
|
|
|
} while(!std::equal(keys.begin(), keys.end(), beginof(TestKeys)));
|
|
}
|
|
|
|
static void test_upper_bound ()
|
|
{
|
|
static ssize_t const TestKeys[] = { 10, 20, 30, 40, 50 };
|
|
std::vector<ssize_t> keys(beginof(TestKeys), endof(TestKeys));
|
|
do {
|
|
|
|
std::next_permutation(keys.begin(), keys.end());
|
|
indexed_map_t<bool> map;
|
|
iterate(key, TestKeys)
|
|
map.set(*key, true);
|
|
|
|
TS_ASSERT_EQUALS(map.upper_bound(10-1).index(), 0);
|
|
TS_ASSERT_EQUALS(map.upper_bound(20-1).index(), 1);
|
|
TS_ASSERT_EQUALS(map.upper_bound(30-1).index(), 2);
|
|
TS_ASSERT_EQUALS(map.upper_bound(40-1).index(), 3);
|
|
TS_ASSERT_EQUALS(map.upper_bound(50-1).index(), 4);
|
|
|
|
TS_ASSERT_EQUALS(map.upper_bound(10).index(), 1);
|
|
TS_ASSERT_EQUALS(map.upper_bound(20).index(), 2);
|
|
TS_ASSERT_EQUALS(map.upper_bound(30).index(), 3);
|
|
TS_ASSERT_EQUALS(map.upper_bound(40).index(), 4);
|
|
TS_ASSERT_EQUALS(map.upper_bound(50).index(), 5);
|
|
|
|
TS_ASSERT_EQUALS(map.upper_bound(10+1).index(), 1);
|
|
TS_ASSERT_EQUALS(map.upper_bound(20+1).index(), 2);
|
|
TS_ASSERT_EQUALS(map.upper_bound(30+1).index(), 3);
|
|
TS_ASSERT_EQUALS(map.upper_bound(40+1).index(), 4);
|
|
TS_ASSERT_EQUALS(map.upper_bound(50+1).index(), 5);
|
|
|
|
} while(!std::equal(keys.begin(), keys.end(), beginof(TestKeys)));
|
|
}
|
|
|
|
void test_preserve ()
|
|
{
|
|
indexed_map_t<size_t> nonPreserveLeft;
|
|
seed_map(nonPreserveLeft);
|
|
nonPreserveLeft.replace(2, 4, 2, false /* bindRight */);
|
|
value_pair nonPreserveLeftPost[] = { { 1, 1 }, { 2, 2 }, { 5, 5 } };
|
|
TS_ASSERT_EQUALS(values(nonPreserveLeft), expected(nonPreserveLeftPost));
|
|
|
|
indexed_map_t<size_t> nonPreserveRight;
|
|
seed_map(nonPreserveRight);
|
|
nonPreserveRight.replace(2, 4, 2, true /* bindRight */);
|
|
value_pair nonPreserveRightPost[] = { { 1, 1 }, { 4, 4 }, { 5, 5 } };
|
|
TS_ASSERT_EQUALS(values(nonPreserveRight), expected(nonPreserveRightPost));
|
|
}
|
|
|
|
void test_bind_right ()
|
|
{
|
|
iterate(row, TestKeys)
|
|
{
|
|
std::vector<ssize_t> keys(beginof(*row), endof(*row));
|
|
do {
|
|
|
|
indexed_map_t<bool> map;
|
|
|
|
ssize_t pivot = 30, pad = 5;
|
|
std::vector<ssize_t> expected, actual;
|
|
iterate(key, keys)
|
|
{
|
|
map.set(*key, true);
|
|
expected.push_back(*key < pivot ? *key : *key + pad);
|
|
}
|
|
|
|
map.replace(pivot, pivot, pad, true /* bindRight */);
|
|
|
|
std::sort(expected.begin(), expected.end());
|
|
std::transform(map.begin(), map.end(), back_inserter(actual), [](std::pair<ssize_t, bool> const& p){ return p.first; });
|
|
TS_ASSERT_EQUALS(actual, expected);
|
|
|
|
std::next_permutation(keys.begin(), keys.end());
|
|
|
|
} while(!std::equal(keys.begin(), keys.end(), beginof(*row)));
|
|
}
|
|
}
|
|
|
|
void test_bind_left ()
|
|
{
|
|
iterate(row, TestKeys)
|
|
{
|
|
std::vector<ssize_t> keys(beginof(*row), endof(*row));
|
|
do {
|
|
|
|
indexed_map_t<bool> map;
|
|
|
|
ssize_t pivot = 30, pad = 5;
|
|
std::vector<ssize_t> expected, actual;
|
|
iterate(key, keys)
|
|
{
|
|
map.set(*key, true);
|
|
expected.push_back(*key <= pivot ? *key : *key + pad);
|
|
}
|
|
|
|
map.replace(pivot, pivot, pad, false /* bindRight */);
|
|
|
|
std::sort(expected.begin(), expected.end());
|
|
std::transform(map.begin(), map.end(), back_inserter(actual), [](std::pair<ssize_t, bool> const& p){ return p.first; });
|
|
TS_ASSERT_EQUALS(actual, expected);
|
|
|
|
std::next_permutation(keys.begin(), keys.end());
|
|
|
|
} while(!std::equal(keys.begin(), keys.end(), beginof(*row)));
|
|
}
|
|
}
|
|
|
|
void test_duplicate ()
|
|
{
|
|
indexed_map_t<bool> map;
|
|
|
|
ssize_t random[] = { 2, 7, 13, 15, 29 };
|
|
std::random_shuffle(random, random + sizeofA(random));
|
|
for(auto i : random)
|
|
map.set(i, true);
|
|
|
|
std::vector<bool> values;
|
|
std::transform(map.begin(), map.end(), back_inserter(values), [](std::pair<ssize_t, bool> const& p){ return p.second; });
|
|
TS_ASSERT_EQUALS(values.size(), sizeofA(random));
|
|
TS_ASSERT(std::find(values.begin(), values.end(), false) == values.end());
|
|
|
|
std::random_shuffle(random, random + sizeofA(random));
|
|
for(auto i : random)
|
|
map.set(i, false);
|
|
|
|
values.clear();
|
|
std::transform(map.begin(), map.end(), back_inserter(values), [](std::pair<ssize_t, bool> const& p){ return p.second; });
|
|
TS_ASSERT_EQUALS(values.size(), sizeofA(random));
|
|
TS_ASSERT(std::find(values.begin(), values.end(), true) == values.end());
|
|
}
|
|
|
|
void test_bind_left_right ()
|
|
{
|
|
indexed_map_t<bool> map;
|
|
|
|
ssize_t random[] = { 2, 7, 13, 15, 29 };
|
|
std::random_shuffle(random, random + sizeofA(random));
|
|
for(auto i : random)
|
|
map.set(i, true);
|
|
|
|
for(size_t from = 0; from < 30; ++from)
|
|
{
|
|
for(size_t to = from; to < 30; ++to)
|
|
{
|
|
for(size_t len = 0; len < 10; ++len)
|
|
{
|
|
indexed_map_t<bool> left = map, right = map;
|
|
left.replace(from, to, len, false /* bindRight */);
|
|
right.replace(from, to, len, true /* bindRight */);
|
|
|
|
std::vector<ssize_t> sortedLeft, sortedRight;
|
|
std::transform(left.begin(), left.end(), back_inserter(sortedLeft), [](std::pair<ssize_t, bool> const& p){ return p.first; });
|
|
std::transform(right.begin(), right.end(), back_inserter(sortedRight), [](std::pair<ssize_t, bool> const& p){ return p.first; });
|
|
|
|
std::set<ssize_t> keysLeft, keysRight;
|
|
for(auto i : random)
|
|
{
|
|
if(!(from < i && i <= to))
|
|
keysLeft.insert(i > to ? i - (to - from) + len : i);
|
|
|
|
if(!(from <= i && i < to))
|
|
keysRight.insert(i >= to ? i - (to - from) + len : i);
|
|
}
|
|
|
|
TS_ASSERT_EQUALS(sortedLeft.size(), keysLeft.size());
|
|
TS_ASSERT_EQUALS(sortedRight.size(), keysRight.size());
|
|
TS_ASSERT(std::equal(sortedLeft.begin(), sortedLeft.end(), keysLeft.begin()));
|
|
TS_ASSERT(std::equal(sortedRight.begin(), sortedRight.end(), keysRight.begin()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|