libStatGen Software 1
NonOverlapRegionsTest.cpp
1/*
2 * Copyright (C) 2011 Regents of the University of Michigan
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 3 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17#include "NonOverlapRegions.h"
18#include "NonOverlapRegionsTest.h"
19#include <assert.h>
20#include <iostream>
21
22int main(int argc, char ** argv)
23{
24
26
27 myTest.test();
28}
29
30void NonOverlapRegionsTest::test()
31{
32 testPos();
33 testChrom();
34}
35
36
37void NonOverlapRegionsTest::testChrom()
38{
40
41 // Assert that the regions are empty.
42 assert(reg.myRegions.size() == 0);
43 // Verify no regions.
44 for(int i = 0; i < 30; i++)
45 {
46 assert(reg.inRegion("a", i) == false);
47 assert(reg.inRegion("3", i) == false);
48 }
49 // The chromosomes checked for were added.
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());
57
58 // Add a region.
59 reg.add("3", 13, 15);
60 // Verify regions.
61 assert(reg.myRegions.size() == 2);
62 for(int i = 0; i < 30; i++)
63 {
64 assert(reg.inRegion("a", i) == false);
65 if((i >= 13) && (i < 15))
66 {
67 assert(reg.inRegion("3", i) == true);
68 }
69 else
70 {
71 assert(reg.inRegion("3", i) == false);
72 }
73 }
74
75 // Add a region.
76 reg.add("a", 1, 5);
77 // Verify regions.
78 assert(reg.myRegions.size() == 2);
79 for(int i = 0; i < 30; i++)
80 {
81 if((i >= 1) && (i < 5))
82 {
83 assert(reg.inRegion("a", i) == true);
84 }
85 else
86 {
87 assert(reg.inRegion("a", i) == false);
88 }
89 if((i >= 13) && (i < 15))
90 {
91 assert(reg.inRegion("3", i) == true);
92 }
93 else
94 {
95 assert(reg.inRegion("3", i) == false);
96 }
97 }
98
99
100}
101
102void NonOverlapRegionsTest::testPos()
103{
105 std::list< std::pair<int32_t, int32_t> >::iterator iter;
106
107 // Assert that the regions are empty.
108 assert(reg.myRegions.empty());
109 assert(reg.myRegionIter == reg.myRegions.end());
110 assert(reg.myTmpIter == reg.myRegions.end());
111 // Verify regions.
112 for(int i = 0; i < 30; i++)
113 {
114 assert(reg.inRegion(i) == false);
115 }
116
117
118 // Add a region
119 reg.add(13, 15);
120 // Verify regions.
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++)
125 {
126 if((i >= 13) && (i < 15))
127 {
128 assert(reg.inRegion(i) == true);
129 }
130 else
131 {
132 assert(reg.inRegion(i) == false);
133 }
134 }
135
136 // Insert before this.
137 reg.add(4,6);
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);
144 ++iter;
145 assert(iter->first == 13);
146 assert(iter->second == 15);
147 ++iter;
148 assert(iter == reg.myRegions.end());
149 for(int i = 0; i < 30; i++)
150 {
151 if(((i >= 4) && (i < 6)) || ((i >= 13) && (i < 15)))
152 {
153 assert(reg.inRegion(i) == true);
154 }
155 else
156 {
157 assert(reg.inRegion(i) == false);
158 }
159 }
160
161 // Insert at the end.
162 reg.add(22,26);
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);
169 ++iter;
170 assert(iter->first == 13);
171 assert(iter->second == 15);
172 ++iter;
173 assert(iter->first == 22);
174 assert(iter->second == 26);
175 ++iter;
176 assert(iter == reg.myRegions.end());
177 for(int i = 0; i < 30; i++)
178 {
179 if(((i >= 4) && (i < 6)) || ((i >= 13) && (i < 15)) ||
180 ((i >= 22) && (i < 26)))
181 {
182 assert(reg.inRegion(i) == true);
183 }
184 else
185 {
186 assert(reg.inRegion(i) == false);
187 }
188 }
189
190 // Insert in the middle.
191 reg.add(8,9);
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);
198 ++iter;
199 assert(iter->first == 8);
200 assert(iter->second == 9);
201 ++iter;
202 assert(iter->first == 13);
203 assert(iter->second == 15);
204 ++iter;
205 assert(iter->first == 22);
206 assert(iter->second == 26);
207 ++iter;
208 assert(iter == reg.myRegions.end());
209 for(int i = 0; i < 30; i++)
210 {
211 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
212 ((i >= 13) && (i < 15)) || ((i >= 22) && (i < 26)))
213 {
214 assert(reg.inRegion(i) == true);
215 }
216 else
217 {
218 assert(reg.inRegion(i) == false);
219 }
220 }
221
222 // Insert start does not overlap, but the end does.
223 reg.add(20,24);
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);
230 ++iter;
231 assert(iter->first == 8);
232 assert(iter->second == 9);
233 ++iter;
234 assert(iter->first == 13);
235 assert(iter->second == 15);
236 ++iter;
237 assert(iter->first == 20);
238 assert(iter->second == 26);
239 ++iter;
240 assert(iter == reg.myRegions.end());
241 for(int i = 0; i < 30; i++)
242 {
243 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
244 ((i >= 13) && (i < 15)) || ((i >= 20) && (i < 26)))
245 {
246 assert(reg.inRegion(i) == true);
247 }
248 else
249 {
250 assert(reg.inRegion(i) == false);
251 }
252 }
253
254 // Add another region
255 reg.add(18,19);
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);
262 ++iter;
263 assert(iter->first == 8);
264 assert(iter->second == 9);
265 ++iter;
266 assert(iter->first == 13);
267 assert(iter->second == 15);
268 ++iter;
269 assert(iter->first == 18);
270 assert(iter->second == 19);
271 ++iter;
272 assert(iter->first == 20);
273 assert(iter->second == 26);
274 ++iter;
275 assert(iter == reg.myRegions.end());
276 for(int i = 0; i < 30; i++)
277 {
278 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
279 ((i >= 13) && (i < 15)) || ((i >= 18) && (i < 19)) ||
280 ((i >= 20) && (i < 26)))
281 {
282 assert(reg.inRegion(i) == true);
283 }
284 else
285 {
286 assert(reg.inRegion(i) == false);
287 }
288 }
289
290 // Start is not in, but overlap two others (ending not at the end).
291 reg.add(12,19);
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);
298 ++iter;
299 assert(iter->first == 8);
300 assert(iter->second == 9);
301 ++iter;
302 assert(iter->first == 12);
303 assert(iter->second == 19);
304 ++iter;
305 assert(iter->first == 20);
306 assert(iter->second == 26);
307 ++iter;
308 assert(iter == reg.myRegions.end());
309 for(int i = 0; i < 30; i++)
310 {
311 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
312 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)))
313 {
314 assert(reg.inRegion(i) == true);
315 }
316 else
317 {
318 assert(reg.inRegion(i) == false);
319 }
320 }
321
322 // Completely in region to left.
323 reg.add(5,6);
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);
330 ++iter;
331 assert(iter->first == 8);
332 assert(iter->second == 9);
333 ++iter;
334 assert(iter->first == 12);
335 assert(iter->second == 19);
336 ++iter;
337 assert(iter->first == 20);
338 assert(iter->second == 26);
339 ++iter;
340 assert(iter == reg.myRegions.end());
341 for(int i = 0; i < 30; i++)
342 {
343 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
344 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)))
345 {
346 assert(reg.inRegion(i) == true);
347 }
348 else
349 {
350 assert(reg.inRegion(i) == false);
351 }
352 }
353
354 // Completely in region to right.
355 reg.add(22,24);
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);
362 ++iter;
363 assert(iter->first == 8);
364 assert(iter->second == 9);
365 ++iter;
366 assert(iter->first == 12);
367 assert(iter->second == 19);
368 ++iter;
369 assert(iter->first == 20);
370 assert(iter->second == 26);
371 ++iter;
372 assert(iter == reg.myRegions.end());
373 for(int i = 0; i < 30; i++)
374 {
375 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
376 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)))
377 {
378 assert(reg.inRegion(i) == true);
379 }
380 else
381 {
382 assert(reg.inRegion(i) == false);
383 }
384 }
385
386 // Add region to right.
387 reg.add(28,29);
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);
394 ++iter;
395 assert(iter->first == 8);
396 assert(iter->second == 9);
397 ++iter;
398 assert(iter->first == 12);
399 assert(iter->second == 19);
400 ++iter;
401 assert(iter->first == 20);
402 assert(iter->second == 26);
403 ++iter;
404 assert(iter->first == 28);
405 assert(iter->second == 29);
406 ++iter;
407 assert(iter == reg.myRegions.end());
408 for(int i = 0; i < 30; i++)
409 {
410 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
411 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)) ||
412 ((i >= 28) && (i < 29)))
413 {
414 assert(reg.inRegion(i) == true);
415 }
416 else
417 {
418 assert(reg.inRegion(i) == false);
419 }
420 }
421
422 // Add region to left, start is in the region, and end extends past.
423 reg.add(8,10);
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);
430 ++iter;
431 assert(iter->first == 8);
432 assert(iter->second == 10);
433 ++iter;
434 assert(iter->first == 12);
435 assert(iter->second == 19);
436 ++iter;
437 assert(iter->first == 20);
438 assert(iter->second == 26);
439 ++iter;
440 assert(iter->first == 28);
441 assert(iter->second == 29);
442 ++iter;
443 assert(iter == reg.myRegions.end());
444 for(int i = 0; i < 30; i++)
445 {
446 if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 10)) ||
447 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)) ||
448 ((i >= 28) && (i < 29)))
449 {
450 assert(reg.inRegion(i) == true);
451 }
452 else
453 {
454 assert(reg.inRegion(i) == false);
455 }
456 }
457
458 // Add region start is in the region, and end extends past and overlaps
459 // the next region.
460 reg.add(5,9);
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);
467 ++iter;
468 assert(iter->first == 12);
469 assert(iter->second == 19);
470 ++iter;
471 assert(iter->first == 20);
472 assert(iter->second == 26);
473 ++iter;
474 assert(iter->first == 28);
475 assert(iter->second == 29);
476 ++iter;
477 assert(iter == reg.myRegions.end());
478 for(int i = 0; i < 30; i++)
479 {
480 if(((i >= 4) && (i < 10)) ||
481 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)) ||
482 ((i >= 28) && (i < 29)))
483 {
484 assert(reg.inRegion(i) == true);
485 }
486 else
487 {
488 assert(reg.inRegion(i) == false);
489 }
490 }
491
492 // Add region start is in the region, and end extends past and overlaps
493 // the next region.
494 reg.add(10,11);
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);
501 ++iter;
502 assert(iter->first == 10);
503 assert(iter->second == 11);
504 ++iter;
505 assert(iter->first == 12);
506 assert(iter->second == 19);
507 ++iter;
508 assert(iter->first == 20);
509 assert(iter->second == 26);
510 ++iter;
511 assert(iter->first == 28);
512 assert(iter->second == 29);
513 ++iter;
514 assert(iter == reg.myRegions.end());
515 for(int i = 0; i < 30; i++)
516 {
517 if(((i >= 4) && (i < 10)) || ((i >= 10) && (i < 11)) ||
518 ((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)) ||
519 ((i >= 28) && (i < 29)))
520 {
521 assert(reg.inRegion(i) == true);
522 }
523 else
524 {
525 assert(reg.inRegion(i) == false);
526 }
527 }
528
529 // Add region start is in the region, and end extends past and overlaps
530 // the next 2 regions.
531 reg.add(10,24);
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);
538 ++iter;
539 assert(iter->first == 10);
540 assert(iter->second == 26);
541 ++iter;
542 assert(iter->first == 28);
543 assert(iter->second == 29);
544 ++iter;
545 assert(iter == reg.myRegions.end());
546 for(int i = 0; i < 30; i++)
547 {
548 if(((i >= 4) && (i < 10)) || ((i >= 10) && (i < 26)) ||
549 ((i >= 28) && (i < 29)))
550 {
551 assert(reg.inRegion(i) == true);
552 }
553 else
554 {
555 assert(reg.inRegion(i) == false);
556 }
557 }
558
559 // Add region start outside of a region and ends at the end.
560 reg.add(2,30);
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);
567 ++iter;
568 assert(iter == reg.myRegions.end());
569 for(int i = 0; i < 50; i++)
570 {
571 if(((i >= 2) && (i < 30)))
572 {
573 assert(reg.inRegion(i) == true);
574 }
575 else
576 {
577 assert(reg.inRegion(i) == false);
578 }
579 }
580
581 // Add invalid region (start = end)
582 reg.add(40,40);
583 assert(reg.myRegions.size() == 1);
584 iter = reg.myRegions.begin();
585 assert(iter->first == 2);
586 assert(iter->second == 30);
587 ++iter;
588 assert(iter == reg.myRegions.end());
589 for(int i = 0; i < 50; i++)
590 {
591 if(((i >= 2) && (i < 30)))
592 {
593 assert(reg.inRegion(i) == true);
594 }
595 else
596 {
597 assert(reg.inRegion(i) == false);
598 }
599 }
600
601 // Add invalid region (start < end)
602 reg.add(40, 38);
603 assert(reg.myRegions.size() == 1);
604 iter = reg.myRegions.begin();
605 assert(iter->first == 2);
606 assert(iter->second == 30);
607 ++iter;
608 assert(iter == reg.myRegions.end());
609 for(int i = 0; i < 50; i++)
610 {
611 if(((i >= 2) && (i < 30)))
612 {
613 assert(reg.inRegion(i) == true);
614 }
615 else
616 {
617 assert(reg.inRegion(i) == false);
618 }
619 }
620}
This class contains a list of non-overlapping regions, just positions, not including chromosomes (see...
void add(int32_t start, int32_t end)
End position is not included in the region.
bool inRegion(int32_t pos)
Return whether or not the position was found within a region.
This class contains a list of non-overlapping regions.
bool inRegion(const char *chrom, 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.