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 
22 int main(int argc, char ** argv)
23 {
24 
25  NonOverlapRegionsTest myTest;
26 
27  myTest.test();
28 }
29 
30 void NonOverlapRegionsTest::test()
31 {
32  testPos();
33  testChrom();
34 }
35 
36 
37 void 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 
102 void 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 }
NonOverlapRegionPos
This class contains a list of non-overlapping regions, just positions, not including chromosomes (see...
Definition: NonOverlapRegions.h:33
NonOverlapRegionsTest
Definition: NonOverlapRegionsTest.h:21
NonOverlapRegionPos::add
void add(int32_t start, int32_t end)
End position is not included in the region.
Definition: NonOverlapRegions.cpp:75
NonOverlapRegionPos::inRegion
bool inRegion(int32_t pos)
Return whether or not the position was found within a region.
Definition: NonOverlapRegions.cpp:155
NonOverlapRegions
This class contains a list of non-overlapping regions.
Definition: NonOverlapRegions.h:83
NonOverlapRegions::inRegion
bool inRegion(const char *chrom, int32_t pos)
Return whether or not the position was found within a region.
Definition: NonOverlapRegions.cpp:42
NonOverlapRegions::add
void add(const char *chrom, int32_t start, int32_t end)
End position is not included in the region.
Definition: NonOverlapRegions.cpp:35