test/jalview/datamodel/features/NCListTest.java

   1 package jalview.datamodel.features;
   2
   3 import static org.testng.Assert.assertEquals;
   4 import static org.testng.Assert.assertTrue;
   5
   6 import java.util.ArrayList;
   7 import java.util.Collections;
   8 import java.util.List;
   9 import java.util.Random;
  10
  11 import org.testng.annotations.Test;
  12
  13 public class NCListTest
  14 {
  15
  16   /**
  17    * A basic sanity test of the constructor
  18    */
  19   @Test(groups = "Functional")
  20   public void testConstructor()
  21   {
  22     List<Range> ranges = new ArrayList<Range>();
  23     ranges.add(new Range(20, 20));
  24     ranges.add(new Range(10, 20));
  25     ranges.add(new Range(15, 30));
  26     ranges.add(new Range(10, 30));
  27     ranges.add(new Range(11, 19));
  28     ranges.add(new Range(10, 20));
  29     ranges.add(new Range(1, 100));
  30
  31     NCList<Range> ncl = new NCList<Range>(ranges);
  32     String expected = "[1-100 [10-30 [10-20 [10-20 [11-19]]]], 15-30 [20-20]]";
  33     assertEquals(ncl.toString(), expected);
  34     assertTrue(ncl.isValid());
  35
  36     Collections.reverse(ranges);
  37     ncl = new NCList<Range>(ranges);
  38     assertEquals(ncl.toString(), expected);
  39     assertTrue(ncl.isValid());
  40   }
  41
  42   @Test(groups = "Functional")
  43   public void testFindOverlaps()
  44   {
  45     List<Range> ranges = new ArrayList<Range>();
  46     ranges.add(new Range(20, 50));
  47     ranges.add(new Range(30, 70));
  48     ranges.add(new Range(1, 100));
  49     ranges.add(new Range(70, 120));
  50
  51     NCList<Range> ncl = new NCList<Range>(ranges);
  52
  53     List<Range> overlaps = ncl.findOverlaps(121, 122);
  54     assertEquals(overlaps.size(), 0);
  55
  56     overlaps = ncl.findOverlaps(21, 22);
  57     assertEquals(overlaps.size(), 2);
  58     assertEquals(((ContiguousI) overlaps.get(0)).getBegin(), 1);
  59     assertEquals(((ContiguousI) overlaps.get(0)).getEnd(), 100);
  60     assertEquals(((ContiguousI) overlaps.get(1)).getBegin(), 20);
  61     assertEquals(((ContiguousI) overlaps.get(1)).getEnd(), 50);
  62
  63     overlaps = ncl.findOverlaps(110, 110);
  64     assertEquals(overlaps.size(), 1);
  65     assertEquals(((ContiguousI) overlaps.get(0)).getBegin(), 70);
  66     assertEquals(((ContiguousI) overlaps.get(0)).getEnd(), 120);
  67   }
  68
  69   @Test(groups = "Functional")
  70   public void testAdd_onTheEnd()
  71   {
  72     List<Range> ranges = new ArrayList<Range>();
  73     ranges.add(new Range(20, 50));
  74     NCList<Range> ncl = new NCList<Range>(ranges);
  75     assertEquals(ncl.toString(), "[20-50]");
  76     assertTrue(ncl.isValid());
  77
  78     ncl.add(new Range(60, 70));
  79     assertEquals(ncl.toString(), "[20-50, 60-70]");
  80     assertTrue(ncl.isValid());
  81   }
  82
  83   @Test(groups = "Functional")
  84   public void testAdd_inside()
  85   {
  86     List<Range> ranges = new ArrayList<Range>();
  87     ranges.add(new Range(20, 50));
  88     NCList<Range> ncl = new NCList<Range>(ranges);
  89     assertEquals(ncl.toString(), "[20-50]");
  90     assertTrue(ncl.isValid());
  91
  92     ncl.add(new Range(30, 40));
  93     assertEquals(ncl.toString(), "[20-50 [30-40]]");
  94   }
  95
  96   @Test(groups = "Functional")
  97   public void testAdd_onTheFront()
  98   {
  99     List<Range> ranges = new ArrayList<Range>();
 100     ranges.add(new Range(20, 50));
 101     NCList<Range> ncl = new NCList<Range>(ranges);
 102     assertEquals(ncl.toString(), "[20-50]");
 103     assertTrue(ncl.isValid());
 104
 105     ncl.add(new Range(5, 15));
 106     assertEquals(ncl.toString(), "[5-15, 20-50]");
 107     assertTrue(ncl.isValid());
 108   }
 109
 110   @Test(groups = "Functional")
 111   public void testAdd_enclosing()
 112   {
 113     List<Range> ranges = new ArrayList<Range>();
 114     ranges.add(new Range(20, 50));
 115     ranges.add(new Range(30, 60));
 116     NCList<Range> ncl = new NCList<Range>(ranges);
 117     assertEquals(ncl.toString(), "[20-50, 30-60]");
 118     assertTrue(ncl.isValid());
 119     assertEquals(ncl.getStart(), 20);
 120
 121     ncl.add(new Range(10, 70));
 122     assertEquals(ncl.toString(), "[10-70 [20-50, 30-60]]");
 123     assertTrue(ncl.isValid());
 124   }
 125
 126   @Test(groups = "Functional")
 127   public void testAdd_spanning()
 128   {
 129     List<Range> ranges = new ArrayList<Range>();
 130     ranges.add(new Range(20, 40));
 131     ranges.add(new Range(60, 70));
 132     NCList<Range> ncl = new NCList<Range>(ranges);
 133     assertEquals(ncl.toString(), "[20-40, 60-70]");
 134     assertTrue(ncl.isValid());
 135
 136     ncl.add(new Range(30, 50));
 137     assertEquals(ncl.toString(), "[20-40, 30-50, 60-70]");
 138     assertTrue(ncl.isValid());
 139
 140     ncl.add(new Range(40, 65));
 141     assertEquals(ncl.toString(), "[20-40, 30-50, 40-65, 60-70]");
 142     assertTrue(ncl.isValid());
 143   }
 144
 145   /**
 146    * Do a number of pseudo-random (reproducible) builds of an NCList, with
 147    * checks for validity of the data structure, for greater (but not perfect!)
 148    * confidence that corner cases are being handled correctly.
 149    */
 150   @Test(groups = "Functional")
 151   public void testAdd_pseudoRandom()
 152   {
 153     Random r = new Random(108); // well why not?
 154     int[] scales = new int[] { 10, 100, 1000 };
 155
 156     for (int scale : scales)
 157     {
 158       NCList<Range> ncl = new NCList<Range>();
 159       int size = 0;
 160       for (int i = 0; i < 100; i++)
 161       {
 162         int r1 = r.nextInt(scale);
 163         int r2 = r.nextInt(scale);
 164         int nextFrom = Math.min(r1, r2);
 165         int nextTo = Math.max(r1, r2);
 166         Range range = new Range(nextFrom, nextTo);
 167         ncl.add(range);
 168         assertTrue(ncl.isValid(),
 169                 String.format("Failed for scale = %d, i=%d", scale, i));
 170         size++;
 171         assertEquals(ncl.getSize(), size);
 172       }
 173       System.out.println(ncl.prettyPrint());
 174     }
 175   }
 176
 177   @Test(groups = "Functional")
 178   public void testGetEntries()
 179   {
 180     List<Range> ranges = new ArrayList<Range>();
 181     Range r1 = new Range(20, 20);
 182     Range r2 = new Range(10, 20);
 183     Range r3 = new Range(15, 30);
 184     Range r4 = new Range(10, 30);
 185     Range r5 = new Range(11, 19);
 186     Range r6 = new Range(10, 20);
 187     ranges.add(r1);
 188     ranges.add(r2);
 189     ranges.add(r3);
 190     ranges.add(r4);
 191     ranges.add(r5);
 192     ranges.add(r6);
 193
 194     NCList<Range> ncl = new NCList<Range>(ranges);
 195     Range r7 = new Range(1, 100);
 196     ncl.add(r7);
 197
 198     List<Range> contents = ncl.getEntries();
 199     assertEquals(contents.size(), 7);
 200     assertTrue(contents.contains(r1));
 201     assertTrue(contents.contains(r2));
 202     assertTrue(contents.contains(r3));
 203     assertTrue(contents.contains(r4));
 204     assertTrue(contents.contains(r5));
 205     assertTrue(contents.contains(r6));
 206     assertTrue(contents.contains(r7));
 207
 208     ncl = new NCList<Range>();
 209     assertTrue(ncl.getEntries().isEmpty());
 210   }
 211 }