test/jalview/datamodel/VisibleContigsIteratorTest.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.datamodel;
  22
  23 import static org.testng.Assert.assertEquals;
  24 import static org.testng.AssertJUnit.assertFalse;
  25 import static org.testng.AssertJUnit.assertTrue;
  26
  27 import java.util.ArrayList;
  28 import java.util.List;
  29
  30 import org.testng.annotations.Test;
  31
  32 public class VisibleContigsIteratorTest
  33 {
  34   /**
  35    * Test the iterator with single visible regions
  36    */
  37   @Test(groups = { "Functional" })
  38   public void testSimpleVisibleRegions()
  39   {
  40     List<int[]> hiddenColumns = null;
  41
  42     // null hidden columns
  43     VisibleContigsIterator it = new VisibleContigsIterator(3, 10,
  44             hiddenColumns);
  45     assertTrue(it.hasNext());
  46     assertFalse(it.endsAtHidden());
  47     int[] result = it.next();
  48     assertEquals(3, result[0]);
  49     assertEquals(9, result[1]);
  50     assertFalse(it.hasNext());
  51     assertFalse(it.endsAtHidden());
  52
  53     hiddenColumns = new ArrayList<>();
  54
  55     // no hidden columns
  56     it = new VisibleContigsIterator(3, 10, hiddenColumns);
  57     assertTrue(it.hasNext());
  58     assertFalse(it.endsAtHidden());
  59     result = it.next();
  60     assertEquals(3, result[0]);
  61     assertEquals(9, result[1]);
  62     assertFalse(it.hasNext());
  63     assertFalse(it.endsAtHidden());
  64
  65     // hidden columns, but not where we are looking
  66     hiddenColumns.add(new int[] { 5, 10 });
  67     hiddenColumns.add(new int[] { 25, 40 });
  68
  69     it = new VisibleContigsIterator(2, 3, hiddenColumns);
  70     assertTrue(it.hasNext());
  71     assertFalse(it.endsAtHidden());
  72     result = it.next();
  73     assertEquals(2, result[0]);
  74     assertEquals(2, result[1]);
  75     assertFalse(it.hasNext());
  76     assertFalse(it.endsAtHidden());
  77
  78     it = new VisibleContigsIterator(5, 7, hiddenColumns);
  79     assertFalse(it.hasNext());
  80     assertFalse(it.endsAtHidden());
  81
  82     it = new VisibleContigsIterator(11, 15, hiddenColumns);
  83     assertTrue(it.hasNext());
  84     assertFalse(it.endsAtHidden());
  85     result = it.next();
  86     assertEquals(11, result[0]);
  87     assertEquals(14, result[1]);
  88     assertFalse(it.hasNext());
  89     assertFalse(it.endsAtHidden());
  90
  91     it = new VisibleContigsIterator(50, 60, hiddenColumns);
  92     assertTrue(it.hasNext());
  93     assertFalse(it.endsAtHidden());
  94     result = it.next();
  95     assertEquals(50, result[0]);
  96     assertEquals(59, result[1]);
  97     assertFalse(it.hasNext());
  98     assertFalse(it.endsAtHidden());
  99   }
 100
 101   /**
 102    * Test the iterator with multiple visible regions
 103    */
 104   @Test(groups = { "Functional" })
 105   public void testMultipleVisibleRegions()
 106   {
 107     List<int[]> hiddenColumns = new ArrayList<>();
 108     hiddenColumns.add(new int[] { 5, 10 });
 109     hiddenColumns.add(new int[] { 25, 40 });
 110
 111     // all hidden columns covered
 112     VisibleContigsIterator it = new VisibleContigsIterator(3, 50,
 113             hiddenColumns);
 114     assertTrue(it.hasNext());
 115     assertFalse(it.endsAtHidden());
 116     int[] result = it.next();
 117     assertEquals(3, result[0]);
 118     assertEquals(4, result[1]);
 119
 120     assertTrue(it.hasNext());
 121     assertFalse(it.endsAtHidden());
 122     result = it.next();
 123     assertEquals(11, result[0]);
 124     assertEquals(24, result[1]);
 125
 126     assertTrue(it.hasNext());
 127     assertFalse(it.endsAtHidden());
 128     result = it.next();
 129     assertEquals(41, result[0]);
 130     assertEquals(49, result[1]);
 131
 132     assertFalse(it.hasNext());
 133     assertFalse(it.endsAtHidden());
 134   }
 135
 136   /**
 137    * Test the iterator with regions which start/end at hidden region edges
 138    */
 139   @Test(groups = { "Functional" })
 140   public void testVisibleRegionsAtHiddenEdges()
 141   {
 142     List<int[]> hiddenColumns = new ArrayList<>();
 143     hiddenColumns.add(new int[] { 5, 10 });
 144     hiddenColumns.add(new int[] { 25, 40 });
 145
 146     VisibleContigsIterator it = new VisibleContigsIterator(0, 10,
 147             hiddenColumns);
 148     assertTrue(it.hasNext());
 149     assertTrue(it.endsAtHidden());
 150     int[] result = it.next();
 151     assertEquals(0, result[0]);
 152     assertEquals(4, result[1]);
 153     assertFalse(it.hasNext());
 154     assertTrue(it.endsAtHidden());
 155
 156     it = new VisibleContigsIterator(2, 11, hiddenColumns);
 157     assertTrue(it.hasNext());
 158     assertTrue(it.endsAtHidden());
 159     result = it.next();
 160     assertEquals(2, result[0]);
 161     assertEquals(4, result[1]);
 162     assertFalse(it.hasNext());
 163     assertTrue(it.endsAtHidden());
 164
 165     it = new VisibleContigsIterator(2, 12, hiddenColumns);
 166     assertTrue(it.hasNext());
 167     assertFalse(it.endsAtHidden());
 168     result = it.next();
 169     assertEquals(2, result[0]);
 170     assertEquals(4, result[1]);
 171     assertTrue(it.hasNext());
 172     assertFalse(it.endsAtHidden());
 173     result = it.next();
 174     assertEquals(11, result[0]);
 175     assertEquals(11, result[1]);
 176     assertFalse(it.hasNext());
 177     assertFalse(it.endsAtHidden());
 178
 179     it = new VisibleContigsIterator(13, 25, hiddenColumns);
 180     assertTrue(it.hasNext());
 181     assertFalse(it.endsAtHidden());
 182     result = it.next();
 183     assertEquals(13, result[0]);
 184     assertEquals(24, result[1]);
 185     assertFalse(it.hasNext());
 186
 187     it = new VisibleContigsIterator(13, 26, hiddenColumns);
 188     assertTrue(it.hasNext());
 189     assertTrue(it.endsAtHidden());
 190     result = it.next();
 191     assertEquals(13, result[0]);
 192     assertEquals(24, result[1]);
 193     assertFalse(it.hasNext());
 194
 195     it = new VisibleContigsIterator(13, 27, hiddenColumns);
 196     assertTrue(it.hasNext());
 197     assertTrue(it.endsAtHidden());
 198     result = it.next();
 199     assertEquals(13, result[0]);
 200     assertEquals(24, result[1]);
 201     assertFalse(it.hasNext());
 202
 203     it = new VisibleContigsIterator(13, 41, hiddenColumns);
 204     assertTrue(it.hasNext());
 205     assertTrue(it.endsAtHidden());
 206     result = it.next();
 207     assertEquals(13, result[0]);
 208     assertEquals(24, result[1]);
 209     assertFalse(it.hasNext());
 210
 211     it = new VisibleContigsIterator(13, 42, hiddenColumns);
 212     assertTrue(it.hasNext());
 213     assertFalse(it.endsAtHidden());
 214     result = it.next();
 215     assertEquals(13, result[0]);
 216     assertEquals(24, result[1]);
 217     assertTrue(it.hasNext());
 218     result = it.next();
 219     assertEquals(41, result[0]);
 220     assertEquals(41, result[1]);
 221   }
 222 }