Exemplo n.º 1
0
  @Test
  public void testStringEquals() throws Exception {
    // First, simple test of string equality and inequality
    filter = FilterImpl.createFilter(new SimpleString("MyString='astring'"));

    doPutStringProperty("MyString", "astring");
    Assert.assertTrue(filter.match(message));

    doPutStringProperty("MyString", "NOTastring");
    Assert.assertTrue(!filter.match(message));

    // test empty string
    filter = FilterImpl.createFilter(new SimpleString("MyString=''"));

    doPutStringProperty("MyString", "");
    Assert.assertTrue("test 1", filter.match(message));

    doPutStringProperty("MyString", "NOTastring");
    Assert.assertTrue("test 2", !filter.match(message));

    // test literal apostrophes (which are escaped using two apostrophes
    // in selectors)
    filter = FilterImpl.createFilter(new SimpleString("MyString='test JBoss''s filter'"));

    // note: apostrophes are not escaped in string properties
    doPutStringProperty("MyString", "test JBoss's filter");
    // this test fails -- bug 530120
    // assertTrue("test 3", filter.match(message));

    doPutStringProperty("MyString", "NOTastring");
    Assert.assertTrue("test 4", !filter.match(message));
  }
Exemplo n.º 2
0
 @Test
 public void testNullFilter() throws Exception {
   Assert.assertNull(FilterImpl.createFilter((String) null));
   Assert.assertNull(FilterImpl.createFilter(""));
   Assert.assertNull(FilterImpl.createFilter((SimpleString) null));
   Assert.assertNull(FilterImpl.createFilter(new SimpleString("")));
 }
Exemplo n.º 3
0
  @Test
  public void testStringLike() throws Exception {
    // test LIKE operator with no wildcards
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE 'astring'"));
    Assert.assertFalse(filter.match(message));

    // test where LIKE operand matches
    doPutStringProperty("MyString", "astring");
    Assert.assertTrue(filter.match(message));

    // test one character string
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE 'a'"));
    doPutStringProperty("MyString", "a");
    Assert.assertTrue(filter.match(message));

    // test empty string
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE ''"));
    doPutStringProperty("MyString", "");
    Assert.assertTrue(filter.match(message));

    // tests where operand does not match
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE 'astring'"));

    // test with extra characters at beginning
    doPutStringProperty("MyString", "NOTastring");
    Assert.assertTrue(!filter.match(message));

    // test with extra characters at end
    doPutStringProperty("MyString", "astringNOT");
    Assert.assertTrue(!filter.match(message));

    // test with extra characters in the middle
    doPutStringProperty("MyString", "astNOTring");
    Assert.assertTrue(!filter.match(message));

    // test where operand is entirely different
    doPutStringProperty("MyString", "totally different");
    Assert.assertTrue(!filter.match(message));

    // test case sensitivity
    doPutStringProperty("MyString", "ASTRING");
    Assert.assertTrue(!filter.match(message));

    // test empty string
    doPutStringProperty("MyString", "");
    Assert.assertTrue(!filter.match(message));

    // test lower-case 'like' operator?
  }
Exemplo n.º 4
0
  public boolean isSatisfied(Capability capability) {
    if (_filter == null) _filter = new FilterImpl(filter);

    @SuppressWarnings("unchecked")
    boolean result = _filter.match(capability.getProperties());
    return result;
  }
Exemplo n.º 5
0
  @Test
  public void testDifferentNullString() throws Exception {
    filter = FilterImpl.createFilter(new SimpleString("prop <> 'foo'"));
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("NOT (prop = 'foo')"));
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("prop <> 'foo'"));
    doPutStringProperty("prop", "bar");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("prop <> 'foo'"));
    doPutStringProperty("prop", "foo");
    Assert.assertFalse(filter.match(message));
  }
Exemplo n.º 6
0
  @Test
  public void testNotLikeExpression() throws Exception {
    // Should evaluate to false when the property MyString is not set
    filter = FilterImpl.createFilter(new SimpleString("NOT (MyString LIKE '%')"));

    Assert.assertFalse(filter.match(message));
  }
