JAL-2546 JAL-2490 efficient lookup of features, correct handling of
[jalview.git] / 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(Comparison.isNucleotide(new SequenceI[][] { new SequenceI[]
66     { seq } }));
67
68     seq = new Sequence("eightyfivepercent", "agctuAGCPVagctuAGCUV");
69     assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));
70
71     seq = new Sequence("nineypercent", "agctuAGCgVagctuAGCUV");
72     assertTrue(Comparison.isNucleotide(new SequenceI[] { seq }));
73
74     seq = new Sequence("eightyfivepercentgapped",
75             "--agc--tuA--GCPV-a---gct-uA-GC---UV");
76     assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));
77
78     seq = new Sequence("nineypercentgapped",
79             "ag--ct-u-A---GC---g----Vag--c---tuAGCUV");
80     assertTrue(Comparison.isNucleotide(new SequenceI[] { seq }));
81
82     seq = new Sequence("allgap", "---------");
83     assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));
84
85     seq = new Sequence("DNA", "ACTugGCCAG");
86     SequenceI seq2 = new Sequence("Protein", "FLIMVSPTYW");
87     /*
88      * 90% DNA:
89      */
90     assertTrue(Comparison.isNucleotide(new SequenceI[] { seq, seq, seq,
91         seq, seq, seq, seq, seq, seq, seq2 }));
92     assertTrue(Comparison.isNucleotide(new SequenceI[][] {
93         new SequenceI[] { seq }, new SequenceI[] { seq, seq, seq },
94         new SequenceI[] { seq, seq, seq, seq, seq, seq2 } }));
95     /*
96      * 80% DNA:
97      */
98     assertFalse(Comparison.isNucleotide(new SequenceI[] { seq, seq, seq,
99         seq, seq, seq, seq, seq, seq2, seq2 }));
100     assertFalse(Comparison.isNucleotide(new SequenceI[][] { new SequenceI[]
101     { seq }, new SequenceI[] { seq, seq, seq },
102         new SequenceI[] { seq, seq, seq, seq, seq2, seq2, null } }));
103
104     seq = new Sequence("ProteinThatLooksLikeDNA", "WYATGCCTGAgtcgt");
105     // 12/14 = 85.7%
106     assertTrue(Comparison.isNucleotide(new SequenceI[] { seq }));
107
108     assertFalse(Comparison.isNucleotide((SequenceI[]) null));
109     assertFalse(Comparison.isNucleotide((SequenceI[][]) null));
110   }
111
112   /**
113    * Test the percentage identity calculation for two sequences
114    */
115   @Test(groups = { "Functional" })
116   public void testPID_includingGaps()
117   {
118     String seq1 = "ABCDEFG"; // extra length here is ignored
119     String seq2 = "abcdef";
120     assertEquals("identical", 100f, Comparison.PID(seq1, seq2), 0.001f);
121
122     // comparison range defaults to length of first sequence
123     seq2 = "abcdefghijklmnopqrstuvwxyz";
124     assertEquals("identical", 100f, Comparison.PID(seq1, seq2), 0.001f);
125
126     // 5 identical, 2 gap-gap, 2 gap-residue, 1 mismatch
127     seq1 = "a--b-cdefh";
128     seq2 = "a---bcdefg";
129     int length = seq1.length();
130
131     // match gap-residue, match gap-gap: 9/10 identical
132     // TODO should gap-gap be included in a PID score? JAL-791
133     assertEquals(90f, Comparison.PID(seq1, seq2, 0, length, true, false),
134             0.001f);
135     // overloaded version of the method signature above:
136     assertEquals(90f, Comparison.PID(seq1, seq2), 0.001f);
137
138     // don't match gap-residue, match gap-gap: 7/10 identical
139     // TODO should gap-gap be included in a PID score?
140     assertEquals(70f, Comparison.PID(seq1, seq2, 0, length, false, false),
141             0.001f);
142   }
143
144   @Test(groups = { "Functional" })
145   public void testIsNucleotide()
146   {
147     assertTrue(Comparison.isNucleotide('a'));
148     assertTrue(Comparison.isNucleotide('A'));
149     assertTrue(Comparison.isNucleotide('c'));
150     assertTrue(Comparison.isNucleotide('C'));
151     assertTrue(Comparison.isNucleotide('g'));
152     assertTrue(Comparison.isNucleotide('G'));
153     assertTrue(Comparison.isNucleotide('t'));
154     assertTrue(Comparison.isNucleotide('T'));
155     assertTrue(Comparison.isNucleotide('u'));
156     assertTrue(Comparison.isNucleotide('U'));
157     assertFalse(Comparison.isNucleotide('-'));
158     assertFalse(Comparison.isNucleotide('P'));
159   }
160
161   /**
162    * Test the percentage identity calculation for two sequences
163    */
164   @Test(groups = { "Functional" })
165   public void testPID_ungappedOnly()
166   {
167     // 5 identical, 2 gap-gap, 2 gap-residue, 1 mismatch
168     // the extra length of seq1 is ignored
169     String seq1 = "a--b-cdefhr";
170     String seq2 = "a---bcdefg";
171     int length = seq1.length();
172
173     /*
174      * As currently coded, 'ungappedOnly' ignores gap-residue but counts
175      * gap-gap. Is this a bug - should gap-gap also be ignored, giving a PID of
176      * 5/6?
177      * 
178      * Note also there is no variant of the calculation that penalises
179      * gap-residue i.e. counts it as a mismatch. This would give a score of 5/8
180      * (if we ignore gap-gap) or 5/10 (if we count gap-gap as a match).
181      */
182     // match gap-residue, match gap-gap: 7/8 identical
183     assertEquals(87.5f, Comparison.PID(seq1, seq2, 0, length, true, true),
184             0.001f);
185
186     // don't match gap-residue with 'ungapped only' - same as above
187     assertEquals(87.5f, Comparison.PID(seq1, seq2, 0, length, false, true),
188             0.001f);
189   }
190
191   @Test(groups = { "Functional" })
192   public void testIsNucleotideSequence()
193   {
194     assertFalse(Comparison.isNucleotideSequence(null, true));
195     assertTrue(Comparison.isNucleotideSequence("", true));
196     assertTrue(Comparison.isNucleotideSequence("aAgGcCtTuU", true));
197     assertTrue(Comparison.isNucleotideSequence("aAgGcCtTuU", false));
198     assertFalse(Comparison.isNucleotideSequence("xAgGcCtTuU", false));
199     assertFalse(Comparison.isNucleotideSequence("aAgGcCtTuUx", false));
200     assertTrue(Comparison.isNucleotideSequence("a A-g.GcCtTuU", true));
201     assertFalse(Comparison.isNucleotideSequence("a A-g.GcCtTuU", false));
202   }
203
204   @Test(groups = { "Functional" })
205   public void testIsSameResidue()
206   {
207     assertTrue(Comparison.isSameResidue('a', 'a', false));
208     assertTrue(Comparison.isSameResidue('a', 'a', true));
209     assertTrue(Comparison.isSameResidue('A', 'a', false));
210     assertTrue(Comparison.isSameResidue('a', 'A', false));
211
212     assertFalse(Comparison.isSameResidue('a', 'A', true));
213     assertFalse(Comparison.isSameResidue('A', 'a', true));
214   }
215 }