JAL-2526 cache first/last residue column positions in cursor

[jalview.git] / test / jalview / datamodel / SequenceTest.java

diff --git a/test/jalview/datamodel/SequenceTest.java b/test/jalview/datamodel/SequenceTest.java
index 97a75f9..e657599 100644 (file)
--- a/test/jalview/datamodel/SequenceTest.java
+++ b/test/jalview/datamodel/SequenceTest.java
@@ -286,6 +286,8 @@ public class SequenceTest
     SequenceI sq = new Sequence("test/8-13", "ABCDEF");
     assertEquals(8, sq.findPosition(0));
     // Sequence should now hold a cursor at [8, 0]
+    assertEquals("test:Pos8:Col1:startCol1:endCol0:tok0",
+            PA.getValue(sq, "cursor").toString());
     SequenceCursor cursor = (SequenceCursor) PA.getValue(sq, "cursor");
     int token = (int) PA.getValue(sq, "changeCount");
     assertEquals(new SequenceCursor(sq, 8, 1, token), cursor);
@@ -294,11 +296,14 @@ public class SequenceTest
 
     /*
      * find F13 at column offset 5, cursor should update to [13, 6]
+     * endColumn is found and saved in cursor
      */
     assertEquals(13, sq.findPosition(5));
     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
     assertEquals(++token, (int) PA.getValue(sq, "changeCount"));
     assertEquals(new SequenceCursor(sq, 13, 6, token), cursor);
+    assertEquals("test:Pos13:Col6:startCol1:endCol6:tok1",
+            PA.getValue(sq, "cursor").toString());
 
     // assertEquals(-1, seq.findPosition(6)); // fails
 
@@ -307,11 +312,15 @@ public class SequenceTest
     assertEquals(8, sq.findPosition(0));
     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
     assertEquals(new SequenceCursor(sq, 8, 1, token), cursor);