Exemplo n.º 7
0
  @Test
  public void testNewlineMatch() throws Exception {
    filter = FilterImpl.createFilter(new SimpleString("fooprop LIKE '%1234%'"));

    message.putStringProperty(new SimpleString("fooprop"), new SimpleString("hello1234\n"));

    Assert.assertTrue(filter.match(message));
  }
Exemplo n.º 8
0
  @Test
  public void testFilterForgets() throws Exception {
    filter = FilterImpl.createFilter(new SimpleString("color = 'RED'"));

    message.putStringProperty(new SimpleString("color"), new SimpleString("RED"));
    Assert.assertTrue(filter.match(message));
    message = new ServerMessageImpl();
    Assert.assertFalse(filter.match(message));
  }
Exemplo n.º 9
0
  @Test
  public void testIS_NOT_NULLWithNullProperty() throws Exception {
    filter = FilterImpl.createFilter(new SimpleString("myNullProp IS NOT NULL"));

    assertFalse(filter.match(message));

    message.putStringProperty("myNullProp", "JMS");
    assertTrue(filter.match(message));
  }
Exemplo n.º 10
0
  @Test
  public void testNOT_LIKEWithNullProperty() throws Exception {
    filter = FilterImpl.createFilter(new SimpleString("myNullProp NOT LIKE '1_3'"));

    assertFalse(filter.match(message));

    message.putStringProperty("myNullProp", "JMS");
    assertTrue(filter.match(message));
  }
Exemplo n.º 11
0
  @Test
  public void testNOT_INWithNullProperty() throws Exception {
    filter = FilterImpl.createFilter(new SimpleString("myNullProp NOT IN ('foo','jms','test')"));

    assertFalse(filter.match(message));

    message.putStringProperty("myNullProp", "JMS");
    assertTrue(filter.match(message));
  }
Exemplo n.º 12
0
 private void testInvalidFilter(final SimpleString filterString) throws Exception {
   try {
     filter = FilterImpl.createFilter(filterString);
     Assert.fail("Should throw exception");
   } catch (ActiveMQInvalidFilterExpressionException ife) {
     // pass
   } catch (ActiveMQException e) {
     fail("Invalid exception type:" + e.getType());
   }
 }
Exemplo n.º 13
0
  @Test
  public void testAMQSize() throws Exception {
    message.setAddress(RandomUtil.randomSimpleString());

    int encodeSize = message.getEncodeSize();

    Filter moreThanSmall =
        FilterImpl.createFilter(new SimpleString("AMQSize > " + (encodeSize - 1)));
    Filter lessThanLarge =
        FilterImpl.createFilter(new SimpleString("AMQSize < " + (encodeSize + 1)));

    Filter lessThanSmall = FilterImpl.createFilter(new SimpleString("AMQSize < " + encodeSize));
    Filter moreThanLarge = FilterImpl.createFilter(new SimpleString("AMQSize > " + encodeSize));

    Assert.assertTrue(moreThanSmall.match(message));
    Assert.assertTrue(lessThanLarge.match(message));

    Assert.assertFalse(lessThanSmall.match(message));
    Assert.assertFalse(moreThanLarge.match(message));
  }
Exemplo n.º 14
0
  @Test
  public void testAMQTimestamp() throws Exception {
    filter = FilterImpl.createFilter(new SimpleString("AMQTimestamp=12345678"));

    message.setTimestamp(87654321);

    Assert.assertFalse(filter.match(message));

    message.setTimestamp(12345678);

    Assert.assertTrue(filter.match(message));
  }
Exemplo n.º 15
0
  @Test
  public void testAMQDurable() throws Exception {
    filter = FilterImpl.createFilter(new SimpleString("AMQDurable='DURABLE'"));

    message.setDurable(true);

    Assert.assertTrue(filter.match(message));

    message.setDurable(false);

    Assert.assertFalse(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("AMQDurable='NON_DURABLE'"));

    message = new ServerMessageImpl();
    message.setDurable(true);

    Assert.assertFalse(filter.match(message));

    message.setDurable(false);

    Assert.assertTrue(filter.match(message));
  }
