X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FSequenceTest.java;h=17dfcdce9dff7778fb2ba2fcf092d7ddb6c0e0c5;hb=f7d70c3514a06321f07f6cda8dd9d26402f7f577;hp=95755ee2b2fa6afbbad190689026b705f3fb2bfe;hpb=6d7cc70c983c0bee2ab25a202bb8b07e046d6de1;p=jalview.git

diff --git a/test/jalview/datamodel/SequenceTest.java b/test/jalview/datamodel/SequenceTest.java
index 95755ee..17dfcdc 100644
--- a/test/jalview/datamodel/SequenceTest.java
+++ b/test/jalview/datamodel/SequenceTest.java
@@ -29,11 +29,14 @@ import static org.testng.AssertJUnit.assertTrue;
 import static org.testng.internal.junit.ArrayAsserts.assertArrayEquals;
 
 import jalview.datamodel.PDBEntry.Type;
+import jalview.util.MapList;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Vector;
 
+import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
@@ -310,9 +313,13 @@ public class SequenceTest
     assertEquals(1, sfs.length);
     assertSame(sf, sfs[0]);
 
+
     /*
      * SequenceFeature on sequence and dataset sequence; returns that on
      * sequence
+     * 
+     * Note JAL-2046: spurious: we have no use case for this at the moment.
+     * This test also buggy - as sf2.equals(sf), no new feature is added
      */
     SequenceFeature sf2 = new SequenceFeature();
     sq.getDatasetSequence().addSequenceFeature(sf2);
@@ -322,17 +329,20 @@ public class SequenceTest
 
     /*
      * SequenceFeature on dataset sequence only
+     * Note JAL-2046: spurious: we have no use case for setting a non-dataset sequence's feature array to null at the moment.
      */
     sq.setSequenceFeatures(null);
-    sfs = sq.getSequenceFeatures();
-    assertEquals(1, sfs.length);
-    assertSame(sf2, sfs[0]);
+    assertNull(sq.getDatasetSequence().getSequenceFeatures());
 
     /*
      * Corrupt case - no SequenceFeature, dataset's dataset is the original
      * sequence. Test shows no infinite loop results.
      */
     sq.getDatasetSequence().setSequenceFeatures(null);
+    /**
+     * is there a usecase for this ? setDatasetSequence should throw an error if
+     * this actually occurs.
+     */
     sq.getDatasetSequence().setDatasetSequence(sq); // loop!
     assertNull(sq.getSequenceFeatures());
   }
@@ -390,14 +400,78 @@ public class SequenceTest
     sq.setStart(3);
     sq.setEnd(4);
 
