+ proteinSelection.hideSelectedColumns(1, hiddenCols);
+ proteinSelection.hideSelectedColumns(3, hiddenCols);
+ MappingUtils.mapColumnSelection(proteinSelection, hiddenCols,
+ proteinView, dnaView, dnaSelection, dnaHidden);
+ regions = dnaHidden.iterator();
+ assertEquals(2, dnaHidden.getNumberOfRegions());
+ assertEquals("[0, 3]", Arrays.toString(regions.next()));
+ assertEquals("[5, 10]", Arrays.toString(regions.next()));
+ }
+
+ @Test(groups = { "Functional" })
+ public void testGetLength()
+ {
+ assertEquals(0, MappingUtils.getLength(null));
+
+ /*
+ * [start, end] ranges
+ */
+ List<int[]> ranges = new ArrayList<>();
+ assertEquals(0, MappingUtils.getLength(ranges));
+ ranges.add(new int[] { 1, 1 });
+ assertEquals(1, MappingUtils.getLength(ranges));
+ ranges.add(new int[] { 2, 10 });
+ assertEquals(10, MappingUtils.getLength(ranges));
+ ranges.add(new int[] { 20, 10 });
+ assertEquals(21, MappingUtils.getLength(ranges));
+
+ /*
+ * [start, end, start, end...] ranges
+ */
+ ranges.clear();
+ ranges.add(new int[] { 1, 5, 8, 4 });
+ ranges.add(new int[] { 8, 2 });
+ ranges.add(new int[] { 12, 12 });
+ assertEquals(18, MappingUtils.getLength(ranges));
+ }
+
+ @Test(groups = { "Functional" })
+ public void testContains()
+ {
+ assertFalse(MappingUtils.contains(null, 1));
+ List<int[]> ranges = new ArrayList<>();
+ assertFalse(MappingUtils.contains(ranges, 1));
+
+ ranges.add(new int[] { 1, 4 });
+ ranges.add(new int[] { 6, 6 });
+ ranges.add(new int[] { 8, 10 });
+ ranges.add(new int[] { 30, 20 });
+ ranges.add(new int[] { -16, -44 });
+
+ assertFalse(MappingUtils.contains(ranges, 0));
+ assertTrue(MappingUtils.contains(ranges, 1));
+ assertTrue(MappingUtils.contains(ranges, 2));
+ assertTrue(MappingUtils.contains(ranges, 3));
+ assertTrue(MappingUtils.contains(ranges, 4));
+ assertFalse(MappingUtils.contains(ranges, 5));
+
+ assertTrue(MappingUtils.contains(ranges, 6));
+ assertFalse(MappingUtils.contains(ranges, 7));
+
+ assertTrue(MappingUtils.contains(ranges, 8));
+ assertTrue(MappingUtils.contains(ranges, 9));
+ assertTrue(MappingUtils.contains(ranges, 10));
+
+ assertFalse(MappingUtils.contains(ranges, 31));
+ assertTrue(MappingUtils.contains(ranges, 30));
+ assertTrue(MappingUtils.contains(ranges, 29));
+ assertTrue(MappingUtils.contains(ranges, 20));
+ assertFalse(MappingUtils.contains(ranges, 19));
+
+ assertFalse(MappingUtils.contains(ranges, -15));
+ assertTrue(MappingUtils.contains(ranges, -16));
+ assertTrue(MappingUtils.contains(ranges, -44));
+ assertFalse(MappingUtils.contains(ranges, -45));
+ }
+
+ /**
+ * Test the method that drops positions from the start of a mapped range
+ */
+ @Test(groups = "Functional")
+ public void testRemoveStartPositions()
+ {
+ int[] ranges = new int[] { 1, 10 };
+ int[] adjusted = MappingUtils.removeStartPositions(0, ranges);
+ assertEquals("[1, 10]", Arrays.toString(adjusted));
+
+ adjusted = MappingUtils.removeStartPositions(1, ranges);
+ assertEquals("[2, 10]", Arrays.toString(adjusted));
+ assertEquals("[1, 10]", Arrays.toString(ranges));
+
+ ranges = adjusted;
+ adjusted = MappingUtils.removeStartPositions(1, ranges);
+ assertEquals("[3, 10]", Arrays.toString(adjusted));
+ assertEquals("[2, 10]", Arrays.toString(ranges));
+
+ ranges = new int[] { 2, 3, 10, 12 };
+ adjusted = MappingUtils.removeStartPositions(1, ranges);
+ assertEquals("[3, 3, 10, 12]", Arrays.toString(adjusted));
+ assertEquals("[2, 3, 10, 12]", Arrays.toString(ranges));
+
+ ranges = new int[] { 2, 2, 8, 12 };
+ adjusted = MappingUtils.removeStartPositions(1, ranges);
+ assertEquals("[8, 12]", Arrays.toString(adjusted));
+ assertEquals("[2, 2, 8, 12]", Arrays.toString(ranges));
+
+ ranges = new int[] { 2, 2, 8, 12 };
+ adjusted = MappingUtils.removeStartPositions(2, ranges);
+ assertEquals("[9, 12]", Arrays.toString(adjusted));
+ assertEquals("[2, 2, 8, 12]", Arrays.toString(ranges));
+
+ ranges = new int[] { 2, 2, 4, 4, 9, 12 };
+ adjusted = MappingUtils.removeStartPositions(1, ranges);
+ assertEquals("[4, 4, 9, 12]", Arrays.toString(adjusted));
+ assertEquals("[2, 2, 4, 4, 9, 12]", Arrays.toString(ranges));
+
+ ranges = new int[] { 2, 2, 4, 4, 9, 12 };
+ adjusted = MappingUtils.removeStartPositions(2, ranges);
+ assertEquals("[9, 12]", Arrays.toString(adjusted));
+ assertEquals("[2, 2, 4, 4, 9, 12]", Arrays.toString(ranges));
+
+ ranges = new int[] { 2, 3, 9, 12 };
+ adjusted = MappingUtils.removeStartPositions(3, ranges);
+ assertEquals("[10, 12]", Arrays.toString(adjusted));
+ assertEquals("[2, 3, 9, 12]", Arrays.toString(ranges));
+ }
+
+ /**
+ * Test the method that drops positions from the start of a mapped range, on
+ * the reverse strand
+ */
+ @Test(groups = "Functional")
+ public void testRemoveStartPositions_reverseStrand()
+ {
+ int[] ranges = new int[] { 10, 1 };
+ int[] adjusted = MappingUtils.removeStartPositions(0, ranges);
+ assertEquals("[10, 1]", Arrays.toString(adjusted));
+ assertEquals("[10, 1]", Arrays.toString(ranges));
+
+ ranges = adjusted;
+ adjusted = MappingUtils.removeStartPositions(1, ranges);
+ assertEquals("[9, 1]", Arrays.toString(adjusted));
+ assertEquals("[10, 1]", Arrays.toString(ranges));
+
+ ranges = adjusted;
+ adjusted = MappingUtils.removeStartPositions(1, ranges);
+ assertEquals("[8, 1]", Arrays.toString(adjusted));
+ assertEquals("[9, 1]", Arrays.toString(ranges));
+
+ ranges = new int[] { 12, 11, 9, 6 };
+ adjusted = MappingUtils.removeStartPositions(1, ranges);
+ assertEquals("[11, 11, 9, 6]", Arrays.toString(adjusted));
+ assertEquals("[12, 11, 9, 6]", Arrays.toString(ranges));
+
+ ranges = new int[] { 12, 12, 8, 4 };
+ adjusted = MappingUtils.removeStartPositions(1, ranges);
+ assertEquals("[8, 4]", Arrays.toString(adjusted));
+ assertEquals("[12, 12, 8, 4]", Arrays.toString(ranges));
+
+ ranges = new int[] { 12, 12, 8, 4 };
+ adjusted = MappingUtils.removeStartPositions(2, ranges);
+ assertEquals("[7, 4]", Arrays.toString(adjusted));
+ assertEquals("[12, 12, 8, 4]", Arrays.toString(ranges));
+
+ ranges = new int[] { 12, 12, 10, 10, 8, 4 };
+ adjusted = MappingUtils.removeStartPositions(1, ranges);
+ assertEquals("[10, 10, 8, 4]", Arrays.toString(adjusted));
+ assertEquals("[12, 12, 10, 10, 8, 4]", Arrays.toString(ranges));
+
+ ranges = new int[] { 12, 12, 10, 10, 8, 4 };
+ adjusted = MappingUtils.removeStartPositions(2, ranges);
+ assertEquals("[8, 4]", Arrays.toString(adjusted));
+ assertEquals("[12, 12, 10, 10, 8, 4]", Arrays.toString(ranges));
+
+ ranges = new int[] { 12, 11, 8, 4 };
+ adjusted = MappingUtils.removeStartPositions(3, ranges);
+ assertEquals("[7, 4]", Arrays.toString(adjusted));
+ assertEquals("[12, 11, 8, 4]", Arrays.toString(ranges));
+ }
+
+ @Test(groups = { "Functional" })
+ public void testRangeContains()
+ {
+ /*
+ * both forward ranges
+ */
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 1, 10 }));
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 2, 10 }));
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 1, 9 }));
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 4, 5 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 0, 9 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { -10, -9 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 1, 11 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 11, 12 }));
+
+ /*
+ * forward range, reverse query
+ */
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 10, 1 }));
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 9, 1 }));
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 10, 2 }));
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 5, 5 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 11, 1 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 10, 0 }));
+
+ /*
+ * reverse range, forward query
+ */
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 1, 10 }));
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 1, 9 }));
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 2, 10 }));
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 6, 6 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 6, 11 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 11, 20 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { -3, -2 }));
+
+ /*
+ * both reverse
+ */
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 10, 1 }));
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 9, 1 }));
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 10, 2 }));
+ assertTrue(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 3, 3 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 11, 1 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 10, 0 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { 12, 11 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 10, 1 }, new int[] { -5, -8 }));
+
+ /*
+ * bad arguments
+ */
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10, 12 }, new int[] { 1, 10 }));
+ assertFalse(
+ MappingUtils.rangeContains(new int[]
+ { 1, 10 }, new int[] { 1 }));
+ assertFalse(MappingUtils.rangeContains(new int[] { 1, 10 }, null));
+ assertFalse(MappingUtils.rangeContains(null, new int[] { 1, 10 }));
+ }
+
+ @Test(groups = "Functional")
+ public void testRemoveEndPositions()
+ {
+ List<int[]> ranges = new ArrayList<>();
+
+ /*
+ * case 1: truncate last range
+ */
+ ranges.add(new int[] { 1, 10 });
+ ranges.add(new int[] { 20, 30 });
+ MappingUtils.removeEndPositions(5, ranges);
+ assertEquals(2, ranges.size());
+ assertEquals(25, ranges.get(1)[1]);
+
+ /*
+ * case 2: remove last range
+ */
+ ranges.clear();
+ ranges.add(new int[] { 1, 10 });
+ ranges.add(new int[] { 20, 22 });
+ MappingUtils.removeEndPositions(3, ranges);
+ assertEquals(1, ranges.size());
+ assertEquals(10, ranges.get(0)[1]);
+
+ /*
+ * case 3: truncate penultimate range
+ */
+ ranges.clear();
+ ranges.add(new int[] { 1, 10 });
+ ranges.add(new int[] { 20, 21 });
+ MappingUtils.removeEndPositions(3, ranges);
+ assertEquals(1, ranges.size());
+ assertEquals(9, ranges.get(0)[1]);
+
+ /*
+ * case 4: remove last two ranges
+ */
+ ranges.clear();
+ ranges.add(new int[] { 1, 10 });
+ ranges.add(new int[] { 20, 20 });
+ ranges.add(new int[] { 30, 30 });
+ MappingUtils.removeEndPositions(3, ranges);
+ assertEquals(1, ranges.size());
+ assertEquals(9, ranges.get(0)[1]);
+ }
+
+ @Test(groups = "Functional")
+ public void testListToArray()
+ {
+ List<int[]> ranges = new ArrayList<>();
+
+ int[] result = MappingUtils.rangeListToArray(ranges);
+ assertEquals(result.length, 0);
+ ranges.add(new int[] { 24, 12 });
+ result = MappingUtils.rangeListToArray(ranges);
+ assertEquals(result.length, 2);
+ assertEquals(result[0], 24);
+ assertEquals(result[1], 12);
+ ranges.add(new int[] { -7, 30 });
+ result = MappingUtils.rangeListToArray(ranges);
+ assertEquals(result.length, 4);
+ assertEquals(result[0], 24);
+ assertEquals(result[1], 12);
+ assertEquals(result[2], -7);
+ assertEquals(result[3], 30);
+ try
+ {
+ MappingUtils.rangeListToArray(null);
+ fail("Expected exception");
+ } catch (NullPointerException e)
+ {
+ // expected
+ }