17 #include "NonOverlapRegions.h" 18 #include "NonOverlapRegionsTest.h" 22 int main(
int argc,
char ** argv)
30 void NonOverlapRegionsTest::test()
37 void NonOverlapRegionsTest::testChrom()
42 assert(reg.myRegions.size() == 0);
44 for(
int i = 0; i < 30; i++)
46 assert(reg.
inRegion(
"a", i) ==
false);
47 assert(reg.
inRegion(
"3", i) ==
false);
50 assert(reg.myRegions.size() == 2);
51 assert(reg.myRegions[
"a"].myRegions.size() == 0);
52 assert(reg.myRegions[
"a"].myRegionIter ==
53 reg.myRegions[
"a"].myRegions.end());
54 assert(reg.myRegions[
"3"].myRegions.size() == 0);
55 assert(reg.myRegions[
"3"].myRegionIter ==
56 reg.myRegions[
"3"].myRegions.end());
61 assert(reg.myRegions.size() == 2);
62 for(
int i = 0; i < 30; i++)
64 assert(reg.
inRegion(
"a", i) ==
false);
65 if((i >= 13) && (i < 15))
67 assert(reg.
inRegion(
"3", i) ==
true);
71 assert(reg.
inRegion(
"3", i) ==
false);
78 assert(reg.myRegions.size() == 2);
79 for(
int i = 0; i < 30; i++)
81 if((i >= 1) && (i < 5))
83 assert(reg.
inRegion(
"a", i) ==
true);
87 assert(reg.
inRegion(
"a", i) ==
false);
89 if((i >= 13) && (i < 15))
91 assert(reg.
inRegion(
"3", i) ==
true);
95 assert(reg.
inRegion(
"3", i) ==
false);
102 void NonOverlapRegionsTest::testPos()
105 std::list< std::pair<int32_t, int32_t> >::iterator iter;
108 assert(reg.myRegions.empty());
109 assert(reg.myRegionIter == reg.myRegions.end());
110 assert(reg.myTmpIter == reg.myRegions.end());
112 for(
int i = 0; i < 30; i++)
121 assert(reg.myRegions.size() == 1);
122 assert(reg.myRegionIter->first == 13);
123 assert(reg.myRegionIter->second == 15);
124 for(
int i = 0; i < 30; i++)
126 if((i >= 13) && (i < 15))
138 assert(reg.myRegions.size() == 2);
139 assert(reg.myRegionIter->first == 4);
140 assert(reg.myRegionIter->second == 6);
141 iter = reg.myRegions.begin();
142 assert(iter->first == 4);
143 assert(iter->second == 6);
145 assert(iter->first == 13);
146 assert(iter->second == 15);
148 assert(iter == reg.myRegions.end());
149 for(
int i = 0; i < 30; i++)
151 if(((i >= 4) && (i < 6)) || ((i >= 13) && (i < 15)))
163 assert(reg.myRegions.size() == 3);
164 assert(reg.myRegionIter->first == 22);
165 assert(reg.myRegionIter->second == 26);
166 iter = reg.myRegions.begin();
167 assert(iter->first == 4);
168 assert(iter->second == 6);
170 assert(iter->first == 13);
171 assert(iter->second == 15);
173 assert(iter->first == 22);
174 assert(iter->second == 26);
176 assert(iter == reg.myRegions.end());
177 for(
int i = 0; i < 30; i++)
179 if(((i >= 4) && (i < 6)) || ((i >= 13) && (i < 15)) ||
180 ((i >= 22) && (i < 26)))
192 assert(reg.myRegions.size() == 4);
193 assert(reg.myRegionIter->first == 8);
194 assert(reg.myRegionIter->second == 9);
195 iter = reg.myRegions.begin();
196 assert(iter->first == 4);
197 assert(iter->second == 6);
199 assert(iter->first == 8);
200 assert(iter->second == 9);
202 assert(iter->first == 13);
203 assert(iter->second == 15);
205 assert(iter->first == 22);
206 assert(iter->second == 26);
208 assert(iter == reg.myRegions.end());
209 for(
int i = 0; i < 30; i++)
211 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
212 ((i >= 13) && (i < 15)) || ((i >= 22) && (i < 26)))
224 assert(reg.myRegions.size() == 4);
225 assert(reg.myRegionIter->first == 20);
226 assert(reg.myRegionIter->second == 26);
227 iter = reg.myRegions.begin();
228 assert(iter->first == 4);
229 assert(iter->second == 6);
231 assert(iter->first == 8);
232 assert(iter->second == 9);
234 assert(iter->first == 13);
235 assert(iter->second == 15);
237 assert(iter->first == 20);
238 assert(iter->second == 26);
240 assert(iter == reg.myRegions.end());
241 for(
int i = 0; i < 30; i++)
243 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
244 ((i >= 13) && (i < 15)) || ((i >= 20) && (i < 26)))
256 assert(reg.myRegions.size() == 5);
257 assert(reg.myRegionIter->first == 18);
258 assert(reg.myRegionIter->second == 19);
259 iter = reg.myRegions.begin();
260 assert(iter->first == 4);
261 assert(iter->second == 6);
263 assert(iter->first == 8);
264 assert(iter->second == 9);
266 assert(iter->first == 13);
267 assert(iter->second == 15);
269 assert(iter->first == 18);
270 assert(iter->second == 19);
272 assert(iter->first == 20);
273 assert(iter->second == 26);
275 assert(iter == reg.myRegions.end());
276 for(
int i = 0; i < 30; i++)
278 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
279 ((i >= 13) && (i < 15)) || ((i >= 18) && (i < 19)) ||
280 ((i >= 20) && (i < 26)))
292 assert(reg.myRegions.size() == 4);
293 assert(reg.myRegionIter->first == 12);
294 assert(reg.myRegionIter->second == 19);
295 iter = reg.myRegions.begin();
296 assert(iter->first == 4);
297 assert(iter->second == 6);
299 assert(iter->first == 8);
300 assert(iter->second == 9);
302 assert(iter->first == 12);
303 assert(iter->second == 19);
305 assert(iter->first == 20);
306 assert(iter->second == 26);
308 assert(iter == reg.myRegions.end());
309 for(
int i = 0; i < 30; i++)
311 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
312 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)))
324 assert(reg.myRegions.size() == 4);
325 assert(reg.myRegionIter->first == 4);
326 assert(reg.myRegionIter->second == 6);
327 iter = reg.myRegions.begin();
328 assert(iter->first == 4);
329 assert(iter->second == 6);
331 assert(iter->first == 8);
332 assert(iter->second == 9);
334 assert(iter->first == 12);
335 assert(iter->second == 19);
337 assert(iter->first == 20);
338 assert(iter->second == 26);
340 assert(iter == reg.myRegions.end());
341 for(
int i = 0; i < 30; i++)
343 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
344 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)))
356 assert(reg.myRegions.size() == 4);
357 assert(reg.myRegionIter->first == 20);
358 assert(reg.myRegionIter->second == 26);
359 iter = reg.myRegions.begin();
360 assert(iter->first == 4);
361 assert(iter->second == 6);
363 assert(iter->first == 8);
364 assert(iter->second == 9);
366 assert(iter->first == 12);
367 assert(iter->second == 19);
369 assert(iter->first == 20);
370 assert(iter->second == 26);
372 assert(iter == reg.myRegions.end());
373 for(
int i = 0; i < 30; i++)
375 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
376 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)))
388 assert(reg.myRegions.size() == 5);
389 assert(reg.myRegionIter->first == 28);
390 assert(reg.myRegionIter->second == 29);
391 iter = reg.myRegions.begin();
392 assert(iter->first == 4);
393 assert(iter->second == 6);
395 assert(iter->first == 8);
396 assert(iter->second == 9);
398 assert(iter->first == 12);
399 assert(iter->second == 19);
401 assert(iter->first == 20);
402 assert(iter->second == 26);
404 assert(iter->first == 28);
405 assert(iter->second == 29);
407 assert(iter == reg.myRegions.end());
408 for(
int i = 0; i < 30; i++)
410 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
411 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)) ||
412 ((i >= 28) && (i < 29)))
424 assert(reg.myRegions.size() == 5);
425 assert(reg.myRegionIter->first == 8);
426 assert(reg.myRegionIter->second == 10);
427 iter = reg.myRegions.begin();
428 assert(iter->first == 4);
429 assert(iter->second == 6);
431 assert(iter->first == 8);
432 assert(iter->second == 10);
434 assert(iter->first == 12);
435 assert(iter->second == 19);
437 assert(iter->first == 20);
438 assert(iter->second == 26);
440 assert(iter->first == 28);
441 assert(iter->second == 29);
443 assert(iter == reg.myRegions.end());
444 for(
int i = 0; i < 30; i++)
446 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 10)) ||
447 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)) ||
448 ((i >= 28) && (i < 29)))
461 assert(reg.myRegions.size() == 4);
462 assert(reg.myRegionIter->first == 4);
463 assert(reg.myRegionIter->second == 10);
464 iter = reg.myRegions.begin();
465 assert(iter->first == 4);
466 assert(iter->second == 10);
468 assert(iter->first == 12);
469 assert(iter->second == 19);
471 assert(iter->first == 20);
472 assert(iter->second == 26);
474 assert(iter->first == 28);
475 assert(iter->second == 29);
477 assert(iter == reg.myRegions.end());
478 for(
int i = 0; i < 30; i++)
480 if(((i >= 4) && (i < 10)) ||
481 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)) ||
482 ((i >= 28) && (i < 29)))
495 assert(reg.myRegions.size() == 5);
496 assert(reg.myRegionIter->first == 10);
497 assert(reg.myRegionIter->second == 11);
498 iter = reg.myRegions.begin();
499 assert(iter->first == 4);
500 assert(iter->second == 10);
502 assert(iter->first == 10);
503 assert(iter->second == 11);
505 assert(iter->first == 12);
506 assert(iter->second == 19);
508 assert(iter->first == 20);
509 assert(iter->second == 26);
511 assert(iter->first == 28);
512 assert(iter->second == 29);
514 assert(iter == reg.myRegions.end());
515 for(
int i = 0; i < 30; i++)
517 if(((i >= 4) && (i < 10)) || ((i >= 10) && (i < 11)) ||
518 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)) ||
519 ((i >= 28) && (i < 29)))
532 assert(reg.myRegions.size() == 3);
533 assert(reg.myRegionIter->first == 10);
534 assert(reg.myRegionIter->second == 26);
535 iter = reg.myRegions.begin();
536 assert(iter->first == 4);
537 assert(iter->second == 10);
539 assert(iter->first == 10);
540 assert(iter->second == 26);
542 assert(iter->first == 28);
543 assert(iter->second == 29);
545 assert(iter == reg.myRegions.end());
546 for(
int i = 0; i < 30; i++)
548 if(((i >= 4) && (i < 10)) || ((i >= 10) && (i < 26)) ||
549 ((i >= 28) && (i < 29)))
561 assert(reg.myRegions.size() == 1);
562 assert(reg.myRegionIter->first == 2);
563 assert(reg.myRegionIter->second == 30);
564 iter = reg.myRegions.begin();
565 assert(iter->first == 2);
566 assert(iter->second == 30);
568 assert(iter == reg.myRegions.end());
569 for(
int i = 0; i < 50; i++)
571 if(((i >= 2) && (i < 30)))
583 assert(reg.myRegions.size() == 1);
584 iter = reg.myRegions.begin();
585 assert(iter->first == 2);
586 assert(iter->second == 30);
588 assert(iter == reg.myRegions.end());
589 for(
int i = 0; i < 50; i++)
591 if(((i >= 2) && (i < 30)))
603 assert(reg.myRegions.size() == 1);
604 iter = reg.myRegions.begin();
605 assert(iter->first == 2);
606 assert(iter->second == 30);
608 assert(iter == reg.myRegions.end());
609 for(
int i = 0; i < 50; i++)
611 if(((i >= 2) && (i < 30)))
bool inRegion(int32_t pos)
Return whether or not the position was found within a region.
void add(const char *chrom, int32_t start, int32_t end)
End position is not included in the region.
bool inRegion(const char *chrom, int32_t pos)
Return whether or not the position was found within a region.
void add(int32_t start, int32_t end)
End position is not included in the region.
This class contains a list of non-overlapping regions, just positions, not including chromosomes (see...
This class contains a list of non-overlapping regions.