test/jalview/datamodel/VisibleRowsIteratorTest.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.assertTrue;
  24
  25 import jalview.analysis.AlignmentGenerator;
  26
  27 import java.util.Hashtable;
  28 import java.util.NoSuchElementException;
  29
  30 import org.testng.annotations.BeforeClass;
  31 import org.testng.annotations.Test;
  32
  33 public class VisibleRowsIteratorTest
  34 {
  35   AlignmentI al;
  36
  37   AlignmentI al2;
  38
  39   AlignmentI al3;
  40
  41   Hashtable<SequenceI, SequenceCollectionI> hiddenRepSequences = new Hashtable<SequenceI, SequenceCollectionI>();
  42
  43   Hashtable<SequenceI, SequenceCollectionI> hiddenRepSequences2 = new Hashtable<SequenceI, SequenceCollectionI>();
  44
  45   @BeforeClass(groups = { "Functional" })
  46   public void setup()
  47   {
  48     // create random alignment
  49     AlignmentGenerator gen = new AlignmentGenerator(false);
  50     al = gen.generate(20, 15, 123, 5, 5);
  51     if (!hiddenRepSequences.isEmpty())
  52     {
  53       al.getHiddenSequences().showAll(hiddenRepSequences);
  54     }
  55     hideSequences(al, hiddenRepSequences, 2, 4);
  56
  57     al2 = gen.generate(20, 15, 123, 5, 5);
  58     if (!hiddenRepSequences2.isEmpty())
  59     {
  60       al2.getHiddenSequences().showAll(hiddenRepSequences2);
  61     }
  62     hideSequences(al2, hiddenRepSequences2, 0, 2);
  63
  64     al3 = gen.generate(20, 15, 123, 5, 5);
  65   }
  66
  67   /*
  68    * Test iterator iterates correctly through the rows
  69    * when alignment has hidden rows
  70    */
  71   @Test(groups = { "Functional" })
  72   public void testHasNextAndNextWithHidden()
  73   {
  74     VisibleRowsIterator it = new VisibleRowsIterator(0, 6, al);
  75     int count = 0;
  76     while (it.hasNext())
  77     {
  78       it.next();
  79       count++;
  80     }
  81     assertTrue(count == 4, "hasNext() is false after 4 iterations");
  82   }
  83
  84   /*
  85    * Test iterator iterates correctly through the rows
  86    * when alignment has no hidden rows
  87    */
  88   @Test(groups = { "Functional" })
  89   public void testHasNextAndNextNoHidden()
  90   {
  91     VisibleRowsIterator it = new VisibleRowsIterator(0, 3, al3);
  92     int count = 0;
  93     while (it.hasNext())
  94     {
  95       it.next();
  96       count++;
  97     }
  98     assertTrue(count == 4, "hasNext() is false after 4 iterations");
  99   }
 100
 101   /*
 102    * Test iterator iterates correctly through the rows
 103    * when alignment has hidden rows at start
 104    */
 105   @Test(groups = { "Functional" })
 106   public void testHasNextAndNextStartHidden()
 107   {
 108     VisibleRowsIterator it = new VisibleRowsIterator(0, 6, al2);
 109     int count = 0;
 110     while (it.hasNext())
 111     {
 112       it.next();
 113       count++;
 114     }
 115     assertTrue(count == 4, "hasNext() is false after 4 iterations");
 116   }
 117
 118   /*
 119    * Test iterator iterates correctly through the rows
 120    * when alignment has hidden rows at end
 121    */
 122   @Test(groups = { "Functional" })
 123   public void testHasNextAndNextEndHidden()
 124   {
 125     VisibleRowsIterator it = new VisibleRowsIterator(0, 4, al);
 126     int count = 0;
 127     while (it.hasNext())
 128     {
 129       it.next();
 130       count++;
 131     }
 132     assertTrue(count == 2, "hasNext() is false after 2 iterations");
 133   }
 134
 135   /*
 136    * Test iterator always throws NoSuchElementException at end of iteration
 137    * when alignment has hidden rows
 138    */
 139   @Test(
 140     groups =
 141     { "Functional" },
 142     expectedExceptions =
 143     { NoSuchElementException.class })
 144   public void testLastNextWithHidden() throws NoSuchElementException
 145   {
 146     VisibleRowsIterator it = new VisibleRowsIterator(0, 3, al);
 147     while (it.hasNext())
 148     {
 149       it.next();
 150     }
 151     it.next();
 152   }
 153
 154   /*
 155    * Test iterator always throws NoSuchElementException at end of iteration
 156    * when alignment has no hidden rows
 157    */
 158   @Test(
 159     groups =
 160     { "Functional" },
 161     expectedExceptions =
 162     { NoSuchElementException.class })
 163   public void testLastNextNoHidden() throws NoSuchElementException
 164   {
 165     VisibleRowsIterator it = new VisibleRowsIterator(0, 3, al3);
 166     while (it.hasNext())
 167     {
 168       it.next();
 169     }
 170     it.next();
 171   }
 172
 173   /*
 174    * Test iterator always throws NoSuchElementException at end of iteration
 175    * when alignment has hidden rows at start
 176    */
 177   @Test(
 178     groups =
 179     { "Functional" },
 180     expectedExceptions =
 181     { NoSuchElementException.class })
 182   public void testLastNextStartHidden() throws NoSuchElementException
 183   {
 184     VisibleRowsIterator it = new VisibleRowsIterator(0, 3, al2);
 185     while (it.hasNext())
 186     {
 187       it.next();
 188     }
 189     it.next();
 190   }
 191
 192   /*
 193    * Test iterator always throws NoSuchElementException at end of iteration
 194    * when alignment has hidden rows at end
 195    */
 196   @Test(
 197     groups =
 198     { "Functional" },
 199     expectedExceptions =
 200     { NoSuchElementException.class })
 201   public void testLastNextEndHidden() throws NoSuchElementException
 202   {
 203     VisibleRowsIterator it = new VisibleRowsIterator(0, 4, al);
 204     while (it.hasNext())
 205     {
 206       it.next();
 207     }
 208     it.next();
 209   }
 210
 211   /*
 212    * Test calls to remove throw UnsupportedOperationException
 213    */
 214   @Test(
 215     groups =
 216     { "Functional" },
 217     expectedExceptions =
 218     { UnsupportedOperationException.class })
 219   public void testRemove() throws UnsupportedOperationException
 220   {
 221     VisibleRowsIterator it = new VisibleRowsIterator(0, 3, al);
 222     it.remove();
 223   }
 224
 225   /*
 226    * Hide sequences between start and end
 227    */
 228   private void hideSequences(AlignmentI alignment,
 229           Hashtable<SequenceI, SequenceCollectionI> hiddenRepSequences,
 230           int start, int end)
 231   {
 232     SequenceI[] allseqs = alignment.getSequencesArray();
 233     SequenceGroup theseSeqs = new SequenceGroup();
 234
 235     for (int i = start; i <= end; i++)
 236     {
 237       theseSeqs.addSequence(allseqs[i], false);
 238       alignment.getHiddenSequences().hideSequence(allseqs[i]);
 239     }
 240
 241     hiddenRepSequences.put(allseqs[start], theseSeqs);
 242   }
 243 }