JAL-3574 Matcher with integer/long value pattern (e.g. VCF POS locus)

[jalview.git] / test / jalview / util / matcher / MatcherTest.java

diff --git a/test/jalview/util/matcher/MatcherTest.java b/test/jalview/util/matcher/MatcherTest.java
index a47fb60..d29f000 100644 (file)
--- a/test/jalview/util/matcher/MatcherTest.java
+++ b/test/jalview/util/matcher/MatcherTest.java
@@ -3,6 +3,7 @@ package jalview.util.matcher;
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertFalse;
 import static org.testng.Assert.assertNotEquals;
+import static org.testng.Assert.assertSame;
 import static org.testng.Assert.assertTrue;
 import static org.testng.Assert.fail;
 
@@ -10,6 +11,7 @@ import java.util.Locale;
 
 import org.testng.annotations.Test;
 
+import jalview.util.matcher.Matcher.PatternType;
 import junit.extensions.PA;
 
 public class MatcherTest
@@ -21,22 +23,44 @@ public class MatcherTest
     assertEquals(m.getCondition(), Condition.Contains);
     assertEquals(m.getPattern(), "foo");
     assertEquals(PA.getValue(m, "uppercasePattern"), "FOO");
-    assertEquals(m.getFloatValue(), 0f);
+    assertEquals(PA.getValue(m, "floatValue"), 0f);
+    assertEquals(PA.getValue(m, "longValue"), 0L);
+    assertSame(PA.getValue(m, "patternType"), PatternType.String);
 
     m = new Matcher(Condition.GT, -2.1f);
     assertEquals(m.getCondition(), Condition.GT);
     assertEquals(m.getPattern(), "-2.1");
-    assertEquals(m.getFloatValue(), -2.1f);
+    assertEquals(PA.getValue(m, "floatValue"), -2.1f);
+    assertEquals(PA.getValue(m, "longValue"), 0L);
+    assertSame(PA.getValue(m, "patternType"), PatternType.Float);
 
     m = new Matcher(Condition.NotContains, "-1.2f");
     assertEquals(m.getCondition(), Condition.NotContains);
     assertEquals(m.getPattern(), "-1.2f");
-    assertEquals(m.getFloatValue(), 0f);
+    assertEquals(PA.getValue(m, "floatValue"), 0f);
+    assertEquals(PA.getValue(m, "longValue"), 0L);
+    assertSame(PA.getValue(m, "patternType"), PatternType.String);
 
     m = new Matcher(Condition.GE, "-1.2f");
     assertEquals(m.getCondition(), Condition.GE);
     assertEquals(m.getPattern(), "-1.2");
-    assertEquals(m.getFloatValue(), -1.2f);
+    assertEquals(PA.getValue(m, "floatValue"), -1.2f);
+    assertEquals(PA.getValue(m, "longValue"), 0L);
+    assertSame(PA.getValue(m, "patternType"), PatternType.Float);
+
+    m = new Matcher(Condition.GE, "113890813");
+    assertEquals(m.getCondition(), Condition.GE);
+    assertEquals(m.getPattern(), "113890813");
+    assertEquals(PA.getValue(m, "floatValue"), 0f);
+    assertEquals(PA.getValue(m, "longValue"), 113890813L);
+    assertSame(PA.getValue(m, "patternType"), PatternType.Integer);
+
+    m = new Matcher(Condition.GE, "-987f");
+    assertEquals(m.getCondition(), Condition.GE);
+    assertEquals(m.getPattern(), "-987.0");
+    assertEquals(PA.getValue(m, "floatValue"), -987f);
+    assertEquals(PA.getValue(m, "longValue"), 0L);
+    assertSame(PA.getValue(m, "patternType"), PatternType.Float);
 
     try
     {
@@ -53,7 +77,25 @@ public class MatcherTest
       fail("Expected exception");
     } catch (NumberFormatException e)
     {
-      // expected
+      // expected - see Long.valueOf()
+    }
+
+    try
+    {
+      new Matcher(Condition.LT, "123_456");
+      fail("Expected exception");
+    } catch (NumberFormatException e)
+    {
+      // expected - see Long.valueOf()
+    }
+
+    try
+    {
+      new Matcher(Condition.LT, "123456L");
+      fail("Expected exception");
+    } catch (NumberFormatException e)
+    {
+      // expected - see Long.valueOf()
     }
   }
 
