@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)); }
@Override public CompositeData[] browse(String filterStr) throws Exception { checkStarted(); clearIO(); try { int pageSize = addressSettingsRepository .getMatch(queue.getName().toString()) .getManagementBrowsePageSize(); int currentPageSize = 0; ArrayList<CompositeData> c = new ArrayList<>(); Filter filter = FilterImpl.createFilter(filterStr); queue.flushExecutor(); try (LinkedListIterator<MessageReference> iterator = queue.totalIterator()) { while (iterator.hasNext() && currentPageSize++ < pageSize) { MessageReference ref = iterator.next(); if (filter == null || filter.match(ref.getMessage())) { c.add(OpenTypeSupport.convert(ref)); } } CompositeData[] rc = new CompositeData[c.size()]; c.toArray(rc); return rc; } } catch (ActiveMQException e) { throw new IllegalStateException(e.getMessage()); } finally { blockOnIO(); } }
private void testBoolean(final String name, final boolean flag) throws Exception { message.putBooleanProperty(new SimpleString(name), flag); Assert.assertTrue(filter.match(message)); message.putBooleanProperty(new SimpleString(name), !flag); Assert.assertTrue(!filter.match(message)); }
@Override public long countMessages(final String filterStr) throws Exception { checkStarted(); clearIO(); try { Filter filter = FilterImpl.createFilter(filterStr); if (filter == null) { return getMessageCount(); } else { try (LinkedListIterator<MessageReference> iterator = queue.totalIterator()) { int count = 0; while (iterator.hasNext()) { MessageReference ref = iterator.next(); if (filter.match(ref.getMessage())) { count++; } } return count; } } } finally { blockOnIO(); } }
@Override public Map<String, Object>[] listMessages(final String filterStr) throws Exception { checkStarted(); clearIO(); try { Filter filter = FilterImpl.createFilter(filterStr); List<Map<String, Object>> messages = new ArrayList<>(); queue.flushExecutor(); try (LinkedListIterator<MessageReference> iterator = queue.totalIterator()) { while (iterator.hasNext()) { MessageReference ref = iterator.next(); if (filter == null || filter.match(ref.getMessage())) { Message message = ref.getMessage(); messages.add(message.toMap()); } } return messages.toArray(new Map[messages.size()]); } } catch (ActiveMQException e) { throw new IllegalStateException(e.getMessage()); } finally { blockOnIO(); } }
@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)); }
@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)); }
@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)); }
@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)); }
@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)); }
@Override public String getFilter() { checkStarted(); clearIO(); try { Filter filter = queue.getFilter(); return filter != null ? filter.getFilterString().toString() : null; } finally { blockOnIO(); } }
@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)); } } }
@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? }
@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)); }
@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)); }
@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)); }
@Override public HandleStatus handle(final MessageReference ref) throws Exception { if (filter != null && !filter.match(ref.getMessage())) { return HandleStatus.NO_MATCH; } synchronized (this) { if (!active || !session.isWritable(this)) { if (logger.isDebugEnabled()) { logger.debug(this + "::Ignoring reference on bridge as it is set to inactive ref=" + ref); } return HandleStatus.BUSY; } if (deliveringLargeMessage) { return HandleStatus.BUSY; } if (logger.isTraceEnabled()) { logger.trace("Bridge " + this + " is handling reference=" + ref); } ref.handled(); synchronized (refs) { refs.put(ref.getMessage().getMessageID(), ref); } final ServerMessage message = beforeForward(ref.getMessage()); final SimpleString dest; if (forwardingAddress != null) { dest = forwardingAddress; } else { // Preserve the original address dest = message.getAddress(); } pendingAcks.countUp(); try { if (message.isLargeMessage()) { deliveringLargeMessage = true; deliverLargeMessage(dest, ref, (LargeServerMessage) message); return HandleStatus.HANDLED; } else { return deliverStandardMessage(dest, ref, message); } } catch (Exception e) { // If an exception happened, we must count down immediately pendingAcks.countDown(); throw e; } } }
@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)); }
private boolean checkBindingExists(DestinationAction command, String filter) { String bindingKey = command.getName(); if (isJms(command)) { if (isTopic(command)) { bindingKey = "jms.topic." + bindingKey; } else { bindingKey = "jms.queue." + bindingKey; } } Map<SimpleString, Binding> bindings = server.getPostOffice().getAllBindings(); System.out.println("bindings: " + bindings); Binding binding = bindings.get(new SimpleString(bindingKey)); System.out.println("got binding: " + binding); if (binding == null) { System.out.println("No bindings for " + bindingKey); return false; } if (filter != null) { Filter bindingFilter = binding.getFilter(); assertNotNull(bindingFilter); assertEquals(filter, bindingFilter.getFilterString().toString()); } return true; }
@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)); }
@Override public void initQueues( Map<Long, QueueBindingInfo> queueBindingInfosMap, List<QueueBindingInfo> queueBindingInfos) throws Exception { int duplicateID = 0; for (QueueBindingInfo queueBindingInfo : queueBindingInfos) { queueBindingInfosMap.put(queueBindingInfo.getId(), queueBindingInfo); Filter filter = FilterImpl.createFilter(queueBindingInfo.getFilterString()); boolean isTopicIdentification = filter != null && filter.getFilterString() != null && filter .getFilterString() .toString() .equals(ActiveMQServerImpl.GENERIC_IGNORED_FILTER); if (postOffice.getBinding(queueBindingInfo.getQueueName()) != null) { if (isTopicIdentification) { long tx = storageManager.generateID(); storageManager.deleteQueueBinding(tx, queueBindingInfo.getId()); storageManager.commitBindings(tx); continue; } else { SimpleString newName = queueBindingInfo.getQueueName().concat("-" + (duplicateID++)); ActiveMQServerLogger.LOGGER.queueDuplicatedRenaming( queueBindingInfo.getQueueName().toString(), newName.toString()); queueBindingInfo.replaceQueueName(newName); } } PageSubscription subscription = null; if (!isTopicIdentification) { subscription = pagingManager .getPageStore(queueBindingInfo.getAddress()) .getCursorProvider() .createSubscription(queueBindingInfo.getId(), filter, true); } Queue queue = queueFactory.createQueue( queueBindingInfo.getId(), queueBindingInfo.getAddress(), queueBindingInfo.getQueueName(), filter, subscription, queueBindingInfo.getUser(), true, false, queueBindingInfo.isAutoCreated()); if (queueBindingInfo.isAutoCreated()) { queue.setConsumersRefCount( new AutoCreatedQueueManagerImpl( ((PostOfficeImpl) postOffice).getServer().getJMSQueueDeleter(), queueBindingInfo.getQueueName())); } Binding binding = new LocalQueueBinding(queueBindingInfo.getAddress(), queue, nodeManager.getNodeId()); queues.put(queueBindingInfo.getId(), queue); postOffice.addBinding(binding); managementService.registerAddress(queueBindingInfo.getAddress()); managementService.registerQueue(queue, queueBindingInfo.getAddress(), storageManager); } }
@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 }
@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)); }
@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)); }