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
  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
  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
 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
 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      * a float with a string match condition will be treated as string
 171      */
 172     Matcher m1 = new Matcher(Condition.Contains, "32");
 173     assertFalse(m1.matches(-203f));
 174     assertTrue(m1.matches(-4321.0f));
 175   }
 176
 177   /**
 178    * If a float is passed with a string condition it gets converted to a string
 179    */
 180   @Test
 181   public void testMatches_floatWithStringCondition()
 182   {
 183     MatcherI m = new Matcher(Condition.Contains, 1.2e-6f);
 184     assertTrue(m.matches("1.2e-6"));
 185
 186     m = new Matcher(Condition.Contains, 0.0000001f);
 187     assertTrue(m.matches("1.0e-7"));
 188     assertTrue(m.matches("1.0E-7"));
 189     assertFalse(m.matches("0.0000001f"));
 190   }
 191
 192   @Test
 193   public void testToString()
 194   {
 195     MatcherI m = new Matcher(Condition.LT, 1.2e-6f);
 196     assertEquals(m.toString(), "LT 1.2E-6");
 197
 198     m = new Matcher(Condition.NotMatches, "ABC");
 199     assertEquals(m.toString(), "NotMatches 'ABC'");
 200
 201     m = new Matcher(Condition.Contains, -1.2f);
 202     assertEquals(m.toString(), "Contains '-1.2'");
 203   }
 204
 205   @Test
 206   public void testEquals()
 207   {
 208     /*
 209      * string condition
 210      */
 211     MatcherI m = new Matcher(Condition.NotMatches, "ABC");
 212     assertFalse(m.equals(null));
 213     assertFalse(m.equals("foo"));
 214     assertTrue(m.equals(m));
 215     assertTrue(m.equals(new Matcher(Condition.NotMatches, "ABC")));
 216     // not case-sensitive:
 217     assertTrue(m.equals(new Matcher(Condition.NotMatches, "abc")));
 218     assertFalse(m.equals(new Matcher(Condition.Matches, "ABC")));
 219     assertFalse(m.equals(new Matcher(Condition.NotMatches, "def")));
 220
 221     /*
 222      * numeric conditions
 223      */
 224     m = new Matcher(Condition.LT, -1f);
 225     assertFalse(m.equals(null));
 226     assertFalse(m.equals("foo"));
 227     assertTrue(m.equals(m));
 228     assertTrue(m.equals(new Matcher(Condition.LT, -1f)));
 229     assertTrue(m.equals(new Matcher(Condition.LT, "-1f")));
 230     assertTrue(m.equals(new Matcher(Condition.LT, "-1.00f")));
 231     assertFalse(m.equals(new Matcher(Condition.LE, -1f)));
 232     assertFalse(m.equals(new Matcher(Condition.GE, -1f)));
 233     assertFalse(m.equals(new Matcher(Condition.NE, -1f)));
 234     assertFalse(m.equals(new Matcher(Condition.LT, 1f)));
 235     assertFalse(m.equals(new Matcher(Condition.LT, -1.1f)));
 236   }
 237
 238   @Test
 239   public void testHashCode()
 240   {
 241     MatcherI m1 = new Matcher(Condition.NotMatches, "ABC");
 242     MatcherI m2 = new Matcher(Condition.NotMatches, "ABC");
 243     MatcherI m3 = new Matcher(Condition.NotMatches, "AB");
 244     MatcherI m4 = new Matcher(Condition.Matches, "ABC");
 245     assertEquals(m1.hashCode(), m2.hashCode());
 246     assertNotEquals(m1.hashCode(), m3.hashCode());
 247     assertNotEquals(m1.hashCode(), m4.hashCode());
 248     assertNotEquals(m3.hashCode(), m4.hashCode());
 249   }
 250 }