X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Futil%2Fmatcher%2FMatcherTest.java;h=cd444ceb649718aa730ae9f1f224d11d128be1ed;hb=57738a1f3c19b1c3a00bd3ac5108f8cd0af32f99;hp=489cdce3c92d0728c6fc15737d5f9a97a1d6a4f0;hpb=61854b0061f5c35c770d9ca1dcf837261e811d99;p=jalview.git diff --git a/test/jalview/util/matcher/MatcherTest.java b/test/jalview/util/matcher/MatcherTest.java index 489cdce..cd444ce 100644 --- a/test/jalview/util/matcher/MatcherTest.java +++ b/test/jalview/util/matcher/MatcherTest.java @@ -3,35 +3,64 @@ 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; +import java.util.Locale; + import org.testng.annotations.Test; +import jalview.util.matcher.Matcher.PatternType; +import junit.extensions.PA; + public class MatcherTest { - @Test + @Test(groups = "Functional") public void testConstructor() { MatcherI m = new Matcher(Condition.Contains, "foo"); assertEquals(m.getCondition(), Condition.Contains); - assertEquals(m.getPattern(), "FOO"); // all comparisons upper-cased - assertEquals(m.getFloatValue(), 0f); + assertEquals(m.getPattern(), "foo"); + assertEquals(PA.getValue(m, "uppercasePattern"), "FOO"); + 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(m.getPattern(), "-1.2f"); + 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 { @@ -48,14 +77,32 @@ 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() } } /** * Tests for float comparison conditions */ - @Test + @Test(groups = "Functional") public void testMatches_float() { /* @@ -77,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")); @@ -93,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")); @@ -107,17 +154,25 @@ public class MatcherTest assertTrue(m.matches("1.9")); } - @Test - public void testMatches_floatNullOrInvalid() + /** + * Verifies that all numeric match conditions fail when applied to non-numeric + * or null values + */ + @Test(groups = "Functional") + 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")); } } } @@ -125,7 +180,7 @@ public class MatcherTest /** * Tests for string comparison conditions */ - @Test + @Test(groups = "Functional") public void testMatches_pattern() { /* @@ -161,48 +216,82 @@ 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)); /* - * a float with a string match condition will be treated as string + * value is present (is not null) + */ + m = new Matcher(Condition.Present, null); + assertTrue(m.matches("benign")); + assertTrue(m.matches("")); + assertFalse(m.matches(null)); + + /* + * value is not present (is null) + */ + m = new Matcher(Condition.NotPresent, null); + assertFalse(m.matches("benign")); + assertFalse(m.matches("")); + assertTrue(m.matches(null)); + + /* + * a number with a string match condition will be treated as string + * (these cases shouldn't arise as the match() method is coded) */ 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)); + assertFalse(m1.matchesLong("-203")); + assertTrue(m1.matchesLong("-4321")); + assertFalse(m1.matchesLong("-203f")); + assertTrue(m1.matchesLong("-4321.0f")); } /** * If a float is passed with a string condition it gets converted to a string */ - @Test + @Test(groups = "Functional") 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")); } - @Test + @Test(groups = "Functional") public void testToString() { + Locale.setDefault(Locale.ENGLISH); + MatcherI m = new Matcher(Condition.LT, 1.2e-6f); - assertEquals(m.toString(), "LT 1.2E-6"); + 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(), "NotMatches 'ABC'"); + assertEquals(m.toString(), "Does not match 'ABC'"); m = new Matcher(Condition.Contains, -1.2f); assertEquals(m.toString(), "Contains '-1.2'"); } - @Test + @Test(groups = "Functional") public void testEquals() { /* @@ -219,7 +308,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)); @@ -233,9 +322,22 @@ 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))); + assertFalse(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 + @Test(groups = "Functional") public void testHashCode() { MatcherI m1 = new Matcher(Condition.NotMatches, "ABC"); @@ -247,4 +349,76 @@ 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")); + assertFalse(m.matches("3")); + // 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")); + } }