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 = { "Functional" },
 141     expectedExceptions = { NoSuchElementException.class })
 142   public void testLastNextWithHidden() throws NoSuchElementException
 143   {
 144     VisibleRowsIterator it = new VisibleRowsIterator(0, 3, al);
 145     while (it.hasNext())
 146     {
 147       it.next();
 148     }
 149     it.next();
 150   }
 151
 152   /*
 153    * Test iterator always throws NoSuchElementException at end of iteration
 154    * when alignment has no hidden rows
 155    */
 156   @Test(
 157     groups = { "Functional" },
 158     expectedExceptions = { NoSuchElementException.class })
 159   public void testLastNextNoHidden() throws NoSuchElementException
 160   {
 161     VisibleRowsIterator it = new VisibleRowsIterator(0, 3, al3);
 162     while (it.hasNext())
 163     {
 164       it.next();
 165     }
 166     it.next();
 167   }
 168
 169   /*
 170    * Test iterator always throws NoSuchElementException at end of iteration
 171    * when alignment has hidden rows at start
 172    */
 173   @Test(
 174     groups = { "Functional" },
 175     expectedExceptions = { NoSuchElementException.class })
 176   public void testLastNextStartHidden() throws NoSuchElementException
 177   {
 178     VisibleRowsIterator it = new VisibleRowsIterator(0, 3, al2);
 179     while (it.hasNext())
 180     {
 181       it.next();
 182     }
 183     it.next();
 184   }
 185
 186   /*
 187    * Test iterator always throws NoSuchElementException at end of iteration
 188    * when alignment has hidden rows at end
 189    */
 190   @Test(
 191     groups = { "Functional" },
 192     expectedExceptions = { NoSuchElementException.class })
 193   public void testLastNextEndHidden() throws NoSuchElementException
 194   {
 195     VisibleRowsIterator it = new VisibleRowsIterator(0, 4, al);
 196     while (it.hasNext())
 197     {
 198       it.next();
 199     }
 200     it.next();
 201   }
 202
 203   /*
 204    * Test calls to remove throw UnsupportedOperationException
 205    */
 206   @Test(
 207     groups = { "Functional" },
 208     expectedExceptions = { UnsupportedOperationException.class })
 209   public void testRemove() throws UnsupportedOperationException
 210   {
 211     VisibleRowsIterator it = new VisibleRowsIterator(0, 3, al);
 212     it.remove();
 213   }
 214
 215   /*
 216    * Hide sequences between start and end
 217    */
 218   private void hideSequences(AlignmentI alignment,
 219           Hashtable<SequenceI, SequenceCollectionI> hiddenRepSequences,
 220           int start, int end)
 221   {
 222     SequenceI[] allseqs = alignment.getSequencesArray();
 223     SequenceGroup theseSeqs = new SequenceGroup();
 224
 225     for (int i = start; i <= end; i++)
 226     {
 227       theseSeqs.addSequence(allseqs[i], false);
 228       alignment.getHiddenSequences().hideSequence(allseqs[i]);
 229     }
 230
 231     hiddenRepSequences.put(allseqs[start], theseSeqs);
 232   }
 233 }