test/jalview/datamodel/SequenceTest.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.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertFalse;
  25 import static org.testng.AssertJUnit.assertNotNull;
  26 import static org.testng.AssertJUnit.assertNotSame;
  27 import static org.testng.AssertJUnit.assertNull;
  28 import static org.testng.AssertJUnit.assertSame;
  29 import static org.testng.AssertJUnit.assertTrue;
  30
  31 import jalview.analysis.AlignmentGenerator;
  32 import jalview.commands.EditCommand;
  33 import jalview.commands.EditCommand.Action;
  34 import jalview.datamodel.PDBEntry.Type;
  35 import jalview.gui.JvOptionPane;
  36 import jalview.util.MapList;
  37 import jalview.ws.params.InvalidArgumentException;
  38
  39 import java.io.File;
  40 import java.util.ArrayList;
  41 import java.util.Arrays;
  42 import java.util.BitSet;
  43 import java.util.Iterator;
  44 import java.util.List;
  45 import java.util.Vector;
  46
  47 import org.testng.Assert;
  48 import org.testng.annotations.BeforeClass;
  49 import org.testng.annotations.BeforeMethod;
  50 import org.testng.annotations.Test;
  51
  52 import junit.extensions.PA;
  53
  54 public class SequenceTest
  55 {
  56   @BeforeClass(alwaysRun = true)
  57   public void setUpJvOptionPane()
  58   {
  59     JvOptionPane.setInteractiveMode(false);
  60     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  61   }
  62
  63   Sequence seq;
  64
  65   @BeforeMethod(alwaysRun = true)
  66   public void setUp()
  67   {
  68     seq = new Sequence("FER1", "AKPNGVL");
  69   }
  70
  71   @Test(groups = { "Functional" })
  72   public void testInsertGapsAndGapmaps()
  73   {
  74     SequenceI aseq = seq.deriveSequence();
  75     aseq.insertCharAt(2, 3, '-');
  76     aseq.insertCharAt(6, 3, '-');
  77     assertEquals("Gap insertions not correct", "AK---P---NGVL",
  78             aseq.getSequenceAsString());
  79     List<int[]> gapInt = aseq.getInsertions();
  80     assertEquals("Gap interval 1 start wrong", 2, gapInt.get(0)[0]);
  81     assertEquals("Gap interval 1 end wrong", 4, gapInt.get(0)[1]);
  82     assertEquals("Gap interval 2 start wrong", 6, gapInt.get(1)[0]);
  83     assertEquals("Gap interval 2 end wrong", 8, gapInt.get(1)[1]);
  84
  85     BitSet gapfield = aseq.getInsertionsAsBits();
  86     BitSet expectedgaps = new BitSet();
  87     expectedgaps.set(2, 5);
  88     expectedgaps.set(6, 9);
  89
  90     assertEquals(6, expectedgaps.cardinality());
  91
  92     assertEquals("getInsertionsAsBits didn't mark expected number of gaps",
  93             6, gapfield.cardinality());
  94
  95     assertEquals("getInsertionsAsBits not correct.", expectedgaps, gapfield);
  96   }
  97
  98   @Test(groups = ("Functional"))
  99   public void testIsProtein()
 100   {
 101     // test Protein
 102     assertTrue(new Sequence("prot", "ASDFASDFASDF").isProtein());
 103     // test DNA
 104     assertFalse(new Sequence("prot", "ACGTACGTACGT").isProtein());
 105     // test RNA
 106     SequenceI sq = new Sequence("prot", "ACGUACGUACGU");
 107     assertFalse(sq.isProtein());
 108     // change sequence, should trigger an update of cached result
 109     sq.setSequence("ASDFASDFADSF");
 110     assertTrue(sq.isProtein());
 111   }
 112
 113   @Test(groups = ("Functional"))
 114   public void testIsProteinWithXorNAmbiguityCodes()
 115   {
 116     // test Protein with N - poly asparagine
 117     assertTrue(new Sequence("prot", "ASDFASDFASDFNNNNNNNNN").isProtein());
 118     assertTrue(new Sequence("prot", "NNNNNNNNNNNNNNNNNNNNN").isProtein());
 119     // test Protein with X
 120     assertTrue(new Sequence("prot", "ASDFASDFASDFXXXXXXXXX").isProtein());
 121     // test DNA with X
 122     assertFalse(new Sequence("prot", "ACGTACGTACGTXXXXXXXX").isProtein());
 123     // test DNA with N
 124     assertFalse(new Sequence("prot", "ACGTACGTACGTNNNNNNNN").isProtein());
 125     // test RNA with X
 126     assertFalse(new Sequence("prot", "ACGUACGUACGUXXXXXXXXX").isProtein());
 127     assertFalse(new Sequence("prot", "ACGUACGUACGUNNNNNNNNN").isProtein());
 128   }
 129
 130   @Test(groups = { "Functional" })
 131   public void testGetAnnotation()
 132   {
 133     // initial state returns null not an empty array
 134     assertNull(seq.getAnnotation());
 135     AlignmentAnnotation ann = addAnnotation("label1", "desc1", "calcId1",
 136             1f);
 137     AlignmentAnnotation[] anns = seq.getAnnotation();
 138     assertEquals(1, anns.length);
 139     assertSame(ann, anns[0]);
 140
 141     // removing all annotations reverts array to null
 142     seq.removeAlignmentAnnotation(ann);
 143     assertNull(seq.getAnnotation());
 144   }
 145
 146   @Test(groups = { "Functional" })
 147   public void testGetAnnotation_forLabel()
 148   {
 149     AlignmentAnnotation ann1 = addAnnotation("label1", "desc1", "calcId1",
 150             1f);
 151     addAnnotation("label2", "desc2", "calcId2", 1f);
 152     AlignmentAnnotation ann3 = addAnnotation("label1", "desc3", "calcId3",
 153             1f);
 154     AlignmentAnnotation[] anns = seq.getAnnotation("label1");
 155     assertEquals(2, anns.length);
 156     assertSame(ann1, anns[0]);
 157     assertSame(ann3, anns[1]);
 158   }
 159
 160   private AlignmentAnnotation addAnnotation(String label,
 161           String description, String calcId, float value)
 162   {
 163     final AlignmentAnnotation annotation = new AlignmentAnnotation(label,
 164             description, value);
 165     annotation.setCalcId(calcId);
 166     seq.addAlignmentAnnotation(annotation);
 167     return annotation;
 168   }
 169
 170   @Test(groups = { "Functional" })
 171   public void testGetAlignmentAnnotations_forCalcIdAndLabel()
 172   {
 173     addAnnotation("label1", "desc1", "calcId1", 1f);
 174     AlignmentAnnotation ann2 = addAnnotation("label2", "desc2", "calcId2",
 175             1f);
 176     addAnnotation("label2", "desc3", "calcId3", 1f);
 177     AlignmentAnnotation ann4 = addAnnotation("label2", "desc3", "calcId2",
 178             1f);
 179     addAnnotation("label5", "desc3", null, 1f);
 180     addAnnotation(null, "desc3", "calcId3", 1f);
 181
 182     List<AlignmentAnnotation> anns = seq.getAlignmentAnnotations("calcId2",
 183             "label2");
 184     assertEquals(2, anns.size());
 185     assertSame(ann2, anns.get(0));
 186     assertSame(ann4, anns.get(1));
 187
 188     assertTrue(seq.getAlignmentAnnotations("calcId2", "label3").isEmpty());
 189     assertTrue(seq.getAlignmentAnnotations("calcId3", "label5").isEmpty());
 190     assertTrue(seq.getAlignmentAnnotations("calcId2", null).isEmpty());
 191     assertTrue(seq.getAlignmentAnnotations(null, "label3").isEmpty());
 192     assertTrue(seq.getAlignmentAnnotations(null, null).isEmpty());
 193   }
 194
 195   /**
 196    * Tests for addAlignmentAnnotation. Note this method has the side-effect of
 197    * setting the sequenceRef on the annotation. Adding the same annotation twice
 198    * should be ignored.
 199    */
 200   @Test(groups = { "Functional" })
 201   public void testAddAlignmentAnnotation()
 202   {
 203     assertNull(seq.getAnnotation());
 204     final AlignmentAnnotation annotation = new AlignmentAnnotation("a",
 205             "b", 2d);
 206     assertNull(annotation.sequenceRef);
 207     seq.addAlignmentAnnotation(annotation);
 208     assertSame(seq, annotation.sequenceRef);
 209     AlignmentAnnotation[] anns = seq.getAnnotation();
 210     assertEquals(1, anns.length);
 211     assertSame(annotation, anns[0]);
 212
 213     // re-adding does nothing
 214     seq.addAlignmentAnnotation(annotation);
 215     anns = seq.getAnnotation();
 216     assertEquals(1, anns.length);
 217     assertSame(annotation, anns[0]);
 218
 219     // an identical but different annotation can be added
 220     final AlignmentAnnotation annotation2 = new AlignmentAnnotation("a",
 221             "b", 2d);
 222     seq.addAlignmentAnnotation(annotation2);
 223     anns = seq.getAnnotation();
 224     assertEquals(2, anns.length);
 225     assertSame(annotation, anns[0]);
 226     assertSame(annotation2, anns[1]);
 227   }
 228
 229   @Test(groups = { "Functional" })
 230   public void testGetStartGetEnd()
 231   {
 232     SequenceI sq = new Sequence("test", "ABCDEF");
 233     assertEquals(1, sq.getStart());
 234     assertEquals(6, sq.getEnd());
 235
 236     sq = new Sequence("test", "--AB-C-DEF--");
 237     assertEquals(1, sq.getStart());
 238     assertEquals(6, sq.getEnd());
 239
 240     sq = new Sequence("test", "----");
 241     assertEquals(1, sq.getStart());
 242     assertEquals(0, sq.getEnd()); // ??
 243   }
 244
 245   /**
 246    * Tests for the method that returns an alignment column position (base 1) for
 247    * a given sequence position (base 1).
 248    */
 249   @Test(groups = { "Functional" })
 250   public void testFindIndex()
 251   {
 252     /*
 253      * call sequenceChanged() after each test to invalidate any cursor,
 254      * forcing the 1-arg findIndex to be executed
 255      */
 256     SequenceI sq = new Sequence("test", "ABCDEF");
 257     assertEquals(0, sq.findIndex(0));
 258     sq.sequenceChanged();
 259     assertEquals(1, sq.findIndex(1));
 260     sq.sequenceChanged();
 261     assertEquals(5, sq.findIndex(5));
 262     sq.sequenceChanged();
 263     assertEquals(6, sq.findIndex(6));
 264     sq.sequenceChanged();
 265     assertEquals(6, sq.findIndex(9));
 266
 267     final String aligned = "-A--B-C-D-E-F--";
 268     assertEquals(15, aligned.length());
 269     sq = new Sequence("test/8-13", aligned);
 270     assertEquals(2, sq.findIndex(8));
 271     sq.sequenceChanged();
 272     assertEquals(5, sq.findIndex(9));
 273     sq.sequenceChanged();
 274     assertEquals(7, sq.findIndex(10));
 275
 276     // before start returns 0
 277     sq.sequenceChanged();
 278     assertEquals(0, sq.findIndex(0));
 279     sq.sequenceChanged();
 280     assertEquals(0, sq.findIndex(-1));
 281
 282     // beyond end returns last residue column
 283     sq.sequenceChanged();
 284     assertEquals(13, sq.findIndex(99));
 285
 286     /*
 287      * residue before sequence 'end' but beyond end of sequence returns
 288      * length of sequence (last column) (rightly or wrongly!)
 289      */
 290     sq = new Sequence("test/8-15", "A-B-C-"); // trailing gap case
 291     assertEquals(6, sq.getLength());
 292     sq.sequenceChanged();
 293     assertEquals(sq.getLength(), sq.findIndex(14));
 294     sq = new Sequence("test/8-99", "-A--B-C-D"); // trailing residue case
 295     sq.sequenceChanged();
 296     assertEquals(sq.getLength(), sq.findIndex(65));
 297
 298     /*
 299      * residue after sequence 'start' but before first residue returns
 300      * zero (before first column) (rightly or wrongly!)
 301      */
 302     sq = new Sequence("test/8-15", "-A-B-C-"); // leading gap case
 303     sq.sequenceChanged();
 304     assertEquals(0, sq.findIndex(3));
 305     sq = new Sequence("test/8-15", "A-B-C-"); // leading residue case
 306     sq.sequenceChanged();
 307     assertEquals(0, sq.findIndex(2));
 308   }
 309
 310   @Test(groups = { "Functional" })
 311   public void testFindPositions()
 312   {
 313     SequenceI sq = new Sequence("test/8-13", "-ABC---DE-F--");
 314
 315     /*
 316      * invalid inputs
 317      */
 318     assertNull(sq.findPositions(6, 5));
 319     assertNull(sq.findPositions(0, 5));
 320     assertNull(sq.findPositions(-1, 5));
 321
 322     /*
 323      * all gapped ranges
 324      */
 325     assertNull(sq.findPositions(1, 1)); // 1-based columns
 326     assertNull(sq.findPositions(5, 5));
 327     assertNull(sq.findPositions(5, 6));
 328     assertNull(sq.findPositions(5, 7));
 329
 330     /*
 331      * all ungapped ranges
 332      */
 333     assertEquals(new Range(8, 8), sq.findPositions(2, 2)); // A
 334     assertEquals(new Range(8, 9), sq.findPositions(2, 3)); // AB
 335     assertEquals(new Range(8, 10), sq.findPositions(2, 4)); // ABC
 336     assertEquals(new Range(9, 10), sq.findPositions(3, 4)); // BC
 337
 338     /*
 339      * gap to ungapped range
 340      */
 341     assertEquals(new Range(8, 10), sq.findPositions(1, 4)); // ABC
 342     assertEquals(new Range(11, 12), sq.findPositions(6, 9)); // DE
 343
 344     /*
 345      * ungapped to gapped range
 346      */
 347     assertEquals(new Range(10, 10), sq.findPositions(4, 5)); // C
 348     assertEquals(new Range(9, 13), sq.findPositions(3, 11)); // BCDEF
 349
 350     /*
 351      * ungapped to ungapped enclosing gaps
 352      */
 353     assertEquals(new Range(10, 11), sq.findPositions(4, 8)); // CD
 354     assertEquals(new Range(8, 13), sq.findPositions(2, 11)); // ABCDEF
 355
 356     /*
 357      * gapped to gapped enclosing ungapped
 358      */
 359     assertEquals(new Range(8, 10), sq.findPositions(1, 5)); // ABC
 360     assertEquals(new Range(11, 12), sq.findPositions(5, 10)); // DE
 361     assertEquals(new Range(8, 13), sq.findPositions(1, 13)); // the lot
 362     assertEquals(new Range(8, 13), sq.findPositions(1, 99));
 363   }
 364
 365   /**
 366    * Tests for the method that returns a dataset sequence position (start..) for
 367    * an aligned column position (base 0).
 368    */
 369   @Test(groups = { "Functional" })
 370   public void testFindPosition()
 371   {
 372     /*
 373      * call sequenceChanged() after each test to invalidate any cursor,
 374      * forcing the 1-arg findPosition to be executed
 375      */
 376     SequenceI sq = new Sequence("test/8-13", "ABCDEF");
 377     assertEquals(8, sq.findPosition(0));
 378     // Sequence should now hold a cursor at [8, 0]
 379     assertEquals("test:Pos8:Col1:startCol1:endCol0:tok1",
 380             PA.getValue(sq, "cursor").toString());
 381     SequenceCursor cursor = (SequenceCursor) PA.getValue(sq, "cursor");
 382     int token = (int) PA.getValue(sq, "changeCount");
 383     assertEquals(new SequenceCursor(sq, 8, 1, token), cursor);
 384
 385     sq.sequenceChanged();
 386
 387     /*
 388      * find F13 at column offset 5, cursor should update to [13, 6]
 389      * endColumn is found and saved in cursor
 390      */
 391     assertEquals(13, sq.findPosition(5));
 392     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
 393     assertEquals(++token, (int) PA.getValue(sq, "changeCount"));
 394     assertEquals(new SequenceCursor(sq, 13, 6, token), cursor);
 395     assertEquals("test:Pos13:Col6:startCol1:endCol6:tok2",
 396             PA.getValue(sq, "cursor").toString());
 397
 398     // assertEquals(-1, seq.findPosition(6)); // fails
 399
 400     sq = new Sequence("test/8-11", "AB-C-D--");
 401     token = (int) PA.getValue(sq, "changeCount"); // 1 for setStart
 402     assertEquals(8, sq.findPosition(0));
 403     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
 404     assertEquals(new SequenceCursor(sq, 8, 1, token), cursor);
 405     assertEquals("test:Pos8:Col1:startCol1:endCol0:tok1",
 406             PA.getValue(sq, "cursor").toString());
 407
 408     sq.sequenceChanged();
 409     assertEquals(9, sq.findPosition(1));
 410     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
 411     assertEquals(new SequenceCursor(sq, 9, 2, ++token), cursor);
 412     assertEquals("test:Pos9:Col2:startCol1:endCol0:tok2",
 413             PA.getValue(sq, "cursor").toString());
 414
 415     sq.sequenceChanged();
 416     // gap position 'finds' residue to the right (not the left as per javadoc)
 417     // cursor is set to the last residue position found [B 2]
 418     assertEquals(10, sq.findPosition(2));
 419     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
 420     assertEquals(new SequenceCursor(sq, 9, 2, ++token), cursor);
 421     assertEquals("test:Pos9:Col2:startCol1:endCol0:tok3",
 422             PA.getValue(sq, "cursor").toString());
 423
 424     sq.sequenceChanged();
 425     assertEquals(10, sq.findPosition(3));
 426     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
 427     assertEquals(new SequenceCursor(sq, 10, 4, ++token), cursor);
 428     assertEquals("test:Pos10:Col4:startCol1:endCol0:tok4",
 429             PA.getValue(sq, "cursor").toString());
 430
 431     sq.sequenceChanged();
 432     // column[4] is the gap after C - returns D11
 433     // cursor is set to [C 4]
 434     assertEquals(11, sq.findPosition(4));
 435     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
 436     assertEquals(new SequenceCursor(sq, 10, 4, ++token), cursor);
 437     assertEquals("test:Pos10:Col4:startCol1:endCol0:tok5",
 438             PA.getValue(sq, "cursor").toString());
 439
 440     sq.sequenceChanged();
 441     assertEquals(11, sq.findPosition(5)); // D
 442     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
 443     assertEquals(new SequenceCursor(sq, 11, 6, ++token), cursor);
 444     // lastCol has been found and saved in the cursor
 445     assertEquals("test:Pos11:Col6:startCol1:endCol6:tok6",
 446             PA.getValue(sq, "cursor").toString());
 447
 448     sq.sequenceChanged();
 449     // returns 1 more than sequence length if off the end ?!?
 450     assertEquals(12, sq.findPosition(6));
 451
 452     sq.sequenceChanged();
 453     assertEquals(12, sq.findPosition(7));
 454
 455     /*
 456      * first findPosition should also set firstResCol in cursor
 457      */
 458     sq = new Sequence("test/8-13", "--AB-C-DEF--");
 459     assertEquals(8, sq.findPosition(0));
 460     assertNull(PA.getValue(sq, "cursor"));
 461     assertEquals(1, PA.getValue(sq, "changeCount"));
 462
 463     sq.sequenceChanged();
 464     assertEquals(8, sq.findPosition(1));
 465     assertNull(PA.getValue(sq, "cursor"));
 466
 467     sq.sequenceChanged();
 468     assertEquals(8, sq.findPosition(2));
 469     assertEquals("test:Pos8:Col3:startCol3:endCol0:tok3",
 470             PA.getValue(sq, "cursor").toString());
 471
 472     sq.sequenceChanged();
 473     assertEquals(9, sq.findPosition(3));
 474     assertEquals("test:Pos9:Col4:startCol3:endCol0:tok4",
 475             PA.getValue(sq, "cursor").toString());
 476
 477     sq.sequenceChanged();
 478     // column[4] is a gap, returns next residue pos (C10)
 479     // cursor is set to last residue found [B]
 480     assertEquals(10, sq.findPosition(4));
 481     assertEquals("test:Pos9:Col4:startCol3:endCol0:tok5",
 482             PA.getValue(sq, "cursor").toString());
 483
 484     sq.sequenceChanged();
 485     assertEquals(10, sq.findPosition(5));
 486     assertEquals("test:Pos10:Col6:startCol3:endCol0:tok6",
 487             PA.getValue(sq, "cursor").toString());
 488
 489     sq.sequenceChanged();
 490     // column[6] is a gap, returns next residue pos (D11)
 491     // cursor is set to last residue found [C]
 492     assertEquals(11, sq.findPosition(6));
 493     assertEquals("test:Pos10:Col6:startCol3:endCol0:tok7",
 494             PA.getValue(sq, "cursor").toString());
 495
 496     sq.sequenceChanged();
 497     assertEquals(11, sq.findPosition(7));
 498     assertEquals("test:Pos11:Col8:startCol3:endCol0:tok8",
 499             PA.getValue(sq, "cursor").toString());
 500
 501     sq.sequenceChanged();
 502     assertEquals(12, sq.findPosition(8));
 503     assertEquals("test:Pos12:Col9:startCol3:endCol0:tok9",
 504             PA.getValue(sq, "cursor").toString());
 505
 506     /*
 507      * when the last residue column is found, it is set in the cursor
 508      */
 509     sq.sequenceChanged();
 510     assertEquals(13, sq.findPosition(9));
 511     assertEquals("test:Pos13:Col10:startCol3:endCol10:tok10",
 512             PA.getValue(sq, "cursor").toString());
 513
 514     sq.sequenceChanged();
 515     assertEquals(14, sq.findPosition(10));
 516     assertEquals("test:Pos13:Col10:startCol3:endCol10:tok11",
 517             PA.getValue(sq, "cursor").toString());
 518
 519     /*
 520      * findPosition for column beyond sequence length
 521      * returns 1 more than last residue position
 522      */
 523     sq.sequenceChanged();
 524     assertEquals(14, sq.findPosition(11));
 525     assertEquals("test:Pos13:Col10:startCol3:endCol10:tok12",
 526             PA.getValue(sq, "cursor").toString());
 527
 528     sq.sequenceChanged();
 529     assertEquals(14, sq.findPosition(99));
 530     assertEquals("test:Pos13:Col10:startCol3:endCol10:tok13",
 531             PA.getValue(sq, "cursor").toString());
 532
 533     /*
 534      * gapped sequence ending in non-gap
 535      */
 536     sq = new Sequence("test/8-13", "--AB-C-DEF");
 537     assertEquals(13, sq.findPosition(9));
 538     assertEquals("test:Pos13:Col10:startCol3:endCol10:tok1",
 539             PA.getValue(sq, "cursor").toString());
 540     sq.sequenceChanged();
 541     assertEquals(12, sq.findPosition(8)); // E12
 542     // sequenceChanged() invalidates cursor.lastResidueColumn
 543     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
 544     assertEquals("test:Pos12:Col9:startCol3:endCol0:tok2",
 545             cursor.toString());
 546     // findPosition with cursor accepts base 1 column values
 547     assertEquals(13, ((Sequence) sq).findPosition(10, cursor));
 548     assertEquals(13, sq.findPosition(9)); // F13
 549     // lastResidueColumn has now been found and saved in cursor
 550     assertEquals("test:Pos13:Col10:startCol3:endCol10:tok2",
 551             PA.getValue(sq, "cursor").toString());
 552   }
 553
 554   @Test(groups = { "Functional" })
 555   public void testDeleteChars()
 556   {
 557     /*
 558      * internal delete
 559      */
 560     SequenceI sq = new Sequence("test", "ABCDEF");
 561     assertNull(PA.getValue(sq, "datasetSequence"));
 562     assertEquals(1, sq.getStart());
 563     assertEquals(6, sq.getEnd());
 564     sq.deleteChars(2, 3);
 565     assertEquals("ABDEF", sq.getSequenceAsString());
 566     assertEquals(1, sq.getStart());
 567     assertEquals(5, sq.getEnd());
 568     assertNull(PA.getValue(sq, "datasetSequence"));
 569
 570     /*
 571      * delete at start
 572      */
 573     sq = new Sequence("test", "ABCDEF");
 574     sq.deleteChars(0, 2);
 575     assertEquals("CDEF", sq.getSequenceAsString());
 576     assertEquals(3, sq.getStart());
 577     assertEquals(6, sq.getEnd());
 578     assertNull(PA.getValue(sq, "datasetSequence"));
 579
 580     sq = new Sequence("test", "ABCDE");
 581     sq.deleteChars(0, 3);
 582     assertEquals("DE", sq.getSequenceAsString());
 583     assertEquals(4, sq.getStart());
 584     assertEquals(5, sq.getEnd());
 585     assertNull(PA.getValue(sq, "datasetSequence"));
 586
 587     /*
 588      * delete at end
 589      */
 590     sq = new Sequence("test", "ABCDEF");
 591     sq.deleteChars(4, 6);
 592     assertEquals("ABCD", sq.getSequenceAsString());
 593     assertEquals(1, sq.getStart());
 594     assertEquals(4, sq.getEnd());
 595     assertNull(PA.getValue(sq, "datasetSequence"));
 596
 597     /*
 598      * delete more positions than there are
 599      */
 600     sq = new Sequence("test/8-11", "ABCD");
 601     sq.deleteChars(0, 99);
 602     assertEquals("", sq.getSequenceAsString());
 603     assertEquals(12, sq.getStart()); // = findPosition(99) ?!?
 604     assertEquals(11, sq.getEnd());
 605
 606     sq = new Sequence("test/8-11", "----");
 607     sq.deleteChars(0, 99); // ArrayIndexOutOfBoundsException <= 2.10.2
 608     assertEquals("", sq.getSequenceAsString());
 609     assertEquals(8, sq.getStart());
 610     assertEquals(11, sq.getEnd());
 611   }
 612
 613   @Test(groups = { "Functional" })
 614   public void testDeleteChars_withDbRefsAndFeatures()
 615   {
 616     /*
 617      * internal delete - new dataset sequence created
 618      * gets a copy of any dbrefs
 619      */
 620     SequenceI sq = new Sequence("test", "ABCDEF");
 621     sq.createDatasetSequence();
 622     DBRefEntry dbr1 = new DBRefEntry("Uniprot", "0", "a123");
 623     sq.addDBRef(dbr1);
 624     Object ds = PA.getValue(sq, "datasetSequence");
 625     assertNotNull(ds);
 626     assertEquals(1, sq.getStart());
 627     assertEquals(6, sq.getEnd());
 628     sq.deleteChars(2, 3);
 629     assertEquals("ABDEF", sq.getSequenceAsString());
 630     assertEquals(1, sq.getStart());
 631     assertEquals(5, sq.getEnd());
 632     Object newDs = PA.getValue(sq, "datasetSequence");
 633     assertNotNull(newDs);
 634     assertNotSame(ds, newDs);
 635     assertNotNull(sq.getDBRefs());
 636     assertEquals(1, sq.getDBRefs().size());
 637     assertNotSame(dbr1, sq.getDBRefs().get(0));
 638     assertEquals(dbr1, sq.getDBRefs().get(0));
 639
 640     /*
 641      * internal delete with sequence features
 642      * (failure case for JAL-2541)
 643      */
 644     sq = new Sequence("test", "ABCDEF");
 645     sq.createDatasetSequence();
 646     SequenceFeature sf1 = new SequenceFeature("Cath", "desc", 2, 4, 2f,
 647             "CathGroup");
 648     sq.addSequenceFeature(sf1);
 649     ds = PA.getValue(sq, "datasetSequence");
 650     assertNotNull(ds);
 651     assertEquals(1, sq.getStart());
 652     assertEquals(6, sq.getEnd());
 653     sq.deleteChars(2, 4);
 654     assertEquals("ABEF", sq.getSequenceAsString());
 655     assertEquals(1, sq.getStart());
 656     assertEquals(4, sq.getEnd());
 657     newDs = PA.getValue(sq, "datasetSequence");
 658     assertNotNull(newDs);
 659     assertNotSame(ds, newDs);
 660     List<SequenceFeature> sfs = sq.getSequenceFeatures();
 661     assertEquals(1, sfs.size());
 662     assertNotSame(sf1, sfs.get(0));
 663     assertEquals(sf1, sfs.get(0));
 664
 665     /*
 666      * delete at start - no new dataset sequence created
 667      * any sequence features remain as before
 668      */
 669     sq = new Sequence("test", "ABCDEF");
 670     sq.createDatasetSequence();
 671     ds = PA.getValue(sq, "datasetSequence");
 672     sf1 = new SequenceFeature("Cath", "desc", 2, 4, 2f, "CathGroup");
 673     sq.addSequenceFeature(sf1);
 674     sq.deleteChars(0, 2);
 675     assertEquals("CDEF", sq.getSequenceAsString());
 676     assertEquals(3, sq.getStart());
 677     assertEquals(6, sq.getEnd());
 678     assertSame(ds, PA.getValue(sq, "datasetSequence"));
 679     sfs = sq.getSequenceFeatures();
 680     assertNotNull(sfs);
 681     assertEquals(1, sfs.size());
 682     assertSame(sf1, sfs.get(0));
 683
 684     /*
 685      * delete at end - no new dataset sequence created
 686      * any dbrefs remain as before
 687      */
 688     sq = new Sequence("test", "ABCDEF");
 689     sq.createDatasetSequence();
 690     ds = PA.getValue(sq, "datasetSequence");
 691     dbr1 = new DBRefEntry("Uniprot", "0", "a123");
 692     sq.addDBRef(dbr1);
 693     sq.deleteChars(4, 6);
 694     assertEquals("ABCD", sq.getSequenceAsString());
 695     assertEquals(1, sq.getStart());
 696     assertEquals(4, sq.getEnd());
 697     assertSame(ds, PA.getValue(sq, "datasetSequence"));
 698     assertNotNull(sq.getDBRefs());
 699     assertEquals(1, sq.getDBRefs().size());
 700     assertSame(dbr1, sq.getDBRefs().get(0));
 701   }
 702
 703   @Test(groups = { "Functional" })
 704   public void testInsertCharAt()
 705   {
 706     // non-static methods:
 707     SequenceI sq = new Sequence("test", "ABCDEF");
 708     sq.insertCharAt(0, 'z');
 709     assertEquals("zABCDEF", sq.getSequenceAsString());
 710     sq.insertCharAt(2, 2, 'x');
 711     assertEquals("zAxxBCDEF", sq.getSequenceAsString());
 712
 713     // for static method see StringUtilsTest
 714   }
 715
 716   /**
 717    * Test the method that returns an array of aligned sequence positions where
 718    * the array index is the data sequence position (both base 0).
 719    */
 720   @Test(groups = { "Functional" })
 721   public void testGapMap()
 722   {
 723     SequenceI sq = new Sequence("test", "-A--B-CD-E--F-");
 724     sq.createDatasetSequence();
 725     assertEquals("[1, 4, 6, 7, 9, 12]", Arrays.toString(sq.gapMap()));
 726   }
 727
 728   /**
 729    * Test the method that gets sequence features, either from the sequence or
 730    * its dataset.
 731    */
 732   @Test(groups = { "Functional" })
 733   public void testGetSequenceFeatures()
 734   {
 735     SequenceI sq = new Sequence("test", "GATCAT");
 736     sq.createDatasetSequence();
 737
 738     assertTrue(sq.getSequenceFeatures().isEmpty());
 739
 740     /*
 741      * SequenceFeature on sequence
 742      */
 743     SequenceFeature sf = new SequenceFeature("Cath", "desc", 2, 4, 2f, null);
 744     sq.addSequenceFeature(sf);
 745     List<SequenceFeature> sfs = sq.getSequenceFeatures();
 746     assertEquals(1, sfs.size());
 747     assertSame(sf, sfs.get(0));
 748
 749     /*
 750      * SequenceFeature on sequence and dataset sequence; returns that on
 751      * sequence
 752      *
 753      * Note JAL-2046: spurious: we have no use case for this at the moment.
 754      * This test also buggy - as sf2.equals(sf), no new feature is added
 755      */
 756     SequenceFeature sf2 = new SequenceFeature("Cath", "desc", 2, 4, 2f,
 757             null);
 758     sq.getDatasetSequence().addSequenceFeature(sf2);
 759     sfs = sq.getSequenceFeatures();
 760     assertEquals(1, sfs.size());
 761     assertSame(sf, sfs.get(0));
 762
 763     /*
 764      * SequenceFeature on dataset sequence only
 765      * Note JAL-2046: spurious: we have no use case for setting a non-dataset sequence's feature array to null at the moment.
 766      */
 767     sq.setSequenceFeatures(null);
 768     assertTrue(sq.getDatasetSequence().getSequenceFeatures().isEmpty());
 769
 770     /*
 771      * Corrupt case - no SequenceFeature, dataset's dataset is the original
 772      * sequence. Test shows no infinite loop results.
 773      */
 774     sq.getDatasetSequence().setSequenceFeatures(null);
 775     /**
 776      * is there a usecase for this ? setDatasetSequence should throw an error if
 777      * this actually occurs.
 778      */
 779     try
 780     {
 781       sq.getDatasetSequence().setDatasetSequence(sq); // loop!
 782       Assert.fail("Expected Error to be raised when calling setDatasetSequence with self reference");
 783     } catch (IllegalArgumentException e)
 784     {
 785       // TODO Jalview error/exception class for raising implementation errors
 786       assertTrue(e.getMessage().toLowerCase()
 787               .contains("implementation error"));
 788     }
 789     assertTrue(sq.getSequenceFeatures().isEmpty());
 790   }
 791
 792   /**
 793    * Test the method that returns an array, indexed by sequence position, whose
 794    * entries are the residue positions at the sequence position (or to the right
 795    * if a gap)
 796    */
 797   @Test(groups = { "Functional" })
 798   public void testFindPositionMap()
 799   {
 800     /*
 801      * Note: Javadoc for findPosition says it returns the residue position to
 802      * the left of a gapped position; in fact it returns the position to the
 803      * right. Also it returns a non-existent residue position for a gap beyond
 804      * the sequence.
 805      */
 806     Sequence sq = new Sequence("TestSeq", "AB.C-D E.");
 807     int[] map = sq.findPositionMap();
 808     assertEquals(Arrays.toString(new int[] { 1, 2, 3, 3, 4, 4, 5, 5, 6 }),
 809             Arrays.toString(map));
 810   }
 811
 812   /**
 813    * Test for getSubsequence
 814    */
 815   @Test(groups = { "Functional" })
 816   public void testGetSubsequence()
 817   {
 818     SequenceI sq = new Sequence("TestSeq", "ABCDEFG");
 819     sq.createDatasetSequence();
 820
 821     // positions are base 0, end position is exclusive
 822     SequenceI subseq = sq.getSubSequence(2, 4);
 823
 824     assertEquals("CD", subseq.getSequenceAsString());
 825     // start/end are base 1 positions
 826     assertEquals(3, subseq.getStart());
 827     assertEquals(4, subseq.getEnd());
 828     // subsequence shares the full dataset sequence
 829     assertSame(sq.getDatasetSequence(), subseq.getDatasetSequence());
 830   }
 831
 832   /**
 833    * test createDatasetSequence behaves to doc
 834    */
 835   @Test(groups = { "Functional" })
 836   public void testCreateDatasetSequence()
 837   {
 838     SequenceI sq = new Sequence("my", "ASDASD");
 839     sq.addSequenceFeature(new SequenceFeature("type", "desc", 1, 10, 1f,
 840             "group"));
 841     sq.addDBRef(new DBRefEntry("source", "version", "accession"));
 842     assertNull(sq.getDatasetSequence());
 843     assertNotNull(PA.getValue(sq, "sequenceFeatureStore"));
 844     assertNotNull(PA.getValue(sq, "dbrefs"));
 845
 846     SequenceI rds = sq.createDatasetSequence();
 847     assertNotNull(rds);
 848     assertNull(rds.getDatasetSequence());
 849     assertSame(sq.getDatasetSequence(), rds);
 850
 851     // sequence features and dbrefs transferred to dataset sequence
 852     assertNull(PA.getValue(sq, "sequenceFeatureStore"));
 853     assertNull(PA.getValue(sq, "dbrefs"));
 854     assertNotNull(PA.getValue(rds, "sequenceFeatureStore"));
 855     assertNotNull(PA.getValue(rds, "dbrefs"));
 856   }
 857
 858   /**
 859    * Test for deriveSequence applied to a sequence with a dataset
 860    */
 861   @Test(groups = { "Functional" })
 862   public void testDeriveSequence_existingDataset()
 863   {
 864     Sequence sq = new Sequence("Seq1", "CD");
 865     sq.setDatasetSequence(new Sequence("Seq1", "ABCDEF"));
 866     sq.getDatasetSequence().addSequenceFeature(
 867             new SequenceFeature("", "", 1, 2, 0f, null));
 868     sq.setStart(3);
 869     sq.setEnd(4);
 870
 871     sq.setDescription("Test sequence description..");
 872     sq.setVamsasId("TestVamsasId");
 873     sq.addDBRef(new DBRefEntry("PDB", "version0", "1TST"));
 874
 875     sq.addDBRef(new DBRefEntry("PDB", "version1", "1PDB"));
 876     sq.addDBRef(new DBRefEntry("PDB", "version2", "2PDB"));
 877     sq.addDBRef(new DBRefEntry("PDB", "version3", "3PDB"));
 878     sq.addDBRef(new DBRefEntry("PDB", "version4", "4PDB"));
 879
 880     sq.addPDBId(new PDBEntry("1PDB", "A", Type.PDB, "filePath/test1"));
 881     sq.addPDBId(new PDBEntry("1PDB", "B", Type.PDB, "filePath/test1"));
 882     sq.addPDBId(new PDBEntry("2PDB", "A", Type.MMCIF, "filePath/test2"));
 883     sq.addPDBId(new PDBEntry("2PDB", "B", Type.MMCIF, "filePath/test2"));
 884
 885     // these are the same as ones already added
 886     DBRefEntry pdb1pdb = new DBRefEntry("PDB", "version1", "1PDB");
 887     DBRefEntry pdb2pdb = new DBRefEntry("PDB", "version2", "2PDB");
 888
 889     List<DBRefEntry> primRefs = Arrays.asList(new DBRefEntry[] { pdb1pdb,
 890         pdb2pdb });
 891
 892     sq.getDatasetSequence().addDBRef(pdb1pdb); // should do nothing
 893     sq.getDatasetSequence().addDBRef(pdb2pdb); // should do nothing
 894     sq.getDatasetSequence().addDBRef(
 895             new DBRefEntry("PDB", "version3", "3PDB")); // should do nothing
 896     sq.getDatasetSequence().addDBRef(
 897             new DBRefEntry("PDB", "version4", "4PDB")); // should do nothing
 898
 899     PDBEntry pdbe1a = new PDBEntry("1PDB", "A", Type.PDB, "filePath/test1");
 900     PDBEntry pdbe1b = new PDBEntry("1PDB", "B", Type.PDB, "filePath/test1");
 901     PDBEntry pdbe2a = new PDBEntry("2PDB", "A", Type.MMCIF,
 902             "filePath/test2");
 903     PDBEntry pdbe2b = new PDBEntry("2PDB", "B", Type.MMCIF,
 904             "filePath/test2");
 905     sq.getDatasetSequence().addPDBId(pdbe1a);
 906     sq.getDatasetSequence().addPDBId(pdbe1b);
 907     sq.getDatasetSequence().addPDBId(pdbe2a);
 908     sq.getDatasetSequence().addPDBId(pdbe2b);
 909
 910     /*
 911      * test we added pdb entries to the dataset sequence
 912      */
 913     Assert.assertEquals(sq.getDatasetSequence().getAllPDBEntries(), Arrays
 914             .asList(new PDBEntry[] { pdbe1a, pdbe1b, pdbe2a, pdbe2b }),
 915             "PDB Entries were not found on dataset sequence.");
 916
 917     /*
 918      * we should recover a pdb entry that is on the dataset sequence via PDBEntry
 919      */
 920     Assert.assertEquals(pdbe1a,
 921             sq.getDatasetSequence().getPDBEntry("1PDB"),
 922             "PDB Entry '1PDB' not found on dataset sequence via getPDBEntry.");
 923     ArrayList<Annotation> annotsList = new ArrayList<>();
 924     System.out.println(">>>>>> " + sq.getSequenceAsString().length());
 925     annotsList.add(new Annotation("A", "A", 'X', 0.1f));
 926     annotsList.add(new Annotation("A", "A", 'X', 0.1f));
 927     Annotation[] annots = annotsList.toArray(new Annotation[0]);
 928     sq.addAlignmentAnnotation(new AlignmentAnnotation("Test annot",
 929             "Test annot description", annots));
 930     sq.getDatasetSequence().addAlignmentAnnotation(
 931             new AlignmentAnnotation("Test annot", "Test annot description",
 932                     annots));
 933     Assert.assertEquals(sq.getDescription(), "Test sequence description..");
 934     Assert.assertEquals(sq.getDBRefs().size(), 5); // DBRefs are on dataset
 935                                                    // sequence
 936     Assert.assertEquals(sq.getAllPDBEntries().size(), 4);
 937     Assert.assertNotNull(sq.getAnnotation());
 938     Assert.assertEquals(sq.getAnnotation()[0].annotations.length, 2);
 939     Assert.assertEquals(sq.getDatasetSequence().getDBRefs().size(), 5); // same
 940                                                                         // as
 941                                                                         // sq.getDBRefs()
 942     Assert.assertEquals(sq.getDatasetSequence().getAllPDBEntries().size(),
 943             4);
 944     Assert.assertNotNull(sq.getDatasetSequence().getAnnotation());
 945
 946     Sequence derived = (Sequence) sq.deriveSequence();
 947
 948     Assert.assertEquals(derived.getDescription(),
 949             "Test sequence description..");
 950     Assert.assertEquals(derived.getDBRefs().size(), 5); // come from dataset
 951     Assert.assertEquals(derived.getAllPDBEntries().size(), 4);
 952     Assert.assertNotNull(derived.getAnnotation());
 953     Assert.assertEquals(derived.getAnnotation()[0].annotations.length, 2);
 954     Assert.assertEquals(derived.getDatasetSequence().getDBRefs().size(), 5);
 955     Assert.assertEquals(derived.getDatasetSequence().getAllPDBEntries()
 956             .size(), 4);
 957     Assert.assertNotNull(derived.getDatasetSequence().getAnnotation());
 958
 959     assertEquals("CD", derived.getSequenceAsString());
 960     assertSame(sq.getDatasetSequence(), derived.getDatasetSequence());
 961
 962     // derived sequence should access dataset sequence features
 963     assertNotNull(sq.getSequenceFeatures());
 964     assertEquals(sq.getSequenceFeatures(), derived.getSequenceFeatures());
 965
 966     /*
 967      *  verify we have primary db refs *just* for PDB IDs with associated
 968      *  PDBEntry objects
 969      */
 970
 971     assertEquals(primRefs, sq.getPrimaryDBRefs());
 972     assertEquals(primRefs, sq.getDatasetSequence().getPrimaryDBRefs());
 973
 974     assertEquals(sq.getPrimaryDBRefs(), derived.getPrimaryDBRefs());
 975
 976   }
 977
 978   /**
 979    * Test for deriveSequence applied to an ungapped sequence with no dataset
 980    */
 981   @Test(groups = { "Functional" })
 982   public void testDeriveSequence_noDatasetUngapped()
 983   {
 984     SequenceI sq = new Sequence("Seq1", "ABCDEF");
 985     assertEquals(1, sq.getStart());
 986     assertEquals(6, sq.getEnd());
 987     SequenceI derived = sq.deriveSequence();
 988     assertEquals("ABCDEF", derived.getSequenceAsString());
 989     assertEquals("ABCDEF", derived.getDatasetSequence()
 990             .getSequenceAsString());
 991   }
 992
 993   /**
 994    * Test for deriveSequence applied to a gapped sequence with no dataset
 995    */
 996   @Test(groups = { "Functional" })
 997   public void testDeriveSequence_noDatasetGapped()
 998   {
 999     SequenceI sq = new Sequence("Seq1", "AB-C.D EF");
1000     assertEquals(1, sq.getStart());
1001     assertEquals(6, sq.getEnd());
1002     assertNull(sq.getDatasetSequence());
1003     SequenceI derived = sq.deriveSequence();
1004     assertEquals("AB-C.D EF", derived.getSequenceAsString());
1005     assertEquals("ABCDEF", derived.getDatasetSequence()
1006             .getSequenceAsString());
1007   }
1008
1009   @Test(groups = { "Functional" })
1010   public void testCopyConstructor_noDataset()
1011   {
1012     SequenceI seq1 = new Sequence("Seq1", "AB-C.D EF");
1013     seq1.setDescription("description");
1014     seq1.addAlignmentAnnotation(new AlignmentAnnotation("label", "desc",
1015             1.3d));
1016     seq1.addSequenceFeature(new SequenceFeature("type", "desc", 22, 33,
1017             12.4f, "group"));
1018     seq1.addPDBId(new PDBEntry("1A70", "B", Type.PDB, "File"));
1019     seq1.addDBRef(new DBRefEntry("EMBL", "1.2", "AZ12345"));
1020
1021     SequenceI copy = new Sequence(seq1);
1022
1023     assertNull(copy.getDatasetSequence());
1024
1025     verifyCopiedSequence(seq1, copy);
1026
1027     // copy has a copy of the DBRefEntry
1028     // this is murky - DBrefs are only copied for dataset sequences
1029     // where the test for 'dataset sequence' is 'dataset is null'
1030     // but that doesn't distinguish it from an aligned sequence
1031     // which has not yet generated a dataset sequence
1032     // NB getDBRef looks inside dataset sequence if not null
1033     List<DBRefEntry> dbrefs = copy.getDBRefs();
1034     assertEquals(1, dbrefs.size());
1035     assertFalse(dbrefs.get(0) == seq1.getDBRefs().get(0));
1036     assertTrue(dbrefs.get(0).equals(seq1.getDBRefs().get(0)));
1037   }
1038
1039   @Test(groups = { "Functional" })
1040   public void testCopyConstructor_withDataset()
1041   {
1042     SequenceI seq1 = new Sequence("Seq1", "AB-C.D EF");
1043     seq1.createDatasetSequence();
1044     seq1.setDescription("description");
1045     seq1.addAlignmentAnnotation(new AlignmentAnnotation("label", "desc",
1046             1.3d));
1047     // JAL-2046 - what is the contract for using a derived sequence's
1048     // addSequenceFeature ?
1049     seq1.addSequenceFeature(new SequenceFeature("type", "desc", 22, 33,
1050             12.4f, "group"));
1051     seq1.addPDBId(new PDBEntry("1A70", "B", Type.PDB, "File"));
1052     // here we add DBRef to the dataset sequence:
1053     seq1.getDatasetSequence().addDBRef(
1054             new DBRefEntry("EMBL", "1.2", "AZ12345"));
1055
1056     SequenceI copy = new Sequence(seq1);
1057
1058     assertNotNull(copy.getDatasetSequence());
1059     assertSame(copy.getDatasetSequence(), seq1.getDatasetSequence());
1060
1061     verifyCopiedSequence(seq1, copy);
1062
1063     // getDBRef looks inside dataset sequence and this is shared,
1064     // so holds the same dbref objects
1065     List<DBRefEntry> dbrefs = copy.getDBRefs();
1066     assertEquals(1, dbrefs.size());
1067     assertSame(dbrefs.get(0), seq1.getDBRefs().get(0));
1068   }
1069
1070   /**
1071    * Helper to make assertions about a copied sequence
1072    *
1073    * @param seq1
1074    * @param copy
1075    */
1076   protected void verifyCopiedSequence(SequenceI seq1, SequenceI copy)
1077   {
1078     // verify basic properties:
1079     assertEquals(copy.getName(), seq1.getName());
1080     assertEquals(copy.getDescription(), seq1.getDescription());
1081     assertEquals(copy.getStart(), seq1.getStart());
1082     assertEquals(copy.getEnd(), seq1.getEnd());
1083     assertEquals(copy.getSequenceAsString(), seq1.getSequenceAsString());
1084
1085     // copy has a copy of the annotation:
1086     AlignmentAnnotation[] anns = copy.getAnnotation();
1087     assertEquals(1, anns.length);
1088     assertFalse(anns[0] == seq1.getAnnotation()[0]);
1089     assertEquals(anns[0].label, seq1.getAnnotation()[0].label);
1090     assertEquals(anns[0].description, seq1.getAnnotation()[0].description);
1091     assertEquals(anns[0].score, seq1.getAnnotation()[0].score);
1092
1093     // copy has a copy of the sequence feature:
1094     List<SequenceFeature> sfs = copy.getSequenceFeatures();
1095     assertEquals(1, sfs.size());
1096     if (seq1.getDatasetSequence() != null
1097             && copy.getDatasetSequence() == seq1.getDatasetSequence())
1098     {
1099       assertSame(sfs.get(0), seq1.getSequenceFeatures().get(0));
1100     }
1101     else
1102     {
1103       assertNotSame(sfs.get(0), seq1.getSequenceFeatures().get(0));
1104     }
1105     assertEquals(sfs.get(0), seq1.getSequenceFeatures().get(0));
1106
1107     // copy has a copy of the PDB entry
1108     Vector<PDBEntry> pdbs = copy.getAllPDBEntries();
1109     assertEquals(1, pdbs.size());
1110     assertFalse(pdbs.get(0) == seq1.getAllPDBEntries().get(0));
1111     assertTrue(pdbs.get(0).equals(seq1.getAllPDBEntries().get(0)));
1112   }
1113
1114   @Test(groups = "Functional")
1115   public void testGetCharAt()
1116   {
1117     SequenceI sq = new Sequence("", "abcde");
1118     assertEquals('a', sq.getCharAt(0));
1119     assertEquals('e', sq.getCharAt(4));
1120     assertEquals(' ', sq.getCharAt(5));
1121     assertEquals(' ', sq.getCharAt(-1));
1122   }
1123
1124   @Test(groups = { "Functional" })
1125   public void testAddSequenceFeatures()
1126   {
1127     SequenceI sq = new Sequence("", "abcde");
1128     // type may not be null
1129     assertFalse(sq.addSequenceFeature(new SequenceFeature(null, "desc", 4,
1130             8, 0f, null)));
1131     assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", 4,
1132             8, 0f, null)));
1133     // can't add a duplicate feature
1134     assertFalse(sq.addSequenceFeature(new SequenceFeature("Cath", "desc",
1135             4, 8, 0f, null)));
1136     // can add a different feature
1137     assertTrue(sq.addSequenceFeature(new SequenceFeature("Scop", "desc", 4,
1138             8, 0f, null))); // different type
1139     assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath",
1140             "description", 4, 8, 0f, null)));// different description
1141     assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", 3,
1142             8, 0f, null))); // different start position
1143     assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", 4,
1144             9, 0f, null))); // different end position
1145     assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", 4,
1146             8, 1f, null))); // different score
1147     assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", 4,
1148             8, Float.NaN, null))); // score NaN
1149     assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", 4,
1150             8, 0f, "Metal"))); // different group
1151     assertEquals(8, sq.getFeatures().getAllFeatures().size());
1152   }
1153
1154   /**
1155    * Tests for adding (or updating) dbrefs
1156    *
1157    * @see DBRefEntry#updateFrom(DBRefEntry)
1158    */
1159   @Test(groups = { "Functional" })
1160   public void testAddDBRef()
1161   {
1162     SequenceI sq = new Sequence("", "abcde");
1163     assertNull(sq.getDBRefs());
1164     DBRefEntry dbref = new DBRefEntry("Uniprot", "1", "P00340");
1165     sq.addDBRef(dbref);
1166     assertEquals(1, sq.getDBRefs().size());
1167     assertSame(dbref, sq.getDBRefs().get(0));
1168
1169     /*
1170      * change of version - new entry
1171      */
1172     DBRefEntry dbref2 = new DBRefEntry("Uniprot", "2", "P00340");
1173     sq.addDBRef(dbref2);
1174     assertEquals(2, sq.getDBRefs().size());
1175     assertSame(dbref, sq.getDBRefs().get(0));
1176     assertSame(dbref2, sq.getDBRefs().get(1));
1177
1178     /*
1179      * matches existing entry - not added
1180      */
1181     sq.addDBRef(new DBRefEntry("UNIPROT", "1", "p00340"));
1182     assertEquals(2, sq.getDBRefs().size());
1183
1184     /*
1185      * different source = new entry
1186      */
1187     DBRefEntry dbref3 = new DBRefEntry("UniRef", "1", "p00340");
1188     sq.addDBRef(dbref3);
1189     assertEquals(3, sq.getDBRefs().size());
1190     assertSame(dbref3, sq.getDBRefs().get(2));
1191
1192     /*
1193      * different ref = new entry
1194      */
1195     DBRefEntry dbref4 = new DBRefEntry("UniRef", "1", "p00341");
1196     sq.addDBRef(dbref4);
1197     assertEquals(4, sq.getDBRefs().size());
1198     assertSame(dbref4, sq.getDBRefs().get(3));
1199
1200     /*
1201      * matching ref with a mapping - map updated
1202      */
1203     DBRefEntry dbref5 = new DBRefEntry("UniRef", "1", "p00341");
1204     Mapping map = new Mapping(new MapList(new int[] { 1, 3 }, new int[] {
1205         1, 1 }, 3, 1));
1206     dbref5.setMap(map);
1207     sq.addDBRef(dbref5);
1208     assertEquals(4, sq.getDBRefs().size());
1209     assertSame(dbref4, sq.getDBRefs().get(3));
1210     assertSame(map, dbref4.getMap());
1211
1212     /*
1213      * 'real' version replaces "0" version
1214      */
1215     dbref2.setVersion("0");
1216     DBRefEntry dbref6 = new DBRefEntry(dbref2.getSource(), "3",
1217             dbref2.getAccessionId());
1218     sq.addDBRef(dbref6);
1219     assertEquals(4, sq.getDBRefs().size());
1220     assertSame(dbref2, sq.getDBRefs().get(1));
1221     assertEquals("3", dbref2.getVersion());
1222
1223     /*
1224      * 'real' version replaces "source:0" version
1225      */
1226     dbref3.setVersion("Uniprot:0");
1227     DBRefEntry dbref7 = new DBRefEntry(dbref3.getSource(), "3",
1228             dbref3.getAccessionId());
1229     sq.addDBRef(dbref7);
1230     assertEquals(4, sq.getDBRefs().size());
1231     assertSame(dbref3, sq.getDBRefs().get(2));
1232     assertEquals("3", dbref2.getVersion());
1233   }
1234
1235   @Test(groups = { "Functional" })
1236   public void testGetPrimaryDBRefs_peptide()
1237   {
1238     SequenceI sq = new Sequence("aseq", "ASDFKYLMQPRST", 10, 22);
1239
1240     // no dbrefs
1241     List<DBRefEntry> primaryDBRefs = sq.getPrimaryDBRefs();
1242     assertTrue(primaryDBRefs.isEmpty());
1243
1244     // empty dbrefs
1245         sq.setDBRefs(null);
1246     primaryDBRefs = sq.getPrimaryDBRefs();
1247     assertTrue(primaryDBRefs.isEmpty());
1248
1249     // primary - uniprot
1250     DBRefEntry upentry1 = new DBRefEntry("UNIPROT", "0", "Q04760");
1251     sq.addDBRef(upentry1);
1252
1253     // primary - uniprot with congruent map
1254     DBRefEntry upentry2 = new DBRefEntry("UNIPROT", "0", "Q04762");
1255     upentry2.setMap(new Mapping(null, new MapList(new int[] { 10, 22 },
1256             new int[] { 10, 22 }, 1, 1)));
1257     sq.addDBRef(upentry2);
1258
1259     // primary - uniprot with map of enclosing sequence
1260     DBRefEntry upentry3 = new DBRefEntry("UNIPROT", "0", "Q04763");
1261     upentry3.setMap(new Mapping(null, new MapList(new int[] { 8, 24 },
1262             new int[] { 8, 24 }, 1, 1)));
1263     sq.addDBRef(upentry3);
1264
1265     // not primary - uniprot with map of sub-sequence (5')
1266     DBRefEntry upentry4 = new DBRefEntry("UNIPROT", "0", "Q04764");
1267     upentry4.setMap(new Mapping(null, new MapList(new int[] { 10, 18 },
1268             new int[] { 10, 18 }, 1, 1)));
1269     sq.addDBRef(upentry4);
1270
1271     // not primary - uniprot with map that overlaps 3'
1272     DBRefEntry upentry5 = new DBRefEntry("UNIPROT", "0", "Q04765");
1273     upentry5.setMap(new Mapping(null, new MapList(new int[] { 12, 22 },
1274             new int[] { 12, 22 }, 1, 1)));
1275     sq.addDBRef(upentry5);
1276
1277     // not primary - uniprot with map to different coordinates frame
1278     DBRefEntry upentry6 = new DBRefEntry("UNIPROT", "0", "Q04766");
1279     upentry6.setMap(new Mapping(null, new MapList(new int[] { 12, 18 },
1280             new int[] { 112, 118 }, 1, 1)));
1281     sq.addDBRef(upentry6);
1282
1283     // not primary - dbref to 'non-core' database
1284     DBRefEntry upentry7 = new DBRefEntry("Pfam", "0", "PF00903");
1285     sq.addDBRef(upentry7);
1286
1287     // primary - type is PDB
1288     DBRefEntry pdbentry = new DBRefEntry("PDB", "0", "1qip");
1289     sq.addDBRef(pdbentry);
1290
1291     // not primary - PDBEntry has no file
1292     sq.addDBRef(new DBRefEntry("PDB", "0", "1AAA"));
1293
1294     // not primary - no PDBEntry
1295     sq.addDBRef(new DBRefEntry("PDB", "0", "1DDD"));
1296
1297     // add corroborating PDB entry for primary DBref -
1298     // needs to have a file as well as matching ID
1299     // note PDB ID is not treated as case sensitive
1300     sq.addPDBId(new PDBEntry("1QIP", null, Type.PDB, new File("/blah")
1301             .toString()));
1302
1303     // not valid DBRef - no file..
1304     sq.addPDBId(new PDBEntry("1AAA", null, null, null));
1305
1306     primaryDBRefs = sq.getPrimaryDBRefs();
1307     assertEquals(4, primaryDBRefs.size());
1308     assertTrue("Couldn't find simple primary reference (UNIPROT)",
1309             primaryDBRefs.contains(upentry1));
1310     assertTrue("Couldn't find mapped primary reference (UNIPROT)",
1311             primaryDBRefs.contains(upentry2));
1312     assertTrue("Couldn't find mapped context reference (UNIPROT)",
1313             primaryDBRefs.contains(upentry3));
1314     assertTrue("Couldn't find expected PDB primary reference",
1315             primaryDBRefs.contains(pdbentry));
1316   }
1317
1318   @Test(groups = { "Functional" })
1319   public void testGetPrimaryDBRefs_nucleotide()
1320   {
1321     SequenceI sq = new Sequence("aseq", "TGATCACTCGACTAGCATCAGCATA", 10, 34);
1322
1323     // primary - Ensembl
1324     DBRefEntry dbr1 = new DBRefEntry("ENSEMBL", "0", "ENSG1234");
1325     sq.addDBRef(dbr1);
1326
1327     // not primary - Ensembl 'transcript' mapping of sub-sequence
1328     DBRefEntry dbr2 = new DBRefEntry("ENSEMBL", "0", "ENST1234");
1329     dbr2.setMap(new Mapping(null, new MapList(new int[] { 15, 25 },
1330             new int[] { 1, 11 }, 1, 1)));
1331     sq.addDBRef(dbr2);
1332
1333     // primary - EMBL with congruent map
1334     DBRefEntry dbr3 = new DBRefEntry("EMBL", "0", "J1234");
1335     dbr3.setMap(new Mapping(null, new MapList(new int[] { 10, 34 },
1336             new int[] { 10, 34 }, 1, 1)));
1337     sq.addDBRef(dbr3);
1338
1339     // not primary - to non-core database
1340     DBRefEntry dbr4 = new DBRefEntry("CCDS", "0", "J1234");
1341     sq.addDBRef(dbr4);
1342
1343     // not primary - to protein
1344     DBRefEntry dbr5 = new DBRefEntry("UNIPROT", "0", "Q87654");
1345     sq.addDBRef(dbr5);
1346
1347     List<DBRefEntry> primaryDBRefs = sq.getPrimaryDBRefs();
1348     assertEquals(2, primaryDBRefs.size());
1349     assertTrue(primaryDBRefs.contains(dbr1));
1350     assertTrue(primaryDBRefs.contains(dbr3));
1351   }
1352
1353   /**
1354    * Test the method that updates the list of PDBEntry from any new DBRefEntry
1355    * for PDB
1356    */
1357   @Test(groups = { "Functional" })
1358   public void testUpdatePDBIds()
1359   {
1360     PDBEntry pdbe1 = new PDBEntry("3A6S", null, null, null);
1361     seq.addPDBId(pdbe1);
1362     seq.addDBRef(new DBRefEntry("Ensembl", "8", "ENST1234"));
1363     seq.addDBRef(new DBRefEntry("PDB", "0", "1A70"));
1364     seq.addDBRef(new DBRefEntry("PDB", "0", "4BQGa"));
1365     seq.addDBRef(new DBRefEntry("PDB", "0", "3a6sB"));
1366     // 7 is not a valid chain code:
1367     seq.addDBRef(new DBRefEntry("PDB", "0", "2GIS7"));
1368
1369     seq.updatePDBIds();
1370     List<PDBEntry> pdbIds = seq.getAllPDBEntries();
1371     assertEquals(4, pdbIds.size());
1372     assertSame(pdbe1, pdbIds.get(0));
1373     // chain code got added to 3A6S:
1374     assertEquals("B", pdbe1.getChainCode());
1375     assertEquals("1A70", pdbIds.get(1).getId());
1376     // 4BQGA is parsed into id + chain
1377     assertEquals("4BQG", pdbIds.get(2).getId());
1378     assertEquals("a", pdbIds.get(2).getChainCode());
1379     assertEquals("2GIS7", pdbIds.get(3).getId());
1380     assertNull(pdbIds.get(3).getChainCode());
1381   }
1382
1383   /**
1384    * Test the method that either adds a pdbid or updates an existing one
1385    */
1386   @Test(groups = { "Functional" })
1387   public void testAddPDBId()
1388   {
1389     PDBEntry pdbe = new PDBEntry("3A6S", null, null, null);
1390     seq.addPDBId(pdbe);
1391     assertEquals(1, seq.getAllPDBEntries().size());
1392     assertSame(pdbe, seq.getPDBEntry("3A6S"));
1393     assertSame(pdbe, seq.getPDBEntry("3a6s")); // case-insensitive
1394
1395     // add the same entry
1396     seq.addPDBId(pdbe);
1397     assertEquals(1, seq.getAllPDBEntries().size());
1398     assertSame(pdbe, seq.getPDBEntry("3A6S"));
1399
1400     // add an identical entry
1401     seq.addPDBId(new PDBEntry("3A6S", null, null, null));
1402     assertEquals(1, seq.getAllPDBEntries().size());
1403     assertSame(pdbe, seq.getPDBEntry("3A6S"));
1404
1405     // add a different entry
1406     PDBEntry pdbe2 = new PDBEntry("1A70", null, null, null);
1407     seq.addPDBId(pdbe2);
1408     assertEquals(2, seq.getAllPDBEntries().size());
1409     assertSame(pdbe, seq.getAllPDBEntries().get(0));
1410     assertSame(pdbe2, seq.getAllPDBEntries().get(1));
1411
1412     // update pdbe with chain code, file, type
1413     PDBEntry pdbe3 = new PDBEntry("3a6s", "A", Type.PDB, "filepath");
1414     seq.addPDBId(pdbe3);
1415     assertEquals(2, seq.getAllPDBEntries().size());
1416     assertSame(pdbe, seq.getAllPDBEntries().get(0)); // updated in situ
1417     assertEquals("3A6S", pdbe.getId()); // unchanged
1418     assertEquals("A", pdbe.getChainCode()); // updated
1419     assertEquals(Type.PDB.toString(), pdbe.getType()); // updated
1420     assertEquals("filepath", pdbe.getFile()); // updated
1421     assertSame(pdbe2, seq.getAllPDBEntries().get(1));
1422
1423     // add with a different file path
1424     PDBEntry pdbe4 = new PDBEntry("3a6s", "A", Type.PDB, "filepath2");
1425     seq.addPDBId(pdbe4);
1426     assertEquals(3, seq.getAllPDBEntries().size());
1427     assertSame(pdbe4, seq.getAllPDBEntries().get(2));
1428
1429     // add with a different chain code
1430     PDBEntry pdbe5 = new PDBEntry("3a6s", "B", Type.PDB, "filepath");
1431     seq.addPDBId(pdbe5);
1432     assertEquals(4, seq.getAllPDBEntries().size());
1433     assertSame(pdbe5, seq.getAllPDBEntries().get(3));
1434   }
1435
1436   @Test(
1437     groups = { "Functional" },
1438     expectedExceptions = { IllegalArgumentException.class })
1439   public void testSetDatasetSequence_toSelf()
1440   {
1441     seq.setDatasetSequence(seq);
1442   }
1443
1444   @Test(
1445     groups = { "Functional" },
1446     expectedExceptions = { IllegalArgumentException.class })
1447   public void testSetDatasetSequence_cascading()
1448   {
1449     SequenceI seq2 = new Sequence("Seq2", "xyz");
1450     seq2.createDatasetSequence();
1451     seq.setDatasetSequence(seq2);
1452   }
1453
1454   @Test(groups = { "Functional" })
1455   public void testFindFeatures()
1456   {
1457     SequenceI sq = new Sequence("test/8-16", "-ABC--DEF--GHI--");
1458     sq.createDatasetSequence();
1459
1460     assertTrue(sq.findFeatures(1, 99).isEmpty());
1461
1462     // add non-positional feature
1463     SequenceFeature sf0 = new SequenceFeature("Cath", "desc", 0, 0, 2f,
1464             null);
1465     sq.addSequenceFeature(sf0);
1466     // add feature on BCD
1467     SequenceFeature sfBCD = new SequenceFeature("Cath", "desc", 9, 11, 2f,
1468             null);
1469     sq.addSequenceFeature(sfBCD);
1470     // add feature on DE
1471     SequenceFeature sfDE = new SequenceFeature("Cath", "desc", 11, 12, 2f,
1472             null);
1473     sq.addSequenceFeature(sfDE);
1474     // add contact feature at [B, H]
1475     SequenceFeature sfContactBH = new SequenceFeature("Disulphide bond",
1476             "desc", 9, 15, 2f, null);
1477     sq.addSequenceFeature(sfContactBH);
1478     // add contact feature at [F, G]
1479     SequenceFeature sfContactFG = new SequenceFeature("Disulfide Bond",
1480             "desc", 13, 14, 2f, null);
1481     sq.addSequenceFeature(sfContactFG);
1482     // add single position feature at [I]
1483     SequenceFeature sfI = new SequenceFeature("Disulfide Bond",
1484             "desc", 16, 16, null);
1485     sq.addSequenceFeature(sfI);
1486
1487     // no features in columns 1-2 (-A)
1488     List<SequenceFeature> found = sq.findFeatures(1, 2);
1489     assertTrue(found.isEmpty());
1490
1491     // columns 1-6 (-ABC--) includes BCD and B/H feature but not DE
1492     found = sq.findFeatures(1, 6);
1493     assertEquals(2, found.size());
1494     assertTrue(found.contains(sfBCD));
1495     assertTrue(found.contains(sfContactBH));
1496
1497     // columns 5-6 (--) includes (enclosing) BCD but not (contact) B/H feature
1498     found = sq.findFeatures(5, 6);
1499     assertEquals(1, found.size());
1500     assertTrue(found.contains(sfBCD));
1501
1502     // columns 7-10 (DEF-) includes BCD, DE, F/G but not B/H feature
1503     found = sq.findFeatures(7, 10);
1504     assertEquals(3, found.size());
1505     assertTrue(found.contains(sfBCD));
1506     assertTrue(found.contains(sfDE));
1507     assertTrue(found.contains(sfContactFG));
1508
1509     // columns 10-11 (--) should find nothing
1510     found = sq.findFeatures(10, 11);
1511     assertEquals(0, found.size());
1512
1513     // columns 14-14 (I) should find variant feature
1514     found = sq.findFeatures(14, 14);
1515     assertEquals(1, found.size());
1516     assertTrue(found.contains(sfI));
1517   }
1518
1519   @Test(groups = { "Functional" })
1520   public void testFindIndex_withCursor()
1521   {
1522     Sequence sq = new Sequence("test/8-13", "-A--BCD-EF--");
1523     final int tok = (int) PA.getValue(sq, "changeCount");
1524     assertEquals(1, tok);
1525
1526     // find F given A, check cursor is now at the found position
1527     assertEquals(10, sq.findIndex(13, new SequenceCursor(sq, 8, 2, tok)));
1528     SequenceCursor cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1529     assertEquals(13, cursor.residuePosition);
1530     assertEquals(10, cursor.columnPosition);
1531
1532     // find A given F
1533     assertEquals(2, sq.findIndex(8, new SequenceCursor(sq, 13, 10, tok)));
1534     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1535     assertEquals(8, cursor.residuePosition);
1536     assertEquals(2, cursor.columnPosition);
1537
1538     // find C given C (no cursor update is done for this case)
1539     assertEquals(6, sq.findIndex(10, new SequenceCursor(sq, 10, 6, tok)));
1540     SequenceCursor cursor2 = (SequenceCursor) PA.getValue(sq, "cursor");
1541     assertSame(cursor2, cursor);
1542
1543     /*
1544      * sequence 'end' beyond end of sequence returns length of sequence
1545      *  (for compatibility with pre-cursor code)
1546      *  - also verify the cursor is left in a valid state
1547      */
1548     sq = new Sequence("test/8-99", "-A--B-C-D-E-F--"); // trailing gap case
1549     assertEquals(7, sq.findIndex(10)); // establishes a cursor
1550     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1551     assertEquals(10, cursor.residuePosition);
1552     assertEquals(7, cursor.columnPosition);
1553     assertEquals(sq.getLength(), sq.findIndex(65));
1554     cursor2 = (SequenceCursor) PA.getValue(sq, "cursor");
1555     assertSame(cursor, cursor2); // not updated for this case!
1556
1557     sq = new Sequence("test/8-99", "-A--B-C-D-E-F"); // trailing residue case
1558     sq.findIndex(10); // establishes a cursor
1559     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1560     assertEquals(sq.getLength(), sq.findIndex(65));
1561     cursor2 = (SequenceCursor) PA.getValue(sq, "cursor");
1562     assertSame(cursor, cursor2); // not updated for this case!
1563
1564     /*
1565      * residue after sequence 'start' but before first residue should return
1566      * zero (for compatibility with pre-cursor code)
1567      */
1568     sq = new Sequence("test/8-15", "-A-B-C-"); // leading gap case
1569     sq.findIndex(10); // establishes a cursor
1570     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1571     assertEquals(0, sq.findIndex(3));
1572     cursor2 = (SequenceCursor) PA.getValue(sq, "cursor");
1573     assertSame(cursor, cursor2); // not updated for this case!
1574
1575     sq = new Sequence("test/8-15", "A-B-C-"); // leading residue case
1576     sq.findIndex(10); // establishes a cursor
1577     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1578     assertEquals(0, sq.findIndex(2));
1579     cursor2 = (SequenceCursor) PA.getValue(sq, "cursor");
1580     assertSame(cursor, cursor2); // not updated for this case!
1581   }
1582
1583   @Test(groups = { "Functional" })
1584   public void testFindPosition_withCursor()
1585   {
1586     Sequence sq = new Sequence("test/8-13", "-A--BCD-EF--");
1587     final int tok = (int) PA.getValue(sq, "changeCount");
1588     assertEquals(1, tok);
1589
1590     // find F pos given A - lastCol gets set in cursor
1591     assertEquals(13,
1592             sq.findPosition(10, new SequenceCursor(sq, 8, 2, tok)));
1593     assertEquals("test:Pos13:Col10:startCol0:endCol10:tok1",
1594             PA.getValue(sq, "cursor").toString());
1595
1596     // find A pos given F - first residue column is saved in cursor
1597     assertEquals(8,
1598             sq.findPosition(2, new SequenceCursor(sq, 13, 10, tok)));
1599     assertEquals("test:Pos8:Col2:startCol2:endCol10:tok1",
1600             PA.getValue(sq, "cursor").toString());
1601
1602     // find C pos given C (neither startCol nor endCol is set)
1603     assertEquals(10,
1604             sq.findPosition(6, new SequenceCursor(sq, 10, 6, tok)));
1605     assertEquals("test:Pos10:Col6:startCol0:endCol0:tok1",
1606             PA.getValue(sq, "cursor").toString());
1607
1608     // now the grey area - what residue position for a gapped column? JAL-2562
1609
1610     // find 'residue' for column 3 given cursor for D (so working left)
1611     // returns B9; cursor is updated to [B 5]
1612     assertEquals(9, sq.findPosition(3, new SequenceCursor(sq, 11, 7, tok)));
1613     assertEquals("test:Pos9:Col5:startCol0:endCol0:tok1",
1614             PA.getValue(sq, "cursor").toString());
1615
1616     // find 'residue' for column 8 given cursor for D (so working right)
1617     // returns E12; cursor is updated to [D 7]
1618     assertEquals(12,
1619             sq.findPosition(8, new SequenceCursor(sq, 11, 7, tok)));
1620     assertEquals("test:Pos11:Col7:startCol0:endCol0:tok1",
1621             PA.getValue(sq, "cursor").toString());
1622
1623     // find 'residue' for column 12 given cursor for B
1624     // returns 1 more than last residue position; cursor is updated to [F 10]
1625     // lastCol position is saved in cursor
1626     assertEquals(14,
1627             sq.findPosition(12, new SequenceCursor(sq, 9, 5, tok)));
1628     assertEquals("test:Pos13:Col10:startCol0:endCol10:tok1",
1629             PA.getValue(sq, "cursor").toString());
1630
1631     /*
1632      * findPosition for column beyond length of sequence
1633      * returns 1 more than the last residue position
1634      * cursor is set to last real residue position [F 10]
1635      */
1636     assertEquals(14,
1637             sq.findPosition(99, new SequenceCursor(sq, 8, 2, tok)));
1638     assertEquals("test:Pos13:Col10:startCol0:endCol10:tok1",
1639             PA.getValue(sq, "cursor").toString());
1640
1641     /*
1642      * and the case without a trailing gap
1643      */
1644     sq = new Sequence("test/8-13", "-A--BCD-EF");
1645     // first find C from A
1646     assertEquals(10, sq.findPosition(6, new SequenceCursor(sq, 8, 2, tok)));
1647     SequenceCursor cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1648     assertEquals("test:Pos10:Col6:startCol0:endCol0:tok1",
1649             cursor.toString());
1650     // now 'find' 99 from C
1651     // cursor is set to [F 10] and saved lastCol
1652     assertEquals(14, sq.findPosition(99, cursor));
1653     assertEquals("test:Pos13:Col10:startCol0:endCol10:tok1",
1654             PA.getValue(sq, "cursor").toString());
1655   }
1656
1657   @Test
1658   public void testIsValidCursor()
1659   {
1660     Sequence sq = new Sequence("Seq", "ABC--DE-F", 8, 13);
1661     assertFalse(sq.isValidCursor(null));
1662
1663     /*
1664      * cursor is valid if it has valid sequence ref and changeCount token
1665      * and positions within the range of the sequence
1666      */
1667     int changeCount = (int) PA.getValue(sq, "changeCount");
1668     SequenceCursor cursor = new SequenceCursor(sq, 13, 1, changeCount);
1669     assertTrue(sq.isValidCursor(cursor));
1670
1671     /*
1672      * column position outside [0 - length] is rejected
1673      */
1674     cursor = new SequenceCursor(sq, 13, -1, changeCount);
1675     assertFalse(sq.isValidCursor(cursor));
1676     cursor = new SequenceCursor(sq, 13, 10, changeCount);
1677     assertFalse(sq.isValidCursor(cursor));
1678     cursor = new SequenceCursor(sq, 7, 8, changeCount);
1679     assertFalse(sq.isValidCursor(cursor));
1680     cursor = new SequenceCursor(sq, 14, 2, changeCount);
1681     assertFalse(sq.isValidCursor(cursor));
1682
1683     /*
1684      * wrong sequence is rejected
1685      */
1686     cursor = new SequenceCursor(null, 13, 1, changeCount);
1687     assertFalse(sq.isValidCursor(cursor));
1688     cursor = new SequenceCursor(new Sequence("Seq", "abc"), 13, 1,
1689             changeCount);
1690     assertFalse(sq.isValidCursor(cursor));
1691
1692     /*
1693      * wrong token value is rejected
1694      */
1695     cursor = new SequenceCursor(sq, 13, 1, changeCount + 1);
1696     assertFalse(sq.isValidCursor(cursor));
1697     cursor = new SequenceCursor(sq, 13, 1, changeCount - 1);
1698     assertFalse(sq.isValidCursor(cursor));
1699   }
1700
1701   @Test(groups = { "Functional" })
1702   public void testFindPosition_withCursorAndEdits()
1703   {
1704     Sequence sq = new Sequence("test/8-13", "-A--BCD-EF--");
1705
1706     // find F pos given A
1707     assertEquals(13, sq.findPosition(10, new SequenceCursor(sq, 8, 2, 0)));
1708     int token = (int) PA.getValue(sq, "changeCount"); // 0
1709     SequenceCursor cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1710     assertEquals(new SequenceCursor(sq, 13, 10, token), cursor);
1711
1712     /*
1713      * setSequence should invalidate the cursor cached by the sequence
1714      */
1715     sq.setSequence("-A-BCD-EF---"); // one gap removed
1716     assertEquals(8, sq.getStart()); // sanity check
1717     assertEquals(11, sq.findPosition(5)); // D11
1718     // cursor should now be at [D 6]
1719     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1720     assertEquals(new SequenceCursor(sq, 11, 6, ++token), cursor);
1721     assertEquals(0, cursor.lastColumnPosition); // not yet found
1722     assertEquals(13, sq.findPosition(8)); // E13
1723     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1724     assertEquals(9, cursor.lastColumnPosition); // found
1725
1726     /*
1727      * deleteChars should invalidate the cached cursor
1728      */
1729     sq.deleteChars(2, 5); // delete -BC
1730     assertEquals("-AD-EF---", sq.getSequenceAsString());
1731     assertEquals(8, sq.getStart()); // sanity check
1732     assertEquals(10, sq.findPosition(4)); // E10
1733     // cursor should now be at [E 5]
1734     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1735     assertEquals(new SequenceCursor(sq, 10, 5, ++token), cursor);
1736
1737     /*
1738      * Edit to insert gaps should invalidate the cached cursor
1739      * insert 2 gaps at column[3] to make -AD---EF---
1740      */
1741     SequenceI[] seqs = new SequenceI[] { sq };
1742     AlignmentI al = new Alignment(seqs);
1743     new EditCommand().appendEdit(Action.INSERT_GAP, seqs, 3, 2, al, true);
1744     assertEquals("-AD---EF---", sq.getSequenceAsString());
1745     assertEquals(10, sq.findPosition(4)); // E10
1746     // cursor should now be at [D 3]
1747     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1748     assertEquals(new SequenceCursor(sq, 9, 3, ++token), cursor);
1749
1750     /*
1751      * insertCharAt should invalidate the cached cursor
1752      * insert CC at column[4] to make -AD-CC--EF---
1753      */
1754     sq.insertCharAt(4, 2, 'C');
1755     assertEquals("-AD-CC--EF---", sq.getSequenceAsString());
1756     assertEquals(13, sq.findPosition(9)); // F13
1757     // cursor should now be at [F 10]
1758     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
1759     assertEquals(new SequenceCursor(sq, 13, 10, ++token), cursor);
1760
1761     /*
1762      * changing sequence start should invalidate cursor
1763      */
1764     sq = new Sequence("test/8-13", "-A--BCD-EF--");
1765     assertEquals(8, sq.getStart());
1766     assertEquals(9, sq.findPosition(4)); // B(9)
1767     sq.setStart(7);
1768     assertEquals(8, sq.findPosition(4)); // is now B(8)
1769     sq.setStart(10);
1770     assertEquals(11, sq.findPosition(4)); // is now B(11)
1771   }
1772
1773   @Test(groups = { "Functional" })
1774   public void testGetSequence()
1775   {
1776     String seqstring = "-A--BCD-EF--";
1777     Sequence sq = new Sequence("test/8-13", seqstring);
1778     sq.createDatasetSequence();
1779     assertTrue(Arrays.equals(sq.getSequence(), seqstring.toCharArray()));
1780     assertTrue(Arrays.equals(sq.getDatasetSequence().getSequence(),
1781             "ABCDEF".toCharArray()));
1782
1783     // verify a copy of the sequence array is returned
1784     char[] theSeq = (char[]) PA.getValue(sq, "sequence");
1785     assertNotSame(theSeq, sq.getSequence());
1786     theSeq = (char[]) PA.getValue(sq.getDatasetSequence(), "sequence");
1787     assertNotSame(theSeq, sq.getDatasetSequence().getSequence());
1788   }
1789
1790   @Test(groups = { "Functional" })
1791   public void testReplace()
1792   {
1793     String seqstring = "-A--BCD-EF--";
1794     SequenceI sq = new Sequence("test/8-13", seqstring);
1795     // changeCount is incremented for setStart
1796     assertEquals(1, PA.getValue(sq, "changeCount"));
1797
1798     assertEquals(0, sq.replace('A', 'A')); // same char
1799     assertEquals(seqstring, sq.getSequenceAsString());
1800     assertEquals(1, PA.getValue(sq, "changeCount"));
1801
1802     assertEquals(0, sq.replace('X', 'Y')); // not there
1803     assertEquals(seqstring, sq.getSequenceAsString());
1804     assertEquals(1, PA.getValue(sq, "changeCount"));
1805
1806     assertEquals(1, sq.replace('A', 'K'));
1807     assertEquals("-K--BCD-EF--", sq.getSequenceAsString());
1808     assertEquals(2, PA.getValue(sq, "changeCount"));
1809
1810     assertEquals(6, sq.replace('-', '.'));
1811     assertEquals(".K..BCD.EF..", sq.getSequenceAsString());
1812     assertEquals(3, PA.getValue(sq, "changeCount"));
1813   }
1814
1815   @Test(groups = { "Functional" })
1816   public void testGapBitset()
1817   {
1818     SequenceI sq = new Sequence("test/8-13", "-ABC---DE-F--");
1819     BitSet bs = sq.gapBitset();
1820     BitSet expected = new BitSet();
1821     expected.set(0);
1822     expected.set(4, 7);
1823     expected.set(9);
1824     expected.set(11, 13);
1825
1826     assertTrue(bs.equals(expected));
1827
1828   }
1829
1830   public void testFindFeatures_largeEndPos()
1831   {
1832     /*
1833      * imitate a PDB sequence where end is larger than end position
1834      */
1835     SequenceI sq = new Sequence("test", "-ABC--DEF--", 1, 20);
1836     sq.createDatasetSequence();
1837
1838     assertTrue(sq.findFeatures(1, 9).isEmpty());
1839     // should be no array bounds exception - JAL-2772
1840     assertTrue(sq.findFeatures(1, 15).isEmpty());
1841
1842     // add feature on BCD
1843     SequenceFeature sfBCD = new SequenceFeature("Cath", "desc", 2, 4, 2f,
1844             null);
1845     sq.addSequenceFeature(sfBCD);
1846
1847     // no features in columns 1-2 (-A)
1848     List<SequenceFeature> found = sq.findFeatures(1, 2);
1849     assertTrue(found.isEmpty());
1850
1851     // columns 1-6 (-ABC--) includes BCD
1852     found = sq.findFeatures(1, 6);
1853     assertEquals(1, found.size());
1854     assertTrue(found.contains(sfBCD));
1855
1856     // columns 10-11 (--) should find nothing
1857     found = sq.findFeatures(10, 11);
1858     assertEquals(0, found.size());
1859   }
1860
1861   @Test(groups = { "Functional" })
1862   public void testSetName()
1863   {
1864     SequenceI sq = new Sequence("test", "-ABC---DE-F--");
1865     assertEquals("test", sq.getName());
1866     assertEquals(1, sq.getStart());
1867     assertEquals(6, sq.getEnd());
1868
1869     sq.setName("testing");
1870     assertEquals("testing", sq.getName());
1871
1872     sq.setName("test/8-10");
1873     assertEquals("test", sq.getName());
1874     assertEquals(8, sq.getStart());
1875     assertEquals(13, sq.getEnd()); // note end is recomputed
1876
1877     sq.setName("testing/7-99");
1878     assertEquals("testing", sq.getName());
1879     assertEquals(7, sq.getStart());
1880     assertEquals(99, sq.getEnd()); // end may be beyond physical end
1881
1882     sq.setName("/2-3");
1883     assertEquals("", sq.getName());
1884     assertEquals(2, sq.getStart());
1885     assertEquals(7, sq.getEnd());
1886
1887     sq.setName("test/"); // invalid
1888     assertEquals("test/", sq.getName());
1889     assertEquals(2, sq.getStart());
1890     assertEquals(7, sq.getEnd());
1891
1892     sq.setName("test/6-13/7-99");
1893     assertEquals("test/6-13", sq.getName());
1894     assertEquals(7, sq.getStart());
1895     assertEquals(99, sq.getEnd());
1896
1897     sq.setName("test/0-5"); // 0 is invalid - ignored
1898     assertEquals("test/0-5", sq.getName());
1899     assertEquals(7, sq.getStart());
1900     assertEquals(99, sq.getEnd());
1901
1902     sq.setName("test/a-5"); // a is invalid - ignored
1903     assertEquals("test/a-5", sq.getName());
1904     assertEquals(7, sq.getStart());
1905     assertEquals(99, sq.getEnd());
1906
1907     sq.setName("test/6-5"); // start > end is invalid - ignored
1908     assertEquals("test/6-5", sq.getName());
1909     assertEquals(7, sq.getStart());
1910     assertEquals(99, sq.getEnd());
1911
1912     sq.setName("test/5"); // invalid - ignored
1913     assertEquals("test/5", sq.getName());
1914     assertEquals(7, sq.getStart());
1915     assertEquals(99, sq.getEnd());
1916
1917     sq.setName("test/-5"); // invalid - ignored
1918     assertEquals("test/-5", sq.getName());
1919     assertEquals(7, sq.getStart());
1920     assertEquals(99, sq.getEnd());
1921
1922     sq.setName("test/5-"); // invalid - ignored
1923     assertEquals("test/5-", sq.getName());
1924     assertEquals(7, sq.getStart());
1925     assertEquals(99, sq.getEnd());
1926
1927     sq.setName("test/5-6-7"); // invalid - ignored
1928     assertEquals("test/5-6-7", sq.getName());
1929     assertEquals(7, sq.getStart());
1930     assertEquals(99, sq.getEnd());
1931
1932     sq.setName(null); // invalid, gets converted to space
1933     assertEquals("", sq.getName());
1934     assertEquals(7, sq.getStart());
1935     assertEquals(99, sq.getEnd());
1936   }
1937
1938   @Test(groups = { "Functional" })
1939   public void testCheckValidRange()
1940   {
1941     Sequence sq = new Sequence("test/7-12", "-ABC---DE-F--");
1942     assertEquals(7, sq.getStart());
1943     assertEquals(12, sq.getEnd());
1944
1945     /*
1946      * checkValidRange ensures end is at least the last residue position
1947      */
1948     PA.setValue(sq, "end", 2);
1949     sq.checkValidRange();
1950     assertEquals(12, sq.getEnd());
1951
1952     /*
1953      * end may be beyond the last residue position
1954      */
1955     PA.setValue(sq, "end", 22);
1956     sq.checkValidRange();
1957     assertEquals(22, sq.getEnd());
1958   }
1959
1960   @Test(groups = { "Functional" })
1961   public void testDeleteChars_withGaps()
1962   {
1963     /*
1964      * delete gaps only
1965      */
1966     SequenceI sq = new Sequence("test/8-10", "A-B-C");
1967     sq.createDatasetSequence();
1968     assertEquals("ABC", sq.getDatasetSequence().getSequenceAsString());
1969     sq.deleteChars(1, 2); // delete first gap
1970     assertEquals("AB-C", sq.getSequenceAsString());
1971     assertEquals(8, sq.getStart());
1972     assertEquals(10, sq.getEnd());
1973     assertEquals("ABC", sq.getDatasetSequence().getSequenceAsString());
1974
1975     /*
1976      * delete gaps and residues at start (no new dataset sequence)
1977      */
1978     sq = new Sequence("test/8-10", "A-B-C");
1979     sq.createDatasetSequence();
1980     sq.deleteChars(0, 3); // delete A-B
1981     assertEquals("-C", sq.getSequenceAsString());
1982     assertEquals(10, sq.getStart());
1983     assertEquals(10, sq.getEnd());
1984     assertEquals("ABC", sq.getDatasetSequence().getSequenceAsString());
1985
1986     /*
1987      * delete gaps and residues at end (no new dataset sequence)
1988      */
1989     sq = new Sequence("test/8-10", "A-B-C");
1990     sq.createDatasetSequence();
1991     sq.deleteChars(2, 5); // delete B-C
1992     assertEquals("A-", sq.getSequenceAsString());
1993     assertEquals(8, sq.getStart());
1994     assertEquals(8, sq.getEnd());
1995     assertEquals("ABC", sq.getDatasetSequence().getSequenceAsString());
1996
1997     /*
1998      * delete gaps and residues internally (new dataset sequence)
1999      * first delete from gap to residue
2000      */
2001     sq = new Sequence("test/8-10", "A-B-C");
2002     sq.createDatasetSequence();
2003     sq.deleteChars(1, 3); // delete -B
2004     assertEquals("A-C", sq.getSequenceAsString());
2005     assertEquals(8, sq.getStart());
2006     assertEquals(9, sq.getEnd());
2007     assertEquals("AC", sq.getDatasetSequence().getSequenceAsString());
2008     assertEquals(8, sq.getDatasetSequence().getStart());
2009     assertEquals(9, sq.getDatasetSequence().getEnd());
2010
2011     /*
2012      * internal delete from gap to gap
2013      */
2014     sq = new Sequence("test/8-10", "A-B-C");
2015     sq.createDatasetSequence();
2016     sq.deleteChars(1, 4); // delete -B-
2017     assertEquals("AC", sq.getSequenceAsString());
2018     assertEquals(8, sq.getStart());
2019     assertEquals(9, sq.getEnd());
2020     assertEquals("AC", sq.getDatasetSequence().getSequenceAsString());
2021     assertEquals(8, sq.getDatasetSequence().getStart());
2022     assertEquals(9, sq.getDatasetSequence().getEnd());
2023
2024     /*
2025      * internal delete from residue to residue
2026      */
2027     sq = new Sequence("test/8-10", "A-B-C");
2028     sq.createDatasetSequence();
2029     sq.deleteChars(2, 3); // delete B
2030     assertEquals("A--C", sq.getSequenceAsString());
2031     assertEquals(8, sq.getStart());
2032     assertEquals(9, sq.getEnd());
2033     assertEquals("AC", sq.getDatasetSequence().getSequenceAsString());
2034     assertEquals(8, sq.getDatasetSequence().getStart());
2035     assertEquals(9, sq.getDatasetSequence().getEnd());
2036   }
2037
2038   /**
2039    * Test the code used to locate the reference sequence ruler origin
2040    */
2041   @Test(groups = { "Functional" })
2042   public void testLocateVisibleStartofSequence()
2043   {
2044     // create random alignment
2045     AlignmentGenerator gen = new AlignmentGenerator(false);
2046     AlignmentI al = gen.generate(50, 20, 123, 5, 5);
2047
2048     HiddenColumns cs = al.getHiddenColumns();
2049     ColumnSelection colsel = new ColumnSelection();
2050
2051     SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
2052     assertEquals(2, seq.findIndex(seq.getStart()));
2053
2054     // no hidden columns
2055     assertEquals(seq.findIndex(seq.getStart()) - 1,
2056             seq.firstResidueOutsideIterator(cs.iterator()));
2057
2058     // hidden column on gap after end of sequence - should not affect bounds
2059     colsel.hideSelectedColumns(13, al.getHiddenColumns());
2060     assertEquals(seq.findIndex(seq.getStart()) - 1,
2061             seq.firstResidueOutsideIterator(cs.iterator()));
2062
2063     cs.revealAllHiddenColumns(colsel);
2064     // hidden column on gap before beginning of sequence - should vis bounds by
2065     // one
2066     colsel.hideSelectedColumns(0, al.getHiddenColumns());
2067     assertEquals(seq.findIndex(seq.getStart()) - 2,
2068             cs.absoluteToVisibleColumn(
2069                     seq.firstResidueOutsideIterator(cs.iterator())));
2070
2071     cs.revealAllHiddenColumns(colsel);
2072     // hide columns around most of sequence - leave one residue remaining
2073     cs.hideColumns(1, 3);
2074     cs.hideColumns(6, 11);
2075
2076     Iterator<int[]> it = cs.getVisContigsIterator(0, 6, false);
2077
2078     assertEquals("-D", seq.getSequenceStringFromIterator(it));
2079     // cs.getVisibleSequenceStrings(0, 5, new SequenceI[]
2080     // { seq })[0]);
2081
2082     assertEquals(4, seq.firstResidueOutsideIterator(cs.iterator()));
2083     cs.revealAllHiddenColumns(colsel);
2084
2085     // hide whole sequence - should just get location of hidden region
2086     // containing sequence
2087     cs.hideColumns(1, 11);
2088     assertEquals(0, seq.firstResidueOutsideIterator(cs.iterator()));
2089
2090     cs.revealAllHiddenColumns(colsel);
2091     cs.hideColumns(0, 15);
2092     assertEquals(0, seq.firstResidueOutsideIterator(cs.iterator()));
2093
2094     SequenceI seq2 = new Sequence("RefSeq2", "-------A-SD-ASD--E---");
2095
2096     cs.revealAllHiddenColumns(colsel);
2097     cs.hideColumns(7, 17);
2098     assertEquals(0, seq2.firstResidueOutsideIterator(cs.iterator()));
2099
2100     cs.revealAllHiddenColumns(colsel);
2101     cs.hideColumns(3, 17);
2102     assertEquals(0, seq2.firstResidueOutsideIterator(cs.iterator()));
2103
2104     cs.revealAllHiddenColumns(colsel);
2105     cs.hideColumns(3, 19);
2106     assertEquals(0, seq2.firstResidueOutsideIterator(cs.iterator()));
2107
2108     cs.revealAllHiddenColumns(colsel);
2109     cs.hideColumns(0, 0);
2110     assertEquals(1, seq.firstResidueOutsideIterator(cs.iterator()));
2111
2112     cs.revealAllHiddenColumns(colsel);
2113     cs.hideColumns(0, 1);
2114     assertEquals(3, seq.firstResidueOutsideIterator(cs.iterator()));
2115
2116     cs.revealAllHiddenColumns(colsel);
2117     cs.hideColumns(0, 2);
2118     assertEquals(3, seq.firstResidueOutsideIterator(cs.iterator()));
2119
2120     cs.revealAllHiddenColumns(colsel);
2121     cs.hideColumns(1, 1);
2122     assertEquals(3, seq.firstResidueOutsideIterator(cs.iterator()));
2123
2124     cs.revealAllHiddenColumns(colsel);
2125     cs.hideColumns(1, 2);
2126     assertEquals(3, seq.firstResidueOutsideIterator(cs.iterator()));
2127
2128     cs.revealAllHiddenColumns(colsel);
2129     cs.hideColumns(1, 3);
2130     assertEquals(4, seq.firstResidueOutsideIterator(cs.iterator()));
2131
2132     cs.revealAllHiddenColumns(colsel);
2133     cs.hideColumns(0, 2);
2134     cs.hideColumns(5, 6);
2135     assertEquals(3, seq.firstResidueOutsideIterator(cs.iterator()));
2136
2137     cs.revealAllHiddenColumns(colsel);
2138     cs.hideColumns(0, 2);
2139     cs.hideColumns(5, 6);
2140     cs.hideColumns(9, 10);
2141     assertEquals(3, seq.firstResidueOutsideIterator(cs.iterator()));
2142
2143     cs.revealAllHiddenColumns(colsel);
2144     cs.hideColumns(0, 2);
2145     cs.hideColumns(7, 11);
2146     assertEquals(3, seq.firstResidueOutsideIterator(cs.iterator()));
2147
2148     cs.revealAllHiddenColumns(colsel);
2149     cs.hideColumns(2, 4);
2150     cs.hideColumns(7, 11);
2151     assertEquals(1, seq.firstResidueOutsideIterator(cs.iterator()));
2152
2153     cs.revealAllHiddenColumns(colsel);
2154     cs.hideColumns(2, 4);
2155     cs.hideColumns(7, 12);
2156     assertEquals(1, seq.firstResidueOutsideIterator(cs.iterator()));
2157
2158     cs.revealAllHiddenColumns(colsel);
2159     cs.hideColumns(1, 11);
2160     assertEquals(0, seq.firstResidueOutsideIterator(cs.iterator()));
2161
2162     cs.revealAllHiddenColumns(colsel);
2163     cs.hideColumns(0, 12);
2164     assertEquals(0, seq.firstResidueOutsideIterator(cs.iterator()));
2165
2166     cs.revealAllHiddenColumns(colsel);
2167     cs.hideColumns(0, 4);
2168     cs.hideColumns(6, 12);
2169     assertEquals(0, seq.firstResidueOutsideIterator(cs.iterator()));
2170
2171     cs.revealAllHiddenColumns(colsel);
2172     cs.hideColumns(0, 1);
2173     cs.hideColumns(3, 12);
2174     assertEquals(0, seq.firstResidueOutsideIterator(cs.iterator()));
2175
2176     cs.revealAllHiddenColumns(colsel);
2177     cs.hideColumns(3, 14);
2178     cs.hideColumns(17, 19);
2179     assertEquals(0, seq2.firstResidueOutsideIterator(cs.iterator()));
2180
2181     cs.revealAllHiddenColumns(colsel);
2182     cs.hideColumns(3, 7);
2183     cs.hideColumns(9, 14);
2184     cs.hideColumns(17, 19);
2185     assertEquals(0, seq2.firstResidueOutsideIterator(cs.iterator()));
2186
2187     cs.revealAllHiddenColumns(colsel);
2188     cs.hideColumns(0, 1);
2189     cs.hideColumns(3, 4);
2190     cs.hideColumns(6, 8);
2191     cs.hideColumns(10, 12);
2192     assertEquals(0, seq.firstResidueOutsideIterator(cs.iterator()));
2193
2194   }
2195   @Test(groups= {"Functional"})
2196   public void testTransferAnnotation() {
2197     Sequence origSeq = new Sequence("MYSEQ","THISISASEQ");
2198     Sequence toSeq = new Sequence("MYSEQ","THISISASEQ");
2199     origSeq.addDBRef(new DBRefEntry("UNIPROT", "0", "Q12345", null, true));
2200     toSeq.transferAnnotation(origSeq, null);
2201     assertTrue(toSeq.getDBRefs().size()==1);
2202
2203     assertTrue(toSeq.getDBRefs().get(0).isCanonical());
2204
2205     // check for promotion of non-canonical
2206     // to canonical (e.g. fetch-db-refs on a jalview project pre 2.11.2)
2207     toSeq.setDBRefs(null);
2208     toSeq.addDBRef(new DBRefEntry("UNIPROT", "0", "Q12345", null, false));
2209     toSeq.transferAnnotation(origSeq, null);
2210     assertTrue(toSeq.getDBRefs().size()==1);
2211
2212     assertTrue("Promotion of non-canonical DBRefEntry failed",toSeq.getDBRefs().get(0).isCanonical());
2213
2214
2215   }
2216 }