+    assertEquals("test:Pos8:Col1:startCol1:endCol0:tok0",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
     assertEquals(9, sq.findPosition(1));
     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
     assertEquals(new SequenceCursor(sq, 9, 2, ++token), cursor);
+    assertEquals("test:Pos9:Col2:startCol1:endCol0:tok1",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
     // gap position 'finds' residue to the right (not the left as per javadoc)
@@ -319,11 +328,15 @@ public class SequenceTest
     assertEquals(10, sq.findPosition(2));
     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
     assertEquals(new SequenceCursor(sq, 9, 2, ++token), cursor);
+    assertEquals("test:Pos9:Col2:startCol1:endCol0:tok2",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
     assertEquals(10, sq.findPosition(3));
     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
     assertEquals(new SequenceCursor(sq, 10, 4, ++token), cursor);
+    assertEquals("test:Pos10:Col4:startCol1:endCol0:tok3",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
     // column[4] is the gap after C - returns D11
@@ -331,11 +344,16 @@ public class SequenceTest
     assertEquals(11, sq.findPosition(4));
     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
     assertEquals(new SequenceCursor(sq, 10, 4, ++token), cursor);
+    assertEquals("test:Pos10:Col4:startCol1:endCol0:tok4",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
     assertEquals(11, sq.findPosition(5)); // D
     cursor = (SequenceCursor) PA.getValue(sq, "cursor");
     assertEquals(new SequenceCursor(sq, 11, 6, ++token), cursor);
+    // lastCol has been found and saved in the cursor
+    assertEquals("test:Pos11:Col6:startCol1:endCol6:tok5",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
     // returns 1 more than sequence length if off the end ?!?
@@ -344,38 +362,68 @@ public class SequenceTest
     sq.sequenceChanged();
     assertEquals(12, sq.findPosition(7));
 
+    /*
+     * first findPosition should also set firstResCol in cursor
+     */
     sq = new Sequence("test/8-13", "--AB-C-DEF--");
     assertEquals(8, sq.findPosition(0));
+    assertNull(PA.getValue(sq, "cursor"));
 
     sq.sequenceChanged();
     assertEquals(8, sq.findPosition(1));
+    assertNull(PA.getValue(sq, "cursor"));
 
     sq.sequenceChanged();
     assertEquals(8, sq.findPosition(2));
+    assertEquals("test:Pos8:Col3:startCol3:endCol0:tok2",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
     assertEquals(9, sq.findPosition(3));
+    assertEquals("test:Pos9:Col4:startCol3:endCol0:tok3",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
+    // column[4] is a gap, returns next residue pos (C10)
+    // cursor is set to last residue found [B]
     assertEquals(10, sq.findPosition(4));
+    assertEquals("test:Pos9:Col4:startCol3:endCol0:tok4",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
     assertEquals(10, sq.findPosition(5));
+    assertEquals("test:Pos10:Col6:startCol3:endCol0:tok5",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
+    // column[6] is a gap, returns next residue pos (D11)
+    // cursor is set to last residue found [C]
     assertEquals(11, sq.findPosition(6));
+    assertEquals("test:Pos10:Col6:startCol3:endCol0:tok6",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
     assertEquals(11, sq.findPosition(7));
+    assertEquals("test:Pos11:Col8:startCol3:endCol0:tok7",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
     assertEquals(12, sq.findPosition(8));
+    assertEquals("test:Pos12:Col9:startCol3:endCol0:tok8",
+            PA.getValue(sq, "cursor").toString());
 
+    /*
+     * when the last residue column is found, it is set in the cursor
+     */
     sq.sequenceChanged();
     assertEquals(13, sq.findPosition(9));
+    assertEquals("test:Pos13:Col10:startCol3:endCol10:tok9",
+            PA.getValue(sq, "cursor").toString());
 
     sq.sequenceChanged();
     assertEquals(14, sq.findPosition(10));
+    assertEquals("test:Pos13:Col10:startCol3:endCol10:tok10",
+            PA.getValue(sq, "cursor").toString());
 
     /*
      * findPosition for column beyond sequence length
@@ -383,8 +431,13 @@ public class SequenceTest
      */
     sq.sequenceChanged();
     assertEquals(14, sq.findPosition(11));
+    assertEquals("test:Pos13:Col10:startCol3:endCol10:tok11",
+            PA.getValue(sq, "cursor").toString());
+
     sq.sequenceChanged();
     assertEquals(14, sq.findPosition(99));
+    assertEquals("test:Pos13:Col10:startCol3:endCol10:tok12",
+            PA.getValue(sq, "cursor").toString());
   }
 
   @Test(groups = { "Functional" })
@@ -1339,41 +1392,41 @@ public class SequenceTest
   {
     Sequence sq = new Sequence("test/8-13", "-A--BCD-EF--");
   
-    // find F pos given A
+    // find F pos given A - lastCol gets set in cursor
     assertEquals(13, sq.findPosition(10, new SequenceCursor(sq, 8, 2, 0)));
-    int token = (int) PA.getValue(sq, "changeCount"); // 0
-    SequenceCursor cursor = (SequenceCursor) PA.getValue(sq, "cursor");
-    assertEquals(new SequenceCursor(sq, 13, 10, token), cursor);
+    assertEquals("test:Pos13:Col10:startCol0:endCol10:tok0",
+            PA.getValue(sq, "cursor").toString());
 
-    // find A pos given F
+    // find A pos given F - first residue column is saved in cursor
     assertEquals(8, sq.findPosition(2, new SequenceCursor(sq, 13, 10, 0)));
-    cursor = (SequenceCursor) PA.getValue(sq, "cursor");
-    assertEquals(new SequenceCursor(sq, 8, 2, token), cursor);
+    assertEquals("test:Pos8:Col2:startCol2:endCol10:tok0",
+            PA.getValue(sq, "cursor").toString());
   
-    // find C pos given C
+    // find C pos given C (neither startCol nor endCol is set)
     assertEquals(10, sq.findPosition(6, new SequenceCursor(sq, 10, 6, 0)));
-    cursor = (SequenceCursor) PA.getValue(sq, "cursor");
-    assertEquals(new SequenceCursor(sq, 10, 6, token), cursor);
+    assertEquals("test:Pos10:Col6:startCol0:endCol0:tok0",
+            PA.getValue(sq, "cursor").toString());
 
     // now the grey area - what residue position for a gapped column? JAL-2562
 
     // find 'residue' for column 3 given cursor for D (so working left)
     // returns B9; cursor is updated to [B 5]
     assertEquals(9, sq.findPosition(3, new SequenceCursor(sq, 11, 7, 0)));
-    cursor = (SequenceCursor) PA.getValue(sq, "cursor");
-    assertEquals(new SequenceCursor(sq, 9, 5, token), cursor);
+    assertEquals("test:Pos9:Col5:startCol0:endCol0:tok0",
+            PA.getValue(sq, "cursor").toString());
 
     // find 'residue' for column 8 given cursor for D (so working right)
     // returns E12; cursor is updated to [D 7]
     assertEquals(12, sq.findPosition(8, new SequenceCursor(sq, 11, 7, 0)));
-    cursor = (SequenceCursor) PA.getValue(sq, "cursor");
-    assertEquals(new SequenceCursor(sq, 11, 7, token), cursor);
+    assertEquals("test:Pos11:Col7:startCol0:endCol0:tok0",
+            PA.getValue(sq, "cursor").toString());
 
     // find 'residue' for column 12 given cursor for B
     // returns 1 more than last residue position; cursor is updated to [F 10]
+    // lastCol position is saved in cursor
     assertEquals(14, sq.findPosition(12, new SequenceCursor(sq, 9, 5, 0)));
-    cursor = (SequenceCursor) PA.getValue(sq, "cursor");
-    assertEquals(new SequenceCursor(sq, 13, 10, token), cursor);
+    assertEquals("test:Pos13:Col10:startCol0:endCol10:tok0",
+            PA.getValue(sq, "cursor").toString());
 
     /*
      * findPosition for column beyond length of sequence
@@ -1381,8 +1434,8 @@ public class SequenceTest
      * cursor is set to last real residue position [F 10]
      */
     assertEquals(14, sq.findPosition(99, new SequenceCursor(sq, 8, 2, 0)));
-    cursor = (SequenceCursor) PA.getValue(sq, "cursor");
-    assertEquals(new SequenceCursor(sq, 13, 10, token), cursor);
+    assertEquals("test:Pos13:Col10:startCol0:endCol10:tok0",
+            PA.getValue(sq, "cursor").toString());
 
     /*
      * and the case without a trailing gap
@@ -1390,13 +1443,14 @@ public class SequenceTest
     sq = new Sequence("test/8-13", "-A--BCD-EF");
     // first find C from A
     assertEquals(10, sq.findPosition(6, new SequenceCursor(sq, 8, 2, 0)));
-    cursor = (SequenceCursor) PA.getValue(sq, "cursor");
-    assertEquals(new SequenceCursor(sq, 10, 6, token), cursor);
+    SequenceCursor cursor = (SequenceCursor) PA.getValue(sq, "cursor");
+    assertEquals("test:Pos10:Col6:startCol0:endCol0:tok0",
+            cursor.toString());
     // now 'find' 99 from C
-    // cursor is set to [F 10]
+    // cursor is set to [F 10] and saved lastCol
     assertEquals(14, sq.findPosition(99, cursor));
-    cursor = (SequenceCursor) PA.getValue(sq, "cursor");
-    assertEquals(new SequenceCursor(sq, 13, 10, token), cursor);
+    assertEquals("test:Pos13:Col10:startCol0:endCol10:tok0",
+            PA.getValue(sq, "cursor").toString());
   }
 
   @Test
@@ -1414,11 +1468,11 @@ public class SequenceTest
     assertTrue(sq.isValidCursor(cursor));
 
     /*
-     * column position outside [0 - length-1] is rejected
+     * column position outside [0 - length] is rejected
      */
     cursor = new SequenceCursor(sq, 13, -1, changeCount);
     assertFalse(sq.isValidCursor(cursor));
-    cursor = new SequenceCursor(sq, 13, 9, changeCount);
+    cursor = new SequenceCursor(sq, 13, 10, changeCount);
     assertFalse(sq.isValidCursor(cursor));
     cursor = new SequenceCursor(sq, 7, 8, changeCount);
     assertFalse(sq.isValidCursor(cursor));