X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2Ffeatures%2FFeatureMatcherTest.java;h=117b6e9355596fdc4b5f58324be414df3a8741ff;hb=3b0aa1a072e9c18ce9b7040204584ce810803bb6;hp=f4e9351c50a2b7cbf72e82b7e6b301bb325a0fc3;hpb=ef14d83cfe8ca0bb2271d50d638516cdc90c2b8b;p=jalview.git diff --git a/test/jalview/datamodel/features/FeatureMatcherTest.java b/test/jalview/datamodel/features/FeatureMatcherTest.java index f4e9351..117b6e9 100644 --- a/test/jalview/datamodel/features/FeatureMatcherTest.java +++ b/test/jalview/datamodel/features/FeatureMatcherTest.java @@ -1,17 +1,45 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors + * + * This file is part of Jalview. + * + * Jalview is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * + * Jalview is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ package jalview.datamodel.features; import static org.testng.Assert.assertEquals; import static org.testng.Assert.assertFalse; +import static org.testng.Assert.assertNull; +import static org.testng.Assert.assertSame; import static org.testng.Assert.assertTrue; -import jalview.datamodel.SequenceFeature; -import jalview.util.matcher.Condition; +import java.util.Locale; import org.testng.annotations.Test; +import jalview.datamodel.SequenceFeature; +import jalview.util.MessageManager; +import jalview.util.matcher.Condition; +import jalview.util.matcher.Matcher; +import jalview.util.matcher.MatcherI; +import junit.extensions.PA; + public class FeatureMatcherTest { - @Test + @Test(groups = "Functional") public void testMatches_byLabel() { SequenceFeature sf = new SequenceFeature("Cath", "this is my label", 11, @@ -58,7 +86,7 @@ public class FeatureMatcherTest FeatureMatcher.byLabel(Condition.NotPresent, "").matches(sf)); } - @Test + @Test(groups = "Functional") public void testMatches_byScore() { SequenceFeature sf = new SequenceFeature("Cath", "this is my label", 11, @@ -83,14 +111,15 @@ public class FeatureMatcherTest assertFalse(FeatureMatcher.byScore(Condition.GT, "3.2").matches(sf)); assertTrue(FeatureMatcher.byScore(Condition.GT, "2.2").matches(sf)); } - @Test + + @Test(groups = "Functional") public void testMatches_byAttribute() { /* * a numeric matcher - MatcherTest covers more conditions */ - FeatureMatcherI fm = FeatureMatcher - .byAttribute(Condition.GE, "-2", "AF"); + FeatureMatcherI fm = FeatureMatcher.byAttribute(Condition.GE, "-2", + "AF"); SequenceFeature sf = new SequenceFeature("Cath", "desc", 11, 12, "grp"); assertFalse(fm.matches(sf)); sf.setValue("AF", "foobar"); @@ -123,9 +152,11 @@ public class FeatureMatcherTest assertFalse(fm.matches(sf)); } - @Test + @Test(groups = "Functional") public void testToString() { + Locale.setDefault(Locale.ENGLISH); + /* * toString uses the i18n translation of the enum conditions */ @@ -137,33 +168,225 @@ public class FeatureMatcherTest * Present / NotPresent omit the value pattern */ fm = FeatureMatcher.byAttribute(Condition.Present, "", "AF"); - assertEquals(fm.toString(), "AF Is present"); + assertEquals(fm.toString(), "AF is present"); fm = FeatureMatcher.byAttribute(Condition.NotPresent, "", "AF"); - assertEquals(fm.toString(), "AF Is not present"); + assertEquals(fm.toString(), "AF is not present"); + + /* + * by Label + */ + fm = FeatureMatcher.byLabel(Condition.Matches, "foobar"); + assertEquals(fm.toString(), + MessageManager.getString("label.label") + " matches 'foobar'"); + + /* + * by Score + */ + fm = FeatureMatcher.byScore(Condition.GE, "12.2"); + assertEquals(fm.toString(), + MessageManager.getString("label.score") + " >= 12.2"); } - @Test - public void testGetKey() + @Test(groups = "Functional") + public void testGetAttribute() { FeatureMatcherI fm = FeatureMatcher.byAttribute(Condition.GE, "-2", "AF"); - assertEquals(fm.getKey(), new String[] { "AF" }); + assertEquals(fm.getAttribute(), new String[] { "AF" }); /* * compound key (attribute / subattribute) */ fm = FeatureMatcher.byAttribute(Condition.GE, "-2F", "CSQ", "Consequence"); - assertEquals(fm.getKey(), new String[] { "CSQ", "Consequence" }); + assertEquals(fm.getAttribute(), new String[] { "CSQ", "Consequence" }); + + /* + * answers null if match is by Label or by Score + */ + assertNull(FeatureMatcher.byLabel(Condition.NotContains, "foo") + .getAttribute()); + assertNull(FeatureMatcher.byScore(Condition.LE, "-1").getAttribute()); + } + + @Test(groups = "Functional") + public void testIsByAttribute() + { + assertFalse(FeatureMatcher.byLabel(Condition.NotContains, "foo") + .isByAttribute()); + assertFalse(FeatureMatcher.byScore(Condition.LE, "-1").isByAttribute()); + assertTrue(FeatureMatcher.byAttribute(Condition.LE, "-1", "AC") + .isByAttribute()); + } + + @Test(groups = "Functional") + public void testIsByLabel() + { + assertTrue(FeatureMatcher.byLabel(Condition.NotContains, "foo") + .isByLabel()); + assertFalse(FeatureMatcher.byScore(Condition.LE, "-1").isByLabel()); + assertFalse(FeatureMatcher.byAttribute(Condition.LE, "-1", "AC") + .isByLabel()); } - @Test + @Test(groups = "Functional") + public void testIsByScore() + { + assertFalse(FeatureMatcher.byLabel(Condition.NotContains, "foo") + .isByScore()); + assertTrue(FeatureMatcher.byScore(Condition.LE, "-1").isByScore()); + assertFalse(FeatureMatcher.byAttribute(Condition.LE, "-1", "AC") + .isByScore()); + } + + @Test(groups = "Functional") public void testGetMatcher() { FeatureMatcherI fm = FeatureMatcher.byAttribute(Condition.GE, "-2f", "AF"); assertEquals(fm.getMatcher().getCondition(), Condition.GE); - assertEquals(fm.getMatcher().getFloatValue(), -2F); + assertEquals(PA.getValue(fm.getMatcher(), "floatValue"), -2F); assertEquals(fm.getMatcher().getPattern(), "-2.0"); } + + @Test(groups = "Functional") + public void testFromString() + { + FeatureMatcherI fm = FeatureMatcher.fromString("'AF' LT 1.2"); + assertFalse(fm.isByLabel()); + assertFalse(fm.isByScore()); + assertEquals(fm.getAttribute(), new String[] { "AF" }); + MatcherI matcher = fm.getMatcher(); + assertSame(Condition.LT, matcher.getCondition()); + assertEquals(PA.getValue(matcher, "floatValue"), 1.2f); + assertSame(PA.getValue(matcher, "patternType"), + Matcher.PatternType.Float); + assertEquals(matcher.getPattern(), "1.2"); + + // quotes are optional, condition is not case sensitive + fm = FeatureMatcher.fromString("AF lt '1.2'"); + matcher = fm.getMatcher(); + assertFalse(fm.isByLabel()); + assertFalse(fm.isByScore()); + assertEquals(fm.getAttribute(), new String[] { "AF" }); + assertSame(Condition.LT, matcher.getCondition()); + assertEquals(PA.getValue(matcher, "floatValue"), 1.2F); + assertEquals(matcher.getPattern(), "1.2"); + + fm = FeatureMatcher.fromString("'AF' Present"); + matcher = fm.getMatcher(); + assertFalse(fm.isByLabel()); + assertFalse(fm.isByScore()); + assertEquals(fm.getAttribute(), new String[] { "AF" }); + assertSame(Condition.Present, matcher.getCondition()); + assertSame(PA.getValue(matcher, "patternType"), + Matcher.PatternType.String); + + fm = FeatureMatcher.fromString("CSQ:Consequence contains damaging"); + matcher = fm.getMatcher(); + assertFalse(fm.isByLabel()); + assertFalse(fm.isByScore()); + assertEquals(fm.getAttribute(), new String[] { "CSQ", "Consequence" }); + assertSame(Condition.Contains, matcher.getCondition()); + assertEquals(matcher.getPattern(), "damaging"); + + // keyword Label is not case sensitive + fm = FeatureMatcher.fromString("LABEL Matches 'foobar'"); + matcher = fm.getMatcher(); + assertTrue(fm.isByLabel()); + assertFalse(fm.isByScore()); + assertNull(fm.getAttribute()); + assertSame(Condition.Matches, matcher.getCondition()); + assertEquals(matcher.getPattern(), "foobar"); + + fm = FeatureMatcher.fromString("'Label' matches 'foo bar'"); + matcher = fm.getMatcher(); + assertTrue(fm.isByLabel()); + assertFalse(fm.isByScore()); + assertNull(fm.getAttribute()); + assertSame(Condition.Matches, matcher.getCondition()); + assertEquals(matcher.getPattern(), "foo bar"); + + // quotes optional on pattern + fm = FeatureMatcher.fromString("'Label' matches foo bar"); + matcher = fm.getMatcher(); + assertTrue(fm.isByLabel()); + assertFalse(fm.isByScore()); + assertNull(fm.getAttribute()); + assertSame(Condition.Matches, matcher.getCondition()); + assertEquals(matcher.getPattern(), "foo bar"); + + // integer condition + fm = FeatureMatcher.fromString("Score GE 12"); + matcher = fm.getMatcher(); + assertFalse(fm.isByLabel()); + assertTrue(fm.isByScore()); + assertNull(fm.getAttribute()); + assertSame(Condition.GE, matcher.getCondition()); + assertEquals(matcher.getPattern(), "12"); + assertEquals(PA.getValue(matcher, "floatValue"), 0f); + assertEquals(PA.getValue(matcher, "longValue"), 12L); + assertSame(PA.getValue(matcher, "patternType"), + Matcher.PatternType.Integer); + + // keyword Score is not case sensitive + fm = FeatureMatcher.fromString("'SCORE' ge '12.2'"); + matcher = fm.getMatcher(); + assertFalse(fm.isByLabel()); + assertTrue(fm.isByScore()); + assertNull(fm.getAttribute()); + assertSame(Condition.GE, matcher.getCondition()); + assertEquals(matcher.getPattern(), "12.2"); + assertEquals(PA.getValue(matcher, "floatValue"), 12.2F); + + // invalid numeric pattern + assertNull(FeatureMatcher.fromString("Score eq twelve")); + // unbalanced opening quote + assertNull(FeatureMatcher.fromString("'Score ge 12.2")); + // unbalanced pattern quote + assertNull(FeatureMatcher.fromString("'Score' ge '12.2")); + // pattern missing + assertNull(FeatureMatcher.fromString("Score ge")); + // condition and pattern missing + assertNull(FeatureMatcher.fromString("Score")); + // everything missing + assertNull(FeatureMatcher.fromString("")); + } + + /** + * Tests for toStableString which (unlike toString) does not i18n the + * conditions + */ + @Test(groups = "Functional") + public void testToStableString() + { + // attribute name not quoted unless it contains space + FeatureMatcherI fm = FeatureMatcher.byAttribute(Condition.LT, "1.2", + "AF"); + assertEquals(fm.toStableString(), "AF LT 1.2"); + + /* + * Present / NotPresent omit the value pattern + */ + fm = FeatureMatcher.byAttribute(Condition.Present, "", "AF"); + assertEquals(fm.toStableString(), "AF Present"); + fm = FeatureMatcher.byAttribute(Condition.NotPresent, "", "AF"); + assertEquals(fm.toStableString(), "AF NotPresent"); + + /* + * by Label + * pattern not quoted unless it contains space + */ + fm = FeatureMatcher.byLabel(Condition.Matches, "foobar"); + assertEquals(fm.toStableString(), "Label Matches foobar"); + + fm = FeatureMatcher.byLabel(Condition.Matches, "foo bar"); + assertEquals(fm.toStableString(), "Label Matches 'foo bar'"); + + /* + * by Score + */ + fm = FeatureMatcher.byScore(Condition.GE, "12.2"); + assertEquals(fm.toStableString(), "Score GE 12.2"); + } }