+    sq.setDescription("Test sequence description..");
+    sq.setVamsasId("TestVamsasId");
+    sq.setSourceDBRef(new DBRefEntry("PDB", "version0", "1TST"));
+
+    sq.addDBRef(new DBRefEntry("PDB", "version1", "1Tst"));
+    sq.addDBRef(new DBRefEntry("PDB", "version2", "2Tst"));
+    sq.addDBRef(new DBRefEntry("PDB", "version3", "3Tst"));
+    sq.addDBRef(new DBRefEntry("PDB", "version4", "4Tst"));
+
+    sq.addPDBId(new PDBEntry("1PDB", "A", Type.PDB, "filePath/test1"));
+    sq.addPDBId(new PDBEntry("1PDB", "B", Type.PDB, "filePath/test1"));
+    sq.addPDBId(new PDBEntry("2PDB", "A", Type.MMCIF, "filePath/test2"));
+    sq.addPDBId(new PDBEntry("2PDB", "B", Type.MMCIF, "filePath/test2"));
+
+    sq.getDatasetSequence().addDBRef(
+            new DBRefEntry("PDB", "version1", "1Tst"));
+    sq.getDatasetSequence().addDBRef(
+            new DBRefEntry("PDB", "version2", "2Tst"));
+    sq.getDatasetSequence().addDBRef(
+            new DBRefEntry("PDB", "version3", "3Tst"));
+    sq.getDatasetSequence().addDBRef(
+            new DBRefEntry("PDB", "version4", "4Tst"));
+
+    sq.getDatasetSequence().addPDBId(
+            new PDBEntry("1PDB", "A", Type.PDB, "filePath/test1"));
+    sq.getDatasetSequence().addPDBId(
+            new PDBEntry("1PDB", "B", Type.PDB, "filePath/test1"));
+    sq.getDatasetSequence().addPDBId(
+            new PDBEntry("2PDB", "A", Type.MMCIF, "filePath/test2"));
+    sq.getDatasetSequence().addPDBId(
+            new PDBEntry("2PDB", "B", Type.MMCIF, "filePath/test2"));
+
+    ArrayList<Annotation> annotsList = new ArrayList<Annotation>();
+    System.out.println(">>>>>> " + sq.getSequenceAsString().length());
+    annotsList.add(new Annotation("A", "A", 'X', 0.1f));
+    annotsList.add(new Annotation("A", "A", 'X', 0.1f));
+    Annotation[] annots = annotsList.toArray(new Annotation[0]);
+    sq.addAlignmentAnnotation(new AlignmentAnnotation("Test annot",
+            "Test annot description", annots));
+    sq.getDatasetSequence().addAlignmentAnnotation(
+            new AlignmentAnnotation("Test annot", "Test annot description",
+                    annots));
+    Assert.assertEquals(sq.getDescription(), "Test sequence description..");
+    Assert.assertEquals(sq.getDBRefs().length, 4);
+    Assert.assertEquals(sq.getAllPDBEntries().size(), 4);
+    Assert.assertNotNull(sq.getAnnotation());
+    Assert.assertEquals(sq.getAnnotation()[0].annotations.length, 2);
+    Assert.assertEquals(sq.getDatasetSequence().getDBRefs().length, 4);
+    Assert.assertEquals(sq.getDatasetSequence().getAllPDBEntries().size(),
+            4);
+    Assert.assertNotNull(sq.getDatasetSequence().getAnnotation());
+
     Sequence derived = (Sequence) sq.deriveSequence();
+
+    Assert.assertEquals(derived.getDescription(),
+            "Test sequence description..");
+    Assert.assertEquals(derived.getDBRefs().length, 4);
+    Assert.assertEquals(derived.getAllPDBEntries().size(), 4);
+    Assert.assertNotNull(derived.getAnnotation());
+    Assert.assertEquals(derived.getAnnotation()[0].annotations.length, 2);
+    Assert.assertEquals(derived.getDatasetSequence().getDBRefs().length, 4);
+    Assert.assertEquals(derived.getDatasetSequence().getAllPDBEntries()
+            .size(), 4);
+    Assert.assertNotNull(derived.getDatasetSequence().getAnnotation());
+
     assertEquals("CD", derived.getSequenceAsString());
     assertSame(sq.getDatasetSequence(), derived.getDatasetSequence());
 
     assertNull(sq.sequenceFeatures);
-    // assertNull(derived.sequenceFeatures);
+    assertNull(derived.sequenceFeatures);
+    // derived sequence should access dataset sequence features
     assertNotNull(sq.getSequenceFeatures());
-    // derived sequence has a copy of the sequence features (is this right?)
     assertArrayEquals(sq.getSequenceFeatures(),
             derived.getSequenceFeatures());
   }
@@ -471,6 +545,8 @@ public class SequenceTest
     seq1.setDescription("description");
     seq1.addAlignmentAnnotation(new AlignmentAnnotation("label", "desc",
             1.3d));
+    // JAL-2046 - what is the contract for using a derived sequence's
+    // addSequenceFeature ?
     seq1.addSequenceFeature(new SequenceFeature("type", "desc", 22, 33,
             12.4f, "group"));
     seq1.addPDBId(new PDBEntry("1A70", "B", Type.PDB, "File"));
@@ -518,7 +594,11 @@ public class SequenceTest
     // copy has a copy of the sequence feature:
     SequenceFeature[] sfs = copy.getSequenceFeatures();
     assertEquals(1, sfs.length);
