[hornetq-commits] JBoss hornetq SVN: r12017 - in trunk: hornetq-core/src/test/java/org/hornetq/core and 5 other directories.
do-not-reply at jboss.org
do-not-reply at jboss.org
Thu Jan 12 07:10:55 EST 2012
Author: borges
Date: 2012-01-12 07:10:54 -0500 (Thu, 12 Jan 2012)
New Revision: 12017
Added:
trunk/hornetq-core/src/test/java/org/hornetq/core/filter/
trunk/hornetq-core/src/test/java/org/hornetq/core/filter/impl/
trunk/hornetq-core/src/test/java/org/hornetq/core/filter/impl/FilterTest.java
trunk/hornetq-core/src/test/java/org/hornetq/core/filter/impl/OperatorTest.java
trunk/hornetq-core/src/test/java/org/hornetq/util/
trunk/hornetq-core/src/test/java/org/hornetq/util/CompressionUtilTest.java
trunk/hornetq-core/src/test/java/org/hornetq/util/ConcurrentHashSetTest.java
trunk/hornetq-core/src/test/java/org/hornetq/util/TimeAndCounterIDGeneratorTest.java
trunk/hornetq-core/src/test/java/org/hornetq/util/TypedPropertiesConversionTest.java
trunk/hornetq-core/src/test/java/org/hornetq/util/TypedPropertiesTest.java
trunk/hornetq-core/src/test/java/org/hornetq/util/XMLUtilTest.java
Removed:
trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/core/filter/impl/FilterTest.java
trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/core/filter/impl/OperatorTest.java
trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/CompressionUtilTest.java
trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/ConcurrentHashSetTest.java
trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TimeAndCounterIDGeneratorTest.java
trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TypedPropertiesConversionTest.java
trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TypedPropertiesTest.java
trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/XMLUtilTest.java
Log:
Move tests into hq-core, avoid cluttering std.out
Copied: trunk/hornetq-core/src/test/java/org/hornetq/core/filter/impl/FilterTest.java (from rev 12016, trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/core/filter/impl/FilterTest.java)
===================================================================
--- trunk/hornetq-core/src/test/java/org/hornetq/core/filter/impl/FilterTest.java (rev 0)
+++ trunk/hornetq-core/src/test/java/org/hornetq/core/filter/impl/FilterTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -0,0 +1,699 @@
+/*
+ * Copyright 2009 Red Hat, Inc.
+ * Red Hat licenses this file to you under the Apache License, version
+ * 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package org.hornetq.core.filter.impl;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.hornetq.api.core.HornetQException;
+import org.hornetq.api.core.SimpleString;
+import org.hornetq.core.filter.Filter;
+import org.hornetq.core.server.ServerMessage;
+import org.hornetq.core.server.impl.ServerMessageImpl;
+import org.hornetq.tests.util.RandomUtil;
+
+/**
+ * Tests the compliance with the HornetQ Filter syntax.
+ *
+ * @author <a href="mailto:jason at planet57.com">Jason Dillon</a>
+ * @author <a href="mailto:tim.fox at jboss.com">Tim Fox</a>
+ */
+public class FilterTest extends TestCase
+{
+ private Filter filter;
+
+ private ServerMessage message;
+
+ @Override
+ protected void setUp() throws Exception
+ {
+ super.setUp();
+
+ message = new ServerMessageImpl(1, 1000);
+ }
+
+ 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));
+ }
+
+ public void testInvalidString() throws Exception
+ {
+ testInvalidFilter("color = 'red");
+ testInvalidFilter(new SimpleString("color = 'red"));
+
+ testInvalidFilter("3");
+ testInvalidFilter(new SimpleString("3"));
+ }
+
+ 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("")));
+ }
+
+ public void testHQDurable() throws Exception
+ {
+ filter = FilterImpl.createFilter(new SimpleString("HQDurable='DURABLE'"));
+
+ message.setDurable(true);
+
+ Assert.assertTrue(filter.match(message));
+
+ message.setDurable(false);
+
+ Assert.assertFalse(filter.match(message));
+
+ filter = FilterImpl.createFilter(new SimpleString("HQDurable='NON_DURABLE'"));
+
+ message = new ServerMessageImpl();
+ message.setDurable(true);
+
+ Assert.assertFalse(filter.match(message));
+
+ message.setDurable(false);
+
+ Assert.assertTrue(filter.match(message));
+
+ }
+
+ public void testHQSize() throws Exception
+ {
+ message.setAddress(RandomUtil.randomSimpleString());
+
+ int encodeSize = message.getEncodeSize();
+
+ Filter moreThanSmall = FilterImpl.createFilter(new SimpleString("HQSize > " + (encodeSize - 1)));
+ Filter lessThanLarge = FilterImpl.createFilter(new SimpleString("HQSize < " + (encodeSize + 1)));
+
+ Filter lessThanSmall = FilterImpl.createFilter(new SimpleString("HQSize < " + encodeSize));
+ Filter moreThanLarge = FilterImpl.createFilter(new SimpleString("HQSize > " + encodeSize));
+
+ Assert.assertTrue(moreThanSmall.match(message));
+ Assert.assertTrue(lessThanLarge.match(message));
+
+ Assert.assertFalse(lessThanSmall.match(message));
+ Assert.assertFalse(moreThanLarge.match(message));
+
+ }
+
+ public void testHQPriority() throws Exception
+ {
+ filter = FilterImpl.createFilter(new SimpleString("HQPriority=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));
+ }
+ }
+ }
+
+ public void testHQTimestamp() throws Exception
+ {
+ filter = FilterImpl.createFilter(new SimpleString("HQTimestamp=12345678"));
+
+ message.setTimestamp(87654321);
+
+ Assert.assertFalse(filter.match(message));
+
+ message.setTimestamp(12345678);
+
+ Assert.assertTrue(filter.match(message));
+ }
+
+ public void testBooleanTrue() throws Exception
+ {
+ filter = FilterImpl.createFilter(new SimpleString("MyBoolean=true"));
+
+ testBoolean("MyBoolean", true);
+ }
+
+ public void testIdentifier() throws Exception
+ {
+ filter = FilterImpl.createFilter(new SimpleString("MyBoolean"));
+
+ testBoolean("MyBoolean", true);
+ }
+
+ 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));
+ }
+
+ public void testBooleanFalse() throws Exception
+ {
+ filter = FilterImpl.createFilter(new SimpleString("MyBoolean=false"));
+ testBoolean("MyBoolean", false);
+ }
+
+ 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));
+ }
+
+ 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));
+
+ }
+
+ 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));
+ }
+
+ 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));
+ }
+
+ 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));
+ }
+
+ 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?
+ }
+
+ 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
+ }
+
+ 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));
+ }
+
+ 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));
+
+ }
+
+ 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));
+ }
+
+ // Private -----------------------------------------------------------------------------------
+
+ private void doPutStringProperty(final String key, final String value)
+ {
+ message.putStringProperty(new SimpleString(key), new SimpleString(value));
+ }
+
+ private void testInvalidFilter(final String filterString) throws Exception
+ {
+ try
+ {
+ filter = FilterImpl.createFilter(filterString);
+ Assert.fail("Should throw exception");
+ }
+ catch (HornetQException e)
+ {
+ Assert.assertEquals(HornetQException.INVALID_FILTER_EXPRESSION, e.getCode());
+ }
+ }
+
+ private void testInvalidFilter(final SimpleString filterString) throws Exception
+ {
+ try
+ {
+ filter = FilterImpl.createFilter(filterString);
+ Assert.fail("Should throw exception");
+ }
+ catch (HornetQException e)
+ {
+ Assert.assertEquals(HornetQException.INVALID_FILTER_EXPRESSION, e.getCode());
+ }
+ }
+
+}
Copied: trunk/hornetq-core/src/test/java/org/hornetq/core/filter/impl/OperatorTest.java (from rev 12016, trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/core/filter/impl/OperatorTest.java)
===================================================================
--- trunk/hornetq-core/src/test/java/org/hornetq/core/filter/impl/OperatorTest.java (rev 0)
+++ trunk/hornetq-core/src/test/java/org/hornetq/core/filter/impl/OperatorTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -0,0 +1,459 @@
+/*
+ * Copyright 2009 Red Hat, Inc.
+ * Red Hat licenses this file to you under the Apache License, version
+ * 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package org.hornetq.core.filter.impl;
+
+import java.util.HashSet;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.hornetq.api.core.SimpleString;
+import org.hornetq.core.filter.impl.Operator;
+
+/**
+ * A OperatorTest
+ *
+ * @author <a href="jmesnil at redhat.com">Jeff Mesnil</a>
+ *
+ * Created 3 nov. 2008 17:22:22
+ *
+ *
+ */
+public class OperatorTest extends TestCase
+{
+
+ // Constants -----------------------------------------------------
+
+ // Attributes ----------------------------------------------------
+
+ // Static --------------------------------------------------------
+ private static void assertSuccess(final int op, final Object arg1, final Object expectedResult) throws Exception
+ {
+ OperatorTest.assertOperationSuccess(new Operator(op, arg1), expectedResult);
+ }
+
+ private static void assertSuccess(final int op, final Object arg1, final Object arg2, final Object expectedResult) throws Exception
+ {
+ OperatorTest.assertOperationSuccess(new Operator(op, arg1, arg2), expectedResult);
+ }
+
+ private static void assertSuccess(final int op,
+ final Object arg1,
+ final Object arg2,
+ final Object arg3,
+ final Object expectedResult) throws Exception
+ {
+ OperatorTest.assertOperationSuccess(new Operator(op, arg1, arg2, arg3), expectedResult);
+ }
+
+ private static void assertOperationSuccess(final Operator operator, final Object expectedResult) throws Exception
+ {
+ Assert.assertEquals(expectedResult, operator.apply());
+ }
+
+ private static void assertFailure(final int op, final Object arg1) throws Exception
+ {
+ OperatorTest.assertOperationFailure(new Operator(op, arg1));
+ }
+
+ private static void assertFailure(final int op, final Object arg1, final Object arg2) throws Exception
+ {
+ OperatorTest.assertOperationFailure(new Operator(op, arg1, arg2));
+ }
+
+ private static void assertFailure(final int op, final Object arg1, final Object arg2, final Object arg3) throws Exception
+ {
+ OperatorTest.assertOperationFailure(new Operator(op, arg1, arg2, arg3));
+ }
+
+ private static void assertOperationFailure(final Operator operator)
+ {
+ try
+ {
+ operator.apply();
+ Assert.fail("expected to throw an exception");
+ }
+ catch (Exception e)
+ {
+ }
+ }
+
+ // Constructors --------------------------------------------------
+
+ // Public --------------------------------------------------------
+
+ public void test_EQUAL() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.EQUAL, 1, 1, true);
+ OperatorTest.assertSuccess(Operator.EQUAL, 1, 1.0, true);
+ OperatorTest.assertSuccess(Operator.EQUAL, 1, null, null);
+ OperatorTest.assertSuccess(Operator.EQUAL, 1.0, 1, true);
+ OperatorTest.assertSuccess(Operator.EQUAL, 1.0, 1.0, true);
+ OperatorTest.assertSuccess(Operator.EQUAL, 1.0, null, null);
+
+ OperatorTest.assertSuccess(Operator.EQUAL, false, false, true);
+ OperatorTest.assertSuccess(Operator.EQUAL, true, false, false);
+ OperatorTest.assertSuccess(Operator.EQUAL, false, true, false);
+ OperatorTest.assertSuccess(Operator.EQUAL, true, true, true);
+
+ SimpleString foo = new SimpleString("foo");
+ SimpleString foo2 = new SimpleString("foo");
+ SimpleString bar = new SimpleString("bar");
+ OperatorTest.assertSuccess(Operator.EQUAL, foo, foo, true);
+ OperatorTest.assertSuccess(Operator.EQUAL, foo, foo2, true);
+ OperatorTest.assertSuccess(Operator.EQUAL, foo, bar, false);
+ OperatorTest.assertSuccess(Operator.EQUAL, foo, null, false);
+
+ OperatorTest.assertSuccess(Operator.EQUAL, null, 1.0, false);
+ }
+
+ public void test_DIFFERENT() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.DIFFERENT, 2, 1, true);
+ OperatorTest.assertSuccess(Operator.DIFFERENT, 2, 1.0, true);
+ OperatorTest.assertSuccess(Operator.DIFFERENT, 2, null, null);
+ OperatorTest.assertSuccess(Operator.DIFFERENT, 2.0, 1, true);
+ OperatorTest.assertSuccess(Operator.DIFFERENT, 2.0, 1.0, true);
+ OperatorTest.assertSuccess(Operator.DIFFERENT, 2.0, null, null);
+
+ OperatorTest.assertSuccess(Operator.DIFFERENT, false, false, false);
+ OperatorTest.assertSuccess(Operator.DIFFERENT, true, false, true);
+ OperatorTest.assertSuccess(Operator.DIFFERENT, false, true, true);
+ OperatorTest.assertSuccess(Operator.DIFFERENT, true, true, false);
+
+ SimpleString foo = new SimpleString("foo");
+ SimpleString foo2 = new SimpleString("foo");
+ SimpleString bar = new SimpleString("bar");
+ OperatorTest.assertSuccess(Operator.DIFFERENT, foo, foo, false);
+ OperatorTest.assertSuccess(Operator.DIFFERENT, foo, foo2, false);
+ OperatorTest.assertSuccess(Operator.DIFFERENT, foo, bar, true);
+ OperatorTest.assertSuccess(Operator.DIFFERENT, foo, null, null);
+
+ OperatorTest.assertSuccess(Operator.DIFFERENT, null, 1.0, true);
+ OperatorTest.assertSuccess(Operator.DIFFERENT, null, null, false);
+ }
+
+ public void test_IS_NULL() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.IS_NULL, null, true);
+ OperatorTest.assertSuccess(Operator.IS_NULL, 1, false);
+ }
+
+ public void test_IS_NOT_NULL() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.IS_NOT_NULL, null, false);
+ OperatorTest.assertSuccess(Operator.IS_NOT_NULL, 1, true);
+ }
+
+ public void test_ADD() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.ADD, 1, 1, 2L);
+ OperatorTest.assertSuccess(Operator.ADD, 1.0, 1, 2.0);
+ OperatorTest.assertSuccess(Operator.ADD, 1, 1.0, 2.0);
+ OperatorTest.assertSuccess(Operator.ADD, 1.0, 1.0, 2.0);
+
+ // incompatible types
+ OperatorTest.assertFailure(Operator.ADD, true, 1.0);
+ OperatorTest.assertFailure(Operator.ADD, 1, true);
+ }
+
+ public void test_SUB() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.SUB, 2, 1, 1L);
+ OperatorTest.assertSuccess(Operator.SUB, 2.0, 1, 1.0);
+ OperatorTest.assertSuccess(Operator.SUB, 2, 1.0, 1.0);
+ OperatorTest.assertSuccess(Operator.SUB, 2.0, 1.0, 1.0);
+
+ // incompatible types
+ OperatorTest.assertFailure(Operator.SUB, true, 1.0);
+ OperatorTest.assertFailure(Operator.SUB, 1, true);
+ }
+
+ public void test_MUL() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.MUL, 2, 1, 2L);
+ OperatorTest.assertSuccess(Operator.MUL, 2.0, 1, 2.0);
+ OperatorTest.assertSuccess(Operator.MUL, 2, 1.0, 2.0);
+ OperatorTest.assertSuccess(Operator.MUL, 2.0, 1.0, 2.0);
+
+ // incompatible types
+ OperatorTest.assertSuccess(Operator.MUL, 2, null, null);
+ OperatorTest.assertSuccess(Operator.MUL, null, 1.0, null);
+ OperatorTest.assertFailure(Operator.MUL, true, 1.0);
+ OperatorTest.assertFailure(Operator.MUL, 1, true);
+ }
+
+ public void test_DIV() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.DIV, 2, 2, 1L);
+ OperatorTest.assertSuccess(Operator.DIV, 2.0, 2, 1.0);
+ OperatorTest.assertSuccess(Operator.DIV, 2, 2.0, 1.0);
+ OperatorTest.assertSuccess(Operator.DIV, 2.0, 2.0, 1.0);
+
+ // incompatible types
+ OperatorTest.assertSuccess(Operator.DIV, 2, null, null);
+ OperatorTest.assertSuccess(Operator.DIV, null, 1.0, null);
+ OperatorTest.assertFailure(Operator.DIV, true, 1.0);
+ OperatorTest.assertFailure(Operator.DIV, 1, true);
+ }
+
+ public void test_NEG() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.NEG, 1, -1L);
+ OperatorTest.assertSuccess(Operator.NEG, -1.0, 1.0);
+
+ // incompatible types
+ OperatorTest.assertFailure(Operator.NEG, true);
+ }
+
+ public void test_AND() throws Exception
+ {
+ // NULL and NULL -> NULL
+ OperatorTest.assertSuccess(Operator.AND, null, null, null);
+ // NULL and F -> F
+ OperatorTest.assertSuccess(Operator.AND, null, false, false);
+ // NULL and T -> NULL
+ OperatorTest.assertSuccess(Operator.AND, null, true, null);
+
+ // F and NULL -> F
+ OperatorTest.assertSuccess(Operator.AND, false, null, false);
+ // F and F -> F
+ OperatorTest.assertSuccess(Operator.AND, false, false, false);
+ // F and T -> F
+ OperatorTest.assertSuccess(Operator.AND, false, true, false);
+
+ // T and NULL -> NULL
+ OperatorTest.assertSuccess(Operator.AND, true, null, null);
+ // T and F -> F
+ OperatorTest.assertSuccess(Operator.AND, true, false, false);
+ // T and T -> T
+ OperatorTest.assertSuccess(Operator.AND, true, true, true);
+
+ // incompatible types
+ OperatorTest.assertFailure(Operator.AND, 1.0, true);
+ OperatorTest.assertFailure(Operator.AND, true, 1.0);
+ OperatorTest.assertFailure(Operator.AND, null, 1.0);
+ }
+
+ public void test_OR() throws Exception
+ {
+ // NULL OR NULL -> NULL
+ OperatorTest.assertSuccess(Operator.OR, null, null, null);
+ // NULL OR F -> NULL
+ OperatorTest.assertSuccess(Operator.OR, null, false, null);
+ // NULL OR T -> T
+ OperatorTest.assertSuccess(Operator.OR, null, true, true);
+
+ // F or NULL -> NULL
+ OperatorTest.assertSuccess(Operator.OR, false, null, null);
+ // F or F -> F
+ OperatorTest.assertSuccess(Operator.OR, false, false, false);
+ // F or T -> F
+ OperatorTest.assertSuccess(Operator.OR, false, true, true);
+
+ // T or NULL -> T
+ OperatorTest.assertSuccess(Operator.OR, true, null, true);
+ // T or F -> T
+ OperatorTest.assertSuccess(Operator.OR, true, false, true);
+ // T or T -> T
+ OperatorTest.assertSuccess(Operator.OR, true, true, true);
+
+ // incompatible types
+ OperatorTest.assertFailure(Operator.OR, 1.0, true);
+ OperatorTest.assertFailure(Operator.OR, false, 1.0);
+ OperatorTest.assertFailure(Operator.OR, null, 1.0);
+ }
+
+ public void test_NOT() throws Exception
+ {
+ // NOT NULL -> NULL
+ OperatorTest.assertSuccess(Operator.NOT, null, null);
+ // NOT F -> T
+ OperatorTest.assertSuccess(Operator.NOT, false, true);
+ // NOT T -> F
+ OperatorTest.assertSuccess(Operator.NOT, true, false);
+
+ // incompatible types
+ OperatorTest.assertFailure(Operator.NOT, 1.0);
+ }
+
+ public void test_GT() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.GT, 2, 1, true);
+ OperatorTest.assertSuccess(Operator.GT, 2.0, 1, true);
+ OperatorTest.assertSuccess(Operator.GT, 2, 1.0, true);
+ OperatorTest.assertSuccess(Operator.GT, 2.0, 1.0, true);
+
+ // incompatible types
+ OperatorTest.assertSuccess(Operator.GT, 2.0, true, false);
+ OperatorTest.assertSuccess(Operator.GT, 2, null, null);
+ OperatorTest.assertSuccess(Operator.GT, true, 1.0, false);
+ OperatorTest.assertSuccess(Operator.GT, null, 1, null);
+ OperatorTest.assertSuccess(Operator.GT, true, true, false);
+ OperatorTest.assertSuccess(Operator.GT, null, null, null);
+ }
+
+ public void test_GE() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.GE, 1, 1, true);
+ OperatorTest.assertSuccess(Operator.GE, 1.0, 1, true);
+ OperatorTest.assertSuccess(Operator.GE, 1, 1.0, true);
+ OperatorTest.assertSuccess(Operator.GE, 1.0, 1.0, true);
+
+ // incompatible types
+ OperatorTest.assertSuccess(Operator.GE, 2.0, true, false);
+ OperatorTest.assertSuccess(Operator.GE, 2, null, null);
+ OperatorTest.assertSuccess(Operator.GE, true, 1.0, false);
+ OperatorTest.assertSuccess(Operator.GE, null, 1, null);
+ OperatorTest.assertSuccess(Operator.GE, true, true, false);
+ OperatorTest.assertSuccess(Operator.GE, null, null, null);
+ }
+
+ public void test_LT() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.LT, 1, 2, true);
+ OperatorTest.assertSuccess(Operator.LT, 1.0, 2, true);
+ OperatorTest.assertSuccess(Operator.LT, 1, 2.0, true);
+ OperatorTest.assertSuccess(Operator.LT, 1.0, 2.0, true);
+
+ // incompatible types
+ OperatorTest.assertSuccess(Operator.LT, 1.0, true, false);
+ OperatorTest.assertSuccess(Operator.LT, 1, null, null);
+ OperatorTest.assertSuccess(Operator.LT, true, 2.0, false);
+ OperatorTest.assertSuccess(Operator.LT, null, 2, null);
+ OperatorTest.assertSuccess(Operator.LT, true, true, false);
+ OperatorTest.assertSuccess(Operator.LT, null, null, null);
+ }
+
+ public void test_LE() throws Exception
+ {
+ OperatorTest.assertSuccess(Operator.LE, 1, 1, true);
+ OperatorTest.assertSuccess(Operator.LE, 1.0, 1, true);
+ OperatorTest.assertSuccess(Operator.LE, 1, 1.0, true);
+ OperatorTest.assertSuccess(Operator.LE, 1.0, 1.0, true);
+
+ // incompatible types
+ OperatorTest.assertSuccess(Operator.LE, 1.0, true, false);
+ OperatorTest.assertSuccess(Operator.LE, 1, null, null);
+ OperatorTest.assertSuccess(Operator.LE, true, 1.0, false);
+ OperatorTest.assertSuccess(Operator.LE, null, 1, null);
+ OperatorTest.assertSuccess(Operator.LE, true, true, false);
+ OperatorTest.assertSuccess(Operator.LE, null, null, null);
+ }
+
+ public void test_BETWEEN() throws Exception
+ {
+ // 2 BETWEEN 1 AND 3
+ OperatorTest.assertSuccess(Operator.BETWEEN, 2, 1, 3, true);
+ OperatorTest.assertSuccess(Operator.BETWEEN, 2.0, 1.0, 3.0, true);
+
+ // incompatible types
+ OperatorTest.assertSuccess(Operator.BETWEEN, true, 1, 3, false);
+ OperatorTest.assertSuccess(Operator.BETWEEN, null, null, 3, null);
+ }
+
+ public void test_NOT_BETWEEN() throws Exception
+ {
+ // 2 NOT BETWEEN 3 AND 4
+ OperatorTest.assertSuccess(Operator.NOT_BETWEEN, 2, 3, 4, true);
+ OperatorTest.assertSuccess(Operator.NOT_BETWEEN, 2.0, 3.0, 4.0, true);
+
+ // incompatible types
+ OperatorTest.assertSuccess(Operator.NOT_BETWEEN, true, 1, 3, false);
+ OperatorTest.assertSuccess(Operator.NOT_BETWEEN, null, null, 3, null);
+ }
+
+ public void test_IN() throws Exception
+ {
+ HashSet<SimpleString> set = new HashSet<SimpleString>();
+ set.add(new SimpleString("foo"));
+ set.add(new SimpleString("bar"));
+ set.add(new SimpleString("baz"));
+
+ SimpleString foo = new SimpleString("foo");
+
+ OperatorTest.assertSuccess(Operator.IN, foo, set, true);
+ OperatorTest.assertSuccess(Operator.IN, foo, new HashSet<SimpleString>(), false);
+
+ // incompatible types
+ OperatorTest.assertFailure(Operator.IN, true, set);
+ }
+
+ public void test_NOT_IN() throws Exception
+ {
+ HashSet<SimpleString> set = new HashSet<SimpleString>();
+ set.add(new SimpleString("foo"));
+ set.add(new SimpleString("bar"));
+ set.add(new SimpleString("baz"));
+
+ SimpleString foo = new SimpleString("foo");
+
+ OperatorTest.assertSuccess(Operator.NOT_IN, foo, set, false);
+ OperatorTest.assertSuccess(Operator.NOT_IN, foo, new HashSet<SimpleString>(), true);
+
+ // incompatible types
+ OperatorTest.assertFailure(Operator.NOT_IN, true, set);
+ }
+
+ public void test_LIKE() throws Exception
+ {
+ SimpleString pattern = new SimpleString("12%3");
+ OperatorTest.assertSuccess(Operator.LIKE, new SimpleString("123"), pattern, true);
+ OperatorTest.assertSuccess(Operator.LIKE, new SimpleString("12993"), pattern, true);
+ OperatorTest.assertSuccess(Operator.LIKE, new SimpleString("1234"), pattern, false);
+
+ pattern = new SimpleString("l_se");
+ OperatorTest.assertSuccess(Operator.LIKE, new SimpleString("lose"), pattern, true);
+ OperatorTest.assertSuccess(Operator.LIKE, new SimpleString("loose"), pattern, false);
+
+ OperatorTest.assertSuccess(Operator.LIKE, null, pattern, null);
+ }
+
+ public void test_LIKE_ESCAPE() throws Exception
+ {
+ SimpleString pattern = new SimpleString("\\_%");
+ SimpleString escapeChar = new SimpleString("\\");
+ OperatorTest.assertSuccess(Operator.LIKE_ESCAPE, new SimpleString("_foo"), pattern, escapeChar, true);
+ OperatorTest.assertSuccess(Operator.LIKE_ESCAPE, new SimpleString("bar"), pattern, escapeChar, false);
+ OperatorTest.assertSuccess(Operator.LIKE_ESCAPE, null, pattern, escapeChar, null);
+
+ OperatorTest.assertFailure(Operator.LIKE_ESCAPE,
+ new SimpleString("_foo"),
+ pattern,
+ new SimpleString("must be a single char"));
+ }
+
+ public void test_NOT_LIKE() throws Exception
+ {
+ SimpleString pattern = new SimpleString("12%3");
+ OperatorTest.assertSuccess(Operator.NOT_LIKE, new SimpleString("123"), pattern, false);
+ OperatorTest.assertSuccess(Operator.NOT_LIKE, new SimpleString("12993"), pattern, false);
+ OperatorTest.assertSuccess(Operator.NOT_LIKE, new SimpleString("1234"), pattern, true);
+ OperatorTest.assertSuccess(Operator.NOT_LIKE, null, pattern, null);
+ }
+
+ public void test_NOT_LIKE_ESCAPE() throws Exception
+ {
+ SimpleString pattern = new SimpleString("\\_%");
+ SimpleString escapeChar = new SimpleString("\\");
+ OperatorTest.assertSuccess(Operator.NOT_LIKE_ESCAPE, new SimpleString("_foo"), pattern, escapeChar, false);
+ OperatorTest.assertSuccess(Operator.NOT_LIKE_ESCAPE, new SimpleString("bar"), pattern, escapeChar, true);
+ OperatorTest.assertSuccess(Operator.NOT_LIKE_ESCAPE, null, pattern, escapeChar, null);
+
+ OperatorTest.assertFailure(Operator.NOT_LIKE_ESCAPE,
+ new SimpleString("_foo"),
+ pattern,
+ new SimpleString("must be a single char"));
+ }
+}
Copied: trunk/hornetq-core/src/test/java/org/hornetq/util/CompressionUtilTest.java (from rev 12016, trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/CompressionUtilTest.java)
===================================================================
--- trunk/hornetq-core/src/test/java/org/hornetq/util/CompressionUtilTest.java (rev 0)
+++ trunk/hornetq-core/src/test/java/org/hornetq/util/CompressionUtilTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -0,0 +1,193 @@
+/*
+ * Copyright 2010 Red Hat, Inc.
+ * Red Hat licenses this file to you under the Apache License, version
+ * 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package org.hornetq.util;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.zip.Deflater;
+
+import junit.framework.TestCase;
+
+import org.hornetq.utils.DeflaterReader;
+import org.hornetq.utils.InflaterReader;
+import org.hornetq.utils.InflaterWriter;
+
+/**
+ * A CompressionUtilTest
+ *
+ * @author <a href="mailto:hgao at redhat.com">Howard Gao</a>
+ *
+ */
+public class CompressionUtilTest extends TestCase
+{
+
+ public void testDeflaterReader() throws Exception
+ {
+ String inputString = "blahblahblah??blahblahblahblahblah??blablahblah??blablahblah??bla";
+ byte[] input = inputString.getBytes("UTF-8");
+
+ ByteArrayInputStream inputStream = new ByteArrayInputStream(input);
+
+ AtomicLong counter = new AtomicLong(0);
+ DeflaterReader reader = new DeflaterReader(inputStream, counter);
+
+ ArrayList<Integer> zipHolder = new ArrayList<Integer>();
+ int b = reader.read();
+
+ while (b != -1)
+ {
+ zipHolder.add(b);
+ b = reader.read();
+ }
+
+ assertEquals(input.length, counter.get());
+
+ byte[] allCompressed = new byte[zipHolder.size()];
+ for (int i = 0; i < allCompressed.length; i++)
+ {
+ allCompressed[i] = (byte) zipHolder.get(i).intValue();
+ }
+
+ byte[] output = new byte[30];
+ Deflater compresser = new Deflater();
+ compresser.setInput(input);
+ compresser.finish();
+ int compressedDataLength = compresser.deflate(output);
+
+ compareByteArray(allCompressed, output, compressedDataLength);
+ }
+
+ public void testDeflaterReader2() throws Exception
+ {
+ String inputString = "blahblahblah??blahblahblahblahblah??blablahblah??blablahblah??bla";
+ byte[] input = inputString.getBytes("UTF-8");
+
+ ByteArrayInputStream inputStream = new ByteArrayInputStream(input);
+ AtomicLong counter = new AtomicLong(0);
+
+ DeflaterReader reader = new DeflaterReader(inputStream, counter);
+
+ byte[] buffer = new byte[7];
+ ArrayList<Integer> zipHolder = new ArrayList<Integer>();
+
+ int n = reader.read(buffer);
+ while (n != -1)
+ {
+ for (int i = 0; i < n; i++)
+ {
+ zipHolder.add((int)buffer[i]);
+ }
+ n = reader.read(buffer);
+ }
+
+ assertEquals(input.length, counter.get());
+
+ byte[] allCompressed = new byte[zipHolder.size()];
+ for (int i = 0; i < allCompressed.length; i++)
+ {
+ allCompressed[i] = (byte) zipHolder.get(i).intValue();
+ }
+
+ byte[] output = new byte[30];
+ Deflater compresser = new Deflater();
+ compresser.setInput(input);
+ compresser.finish();
+ int compressedDataLength = compresser.deflate(output);
+
+ compareByteArray(allCompressed, output, compressedDataLength);
+ }
+
+ public void testInflaterReader() throws Exception
+ {
+ String inputString = "blahblahblah??blahblahblahblahblah??blablahblah??blablahblah??bla";
+ byte[] input = inputString.getBytes("UTF-8");
+ byte[] output = new byte[30];
+ Deflater compresser = new Deflater();
+ compresser.setInput(input);
+ compresser.finish();
+ int compressedDataLength = compresser.deflate(output);
+
+ byte[] zipBytes = new byte[compressedDataLength];
+
+ System.arraycopy(output, 0, zipBytes, 0, compressedDataLength);
+ ByteArrayInputStream byteInput = new ByteArrayInputStream(zipBytes);
+
+ InflaterReader inflater = new InflaterReader(byteInput);
+ ArrayList<Integer> holder = new ArrayList<Integer>();
+ int read = inflater.read();
+
+ while (read != -1)
+ {
+ holder.add(read);
+ read = inflater.read();
+ }
+
+ byte[] result = new byte[holder.size()];
+
+ for (int i = 0; i < result.length; i++)
+ {
+ result[i] = holder.get(i).byteValue();
+ }
+
+ String txt = new String(result);
+
+ assertEquals(inputString, txt);
+
+ }
+
+ public void testInflaterWriter() throws Exception
+ {
+ String inputString = "blahblahblah??blahblahblahblahblah??blablahblah??blablahblah??bla";
+ byte[] input = inputString.getBytes("UTF-8");
+ byte[] output = new byte[30];
+ Deflater compresser = new Deflater();
+ compresser.setInput(input);
+ compresser.finish();
+ int compressedDataLength = compresser.deflate(output);
+
+ byte[] zipBytes = new byte[compressedDataLength];
+
+ System.arraycopy(output, 0, zipBytes, 0, compressedDataLength);
+ ByteArrayInputStream byteInput = new ByteArrayInputStream(zipBytes);
+
+ ByteArrayOutputStream byteOutput = new ByteArrayOutputStream();
+ InflaterWriter writer = new InflaterWriter(byteOutput);
+
+ byte[] zipBuffer = new byte[12];
+
+ int n = byteInput.read(zipBuffer);
+ while (n > 0)
+ {
+ writer.write(zipBuffer, 0, n);
+ n = byteInput.read(zipBuffer);
+ }
+
+ writer.close();
+
+ byte[] outcome = byteOutput.toByteArray();
+ String outStr = new String(outcome);
+
+ assertEquals(inputString, outStr);
+ }
+
+ private void compareByteArray(byte[] first, byte[] second, int length)
+ {
+ for (int i = 0; i < length; i++)
+ {
+ assertEquals(first[i], second[i]);
+ }
+ }
+}
Copied: trunk/hornetq-core/src/test/java/org/hornetq/util/ConcurrentHashSetTest.java (from rev 12016, trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/ConcurrentHashSetTest.java)
===================================================================
--- trunk/hornetq-core/src/test/java/org/hornetq/util/ConcurrentHashSetTest.java (rev 0)
+++ trunk/hornetq-core/src/test/java/org/hornetq/util/ConcurrentHashSetTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2009 Red Hat, Inc.
+ * Red Hat licenses this file to you under the Apache License, version
+ * 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package org.hornetq.util;
+
+import java.util.Iterator;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.hornetq.tests.util.RandomUtil;
+import org.hornetq.utils.ConcurrentHashSet;
+import org.hornetq.utils.ConcurrentSet;
+
+/**
+ * @author <a href="mailto:jmesnil at redhat.com">Jeff Mesnil</a>
+ *
+ * @version <tt>$Revision$</tt>
+ *
+ */
+public class ConcurrentHashSetTest extends TestCase
+{
+ // Constants -----------------------------------------------------
+
+ // Attributes ----------------------------------------------------
+
+ private ConcurrentSet<String> set;
+
+ private String element;
+
+ // Static --------------------------------------------------------
+
+ // Constructors --------------------------------------------------
+
+ // Public --------------------------------------------------------
+
+ public void testAdd() throws Exception
+ {
+ Assert.assertTrue(set.add(element));
+ Assert.assertFalse(set.add(element));
+ }
+
+ public void testAddIfAbsent() throws Exception
+ {
+ Assert.assertTrue(set.addIfAbsent(element));
+ Assert.assertFalse(set.addIfAbsent(element));
+ }
+
+ public void testRemove() throws Exception
+ {
+ Assert.assertTrue(set.add(element));
+
+ Assert.assertTrue(set.remove(element));
+ Assert.assertFalse(set.remove(element));
+ }
+
+ public void testContains() throws Exception
+ {
+ Assert.assertFalse(set.contains(element));
+
+ Assert.assertTrue(set.add(element));
+ Assert.assertTrue(set.contains(element));
+
+ Assert.assertTrue(set.remove(element));
+ Assert.assertFalse(set.contains(element));
+ }
+
+ public void testSize() throws Exception
+ {
+ Assert.assertEquals(0, set.size());
+
+ Assert.assertTrue(set.add(element));
+ Assert.assertEquals(1, set.size());
+
+ Assert.assertTrue(set.remove(element));
+ Assert.assertEquals(0, set.size());
+ }
+
+ public void testClear() throws Exception
+ {
+ Assert.assertTrue(set.add(element));
+
+ Assert.assertTrue(set.contains(element));
+ set.clear();
+ Assert.assertFalse(set.contains(element));
+ }
+
+ public void testIsEmpty() throws Exception
+ {
+ Assert.assertTrue(set.isEmpty());
+
+ Assert.assertTrue(set.add(element));
+ Assert.assertFalse(set.isEmpty());
+
+ set.clear();
+ Assert.assertTrue(set.isEmpty());
+ }
+
+ public void testIterator() throws Exception
+ {
+ set.add(element);
+
+ Iterator<String> iterator = set.iterator();
+ while (iterator.hasNext())
+ {
+ String e = iterator.next();
+ Assert.assertEquals(element, e);
+ }
+ }
+
+ // TestCase overrides --------------------------------------------
+
+ @Override
+ protected void setUp() throws Exception
+ {
+ super.setUp();
+
+ set = new ConcurrentHashSet<String>();
+ element = RandomUtil.randomString();
+ }
+
+ @Override
+ protected void tearDown() throws Exception
+ {
+ set = null;
+ element = null;
+
+ super.tearDown();
+ }
+ // Package protected ---------------------------------------------
+
+ // Protected -----------------------------------------------------
+
+ // Private -------------------------------------------------------
+
+ // Inner classes -------------------------------------------------
+}
Copied: trunk/hornetq-core/src/test/java/org/hornetq/util/TimeAndCounterIDGeneratorTest.java (from rev 12016, trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TimeAndCounterIDGeneratorTest.java)
===================================================================
--- trunk/hornetq-core/src/test/java/org/hornetq/util/TimeAndCounterIDGeneratorTest.java (rev 0)
+++ trunk/hornetq-core/src/test/java/org/hornetq/util/TimeAndCounterIDGeneratorTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -0,0 +1,197 @@
+/*
+ * Copyright 2009 Red Hat, Inc.
+ * Red Hat licenses this file to you under the Apache License, version
+ * 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package org.hornetq.util;
+
+import java.util.concurrent.CountDownLatch;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.hornetq.utils.ConcurrentHashSet;
+import org.hornetq.utils.TimeAndCounterIDGenerator;
+
+/**
+ * A TimeAndCounterIDGeneratorTest
+ *
+ * @author <a href="mailto:clebert.suconic at jboss.org">Clebert Suconic</a> Created 24-Sep-08 3:42:25 PM
+ */
+public class TimeAndCounterIDGeneratorTest extends TestCase
+{
+
+ // Constants -----------------------------------------------------
+
+ // Attributes ----------------------------------------------------
+
+ // Static --------------------------------------------------------
+
+ // Constructors --------------------------------------------------
+
+ // Public --------------------------------------------------------
+
+ public void testCalculation()
+ {
+ TimeAndCounterIDGenerator seq = new TimeAndCounterIDGenerator();
+ long max = 11000;
+
+ long lastNr = 0;
+
+ for (long i = 0; i < max; i++)
+ {
+ long seqNr = seq.generateID();
+
+ Assert.assertTrue("The sequence generator should aways generate crescent numbers", seqNr > lastNr);
+
+ lastNr = seqNr;
+ }
+
+ }
+
+ public void testCalculationRefresh()
+ {
+ TimeAndCounterIDGenerator seq = new TimeAndCounterIDGenerator();
+
+ long id1 = seq.generateID();
+ Assert.assertEquals(1, id1 & 0xffff);
+ Assert.assertEquals(2, seq.generateID() & 0xffff);
+
+ seq.refresh();
+
+ long id2 = seq.generateID();
+
+ Assert.assertTrue(id2 > id1);
+
+ Assert.assertEquals(1, id2 & 0xffff);
+
+ }
+
+ public void testCalculationOnMultiThread() throws Throwable
+ {
+ final ConcurrentHashSet<Long> hashSet = new ConcurrentHashSet<Long>();
+
+ final TimeAndCounterIDGenerator seq = new TimeAndCounterIDGenerator();
+
+ System.out.println("Time = " + TimeAndCounterIDGeneratorTest.hex(System.currentTimeMillis()) + ", " + seq);
+
+ final int NUMBER_OF_THREADS = 100;
+
+ final int NUMBER_OF_IDS = 10;
+
+ final CountDownLatch latchAlign = new CountDownLatch(NUMBER_OF_THREADS);
+
+ final CountDownLatch latchStart = new CountDownLatch(1);
+
+ class T1 extends Thread
+ {
+ Throwable e;
+
+ @Override
+ public void run()
+ {
+ try
+ {
+ latchAlign.countDown();
+ latchStart.await();
+
+ long lastValue = 0l;
+ for (int i = 0; i < NUMBER_OF_IDS; i++)
+ {
+ long value = seq.generateID();
+ Assert.assertTrue(TimeAndCounterIDGeneratorTest.hex(value) + " should be greater than " +
+ TimeAndCounterIDGeneratorTest.hex(lastValue) +
+ " on seq " +
+ seq.toString(), value > lastValue);
+ lastValue = value;
+
+ hashSet.add(value);
+ }
+ }
+ catch (Throwable e)
+ {
+ this.e = e;
+ }
+ }
+
+ };
+
+ T1[] arrays = new T1[NUMBER_OF_THREADS];
+
+ for (int i = 0; i < arrays.length; i++)
+ {
+ arrays[i] = new T1();
+ arrays[i].start();
+ }
+
+ latchAlign.await();
+
+ latchStart.countDown();
+
+ for (T1 t : arrays)
+ {
+ t.join();
+ if (t.e != null)
+ {
+ throw t.e;
+ }
+ }
+
+ Assert.assertEquals(NUMBER_OF_THREADS * NUMBER_OF_IDS, hashSet.size());
+
+ hashSet.clear();
+
+ }
+
+ public void testWrapID() throws Throwable
+ {
+ final ConcurrentHashSet<Long> hashSet = new org.hornetq.utils.ConcurrentHashSet<Long>();
+
+ TimeAndCounterIDGenerator seq = new TimeAndCounterIDGenerator();
+
+ System.out.println("Current Time = " + TimeAndCounterIDGeneratorTest.hex(System.currentTimeMillis()) + " " + seq);
+
+ seq.setInternalDate(System.currentTimeMillis() + 10000l); // 10 seconds in the future
+
+ seq.setInternalID(TimeAndCounterIDGenerator.ID_MASK); // 1 ID about to explode
+
+ try
+ {
+ // This is simulating a situation where we generated more than 268 million messages on the same time interval
+ seq.generateID();
+ Assert.fail("It was supposed to throw an exception, as the counter was set to explode on this test");
+ }
+ catch (Exception e)
+ {
+ }
+
+ seq = new TimeAndCounterIDGenerator();
+
+ seq.setInternalDate(System.currentTimeMillis() - 10000l); // 10 seconds in the past
+
+ long timeMark = seq.getInternalTimeMark();
+
+ seq.setInternalID(TimeAndCounterIDGenerator.ID_MASK); // 1 ID about to explode
+
+ // This is ok... the time portion would be added to the next one generated 10 seconds ago
+ seq.generateID();
+
+ Assert.assertTrue(TimeAndCounterIDGeneratorTest.hex(timeMark) + " < " +
+ TimeAndCounterIDGeneratorTest.hex(seq.getInternalTimeMark()),
+ timeMark < seq.getInternalTimeMark());
+ }
+
+ private static String hex(final long value)
+ {
+ return String.format("%1$X", value);
+ }
+
+}
Copied: trunk/hornetq-core/src/test/java/org/hornetq/util/TypedPropertiesConversionTest.java (from rev 12016, trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TypedPropertiesConversionTest.java)
===================================================================
--- trunk/hornetq-core/src/test/java/org/hornetq/util/TypedPropertiesConversionTest.java (rev 0)
+++ trunk/hornetq-core/src/test/java/org/hornetq/util/TypedPropertiesConversionTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -0,0 +1,364 @@
+/*
+ * Copyright 2009 Red Hat, Inc.
+ * Red Hat licenses this file to you under the Apache License, version
+ * 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package org.hornetq.util;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.hornetq.api.core.PropertyConversionException;
+import org.hornetq.api.core.SimpleString;
+import org.hornetq.tests.util.RandomUtil;
+import org.hornetq.tests.util.UnitTestCase;
+import org.hornetq.utils.TypedProperties;
+
+/**
+ * A TypedPropertiesConversionTest
+ *
+ * @author jmesnil
+ *
+ *
+ */
+public class TypedPropertiesConversionTest extends TestCase
+{
+
+ // Constants -----------------------------------------------------
+
+ // Attributes ----------------------------------------------------
+
+ private TypedProperties props;
+
+ private SimpleString key;
+
+ private final SimpleString unknownKey = new SimpleString("this.key.is.never.used");
+
+ // Static --------------------------------------------------------
+
+ // Constructors --------------------------------------------------
+
+ // Public --------------------------------------------------------
+
+ @Override
+ protected void setUp() throws Exception
+ {
+ super.setUp();
+
+ key = RandomUtil.randomSimpleString();
+ props = new TypedProperties();
+ }
+
+ @Override
+ protected void tearDown() throws Exception
+ {
+ key = null;
+ props = null;
+
+ super.tearDown();
+ }
+
+ public void testBooleanProperty() throws Exception
+ {
+ Boolean val = RandomUtil.randomBoolean();
+ props.putBooleanProperty(key, val);
+
+ Assert.assertEquals(val, props.getBooleanProperty(key));
+ Assert.assertEquals(new SimpleString(Boolean.toString(val)), props.getSimpleStringProperty(key));
+
+ props.putSimpleStringProperty(key, new SimpleString(Boolean.toString(val)));
+ Assert.assertEquals(val, props.getBooleanProperty(key));
+
+ try
+ {
+ props.putByteProperty(key, RandomUtil.randomByte());
+ props.getBooleanProperty(key);
+ Assert.fail();
+ }
+ catch (PropertyConversionException e)
+ {
+ }
+
+ Assert.assertFalse(props.getBooleanProperty(unknownKey));
+ }
+
+ public void testCharProperty() throws Exception
+ {
+ Character val = RandomUtil.randomChar();
+ props.putCharProperty(key, val);
+
+ Assert.assertEquals(val, props.getCharProperty(key));
+ Assert.assertEquals(new SimpleString(Character.toString(val)), props.getSimpleStringProperty(key));
+
+ try
+ {
+ props.putByteProperty(key, RandomUtil.randomByte());
+ props.getCharProperty(key);
+ Assert.fail();
+ }
+ catch (PropertyConversionException e)
+ {
+ }
+
+ try
+ {
+ props.getCharProperty(unknownKey);
+ Assert.fail();
+ }
+ catch (NullPointerException e)
+ {
+ }
+ }
+
+ public void testByteProperty() throws Exception
+ {
+ Byte val = RandomUtil.randomByte();
+ props.putByteProperty(key, val);
+
+ Assert.assertEquals(val, props.getByteProperty(key));
+ Assert.assertEquals(new SimpleString(Byte.toString(val)), props.getSimpleStringProperty(key));
+
+ props.putSimpleStringProperty(key, new SimpleString(Byte.toString(val)));
+ Assert.assertEquals(val, props.getByteProperty(key));
+
+ try
+ {
+ props.putBooleanProperty(key, RandomUtil.randomBoolean());
+ props.getByteProperty(key);
+ Assert.fail();
+ }
+ catch (PropertyConversionException e)
+ {
+ }
+
+ try
+ {
+ props.getByteProperty(unknownKey);
+ Assert.fail();
+ }
+ catch (NumberFormatException e)
+ {
+ }
+ }
+
+ public void testIntProperty() throws Exception
+ {
+ Integer val = RandomUtil.randomInt();
+ props.putIntProperty(key, val);
+
+ Assert.assertEquals(val, props.getIntProperty(key));
+ Assert.assertEquals(new SimpleString(Integer.toString(val)), props.getSimpleStringProperty(key));
+
+ props.putSimpleStringProperty(key, new SimpleString(Integer.toString(val)));
+ Assert.assertEquals(val, props.getIntProperty(key));
+
+ Byte byteVal = RandomUtil.randomByte();
+ props.putByteProperty(key, byteVal);
+ Assert.assertEquals(Integer.valueOf(byteVal), props.getIntProperty(key));
+
+ try
+ {
+ props.putBooleanProperty(key, RandomUtil.randomBoolean());
+ props.getIntProperty(key);
+ Assert.fail();
+ }
+ catch (PropertyConversionException e)
+ {
+ }
+
+ try
+ {
+ props.getIntProperty(unknownKey);
+ Assert.fail();
+ }
+ catch (NumberFormatException e)
+ {
+ }
+ }
+
+ public void testLongProperty() throws Exception
+ {
+ Long val = RandomUtil.randomLong();
+ props.putLongProperty(key, val);
+
+ Assert.assertEquals(val, props.getLongProperty(key));
+ Assert.assertEquals(new SimpleString(Long.toString(val)), props.getSimpleStringProperty(key));
+
+ props.putSimpleStringProperty(key, new SimpleString(Long.toString(val)));
+ Assert.assertEquals(val, props.getLongProperty(key));
+
+ Byte byteVal = RandomUtil.randomByte();
+ props.putByteProperty(key, byteVal);
+ Assert.assertEquals(Long.valueOf(byteVal), props.getLongProperty(key));
+
+ Short shortVal = RandomUtil.randomShort();
+ props.putShortProperty(key, shortVal);
+ Assert.assertEquals(Long.valueOf(shortVal), props.getLongProperty(key));
+
+ Integer intVal = RandomUtil.randomInt();
+ props.putIntProperty(key, intVal);
+ Assert.assertEquals(Long.valueOf(intVal), props.getLongProperty(key));
+
+ try
+ {
+ props.putBooleanProperty(key, RandomUtil.randomBoolean());
+ props.getLongProperty(key);
+ Assert.fail();
+ }
+ catch (PropertyConversionException e)
+ {
+ }
+
+ try
+ {
+ props.getLongProperty(unknownKey);
+ Assert.fail();
+ }
+ catch (NumberFormatException e)
+ {
+ }
+ }
+
+ public void testDoubleProperty() throws Exception
+ {
+ Double val = RandomUtil.randomDouble();
+ props.putDoubleProperty(key, val);
+
+ Assert.assertEquals(val, props.getDoubleProperty(key));
+ Assert.assertEquals(new SimpleString(Double.toString(val)), props.getSimpleStringProperty(key));
+
+ props.putSimpleStringProperty(key, new SimpleString(Double.toString(val)));
+ Assert.assertEquals(val, props.getDoubleProperty(key));
+
+ try
+ {
+ props.putBooleanProperty(key, RandomUtil.randomBoolean());
+ props.getDoubleProperty(key);
+ Assert.fail();
+ }
+ catch (PropertyConversionException e)
+ {
+ }
+
+ try
+ {
+ props.getDoubleProperty(unknownKey);
+ Assert.fail();
+ }
+ catch (Exception e)
+ {
+ }
+ }
+
+ public void testFloatProperty() throws Exception
+ {
+ Float val = RandomUtil.randomFloat();
+ props.putFloatProperty(key, val);
+
+ Assert.assertEquals(val, props.getFloatProperty(key));
+ Assert.assertEquals(Double.valueOf(val), props.getDoubleProperty(key));
+ Assert.assertEquals(new SimpleString(Float.toString(val)), props.getSimpleStringProperty(key));
+
+ props.putSimpleStringProperty(key, new SimpleString(Float.toString(val)));
+ Assert.assertEquals(val, props.getFloatProperty(key));
+
+ try
+ {
+ props.putBooleanProperty(key, RandomUtil.randomBoolean());
+ props.getFloatProperty(key);
+ Assert.fail();
+ }
+ catch (PropertyConversionException e)
+ {
+ }
+
+ try
+ {
+ props.getFloatProperty(unknownKey);
+ Assert.fail();
+ }
+ catch (Exception e)
+ {
+ }
+ }
+
+ public void testShortProperty() throws Exception
+ {
+ Short val = RandomUtil.randomShort();
+ props.putShortProperty(key, val);
+
+ Assert.assertEquals(val, props.getShortProperty(key));
+ Assert.assertEquals(Integer.valueOf(val), props.getIntProperty(key));
+ Assert.assertEquals(new SimpleString(Short.toString(val)), props.getSimpleStringProperty(key));
+
+ props.putSimpleStringProperty(key, new SimpleString(Short.toString(val)));
+ Assert.assertEquals(val, props.getShortProperty(key));
+
+ Byte byteVal = RandomUtil.randomByte();
+ props.putByteProperty(key, byteVal);
+ Assert.assertEquals(Short.valueOf(byteVal), props.getShortProperty(key));
+
+ try
+ {
+ props.putBooleanProperty(key, RandomUtil.randomBoolean());
+ props.getShortProperty(key);
+ Assert.fail();
+ }
+ catch (PropertyConversionException e)
+ {
+ }
+
+ try
+ {
+ props.getShortProperty(unknownKey);
+ Assert.fail();
+ }
+ catch (NumberFormatException e)
+ {
+ }
+ }
+
+ public void testSimpleStringProperty() throws Exception
+ {
+ SimpleString strVal = RandomUtil.randomSimpleString();
+ props.putSimpleStringProperty(key, strVal);
+ Assert.assertEquals(strVal, props.getSimpleStringProperty(key));
+ }
+
+ public void testBytesProperty() throws Exception
+ {
+ byte[] val = RandomUtil.randomBytes();
+ props.putBytesProperty(key, val);
+
+ UnitTestCase.assertEqualsByteArrays(val, props.getBytesProperty(key));
+
+ try
+ {
+ props.putBooleanProperty(key, RandomUtil.randomBoolean());
+ props.getBytesProperty(key);
+ Assert.fail();
+ }
+ catch (PropertyConversionException e)
+ {
+ }
+
+ Assert.assertNull(props.getBytesProperty(unknownKey));
+ }
+
+ // Package protected ---------------------------------------------
+
+ // Protected -----------------------------------------------------
+
+ // Private -------------------------------------------------------
+
+ // Inner classes -------------------------------------------------
+
+}
Copied: trunk/hornetq-core/src/test/java/org/hornetq/util/TypedPropertiesTest.java (from rev 12016, trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TypedPropertiesTest.java)
===================================================================
--- trunk/hornetq-core/src/test/java/org/hornetq/util/TypedPropertiesTest.java (rev 0)
+++ trunk/hornetq-core/src/test/java/org/hornetq/util/TypedPropertiesTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -0,0 +1,248 @@
+/*
+ * Copyright 2009 Red Hat, Inc.
+ * Red Hat licenses this file to you under the Apache License, version
+ * 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package org.hornetq.util;
+import java.util.Iterator;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.hornetq.api.core.HornetQBuffer;
+import org.hornetq.api.core.HornetQBuffers;
+import org.hornetq.api.core.SimpleString;
+import org.hornetq.tests.util.RandomUtil;
+import org.hornetq.tests.util.UnitTestCase;
+import org.hornetq.utils.TypedProperties;
+
+/**
+ * @author <a href="mailto:jmesnil at redhat.com">Jeff Mesnil</a>
+ */
+public class TypedPropertiesTest extends TestCase
+{
+
+ private static void assertEqualsTypeProperties(final TypedProperties expected, final TypedProperties actual)
+ {
+ Assert.assertNotNull(expected);
+ Assert.assertNotNull(actual);
+ Assert.assertEquals(expected.getEncodeSize(), actual.getEncodeSize());
+ Assert.assertEquals(expected.getPropertyNames(), actual.getPropertyNames());
+ Iterator<SimpleString> iterator = actual.getPropertyNames().iterator();
+ while (iterator.hasNext())
+ {
+ SimpleString key = iterator.next();
+ Object expectedValue = expected.getProperty(key);
+ Object actualValue = actual.getProperty(key);
+ if (expectedValue instanceof byte[] && actualValue instanceof byte[])
+ {
+ byte[] expectedBytes = (byte[])expectedValue;
+ byte[] actualBytes = (byte[])actualValue;
+ UnitTestCase.assertEqualsByteArrays(expectedBytes, actualBytes);
+ }
+ else
+ {
+ Assert.assertEquals(expectedValue, actualValue);
+ }
+ }
+ }
+
+ // Constructors --------------------------------------------------
+
+ // Public --------------------------------------------------------
+
+ private TypedProperties props;
+
+ private SimpleString key;
+
+ public void testCopyContructor() throws Exception
+ {
+ props.putSimpleStringProperty(key, RandomUtil.randomSimpleString());
+
+ TypedProperties copy = new TypedProperties(props);
+
+ Assert.assertEquals(props.getEncodeSize(), copy.getEncodeSize());
+ Assert.assertEquals(props.getPropertyNames(), copy.getPropertyNames());
+
+ Assert.assertTrue(copy.containsProperty(key));
+ Assert.assertEquals(props.getProperty(key), copy.getProperty(key));
+ }
+
+ public void testRemove() throws Exception
+ {
+ props.putSimpleStringProperty(key, RandomUtil.randomSimpleString());
+
+ Assert.assertTrue(props.containsProperty(key));
+ Assert.assertNotNull(props.getProperty(key));
+
+ props.removeProperty(key);
+
+ Assert.assertFalse(props.containsProperty(key));
+ Assert.assertNull(props.getProperty(key));
+ }
+
+ public void testClear() throws Exception
+ {
+ props.putSimpleStringProperty(key, RandomUtil.randomSimpleString());
+
+ Assert.assertTrue(props.containsProperty(key));
+ Assert.assertNotNull(props.getProperty(key));
+
+ props.clear();
+
+ Assert.assertFalse(props.containsProperty(key));
+ Assert.assertNull(props.getProperty(key));
+ }
+
+ public void testKey() throws Exception
+ {
+ props.putBooleanProperty(key, true);
+ boolean bool = (Boolean)props.getProperty(key);
+ Assert.assertEquals(true, bool);
+
+ props.putCharProperty(key, 'a');
+ char c = (Character)props.getProperty(key);
+ Assert.assertEquals('a', c);
+ }
+
+ public void testGetPropertyOnEmptyProperties() throws Exception
+ {
+ Assert.assertFalse(props.containsProperty(key));
+ Assert.assertNull(props.getProperty(key));
+ }
+
+ public void testRemovePropertyOnEmptyProperties() throws Exception
+ {
+ Assert.assertFalse(props.containsProperty(key));
+ Assert.assertNull(props.removeProperty(key));
+ }
+
+ public void testNullProperty() throws Exception
+ {
+ props.putSimpleStringProperty(key, null);
+ Assert.assertTrue(props.containsProperty(key));
+ Assert.assertNull(props.getProperty(key));
+ }
+
+ public void testBytesPropertyWithNull() throws Exception
+ {
+ props.putBytesProperty(key, null);
+
+ Assert.assertTrue(props.containsProperty(key));
+ byte[] bb = (byte[])props.getProperty(key);
+ Assert.assertNull(bb);
+ }
+
+ public void testTypedProperties() throws Exception
+ {
+ SimpleString longKey = RandomUtil.randomSimpleString();
+ long longValue = RandomUtil.randomLong();
+ SimpleString simpleStringKey = RandomUtil.randomSimpleString();
+ SimpleString simpleStringValue = RandomUtil.randomSimpleString();
+ TypedProperties otherProps = new TypedProperties();
+ otherProps.putLongProperty(longKey, longValue);
+ otherProps.putSimpleStringProperty(simpleStringKey, simpleStringValue);
+
+ props.putTypedProperties(otherProps);
+
+ long ll = props.getLongProperty(longKey);
+ Assert.assertEquals(longValue, ll);
+ SimpleString ss = props.getSimpleStringProperty(simpleStringKey);
+ Assert.assertEquals(simpleStringValue, ss);
+ }
+
+ public void testEmptyTypedProperties() throws Exception
+ {
+ Assert.assertEquals(0, props.getPropertyNames().size());
+
+ props.putTypedProperties(new TypedProperties());
+
+ Assert.assertEquals(0, props.getPropertyNames().size());
+ }
+
+ public void testNullTypedProperties() throws Exception
+ {
+ Assert.assertEquals(0, props.getPropertyNames().size());
+
+ props.putTypedProperties(null);
+
+ Assert.assertEquals(0, props.getPropertyNames().size());
+ }
+
+ public void testEncodeDecode() throws Exception
+ {
+ props.putByteProperty(RandomUtil.randomSimpleString(), RandomUtil.randomByte());
+ props.putBytesProperty(RandomUtil.randomSimpleString(), RandomUtil.randomBytes());
+ props.putBytesProperty(RandomUtil.randomSimpleString(), null);
+ props.putBooleanProperty(RandomUtil.randomSimpleString(), RandomUtil.randomBoolean());
+ props.putShortProperty(RandomUtil.randomSimpleString(), RandomUtil.randomShort());
+ props.putIntProperty(RandomUtil.randomSimpleString(), RandomUtil.randomInt());
+ props.putLongProperty(RandomUtil.randomSimpleString(), RandomUtil.randomLong());
+ props.putFloatProperty(RandomUtil.randomSimpleString(), RandomUtil.randomFloat());
+ props.putDoubleProperty(RandomUtil.randomSimpleString(), RandomUtil.randomDouble());
+ props.putCharProperty(RandomUtil.randomSimpleString(), RandomUtil.randomChar());
+ props.putSimpleStringProperty(RandomUtil.randomSimpleString(), RandomUtil.randomSimpleString());
+ props.putSimpleStringProperty(RandomUtil.randomSimpleString(), null);
+ SimpleString keyToRemove = RandomUtil.randomSimpleString();
+ props.putSimpleStringProperty(keyToRemove, RandomUtil.randomSimpleString());
+
+ HornetQBuffer buffer = HornetQBuffers.dynamicBuffer(1024);
+ props.encode(buffer);
+
+ Assert.assertEquals(props.getEncodeSize(), buffer.writerIndex());
+
+ TypedProperties decodedProps = new TypedProperties();
+ decodedProps.decode(buffer);
+
+ TypedPropertiesTest.assertEqualsTypeProperties(props, decodedProps);
+
+ buffer.clear();
+
+ // After removing a property, you should still be able to encode the Property
+ props.removeProperty(keyToRemove);
+ props.encode(buffer);
+
+ Assert.assertEquals(props.getEncodeSize(), buffer.writerIndex());
+ }
+
+ public void testEncodeDecodeEmpty() throws Exception
+ {
+ TypedProperties emptyProps = new TypedProperties();
+
+ HornetQBuffer buffer = HornetQBuffers.dynamicBuffer(1024);
+ emptyProps.encode(buffer);
+
+ Assert.assertEquals(props.getEncodeSize(), buffer.writerIndex());
+
+ TypedProperties decodedProps = new TypedProperties();
+ decodedProps.decode(buffer);
+
+ TypedPropertiesTest.assertEqualsTypeProperties(emptyProps, decodedProps);
+ }
+
+ @Override
+ protected void setUp() throws Exception
+ {
+ super.setUp();
+
+ props = new TypedProperties();
+ key = RandomUtil.randomSimpleString();
+ }
+
+ @Override
+ protected void tearDown() throws Exception
+ {
+ key = null;
+ props = null;
+
+ super.tearDown();
+ }
+}
Copied: trunk/hornetq-core/src/test/java/org/hornetq/util/XMLUtilTest.java (from rev 12016, trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/XMLUtilTest.java)
===================================================================
--- trunk/hornetq-core/src/test/java/org/hornetq/util/XMLUtilTest.java (rev 0)
+++ trunk/hornetq-core/src/test/java/org/hornetq/util/XMLUtilTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -0,0 +1,256 @@
+/*
+ * Copyright 2009 Red Hat, Inc.
+ * Red Hat licenses this file to you under the Apache License, version
+ * 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package org.hornetq.util;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.hornetq.utils.XMLUtil;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ * @author <a href="mailto:ovidiu at feodorov.com">Ovidiu Feodorov</a>
+ * @version <tt>$Revision$</tt>
+ */
+public class XMLUtilTest extends TestCase
+{
+ // Constructors --------------------------------------------------
+
+ // Public --------------------------------------------------------
+
+ public void testGetTextContext_1() throws Exception
+ {
+ String document = "<blah>foo</blah>";
+
+ Element e = org.hornetq.utils.XMLUtil.stringToElement(document);
+
+ Assert.assertEquals("foo", org.hornetq.utils.XMLUtil.getTextContent(e));
+ }
+
+ public void testGetTextContext_2() throws Exception
+ {
+ String document = "<blah someattribute=\"somevalue\">foo</blah>";
+
+ Element e = XMLUtil.stringToElement(document);
+
+ Assert.assertEquals("foo", org.hornetq.utils.XMLUtil.getTextContent(e));
+ }
+
+ public void testGetTextContext_3() throws Exception
+ {
+ String document = "<blah someattribute=\"somevalue\"><a/></blah>";
+
+ Element e = org.hornetq.utils.XMLUtil.stringToElement(document);
+
+ String s = org.hornetq.utils.XMLUtil.getTextContent(e);
+
+ Element subelement = org.hornetq.utils.XMLUtil.stringToElement(s);
+
+ Assert.assertEquals("a", subelement.getNodeName());
+ }
+
+ public void testGetTextContext_4() throws Exception
+ {
+ String document = "<blah someattribute=\"somevalue\"><a></a></blah>";
+
+ Element e = org.hornetq.utils.XMLUtil.stringToElement(document);
+
+ String s = org.hornetq.utils.XMLUtil.getTextContent(e);
+
+ Element subelement = org.hornetq.utils.XMLUtil.stringToElement(s);
+
+ Assert.assertEquals("a", subelement.getNodeName());
+ }
+
+ public void testGetTextContext_5() throws Exception
+ {
+ String document = "<blah someattribute=\"somevalue\"><a><b/></a></blah>";
+
+ Element e = org.hornetq.utils.XMLUtil.stringToElement(document);
+
+ String s = org.hornetq.utils.XMLUtil.getTextContent(e);
+
+ Element subelement = org.hornetq.utils.XMLUtil.stringToElement(s);
+
+ Assert.assertEquals("a", subelement.getNodeName());
+ NodeList nl = subelement.getChildNodes();
+
+ // try to find <b>
+ boolean found = false;
+ for (int i = 0; i < nl.getLength(); i++)
+ {
+ Node n = nl.item(i);
+ if ("b".equals(n.getNodeName()))
+ {
+ found = true;
+ }
+ }
+ Assert.assertTrue(found);
+ }
+
+ public void testEquivalent_1() throws Exception
+ {
+ String s = "<a/>";
+ String s2 = "<a/>";
+
+ XMLUtil.assertEquivalent(XMLUtil.stringToElement(s), org.hornetq.utils.XMLUtil.stringToElement(s2));
+ }
+
+ public void testEquivalent_2() throws Exception
+ {
+ String s = "<a></a>";
+ String s2 = "<a/>";
+
+ XMLUtil.assertEquivalent(XMLUtil.stringToElement(s), org.hornetq.utils.XMLUtil.stringToElement(s2));
+ }
+
+ public void testEquivalent_3() throws Exception
+ {
+ String s = "<a attr1=\"val1\" attr2=\"val2\"/>";
+ String s2 = "<a attr2=\"val2\"/>";
+
+ try
+ {
+ org.hornetq.utils.XMLUtil.assertEquivalent(org.hornetq.utils.XMLUtil.stringToElement(s),
+ XMLUtil.stringToElement(s2));
+ Assert.fail("this should throw exception");
+ }
+ catch (IllegalArgumentException e)
+ {
+ // OK
+ }
+ }
+
+ public void testEquivalent_4() throws Exception
+ {
+ String s = "<a attr1=\"val1\" attr2=\"val2\"/>";
+ String s2 = "<a attr2=\"val2\" attr1=\"val1\"/>";
+
+ org.hornetq.utils.XMLUtil.assertEquivalent(org.hornetq.utils.XMLUtil.stringToElement(s),
+ org.hornetq.utils.XMLUtil.stringToElement(s2));
+ }
+
+ public void testEquivalent_5() throws Exception
+ {
+ String s = "<a><b/></a>";
+ String s2 = "<a><b/></a>";
+
+ org.hornetq.utils.XMLUtil.assertEquivalent(org.hornetq.utils.XMLUtil.stringToElement(s),
+ org.hornetq.utils.XMLUtil.stringToElement(s2));
+ }
+
+ public void testEquivalent_6() throws Exception
+ {
+ String s = "<enclosing><a attr1=\"val1\" attr2=\"val2\"/></enclosing>";
+ String s2 = "<enclosing><a attr2=\"val2\" attr1=\"val1\"/></enclosing>";
+
+ org.hornetq.utils.XMLUtil.assertEquivalent(XMLUtil.stringToElement(s),
+ org.hornetq.utils.XMLUtil.stringToElement(s2));
+ }
+
+ public void testEquivalent_7() throws Exception
+ {
+ String s = "<a><b/><c/></a>";
+ String s2 = "<a><c/><b/></a>";
+
+ try
+ {
+ org.hornetq.utils.XMLUtil.assertEquivalent(org.hornetq.utils.XMLUtil.stringToElement(s),
+ org.hornetq.utils.XMLUtil.stringToElement(s2));
+ Assert.fail("this should throw exception");
+ }
+ catch (IllegalArgumentException e)
+ {
+ // OK
+ }
+ }
+
+ public void testEquivalent_8() throws Exception
+ {
+ String s = "<a><!-- some comment --><b/><!--some other comment --><c/><!-- blah --></a>";
+ String s2 = "<a><b/><!--blah blah--><c/></a>";
+
+ org.hornetq.utils.XMLUtil.assertEquivalent(XMLUtil.stringToElement(s),
+ org.hornetq.utils.XMLUtil.stringToElement(s2));
+ }
+
+ public void testElementToString_1() throws Exception
+ {
+ String s = "<a b=\"something\">somethingelse</a>";
+ Element e = org.hornetq.utils.XMLUtil.stringToElement(s);
+ String tostring = org.hornetq.utils.XMLUtil.elementToString(e);
+ Element convertedAgain = org.hornetq.utils.XMLUtil.stringToElement(tostring);
+ org.hornetq.utils.XMLUtil.assertEquivalent(e, convertedAgain);
+ }
+
+ public void testElementToString_2() throws Exception
+ {
+ String s = "<a b=\"something\"></a>";
+ Element e = org.hornetq.utils.XMLUtil.stringToElement(s);
+ String tostring = XMLUtil.elementToString(e);
+ Element convertedAgain = XMLUtil.stringToElement(tostring);
+ XMLUtil.assertEquivalent(e, convertedAgain);
+ }
+
+ public void testElementToString_3() throws Exception
+ {
+ String s = "<a b=\"something\"/>";
+ Element e = org.hornetq.utils.XMLUtil.stringToElement(s);
+ String tostring = XMLUtil.elementToString(e);
+ Element convertedAgain = org.hornetq.utils.XMLUtil.stringToElement(tostring);
+ org.hornetq.utils.XMLUtil.assertEquivalent(e, convertedAgain);
+ }
+
+ public void testElementToString_4() throws Exception
+ {
+ String s = "<a><![CDATA[somedata]]></a>";
+ Element e = org.hornetq.utils.XMLUtil.stringToElement(s);
+ String tostring = XMLUtil.elementToString(e);
+ Element convertedAgain = org.hornetq.utils.XMLUtil.stringToElement(tostring);
+ org.hornetq.utils.XMLUtil.assertEquivalent(e, convertedAgain);
+ }
+
+ public void testReplaceSystemProperties()
+ {
+ String before = "<configuration>\n" + " <test name=\"${sysprop1}\">content1</test>\n"
+ + " <test name=\"test2\">content2</test>\n"
+ + " <test name=\"test3\">content3</test>\n"
+ + " <test name=\"test4\">${sysprop2}</test>\n"
+ + " <test name=\"test5\">content5</test>\n"
+ + " <test name=\"test6\">content6</test>\n"
+ + "</configuration>";
+ String after = "<configuration>\n" + " <test name=\"test1\">content1</test>\n"
+ + " <test name=\"test2\">content2</test>\n"
+ + " <test name=\"test3\">content3</test>\n"
+ + " <test name=\"test4\">content4</test>\n"
+ + " <test name=\"test5\">content5</test>\n"
+ + " <test name=\"test6\">content6</test>\n"
+ + "</configuration>";
+ System.setProperty("sysprop1", "test1");
+ System.setProperty("sysprop2", "content4");
+ String replaced = org.hornetq.utils.XMLUtil.replaceSystemProps(before);
+ Assert.assertEquals(after, replaced);
+ }
+
+ public void testStripCDATA() throws Exception
+ {
+ String xml = "<![CDATA[somedata]]>";
+ String stripped = XMLUtil.stripCDATA(xml);
+
+ Assert.assertEquals("somedata", stripped);
+ }
+
+}
Deleted: trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/core/filter/impl/FilterTest.java
===================================================================
--- trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/core/filter/impl/FilterTest.java 2012-01-12 12:10:11 UTC (rev 12016)
+++ trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/core/filter/impl/FilterTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -1,703 +0,0 @@
-/*
- * Copyright 2009 Red Hat, Inc.
- * Red Hat licenses this file to you under the Apache License, version
- * 2.0 (the "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-package org.hornetq.tests.unit.core.filter.impl;
-
-import junit.framework.Assert;
-
-import org.hornetq.api.core.HornetQException;
-import org.hornetq.api.core.SimpleString;
-import org.hornetq.core.filter.Filter;
-import org.hornetq.core.filter.impl.FilterImpl;
-import org.hornetq.core.logging.Logger;
-import org.hornetq.core.server.ServerMessage;
-import org.hornetq.core.server.impl.ServerMessageImpl;
-import org.hornetq.tests.util.RandomUtil;
-import org.hornetq.tests.util.UnitTestCase;
-
-/**
- * Tests the compliance with the HornetQ Filter syntax.
- *
- * @author <a href="mailto:jason at planet57.com">Jason Dillon</a>
- * @author <a href="mailto:tim.fox at jboss.com">Tim Fox</a>
- * @version $Revision: 3514 $
- */
-public class FilterTest extends UnitTestCase
-{
- private static final Logger log = Logger.getLogger(FilterTest.class);
-
- private Filter filter;
-
- private ServerMessage message;
-
- protected void setUp() throws Exception
- {
- super.setUp();
-
- message = new ServerMessageImpl(1, 1000);
- }
-
- 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));
- }
-
- public void testInvalidString() throws Exception
- {
- testInvalidFilter("color = 'red");
- testInvalidFilter(new SimpleString("color = 'red"));
-
- testInvalidFilter("3");
- testInvalidFilter(new SimpleString("3"));
- }
-
- 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("")));
- }
-
- public void testHQDurable() throws Exception
- {
- filter = FilterImpl.createFilter(new SimpleString("HQDurable='DURABLE'"));
-
- message.setDurable(true);
-
- Assert.assertTrue(filter.match(message));
-
- message.setDurable(false);
-
- Assert.assertFalse(filter.match(message));
-
- filter = FilterImpl.createFilter(new SimpleString("HQDurable='NON_DURABLE'"));
-
- message = new ServerMessageImpl();
- message.setDurable(true);
-
- Assert.assertFalse(filter.match(message));
-
- message.setDurable(false);
-
- Assert.assertTrue(filter.match(message));
-
- }
-
- public void testHQSize() throws Exception
- {
- message.setAddress(RandomUtil.randomSimpleString());
-
- int encodeSize = message.getEncodeSize();
-
- Filter moreThanSmall = FilterImpl.createFilter(new SimpleString("HQSize > " + (encodeSize - 1)));
- Filter lessThanLarge = FilterImpl.createFilter(new SimpleString("HQSize < " + (encodeSize + 1)));
-
- Filter lessThanSmall = FilterImpl.createFilter(new SimpleString("HQSize < " + encodeSize));
- Filter moreThanLarge = FilterImpl.createFilter(new SimpleString("HQSize > " + encodeSize));
-
- Assert.assertTrue(moreThanSmall.match(message));
- Assert.assertTrue(lessThanLarge.match(message));
-
- Assert.assertFalse(lessThanSmall.match(message));
- Assert.assertFalse(moreThanLarge.match(message));
-
- }
-
- public void testHQPriority() throws Exception
- {
- filter = FilterImpl.createFilter(new SimpleString("HQPriority=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));
- }
- }
- }
-
- public void testHQTimestamp() throws Exception
- {
- filter = FilterImpl.createFilter(new SimpleString("HQTimestamp=12345678"));
-
- message.setTimestamp(87654321);
-
- Assert.assertFalse(filter.match(message));
-
- message.setTimestamp(12345678);
-
- Assert.assertTrue(filter.match(message));
- }
-
- public void testBooleanTrue() throws Exception
- {
- filter = FilterImpl.createFilter(new SimpleString("MyBoolean=true"));
-
- testBoolean("MyBoolean", true);
- }
-
- public void testIdentifier() throws Exception
- {
- filter = FilterImpl.createFilter(new SimpleString("MyBoolean"));
-
- testBoolean("MyBoolean", true);
- }
-
- 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));
- }
-
- public void testBooleanFalse() throws Exception
- {
- filter = FilterImpl.createFilter(new SimpleString("MyBoolean=false"));
- testBoolean("MyBoolean", false);
- }
-
- 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));
- }
-
- 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));
-
- }
-
- 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));
- }
-
- 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));
- }
-
- 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));
- }
-
- 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?
- }
-
- 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
- }
-
- 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));
- }
-
- 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));
-
- }
-
- 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));
- }
-
- // Private -----------------------------------------------------------------------------------
-
- private void doPutStringProperty(final String key, final String value)
- {
- message.putStringProperty(new SimpleString(key), new SimpleString(value));
- }
-
- private void testInvalidFilter(final String filterString) throws Exception
- {
- try
- {
- filter = FilterImpl.createFilter(filterString);
- Assert.fail("Should throw exception");
- }
- catch (HornetQException e)
- {
- Assert.assertEquals(HornetQException.INVALID_FILTER_EXPRESSION, e.getCode());
- }
- }
-
- private void testInvalidFilter(final SimpleString filterString) throws Exception
- {
- try
- {
- filter = FilterImpl.createFilter(filterString);
- Assert.fail("Should throw exception");
- }
- catch (HornetQException e)
- {
- Assert.assertEquals(HornetQException.INVALID_FILTER_EXPRESSION, e.getCode());
- }
- }
-
-}
Deleted: trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/core/filter/impl/OperatorTest.java
===================================================================
--- trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/core/filter/impl/OperatorTest.java 2012-01-12 12:10:11 UTC (rev 12016)
+++ trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/core/filter/impl/OperatorTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -1,468 +0,0 @@
-/*
- * Copyright 2009 Red Hat, Inc.
- * Red Hat licenses this file to you under the Apache License, version
- * 2.0 (the "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-package org.hornetq.tests.unit.core.filter.impl;
-
-import java.util.HashSet;
-
-import junit.framework.Assert;
-
-import org.hornetq.api.core.SimpleString;
-import org.hornetq.core.filter.impl.Operator;
-import org.hornetq.tests.util.UnitTestCase;
-
-/**
- * A OperatorTest
- *
- * @author <a href="jmesnil at redhat.com">Jeff Mesnil</a>
- *
- * Created 3 nov. 2008 17:22:22
- *
- *
- */
-public class OperatorTest extends UnitTestCase
-{
-
- // Constants -----------------------------------------------------
-
- // Attributes ----------------------------------------------------
-
- // Static --------------------------------------------------------
- private static void assertSuccess(final int op, final Object arg1, final Object expectedResult) throws Exception
- {
- OperatorTest.assertOperationSuccess(new Operator(op, arg1), expectedResult);
- }
-
- private static void assertSuccess(final int op, final Object arg1, final Object arg2, final Object expectedResult) throws Exception
- {
- OperatorTest.assertOperationSuccess(new Operator(op, arg1, arg2), expectedResult);
- }
-
- private static void assertSuccess(final int op,
- final Object arg1,
- final Object arg2,
- final Object arg3,
- final Object expectedResult) throws Exception
- {
- OperatorTest.assertOperationSuccess(new Operator(op, arg1, arg2, arg3), expectedResult);
- }
-
- private static void assertOperationSuccess(final Operator operator, final Object expectedResult) throws Exception
- {
- Assert.assertEquals(expectedResult, operator.apply());
- }
-
- private static void assertFailure(final int op, final Object arg1) throws Exception
- {
- OperatorTest.assertOperationFailure(new Operator(op, arg1));
- }
-
- private static void assertFailure(final int op, final Object arg1, final Object arg2) throws Exception
- {
- OperatorTest.assertOperationFailure(new Operator(op, arg1, arg2));
- }
-
- private static void assertFailure(final int op, final Object arg1, final Object arg2, final Object arg3) throws Exception
- {
- OperatorTest.assertOperationFailure(new Operator(op, arg1, arg2, arg3));
- }
-
- private static void assertOperationFailure(final Operator operator)
- {
- try
- {
- operator.apply();
- Assert.fail("expected to throw an exception");
- }
- catch (Exception e)
- {
- }
- }
-
- // Constructors --------------------------------------------------
-
- // Public --------------------------------------------------------
-
- public void test_EQUAL() throws Exception
- {
- OperatorTest.assertSuccess(Operator.EQUAL, 1, 1, true);
- OperatorTest.assertSuccess(Operator.EQUAL, 1, 1.0, true);
- OperatorTest.assertSuccess(Operator.EQUAL, 1, null, null);
- OperatorTest.assertSuccess(Operator.EQUAL, 1.0, 1, true);
- OperatorTest.assertSuccess(Operator.EQUAL, 1.0, 1.0, true);
- OperatorTest.assertSuccess(Operator.EQUAL, 1.0, null, null);
-
- OperatorTest.assertSuccess(Operator.EQUAL, false, false, true);
- OperatorTest.assertSuccess(Operator.EQUAL, true, false, false);
- OperatorTest.assertSuccess(Operator.EQUAL, false, true, false);
- OperatorTest.assertSuccess(Operator.EQUAL, true, true, true);
-
- SimpleString foo = new SimpleString("foo");
- SimpleString foo2 = new SimpleString("foo");
- SimpleString bar = new SimpleString("bar");
- OperatorTest.assertSuccess(Operator.EQUAL, foo, foo, true);
- OperatorTest.assertSuccess(Operator.EQUAL, foo, foo2, true);
- OperatorTest.assertSuccess(Operator.EQUAL, foo, bar, false);
- OperatorTest.assertSuccess(Operator.EQUAL, foo, null, false);
-
- OperatorTest.assertSuccess(Operator.EQUAL, null, 1.0, false);
- }
-
- public void test_DIFFERENT() throws Exception
- {
- OperatorTest.assertSuccess(Operator.DIFFERENT, 2, 1, true);
- OperatorTest.assertSuccess(Operator.DIFFERENT, 2, 1.0, true);
- OperatorTest.assertSuccess(Operator.DIFFERENT, 2, null, null);
- OperatorTest.assertSuccess(Operator.DIFFERENT, 2.0, 1, true);
- OperatorTest.assertSuccess(Operator.DIFFERENT, 2.0, 1.0, true);
- OperatorTest.assertSuccess(Operator.DIFFERENT, 2.0, null, null);
-
- OperatorTest.assertSuccess(Operator.DIFFERENT, false, false, false);
- OperatorTest.assertSuccess(Operator.DIFFERENT, true, false, true);
- OperatorTest.assertSuccess(Operator.DIFFERENT, false, true, true);
- OperatorTest.assertSuccess(Operator.DIFFERENT, true, true, false);
-
- SimpleString foo = new SimpleString("foo");
- SimpleString foo2 = new SimpleString("foo");
- SimpleString bar = new SimpleString("bar");
- OperatorTest.assertSuccess(Operator.DIFFERENT, foo, foo, false);
- OperatorTest.assertSuccess(Operator.DIFFERENT, foo, foo2, false);
- OperatorTest.assertSuccess(Operator.DIFFERENT, foo, bar, true);
- OperatorTest.assertSuccess(Operator.DIFFERENT, foo, null, null);
-
- OperatorTest.assertSuccess(Operator.DIFFERENT, null, 1.0, true);
- OperatorTest.assertSuccess(Operator.DIFFERENT, null, null, false);
- }
-
- public void test_IS_NULL() throws Exception
- {
- OperatorTest.assertSuccess(Operator.IS_NULL, null, true);
- OperatorTest.assertSuccess(Operator.IS_NULL, 1, false);
- }
-
- public void test_IS_NOT_NULL() throws Exception
- {
- OperatorTest.assertSuccess(Operator.IS_NOT_NULL, null, false);
- OperatorTest.assertSuccess(Operator.IS_NOT_NULL, 1, true);
- }
-
- public void test_ADD() throws Exception
- {
- OperatorTest.assertSuccess(Operator.ADD, 1, 1, 2L);
- OperatorTest.assertSuccess(Operator.ADD, 1.0, 1, 2.0);
- OperatorTest.assertSuccess(Operator.ADD, 1, 1.0, 2.0);
- OperatorTest.assertSuccess(Operator.ADD, 1.0, 1.0, 2.0);
-
- // incompatible types
- OperatorTest.assertFailure(Operator.ADD, true, 1.0);
- OperatorTest.assertFailure(Operator.ADD, 1, true);
- }
-
- public void test_SUB() throws Exception
- {
- OperatorTest.assertSuccess(Operator.SUB, 2, 1, 1L);
- OperatorTest.assertSuccess(Operator.SUB, 2.0, 1, 1.0);
- OperatorTest.assertSuccess(Operator.SUB, 2, 1.0, 1.0);
- OperatorTest.assertSuccess(Operator.SUB, 2.0, 1.0, 1.0);
-
- // incompatible types
- OperatorTest.assertFailure(Operator.SUB, true, 1.0);
- OperatorTest.assertFailure(Operator.SUB, 1, true);
- }
-
- public void test_MUL() throws Exception
- {
- OperatorTest.assertSuccess(Operator.MUL, 2, 1, 2L);
- OperatorTest.assertSuccess(Operator.MUL, 2.0, 1, 2.0);
- OperatorTest.assertSuccess(Operator.MUL, 2, 1.0, 2.0);
- OperatorTest.assertSuccess(Operator.MUL, 2.0, 1.0, 2.0);
-
- // incompatible types
- OperatorTest.assertSuccess(Operator.MUL, 2, null, null);
- OperatorTest.assertSuccess(Operator.MUL, null, 1.0, null);
- OperatorTest.assertFailure(Operator.MUL, true, 1.0);
- OperatorTest.assertFailure(Operator.MUL, 1, true);
- }
-
- public void test_DIV() throws Exception
- {
- OperatorTest.assertSuccess(Operator.DIV, 2, 2, 1L);
- OperatorTest.assertSuccess(Operator.DIV, 2.0, 2, 1.0);
- OperatorTest.assertSuccess(Operator.DIV, 2, 2.0, 1.0);
- OperatorTest.assertSuccess(Operator.DIV, 2.0, 2.0, 1.0);
-
- // incompatible types
- OperatorTest.assertSuccess(Operator.DIV, 2, null, null);
- OperatorTest.assertSuccess(Operator.DIV, null, 1.0, null);
- OperatorTest.assertFailure(Operator.DIV, true, 1.0);
- OperatorTest.assertFailure(Operator.DIV, 1, true);
- }
-
- public void test_NEG() throws Exception
- {
- OperatorTest.assertSuccess(Operator.NEG, 1, -1L);
- OperatorTest.assertSuccess(Operator.NEG, -1.0, 1.0);
-
- // incompatible types
- OperatorTest.assertFailure(Operator.NEG, true);
- }
-
- public void test_AND() throws Exception
- {
- // NULL and NULL -> NULL
- OperatorTest.assertSuccess(Operator.AND, null, null, null);
- // NULL and F -> F
- OperatorTest.assertSuccess(Operator.AND, null, false, false);
- // NULL and T -> NULL
- OperatorTest.assertSuccess(Operator.AND, null, true, null);
-
- // F and NULL -> F
- OperatorTest.assertSuccess(Operator.AND, false, null, false);
- // F and F -> F
- OperatorTest.assertSuccess(Operator.AND, false, false, false);
- // F and T -> F
- OperatorTest.assertSuccess(Operator.AND, false, true, false);
-
- // T and NULL -> NULL
- OperatorTest.assertSuccess(Operator.AND, true, null, null);
- // T and F -> F
- OperatorTest.assertSuccess(Operator.AND, true, false, false);
- // T and T -> T
- OperatorTest.assertSuccess(Operator.AND, true, true, true);
-
- // incompatible types
- OperatorTest.assertFailure(Operator.AND, 1.0, true);
- OperatorTest.assertFailure(Operator.AND, true, 1.0);
- OperatorTest.assertFailure(Operator.AND, null, 1.0);
- }
-
- public void test_OR() throws Exception
- {
- // NULL OR NULL -> NULL
- OperatorTest.assertSuccess(Operator.OR, null, null, null);
- // NULL OR F -> NULL
- OperatorTest.assertSuccess(Operator.OR, null, false, null);
- // NULL OR T -> T
- OperatorTest.assertSuccess(Operator.OR, null, true, true);
-
- // F or NULL -> NULL
- OperatorTest.assertSuccess(Operator.OR, false, null, null);
- // F or F -> F
- OperatorTest.assertSuccess(Operator.OR, false, false, false);
- // F or T -> F
- OperatorTest.assertSuccess(Operator.OR, false, true, true);
-
- // T or NULL -> T
- OperatorTest.assertSuccess(Operator.OR, true, null, true);
- // T or F -> T
- OperatorTest.assertSuccess(Operator.OR, true, false, true);
- // T or T -> T
- OperatorTest.assertSuccess(Operator.OR, true, true, true);
-
- // incompatible types
- OperatorTest.assertFailure(Operator.OR, 1.0, true);
- OperatorTest.assertFailure(Operator.OR, false, 1.0);
- OperatorTest.assertFailure(Operator.OR, null, 1.0);
- }
-
- public void test_NOT() throws Exception
- {
- // NOT NULL -> NULL
- OperatorTest.assertSuccess(Operator.NOT, null, null);
- // NOT F -> T
- OperatorTest.assertSuccess(Operator.NOT, false, true);
- // NOT T -> F
- OperatorTest.assertSuccess(Operator.NOT, true, false);
-
- // incompatible types
- OperatorTest.assertFailure(Operator.NOT, 1.0);
- }
-
- public void test_GT() throws Exception
- {
- OperatorTest.assertSuccess(Operator.GT, 2, 1, true);
- OperatorTest.assertSuccess(Operator.GT, 2.0, 1, true);
- OperatorTest.assertSuccess(Operator.GT, 2, 1.0, true);
- OperatorTest.assertSuccess(Operator.GT, 2.0, 1.0, true);
-
- // incompatible types
- OperatorTest.assertSuccess(Operator.GT, 2.0, true, false);
- OperatorTest.assertSuccess(Operator.GT, 2, null, null);
- OperatorTest.assertSuccess(Operator.GT, true, 1.0, false);
- OperatorTest.assertSuccess(Operator.GT, null, 1, null);
- OperatorTest.assertSuccess(Operator.GT, true, true, false);
- OperatorTest.assertSuccess(Operator.GT, null, null, null);
- }
-
- public void test_GE() throws Exception
- {
- OperatorTest.assertSuccess(Operator.GE, 1, 1, true);
- OperatorTest.assertSuccess(Operator.GE, 1.0, 1, true);
- OperatorTest.assertSuccess(Operator.GE, 1, 1.0, true);
- OperatorTest.assertSuccess(Operator.GE, 1.0, 1.0, true);
-
- // incompatible types
- OperatorTest.assertSuccess(Operator.GE, 2.0, true, false);
- OperatorTest.assertSuccess(Operator.GE, 2, null, null);
- OperatorTest.assertSuccess(Operator.GE, true, 1.0, false);
- OperatorTest.assertSuccess(Operator.GE, null, 1, null);
- OperatorTest.assertSuccess(Operator.GE, true, true, false);
- OperatorTest.assertSuccess(Operator.GE, null, null, null);
- }
-
- public void test_LT() throws Exception
- {
- OperatorTest.assertSuccess(Operator.LT, 1, 2, true);
- OperatorTest.assertSuccess(Operator.LT, 1.0, 2, true);
- OperatorTest.assertSuccess(Operator.LT, 1, 2.0, true);
- OperatorTest.assertSuccess(Operator.LT, 1.0, 2.0, true);
-
- // incompatible types
- OperatorTest.assertSuccess(Operator.LT, 1.0, true, false);
- OperatorTest.assertSuccess(Operator.LT, 1, null, null);
- OperatorTest.assertSuccess(Operator.LT, true, 2.0, false);
- OperatorTest.assertSuccess(Operator.LT, null, 2, null);
- OperatorTest.assertSuccess(Operator.LT, true, true, false);
- OperatorTest.assertSuccess(Operator.LT, null, null, null);
- }
-
- public void test_LE() throws Exception
- {
- OperatorTest.assertSuccess(Operator.LE, 1, 1, true);
- OperatorTest.assertSuccess(Operator.LE, 1.0, 1, true);
- OperatorTest.assertSuccess(Operator.LE, 1, 1.0, true);
- OperatorTest.assertSuccess(Operator.LE, 1.0, 1.0, true);
-
- // incompatible types
- OperatorTest.assertSuccess(Operator.LE, 1.0, true, false);
- OperatorTest.assertSuccess(Operator.LE, 1, null, null);
- OperatorTest.assertSuccess(Operator.LE, true, 1.0, false);
- OperatorTest.assertSuccess(Operator.LE, null, 1, null);
- OperatorTest.assertSuccess(Operator.LE, true, true, false);
- OperatorTest.assertSuccess(Operator.LE, null, null, null);
- }
-
- public void test_BETWEEN() throws Exception
- {
- // 2 BETWEEN 1 AND 3
- OperatorTest.assertSuccess(Operator.BETWEEN, 2, 1, 3, true);
- OperatorTest.assertSuccess(Operator.BETWEEN, 2.0, 1.0, 3.0, true);
-
- // incompatible types
- OperatorTest.assertSuccess(Operator.BETWEEN, true, 1, 3, false);
- OperatorTest.assertSuccess(Operator.BETWEEN, null, null, 3, null);
- }
-
- public void test_NOT_BETWEEN() throws Exception
- {
- // 2 NOT BETWEEN 3 AND 4
- OperatorTest.assertSuccess(Operator.NOT_BETWEEN, 2, 3, 4, true);
- OperatorTest.assertSuccess(Operator.NOT_BETWEEN, 2.0, 3.0, 4.0, true);
-
- // incompatible types
- OperatorTest.assertSuccess(Operator.NOT_BETWEEN, true, 1, 3, false);
- OperatorTest.assertSuccess(Operator.NOT_BETWEEN, null, null, 3, null);
- }
-
- public void test_IN() throws Exception
- {
- HashSet set = new HashSet();
- set.add(new SimpleString("foo"));
- set.add(new SimpleString("bar"));
- set.add(new SimpleString("baz"));
-
- SimpleString foo = new SimpleString("foo");
-
- OperatorTest.assertSuccess(Operator.IN, foo, set, true);
- OperatorTest.assertSuccess(Operator.IN, foo, new HashSet(), false);
-
- // incompatible types
- OperatorTest.assertFailure(Operator.IN, true, set);
- }
-
- public void test_NOT_IN() throws Exception
- {
- HashSet set = new HashSet();
- set.add(new SimpleString("foo"));
- set.add(new SimpleString("bar"));
- set.add(new SimpleString("baz"));
-
- SimpleString foo = new SimpleString("foo");
-
- OperatorTest.assertSuccess(Operator.NOT_IN, foo, set, false);
- OperatorTest.assertSuccess(Operator.NOT_IN, foo, new HashSet(), true);
-
- // incompatible types
- OperatorTest.assertFailure(Operator.NOT_IN, true, set);
- }
-
- public void test_LIKE() throws Exception
- {
- SimpleString pattern = new SimpleString("12%3");
- OperatorTest.assertSuccess(Operator.LIKE, new SimpleString("123"), pattern, true);
- OperatorTest.assertSuccess(Operator.LIKE, new SimpleString("12993"), pattern, true);
- OperatorTest.assertSuccess(Operator.LIKE, new SimpleString("1234"), pattern, false);
-
- pattern = new SimpleString("l_se");
- OperatorTest.assertSuccess(Operator.LIKE, new SimpleString("lose"), pattern, true);
- OperatorTest.assertSuccess(Operator.LIKE, new SimpleString("loose"), pattern, false);
-
- OperatorTest.assertSuccess(Operator.LIKE, null, pattern, null);
- }
-
- public void test_LIKE_ESCAPE() throws Exception
- {
- SimpleString pattern = new SimpleString("\\_%");
- SimpleString escapeChar = new SimpleString("\\");
- OperatorTest.assertSuccess(Operator.LIKE_ESCAPE, new SimpleString("_foo"), pattern, escapeChar, true);
- OperatorTest.assertSuccess(Operator.LIKE_ESCAPE, new SimpleString("bar"), pattern, escapeChar, false);
- OperatorTest.assertSuccess(Operator.LIKE_ESCAPE, null, pattern, escapeChar, null);
-
- OperatorTest.assertFailure(Operator.LIKE_ESCAPE,
- new SimpleString("_foo"),
- pattern,
- new SimpleString("must be a single char"));
- }
-
- public void test_NOT_LIKE() throws Exception
- {
- SimpleString pattern = new SimpleString("12%3");
- OperatorTest.assertSuccess(Operator.NOT_LIKE, new SimpleString("123"), pattern, false);
- OperatorTest.assertSuccess(Operator.NOT_LIKE, new SimpleString("12993"), pattern, false);
- OperatorTest.assertSuccess(Operator.NOT_LIKE, new SimpleString("1234"), pattern, true);
- OperatorTest.assertSuccess(Operator.NOT_LIKE, null, pattern, null);
- }
-
- public void test_NOT_LIKE_ESCAPE() throws Exception
- {
- SimpleString pattern = new SimpleString("\\_%");
- SimpleString escapeChar = new SimpleString("\\");
- OperatorTest.assertSuccess(Operator.NOT_LIKE_ESCAPE, new SimpleString("_foo"), pattern, escapeChar, false);
- OperatorTest.assertSuccess(Operator.NOT_LIKE_ESCAPE, new SimpleString("bar"), pattern, escapeChar, true);
- OperatorTest.assertSuccess(Operator.NOT_LIKE_ESCAPE, null, pattern, escapeChar, null);
-
- OperatorTest.assertFailure(Operator.NOT_LIKE_ESCAPE,
- new SimpleString("_foo"),
- pattern,
- new SimpleString("must be a single char"));
- }
-
- // Package protected ---------------------------------------------
-
- // Protected -----------------------------------------------------
-
- // Private -------------------------------------------------------
-
- // Inner classes -------------------------------------------------
-
-}
Deleted: trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/CompressionUtilTest.java
===================================================================
--- trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/CompressionUtilTest.java 2012-01-12 12:10:11 UTC (rev 12016)
+++ trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/CompressionUtilTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -1,192 +0,0 @@
-/*
- * Copyright 2010 Red Hat, Inc.
- * Red Hat licenses this file to you under the Apache License, version
- * 2.0 (the "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-package org.hornetq.tests.unit.util;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.util.ArrayList;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.zip.Deflater;
-
-import org.hornetq.tests.util.UnitTestCase;
-import org.hornetq.utils.DeflaterReader;
-import org.hornetq.utils.InflaterReader;
-import org.hornetq.utils.InflaterWriter;
-
-/**
- * A CompressionUtilTest
- *
- * @author <a href="mailto:hgao at redhat.com">Howard Gao</a>
- *
- */
-public class CompressionUtilTest extends UnitTestCase
-{
-
- public void testDeflaterReader() throws Exception
- {
- String inputString = "blahblahblah??blahblahblahblahblah??blablahblah??blablahblah??bla";
- byte[] input = inputString.getBytes("UTF-8");
-
- ByteArrayInputStream inputStream = new ByteArrayInputStream(input);
-
- AtomicLong counter = new AtomicLong(0);
- DeflaterReader reader = new DeflaterReader(inputStream, counter);
-
- ArrayList<Integer> zipHolder = new ArrayList<Integer>();
- int b = reader.read();
-
- while (b != -1)
- {
- zipHolder.add(b);
- b = reader.read();
- }
-
- assertEquals(input.length, counter.get());
-
- byte[] allCompressed = new byte[zipHolder.size()];
- for (int i = 0; i < allCompressed.length; i++)
- {
- allCompressed[i] = (byte) zipHolder.get(i).intValue();
- }
-
- byte[] output = new byte[30];
- Deflater compresser = new Deflater();
- compresser.setInput(input);
- compresser.finish();
- int compressedDataLength = compresser.deflate(output);
-
- compareByteArray(allCompressed, output, compressedDataLength);
- }
-
- public void testDeflaterReader2() throws Exception
- {
- String inputString = "blahblahblah??blahblahblahblahblah??blablahblah??blablahblah??bla";
- byte[] input = inputString.getBytes("UTF-8");
-
- ByteArrayInputStream inputStream = new ByteArrayInputStream(input);
- AtomicLong counter = new AtomicLong(0);
-
- DeflaterReader reader = new DeflaterReader(inputStream, counter);
-
- byte[] buffer = new byte[7];
- ArrayList<Integer> zipHolder = new ArrayList<Integer>();
-
- int n = reader.read(buffer);
- while (n != -1)
- {
- for (int i = 0; i < n; i++)
- {
- zipHolder.add((int)buffer[i]);
- }
- n = reader.read(buffer);
- }
-
- assertEquals(input.length, counter.get());
-
- byte[] allCompressed = new byte[zipHolder.size()];
- for (int i = 0; i < allCompressed.length; i++)
- {
- allCompressed[i] = (byte) zipHolder.get(i).intValue();
- }
-
- byte[] output = new byte[30];
- Deflater compresser = new Deflater();
- compresser.setInput(input);
- compresser.finish();
- int compressedDataLength = compresser.deflate(output);
-
- compareByteArray(allCompressed, output, compressedDataLength);
- }
-
- public void testInflaterReader() throws Exception
- {
- String inputString = "blahblahblah??blahblahblahblahblah??blablahblah??blablahblah??bla";
- byte[] input = inputString.getBytes("UTF-8");
- byte[] output = new byte[30];
- Deflater compresser = new Deflater();
- compresser.setInput(input);
- compresser.finish();
- int compressedDataLength = compresser.deflate(output);
-
- byte[] zipBytes = new byte[compressedDataLength];
-
- System.arraycopy(output, 0, zipBytes, 0, compressedDataLength);
- ByteArrayInputStream byteInput = new ByteArrayInputStream(zipBytes);
-
- InflaterReader inflater = new InflaterReader(byteInput);
- ArrayList<Integer> holder = new ArrayList<Integer>();
- int read = inflater.read();
-
- while (read != -1)
- {
- holder.add(read);
- read = inflater.read();
- }
-
- byte[] result = new byte[holder.size()];
-
- for (int i = 0; i < result.length; i++)
- {
- result[i] = holder.get(i).byteValue();
- }
-
- String txt = new String(result);
-
- assertEquals(inputString, txt);
-
- }
-
- public void testInflaterWriter() throws Exception
- {
- String inputString = "blahblahblah??blahblahblahblahblah??blablahblah??blablahblah??bla";
- byte[] input = inputString.getBytes("UTF-8");
- byte[] output = new byte[30];
- Deflater compresser = new Deflater();
- compresser.setInput(input);
- compresser.finish();
- int compressedDataLength = compresser.deflate(output);
-
- byte[] zipBytes = new byte[compressedDataLength];
-
- System.arraycopy(output, 0, zipBytes, 0, compressedDataLength);
- ByteArrayInputStream byteInput = new ByteArrayInputStream(zipBytes);
-
- ByteArrayOutputStream byteOutput = new ByteArrayOutputStream();
- InflaterWriter writer = new InflaterWriter(byteOutput);
-
- byte[] zipBuffer = new byte[12];
-
- int n = byteInput.read(zipBuffer);
- while (n > 0)
- {
- writer.write(zipBuffer, 0, n);
- n = byteInput.read(zipBuffer);
- }
-
- writer.close();
-
- byte[] outcome = byteOutput.toByteArray();
- String outStr = new String(outcome);
-
- assertEquals(inputString, outStr);
- }
-
- private void compareByteArray(byte[] first, byte[] second, int length)
- {
- for (int i = 0; i < length; i++)
- {
- assertEquals(first[i], second[i]);
- }
- }
-}
Deleted: trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/ConcurrentHashSetTest.java
===================================================================
--- trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/ConcurrentHashSetTest.java 2012-01-12 12:10:11 UTC (rev 12016)
+++ trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/ConcurrentHashSetTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -1,147 +0,0 @@
-/*
- * Copyright 2009 Red Hat, Inc.
- * Red Hat licenses this file to you under the Apache License, version
- * 2.0 (the "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-package org.hornetq.tests.unit.util;
-
-import java.util.Iterator;
-
-import junit.framework.Assert;
-
-import org.hornetq.tests.util.RandomUtil;
-import org.hornetq.tests.util.UnitTestCase;
-import org.hornetq.utils.ConcurrentHashSet;
-import org.hornetq.utils.ConcurrentSet;
-
-/**
- * @author <a href="mailto:jmesnil at redhat.com">Jeff Mesnil</a>
- *
- * @version <tt>$Revision$</tt>
- *
- */
-public class ConcurrentHashSetTest extends UnitTestCase
-{
- // Constants -----------------------------------------------------
-
- // Attributes ----------------------------------------------------
-
- private ConcurrentSet<String> set;
-
- private String element;
-
- // Static --------------------------------------------------------
-
- // Constructors --------------------------------------------------
-
- // Public --------------------------------------------------------
-
- public void testAdd() throws Exception
- {
- Assert.assertTrue(set.add(element));
- Assert.assertFalse(set.add(element));
- }
-
- public void testAddIfAbsent() throws Exception
- {
- Assert.assertTrue(set.addIfAbsent(element));
- Assert.assertFalse(set.addIfAbsent(element));
- }
-
- public void testRemove() throws Exception
- {
- Assert.assertTrue(set.add(element));
-
- Assert.assertTrue(set.remove(element));
- Assert.assertFalse(set.remove(element));
- }
-
- public void testContains() throws Exception
- {
- Assert.assertFalse(set.contains(element));
-
- Assert.assertTrue(set.add(element));
- Assert.assertTrue(set.contains(element));
-
- Assert.assertTrue(set.remove(element));
- Assert.assertFalse(set.contains(element));
- }
-
- public void testSize() throws Exception
- {
- Assert.assertEquals(0, set.size());
-
- Assert.assertTrue(set.add(element));
- Assert.assertEquals(1, set.size());
-
- Assert.assertTrue(set.remove(element));
- Assert.assertEquals(0, set.size());
- }
-
- public void testClear() throws Exception
- {
- Assert.assertTrue(set.add(element));
-
- Assert.assertTrue(set.contains(element));
- set.clear();
- Assert.assertFalse(set.contains(element));
- }
-
- public void testIsEmpty() throws Exception
- {
- Assert.assertTrue(set.isEmpty());
-
- Assert.assertTrue(set.add(element));
- Assert.assertFalse(set.isEmpty());
-
- set.clear();
- Assert.assertTrue(set.isEmpty());
- }
-
- public void testIterator() throws Exception
- {
- set.add(element);
-
- Iterator<String> iterator = set.iterator();
- while (iterator.hasNext())
- {
- String e = iterator.next();
- Assert.assertEquals(element, e);
- }
- }
-
- // TestCase overrides --------------------------------------------
-
- @Override
- protected void setUp() throws Exception
- {
- super.setUp();
-
- set = new ConcurrentHashSet<String>();
- element = RandomUtil.randomString();
- }
-
- @Override
- protected void tearDown() throws Exception
- {
- set = null;
- element = null;
-
- super.tearDown();
- }
- // Package protected ---------------------------------------------
-
- // Protected -----------------------------------------------------
-
- // Private -------------------------------------------------------
-
- // Inner classes -------------------------------------------------
-}
Deleted: trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TimeAndCounterIDGeneratorTest.java
===================================================================
--- trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TimeAndCounterIDGeneratorTest.java 2012-01-12 12:10:11 UTC (rev 12016)
+++ trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TimeAndCounterIDGeneratorTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -1,197 +0,0 @@
-/*
- * Copyright 2009 Red Hat, Inc.
- * Red Hat licenses this file to you under the Apache License, version
- * 2.0 (the "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-package org.hornetq.tests.unit.util;
-
-import java.util.concurrent.CountDownLatch;
-
-import junit.framework.Assert;
-
-import org.hornetq.tests.util.UnitTestCase;
-import org.hornetq.utils.ConcurrentHashSet;
-import org.hornetq.utils.TimeAndCounterIDGenerator;
-
-/**
- * A TimeAndCounterIDGeneratorTest
- *
- * @author <a href="mailto:clebert.suconic at jboss.org">Clebert Suconic</a> Created 24-Sep-08 3:42:25 PM
- */
-public class TimeAndCounterIDGeneratorTest extends UnitTestCase
-{
-
- // Constants -----------------------------------------------------
-
- // Attributes ----------------------------------------------------
-
- // Static --------------------------------------------------------
-
- // Constructors --------------------------------------------------
-
- // Public --------------------------------------------------------
-
- public void testCalculation()
- {
- TimeAndCounterIDGenerator seq = new TimeAndCounterIDGenerator();
- long max = 11000;
-
- long lastNr = 0;
-
- for (long i = 0; i < max; i++)
- {
- long seqNr = seq.generateID();
-
- Assert.assertTrue("The sequence generator should aways generate crescent numbers", seqNr > lastNr);
-
- lastNr = seqNr;
- }
-
- }
-
- public void testCalculationRefresh()
- {
- TimeAndCounterIDGenerator seq = new TimeAndCounterIDGenerator();
-
- long id1 = seq.generateID();
- Assert.assertEquals(1, id1 & 0xffff);
- Assert.assertEquals(2, seq.generateID() & 0xffff);
-
- seq.refresh();
-
- long id2 = seq.generateID();
-
- Assert.assertTrue(id2 > id1);
-
- Assert.assertEquals(1, id2 & 0xffff);
-
- }
-
- public void testCalculationOnMultiThread() throws Throwable
- {
- final ConcurrentHashSet<Long> hashSet = new ConcurrentHashSet<Long>();
-
- final TimeAndCounterIDGenerator seq = new TimeAndCounterIDGenerator();
-
- System.out.println("Time = " + TimeAndCounterIDGeneratorTest.hex(System.currentTimeMillis()) + ", " + seq);
-
- final int NUMBER_OF_THREADS = 100;
-
- final int NUMBER_OF_IDS = 10;
-
- final CountDownLatch latchAlign = new CountDownLatch(NUMBER_OF_THREADS);
-
- final CountDownLatch latchStart = new CountDownLatch(1);
-
- class T1 extends Thread
- {
- Throwable e;
-
- @Override
- public void run()
- {
- try
- {
- latchAlign.countDown();
- latchStart.await();
-
- long lastValue = 0l;
- for (int i = 0; i < NUMBER_OF_IDS; i++)
- {
- long value = seq.generateID();
- Assert.assertTrue(TimeAndCounterIDGeneratorTest.hex(value) + " should be greater than " +
- TimeAndCounterIDGeneratorTest.hex(lastValue) +
- " on seq " +
- seq.toString(), value > lastValue);
- lastValue = value;
-
- hashSet.add(value);
- }
- }
- catch (Throwable e)
- {
- this.e = e;
- }
- }
-
- };
-
- T1[] arrays = new T1[NUMBER_OF_THREADS];
-
- for (int i = 0; i < arrays.length; i++)
- {
- arrays[i] = new T1();
- arrays[i].start();
- }
-
- latchAlign.await();
-
- latchStart.countDown();
-
- for (T1 t : arrays)
- {
- t.join();
- if (t.e != null)
- {
- throw t.e;
- }
- }
-
- Assert.assertEquals(NUMBER_OF_THREADS * NUMBER_OF_IDS, hashSet.size());
-
- hashSet.clear();
-
- }
-
- public void testWrapID() throws Throwable
- {
- final ConcurrentHashSet<Long> hashSet = new org.hornetq.utils.ConcurrentHashSet<Long>();
-
- TimeAndCounterIDGenerator seq = new TimeAndCounterIDGenerator();
-
- System.out.println("Current Time = " + TimeAndCounterIDGeneratorTest.hex(System.currentTimeMillis()) + " " + seq);
-
- seq.setInternalDate(System.currentTimeMillis() + 10000l); // 10 seconds in the future
-
- seq.setInternalID(TimeAndCounterIDGenerator.ID_MASK); // 1 ID about to explode
-
- try
- {
- // This is simulating a situation where we generated more than 268 million messages on the same time interval
- seq.generateID();
- Assert.fail("It was supposed to throw an exception, as the counter was set to explode on this test");
- }
- catch (Exception e)
- {
- }
-
- seq = new TimeAndCounterIDGenerator();
-
- seq.setInternalDate(System.currentTimeMillis() - 10000l); // 10 seconds in the past
-
- long timeMark = seq.getInternalTimeMark();
-
- seq.setInternalID(TimeAndCounterIDGenerator.ID_MASK); // 1 ID about to explode
-
- // This is ok... the time portion would be added to the next one generated 10 seconds ago
- seq.generateID();
-
- Assert.assertTrue(TimeAndCounterIDGeneratorTest.hex(timeMark) + " < " +
- TimeAndCounterIDGeneratorTest.hex(seq.getInternalTimeMark()),
- timeMark < seq.getInternalTimeMark());
- }
-
- private static String hex(final long value)
- {
- return String.format("%1$X", value);
- }
-
-}
Deleted: trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TypedPropertiesConversionTest.java
===================================================================
--- trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TypedPropertiesConversionTest.java 2012-01-12 12:10:11 UTC (rev 12016)
+++ trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TypedPropertiesConversionTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -1,364 +0,0 @@
-/*
- * Copyright 2009 Red Hat, Inc.
- * Red Hat licenses this file to you under the Apache License, version
- * 2.0 (the "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-package org.hornetq.tests.unit.util;
-
-import junit.framework.Assert;
-import junit.framework.TestCase;
-
-import org.hornetq.api.core.PropertyConversionException;
-import org.hornetq.api.core.SimpleString;
-import org.hornetq.tests.util.RandomUtil;
-import org.hornetq.tests.util.UnitTestCase;
-import org.hornetq.utils.TypedProperties;
-
-/**
- * A TypedPropertiesConversionTest
- *
- * @author jmesnil
- *
- *
- */
-public class TypedPropertiesConversionTest extends TestCase
-{
-
- // Constants -----------------------------------------------------
-
- // Attributes ----------------------------------------------------
-
- private TypedProperties props;
-
- private SimpleString key;
-
- private final SimpleString unknownKey = new SimpleString("this.key.is.never.used");
-
- // Static --------------------------------------------------------
-
- // Constructors --------------------------------------------------
-
- // Public --------------------------------------------------------
-
- @Override
- protected void setUp() throws Exception
- {
- super.setUp();
-
- key = RandomUtil.randomSimpleString();
- props = new TypedProperties();
- }
-
- @Override
- protected void tearDown() throws Exception
- {
- key = null;
- props = null;
-
- super.tearDown();
- }
-
- public void testBooleanProperty() throws Exception
- {
- Boolean val = RandomUtil.randomBoolean();
- props.putBooleanProperty(key, val);
-
- Assert.assertEquals(val, props.getBooleanProperty(key));
- Assert.assertEquals(new SimpleString(Boolean.toString(val)), props.getSimpleStringProperty(key));
-
- props.putSimpleStringProperty(key, new SimpleString(Boolean.toString(val)));
- Assert.assertEquals(val, props.getBooleanProperty(key));
-
- try
- {
- props.putByteProperty(key, RandomUtil.randomByte());
- props.getBooleanProperty(key);
- Assert.fail();
- }
- catch (PropertyConversionException e)
- {
- }
-
- Assert.assertFalse(props.getBooleanProperty(unknownKey));
- }
-
- public void testCharProperty() throws Exception
- {
- Character val = RandomUtil.randomChar();
- props.putCharProperty(key, val);
-
- Assert.assertEquals(val, props.getCharProperty(key));
- Assert.assertEquals(new SimpleString(Character.toString(val)), props.getSimpleStringProperty(key));
-
- try
- {
- props.putByteProperty(key, RandomUtil.randomByte());
- props.getCharProperty(key);
- Assert.fail();
- }
- catch (PropertyConversionException e)
- {
- }
-
- try
- {
- props.getCharProperty(unknownKey);
- Assert.fail();
- }
- catch (NullPointerException e)
- {
- }
- }
-
- public void testByteProperty() throws Exception
- {
- Byte val = RandomUtil.randomByte();
- props.putByteProperty(key, val);
-
- Assert.assertEquals(val, props.getByteProperty(key));
- Assert.assertEquals(new SimpleString(Byte.toString(val)), props.getSimpleStringProperty(key));
-
- props.putSimpleStringProperty(key, new SimpleString(Byte.toString(val)));
- Assert.assertEquals(val, props.getByteProperty(key));
-
- try
- {
- props.putBooleanProperty(key, RandomUtil.randomBoolean());
- props.getByteProperty(key);
- Assert.fail();
- }
- catch (PropertyConversionException e)
- {
- }
-
- try
- {
- props.getByteProperty(unknownKey);
- Assert.fail();
- }
- catch (NumberFormatException e)
- {
- }
- }
-
- public void testIntProperty() throws Exception
- {
- Integer val = RandomUtil.randomInt();
- props.putIntProperty(key, val);
-
- Assert.assertEquals(val, props.getIntProperty(key));
- Assert.assertEquals(new SimpleString(Integer.toString(val)), props.getSimpleStringProperty(key));
-
- props.putSimpleStringProperty(key, new SimpleString(Integer.toString(val)));
- Assert.assertEquals(val, props.getIntProperty(key));
-
- Byte byteVal = RandomUtil.randomByte();
- props.putByteProperty(key, byteVal);
- Assert.assertEquals(Integer.valueOf(byteVal), props.getIntProperty(key));
-
- try
- {
- props.putBooleanProperty(key, RandomUtil.randomBoolean());
- props.getIntProperty(key);
- Assert.fail();
- }
- catch (PropertyConversionException e)
- {
- }
-
- try
- {
- props.getIntProperty(unknownKey);
- Assert.fail();
- }
- catch (NumberFormatException e)
- {
- }
- }
-
- public void testLongProperty() throws Exception
- {
- Long val = RandomUtil.randomLong();
- props.putLongProperty(key, val);
-
- Assert.assertEquals(val, props.getLongProperty(key));
- Assert.assertEquals(new SimpleString(Long.toString(val)), props.getSimpleStringProperty(key));
-
- props.putSimpleStringProperty(key, new SimpleString(Long.toString(val)));
- Assert.assertEquals(val, props.getLongProperty(key));
-
- Byte byteVal = RandomUtil.randomByte();
- props.putByteProperty(key, byteVal);
- Assert.assertEquals(Long.valueOf(byteVal), props.getLongProperty(key));
-
- Short shortVal = RandomUtil.randomShort();
- props.putShortProperty(key, shortVal);
- Assert.assertEquals(Long.valueOf(shortVal), props.getLongProperty(key));
-
- Integer intVal = RandomUtil.randomInt();
- props.putIntProperty(key, intVal);
- Assert.assertEquals(Long.valueOf(intVal), props.getLongProperty(key));
-
- try
- {
- props.putBooleanProperty(key, RandomUtil.randomBoolean());
- props.getLongProperty(key);
- Assert.fail();
- }
- catch (PropertyConversionException e)
- {
- }
-
- try
- {
- props.getLongProperty(unknownKey);
- Assert.fail();
- }
- catch (NumberFormatException e)
- {
- }
- }
-
- public void testDoubleProperty() throws Exception
- {
- Double val = RandomUtil.randomDouble();
- props.putDoubleProperty(key, val);
-
- Assert.assertEquals(val, props.getDoubleProperty(key));
- Assert.assertEquals(new SimpleString(Double.toString(val)), props.getSimpleStringProperty(key));
-
- props.putSimpleStringProperty(key, new SimpleString(Double.toString(val)));
- Assert.assertEquals(val, props.getDoubleProperty(key));
-
- try
- {
- props.putBooleanProperty(key, RandomUtil.randomBoolean());
- props.getDoubleProperty(key);
- Assert.fail();
- }
- catch (PropertyConversionException e)
- {
- }
-
- try
- {
- props.getDoubleProperty(unknownKey);
- Assert.fail();
- }
- catch (Exception e)
- {
- }
- }
-
- public void testFloatProperty() throws Exception
- {
- Float val = RandomUtil.randomFloat();
- props.putFloatProperty(key, val);
-
- Assert.assertEquals(val, props.getFloatProperty(key));
- Assert.assertEquals(Double.valueOf(val), props.getDoubleProperty(key));
- Assert.assertEquals(new SimpleString(Float.toString(val)), props.getSimpleStringProperty(key));
-
- props.putSimpleStringProperty(key, new SimpleString(Float.toString(val)));
- Assert.assertEquals(val, props.getFloatProperty(key));
-
- try
- {
- props.putBooleanProperty(key, RandomUtil.randomBoolean());
- props.getFloatProperty(key);
- Assert.fail();
- }
- catch (PropertyConversionException e)
- {
- }
-
- try
- {
- props.getFloatProperty(unknownKey);
- Assert.fail();
- }
- catch (Exception e)
- {
- }
- }
-
- public void testShortProperty() throws Exception
- {
- Short val = RandomUtil.randomShort();
- props.putShortProperty(key, val);
-
- Assert.assertEquals(val, props.getShortProperty(key));
- Assert.assertEquals(Integer.valueOf(val), props.getIntProperty(key));
- Assert.assertEquals(new SimpleString(Short.toString(val)), props.getSimpleStringProperty(key));
-
- props.putSimpleStringProperty(key, new SimpleString(Short.toString(val)));
- Assert.assertEquals(val, props.getShortProperty(key));
-
- Byte byteVal = RandomUtil.randomByte();
- props.putByteProperty(key, byteVal);
- Assert.assertEquals(Short.valueOf(byteVal), props.getShortProperty(key));
-
- try
- {
- props.putBooleanProperty(key, RandomUtil.randomBoolean());
- props.getShortProperty(key);
- Assert.fail();
- }
- catch (PropertyConversionException e)
- {
- }
-
- try
- {
- props.getShortProperty(unknownKey);
- Assert.fail();
- }
- catch (NumberFormatException e)
- {
- }
- }
-
- public void testSimpleStringProperty() throws Exception
- {
- SimpleString strVal = RandomUtil.randomSimpleString();
- props.putSimpleStringProperty(key, strVal);
- Assert.assertEquals(strVal, props.getSimpleStringProperty(key));
- }
-
- public void testBytesProperty() throws Exception
- {
- byte[] val = RandomUtil.randomBytes();
- props.putBytesProperty(key, val);
-
- UnitTestCase.assertEqualsByteArrays(val, props.getBytesProperty(key));
-
- try
- {
- props.putBooleanProperty(key, RandomUtil.randomBoolean());
- props.getBytesProperty(key);
- Assert.fail();
- }
- catch (PropertyConversionException e)
- {
- }
-
- Assert.assertNull(props.getBytesProperty(unknownKey));
- }
-
- // Package protected ---------------------------------------------
-
- // Protected -----------------------------------------------------
-
- // Private -------------------------------------------------------
-
- // Inner classes -------------------------------------------------
-
-}
Deleted: trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TypedPropertiesTest.java
===================================================================
--- trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TypedPropertiesTest.java 2012-01-12 12:10:11 UTC (rev 12016)
+++ trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/TypedPropertiesTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -1,264 +0,0 @@
-/*
- * Copyright 2009 Red Hat, Inc.
- * Red Hat licenses this file to you under the Apache License, version
- * 2.0 (the "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-package org.hornetq.tests.unit.util;
-
-import java.util.Iterator;
-
-import junit.framework.Assert;
-
-import org.hornetq.api.core.HornetQBuffer;
-import org.hornetq.api.core.HornetQBuffers;
-import org.hornetq.api.core.SimpleString;
-import org.hornetq.tests.util.RandomUtil;
-import org.hornetq.tests.util.UnitTestCase;
-import org.hornetq.utils.TypedProperties;
-
-/**
- * @author <a href="mailto:jmesnil at redhat.com">Jeff Mesnil</a>
- *
- * @version <tt>$Revision$</tt>
- *
- */
-public class TypedPropertiesTest extends UnitTestCase
-{
- // Constants -----------------------------------------------------
-
- // Attributes ----------------------------------------------------
-
- // Static --------------------------------------------------------
-
- private static void assertEqualsTypeProperties(final TypedProperties expected, final TypedProperties actual)
- {
- Assert.assertNotNull(expected);
- Assert.assertNotNull(actual);
- Assert.assertEquals(expected.getEncodeSize(), actual.getEncodeSize());
- Assert.assertEquals(expected.getPropertyNames(), actual.getPropertyNames());
- Iterator<SimpleString> iterator = actual.getPropertyNames().iterator();
- while (iterator.hasNext())
- {
- SimpleString key = iterator.next();
- Object expectedValue = expected.getProperty(key);
- Object actualValue = actual.getProperty(key);
- if (expectedValue instanceof byte[] && actualValue instanceof byte[])
- {
- byte[] expectedBytes = (byte[])expectedValue;
- byte[] actualBytes = (byte[])actualValue;
- UnitTestCase.assertEqualsByteArrays(expectedBytes, actualBytes);
- }
- else
- {
- Assert.assertEquals(expectedValue, actualValue);
- }
- }
- }
-
- // Constructors --------------------------------------------------
-
- // Public --------------------------------------------------------
-
- private TypedProperties props;
-
- private SimpleString key;
-
- public void testCopyContructor() throws Exception
- {
- props.putSimpleStringProperty(key, RandomUtil.randomSimpleString());
-
- TypedProperties copy = new TypedProperties(props);
-
- Assert.assertEquals(props.getEncodeSize(), copy.getEncodeSize());
- Assert.assertEquals(props.getPropertyNames(), copy.getPropertyNames());
-
- Assert.assertTrue(copy.containsProperty(key));
- Assert.assertEquals(props.getProperty(key), copy.getProperty(key));
- }
-
- public void testRemove() throws Exception
- {
- props.putSimpleStringProperty(key, RandomUtil.randomSimpleString());
-
- Assert.assertTrue(props.containsProperty(key));
- Assert.assertNotNull(props.getProperty(key));
-
- props.removeProperty(key);
-
- Assert.assertFalse(props.containsProperty(key));
- Assert.assertNull(props.getProperty(key));
- }
-
- public void testClear() throws Exception
- {
- props.putSimpleStringProperty(key, RandomUtil.randomSimpleString());
-
- Assert.assertTrue(props.containsProperty(key));
- Assert.assertNotNull(props.getProperty(key));
-
- props.clear();
-
- Assert.assertFalse(props.containsProperty(key));
- Assert.assertNull(props.getProperty(key));
- }
-
- public void testKey() throws Exception
- {
- props.putBooleanProperty(key, true);
- boolean bool = (Boolean)props.getProperty(key);
- Assert.assertEquals(true, bool);
-
- props.putCharProperty(key, 'a');
- char c = (Character)props.getProperty(key);
- Assert.assertEquals('a', c);
- }
-
- public void testGetPropertyOnEmptyProperties() throws Exception
- {
- Assert.assertFalse(props.containsProperty(key));
- Assert.assertNull(props.getProperty(key));
- }
-
- public void testRemovePropertyOnEmptyProperties() throws Exception
- {
- Assert.assertFalse(props.containsProperty(key));
- Assert.assertNull(props.removeProperty(key));
- }
-
- public void testNullProperty() throws Exception
- {
- props.putSimpleStringProperty(key, null);
- Assert.assertTrue(props.containsProperty(key));
- Assert.assertNull(props.getProperty(key));
- }
-
- public void testBytesPropertyWithNull() throws Exception
- {
- props.putBytesProperty(key, null);
-
- Assert.assertTrue(props.containsProperty(key));
- byte[] bb = (byte[])props.getProperty(key);
- Assert.assertNull(bb);
- }
-
- public void testTypedProperties() throws Exception
- {
- SimpleString longKey = RandomUtil.randomSimpleString();
- long longValue = RandomUtil.randomLong();
- SimpleString simpleStringKey = RandomUtil.randomSimpleString();
- SimpleString simpleStringValue = RandomUtil.randomSimpleString();
- TypedProperties otherProps = new TypedProperties();
- otherProps.putLongProperty(longKey, longValue);
- otherProps.putSimpleStringProperty(simpleStringKey, simpleStringValue);
-
- props.putTypedProperties(otherProps);
-
- long ll = props.getLongProperty(longKey);
- Assert.assertEquals(longValue, ll);
- SimpleString ss = props.getSimpleStringProperty(simpleStringKey);
- Assert.assertEquals(simpleStringValue, ss);
- }
-
- public void testEmptyTypedProperties() throws Exception
- {
- Assert.assertEquals(0, props.getPropertyNames().size());
-
- props.putTypedProperties(new TypedProperties());
-
- Assert.assertEquals(0, props.getPropertyNames().size());
- }
-
- public void testNullTypedProperties() throws Exception
- {
- Assert.assertEquals(0, props.getPropertyNames().size());
-
- props.putTypedProperties(null);
-
- Assert.assertEquals(0, props.getPropertyNames().size());
- }
-
- public void testEncodeDecode() throws Exception
- {
- props.putByteProperty(RandomUtil.randomSimpleString(), RandomUtil.randomByte());
- props.putBytesProperty(RandomUtil.randomSimpleString(), RandomUtil.randomBytes());
- props.putBytesProperty(RandomUtil.randomSimpleString(), null);
- props.putBooleanProperty(RandomUtil.randomSimpleString(), RandomUtil.randomBoolean());
- props.putShortProperty(RandomUtil.randomSimpleString(), RandomUtil.randomShort());
- props.putIntProperty(RandomUtil.randomSimpleString(), RandomUtil.randomInt());
- props.putLongProperty(RandomUtil.randomSimpleString(), RandomUtil.randomLong());
- props.putFloatProperty(RandomUtil.randomSimpleString(), RandomUtil.randomFloat());
- props.putDoubleProperty(RandomUtil.randomSimpleString(), RandomUtil.randomDouble());
- props.putCharProperty(RandomUtil.randomSimpleString(), RandomUtil.randomChar());
- props.putSimpleStringProperty(RandomUtil.randomSimpleString(), RandomUtil.randomSimpleString());
- props.putSimpleStringProperty(RandomUtil.randomSimpleString(), null);
- SimpleString keyToRemove = RandomUtil.randomSimpleString();
- props.putSimpleStringProperty(keyToRemove, RandomUtil.randomSimpleString());
-
- HornetQBuffer buffer = HornetQBuffers.dynamicBuffer(1024);
- props.encode(buffer);
-
- Assert.assertEquals(props.getEncodeSize(), buffer.writerIndex());
-
- TypedProperties decodedProps = new TypedProperties();
- decodedProps.decode(buffer);
-
- TypedPropertiesTest.assertEqualsTypeProperties(props, decodedProps);
-
- buffer.clear();
-
- // After removing a property, you should still be able to encode the Property
- props.removeProperty(keyToRemove);
- props.encode(buffer);
-
- Assert.assertEquals(props.getEncodeSize(), buffer.writerIndex());
- }
-
- public void testEncodeDecodeEmpty() throws Exception
- {
- TypedProperties emptyProps = new TypedProperties();
-
- HornetQBuffer buffer = HornetQBuffers.dynamicBuffer(1024);
- emptyProps.encode(buffer);
-
- Assert.assertEquals(props.getEncodeSize(), buffer.writerIndex());
-
- TypedProperties decodedProps = new TypedProperties();
- decodedProps.decode(buffer);
-
- TypedPropertiesTest.assertEqualsTypeProperties(emptyProps, decodedProps);
- }
-
- @Override
- protected void setUp() throws Exception
- {
- super.setUp();
-
- props = new TypedProperties();
- key = RandomUtil.randomSimpleString();
- }
-
- @Override
- protected void tearDown() throws Exception
- {
- key = null;
- props = null;
-
- super.tearDown();
- }
-
- // Package protected ---------------------------------------------
-
- // Protected -----------------------------------------------------
-
- // Private -------------------------------------------------------
-
- // Inner classes -------------------------------------------------
-}
Deleted: trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/XMLUtilTest.java
===================================================================
--- trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/XMLUtilTest.java 2012-01-12 12:10:11 UTC (rev 12016)
+++ trunk/tests/unit-tests/src/test/java/org/hornetq/tests/unit/util/XMLUtilTest.java 2012-01-12 12:10:54 UTC (rev 12017)
@@ -1,258 +0,0 @@
-/*
- * Copyright 2009 Red Hat, Inc.
- * Red Hat licenses this file to you under the Apache License, version
- * 2.0 (the "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-package org.hornetq.tests.unit.util;
-
-import junit.framework.Assert;
-
-import org.hornetq.tests.util.UnitTestCase;
-import org.hornetq.utils.XMLUtil;
-import org.w3c.dom.Element;
-import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
-
-/**
- * @author <a href="mailto:ovidiu at feodorov.com">Ovidiu Feodorov</a>
- * @version <tt>$Revision$</tt>
- */
-public class XMLUtilTest extends UnitTestCase
-{
- // Constructors --------------------------------------------------
-
- // Public --------------------------------------------------------
-
- public void testGetTextContext_1() throws Exception
- {
- String document = "<blah>foo</blah>";
-
- Element e = org.hornetq.utils.XMLUtil.stringToElement(document);
-
- Assert.assertEquals("foo", org.hornetq.utils.XMLUtil.getTextContent(e));
- }
-
- public void testGetTextContext_2() throws Exception
- {
- String document = "<blah someattribute=\"somevalue\">foo</blah>";
-
- Element e = XMLUtil.stringToElement(document);
-
- Assert.assertEquals("foo", org.hornetq.utils.XMLUtil.getTextContent(e));
- }
-
- public void testGetTextContext_3() throws Exception
- {
- String document = "<blah someattribute=\"somevalue\"><a/></blah>";
-
- Element e = org.hornetq.utils.XMLUtil.stringToElement(document);
-
- String s = org.hornetq.utils.XMLUtil.getTextContent(e);
-
- Element subelement = org.hornetq.utils.XMLUtil.stringToElement(s);
-
- Assert.assertEquals("a", subelement.getNodeName());
- }
-
- public void testGetTextContext_4() throws Exception
- {
- String document = "<blah someattribute=\"somevalue\"><a></a></blah>";
-
- Element e = org.hornetq.utils.XMLUtil.stringToElement(document);
-
- String s = org.hornetq.utils.XMLUtil.getTextContent(e);
-
- Element subelement = org.hornetq.utils.XMLUtil.stringToElement(s);
-
- Assert.assertEquals("a", subelement.getNodeName());
- }
-
- public void testGetTextContext_5() throws Exception
- {
- String document = "<blah someattribute=\"somevalue\"><a><b/></a></blah>";
-
- Element e = org.hornetq.utils.XMLUtil.stringToElement(document);
-
- String s = org.hornetq.utils.XMLUtil.getTextContent(e);
-
- Element subelement = org.hornetq.utils.XMLUtil.stringToElement(s);
-
- Assert.assertEquals("a", subelement.getNodeName());
- NodeList nl = subelement.getChildNodes();
-
- // try to find <b>
- boolean found = false;
- for (int i = 0; i < nl.getLength(); i++)
- {
- Node n = nl.item(i);
- if ("b".equals(n.getNodeName()))
- {
- found = true;
- }
- }
- Assert.assertTrue(found);
- }
-
- public void testEquivalent_1() throws Exception
- {
- String s = "<a/>";
- String s2 = "<a/>";
-
- XMLUtil.assertEquivalent(XMLUtil.stringToElement(s), org.hornetq.utils.XMLUtil.stringToElement(s2));
- }
-
- public void testEquivalent_2() throws Exception
- {
- String s = "<a></a>";
- String s2 = "<a/>";
-
- XMLUtil.assertEquivalent(XMLUtil.stringToElement(s), org.hornetq.utils.XMLUtil.stringToElement(s2));
- }
-
- public void testEquivalent_3() throws Exception
- {
- String s = "<a attr1=\"val1\" attr2=\"val2\"/>";
- String s2 = "<a attr2=\"val2\"/>";
-
- try
- {
- org.hornetq.utils.XMLUtil.assertEquivalent(org.hornetq.utils.XMLUtil.stringToElement(s),
- XMLUtil.stringToElement(s2));
- Assert.fail("this should throw exception");
- }
- catch (IllegalArgumentException e)
- {
- // OK
- e.printStackTrace();
- }
- }
-
- public void testEquivalent_4() throws Exception
- {
- String s = "<a attr1=\"val1\" attr2=\"val2\"/>";
- String s2 = "<a attr2=\"val2\" attr1=\"val1\"/>";
-
- org.hornetq.utils.XMLUtil.assertEquivalent(org.hornetq.utils.XMLUtil.stringToElement(s),
- org.hornetq.utils.XMLUtil.stringToElement(s2));
- }
-
- public void testEquivalent_5() throws Exception
- {
- String s = "<a><b/></a>";
- String s2 = "<a><b/></a>";
-
- org.hornetq.utils.XMLUtil.assertEquivalent(org.hornetq.utils.XMLUtil.stringToElement(s),
- org.hornetq.utils.XMLUtil.stringToElement(s2));
- }
-
- public void testEquivalent_6() throws Exception
- {
- String s = "<enclosing><a attr1=\"val1\" attr2=\"val2\"/></enclosing>";
- String s2 = "<enclosing><a attr2=\"val2\" attr1=\"val1\"/></enclosing>";
-
- org.hornetq.utils.XMLUtil.assertEquivalent(XMLUtil.stringToElement(s),
- org.hornetq.utils.XMLUtil.stringToElement(s2));
- }
-
- public void testEquivalent_7() throws Exception
- {
- String s = "<a><b/><c/></a>";
- String s2 = "<a><c/><b/></a>";
-
- try
- {
- org.hornetq.utils.XMLUtil.assertEquivalent(org.hornetq.utils.XMLUtil.stringToElement(s),
- org.hornetq.utils.XMLUtil.stringToElement(s2));
- Assert.fail("this should throw exception");
- }
- catch (IllegalArgumentException e)
- {
- // OK
- e.printStackTrace();
- }
- }
-
- public void testEquivalent_8() throws Exception
- {
- String s = "<a><!-- some comment --><b/><!--some other comment --><c/><!-- blah --></a>";
- String s2 = "<a><b/><!--blah blah--><c/></a>";
-
- org.hornetq.utils.XMLUtil.assertEquivalent(XMLUtil.stringToElement(s),
- org.hornetq.utils.XMLUtil.stringToElement(s2));
- }
-
- public void testElementToString_1() throws Exception
- {
- String s = "<a b=\"something\">somethingelse</a>";
- Element e = org.hornetq.utils.XMLUtil.stringToElement(s);
- String tostring = org.hornetq.utils.XMLUtil.elementToString(e);
- Element convertedAgain = org.hornetq.utils.XMLUtil.stringToElement(tostring);
- org.hornetq.utils.XMLUtil.assertEquivalent(e, convertedAgain);
- }
-
- public void testElementToString_2() throws Exception
- {
- String s = "<a b=\"something\"></a>";
- Element e = org.hornetq.utils.XMLUtil.stringToElement(s);
- String tostring = XMLUtil.elementToString(e);
- Element convertedAgain = XMLUtil.stringToElement(tostring);
- XMLUtil.assertEquivalent(e, convertedAgain);
- }
-
- public void testElementToString_3() throws Exception
- {
- String s = "<a b=\"something\"/>";
- Element e = org.hornetq.utils.XMLUtil.stringToElement(s);
- String tostring = XMLUtil.elementToString(e);
- Element convertedAgain = org.hornetq.utils.XMLUtil.stringToElement(tostring);
- org.hornetq.utils.XMLUtil.assertEquivalent(e, convertedAgain);
- }
-
- public void testElementToString_4() throws Exception
- {
- String s = "<a><![CDATA[somedata]]></a>";
- Element e = org.hornetq.utils.XMLUtil.stringToElement(s);
- String tostring = XMLUtil.elementToString(e);
- Element convertedAgain = org.hornetq.utils.XMLUtil.stringToElement(tostring);
- org.hornetq.utils.XMLUtil.assertEquivalent(e, convertedAgain);
- }
-
- public void testReplaceSystemProperties()
- {
- String before = "<configuration>\n" + " <test name=\"${sysprop1}\">content1</test>\n"
- + " <test name=\"test2\">content2</test>\n"
- + " <test name=\"test3\">content3</test>\n"
- + " <test name=\"test4\">${sysprop2}</test>\n"
- + " <test name=\"test5\">content5</test>\n"
- + " <test name=\"test6\">content6</test>\n"
- + "</configuration>";
- String after = "<configuration>\n" + " <test name=\"test1\">content1</test>\n"
- + " <test name=\"test2\">content2</test>\n"
- + " <test name=\"test3\">content3</test>\n"
- + " <test name=\"test4\">content4</test>\n"
- + " <test name=\"test5\">content5</test>\n"
- + " <test name=\"test6\">content6</test>\n"
- + "</configuration>";
- System.setProperty("sysprop1", "test1");
- System.setProperty("sysprop2", "content4");
- String replaced = org.hornetq.utils.XMLUtil.replaceSystemProps(before);
- Assert.assertEquals(after, replaced);
- }
-
- public void testStripCDATA() throws Exception
- {
- String xml = "<![CDATA[somedata]]>";
- String stripped = XMLUtil.stripCDATA(xml);
-
- Assert.assertEquals("somedata", stripped);
- }
-
-}
More information about the hornetq-commits
mailing list