1 | #include <string>
|
2 | #include <iostream>
|
3 | #include <assert.h>
|
4 | #include "../subset_map.hpp"
|
5 |
|
6 | Subset_Map<std::string, std::string> ssm;
|
7 |
|
8 | string toString(std::vector<std::string> v);
|
9 | string toString(std::vector<std::pair<std::string, std::vector<std::string>>> v);
|
10 | void assertEqual(string std::sExpected, std::string sResult);
|
11 |
|
12 | void setup() {
|
13 | ssm.clear();
|
14 |
|
15 |
|
16 | std::vector<std::string> s1;
|
17 | s1.push_back("1");
|
18 | s1.push_back("2");
|
19 | ssm.put(s1, "Foo");
|
20 |
|
21 |
|
22 | std::vector<std::string> s2;
|
23 | s2.push_back("fizz");
|
24 | s2.push_back("fazz");
|
25 | ssm.put(s2, "Bar");
|
26 |
|
27 |
|
28 | std::vector<std::string> s3;
|
29 | s3.push_back(":foo");
|
30 | s3.push_back(":bar");
|
31 | ssm.put(s3, "Baz");
|
32 |
|
33 |
|
34 | std::vector<std::string> s4;
|
35 | s4.push_back(":foo");
|
36 | s4.push_back(":bar");
|
37 | s4.push_back(":baz");
|
38 | ssm.put(s4, "Bang");
|
39 |
|
40 |
|
41 | std::vector<std::string> s5;
|
42 | s5.push_back(":bip");
|
43 | s5.push_back(":bop");
|
44 | s5.push_back(":blip");
|
45 | ssm.put(s5, "Qux");
|
46 |
|
47 |
|
48 | std::vector<std::string> s6;
|
49 | s6.push_back(":bip");
|
50 | s6.push_back(":bop");
|
51 | ssm.put(s6, "Thram");
|
52 | }
|
53 |
|
54 | void testEqualKeys() {
|
55 | std::cout << "testEqualKeys" << std::endl;
|
56 |
|
57 |
|
58 | std::vector<std::string> k1;
|
59 | k1.push_back("1");
|
60 | k1.push_back("2");
|
61 | assertEqual("[[Foo, Set[1, 2]]]", toString(ssm.get_kv(k1)));
|
62 |
|
63 |
|
64 | std::vector<std::string> k2;
|
65 | k2.push_back("fizz");
|
66 | k2.push_back("fazz");
|
67 | assertEqual("[[Bar, Set[fizz, fazz]]]", toString(ssm.get_kv(k2)));
|
68 |
|
69 | std::cout << std::endl;
|
70 | }
|
71 |
|
72 | void testSubsetKeys() {
|
73 | std::cout << "testSubsetKeys" << std::endl;
|
74 |
|
75 |
|
76 | std::vector<std::string> k1;
|
77 | k1.push_back("1");
|
78 | k1.push_back("2");
|
79 | k1.push_back("fuzz");
|
80 | assertEqual("[[Foo, Set[1, 2]]]", toString(ssm.get_kv(k1)));
|
81 |
|
82 |
|
83 | std::vector<std::string> k2;
|
84 | k2.push_back("fizz");
|
85 | k2.push_back("fazz");
|
86 | k2.push_back("3");
|
87 | assertEqual("[[Bar, Set[fizz, fazz]]]", toString(ssm.get_kv(k2)));
|
88 |
|
89 | std::cout << std::endl;
|
90 | }
|
91 |
|
92 | void testSupersetKeys() {
|
93 | std::cout << "testSupersetKeys" << std::endl;
|
94 |
|
95 |
|
96 | std::vector<std::string> k1;
|
97 | k1.push_back("1");
|
98 | assertEqual("[]", toString(ssm.get_kv(k1)));
|
99 |
|
100 |
|
101 | std::vector<std::string> k2;
|
102 | k2.push_back("2");
|
103 | assertEqual("[]", toString(ssm.get_kv(k2)));
|
104 |
|
105 |
|
106 | std::vector<std::string> k3;
|
107 | k3.push_back("fizz");
|
108 | assertEqual("[]", toString(ssm.get_kv(k3)));
|
109 |
|
110 |
|
111 | std::vector<std::string> k4;
|
112 | k4.push_back("fazz");
|
113 | assertEqual("[]", toString(ssm.get_kv(k4)));
|
114 |
|
115 | std::cout << std::endl;
|
116 | }
|
117 |
|
118 | void testDisjointKeys() {
|
119 | std::cout << "testDisjointKeys" << std::endl;
|
120 |
|
121 |
|
122 | std::vector<std::string> k1;
|
123 | k1.push_back("3");
|
124 | k1.push_back("4");
|
125 | assertEqual("[]", toString(ssm.get_kv(k1)));
|
126 |
|
127 |
|
128 | std::vector<std::string> k2;
|
129 | k2.push_back("fuzz");
|
130 | k2.push_back("frizz");
|
131 | assertEqual("[]", toString(ssm.get_kv(k2)));
|
132 |
|
133 |
|
134 | std::vector<std::string> k3;
|
135 | k3.push_back("gran");
|
136 | k3.push_back("15");
|
137 | assertEqual("[]", toString(ssm.get_kv(k3)));
|
138 |
|
139 | std::cout << std::endl;
|
140 | }
|
141 |
|
142 | void testSemiDisjointKeys() {
|
143 | std::cout << "testSemiDisjointKeys" << std::endl;
|
144 |
|
145 |
|
146 | std::vector<std::string> k1;
|
147 | k1.push_back("2");
|
148 | k1.push_back("3");
|
149 | assertEqual("[]", toString(ssm.get_kv(k1)));
|
150 |
|
151 |
|
152 | std::vector<std::string> k2;
|
153 | k2.push_back("fizz");
|
154 | k2.push_back("fuzz");
|
155 | assertEqual("[]", toString(ssm.get_kv(k2)));
|
156 |
|
157 |
|
158 | std::vector<std::string> k3;
|
159 | k3.push_back("1");
|
160 | k3.push_back("fazz");
|
161 | assertEqual("[]", toString(ssm.get_kv(k3)));
|
162 |
|
163 | std::cout << std::endl;
|
164 | }
|
165 |
|
166 | void testEmptyKeySet() {
|
167 | std::cout << "testEmptyKeySet" << std::endl;
|
168 |
|
169 |
|
170 | std::vector<std::string> s1;
|
171 | try {
|
172 | ssm.put(s1, "Fail");
|
173 | }
|
174 | catch (const char* &e) {
|
175 | assertEqual("internal error: subset map keys may not be empty", e);
|
176 | }
|
177 | }
|
178 |
|
179 | void testEmptyKeyGet() {
|
180 | std::cout << "testEmptyKeyGet" << std::endl;
|
181 |
|
182 |
|
183 | std::vector<std::string> k1;
|
184 | assertEqual("[]", toString(ssm.get_kv(k1)));
|
185 |
|
186 | std::cout << std::endl;
|
187 | }
|
188 | void testMultipleSubsets() {
|
189 | std::cout << "testMultipleSubsets" << std::endl;
|
190 |
|
191 |
|
192 | std::vector<std::string> k1;
|
193 | k1.push_back("1");
|
194 | k1.push_back("2");
|
195 | k1.push_back("fizz");
|
196 | k1.push_back("fazz");
|
197 | assertEqual("[[Foo, Set[1, 2]], [Bar, Set[fizz, fazz]]]", toString(ssm.get_kv(k1)));
|
198 |
|
199 |
|
200 | std::vector<std::string> k2;
|
201 | k2.push_back("1");
|
202 | k2.push_back("2");
|
203 | k2.push_back("3");
|
204 | k2.push_back("fizz");
|
205 | k2.push_back("fazz");
|
206 | k2.push_back("fuzz");
|
207 | assertEqual("[[Foo, Set[1, 2]], [Bar, Set[fizz, fazz]]]", toString(ssm.get_kv(k2)));
|
208 |
|
209 |
|
210 | std::vector<std::string> k3;
|
211 | k3.push_back(":foo");
|
212 | k3.push_back(":bar");
|
213 | assertEqual("[[Baz, Set[:foo, :bar]]]", toString(ssm.get_kv(k3)));
|
214 |
|
215 |
|
216 | std::vector<std::string> k4;
|
217 | k4.push_back(":foo");
|
218 | k4.push_back(":bar");
|
219 | k4.push_back(":baz");
|
220 | assertEqual("[[Baz, Set[:foo, :bar]], [Bang, Set[:foo, :bar, :baz]]]", toString(ssm.get_kv(k4)));
|
221 |
|
222 | std::cout << std::endl;
|
223 | }
|
224 | void testBracketBracket() {
|
225 | std::cout << "testBracketBracket" << std::endl;
|
226 |
|
227 |
|
228 | std::vector<std::string> k1;
|
229 | k1.push_back("1");
|
230 | k1.push_back("2");
|
231 | k1.push_back("fuzz");
|
232 | assertEqual("[Foo]", toString(ssm.get_v(k1)));
|
233 |
|
234 |
|
235 | std::vector<std::string> k2;
|
236 | k2.push_back(":foo");
|
237 | k2.push_back(":bar");
|
238 | k2.push_back(":baz");
|
239 | assertEqual("[Baz, Bang]", toString(ssm.get_v(k2)));
|
240 |
|
241 | std::cout << std::endl;
|
242 | }
|
243 |
|
244 | void testKeyOrder() {
|
245 | std::cout << "testEqualKeys" << std::endl;
|
246 |
|
247 |
|
248 | std::vector<std::string> k1;
|
249 | k1.push_back("2");
|
250 | k1.push_back("1");
|
251 | assertEqual("[[Foo, Set[1, 2]]]", toString(ssm.get_kv(k1)));
|
252 |
|
253 | std::cout << std::endl;
|
254 | }
|
255 |
|
256 | void testOrderPreserved() {
|
257 | std::cout << "testOrderPreserved" << std::endl;
|
258 |
|
259 | std::vector<std::string> s1;
|
260 | s1.push_back("10");
|
261 | s1.push_back("11");
|
262 | s1.push_back("12");
|
263 | ssm.put(s1, "1");
|
264 |
|
265 |
|
266 | std::vector<std::string> s2;
|
267 | s2.push_back("10");
|
268 | s2.push_back("11");
|
269 | ssm.put(s2, "2");
|
270 |
|
271 |
|
272 | std::vector<std::string> s3;
|
273 | s3.push_back("11");
|
274 | ssm.put(s3, "3");
|
275 |
|
276 |
|
277 | std::vector<std::string> s4;
|
278 | s4.push_back("11");
|
279 | s4.push_back("12");
|
280 | ssm.put(s4, "4");
|
281 |
|
282 |
|
283 | std::vector<std::string> s5;
|
284 | s5.push_back("9");
|
285 | s5.push_back("10");
|
286 | s5.push_back("11");
|
287 | s5.push_back("12");
|
288 | s5.push_back("13");
|
289 | ssm.put(s5, "5");
|
290 |
|
291 |
|
292 | std::vector<std::string> s6;
|
293 | s6.push_back("10");
|
294 | s6.push_back("13");
|
295 | ssm.put(s6, "6");
|
296 |
|
297 |
|
298 | std::vector<std::string> k1;
|
299 | k1.push_back("9");
|
300 | k1.push_back("10");
|
301 | k1.push_back("11");
|
302 | k1.push_back("12");
|
303 | k1.push_back("13");
|
304 | assertEqual("[[1, Set[10, 11, 12]], [2, Set[10, 11]], [3, Set[11]], [4, Set[11, 12]], [5, Set[9, 10, 11, 12, 13]], [6, Set[10, 13]]]", toString(ssm.get_kv(k1)));
|
305 |
|
306 | std::cout << std::endl;
|
307 | }
|
308 | void testMultipleEqualValues() {
|
309 | std::cout << "testMultipleEqualValues" << std::endl;
|
310 |
|
311 | std::vector<std::string> s1;
|
312 | s1.push_back("11");
|
313 | s1.push_back("12");
|
314 | ssm.put(s1, "1");
|
315 |
|
316 |
|
317 | std::vector<std::string> s2;
|
318 | s2.push_back("12");
|
319 | s2.push_back("13");
|
320 | ssm.put(s2, "2");
|
321 |
|
322 |
|
323 | std::vector<std::string> s3;
|
324 | s3.push_back("13");
|
325 | s3.push_back("14");
|
326 | ssm.put(s3, "1");
|
327 |
|
328 |
|
329 | std::vector<std::string> s4;
|
330 | s4.push_back("14");
|
331 | s4.push_back("15");
|
332 | ssm.put(s4, "1");
|
333 |
|
334 |
|
335 | std::vector<std::string> k1;
|
336 | k1.push_back("11");
|
337 | k1.push_back("12");
|
338 | k1.push_back("13");
|
339 | k1.push_back("14");
|
340 | k1.push_back("15");
|
341 | assertEqual("[[1, Set[11, 12]], [2, Set[12, 13]], [1, Set[13, 14]], [1, Set[14, 15]]]", toString(ssm.get_kv(k1)));
|
342 |
|
343 | std::cout << std::endl;
|
344 | }
|
345 |
|
346 | int main()
|
347 | {
|
348 | std::vector<std::string> s1;
|
349 | s1.push_back("1");
|
350 | s1.push_back("2");
|
351 |
|
352 | std::vector<std::string> s2;
|
353 | s2.push_back("2");
|
354 | s2.push_back("3");
|
355 |
|
356 | std::vector<std::string> s3;
|
357 | s3.push_back("3");
|
358 | s3.push_back("4");
|
359 |
|
360 | ssm.put(s1, "value1");
|
361 | ssm.put(s2, "value2");
|
362 | ssm.put(s3, "value3");
|
363 |
|
364 | std::vector<std::string> s4;
|
365 | s4.push_back("1");
|
366 | s4.push_back("2");
|
367 | s4.push_back("3");
|
368 |
|
369 | std::vector<std::pair<string, std::vector<std::string> > > fetched(ssm.get_kv(s4));
|
370 |
|
371 | std::cout << "PRINTING RESULTS:" << std::endl;
|
372 | for (size_t i = 0, S = fetched.size(); i < S; ++i) {
|
373 | std::cout << fetched[i].first << std::endl;
|
374 | }
|
375 |
|
376 | Subset_Map<string, string> ssm2;
|
377 | ssm2.put(s1, "foo");
|
378 | ssm2.put(s2, "bar");
|
379 | ssm2.put(s4, "hux");
|
380 |
|
381 | std::vector<std::pair<string, std::vector<std::string> > > fetched2(ssm2.get_kv(s4));
|
382 |
|
383 | std::cout << std::endl << "PRINTING RESULTS:" << std::endl;
|
384 | for (size_t i = 0, S = fetched2.size(); i < S; ++i) {
|
385 | std::cout << fetched2[i].first << std::endl;
|
386 | }
|
387 |
|
388 | std::cout << "TRYING ON A SELECTOR-LIKE OBJECT" << std::endl;
|
389 |
|
390 | Subset_Map<string, string> sel_ssm;
|
391 | std::vector<std::string> target;
|
392 | target.push_back("desk");
|
393 | target.push_back(".wood");
|
394 |
|
395 | std::vector<std::string> actual;
|
396 | actual.push_back("desk");
|
397 | actual.push_back(".wood");
|
398 | actual.push_back(".mine");
|
399 |
|
400 | sel_ssm.put(target, "has-aquarium");
|
401 | std::vector<std::pair<string, std::vector<std::string> > > fetched3(sel_ssm.get_kv(actual));
|
402 | std::cout << "RESULTS:" << std::endl;
|
403 | for (size_t i = 0, S = fetched3.size(); i < S; ++i) {
|
404 | std::cout << fetched3[i].first << std::endl;
|
405 | }
|
406 |
|
407 | std::cout << std::endl;
|
408 |
|
409 |
|
410 |
|
411 | setup();
|
412 | testEqualKeys();
|
413 | testSubsetKeys();
|
414 | testSupersetKeys();
|
415 | testDisjointKeys();
|
416 | testSemiDisjointKeys();
|
417 | testEmptyKeySet();
|
418 | testEmptyKeyGet();
|
419 | testMultipleSubsets();
|
420 | testBracketBracket();
|
421 | testKeyOrder();
|
422 |
|
423 | setup();
|
424 | testOrderPreserved();
|
425 |
|
426 | setup();
|
427 | testMultipleEqualValues();
|
428 |
|
429 | return 0;
|
430 | }
|
431 |
|
432 | string toString(std::vector<std::pair<string, std::vector<std::string>>> v)
|
433 | {
|
434 | std::stringstream buffer;
|
435 | buffer << "[";
|
436 | for (size_t i = 0, S = v.size(); i < S; ++i) {
|
437 | buffer << "[" << v[i].first;
|
438 | buffer << ", Set[";
|
439 | for (size_t j = 0, S = v[i].second.size(); j < S; ++j) {
|
440 | buffer << v[i].second[j];
|
441 | if (j < S-1) {
|
442 | buffer << ", ";
|
443 | }
|
444 | }
|
445 | buffer << "]]";
|
446 | if (i < S-1) {
|
447 | buffer << ", ";
|
448 | }
|
449 | }
|
450 | buffer << "]";
|
451 | return buffer.str();
|
452 | }
|
453 |
|
454 | string toString(std::vector<std::string> v)
|
455 | {
|
456 | std::stringstream buffer;
|
457 | buffer << "[";
|
458 | for (size_t i = 0, S = v.size(); i < S; ++i) {
|
459 | buffer << v[i];
|
460 | if (i < S-1) {
|
461 | buffer << ", ";
|
462 | }
|
463 | }
|
464 | buffer << "]";
|
465 | return buffer.str();
|
466 | }
|
467 |
|
468 | void assertEqual(string sExpected, string sResult) {
|
469 | std::cout << "Expected: " << sExpected << std::endl;
|
470 | std::cout << "Result: " << sResult << std::endl;
|
471 | assert(sExpected == sResult);
|
472 | }
|