X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Futil%2FMapListTest.java;h=3f1f7f3b68550a66895d64cdb0c99b03bd619b9e;hb=27aed96d1aeae689818bd0a0028553186e3c3839;hp=86dcc39b267c2239216a2427ca5f0dd00fa06021;hpb=10dd3a771da0085ead2318b7385211c7b675d7f4;p=jalview.git diff --git a/test/jalview/util/MapListTest.java b/test/jalview/util/MapListTest.java index 86dcc39..3f1f7f3 100644 --- a/test/jalview/util/MapListTest.java +++ b/test/jalview/util/MapListTest.java @@ -25,20 +25,28 @@ import static org.testng.AssertJUnit.assertFalse; import static org.testng.AssertJUnit.assertNull; import static org.testng.AssertJUnit.assertSame; import static org.testng.AssertJUnit.assertTrue; +import static org.testng.AssertJUnit.fail; import static org.testng.internal.junit.ArrayAsserts.assertArrayEquals; -import jalview.gui.JvOptionPane; - import java.util.ArrayList; import java.util.Arrays; +import java.util.BitSet; import java.util.List; import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; +import jalview.bin.Cache; +import jalview.gui.JvOptionPane; + public class MapListTest { - + @BeforeClass(alwaysRun = true) + public void setUp() + { + Cache.initLogger(); + } + @BeforeClass(alwaysRun = true) public void setUpJvOptionPane() { @@ -46,20 +54,23 @@ public class MapListTest JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); } - @Test(groups = { "Functional" }) + @Test(groups = { "Functional" }, enabled = false) public void testSomething() { - MapList ml = new MapList(new int[] { 1, 5, 10, 15, 25, 20 }, new int[] { - 51, 1 }, 1, 3); + MapList ml = new MapList(new int[] { 1, 5, 10, 15, 25, 20 }, + new int[] + { 51, 1 }, 1, 3); MapList ml1 = new MapList(new int[] { 1, 3, 17, 4 }, - new int[] { 51, 1 }, 1, 3); + new int[] + { 51, 1 }, 1, 3); MapList ml2 = new MapList(new int[] { 1, 60 }, new int[] { 1, 20 }, 3, 1); // test internal consistency int to[] = new int[51]; testMap(ml, 1, 60); - MapList mldna = new MapList(new int[] { 2, 2, 6, 8, 12, 16 }, new int[] - { 1, 3 }, 3, 1); + MapList mldna = new MapList(new int[] { 2, 2, 6, 8, 12, 16 }, + new int[] + { 1, 3 }, 3, 1); int[] frm = mldna.locateInFrom(1, 1); testLocateFrom(mldna, 1, 1, new int[] { 2, 2, 6, 7 }); testMap(mldna, 1, 3); @@ -261,15 +272,25 @@ public class MapListTest assertEquals("[10, 12]", Arrays.toString(ml.locateInFrom(4, 4))); assertEquals("[1, 6]", Arrays.toString(ml.locateInFrom(1, 2))); assertEquals("[1, 9]", Arrays.toString(ml.locateInFrom(1, 3))); + // reversed range treated as if forwards: + assertEquals("[1, 9]", Arrays.toString(ml.locateInFrom(3, 1))); assertEquals("[1, 12]", Arrays.toString(ml.locateInFrom(1, 4))); assertEquals("[4, 9]", Arrays.toString(ml.locateInFrom(2, 3))); assertEquals("[4, 12]", Arrays.toString(ml.locateInFrom(2, 4))); assertEquals("[7, 12]", Arrays.toString(ml.locateInFrom(3, 4))); assertEquals("[10, 12]", Arrays.toString(ml.locateInFrom(4, 4))); + /* + * partial overlap + */ + assertEquals("[1, 12]", Arrays.toString(ml.locateInFrom(1, 5))); + assertEquals("[1, 3]", Arrays.toString(ml.locateInFrom(-1, 1))); + + /* + * no overlap + */ assertNull(ml.locateInFrom(0, 0)); - assertNull(ml.locateInFrom(1, 5)); - assertNull(ml.locateInFrom(-1, 1)); + } /** @@ -291,6 +312,28 @@ public class MapListTest assertEquals("[10, 10, 12, 12, 14, 14]", Arrays.toString(ml.locateInFrom(3, 3))); assertEquals("[16, 18]", Arrays.toString(ml.locateInFrom(4, 4))); + + /* + * codons at 11-16, 21-26, 31-36 mapped to peptide positions 1, 3-4, 6-8 + */ + ml = new MapList(new int[] { 11, 16, 21, 26, 31, 36 }, + new int[] + { 1, 1, 3, 4, 6, 8 }, 3, 1); + assertArrayEquals(new int[] { 11, 13 }, ml.locateInFrom(1, 1)); + assertArrayEquals(new int[] { 11, 16 }, ml.locateInFrom(1, 3)); + assertArrayEquals(new int[] { 11, 16, 21, 23 }, ml.locateInFrom(1, 4)); + assertArrayEquals(new int[] { 14, 16, 21, 23 }, ml.locateInFrom(3, 4)); + + } + + @Test(groups = { "Functional" }) + public void testLocateInFrom_reverseStrand() + { + int[] codons = new int[] { 12, 1 }; + int[] protein = new int[] { 1, 4 }; + MapList ml = new MapList(codons, protein, 3, 1); + assertEquals("[12, 10]", Arrays.toString(ml.locateInFrom(1, 1))); + assertEquals("[9, 4]", Arrays.toString(ml.locateInFrom(2, 3))); } /** @@ -315,6 +358,8 @@ public class MapListTest assertEquals("[1, 4]", Arrays.toString(ml.locateInTo(1, 12))); assertEquals("[2, 2]", Arrays.toString(ml.locateInTo(4, 6))); assertEquals("[2, 4]", Arrays.toString(ml.locateInTo(4, 12))); + // reverse range treated as if forwards: + assertEquals("[2, 4]", Arrays.toString(ml.locateInTo(12, 4))); /* * A part codon is treated as if a whole one. @@ -326,9 +371,16 @@ public class MapListTest assertEquals("[1, 4]", Arrays.toString(ml.locateInTo(3, 11))); assertEquals("[2, 4]", Arrays.toString(ml.locateInTo(5, 11))); + /* + * partial overlap + */ + assertEquals("[1, 4]", Arrays.toString(ml.locateInTo(1, 13))); + assertEquals("[1, 1]", Arrays.toString(ml.locateInTo(-1, 2))); + + /* + * no overlap + */ assertNull(ml.locateInTo(0, 0)); - assertNull(ml.locateInTo(1, 13)); - assertNull(ml.locateInTo(-1, 1)); } /** @@ -350,14 +402,7 @@ public class MapListTest MapList ml = new MapList(codons, protein, 3, 1); /* - * Can't map from an unmapped position - */ - assertNull(ml.locateInTo(1, 2)); - assertNull(ml.locateInTo(2, 4)); - assertNull(ml.locateInTo(4, 4)); - - /* - * Valid range or subrange of codon1 maps to protein1. + * Valid range or subrange of codon1 maps to protein1 */ assertEquals("[1, 1]", Arrays.toString(ml.locateInTo(2, 2))); assertEquals("[1, 1]", Arrays.toString(ml.locateInTo(3, 3))); @@ -371,6 +416,17 @@ public class MapListTest // codon positions 7 to 17 (part) cover proteins 2/3/4 at positions 3/4/6 assertEquals("[3, 4, 6, 6]", Arrays.toString(ml.locateInTo(7, 17))); + /* + * partial overlap + */ + assertEquals("[1, 1]", Arrays.toString(ml.locateInTo(1, 2))); + assertEquals("[1, 1]", Arrays.toString(ml.locateInTo(1, 4))); + assertEquals("[1, 1]", Arrays.toString(ml.locateInTo(2, 4))); + + /* + * no overlap + */ + assertNull(ml.locateInTo(4, 4)); } /** @@ -431,7 +487,8 @@ public class MapListTest List ranges = new ArrayList<>(); ranges.add(new int[] { 2, 3 }); ranges.add(new int[] { 5, 6 }); - assertEquals("[2, 3, 5, 6]", Arrays.toString(MapList.getRanges(ranges))); + assertEquals("[2, 3, 5, 6]", + Arrays.toString(MapList.getRanges(ranges))); } /** @@ -463,7 +520,8 @@ public class MapListTest assertEquals(6, ml2.getToHighest()); assertEquals("{[2, 3], [5, 7], [9, 10], [12, 12], [14, 14], [16, 18]}", prettyPrint(ml2.getFromRanges())); - assertEquals("{[1, 1], [3, 4], [6, 6]}", prettyPrint(ml2.getToRanges())); + assertEquals("{[1, 1], [3, 4], [6, 6]}", + prettyPrint(ml2.getToRanges())); /* * reverse direction @@ -478,22 +536,23 @@ public class MapListTest } /** - * Test constructor can merge consecutive ranges + * Test constructor used to merge consecutive ranges but now just leaves them + * as supplied (JAL-3751) */ @Test(groups = { "Functional" }) public void testConstructor_mergeRanges() { - int[] codons = { 2, 3, 3, 7, 9, 10, 12, 12, 14, 14, 16, 17 }; - int[] protein = { 1, 1, 1, 3, 6, 6 }; + int[] codons = { 2, 3, 3, 7, 9, 10, 12, 12, 13, 14, 16, 17 }; + int[] protein = { 1, 1, 2, 3, 6, 6 }; MapList ml = new MapList(codons, protein, 3, 1); assertEquals(3, ml.getFromRatio()); assertEquals(2, ml.getFromLowest()); assertEquals(17, ml.getFromHighest()); assertEquals(1, ml.getToLowest()); assertEquals(6, ml.getToHighest()); - assertEquals("{[2, 7], [9, 10], [12, 12], [14, 14], [16, 17]}", + assertEquals("{[2, 3], [3, 7], [9, 10], [12, 12], [13, 14], [16, 17]}", prettyPrint(ml.getFromRanges())); - assertEquals("{[1, 3], [6, 6]}", prettyPrint(ml.getToRanges())); + assertEquals("{[1, 1], [2, 3], [6, 6]}", prettyPrint(ml.getToRanges())); } /** @@ -544,8 +603,9 @@ public class MapListTest @Test(groups = { "Functional" }) public void testToString() { - MapList ml = new MapList(new int[] { 1, 5, 10, 15, 25, 20 }, new int[] { - 51, 1 }, 1, 3); + MapList ml = new MapList(new int[] { 1, 5, 10, 15, 25, 20 }, + new int[] + { 51, 1 }, 1, 3); String s = ml.toString(); assertEquals("[ [1, 5] [10, 15] [25, 20] ] 1:3 to [ [51, 1] ]", s); } @@ -554,14 +614,16 @@ public class MapListTest public void testAddMapList() { MapList ml = new MapList(new int[] { 11, 15, 20, 25, 35, 30 }, - new int[] { 72, 22 }, 1, 3); + new int[] + { 72, 22 }, 1, 3); assertEquals(11, ml.getFromLowest()); assertEquals(35, ml.getFromHighest()); assertEquals(22, ml.getToLowest()); assertEquals(72, ml.getToHighest()); - MapList ml2 = new MapList(new int[] { 2, 4, 37, 40 }, new int[] { 12, - 17, 78, 83, 88, 96 }, 1, 3); + MapList ml2 = new MapList(new int[] { 2, 4, 37, 40 }, + new int[] + { 12, 17, 78, 83, 88, 96 }, 1, 3); ml.addMapList(ml2); assertEquals(2, ml.getFromLowest()); assertEquals(40, ml.getFromHighest()); @@ -581,7 +643,8 @@ public class MapListTest public void testAddMapList_sameMap() { MapList ml = new MapList(new int[] { 11, 15, 20, 25, 35, 30 }, - new int[] { 72, 22 }, 1, 3); + new int[] + { 72, 22 }, 1, 3); String before = ml.toString(); ml.addMapList(ml); assertEquals(before, ml.toString()); @@ -595,8 +658,8 @@ public class MapListTest MapList ml = new MapList(new int[] { 11, 15 }, new int[] { 72, 58 }, 1, 3); - MapList ml2 = new MapList(new int[] { 15, 16 }, new int[] { 58, 53 }, - 1, 3); + MapList ml2 = new MapList(new int[] { 15, 16 }, new int[] { 58, 53 }, 1, + 3); ml.addMapList(ml2); assertEquals("[ [11, 16] ] 1:3 to [ [72, 53] ]", ml.toString()); } @@ -682,13 +745,15 @@ public class MapListTest public void testIsFromForwardStrand() { // [3-9] declares forward strand - MapList ml = new MapList(new int[] { 2, 2, 3, 9, 12, 11 }, new int[] { - 20, 11 }, 1, 1); + MapList ml = new MapList(new int[] { 2, 2, 3, 9, 12, 11 }, + new int[] + { 20, 11 }, 1, 1); assertTrue(ml.isFromForwardStrand()); // [11-5] declares reverse strand ([13-14] is ignored) ml = new MapList(new int[] { 2, 2, 11, 5, 13, 14 }, - new int[] { 20, 11 }, 1, 1); + new int[] + { 20, 11 }, 1, 1); assertFalse(ml.isFromForwardStrand()); // all single position ranges - defaults to forward strand @@ -698,7 +763,7 @@ public class MapListTest } /** - * Test the method that merges a list of ranges where possible + * Test the method that merges contiguous ranges */ @Test(groups = { "Functional" }) public void testCoalesceRanges() @@ -720,101 +785,58 @@ public class MapListTest // merging in forward direction: ranges.clear(); ranges.add(new int[] { 1, 3 }); - ranges.add(new int[] { 4, 5 }); - ranges.add(new int[] { 5, 5 }); - ranges.add(new int[] { 5, 7 }); + ranges.add(new int[] { 4, 5 }); // contiguous + ranges.add(new int[] { 5, 5 }); // overlap! + ranges.add(new int[] { 6, 7 }); // contiguous List merged = MapList.coalesceRanges(ranges); - assertEquals(1, merged.size()); - assertArrayEquals(new int[] { 1, 7 }, merged.get(0)); + assertEquals(2, merged.size()); + assertArrayEquals(new int[] { 1, 5 }, merged.get(0)); + assertArrayEquals(new int[] { 5, 7 }, merged.get(1)); // verify input list is unchanged assertEquals(4, ranges.size()); assertArrayEquals(new int[] { 1, 3 }, ranges.get(0)); assertArrayEquals(new int[] { 4, 5 }, ranges.get(1)); assertArrayEquals(new int[] { 5, 5 }, ranges.get(2)); - assertArrayEquals(new int[] { 5, 7 }, ranges.get(3)); + assertArrayEquals(new int[] { 6, 7 }, ranges.get(3)); // merging in reverse direction: ranges.clear(); ranges.add(new int[] { 7, 5 }); - ranges.add(new int[] { 5, 4 }); - ranges.add(new int[] { 4, 4 }); - ranges.add(new int[] { 3, 1 }); + ranges.add(new int[] { 5, 4 }); // overlap + ranges.add(new int[] { 4, 4 }); // overlap + ranges.add(new int[] { 3, 1 }); // contiguous merged = MapList.coalesceRanges(ranges); - assertEquals(1, merged.size()); - assertArrayEquals(new int[] { 7, 1 }, merged.get(0)); + assertEquals(3, merged.size()); + assertArrayEquals(new int[] { 7, 5 }, merged.get(0)); + assertArrayEquals(new int[] { 5, 4 }, merged.get(1)); + assertArrayEquals(new int[] { 4, 1 }, merged.get(2)); // merging with switches of direction: ranges.clear(); ranges.add(new int[] { 1, 3 }); - ranges.add(new int[] { 4, 5 }); - ranges.add(new int[] { 5, 5 }); - ranges.add(new int[] { 6, 6 }); + ranges.add(new int[] { 4, 5 }); // contiguous + ranges.add(new int[] { 5, 5 }); // overlap + ranges.add(new int[] { 6, 6 }); // contiguous ranges.add(new int[] { 12, 10 }); - ranges.add(new int[] { 9, 8 }); - ranges.add(new int[] { 8, 8 }); - ranges.add(new int[] { 7, 7 }); + ranges.add(new int[] { 9, 8 }); // contiguous + ranges.add(new int[] { 8, 8 }); // overlap + ranges.add(new int[] { 7, 7 }); // contiguous merged = MapList.coalesceRanges(ranges); - assertEquals(2, merged.size()); - assertArrayEquals(new int[] { 1, 6 }, merged.get(0)); - assertArrayEquals(new int[] { 12, 7 }, merged.get(1)); - } - - /** - * Test the method that merges a list of ranges where possible - */ - @Test(groups = { "Functional" }) - public void testCoalesceRanges_withOverlap() - { - List ranges = new ArrayList<>(); - ranges.add(new int[] { 1, 3 }); - ranges.add(new int[] { 2, 5 }); - - /* - * [2, 5] should extend [1, 3] - */ - List merged = MapList.coalesceRanges(ranges); - assertEquals(1, merged.size()); + assertEquals(4, merged.size()); assertArrayEquals(new int[] { 1, 5 }, merged.get(0)); - - /* - * a subsumed interval should be dropped - */ - ranges.clear(); - ranges.add(new int[] { 1, 6 }); - ranges.add(new int[] { 2, 4 }); - merged = MapList.coalesceRanges(ranges); - assertEquals(1, merged.size()); - assertArrayEquals(new int[] { 1, 6 }, merged.get(0)); - + assertArrayEquals(new int[] { 5, 6 }, merged.get(1)); + assertArrayEquals(new int[] { 12, 8 }, merged.get(2)); + assertArrayEquals(new int[] { 8, 7 }, merged.get(3)); + + // 'subsumed' ranges are preserved ranges.clear(); - ranges.add(new int[] { 1, 5 }); - ranges.add(new int[] { 1, 6 }); - merged = MapList.coalesceRanges(ranges); - assertEquals(1, merged.size()); - assertArrayEquals(new int[] { 1, 6 }, merged.get(0)); - - /* - * merge duplicate ranges - */ - ranges.clear(); - ranges.add(new int[] { 1, 3 }); - ranges.add(new int[] { 1, 3 }); - merged = MapList.coalesceRanges(ranges); - assertEquals(1, merged.size()); - assertArrayEquals(new int[] { 1, 3 }, merged.get(0)); + ranges.add(new int[] { 10, 30 }); + ranges.add(new int[] { 15, 25 }); - /* - * reverse direction - */ - ranges.clear(); - ranges.add(new int[] { 9, 5 }); - ranges.add(new int[] { 9, 4 }); - ranges.add(new int[] { 8, 3 }); - ranges.add(new int[] { 3, 2 }); - ranges.add(new int[] { 1, 0 }); merged = MapList.coalesceRanges(ranges); - assertEquals(1, merged.size()); - assertArrayEquals(new int[] { 9, 0 }, merged.get(0)); + assertEquals(2, merged.size()); + assertArrayEquals(new int[] { 10, 30 }, merged.get(0)); + assertArrayEquals(new int[] { 15, 25 }, merged.get(1)); } /** @@ -826,13 +848,15 @@ public class MapListTest /* * simple 1:1 plus 1:1 forwards */ - MapList ml1 = new MapList(new int[] { 3, 4, 8, 12 }, new int[] { 5, 8, - 11, 13 }, 1, 1); + MapList ml1 = new MapList(new int[] { 3, 4, 8, 12 }, + new int[] + { 5, 8, 11, 13 }, 1, 1); assertEquals("{[3, 4], [8, 12]}", prettyPrint(ml1.getFromRanges())); assertEquals("{[5, 8], [11, 13]}", prettyPrint(ml1.getToRanges())); - MapList ml2 = new MapList(new int[] { 1, 50 }, new int[] { 40, 45, 70, - 75, 90, 127 }, 1, 1); + MapList ml2 = new MapList(new int[] { 1, 50 }, + new int[] + { 40, 45, 70, 75, 90, 127 }, 1, 1); assertEquals("{[1, 50]}", prettyPrint(ml2.getFromRanges())); assertEquals("{[40, 45], [70, 75], [90, 127]}", prettyPrint(ml2.getToRanges())); @@ -859,7 +883,8 @@ public class MapListTest */ ml1 = new MapList(new int[] { 1, 50 }, new int[] { 70, 119 }, 1, 1); ml2 = new MapList(new int[] { 1, 500 }, - new int[] { 1000, 901, 600, 201 }, 1, 1); + new int[] + { 1000, 901, 600, 201 }, 1, 1); compound = ml1.traverse(ml2); assertEquals(1, compound.getFromRatio()); @@ -870,14 +895,14 @@ public class MapListTest toRanges = compound.getToRanges(); assertEquals(2, toRanges.size()); assertArrayEquals(new int[] { 931, 901 }, toRanges.get(0)); - assertArrayEquals(new int[] { 600, 582 }, toRanges.get(1)); + assertArrayEquals(new int[] { 600, 582}, toRanges.get(1)); /* * 1:1 plus 1:3 should result in 1:3 */ ml1 = new MapList(new int[] { 1, 30 }, new int[] { 11, 40 }, 1, 1); - ml2 = new MapList(new int[] { 1, 100 }, new int[] { 1, 50, 91, 340 }, - 1, 3); + ml2 = new MapList(new int[] { 1, 100 }, new int[] { 1, 50, 91, 340 }, 1, + 3); compound = ml1.traverse(ml2); assertEquals(1, compound.getFromRatio()); @@ -895,8 +920,8 @@ public class MapListTest * 3:1 plus 1:1 should result in 3:1 */ ml1 = new MapList(new int[] { 1, 30 }, new int[] { 11, 20 }, 3, 1); - ml2 = new MapList(new int[] { 1, 100 }, new int[] { 1, 15, 91, 175 }, - 1, 1); + ml2 = new MapList(new int[] { 1, 100 }, new int[] { 1, 15, 91, 175 }, 1, + 1); compound = ml1.traverse(ml2); assertEquals(3, compound.getFromRatio()); @@ -949,17 +974,17 @@ public class MapListTest assertArrayEquals(new int[] { 71, 126 }, toRanges.get(1)); /* - * method returns null if not all regions are mapped through + * if not all regions are mapped through, returns what is */ ml1 = new MapList(new int[] { 1, 50 }, new int[] { 101, 150 }, 1, 1); - ml2 = new MapList(new int[] { 131, 180 }, new int[] { 201, 250 }, 1, 3); + ml2 = new MapList(new int[] { 131, 180 }, new int[] { 201, 250 }, 1, 1); compound = ml1.traverse(ml2); assertNull(compound); } /** - * Test that method that inspects for the (first) forward or reverse 'to' range. - * Single position ranges are ignored. + * Test that method that inspects for the (first) forward or reverse 'to' + * range. Single position ranges are ignored. */ @Test(groups = { "Functional" }) public void testIsToForwardsStrand() @@ -981,4 +1006,427 @@ public class MapListTest 1); assertTrue(ml.isToForwardStrand()); } + + /** + * Test for mapping with overlapping ranges + */ + @Test(groups = { "Functional" }) + public void testLocateInFrom_withOverlap() + { + /* + * gene to protein... + */ + int[] codons = new int[] { 1, 12, 12, 17 }; + int[] protein = new int[] { 1, 6 }; + MapList ml = new MapList(codons, protein, 3, 1); + assertEquals("[1, 3]", Arrays.toString(ml.locateInFrom(1, 1))); + assertEquals("[4, 6]", Arrays.toString(ml.locateInFrom(2, 2))); + assertEquals("[7, 9]", Arrays.toString(ml.locateInFrom(3, 3))); + assertEquals("[10, 12]", Arrays.toString(ml.locateInFrom(4, 4))); + assertEquals("[12, 14]", Arrays.toString(ml.locateInFrom(5, 5))); + assertEquals("[15, 17]", Arrays.toString(ml.locateInFrom(6, 6))); + assertEquals("[1, 6]", Arrays.toString(ml.locateInFrom(1, 2))); + assertEquals("[1, 9]", Arrays.toString(ml.locateInFrom(1, 3))); + assertEquals("[1, 12]", Arrays.toString(ml.locateInFrom(1, 4))); + assertEquals("[1, 12, 12, 14]", Arrays.toString(ml.locateInFrom(1, 5))); + assertEquals("[1, 12, 12, 17]", Arrays.toString(ml.locateInFrom(1, 6))); + assertEquals("[4, 9]", Arrays.toString(ml.locateInFrom(2, 3))); + assertEquals("[7, 12, 12, 17]", Arrays.toString(ml.locateInFrom(3, 6))); + + /* + * partial overlap of range + */ + assertEquals("[4, 12, 12, 17]", Arrays.toString(ml.locateInFrom(2, 7))); + assertEquals("[1, 3]", Arrays.toString(ml.locateInFrom(-1, 1))); + + /* + * no overlap in range + */ + assertNull(ml.locateInFrom(0, 0)); + + /* + * gene to CDS...from EMBL:MN908947 + */ + int[] gene = new int[] { 266, 13468, 13468, 21555 }; + int[] cds = new int[] { 1, 21291 }; + ml = new MapList(gene, cds, 1, 1); + assertEquals("[13468, 13468]", + Arrays.toString(ml.locateInFrom(13203, 13203))); + assertEquals("[13468, 13468]", + Arrays.toString(ml.locateInFrom(13204, 13204))); + assertEquals("[13468, 13468, 13468, 13468]", + Arrays.toString(ml.locateInFrom(13203, 13204))); + } + + /** + * Test for mapping with overlapping ranges + */ + @Test(groups = { "Functional" }) + public void testLocateInTo_withOverlap() + { + /* + * gene to protein... + */ + int[] codons = new int[] { 1, 12, 12, 17 }; + int[] protein = new int[] { 1, 6 }; + MapList ml = new MapList(codons, protein, 3, 1); + assertEquals("[1, 1]", Arrays.toString(ml.locateInTo(1, 1))); + assertEquals("[1, 3]", Arrays.toString(ml.locateInTo(3, 8))); + assertEquals("[1, 4]", Arrays.toString(ml.locateInTo(2, 11))); + assertEquals("[1, 4]", Arrays.toString(ml.locateInTo(3, 11))); + + // we want base 12 to map to both of the amino acids it codes for + assertEquals("[4, 5]", Arrays.toString(ml.locateInTo(12, 12))); + assertEquals("[4, 5]", Arrays.toString(ml.locateInTo(11, 12))); + assertEquals("[4, 6]", Arrays.toString(ml.locateInTo(11, 15))); + assertEquals("[6, 6]", Arrays.toString(ml.locateInTo(15, 17))); + + /* + * no overlap + */ + assertNull(ml.locateInTo(0, 0)); + + /* + * partial overlap + */ + assertEquals("[1, 6]", Arrays.toString(ml.locateInTo(1, 18))); + assertEquals("[1, 1]", Arrays.toString(ml.locateInTo(-1, 1))); + + /* + * gene to CDS...from EMBL:MN908947 + * the base at 13468 is used twice in transcription + */ + int[] gene = new int[] { 266, 13468, 13468, 21555 }; + int[] cds = new int[] { 1, 21291 }; + ml = new MapList(gene, cds, 1, 1); + assertEquals("[13203, 13204]", + Arrays.toString(ml.locateInTo(13468, 13468))); + + /* + * gene to protein + * the base at 13468 is in the codon for 4401N and also 4402R + */ + gene = new int[] { 266, 13468, 13468, 21552 }; // stop codon excluded + protein = new int[] { 1, 7096 }; + ml = new MapList(gene, protein, 3, 1); + assertEquals("[4401, 4402]", + Arrays.toString(ml.locateInTo(13468, 13468))); + } + + @Test(groups = { "Functional" }) + public void testTraverseToPosition() + { + List ranges = new ArrayList<>(); + assertNull(MapList.traverseToPosition(ranges, 0)); + + ranges.add(new int[] { 3, 6 }); + assertNull(MapList.traverseToPosition(ranges, 0)); + } + + @Test(groups = { "Functional" }) + public void testCountPositions() + { + try + { + MapList.countPositions(null, 1); + fail("expected exception"); + } catch (NullPointerException e) + { + // expected + } + + List intervals = new ArrayList<>(); + assertNull(MapList.countPositions(intervals, 1)); + + /* + * forward strand + */ + intervals.add(new int[] { 10, 20 }); + assertNull(MapList.countPositions(intervals, 9)); + assertNull(MapList.countPositions(intervals, 21)); + assertArrayEquals(new int[] { 1, 1 }, + MapList.countPositions(intervals, 10)); + assertArrayEquals(new int[] { 6, 1 }, + MapList.countPositions(intervals, 15)); + assertArrayEquals(new int[] { 11, 1 }, + MapList.countPositions(intervals, 20)); + + intervals.add(new int[] { 25, 25 }); + assertArrayEquals(new int[] { 12, 1 }, + MapList.countPositions(intervals, 25)); + + // next interval repeats position 25 - which should be counted twice if + // traversed + intervals.add(new int[] { 25, 26 }); + assertArrayEquals(new int[] { 12, 1 }, + MapList.countPositions(intervals, 25)); + assertArrayEquals(new int[] { 14, 1 }, + MapList.countPositions(intervals, 26)); + + /* + * reverse strand + */ + intervals.clear(); + intervals.add(new int[] { 5, -5 }); + assertNull(MapList.countPositions(intervals, 6)); + assertNull(MapList.countPositions(intervals, -6)); + assertArrayEquals(new int[] { 1, -1 }, + MapList.countPositions(intervals, 5)); + assertArrayEquals(new int[] { 7, -1 }, + MapList.countPositions(intervals, -1)); + assertArrayEquals(new int[] { 11, -1 }, + MapList.countPositions(intervals, -5)); + + /* + * reverse then forward + */ + intervals.add(new int[] { 5, 10 }); + assertArrayEquals(new int[] { 13, 1 }, + MapList.countPositions(intervals, 6)); + + /* + * reverse then forward then reverse + */ + intervals.add(new int[] { -10, -20 }); + assertArrayEquals(new int[] { 20, -1 }, + MapList.countPositions(intervals, -12)); + + /* + * an interval [x, x] is treated as forward + */ + intervals.add(new int[] { 30, 30 }); + assertArrayEquals(new int[] { 29, 1 }, + MapList.countPositions(intervals, 30)); + + /* + * it is the first matched occurrence that is returned + */ + intervals.clear(); + intervals.add(new int[] { 1, 2 }); + intervals.add(new int[] { 2, 3 }); + assertArrayEquals(new int[] { 2, 1 }, + MapList.countPositions(intervals, 2)); + intervals.add(new int[] { -1, -2 }); + intervals.add(new int[] { -2, -3 }); + assertArrayEquals(new int[] { 6, -1 }, + MapList.countPositions(intervals, -2)); + } + + /** + * Tests for helper method that adds any overlap (plus offset) to a set of + * overlaps + */ + @Test(groups = { "Functional" }) + public void testAddOffsetPositions() + { + List mapped = new ArrayList<>(); + int[] range = new int[] {10, 20}; + BitSet offsets = new BitSet(); + + MapList.addOffsetPositions(mapped, 0, range, offsets); + assertTrue(mapped.isEmpty()); // nothing marked for overlap + + offsets.set(11); + MapList.addOffsetPositions(mapped, 0, range, offsets); + assertTrue(mapped.isEmpty()); // no offset 11 in range + + offsets.set(4, 6); // this sets bits 4 and 5 + MapList.addOffsetPositions(mapped, 0, range, offsets); + assertEquals(1, mapped.size()); + assertArrayEquals(new int[] { 14, 15 }, mapped.get(0)); + + mapped.clear(); + offsets.set(10); + MapList.addOffsetPositions(mapped, 0, range, offsets); + assertEquals(2, mapped.size()); + assertArrayEquals(new int[] { 14, 15 }, mapped.get(0)); + assertArrayEquals(new int[] { 20, 20 }, mapped.get(1)); + + /* + * reverse range + */ + range = new int[] { 20, 10 }; + mapped.clear(); + offsets.clear(); + MapList.addOffsetPositions(mapped, 0, range, offsets); + assertTrue(mapped.isEmpty()); // nothing marked for overlap + offsets.set(11); + MapList.addOffsetPositions(mapped, 0, range, offsets); + assertTrue(mapped.isEmpty()); // no offset 11 in range + offsets.set(0); + offsets.set(10); + offsets.set(6, 8); // sets bits 6 and 7 + MapList.addOffsetPositions(mapped, 0, range, offsets); + assertEquals(3, mapped.size()); + assertArrayEquals(new int[] { 20, 20 }, mapped.get(0)); + assertArrayEquals(new int[] { 14, 13 }, mapped.get(1)); + assertArrayEquals(new int[] { 10, 10 }, mapped.get(2)); + } + + @Test(groups = { "Functional" }) + public void testGetPositionsForOffsets() + { + List ranges = new ArrayList<>(); + BitSet offsets = new BitSet(); + List mapped = MapList.getPositionsForOffsets(ranges, offsets); + assertTrue(mapped.isEmpty()); // no ranges and no offsets! + + offsets.set(5, 1000); + mapped = MapList.getPositionsForOffsets(ranges, offsets); + assertTrue(mapped.isEmpty()); // no ranges + + /* + * one range with overlap of offsets + */ + ranges.add(new int[] {15, 25}); + mapped = MapList.getPositionsForOffsets(ranges, offsets); + assertEquals(1, mapped.size()); + assertArrayEquals(new int[] {20, 25}, mapped.get(0)); + + /* + * two ranges + */ + ranges.add(new int[] {300, 320}); + mapped = MapList.getPositionsForOffsets(ranges, offsets); + assertEquals(2, mapped.size()); + assertArrayEquals(new int[] {20, 25}, mapped.get(0)); + assertArrayEquals(new int[] {300, 320}, mapped.get(1)); + + /* + * boundary case - right end of first range overlaps + */ + offsets.clear(); + offsets.set(10); + mapped = MapList.getPositionsForOffsets(ranges, offsets); + assertEquals(1, mapped.size()); + assertArrayEquals(new int[] {25, 25}, mapped.get(0)); + + /* + * boundary case - left end of second range overlaps + */ + offsets.set(11); + mapped = MapList.getPositionsForOffsets(ranges, offsets); + assertEquals(2, mapped.size()); + assertArrayEquals(new int[] {25, 25}, mapped.get(0)); + assertArrayEquals(new int[] {300, 300}, mapped.get(1)); + + /* + * offsets into a circular range are reported in + * the order in which they are traversed + */ + ranges.clear(); + ranges.add(new int[] {100, 150}); + ranges.add(new int[] {60, 80}); + offsets.clear(); + offsets.set(45, 55); // sets bits 45 to 54 + mapped = MapList.getPositionsForOffsets(ranges, offsets); + assertEquals(2, mapped.size()); + assertArrayEquals(new int[] {145, 150}, mapped.get(0)); // offsets 45-50 + assertArrayEquals(new int[] {60, 63}, mapped.get(1)); // offsets 51-54 + + /* + * reverse range overlap is reported with start < end + */ + ranges.clear(); + ranges.add(new int[] {4321, 4000}); + offsets.clear(); + offsets.set(20, 22); // sets bits 20 and 21 + offsets.set(30); + mapped = MapList.getPositionsForOffsets(ranges, offsets); + assertEquals(2, mapped.size()); + assertArrayEquals(new int[] {4301, 4300}, mapped.get(0)); + assertArrayEquals(new int[] {4291, 4291}, mapped.get(1)); + } + + @Test(groups = { "Functional" }) + public void testGetMappedOffsetsForPositions() + { + /* + * start by verifying the examples in the method's Javadoc! + */ + List ranges = new ArrayList<>(); + ranges.add(new int[] {10, 20}); + ranges.add(new int[] {31, 40}); + BitSet overlaps = MapList.getMappedOffsetsForPositions(1, 9, ranges, 1, 1); + assertTrue(overlaps.isEmpty()); + overlaps = MapList.getMappedOffsetsForPositions(1, 11, ranges, 1, 1); + assertEquals(2, overlaps.cardinality()); + assertTrue(overlaps.get(0)); + assertTrue(overlaps.get(1)); + overlaps = MapList.getMappedOffsetsForPositions(15, 35, ranges, 1, 1); + assertEquals(11, overlaps.cardinality()); + for (int i = 5 ; i <= 11 ; i++) + { + assertTrue(overlaps.get(i)); + } + + ranges.clear(); + ranges.add(new int[] {1, 200}); + overlaps = MapList.getMappedOffsetsForPositions(9, 9, ranges, 1, 3); + assertEquals(3, overlaps.cardinality()); + assertTrue(overlaps.get(24)); + assertTrue(overlaps.get(25)); + assertTrue(overlaps.get(26)); + + ranges.clear(); + ranges.add(new int[] {101, 150}); + ranges.add(new int[] {171, 180}); + overlaps = MapList.getMappedOffsetsForPositions(101, 102, ranges, 3, 1); + assertEquals(1, overlaps.cardinality()); + assertTrue(overlaps.get(0)); + overlaps = MapList.getMappedOffsetsForPositions(150, 171, ranges, 3, 1); + assertEquals(1, overlaps.cardinality()); + assertTrue(overlaps.get(16)); + + ranges.clear(); + ranges.add(new int[] {101, 150}); + ranges.add(new int[] {21, 30}); + overlaps = MapList.getMappedOffsetsForPositions(24, 40, ranges, 3, 1); + assertEquals(3, overlaps.cardinality()); + assertTrue(overlaps.get(17)); + assertTrue(overlaps.get(18)); + assertTrue(overlaps.get(19)); + + /* + * reverse range 1:1 (e.g. reverse strand gene to transcript) + */ + ranges.clear(); + ranges.add(new int[] {20, 10}); + overlaps = MapList.getMappedOffsetsForPositions(12, 13, ranges, 1, 1); + assertEquals(2, overlaps.cardinality()); + assertTrue(overlaps.get(7)); + assertTrue(overlaps.get(8)); + + /* + * reverse range 3:1 (e.g. reverse strand gene to peptide) + * from EMBL:J03321 to P0CE20 + */ + ranges.clear(); + ranges.add(new int[] {1480, 488}); + overlaps = MapList.getMappedOffsetsForPositions(1460, 1460, ranges, 3, 1); + // 1460 is the end of the 7th codon + assertEquals(1, overlaps.cardinality()); + assertTrue(overlaps.get(6)); + // add one base (part codon) + overlaps = MapList.getMappedOffsetsForPositions(1459, 1460, ranges, 3, 1); + assertEquals(2, overlaps.cardinality()); + assertTrue(overlaps.get(6)); + assertTrue(overlaps.get(7)); + // add second base (part codon) + overlaps = MapList.getMappedOffsetsForPositions(1458, 1460, ranges, 3, 1); + assertEquals(2, overlaps.cardinality()); + assertTrue(overlaps.get(6)); + assertTrue(overlaps.get(7)); + // add third base (whole codon) + overlaps = MapList.getMappedOffsetsForPositions(1457, 1460, ranges, 3, 1); + assertEquals(2, overlaps.cardinality()); + assertTrue(overlaps.get(6)); + assertTrue(overlaps.get(7)); + // add one more base (part codon) + overlaps = MapList.getMappedOffsetsForPositions(1456, 1460, ranges, 3, 1); + assertEquals(3, overlaps.cardinality()); + assertTrue(overlaps.get(6)); + assertTrue(overlaps.get(7)); + assertTrue(overlaps.get(8)); + } }