+
+ /**
+ * Test that method that inspects for the (first) forward or reverse 'to'
+ * range. Single position ranges are ignored.
+ */
+ @Test(groups = { "Functional" })
+ public void testIsToForwardsStrand()
+ {
+ // [3-9] declares forward strand
+ MapList ml = new MapList(new int[] { 20, 11 },
+ new int[]
+ { 2, 2, 3, 9, 12, 11 }, 1, 1);
+ assertTrue(ml.isToForwardStrand());
+
+ // [11-5] declares reverse strand ([13-14] is ignored)
+ ml = new MapList(new int[] { 20, 11 },
+ new int[]
+ { 2, 2, 11, 5, 13, 14 }, 1, 1);
+ assertFalse(ml.isToForwardStrand());
+
+ // all single position ranges - defaults to forward strand
+ ml = new MapList(new int[] { 3, 1 }, new int[] { 2, 2, 4, 4, 6, 6 }, 1,
+ 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)));
+
+ assertNull(ml.locateInFrom(0, 0));
+ assertNull(ml.locateInFrom(1, 7));
+ assertNull(ml.locateInFrom(-1, 1));
+
+ /*
+ * 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]", 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)));
+
+ assertNull(ml.locateInTo(0, 0));
+ assertNull(ml.locateInTo(1, 18));
+ assertNull(ml.locateInTo(-1, 1));
+
+ /*
+ * 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("[13203, 13204]", Arrays.toString(ml.locateInTo(13468, 13468)));
+ }
+
+ @Test(groups = { "Functional" })
+ public void testTraverseToPosition()
+ {
+ List<int[]> 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<int[]> 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));
+ }
+
+ @Test(groups = { "Functional" })
+ public void testFindOverlapPositions()
+ {
+ List<int[]> ranges = new ArrayList<>();
+ List<int[]> overlaps = MapList.findOverlapPositions(ranges, 20, 30);
+ assertTrue(overlaps.isEmpty());
+ ranges.add(new int[] {15, 25});
+ overlaps = MapList.findOverlapPositions(ranges, 20, 30);
+ assertEquals(1, overlaps.size());
+ assertArrayEquals(new int[] {6, 11}, overlaps.get(0));
+ }
+
+ @Test(groups = { "Functional" })
+ public void testMapWords()
+ {
+ List<int[]> ranges = new ArrayList<>();
+
+ /*
+ * 1:1 (trivial) case
+ */
+ ranges.add(new int[] {2, 4});
+ ranges.add(new int[] {6, 9});
+ MapList.mapWords(ranges, 1, 1);
+ assertEquals(ranges.size(), 2);
+ assertArrayEquals(new int[] {2, 4}, ranges.get(0));
+ assertArrayEquals(new int[] {6, 9}, ranges.get(1));
+
+ /*
+ * 1:3 case (peptide to codon ranges)
+ */
+ MapList.mapWords(ranges, 1, 3);
+ assertEquals(ranges.size(), 2);
+ assertArrayEquals(new int[] {6, 14}, ranges.get(0));
+ assertArrayEquals(new int[] {18, 29}, ranges.get(1));
+
+ /*
+ * 3:1 case (codon or part codon to peptide)
+ */
+ ranges.clear();
+ ranges.add(new int[] {0, 5}); // 2 whole codons
+ ranges.add(new int[] {7, 11}); // part + whole codon
+ ranges.add(new int[] {15, 19}); // whole + part codon
+ ranges.add(new int[] {23, 27}); // part + part codon
+ ranges.add(new int[] {30, 30}); // first base of codon
+ ranges.add(new int[] {31, 31}); // second base of codon
+ ranges.add(new int[] {32, 32}); // third base of codon
+ MapList.mapWords(ranges, 3, 1);
+ assertEquals(ranges.size(), 7);
+ assertArrayEquals(new int[] {0, 1}, ranges.get(0));
+ assertArrayEquals(new int[] {2, 3}, ranges.get(1));
+ assertArrayEquals(new int[] {5, 6}, ranges.get(2));
+ assertArrayEquals(new int[] {7, 9}, ranges.get(3));
+ assertArrayEquals(new int[] {10, 10}, ranges.get(4));
+ assertArrayEquals(new int[] {10, 10}, ranges.get(5));
+ assertArrayEquals(new int[] {10, 10}, ranges.get(6));
+ }