Exemplo n.º 16
0
  @Test
  public void testAMQPriority() throws Exception {
    filter = FilterImpl.createFilter(new SimpleString("AMQPriority=3"));

    for (int i = 0; i < 10; i++) {
      message.setPriority((byte) i);

      if (i == 3) {
        Assert.assertTrue(filter.match(message));
      } else {
        Assert.assertFalse(filter.match(message));
      }
    }
  }
Exemplo n.º 17
0
    /**
     * Filter using a {@code Map}. This {@code Filter} is executed using the specified {@code Map}'s
     * keys and values. The keys are looked up in a normal manner respecting case.
     *
     * @param map The {@code Map} whose key/value pairs are used in the match. Maps with {@code
     *     null} key or values are not supported. A {@code null} value is considered not present to
     *     the filter.
     * @return {@code true} if the {@code Map}'s values match this filter; {@code false} otherwise.
     * @since 1.6
     */
    @Override
    public boolean matches(Map<String, ?> map) {
      switch (op) {
        case AND:
          {
            FilterImpl[] filters = (FilterImpl[]) value;
            for (FilterImpl f : filters) {
              if (!f.matches(map)) {
                return false;
              }
            }
            return true;
          }

        case OR:
          {
            FilterImpl[] filters = (FilterImpl[]) value;
            for (FilterImpl f : filters) {
              if (f.matches(map)) {
                return true;
              }
            }
            return false;
          }

        case NOT:
          {
            FilterImpl filter = (FilterImpl) value;
            return !filter.matches(map);
          }

        case SUBSTRING:
        case EQUAL:
        case GREATER:
        case LESS:
        case APPROX:
          {
            Object prop = (map == null) ? null : map.get(attr);
            return compare(op, prop, value);
          }

        case PRESENT:
          {
            Object prop = (map == null) ? null : map.get(attr);
            return prop != null;
          }
      }

      return false;
    }
Exemplo n.º 18
0
 /**
  * Creates a {@code Filter} object. This {@code Filter} object may be used to match a {@code
  * ServiceReference} object or a {@code Dictionary} object.
  *
  * <p>If the filter cannot be parsed, an {@link InvalidSyntaxException} will be thrown with a
  * human readable message where the filter became unparsable.
  *
  * <p>This method returns a Filter implementation which may not perform as well as the framework
  * implementation-specific Filter implementation returned by {@link
  * ModuleContext#createFilter(String)}.
  *
  * @param filter The filter string.
  * @return A {@code Filter} object encapsulating the filter string. @If {@code filter} contains an
  *     invalid filter string that cannot be parsed.
  * @throws NullPointerException If {@code filter} is null.
  * @see Filter
  */
 static Filter createFilter(String filter) {
   return FilterImpl.newInstance(filter);
 }
Exemplo n.º 19
0
    /**
     * Returns this {@code Filter}'s normalized filter string.
     *
     * <p>The filter string is normalized by removing whitespace which does not affect the meaning
     * of the filter.
     *
     * @return This {@code Filter}'s filter string.
     */
    private StringBuffer normalize() {
      StringBuffer sb = new StringBuffer();
      sb.append('(');

      switch (op) {
        case AND:
          {
            sb.append('&');

            FilterImpl[] filters = (FilterImpl[]) value;
            for (FilterImpl f : filters) {
              sb.append(f.normalize());
            }

            break;
          }

        case OR:
          {
            sb.append('|');

            FilterImpl[] filters = (FilterImpl[]) value;
            for (FilterImpl f : filters) {
              sb.append(f.normalize());
            }

            break;
          }

        case NOT:
          {
            sb.append('!');
            FilterImpl filter = (FilterImpl) value;
            sb.append(filter.normalize());

            break;
          }

        case SUBSTRING:
          {
            sb.append(attr);
            sb.append('=');

            String[] substrings = (String[]) value;

            for (String substr : substrings) {
              if (substr == null) /* * */ {
                sb.append('*');
              } else /* xxx */ {
                sb.append(encodeValue(substr));
              }
            }

            break;
          }
        case EQUAL:
          {
            sb.append(attr);
            sb.append('=');
            sb.append(encodeValue((String) value));

            break;
          }
        case GREATER:
          {
            sb.append(attr);
            sb.append(">=");
            sb.append(encodeValue((String) value));

            break;
          }
        case LESS:
          {
            sb.append(attr);
            sb.append("<=");
            sb.append(encodeValue((String) value));

            break;
          }
        case APPROX:
          {
            sb.append(attr);
            sb.append("~=");
            sb.append(encodeValue(approxString((String) value)));

            break;
          }

        case PRESENT:
          {
            sb.append(attr);
            sb.append("=*");

            break;
          }
      }

      sb.append(')');

      return sb;
    }
