JAL-2292 Unit test for utility method for comparing two chars

[jalview.git] / test / jalview / util / ComparisonTest.java

diff --git a/test/jalview/util/ComparisonTest.java b/test/jalview/util/ComparisonTest.java
index 67c81ad..bce34d4 100644 (file)
--- a/test/jalview/util/ComparisonTest.java
+++ b/test/jalview/util/ComparisonTest.java
@@ -49,7 +49,7 @@ public class ComparisonTest
    * AGCTU. Test is not case-sensitive and ignores gaps.
    */
   @Test(groups = { "Functional" })
-  public void testIsNucleotide()
+  public void testIsNucleotide_sequences()
   {
     SequenceI seq = new Sequence("eightypercent", "agctuAGCPV");
     assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));
@@ -104,7 +104,7 @@ public class ComparisonTest
    * Test the percentage identity calculation for two sequences
    */
   @Test(groups = { "Functional" })
-  public void testPID()
+  public void testPID_includingGaps()
   {
     String seq1 = "ABCDEF";
     String seq2 = "abcdef";
@@ -126,18 +126,78 @@ public class ComparisonTest
     assertEquals(90f, Comparison.PID(seq1, seq2), 0.001f);
 
     // don't match gap-residue, match gap-gap: 7/10 identical
-    assertEquals(70f,
-            Comparison.PID(seq1, seq2, 0, seq1.length(), false, false),
+    assertEquals(70f, Comparison.PID(seq1, seq2, 0, length, false, false),
             0.001f);
+  }
+
+  @Test(groups = { "Functional" })
+  public void testIsNucleotide()
+  {
+    assertTrue(Comparison.isNucleotide('a'));
+    assertTrue(Comparison.isNucleotide('A'));
+    assertTrue(Comparison.isNucleotide('c'));
+    assertTrue(Comparison.isNucleotide('C'));
+    assertTrue(Comparison.isNucleotide('g'));
+    assertTrue(Comparison.isNucleotide('G'));
+    assertTrue(Comparison.isNucleotide('t'));
+    assertTrue(Comparison.isNucleotide('T'));
+    assertTrue(Comparison.isNucleotide('u'));
+    assertTrue(Comparison.isNucleotide('U'));
+    assertFalse(Comparison.isNucleotide('-'));
+    assertFalse(Comparison.isNucleotide('P'));
+  }
+
+  /**
+   * Test the percentage identity calculation for two sequences
+   */
+  @Test(groups = { "Functional" })
+  public void testPID_ungappedOnly()
+  {
+    // 5 identical, 2 gap-gap, 2 gap-residue, 1 mismatch
+    String seq1 = "a--b-cdefh";
+    String seq2 = "a---bcdefg";
+    int length = seq1.length();
 
+    /*
+     * As currently coded, 'ungappedOnly' ignores gap-residue but counts
+     * gap-gap. Is this a bug - should gap-gap also be ignored, giving a PID of
+     * 5/6?
+     * 
+     * Note also there is no variant of the calculation that penalises
+     * gap-residue i.e. counts it as a mismatch. This would give a score of 5/8
+     * (if we ignore gap-gap) or 5/10 (if we count gap-gap as a match).
+     */
     // match gap-residue, match gap-gap: 7/8 identical
-    assertEquals(87.5f,
-            Comparison.PID(seq1, seq2, 0, seq1.length(), true, true),
+    assertEquals(87.5f, Comparison.PID(seq1, seq2, 0, length, true, true),
             0.001f);
 
     // don't match gap-residue with 'ungapped only' - same as above
-    assertEquals(87.5f,
-            Comparison.PID(seq1, seq2, 0, seq1.length(), false, true),
+    assertEquals(87.5f, Comparison.PID(seq1, seq2, 0, length, false, true),
             0.001f);
   }
+
+  @Test(groups = { "Functional" })
+  public void testIsNucleotideSequence()
+  {
+    assertFalse(Comparison.isNucleotideSequence(null, true));
+    assertTrue(Comparison.isNucleotideSequence("", true));
+    assertTrue(Comparison.isNucleotideSequence("aAgGcCtTuU", true));
+    assertTrue(Comparison.isNucleotideSequence("aAgGcCtTuU", false));
+    assertFalse(Comparison.isNucleotideSequence("xAgGcCtTuU", false));
+    assertFalse(Comparison.isNucleotideSequence("aAgGcCtTuUx", false));
+    assertTrue(Comparison.isNucleotideSequence("a A-g.GcCtTuU", true));
+    assertFalse(Comparison.isNucleotideSequence("a A-g.GcCtTuU", false));
+  }
+
+  @Test(groups = { "Functional" })
+  public void compareCharsTest()
+  {
+    assertTrue(Comparison.compareChars('a', 'a', false));
+    assertTrue(Comparison.compareChars('a', 'a', true));
+    assertTrue(Comparison.compareChars('A', 'a', false));
+    assertTrue(Comparison.compareChars('a', 'A', false));
+
+    assertFalse(Comparison.compareChars('a', 'A', true));
+    assertFalse(Comparison.compareChars('A', 'a', true));
+  }
 }