OXYGENHUB
◆ main openmsx / src / unittest / IterableBitSet_test.cc
3.3 KiB · C++ · last changed chore(): initial commit 1 month ago source blame history raw
1 
#include "catch.hpp"
2
3 
#include "IterableBitSet.hh"
4
5 
#include <algorithm>
6 
#include <vector>
7
8 
template<size_t N>
9 
void expect(const IterableBitSet<N>& s, const std::vector<size_t>& expected)
10 
{
11 
	auto it = expected.begin();
12 
	s.foreachSetBit([&](size_t i) {
13 
		REQUIRE(it != expected.end());
14 
		CHECK(*it++ == i);
15 
	});
16 
	CHECK(it == expected.end());
17 
}
18
19 
template<size_t N>
20 
void test(const IterableBitSet<N>& s, std::initializer_list<size_t> list)
21 
{
22 
	REQUIRE((list.size() % 2) == 0);
23 
	std::vector<size_t> v;
24 
	auto f = list.begin();
25 
	auto l = list.end();
26 
	while (f != l) {
27 
		auto b = *f++;
28 
		auto e = *f++;
29 
		for (auto i = b; i != e; ++i) v.push_back(i);
30 
	}
31 
	std::ranges::sort(v);
32 
	auto u = std::ranges::unique(v);
33 
	v.erase(u.begin(), u.end());
34
35 
	expect(s, v);
36 
}
37
38 
template<size_t N>
39 
void test(std::initializer_list<size_t> list)
40 
{
41 
	IterableBitSet<N> s1;
42 
	IterableBitSet<N> s2;
43
44 
	REQUIRE((list.size() % 2) == 0);
45 
	auto f = list.begin();
46 
	auto l = list.end();
47 
	while (f != l) {
48 
		auto b = *f++;
49 
		auto e = *f++;
50 
		REQUIRE(b <= e);
51 
		REQUIRE(e <= 256);
52 
		s1.setPosN(b, e - b);
53 
		s2.setRange(b, e);
54 
	}
55 
	test(s1, list);
56 
	test(s2, list);
57 
}
58
59 
TEST_CASE("IterableBitSet")
60 
{
61 
	SECTION("empty") {
62 
		SECTION("single word") {
63 
			IterableBitSet<40> s;
64 
			CHECK(s.empty());
65 
			s.set(2);
66 
			CHECK(!s.empty());
67 
		}
68 
		SECTION("multiple words") {
69 
			IterableBitSet<100> s;
70 
			CHECK(s.empty());
71 
			SECTION("1st") {
72 
				s.set(2);
73 
				CHECK(!s.empty());
74 
			}
75 
			SECTION("2nd") {
76 
				s.set(70);
77 
				CHECK(!s.empty());
78 
			}
79 
		}
80 
	}
81 
	SECTION("set single") {
82 
		SECTION("single word") {
83 
			IterableBitSet<23> s;
84 
			expect(s, {});
85 
			s.set(11);
86 
			expect(s, {11});
87 
			s.set(17);
88 
			expect(s, {11, 17});
89 
			s.set(3);
90 
			expect(s, {3, 11, 17});
91 
		}
92 
		SECTION("multiple words") {
93 
			IterableBitSet<111> s;
94 
			expect(s, {});
95 
			s.set(87);
96 
			expect(s, {87});
97 
			s.set(17);
98 
			expect(s, {17, 87});
99 
			s.set(110);
100 
			expect(s, {17, 87, 110});
101 
		}
102 
	}
103 
	SECTION("set range") {
104 
		SECTION("single word") {
105 
			test<32>({});
106
107 
			test<32>({0, 0});
108 
			test<32>({0, 16});
109 
			test<32>({0, 31});
110 
			test<32>({0, 32});
111
112 
			test<32>({10, 10});
113 
			test<32>({10, 16});
114 
			test<32>({10, 31});
115 
			test<32>({10, 32});
116
117 
			test<32>({31, 31});
118 
			test<32>({31, 32});
119
120 
			test<32>({32, 32});
121
122 
			test<32>({10, 20,  25, 30});
123 
		}
124 
		SECTION("multiple words") {
125 
			test<256>({});
126
127 
			test<256>({0, 0});
128 
			test<256>({0, 16});
129 
			test<256>({0, 63});
130 
			test<256>({0, 64});
131 
			test<256>({0, 65});
132 
			test<256>({0, 80});
133 
			test<256>({0, 127});
134 
			test<256>({0, 128});
135 
			test<256>({0, 143});
136 
			test<256>({0, 255});
137 
			test<256>({0, 256});
138
139 
			test<256>({10, 10});
140 
			test<256>({10, 16});
141 
			test<256>({10, 63});
142 
			test<256>({10, 64});
143 
			test<256>({10, 65});
144 
			test<256>({10, 80});
145 
			test<256>({10, 127});
146 
			test<256>({10, 128});
147 
			test<256>({10, 143});
148 
			test<256>({10, 255});
149 
			test<256>({10, 256});
150
151 
			test<256>({63, 63});
152 
			test<256>({63, 64});
153 
			test<256>({63, 65});
154 
			test<256>({63, 80});
155 
			test<256>({63, 127});
156 
			test<256>({63, 128});
157 
			test<256>({63, 143});
158 
			test<256>({63, 255});
159 
			test<256>({63, 256});
160
161 
			test<256>({64, 64});
162 
			test<256>({64, 65});
163 
			test<256>({64, 80});
164 
			test<256>({64, 127});
165 
			test<256>({64, 128});
166 
			test<256>({64, 143});
167 
			test<256>({64, 255});
168 
			test<256>({64, 256});
169
170 
			test<256>({10, 20,  40, 50});
171 
			test<256>({10, 20,  60, 70});
172 
			test<256>({10, 40,  20, 30});
173 
			test<256>({10, 40,  20, 50});
174 
		}
175 
	}
176 
}