@@ -82,7 +124,7 @@ public class MatcherTest
     /*
      * >= test
      */
-    m = new Matcher(Condition.GE, 2f);
+    m = new Matcher(Condition.GE, "2f");
     assertTrue(m.matches("2"));
     assertTrue(m.matches("2.1"));
     assertFalse(m.matches("1.9"));
@@ -98,7 +140,7 @@ public class MatcherTest
     /*
      * <= test
      */
-    m = new Matcher(Condition.LE, 2f);
+    m = new Matcher(Condition.LE, "2.0f");
     assertTrue(m.matches("2"));
     assertFalse(m.matches("2.1"));
     assertTrue(m.matches("1.9"));
@@ -112,17 +154,25 @@ public class MatcherTest
     assertTrue(m.matches("1.9"));
   }
 
+  /**
+   * Verifies that all numeric match conditions fail when applied to non-numeric
+   * or null values
+   */
   @Test(groups = "Functional")
-  public void testMatches_floatNullOrInvalid()
+  public void testNumericMatch_nullOrInvalidValue()
   {
     for (Condition cond : Condition.values())
     {
       if (cond.isNumeric())
       {
-        MatcherI m = new Matcher(cond, 2f);
-        assertFalse(m.matches(null));
-        assertFalse(m.matches(""));
-        assertFalse(m.matches("two"));
+        MatcherI m1 = new Matcher(cond, 2.1f);
+        MatcherI m2 = new Matcher(cond, 2345L);
+        assertFalse(m1.matches(null));
+        assertFalse(m1.matches(""));
+        assertFalse(m1.matches("two"));
+        assertFalse(m2.matches(null));
+        assertFalse(m2.matches(""));
+        assertFalse(m2.matches("two"));
       }
     }
   }
@@ -166,7 +216,7 @@ public class MatcherTest
      */
     m = new Matcher(Condition.NotMatches, "benign");
     assertFalse(m.matches("benign"));
-    assertFalse(m.matches(" Benign ")); // trim before testing
+    assertFalse(m.matches(" Benign ")); // trimmed before testing
     assertTrue(m.matches("MOSTLY BENIGN"));
     assertTrue(m.matches("pathogenic"));
     assertTrue(m.matches(null));
@@ -188,11 +238,13 @@ public class MatcherTest
     assertTrue(m.matches(null));
 
     /*
-     * a float with a string match condition will be treated as string
+     * a number with a string match condition will be treated as string
      */
     Matcher m1 = new Matcher(Condition.Contains, "32");
-    assertFalse(m1.matches(-203f));
-    assertTrue(m1.matches(-4321.0f));
+    assertFalse(m1.matchesFloat("-203f", 0f));
+    assertTrue(m1.matchesFloat("-4321.0f", 0f));
+    assertFalse(m1.matchesFloat("-203", 0f));
+    assertTrue(m1.matchesFloat("-4321", 0f));
   }
 
   /**
@@ -202,9 +254,15 @@ public class MatcherTest
   public void testMatches_floatWithStringCondition()
   {
     MatcherI m = new Matcher(Condition.Contains, 1.2e-6f);
+    assertEquals(m.getPattern(), "1.2E-6");
+    assertEquals(PA.getValue(m, "uppercasePattern"), "1.2E-6");
+    assertEquals(PA.getValue(m, "floatValue"), 0f);
+    assertEquals(PA.getValue(m, "longValue"), 0L);
+    assertSame(PA.getValue(m, "patternType"), PatternType.String);
     assertTrue(m.matches("1.2e-6"));
 
     m = new Matcher(Condition.Contains, 0.0000001f);
+    assertEquals(m.getPattern(), "1.0E-7");
     assertTrue(m.matches("1.0e-7"));
     assertTrue(m.matches("1.0E-7"));
     assertFalse(m.matches("0.0000001f"));
@@ -218,6 +276,9 @@ public class MatcherTest
     MatcherI m = new Matcher(Condition.LT, 1.2e-6f);
     assertEquals(m.toString(), "< 1.2E-6");
 
+    m = new Matcher(Condition.GE, "20200413");
+    assertEquals(m.toString(), ">= 20200413");
+
     m = new Matcher(Condition.NotMatches, "ABC");
     assertEquals(m.toString(), "Does not match 'ABC'");
 
@@ -242,7 +303,7 @@ public class MatcherTest
     assertFalse(m.equals(new Matcher(Condition.NotMatches, "def")));
 
     /*
-     * numeric conditions
+     * numeric conditions - float values
      */
     m = new Matcher(Condition.LT, -1f);
     assertFalse(m.equals(null));
