Loading...
Searching...
No Matches
NonOverlapRegionsTest.cpp
/*
* Copyright (C) 2011 Regents of the University of Michigan
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "NonOverlapRegions.h"
#include "NonOverlapRegionsTest.h"
#include <assert.h>
#include <iostream>
int main(int argc, char ** argv)
{
NonOverlapRegionsTest myTest;
myTest.test();
}
void NonOverlapRegionsTest::test()
{
testPos();
testChrom();
}
void NonOverlapRegionsTest::testChrom()
{
NonOverlapRegions reg;
// Assert that the regions are empty.
assert(reg.myRegions.size() == 0);
// Verify no regions.
for(int i = 0; i < 30; i++)
{
assert(reg.inRegion("a", i) == false);
assert(reg.inRegion("3", i) == false);
}
// The chromosomes checked for were added.
assert(reg.myRegions.size() == 2);
assert(reg.myRegions["a"].myRegions.size() == 0);
assert(reg.myRegions["a"].myRegionIter ==
reg.myRegions["a"].myRegions.end());
assert(reg.myRegions["3"].myRegions.size() == 0);
assert(reg.myRegions["3"].myRegionIter ==
reg.myRegions["3"].myRegions.end());
// Add a region.
reg.add("3", 13, 15);
// Verify regions.
assert(reg.myRegions.size() == 2);
for(int i = 0; i < 30; i++)
{
assert(reg.inRegion("a", i) == false);
if((i >= 13) && (i < 15))
{
assert(reg.inRegion("3", i) == true);
}
else
{
assert(reg.inRegion("3", i) == false);
}
}
// Add a region.
reg.add("a", 1, 5);
// Verify regions.
assert(reg.myRegions.size() == 2);
for(int i = 0; i < 30; i++)
{
if((i >= 1) && (i < 5))
{
assert(reg.inRegion("a", i) == true);
}
else
{
assert(reg.inRegion("a", i) == false);
}
if((i >= 13) && (i < 15))
{
assert(reg.inRegion("3", i) == true);
}
else
{
assert(reg.inRegion("3", i) == false);
}
}
}
void NonOverlapRegionsTest::testPos()
{
NonOverlapRegionPos reg;
std::list< std::pair<int32_t, int32_t> >::iterator iter;
// Assert that the regions are empty.
assert(reg.myRegions.empty());
assert(reg.myRegionIter == reg.myRegions.end());
assert(reg.myTmpIter == reg.myRegions.end());
// Verify regions.
for(int i = 0; i < 30; i++)
{
assert(reg.inRegion(i) == false);
}
// Add a region
reg.add(13, 15);
// Verify regions.
assert(reg.myRegions.size() == 1);
assert(reg.myRegionIter->first == 13);
assert(reg.myRegionIter->second == 15);
for(int i = 0; i < 30; i++)
{
if((i >= 13) && (i < 15))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Insert before this.
reg.add(4,6);
assert(reg.myRegions.size() == 2);
assert(reg.myRegionIter->first == 4);
assert(reg.myRegionIter->second == 6);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 6);
++iter;
assert(iter->first == 13);
assert(iter->second == 15);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 6)) || ((i >= 13) && (i < 15)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Insert at the end.
reg.add(22,26);
assert(reg.myRegions.size() == 3);
assert(reg.myRegionIter->first == 22);
assert(reg.myRegionIter->second == 26);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 6);
++iter;
assert(iter->first == 13);
assert(iter->second == 15);
++iter;
assert(iter->first == 22);
assert(iter->second == 26);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 6)) || ((i >= 13) && (i < 15)) ||
((i >= 22) && (i < 26)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Insert in the middle.
reg.add(8,9);
assert(reg.myRegions.size() == 4);
assert(reg.myRegionIter->first == 8);
assert(reg.myRegionIter->second == 9);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 6);
++iter;
assert(iter->first == 8);
assert(iter->second == 9);
++iter;
assert(iter->first == 13);
assert(iter->second == 15);
++iter;
assert(iter->first == 22);
assert(iter->second == 26);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
((i >= 13) && (i < 15)) || ((i >= 22) && (i < 26)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Insert start does not overlap, but the end does.
reg.add(20,24);
assert(reg.myRegions.size() == 4);
assert(reg.myRegionIter->first == 20);
assert(reg.myRegionIter->second == 26);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 6);
++iter;
assert(iter->first == 8);
assert(iter->second == 9);
++iter;
assert(iter->first == 13);
assert(iter->second == 15);
++iter;
assert(iter->first == 20);
assert(iter->second == 26);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
((i >= 13) && (i < 15)) || ((i >= 20) && (i < 26)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Add another region
reg.add(18,19);
assert(reg.myRegions.size() == 5);
assert(reg.myRegionIter->first == 18);
assert(reg.myRegionIter->second == 19);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 6);
++iter;
assert(iter->first == 8);
assert(iter->second == 9);
++iter;
assert(iter->first == 13);
assert(iter->second == 15);
++iter;
assert(iter->first == 18);
assert(iter->second == 19);
++iter;
assert(iter->first == 20);
assert(iter->second == 26);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
((i >= 13) && (i < 15)) || ((i >= 18) && (i < 19)) ||
((i >= 20) && (i < 26)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Start is not in, but overlap two others (ending not at the end).
reg.add(12,19);
assert(reg.myRegions.size() == 4);
assert(reg.myRegionIter->first == 12);
assert(reg.myRegionIter->second == 19);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 6);
++iter;
assert(iter->first == 8);
assert(iter->second == 9);
++iter;
assert(iter->first == 12);
assert(iter->second == 19);
++iter;
assert(iter->first == 20);
assert(iter->second == 26);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Completely in region to left.
reg.add(5,6);
assert(reg.myRegions.size() == 4);
assert(reg.myRegionIter->first == 4);
assert(reg.myRegionIter->second == 6);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 6);
++iter;
assert(iter->first == 8);
assert(iter->second == 9);
++iter;
assert(iter->first == 12);
assert(iter->second == 19);
++iter;
assert(iter->first == 20);
assert(iter->second == 26);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Completely in region to right.
reg.add(22,24);
assert(reg.myRegions.size() == 4);
assert(reg.myRegionIter->first == 20);
assert(reg.myRegionIter->second == 26);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 6);
++iter;
assert(iter->first == 8);
assert(iter->second == 9);
++iter;
assert(iter->first == 12);
assert(iter->second == 19);
++iter;
assert(iter->first == 20);
assert(iter->second == 26);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Add region to right.
reg.add(28,29);
assert(reg.myRegions.size() == 5);
assert(reg.myRegionIter->first == 28);
assert(reg.myRegionIter->second == 29);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 6);
++iter;
assert(iter->first == 8);
assert(iter->second == 9);
++iter;
assert(iter->first == 12);
assert(iter->second == 19);
++iter;
assert(iter->first == 20);
assert(iter->second == 26);
++iter;
assert(iter->first == 28);
assert(iter->second == 29);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 9)) ||
((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)) ||
((i >= 28) && (i < 29)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Add region to left, start is in the region, and end extends past.
reg.add(8,10);
assert(reg.myRegions.size() == 5);
assert(reg.myRegionIter->first == 8);
assert(reg.myRegionIter->second == 10);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 6);
++iter;
assert(iter->first == 8);
assert(iter->second == 10);
++iter;
assert(iter->first == 12);
assert(iter->second == 19);
++iter;
assert(iter->first == 20);
assert(iter->second == 26);
++iter;
assert(iter->first == 28);
assert(iter->second == 29);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 6)) || ((i >= 8) && (i < 10)) ||
((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)) ||
((i >= 28) && (i < 29)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Add region start is in the region, and end extends past and overlaps
// the next region.
reg.add(5,9);
assert(reg.myRegions.size() == 4);
assert(reg.myRegionIter->first == 4);
assert(reg.myRegionIter->second == 10);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 10);
++iter;
assert(iter->first == 12);
assert(iter->second == 19);
++iter;
assert(iter->first == 20);
assert(iter->second == 26);
++iter;
assert(iter->first == 28);
assert(iter->second == 29);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 10)) ||
((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)) ||
((i >= 28) && (i < 29)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Add region start is in the region, and end extends past and overlaps
// the next region.
reg.add(10,11);
assert(reg.myRegions.size() == 5);
assert(reg.myRegionIter->first == 10);
assert(reg.myRegionIter->second == 11);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 10);
++iter;
assert(iter->first == 10);
assert(iter->second == 11);
++iter;
assert(iter->first == 12);
assert(iter->second == 19);
++iter;
assert(iter->first == 20);
assert(iter->second == 26);
++iter;
assert(iter->first == 28);
assert(iter->second == 29);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 10)) || ((i >= 10) && (i < 11)) ||
((i >= 12) && (i < 19)) || ((i >= 20) && (i < 26)) ||
((i >= 28) && (i < 29)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Add region start is in the region, and end extends past and overlaps
// the next 2 regions.
reg.add(10,24);
assert(reg.myRegions.size() == 3);
assert(reg.myRegionIter->first == 10);
assert(reg.myRegionIter->second == 26);
iter = reg.myRegions.begin();
assert(iter->first == 4);
assert(iter->second == 10);
++iter;
assert(iter->first == 10);
assert(iter->second == 26);
++iter;
assert(iter->first == 28);
assert(iter->second == 29);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 30; i++)
{
if(((i >= 4) && (i < 10)) || ((i >= 10) && (i < 26)) ||
((i >= 28) && (i < 29)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Add region start outside of a region and ends at the end.
reg.add(2,30);
assert(reg.myRegions.size() == 1);
assert(reg.myRegionIter->first == 2);
assert(reg.myRegionIter->second == 30);
iter = reg.myRegions.begin();
assert(iter->first == 2);
assert(iter->second == 30);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 50; i++)
{
if(((i >= 2) && (i < 30)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Add invalid region (start = end)
reg.add(40,40);
assert(reg.myRegions.size() == 1);
iter = reg.myRegions.begin();
assert(iter->first == 2);
assert(iter->second == 30);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 50; i++)
{
if(((i >= 2) && (i < 30)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
// Add invalid region (start < end)
reg.add(40, 38);
assert(reg.myRegions.size() == 1);
iter = reg.myRegions.begin();
assert(iter->first == 2);
assert(iter->second == 30);
++iter;
assert(iter == reg.myRegions.end());
for(int i = 0; i < 50; i++)
{
if(((i >= 2) && (i < 30)))
{
assert(reg.inRegion(i) == true);
}
else
{
assert(reg.inRegion(i) == false);
}
}
}
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
NonOverlapRegionsTest
Definition NonOverlapRegionsTest.h:22
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