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