Merge branch 'documentation/JAL-3407_2.11.1_release' into develop

[jalview.git] / test / jalview / datamodel / features / FeatureMatcherTest.java

diff --git a/test/jalview/datamodel/features/FeatureMatcherTest.java b/test/jalview/datamodel/features/FeatureMatcherTest.java
index 62b03a3..f403a57 100644 (file)
--- a/test/jalview/datamodel/features/FeatureMatcherTest.java
+++ b/test/jalview/datamodel/features/FeatureMatcherTest.java
@@ -3,19 +3,23 @@ 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.MessageManager;
-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,
@@ -62,7 +66,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,
@@ -87,7 +91,8 @@ 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()
   {
     /*
@@ -127,7 +132,7 @@ public class FeatureMatcherTest
     assertFalse(fm.matches(sf));
   }
 
-  @Test
+  @Test(groups = "Functional")
   public void testToString()
   {
     Locale.setDefault(Locale.ENGLISH);
@@ -162,7 +167,7 @@ public class FeatureMatcherTest
             MessageManager.getString("label.score") + " >= 12.2");
   }
 
-  @Test
+  @Test(groups = "Functional")
   public void testGetAttribute()
   {
     FeatureMatcherI fm = FeatureMatcher.byAttribute(Condition.GE, "-2",
@@ -184,7 +189,17 @@ public class FeatureMatcherTest
     assertNull(FeatureMatcher.byScore(Condition.LE, "-1").getAttribute());
   }
 
-  @Test
+  @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")
@@ -194,7 +209,7 @@ public class FeatureMatcherTest
             .isByLabel());
   }
 
-  @Test
+  @Test(groups = "Functional")
   public void testIsByScore()
   {
     assertFalse(FeatureMatcher.byLabel(Condition.NotContains, "foo")
@@ -204,13 +219,154 @@ public class FeatureMatcherTest
             .isByScore());
   }
 
-  @Test
+  @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");
+  }
 }