Exemplo n.º 20
0
 @Test
 public void testBooleanFalse() throws Exception {
   filter = FilterImpl.createFilter(new SimpleString("MyBoolean=false"));
   testBoolean("MyBoolean", false);
 }
Exemplo n.º 21
0
  @Test
  public void testStringLikePunctuation() throws Exception {
    // test proper handling of some punctuation characters.
    // non-trivial since the underlying implementation might
    // (and in fact currently does) use a general-purpose
    // RE library, which has a different notion of which
    // characters are wildcards

    // the particular tests here are motivated by the
    // wildcards of the current underlying RE engine,
    // GNU regexp.

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE 'a^$b'"));
    Assert.assertFalse(filter.match(message));

    doPutStringProperty("MyString", "a^$b");
    Assert.assertTrue(filter.match(message));

    // this one has a double backslash since backslash
    // is interpreted specially by Java
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE 'a\\dc'"));
    doPutStringProperty("MyString", "a\\dc");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE 'a.c'"));
    doPutStringProperty("MyString", "abc");
    Assert.assertTrue(!filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '[abc]'"));
    doPutStringProperty("MyString", "[abc]");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '[^abc]'"));
    doPutStringProperty("MyString", "[^abc]");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '[a-c]'"));
    doPutStringProperty("MyString", "[a-c]");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '[:alpha]'"));
    doPutStringProperty("MyString", "[:alpha]");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '(abc)'"));
    doPutStringProperty("MyString", "(abc)");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE 'a|bc'"));
    doPutStringProperty("MyString", "a|bc");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '(abc)?'"));
    doPutStringProperty("MyString", "(abc)?");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '(abc)*'"));
    doPutStringProperty("MyString", "(abc)*");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '(abc)+'"));
    doPutStringProperty("MyString", "(abc)+");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '(abc){3}'"));
    doPutStringProperty("MyString", "(abc){3}");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '(abc){3,5}'"));
    doPutStringProperty("MyString", "(abc){3,5}");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '(abc){3,}'"));
    doPutStringProperty("MyString", "(abc){3,}");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '(?=abc)'"));
    doPutStringProperty("MyString", "(?=abc)");
    Assert.assertTrue(filter.match(message));

    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '(?!abc)'"));
    doPutStringProperty("MyString", "(?!abc)");
    Assert.assertTrue(filter.match(message));
  }
  /**
   * Construct a Filter object. This filter object may be used to match a ServiceReference or a
   * Dictionary. See Filter for a description of the filter string syntax.
   *
   * @param filter The filter string.
   * @return A Filter object encapsulating the filter string.
   * @exception InvalidSyntaxException If the filter parameter contains an invalid filter string
   *     which cannot be parsed.
   */
  public Filter createFilter(String filter) throws InvalidSyntaxException {
    checkValid();

    return FilterImpl.newInstance(filter);
  }
Exemplo n.º 23
0
  @Test
  public void testStringLikePercentWildcard() throws Exception {
    // test LIKE operator with the % wildcard, which
    // matches any sequence of characters
    // note many of the tests are similar to those for _

    // first, some tests with the wildcard by itself
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '%'"));
    Assert.assertFalse(filter.match(message));

    // test match against single character
    doPutStringProperty("MyString", "a");
    Assert.assertTrue(filter.match(message));

    // test match against multiple characters
    doPutStringProperty("MyString", "aaaaa");
    Assert.assertTrue(filter.match(message));

    doPutStringProperty("MyString", "abcdf");
    Assert.assertTrue(filter.match(message));

    // test match against the empty string
    doPutStringProperty("MyString", "");
    Assert.assertTrue(filter.match(message));

    // next, tests with wildcard at the beginning of the string
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '%bcdf'"));

    // test match with single character at beginning of string
    doPutStringProperty("MyString", "Xbcdf");
    Assert.assertTrue(filter.match(message));

    // match with multiple characters at beginning
    doPutStringProperty("MyString", "XXbcdf");
    Assert.assertTrue(filter.match(message));

    // match failure in middle character
    doPutStringProperty("MyString", "abXdf");
    Assert.assertTrue(!filter.match(message));

    // match failure in last character
    doPutStringProperty("MyString", "abcdX");
    Assert.assertTrue(!filter.match(message));

    // match failure with empty string
    doPutStringProperty("MyString", "");
    Assert.assertTrue(!filter.match(message));

    // match failure due to extra characters at the end
    doPutStringProperty("MyString", "abcdfXXX");
    Assert.assertTrue(!filter.match(message));

    // test that the % wildcard matches the empty string
    doPutStringProperty("MyString", "bcdf");
    Assert.assertTrue(filter.match(message));

    // next, tests with wildcard at the end of the string
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE 'abcd%'"));

    // test match of single character at end of string
    doPutStringProperty("MyString", "abcdf");
    Assert.assertTrue(filter.match(message));

    // test match of multiple characters at end of string
    doPutStringProperty("MyString", "abcdfgh");
    Assert.assertTrue(filter.match(message));

    // match failure in first character before wildcard
    doPutStringProperty("MyString", "abcXf");
    Assert.assertTrue(!filter.match(message));

    // match failure in middle character
    doPutStringProperty("MyString", "abXdf");
    Assert.assertTrue(!filter.match(message));

    // match failure in first character
    doPutStringProperty("MyString", "Xbcdf");
    Assert.assertTrue(!filter.match(message));

    // match failure with empty string
    doPutStringProperty("MyString", "");
    Assert.assertTrue(!filter.match(message));

    // match failure due to extra characters at beginning
    doPutStringProperty("MyString", "XXXabcdf");
    Assert.assertTrue(!filter.match(message));

    // test that the % wildcard matches the empty string
    doPutStringProperty("MyString", "abcd");
    Assert.assertTrue(filter.match(message));

    // next, tests with wildcard in the middle of the string
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE 'ab%df'"));

    // test match with single character in the middle of string
    doPutStringProperty("MyString", "abXdf");
    Assert.assertTrue(filter.match(message));

    // test match with multiple characters in the middle of string
    doPutStringProperty("MyString", "abXXXdf");
    Assert.assertTrue(filter.match(message));

    // match failure in first character before wildcard
    doPutStringProperty("MyString", "aXcdf");
    Assert.assertTrue(!filter.match(message));

    // match failure in first character after wildcard
    doPutStringProperty("MyString", "abcXf");
    Assert.assertTrue(!filter.match(message));

    // match failure in last character
    doPutStringProperty("MyString", "abcdX");
    Assert.assertTrue(!filter.match(message));

    // match failure with empty string
    doPutStringProperty("MyString", "");
    Assert.assertTrue(!filter.match(message));

    // match failure due to extra characters at beginning
    doPutStringProperty("MyString", "XXXabcdf");
    Assert.assertTrue(!filter.match(message));

    // match failure due to extra characters at the end
    doPutStringProperty("MyString", "abcdfXXX");
    Assert.assertTrue(!filter.match(message));

    // test that the % wildcard matches the empty string
    doPutStringProperty("MyString", "abdf");
    Assert.assertTrue(filter.match(message));
  }
Exemplo n.º 24
0
  @Test
  public void testStringLikeUnderbarWildcard() throws Exception {
    // test LIKE operator with the _ wildcard, which
    // matches any single character

    // first, some tests with the wildcard by itself
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '_'"));
    Assert.assertFalse(filter.match(message));

    // test match against single character
    doPutStringProperty("MyString", "a");
    Assert.assertTrue(filter.match(message));

    // test match failure against multiple characters
    doPutStringProperty("MyString", "aaaaa");
    Assert.assertTrue(!filter.match(message));

    // test match failure against the empty string
    doPutStringProperty("MyString", "");
    Assert.assertTrue(!filter.match(message));

    // next, tests with wildcard at the beginning of the string
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE '_bcdf'"));

    // test match at beginning of string
    doPutStringProperty("MyString", "abcdf");
    Assert.assertTrue(filter.match(message));

    // match failure in first character after wildcard
    doPutStringProperty("MyString", "aXcdf");
    Assert.assertTrue(!filter.match(message));

    // match failure in middle character
    doPutStringProperty("MyString", "abXdf");
    Assert.assertTrue(!filter.match(message));

    // match failure in last character
    doPutStringProperty("MyString", "abcdX");
    Assert.assertTrue(!filter.match(message));

    // match failure with empty string
    doPutStringProperty("MyString", "");
    Assert.assertTrue(!filter.match(message));

    // match failure due to extra characters at beginning
    doPutStringProperty("MyString", "XXXabcdf");
    Assert.assertTrue(!filter.match(message));

    // match failure due to extra characters at the end
    doPutStringProperty("MyString", "abcdfXXX");
    Assert.assertTrue(!filter.match(message));

    // test that the _ wildcard does not match the 'empty' character
    doPutStringProperty("MyString", "bcdf");
    Assert.assertTrue(!filter.match(message));

    // next, tests with wildcard at the end of the string
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE 'abcd_'"));

    // test match at end of string
    doPutStringProperty("MyString", "abcdf");
    Assert.assertTrue(filter.match(message));

    // match failure in first character before wildcard
    doPutStringProperty("MyString", "abcXf");
    Assert.assertTrue(!filter.match(message));

    // match failure in middle character
    doPutStringProperty("MyString", "abXdf");
    Assert.assertTrue(!filter.match(message));

    // match failure in first character
    doPutStringProperty("MyString", "Xbcdf");
    Assert.assertTrue(!filter.match(message));

    // match failure with empty string
    doPutStringProperty("MyString", "");
    Assert.assertTrue(!filter.match(message));

    // match failure due to extra characters at beginning
    doPutStringProperty("MyString", "XXXabcdf");
    Assert.assertTrue(!filter.match(message));

    // match failure due to extra characters at the end
    doPutStringProperty("MyString", "abcdfXXX");
    Assert.assertTrue(!filter.match(message));

    // test that the _ wildcard does not match the 'empty' character
    doPutStringProperty("MyString", "abcd");
    Assert.assertTrue(!filter.match(message));

    // test match in middle of string

    // next, tests with wildcard in the middle of the string
    filter = FilterImpl.createFilter(new SimpleString("MyString LIKE 'ab_df'"));

    // test match in the middle of string
    doPutStringProperty("MyString", "abcdf");
    Assert.assertTrue(filter.match(message));

    // match failure in first character before wildcard
    doPutStringProperty("MyString", "aXcdf");
    Assert.assertTrue(!filter.match(message));

    // match failure in first character after wildcard
    doPutStringProperty("MyString", "abcXf");
    Assert.assertTrue(!filter.match(message));

    // match failure in last character
    doPutStringProperty("MyString", "abcdX");
    Assert.assertTrue(!filter.match(message));

    // match failure with empty string
    doPutStringProperty("MyString", "");
    Assert.assertTrue(!filter.match(message));

    // match failure due to extra characters at beginning
    doPutStringProperty("MyString", "XXXabcdf");
    Assert.assertTrue(!filter.match(message));

    // match failure due to extra characters at the end
    doPutStringProperty("MyString", "abcdfXXX");
    Assert.assertTrue(!filter.match(message));

    // test that the _ wildcard does not match the 'empty' character
    doPutStringProperty("MyString", "abdf");
    Assert.assertTrue(!filter.match(message));

    // test match failures
  }
Exemplo n.º 25
0
  @Test
  public void testIdentifier() throws Exception {
    filter = FilterImpl.createFilter(new SimpleString("MyBoolean"));

    testBoolean("MyBoolean", true);
  }