test/jalview/util/matcher/MatcherTest.java

   1 package jalview.util.matcher;
   2
   3 import static org.testng.Assert.assertEquals;
   4 import static org.testng.Assert.assertFalse;
   5 import static org.testng.Assert.assertNotEquals;
   6 import static org.testng.Assert.assertTrue;
   7 import static org.testng.Assert.fail;
   8
   9 import org.testng.annotations.Test;
  10
  11 public class MatcherTest
  12 {
  13   @Test(groups = "Functional")
  14   public void testConstructor()
  15   {
  16     MatcherI m = new Matcher(Condition.Contains, "foo");
  17     assertEquals(m.getCondition(), Condition.Contains);
  18     assertEquals(m.getPattern(), "FOO"); // all comparisons upper-cased
  19     assertEquals(m.getFloatValue(), 0f);
  20
  21     m = new Matcher(Condition.GT, -2.1f);
  22     assertEquals(m.getCondition(), Condition.GT);
  23     assertEquals(m.getPattern(), "-2.1");
  24     assertEquals(m.getFloatValue(), -2.1f);
  25
  26     m = new Matcher(Condition.NotContains, "-1.2f");
  27     assertEquals(m.getCondition(), Condition.NotContains);
  28     assertEquals(m.getPattern(), "-1.2F");
  29     assertEquals(m.getFloatValue(), 0f);
  30
  31     m = new Matcher(Condition.GE, "-1.2f");
  32     assertEquals(m.getCondition(), Condition.GE);
  33     assertEquals(m.getPattern(), "-1.2");
  34     assertEquals(m.getFloatValue(), -1.2f);
  35
  36     try
  37     {
  38       new Matcher(null, 0f);
  39       fail("Expected exception");
  40     } catch (NullPointerException e)
  41     {
  42       // expected
  43     }
  44
  45     try
  46     {
  47       new Matcher(Condition.LT, "123,456");
  48       fail("Expected exception");
  49     } catch (NumberFormatException e)
  50     {
  51       // expected
  52     }
  53   }
  54
  55   /**
  56    * Tests for float comparison conditions
  57    */
  58   @Test(groups = "Functional")
  59   public void testMatches_float()
  60   {
  61     /*
  62      * EQUALS test
  63      */
  64     MatcherI m = new Matcher(Condition.EQ, 2f);
  65     assertTrue(m.matches("2"));
  66     assertTrue(m.matches("2.0"));
  67     assertFalse(m.matches("2.01"));
  68
  69     /*
  70      * NOT EQUALS test
  71      */
  72     m = new Matcher(Condition.NE, 2f);
  73     assertFalse(m.matches("2"));
  74     assertFalse(m.matches("2.0"));
  75     assertTrue(m.matches("2.01"));
  76
  77     /*
  78      * >= test
  79      */
  80     m = new Matcher(Condition.GE, 2f);
  81     assertTrue(m.matches("2"));
  82     assertTrue(m.matches("2.1"));
  83     assertFalse(m.matches("1.9"));
  84
  85     /*
  86      * > test
  87      */
  88     m = new Matcher(Condition.GT, 2f);
  89     assertFalse(m.matches("2"));
  90     assertTrue(m.matches("2.1"));
  91     assertFalse(m.matches("1.9"));
  92
  93     /*
  94      * <= test
  95      */
  96     m = new Matcher(Condition.LE, 2f);
  97     assertTrue(m.matches("2"));
  98     assertFalse(m.matches("2.1"));
  99     assertTrue(m.matches("1.9"));
 100
 101     /*
 102      * < test
 103      */
 104     m = new Matcher(Condition.LT, 2f);
 105     assertFalse(m.matches("2"));
 106     assertFalse(m.matches("2.1"));
 107     assertTrue(m.matches("1.9"));
 108   }
 109
 110   @Test(groups = "Functional")
 111   public void testMatches_floatNullOrInvalid()
 112   {
 113     for (Condition cond : Condition.values())
 114     {
 115       if (cond.isNumeric())
 116       {
 117         MatcherI m = new Matcher(cond, 2f);
 118         assertFalse(m.matches(null));
 119         assertFalse(m.matches(""));
 120         assertFalse(m.matches("two"));
 121       }
 122     }
 123   }
 124
 125   /**
 126    * Tests for string comparison conditions
 127    */
 128   @Test(groups = "Functional")
 129   public void testMatches_pattern()
 130   {
 131     /*
 132      * Contains
 133      */
 134     MatcherI m = new Matcher(Condition.Contains, "benign");
 135     assertTrue(m.matches("benign"));
 136     assertTrue(m.matches("MOSTLY BENIGN OBSERVED")); // not case-sensitive
 137     assertFalse(m.matches("pathogenic"));
 138     assertFalse(m.matches(null));
 139
 140     /*
 141      * does not contain
 142      */
 143     m = new Matcher(Condition.NotContains, "benign");
 144     assertFalse(m.matches("benign"));
 145     assertFalse(m.matches("MOSTLY BENIGN OBSERVED")); // not case-sensitive
 146     assertTrue(m.matches("pathogenic"));
 147     assertTrue(m.matches(null)); // null value passes this condition
 148
 149     /*
 150      * matches
 151      */
 152     m = new Matcher(Condition.Matches, "benign");
 153     assertTrue(m.matches("benign"));
 154     assertTrue(m.matches(" Benign ")); // trim before testing
 155     assertFalse(m.matches("MOSTLY BENIGN"));
 156     assertFalse(m.matches("pathogenic"));
 157     assertFalse(m.matches(null));
 158
 159     /*
 160      * does not match
 161      */
 162     m = new Matcher(Condition.NotMatches, "benign");
 163     assertFalse(m.matches("benign"));
 164     assertFalse(m.matches(" Benign ")); // trim before testing
 165     assertTrue(m.matches("MOSTLY BENIGN"));
 166     assertTrue(m.matches("pathogenic"));
 167     assertTrue(m.matches(null));
 168
 169     /*
 170      * value is present (is not null)
 171      */
 172     m = new Matcher(Condition.Present, null);
 173     assertTrue(m.matches("benign"));
 174     assertTrue(m.matches(""));
 175     assertFalse(m.matches(null));
 176
 177     /*
 178      * value is not present (is null)
 179      */
 180     m = new Matcher(Condition.NotPresent, null);
 181     assertFalse(m.matches("benign"));
 182     assertFalse(m.matches(""));
 183     assertTrue(m.matches(null));
 184
 185     /*
 186      * a float with a string match condition will be treated as string
 187      */
 188     Matcher m1 = new Matcher(Condition.Contains, "32");
 189     assertFalse(m1.matches(-203f));
 190     assertTrue(m1.matches(-4321.0f));
 191   }
 192
 193   /**
 194    * If a float is passed with a string condition it gets converted to a string
 195    */
 196   @Test(groups = "Functional")
 197   public void testMatches_floatWithStringCondition()
 198   {
 199     MatcherI m = new Matcher(Condition.Contains, 1.2e-6f);
 200     assertTrue(m.matches("1.2e-6"));
 201
 202     m = new Matcher(Condition.Contains, 0.0000001f);
 203     assertTrue(m.matches("1.0e-7"));
 204     assertTrue(m.matches("1.0E-7"));
 205     assertFalse(m.matches("0.0000001f"));
 206   }
 207
 208   @Test(groups = "Functional")
 209   public void testToString()
 210   {
 211     MatcherI m = new Matcher(Condition.LT, 1.2e-6f);
 212     assertEquals(m.toString(), "LT 1.2E-6");
 213
 214     m = new Matcher(Condition.NotMatches, "ABC");
 215     assertEquals(m.toString(), "NotMatches 'ABC'");
 216
 217     m = new Matcher(Condition.Contains, -1.2f);
 218     assertEquals(m.toString(), "Contains '-1.2'");
 219   }
 220
 221   @Test(groups = "Functional")
 222   public void testEquals()
 223   {
 224     /*
 225      * string condition
 226      */
 227     MatcherI m = new Matcher(Condition.NotMatches, "ABC");
 228     assertFalse(m.equals(null));
 229     assertFalse(m.equals("foo"));
 230     assertTrue(m.equals(m));
 231     assertTrue(m.equals(new Matcher(Condition.NotMatches, "ABC")));
 232     // not case-sensitive:
 233     assertTrue(m.equals(new Matcher(Condition.NotMatches, "abc")));
 234     assertFalse(m.equals(new Matcher(Condition.Matches, "ABC")));
 235     assertFalse(m.equals(new Matcher(Condition.NotMatches, "def")));
 236
 237     /*
 238      * numeric conditions
 239      */
 240     m = new Matcher(Condition.LT, -1f);
 241     assertFalse(m.equals(null));
 242     assertFalse(m.equals("foo"));
 243     assertTrue(m.equals(m));
 244     assertTrue(m.equals(new Matcher(Condition.LT, -1f)));
 245     assertTrue(m.equals(new Matcher(Condition.LT, "-1f")));
 246     assertTrue(m.equals(new Matcher(Condition.LT, "-1.00f")));
 247     assertFalse(m.equals(new Matcher(Condition.LE, -1f)));
 248     assertFalse(m.equals(new Matcher(Condition.GE, -1f)));
 249     assertFalse(m.equals(new Matcher(Condition.NE, -1f)));
 250     assertFalse(m.equals(new Matcher(Condition.LT, 1f)));
 251     assertFalse(m.equals(new Matcher(Condition.LT, -1.1f)));
 252   }
 253
 254   @Test(groups = "Functional")
 255   public void testHashCode()
 256   {
 257     MatcherI m1 = new Matcher(Condition.NotMatches, "ABC");
 258     MatcherI m2 = new Matcher(Condition.NotMatches, "ABC");
 259     MatcherI m3 = new Matcher(Condition.NotMatches, "AB");
 260     MatcherI m4 = new Matcher(Condition.Matches, "ABC");
 261     assertEquals(m1.hashCode(), m2.hashCode());
 262     assertNotEquals(m1.hashCode(), m3.hashCode());
 263     assertNotEquals(m1.hashCode(), m4.hashCode());
 264     assertNotEquals(m3.hashCode(), m4.hashCode());
 265   }
 266 }