-    assertFalse(sfs[0] == seq1.getSequenceFeatures()[0]);
+    if (seq1.getDatasetSequence()!=null && copy.getDatasetSequence()==seq1.getDatasetSequence()) {
+      assertTrue(sfs[0] == seq1.getSequenceFeatures()[0]);
+    } else {
+      assertFalse(sfs[0] == seq1.getSequenceFeatures()[0]);
+    }
     assertTrue(sfs[0].equals(seq1.getSequenceFeatures()[0]));
 
     // copy has a copy of the PDB entry
@@ -537,4 +617,85 @@ public class SequenceTest
     assertEquals(' ', sq.getCharAt(5));
     assertEquals(' ', sq.getCharAt(-1));
   }
+
+  /**
+   * Tests for adding (or updating) dbrefs
+   * 
+   * @see DBRefEntry#updateFrom(DBRefEntry)
+   */
+  @Test(groups = { "Functional" })
+  public void testAddDBRef()
+  {
+    SequenceI sq = new Sequence("", "abcde");
+    assertNull(sq.getDBRefs());
+    DBRefEntry dbref = new DBRefEntry("Uniprot", "1", "P00340");
+    sq.addDBRef(dbref);
+    assertEquals(1, sq.getDBRefs().length);
+    assertSame(dbref, sq.getDBRefs()[0]);
+
+    /*
+     * change of version - new entry
+     */
+    DBRefEntry dbref2 = new DBRefEntry("Uniprot", "2", "P00340");
+    sq.addDBRef(dbref2);
+    assertEquals(2, sq.getDBRefs().length);
+    assertSame(dbref, sq.getDBRefs()[0]);
+    assertSame(dbref2, sq.getDBRefs()[1]);
+
+    /*
+     * matches existing entry - not added
+     */
+    sq.addDBRef(new DBRefEntry("UNIPROT", "1", "p00340"));
+    assertEquals(2, sq.getDBRefs().length);
+
+    /*
+     * different source = new entry
+     */
+    DBRefEntry dbref3 = new DBRefEntry("UniRef", "1", "p00340");
+    sq.addDBRef(dbref3);
+    assertEquals(3, sq.getDBRefs().length);
+    assertSame(dbref3, sq.getDBRefs()[2]);
+
+    /*
+     * different ref = new entry
+     */
+    DBRefEntry dbref4 = new DBRefEntry("UniRef", "1", "p00341");
+    sq.addDBRef(dbref4);
+    assertEquals(4, sq.getDBRefs().length);
+    assertSame(dbref4, sq.getDBRefs()[3]);
+
+    /*
+     * matching ref with a mapping - map updated
+     */
+    DBRefEntry dbref5 = new DBRefEntry("UniRef", "1", "p00341");
+    Mapping map = new Mapping(new MapList(new int[] { 1, 3 }, new int[] {
+        1, 1 }, 3, 1));
+    dbref5.setMap(map);
+    sq.addDBRef(dbref5);
+    assertEquals(4, sq.getDBRefs().length);
+    assertSame(dbref4, sq.getDBRefs()[3]);
+    assertSame(map, dbref4.getMap());
+
+    /*
+     * 'real' version replaces "0" version
+     */
+    dbref2.setVersion("0");
+    DBRefEntry dbref6 = new DBRefEntry(dbref2.getSource(), "3",
+            dbref2.getAccessionId());
+    sq.addDBRef(dbref6);
+    assertEquals(4, sq.getDBRefs().length);
+    assertSame(dbref2, sq.getDBRefs()[1]);
+    assertEquals("3", dbref2.getVersion());
+
+    /*
+     * 'real' version replaces "source:0" version
+     */
+    dbref3.setVersion("Uniprot:0");
+    DBRefEntry dbref7 = new DBRefEntry(dbref3.getSource(), "3",
+            dbref3.getAccessionId());
+    sq.addDBRef(dbref7);
+    assertEquals(4, sq.getDBRefs().length);
+    assertSame(dbref3, sq.getDBRefs()[2]);
+    assertEquals("3", dbref2.getVersion());
+  }
 }