test/jalview/util/ComparisonTest.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.util;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertFalse;
  25 import static org.testng.AssertJUnit.assertTrue;
  26
  27 import jalview.datamodel.Sequence;
  28 import jalview.datamodel.SequenceI;
  29 import jalview.gui.JvOptionPane;
  30
  31 import org.testng.annotations.BeforeClass;
  32 import org.testng.annotations.Test;
  33
  34 public class ComparisonTest
  35 {
  36
  37   @BeforeClass(alwaysRun = true)
  38   public void setUpJvOptionPane()
  39   {
  40     JvOptionPane.setInteractiveMode(false);
  41     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  42   }
  43
  44   @Test(groups = { "Functional" })
  45   public void testIsGap()
  46   {
  47     assertTrue(Comparison.isGap('-'));
  48     assertTrue(Comparison.isGap('.'));
  49     assertTrue(Comparison.isGap(' '));
  50     assertFalse(Comparison.isGap('X'));
  51     assertFalse(Comparison.isGap('x'));
  52     assertFalse(Comparison.isGap('*'));
  53     assertFalse(Comparison.isGap('G'));
  54   }
  55
  56   /**
  57    * Test for isNucleotide is that sequences in a dataset are more than 85%
  58    * AGCTU. Test is not case-sensitive and ignores gaps.
  59    */
  60   @Test(groups = { "Functional" })
  61   public void testIsNucleotide_sequences()
  62   {
  63     SequenceI seq = new Sequence("eightypercent", "agctuAGCPV");
  64     assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));
  65     assertFalse(
  66             Comparison.isNucleotide(new SequenceI[][]
  67             { new SequenceI[] { seq } }));
  68
  69     seq = new Sequence("eightyfivepercent", "agctuAGCPVagctuAGCUV");
  70     assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));
  71
  72     seq = new Sequence("nineypercent", "agctuAGCgVagctuAGCUV");
  73     assertTrue(Comparison.isNucleotide(new SequenceI[] { seq }));
  74
  75     seq = new Sequence("eightyfivepercentgapped",
  76             "--agc--tuA--GCPV-a---gct-uA-GC---UV");
  77     assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));
  78
  79     seq = new Sequence("nineypercentgapped",
  80             "ag--ct-u-A---GC---g----Vag--c---tuAGCUV");
  81     assertTrue(Comparison.isNucleotide(new SequenceI[] { seq }));
  82
  83     seq = new Sequence("allgap", "---------");
  84     assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));
  85
  86     seq = new Sequence("DNA", "ACTugGCCAG");
  87     SequenceI seq2 = new Sequence("Protein", "FLIMVSPTYW");
  88     /*
  89      * 90% DNA but one protein sequence - expect false
  90      */
  91     assertFalse(
  92             Comparison.isNucleotide(new SequenceI[]
  93             { seq, seq, seq, seq, seq, seq, seq, seq, seq, seq2 }));
  94     assertFalse(
  95             Comparison.isNucleotide(new SequenceI[][]
  96             { new SequenceI[] { seq }, new SequenceI[] { seq, seq, seq },
  97                 new SequenceI[]
  98                 { seq, seq, seq, seq, seq, seq2 } }));
  99     /*
 100      * 80% DNA but one protein sequence - Expect false
 101      */
 102     assertFalse(
 103             Comparison.isNucleotide(new SequenceI[]
 104             { seq, seq, seq, seq, seq, seq, seq, seq, seq2, seq2 }));
 105     assertFalse(
 106             Comparison.isNucleotide(new SequenceI[][]
 107             { new SequenceI[] { seq }, new SequenceI[] { seq, seq, seq },
 108                 new SequenceI[]
 109                 { seq, seq, seq, seq, seq2, seq2, null } }));
 110
 111     seq = new Sequence("ProteinThatLooksLikeDNA", "WYATGCCTGAgtcgt");
 112     // 12/14 = 85.7%
 113     assertTrue(Comparison.isNucleotide(new SequenceI[] { seq }));
 114
 115     assertFalse(Comparison.isNucleotide((SequenceI[]) null));
 116     assertFalse(Comparison.isNucleotide((SequenceI[][]) null));
 117   }
 118
 119   /**
 120    * Test the percentage identity calculation for two sequences
 121    */
 122   @Test(groups = { "Functional" })
 123   public void testPID_includingGaps()
 124   {
 125     String seq1 = "ABCDEFG"; // extra length here is ignored
 126     String seq2 = "abcdef";
 127     assertEquals("identical", 100f, Comparison.PID(seq1, seq2), 0.001f);
 128
 129     // comparison range defaults to length of first sequence
 130     seq2 = "abcdefghijklmnopqrstuvwxyz";
 131     assertEquals("identical", 100f, Comparison.PID(seq1, seq2), 0.001f);
 132
 133     // 5 identical, 2 gap-gap, 2 gap-residue, 1 mismatch
 134     seq1 = "a--b-cdefh";
 135     seq2 = "a---bcdefg";
 136     int length = seq1.length();
 137
 138     // match gap-residue, match gap-gap: 9/10 identical
 139     // TODO should gap-gap be included in a PID score? JAL-791
 140     assertEquals(90f, Comparison.PID(seq1, seq2, 0, length, true, false),
 141             0.001f);
 142     // overloaded version of the method signature above:
 143     assertEquals(90f, Comparison.PID(seq1, seq2), 0.001f);
 144
 145     // don't match gap-residue, match gap-gap: 7/10 identical
 146     // TODO should gap-gap be included in a PID score?
 147     assertEquals(70f, Comparison.PID(seq1, seq2, 0, length, false, false),
 148             0.001f);
 149   }
 150
 151   @Test(groups = { "Functional" })
 152   public void testIsNucleotide()
 153   {
 154     assertTrue(Comparison.isNucleotide('a'));
 155     assertTrue(Comparison.isNucleotide('A'));
 156     assertTrue(Comparison.isNucleotide('c'));
 157     assertTrue(Comparison.isNucleotide('C'));
 158     assertTrue(Comparison.isNucleotide('g'));
 159     assertTrue(Comparison.isNucleotide('G'));
 160     assertTrue(Comparison.isNucleotide('t'));
 161     assertTrue(Comparison.isNucleotide('T'));
 162     assertTrue(Comparison.isNucleotide('u'));
 163     assertTrue(Comparison.isNucleotide('U'));
 164     assertFalse(Comparison.isNucleotide('-'));
 165     assertFalse(Comparison.isNucleotide('P'));
 166   }
 167
 168   /**
 169    * Test the percentage identity calculation for two sequences
 170    */
 171   @Test(groups = { "Functional" })
 172   public void testPID_ungappedOnly()
 173   {
 174     // 5 identical, 2 gap-gap, 2 gap-residue, 1 mismatch
 175     // the extra length of seq1 is ignored
 176     String seq1 = "a--b-cdefhr";
 177     String seq2 = "a---bcdefg";
 178     int length = seq1.length();
 179
 180     /*
 181      * As currently coded, 'ungappedOnly' ignores gap-residue but counts
 182      * gap-gap. Is this a bug - should gap-gap also be ignored, giving a PID of
 183      * 5/6?
 184      *
 185      * Note also there is no variant of the calculation that penalises
 186      * gap-residue i.e. counts it as a mismatch. This would give a score of 5/8
 187      * (if we ignore gap-gap) or 5/10 (if we count gap-gap as a match).
 188      */
 189     // match gap-residue, match gap-gap: 7/8 identical
 190     assertEquals(87.5f, Comparison.PID(seq1, seq2, 0, length, true, true),
 191             0.001f);
 192
 193     // don't match gap-residue with 'ungapped only' - same as above
 194     assertEquals(87.5f, Comparison.PID(seq1, seq2, 0, length, false, true),
 195             0.001f);
 196   }
 197
 198   @Test(groups = { "Functional" })
 199   public void testIsNucleotideSequence()
 200   {
 201     assertFalse(Comparison.isNucleotideSequence(null, true));
 202     assertTrue(Comparison.isNucleotideSequence("", true));
 203     assertTrue(Comparison.isNucleotideSequence("aAgGcCtTuU", true));
 204     assertTrue(Comparison.isNucleotideSequence("aAgGcCtTuU", false));
 205     assertFalse(Comparison.isNucleotideSequence("xAgGcCtTuU", false));
 206     assertFalse(Comparison.isNucleotideSequence("aAgGcCtTuUx", false));
 207     assertTrue(Comparison.isNucleotideSequence("a A-g.GcCtTuU", true));
 208     assertFalse(Comparison.isNucleotideSequence("a A-g.GcCtTuU", false));
 209   }
 210
 211   @Test(groups = { "Functional" })
 212   public void testIsSameResidue()
 213   {
 214     assertTrue(Comparison.isSameResidue('a', 'a', false));
 215     assertTrue(Comparison.isSameResidue('a', 'a', true));
 216     assertTrue(Comparison.isSameResidue('A', 'a', false));
 217     assertTrue(Comparison.isSameResidue('a', 'A', false));
 218
 219     assertFalse(Comparison.isSameResidue('a', 'A', true));
 220     assertFalse(Comparison.isSameResidue('A', 'a', true));
 221   }
 222 }