@@ -256,6 +317,18 @@ public class MatcherTest
     assertFalse(m.equals(new Matcher(Condition.NE, -1f)));
     assertFalse(m.equals(new Matcher(Condition.LT, 1f)));
     assertFalse(m.equals(new Matcher(Condition.LT, -1.1f)));
+
+    /*
+     * numeric conditions - integer values
+     */
+    m = new Matcher(Condition.LT, -123456);
+    assertFalse(m.equals(null));
+    assertFalse(m.equals("foo"));
+    assertTrue(m.equals(m));
+    assertTrue(m.equals(new Matcher(Condition.LT, -123456)));
+    assertTrue(m.equals(new Matcher(Condition.LT, "-123456")));
+    assertFalse(m.equals(new Matcher(Condition.LT, -123456f)));
+    assertFalse(m.equals(new Matcher(Condition.LT, "-123456f")));
   }
 
   @Test(groups = "Functional")
@@ -270,4 +343,75 @@ public class MatcherTest
     assertNotEquals(m1.hashCode(), m4.hashCode());
     assertNotEquals(m3.hashCode(), m4.hashCode());
   }
+
+  /**
+   * Tests for integer comparison conditions
+   */
+  @Test(groups = "Functional")
+  public void testMatches_long()
+  {
+    /*
+     * EQUALS test
+     */
+    MatcherI m = new Matcher(Condition.EQ, 2);
+    assertTrue(m.matches("2"));
+    assertTrue(m.matches("+2"));
+    // a float value may be passed to an integer matcher
+    assertTrue(m.matches("2.0"));
+    assertTrue(m.matches("2.000000f"));
+    assertFalse(m.matches("2.01"));
+  
+    /*
+     * NOT EQUALS test
+     */
+    m = new Matcher(Condition.NE, 123);
+    assertFalse(m.matches("123"));
+    assertFalse(m.matches("123.0"));
+    assertTrue(m.matches("-123"));
+  
+    /*
+     * >= test
+     */
+    m = new Matcher(Condition.GE, "113890813");
+    assertTrue(m.matches("113890813"));
+    assertTrue(m.matches("113890814"));
+    assertFalse(m.matches("-113890813"));
+  
+    /*
+     * > test
+     */
+    m = new Matcher(Condition.GT, 113890813);
+    assertFalse(m.matches("113890813"));
+    assertTrue(m.matches("113890814"));
+  
+    /*
+     * <= test
+     */
+    m = new Matcher(Condition.LE, "113890813");
+    assertTrue(m.matches("113890813"));
+    assertFalse(m.matches("113890814"));
+    assertTrue(m.matches("113890812"));
+  
+    /*
+     * < test
+     */
+    m = new Matcher(Condition.LT, 113890813);
+    assertFalse(m.matches("113890813"));
+    assertFalse(m.matches("113890814"));
+    assertTrue(m.matches("113890812"));
+  }
+
+  /**
+   * Tests comparing a float value with an integer condition
+   */
+  @Test(groups = "Functional")
+  public void testMatches_floatValueIntegerCondition()
+  {
+    MatcherI m = new Matcher(Condition.GT, 1234);
+    assertEquals(PA.getValue(m, "longValue"), 1234L);
+    assertSame(PA.getValue(m, "patternType"), PatternType.Integer);
+    assertTrue(m.matches("1235"));
+    assertTrue(m.matches("9867.345"));
+    assertTrue(m.matches("9867.345f"));
+  }
 }