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