You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@turbine.apache.org by gk...@apache.org on 2018/12/13 14:54:05 UTC
svn commit: r1848852 [2/3] - in /turbine/fulcrum/trunk: ./
crypto/src/test/org/apache/fulcrum/crypto/
intake/src/test/org/apache/fulcrum/intake/
json/jackson2/src/java/org/apache/fulcrum/json/jackson/
json/jackson2/src/test/ json/jackson2/src/test/org/...
Modified: turbine/fulcrum/trunk/json/jackson2/src/test/org/apache/fulcrum/json/jackson/DefaultServiceTest.java
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/json/jackson2/src/test/org/apache/fulcrum/json/jackson/DefaultServiceTest.java?rev=1848852&r1=1848851&r2=1848852&view=diff
==============================================================================
--- turbine/fulcrum/trunk/json/jackson2/src/test/org/apache/fulcrum/json/jackson/DefaultServiceTest.java (original)
+++ turbine/fulcrum/trunk/json/jackson2/src/test/org/apache/fulcrum/json/jackson/DefaultServiceTest.java Thu Dec 13 14:54:04 2018
@@ -50,6 +50,7 @@ import org.apache.fulcrum.testcontainer.
import org.apache.log4j.LogManager;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestReporter;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.runner.RunWith;
@@ -314,7 +315,7 @@ public class DefaultServiceTest extends
* @throws Exception generic exception
*/
@Test
- public void testSerializationCollectioPrimitiveWrapper() throws Exception {
+ public void testSerializationCollectioPrimitiveWrapper(TestReporter testReporter) throws Exception {
List<Integer> intList = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
Integer integer = new Integer(i * i);
@@ -323,7 +324,7 @@ public class DefaultServiceTest extends
String result = sc.serializeOnlyFilter(intList, Integer.class);
assertEquals("[0,1,4,9,16,25,36,49,64,81]", result, "Serialization of beans failed ");
// primitives could be deserialzed without type
- Collection<Integer> result2 = checkDeserCollection(result, List.class, Integer.class);
+ Collection<Integer> result2 = checkDeserCollection(result, List.class, Integer.class, testReporter);
assertTrue( !result2.isEmpty(), "expect at least one entry ");
assertTrue( result2.iterator().next().getClass().isAssignableFrom(Integer.class), "result entry instance check");
}
@@ -553,7 +554,7 @@ public class DefaultServiceTest extends
* @throws Exception generic exception
*/
@Test
- public void testSerializeCollectionWithOnlyFilterAndParentClass() throws Exception {
+ public void testSerializeCollectionWithOnlyFilterAndParentClass(TestReporter testReporter) throws Exception {
List<BeanChild> beanList = new ArrayList<BeanChild>();
for (int i = 0; i < 3; i++) {
BeanChild bean = new BeanChild();
@@ -566,7 +567,7 @@ public class DefaultServiceTest extends
// assertEquals("[{\"type\":\"\"},{\"type\":\"\"},{\"type\":\"\"}]",sc.serializeOnlyFilter(beanList,
// BeanChild.class, true,"type"));
- Collection<BeanChild> result2 = checkDeserCollection(jsonResult, List.class, BeanChild.class);
+ Collection<BeanChild> result2 = checkDeserCollection(jsonResult, List.class, BeanChild.class, testReporter);
assertTrue( !result2.isEmpty());
assertTrue(
result2.iterator().next().getClass().isAssignableFrom(BeanChild.class),
@@ -577,7 +578,7 @@ public class DefaultServiceTest extends
* @throws Exception generic exception
*/
@Test
- public void testSerializeCollectionWithOnlyFilterAndExactClass() throws Exception {
+ public void testSerializeCollectionWithOnlyFilterAndExactClass(TestReporter testReporter) throws Exception {
List<Bean> beanList = new ArrayList<Bean>();
for (int i = 0; i < 3; i++) {
Bean bean = new BeanChild();
@@ -589,7 +590,7 @@ public class DefaultServiceTest extends
assertEquals("[{\"name\":\"bean0\"},{\"name\":\"bean1\"},{\"name\":\"bean2\"}]", jsonResult);
// assertEquals("[{\"type\":\"\"},{\"type\":\"\"},{\"type\":\"\"}]",sc.serializeOnlyFilter(beanList,
// BeanChild.class, true,"type"));
- Collection<Bean> result2 = checkDeserCollection(jsonResult, List.class, Bean.class);
+ Collection<Bean> result2 = checkDeserCollection(jsonResult, List.class, Bean.class, testReporter);
assertTrue( !result2.isEmpty(), "expect at least one entry ");
assertTrue( result2.iterator().next().getClass().isAssignableFrom(Bean.class), "result entry instance check");
}
@@ -598,7 +599,7 @@ public class DefaultServiceTest extends
* @throws Exception generic exception
*/
@Test
- public void testSerializeCollectionWithOnlyFilterWithChildClass() throws Exception {
+ public void testSerializeCollectionWithOnlyFilterWithChildClass(TestReporter testReporter) throws Exception {
List<Bean> beanList = new ArrayList<Bean>();
for (int i = 0; i < 3; i++) {
Bean bean = new Bean();
@@ -610,7 +611,7 @@ public class DefaultServiceTest extends
assertEquals("[{\"name\":\"bean0\"},{\"name\":\"bean1\"},{\"name\":\"bean2\"}]", jsonResult);
// assertEquals("[{\"type\":\"\"},{\"type\":\"\"},{\"type\":\"\"}]",sc.serializeOnlyFilter(beanList,
// BeanChild.class, true,"type"));
- Collection<Bean> result2 = checkDeserCollection(jsonResult, List.class, Bean.class);
+ Collection<Bean> result2 = checkDeserCollection(jsonResult, List.class, Bean.class, testReporter);
assertTrue( !result2.isEmpty(), "expect at least one entry ");
assertTrue( result2.iterator().next().getClass().isAssignableFrom(Bean.class), "result entry instance check");
}
@@ -655,7 +656,7 @@ public class DefaultServiceTest extends
* @throws Exception generic exception
*/
@Test
- public void testSerializeCollectionWithTypedReference() throws Exception {
+ public void testSerializeCollectionWithTypedReference(TestReporter testReporter) throws Exception {
List<TypedRectangle> rectList = new ArrayList<TypedRectangle>();
for (int i = 0; i < 2; i++) {
@@ -667,7 +668,7 @@ public class DefaultServiceTest extends
String jsonResult = ((Jackson2MapperService) sc).serCollectionWithTypeReference(rectList, typeRef, false);
logger.debug("aa:" + jsonResult);
// could deserialize with type information
- Collection<TypedRectangle> result2 = checkDeserCollection(jsonResult, List.class, TypedRectangle.class);
+ Collection<TypedRectangle> result2 = checkDeserCollection(jsonResult, List.class, TypedRectangle.class, testReporter);
assertTrue( !result2.isEmpty(), "expect at least one entry ");
assertTrue(
result2.iterator().next().getClass().isAssignableFrom(TypedRectangle.class),
@@ -712,10 +713,9 @@ public class DefaultServiceTest extends
}
private <U> Collection<U> checkDeserCollection(String serJson, Class<? extends Collection> collClass,
- Class<U> entryClass) throws Exception {
+ Class<U> entryClass, TestReporter testReporter) throws Exception {
Collection<U> result = ((Jackson2MapperService) sc).deSerCollectionWithType(serJson, collClass, entryClass);
- // System.out.println("result:"+ result + " is of type: "+ result.getClass() +
- // "and assignable from "+ collClass);
+ testReporter.publishEntry("result:"+ result + " is of type: "+ result.getClass() + "and assignable from "+ collClass);
assertTrue(collClass.isAssignableFrom(result.getClass()),
"Result Instance Check failed for result class " + result.getClass() + " and target class: " + collClass);
return result;
Modified: turbine/fulcrum/trunk/parser/src/test/org/apache/fulcrum/parser/BaseValueParserTest.java
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/parser/src/test/org/apache/fulcrum/parser/BaseValueParserTest.java?rev=1848852&r1=1848851&r2=1848852&view=diff
==============================================================================
--- turbine/fulcrum/trunk/parser/src/test/org/apache/fulcrum/parser/BaseValueParserTest.java (original)
+++ turbine/fulcrum/trunk/parser/src/test/org/apache/fulcrum/parser/BaseValueParserTest.java Thu Dec 13 14:54:04 2018
@@ -1,13 +1,5 @@
package org.apache.fulcrum.parser;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
@@ -26,15 +18,20 @@ import static org.junit.Assert.fail;
* specific language governing permissions and limitations
* under the License.
*/
+
+import static org.junit.jupiter.api.Assertions.*;
+
import java.math.BigDecimal;
import java.util.Calendar;
import java.util.Locale;
import org.apache.avalon.framework.component.ComponentException;
-import org.apache.fulcrum.testcontainer.BaseUnit4Test;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import org.apache.fulcrum.testcontainer.BaseUnit5Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+
/**
* Testing of the BaseValueParser class
@@ -42,7 +39,7 @@ import org.junit.Test;
* @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
* @version $Id: BaseValueParserTest.java 222043 2004-12-06 17:47:33Z painter $
*/
-public class BaseValueParserTest extends BaseUnit4Test
+public class BaseValueParserTest extends BaseUnit5Test
{
private BaseValueParser parser;
@@ -53,7 +50,7 @@ public class BaseValueParserTest extends
* Performs any initialization that must happen before each test is run.
* @throws Exception
*/
- @Before
+ @BeforeEach
public void setUp() throws Exception
{
try
@@ -71,7 +68,7 @@ public class BaseValueParserTest extends
/**
* Clean up after each test is run.
*/
- @After
+ @AfterEach
public void tearDown()
{
parserService.putParser(parser);
@@ -83,7 +80,7 @@ public class BaseValueParserTest extends
parser.clear();
parser.setLocale(Locale.US);
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals(0, parser.keySet().size(), "Wrong number of keys");
parser.add("foo", "03/21/2008");
@@ -91,7 +88,7 @@ public class BaseValueParserTest extends
cal.clear();
cal.set(2008, 2, 21, 0, 0, 0);
- assertEquals("Wrong Date value (US)", cal.getTime(), parser.getDate("foo"));
+ assertEquals( cal.getTime(), parser.getDate("foo"), "Wrong Date value (US)");
parser.clear();
parser.setLocale(Locale.GERMANY);
@@ -102,7 +99,7 @@ public class BaseValueParserTest extends
cal.clear();
cal.set(2008, 2, 21, 0, 0, 0);
- assertEquals("Wrong Date value (German)", cal.getTime(), parser.getDate("foo"));
+ assertEquals( cal.getTime(), parser.getDate("foo"), "Wrong Date value (German)");
}
@Test
public void testGetByte()
@@ -241,21 +238,21 @@ public class BaseValueParserTest extends
{
// no param
float result = parser.getFloat("invalid");
- assertEquals(result, 0, 0);
+ assertEquals(0, result);
// default
result = parser.getFloat("default", 3);
- assertEquals(result, 3, 0);
+ assertEquals(3, result);
// param exists
parser.add("exists", "1");
result = parser.getFloat("exists");
- assertEquals(result, 1, 0);
+ assertEquals(1, result);
// unparsable value
parser.add("unparsable", "a");
result = parser.getFloat("unparsable");
- assertEquals(result, 0, 0);
+ assertEquals(0, result);
// array
parser.add("array", "1");
@@ -266,7 +263,7 @@ public class BaseValueParserTest extends
assertEquals(arrayResult.length, compare.length);
for( int i=0; i<compare.length; i++)
{
- assertEquals(compare[i], arrayResult[i], 0);
+ assertEquals(compare[i], arrayResult[i]);
}
// array w/ unparsable element
@@ -275,10 +272,10 @@ public class BaseValueParserTest extends
parser.add("array2", "3");
float arrayResult2[] = parser.getFloats("array2");
float compare2[] = {1,0,3};
- assertEquals(arrayResult2.length, compare2.length);
+ assertEquals(compare2.length, arrayResult2.length);
for( int i=0; i<compare2.length; i++)
{
- assertEquals(compare2[i], arrayResult2[i], 0);
+ assertEquals(compare2[i], arrayResult2[i]);
}
}
@Test
@@ -290,12 +287,12 @@ public class BaseValueParserTest extends
// default
result = parser.getFloatObject("default", new Float(3));
- assertEquals(result, new Float(3));
+ assertEquals(new Float(3), result);
// param exists
parser.add("exists", "1");
result = parser.getFloatObject("exists");
- assertEquals(result, new Float(1));
+ assertEquals(new Float(1), result);
// unparsable value
parser.add("unparsable", "a");
@@ -308,7 +305,7 @@ public class BaseValueParserTest extends
parser.add("array", "3");
Float arrayResult[] = parser.getFloatObjects("array");
Float compare[] = {new Float(1), new Float(2), new Float(3)};
- assertEquals(arrayResult.length, compare.length);
+ assertEquals(compare.length, arrayResult.length);
for( int i=0; i<compare.length; i++)
{
assertEquals(compare[i], arrayResult[i]);
@@ -320,10 +317,10 @@ public class BaseValueParserTest extends
parser.add("array2", "3");
Float arrayResult2[] = parser.getFloatObjects("array2");
Float compare2[] = {new Float(1), null, new Float(3)};
- assertEquals(arrayResult2.length, compare2.length);
+ assertEquals(compare2.length, arrayResult2.length);
for( int i=0; i<compare2.length; i++)
{
- assertEquals(compare2[i], arrayResult2[i] );
+ assertEquals(arrayResult2[i], compare2[i] );
}
}
@Test
@@ -331,21 +328,21 @@ public class BaseValueParserTest extends
{
// no param
double result = parser.getDouble("invalid");
- assertEquals(result, 0, 0);
+ assertEquals(0, result);
// default
result = parser.getDouble("default", 3);
- assertEquals(result, 3, 0);
+ assertEquals(3, result);
// param exists
parser.add("exists", "1");
result = parser.getDouble("exists");
- assertEquals(result, 1, 0);
+ assertEquals(1, result);
// unparsable value
parser.add("unparsable", "a");
result = parser.getDouble("unparsable");
- assertEquals(result, 0, 0);
+ assertEquals(0, result);
// array
parser.add("array", "1");
@@ -356,7 +353,7 @@ public class BaseValueParserTest extends
assertEquals(arrayResult.length, compare.length);
for( int i=0; i<compare.length; i++)
{
- assertEquals(compare[i], arrayResult[i], 0);
+ assertEquals( arrayResult[i], compare[i]);
}
// array w/ unparsable element
@@ -368,7 +365,7 @@ public class BaseValueParserTest extends
assertEquals(arrayResult2.length, compare2.length);
for( int i=0; i<compare2.length; i++)
{
- assertEquals(compare2[i], arrayResult2[i], 0);
+ assertEquals( arrayResult2[i], compare2[i]);
}
}
@Test
@@ -380,12 +377,12 @@ public class BaseValueParserTest extends
// default
result = parser.getDoubleObject("default", new Double(3));
- assertEquals(result, new Double(3));
+ assertEquals( new Double(3), result);
// param exists
parser.add("exists", "1");
result = parser.getDoubleObject("exists");
- assertEquals(result, new Double(1));
+ assertEquals( new Double(1), result);
// unparsable value
parser.add("unparsable", "a");
@@ -401,7 +398,7 @@ public class BaseValueParserTest extends
assertEquals(arrayResult.length, compare.length);
for( int i=0; i<compare.length; i++)
{
- assertEquals(compare[i], arrayResult[i]);
+ assertEquals( arrayResult[i], compare[i]);
}
// array w/ unparsable element
@@ -413,7 +410,7 @@ public class BaseValueParserTest extends
assertEquals(arrayResult2.length, compare2.length);
for( int i=0; i<compare2.length; i++)
{
- assertEquals(compare2[i], arrayResult2[i] );
+ assertEquals( arrayResult2[i], compare2[i] );
}
}
@Test
@@ -421,21 +418,21 @@ public class BaseValueParserTest extends
{
// no param
long result = parser.getLong("invalid");
- assertEquals(result, 0);
+ assertEquals(0, result);
// default
result = parser.getLong("default", 3);
- assertEquals(result, 3);
+ assertEquals(3, result);
// param exists
parser.add("exists", "1");
result = parser.getLong("exists");
- assertEquals(result, 1);
+ assertEquals(1, result);
// unparsable value
parser.add("unparsable", "a");
result = parser.getLong("unparsable");
- assertEquals(result, 0);
+ assertEquals(0, result);
// array
parser.add("array", "1");
@@ -458,7 +455,7 @@ public class BaseValueParserTest extends
assertEquals(arrayResult2.length, compare2.length);
for( int i=0; i<compare2.length; i++)
{
- assertEquals(compare2[i], arrayResult2[i]);
+ assertEquals( arrayResult2[i], compare2[i]);
}
}
@Test
@@ -680,12 +677,12 @@ public class BaseValueParserTest extends
}
catch (InstantiationException e)
{
- assertTrue("Could not instantiate ValueParser object", false);
+ assertTrue(false, "Could not instantiate ValueParser object");
}
// TODO expose PARAMETER_ENCODING_DEFAULT
-// assertEquals("Wrong Character Encoding", TurbineConstants.PARAMETER_ENCODING_DEFAULT, vp.getCharacterEncoding());
+// assertEquals( TurbineConstants.PARAMETER_ENCODING_DEFAULT, vp.getCharacterEncoding(),"Wrong Character Encoding");
}
/**
@@ -696,27 +693,27 @@ public class BaseValueParserTest extends
// {
// ValueParser vp = new BaseValueParser();
//
-// assertEquals("Wrong Character Encoding", TurbineConstants.PARAMETER_ENCODING_DEFAULT, vp.getCharacterEncoding());
+// assertEquals( TurbineConstants.PARAMETER_ENCODING_DEFAULT, vp.getCharacterEncoding(),"Wrong Character Encoding");
//
// String encoding = "ISO-8859-2";
// vp.setCharacterEncoding(encoding);
//
-// assertEquals("Wrong Character Encoding", encoding, vp.getCharacterEncoding());
+// assertEquals( encoding, vp.getCharacterEncoding(),"Wrong Character Encoding");
// }
@Test
public void testClear()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
parser.add("foo", "bar");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
}
@Test
@@ -724,15 +721,15 @@ public class BaseValueParserTest extends
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
parser.add("foo", "bar");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
parser.dispose();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
assertTrue(parser.isDisposed());
}
@@ -741,15 +738,15 @@ public class BaseValueParserTest extends
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
parser.add("bar", "foo");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
parser.add("bar", "baz");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
}
public void testDoubleAdd()
@@ -757,310 +754,310 @@ public class BaseValueParserTest extends
parser.clear();
parser.setLocale(Locale.US);
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
double testValue = 2.2;
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
- assertEquals("Wrong string value", "2.2", parser.getString("foo"));
- assertEquals("Wrong double value", testValue, parser.getDouble("foo"), 0.001);
- assertEquals("Wrong Double value", testValue, parser.getDoubleObject("foo").doubleValue(), 0.001);
+ assertEquals( "2.2", parser.getString("foo"), "Wrong string value");
+ assertEquals( testValue, parser.getDouble("foo"), 0.001, "Wrong double value");
+ assertEquals( testValue, parser.getDoubleObject("foo").doubleValue(), 0.001, "Wrong Double value");
double [] doubles = parser.getDoubles("foo");
- assertEquals("Wrong Array Size", 1, doubles.length);
+ assertEquals( 1, doubles.length,"Wrong Array Size");
- assertEquals("Wrong double array value", testValue, doubles[0], 0.001);
+ assertEquals( testValue, doubles[0], 0.001,"Wrong double array value");
Double [] doubleObjs = parser.getDoubleObjects("foo");
- assertEquals("Wrong Array Size", 1, doubleObjs.length);
+ assertEquals( 1, doubleObjs.length,"Wrong Array Size");
- assertEquals("Wrong Double array value", testValue, doubleObjs[0].doubleValue(), 0.001);
+ assertEquals( testValue, doubleObjs[0].doubleValue(), 0.001,"Wrong Double array value");
parser.clear();
parser.setLocale(Locale.GERMANY);
String testDouble = "2,3";
parser.add("foo", testDouble);
- assertEquals("Wrong double value", 2.3, parser.getDouble("foo"), 0.001);
+ assertEquals( 2.3, parser.getDouble("foo"), 0.001,"Wrong double value");
parser.add("unparsable2", "1a");
Double result = parser.getDoubleObject("unparsable2");
- assertNull("Double object should be null", result);
+ assertNull(result, "Double object should be null");
}
@Test
public void testIntAdd()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
int testValue = 123;
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong string value", "123", parser.getString("foo"));
- assertEquals("Wrong int value", testValue, parser.getInt("foo"));
- assertEquals("Wrong Int value", testValue, parser.getIntObject("foo").intValue());
+ assertEquals( "123", parser.getString("foo"),"Wrong string value");
+ assertEquals( testValue, parser.getInt("foo"),"Wrong int value");
+ assertEquals( testValue, parser.getIntObject("foo").intValue(),"Wrong Int value");
int [] ints = parser.getInts("foo");
- assertEquals("Wrong Array Size", 1, ints.length);
+ assertEquals( 1, ints.length,"Wrong Array Size");
- assertEquals("Wrong int array value", testValue, ints[0]);
+ assertEquals( testValue, ints[0],"Wrong int array value");
Integer [] intObjs = parser.getIntObjects("foo");
- assertEquals("Wrong Array Size", 1, intObjs.length);
+ assertEquals( 1, intObjs.length,"Wrong Array Size");
- assertEquals("Wrong Int array value", testValue, intObjs[0].intValue());
+ assertEquals( testValue, intObjs[0].intValue(),"Wrong Int array value");
}
@Test
public void testIntegerAdd()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
Integer testValue = new Integer(123);
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong string value", "123", parser.getString("foo"));
- assertEquals("Wrong int value", testValue.intValue(), parser.getInt("foo"));
- assertEquals("Wrong Int value", testValue.intValue(), parser.getIntObject("foo").intValue());
+ assertEquals( "123", parser.getString("foo"),"Wrong string value");
+ assertEquals( testValue.intValue(), parser.getInt("foo"),"Wrong int value");
+ assertEquals( testValue.intValue(), parser.getIntObject("foo").intValue(),"Wrong Int value");
int [] ints = parser.getInts("foo");
- assertEquals("Wrong Array Size", 1, ints.length);
+ assertEquals( 1, ints.length,"Wrong Array Size");
- assertEquals("Wrong int array value", testValue.intValue(), ints[0]);
+ assertEquals( testValue.intValue(), ints[0],"Wrong int array value");
Integer [] intObjs = parser.getIntObjects("foo");
- assertEquals("Wrong Array Size", 1, intObjs.length);
+ assertEquals( 1, intObjs.length,"Wrong Array Size");
- assertEquals("Wrong Int array value", testValue.intValue(), intObjs[0].intValue());
+ assertEquals( testValue.intValue(), intObjs[0].intValue(),"Wrong Int array value");
}
@Test
public void testLongAdd()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
long testValue = 9223372036854775807l;
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong string value", "9223372036854775807", parser.getString("foo"));
- assertEquals("Wrong long value", testValue, parser.getLong("foo"));
- assertEquals("Wrong Long value", testValue, parser.getLongObject("foo").longValue());
+ assertEquals( "9223372036854775807", parser.getString("foo"),"Wrong string value");
+ assertEquals( testValue, parser.getLong("foo"),"Wrong long value");
+ assertEquals( testValue, parser.getLongObject("foo").longValue(),"Wrong Long value");
long [] longs = parser.getLongs("foo");
- assertEquals("Wrong Array Size", 1, longs.length);
+ assertEquals( 1, longs.length,"Wrong Array Size");
- assertEquals("Wrong long array value", testValue, longs[0]);
+ assertEquals( testValue, longs[0],"Wrong long array value");
Long [] longObjs = parser.getLongObjects("foo");
- assertEquals("Wrong Array Size", 1, longObjs.length);
+ assertEquals( 1, longObjs.length,"Wrong Array Size");
- assertEquals("Wrong Long array value", testValue, longObjs[0].longValue());
+ assertEquals( testValue, longObjs[0].longValue(),"Wrong Long array value");
}
@Test
public void testLongToInt()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
long testValue = 1234l;
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong string value", "1234", parser.getString("foo"));
- assertEquals("Wrong int value", (int) testValue, parser.getInt("foo"));
- assertEquals("Wrong Int value", (int) testValue, parser.getIntObject("foo").intValue());
+ assertEquals( "1234", parser.getString("foo"),"Wrong string value");
+ assertEquals( (int) testValue, parser.getInt("foo"),"Wrong int value");
+ assertEquals( (int) testValue, parser.getIntObject("foo").intValue(),"Wrong Int value");
int [] ints = parser.getInts("foo");
- assertEquals("Wrong Array Size", 1, ints.length);
+ assertEquals( 1, ints.length,"Wrong Array Size");
- assertEquals("Wrong int array value", testValue, ints[0]);
+ assertEquals( testValue, ints[0],"Wrong int array value");
Integer [] intObjs = parser.getIntObjects("foo");
- assertEquals("Wrong Array Size", 1, intObjs.length);
+ assertEquals( 1, intObjs.length,"Wrong Array Size");
- assertEquals("Wrong Int array value", testValue, intObjs[0].intValue());
+ assertEquals( testValue, intObjs[0].intValue(),"Wrong Int array value");
}
public void testIntToLong()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
int testValue = 123;
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong string value", "123", parser.getString("foo"));
- assertEquals("Wrong long value", testValue, parser.getLong("foo"));
- assertEquals("Wrong Long value", testValue, parser.getLongObject("foo").longValue());
+ assertEquals( "123", parser.getString("foo"),"Wrong string value");
+ assertEquals( testValue, parser.getLong("foo"),"Wrong long value");
+ assertEquals( testValue, parser.getLongObject("foo").longValue(),"Wrong Long value");
long [] longs = parser.getLongs("foo");
- assertEquals("Wrong Array Size", 1, longs.length);
+ assertEquals( 1, longs.length,"Wrong Array Size");
- assertEquals("Wrong long array value", testValue, longs[0]);
+ assertEquals( testValue, longs[0],"Wrong long array value");
Long [] longObjs = parser.getLongObjects("foo");
- assertEquals("Wrong Array Size", 1, longObjs.length);
+ assertEquals( 1, longObjs.length,"Wrong Array Size");
- assertEquals("Wrong Long array value", testValue, longObjs[0].longValue());
+ assertEquals( testValue, longObjs[0].longValue(),"Wrong Long array value");
}
@Test
public void testIntToDouble()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
int testValue = 123;
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong string value", "123", parser.getString("foo"));
- assertEquals("Wrong double value", testValue, parser.getDouble("foo"), 0.001);
- assertEquals("Wrong Double value", testValue, parser.getDoubleObject("foo").doubleValue(), 0.001);
+ assertEquals( "123", parser.getString("foo"),"Wrong string value");
+ assertEquals( testValue, parser.getDouble("foo"), 0.001,"Wrong double value");
+ assertEquals( testValue, parser.getDoubleObject("foo").doubleValue(), 0.001,"Wrong Double value");
double [] doubles = parser.getDoubles("foo");
- assertEquals("Wrong Array Size", 1, doubles.length);
+ assertEquals( 1, doubles.length,"Wrong Array Size");
- assertEquals("Wrong double array value", testValue, doubles[0], 0.001);
+ assertEquals( testValue, doubles[0], 0.001,"Wrong double array value");
Double [] doubleObjs = parser.getDoubleObjects("foo");
- assertEquals("Wrong Array Size", 1, doubleObjs.length);
+ assertEquals( 1, doubleObjs.length,"Wrong Array Size");
- assertEquals("Wrong Double array value", testValue, doubleObjs[0].doubleValue(), 0.001);
+ assertEquals( testValue, doubleObjs[0].doubleValue(), 0.001,"Wrong Double array value");
}
@Test
public void testLongToDouble()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
long testValue = 9223372036854775807l;
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong string value", "9223372036854775807", parser.getString("foo"));
- assertEquals("Wrong double value", testValue, parser.getDouble("foo"), 0.001);
- assertEquals("Wrong Double value", testValue, parser.getDoubleObject("foo").doubleValue(), 0.001);
+ assertEquals( "9223372036854775807", parser.getString("foo"),"Wrong string value");
+ assertEquals( testValue, parser.getDouble("foo"), 0.001,"Wrong double value");
+ assertEquals( testValue, parser.getDoubleObject("foo").doubleValue(), 0.001,"Wrong Double value");
double [] doubles = parser.getDoubles("foo");
- assertEquals("Wrong Array Size", 1, doubles.length);
+ assertEquals( 1, doubles.length,"Wrong Array Size");
- assertEquals("Wrong double array value", testValue, doubles[0], 0.001);
+ assertEquals( testValue, doubles[0], 0.001,"Wrong double array value");
Double [] doubleObjs = parser.getDoubleObjects("foo");
- assertEquals("Wrong Array Size", 1, doubleObjs.length);
+ assertEquals( 1, doubleObjs.length,"Wrong Array Size");
- assertEquals("Wrong Double array value", testValue, doubleObjs[0].doubleValue(), 0.001);
+ assertEquals( testValue, doubleObjs[0].doubleValue(), 0.001,"Wrong Double array value");
}
public void testStringAdd()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
String testValue = "the quick brown fox";
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong string value", testValue, parser.getString("foo"));
+ assertEquals( testValue, parser.getString("foo"),"Wrong string value");
String [] Strings = parser.getStrings("foo");
- assertEquals("Wrong Array Size", 1, Strings.length);
+ assertEquals( 1, Strings.length,"Wrong Array Size");
- assertEquals("Wrong String array value", testValue, Strings[0]);
+ assertEquals( testValue, Strings[0],"Wrong String array value");
}
public void testStringToInt()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
String testValue = "123456";
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong string value", testValue, parser.getString("foo"));
+ assertEquals( testValue, parser.getString("foo"),"Wrong string value");
- assertEquals("Wrong int value", Integer.parseInt(testValue), parser.getInt("foo"));
- assertEquals("Wrong Int value", Integer.valueOf(testValue).intValue(), parser.getIntObject("foo").intValue());
+ assertEquals( Integer.parseInt(testValue), parser.getInt("foo"),"Wrong int value");
+ assertEquals( Integer.valueOf(testValue).intValue(), parser.getIntObject("foo").intValue(),"Wrong Int value");
int [] ints = parser.getInts("foo");
- assertEquals("Wrong Array Size", 1, ints.length);
+ assertEquals( 1, ints.length,"Wrong Array Size");
- assertEquals("Wrong int array value", Integer.parseInt(testValue), ints[0]);
+ assertEquals( Integer.parseInt(testValue), ints[0],"Wrong int array value");
Integer [] intObjs = parser.getIntObjects("foo");
- assertEquals("Wrong Array Size", 1, intObjs.length);
+ assertEquals( 1, intObjs.length,"Wrong Array Size");
- assertEquals("Wrong Int array value", Integer.valueOf(testValue).intValue(), intObjs[0].intValue());
+ assertEquals( Integer.valueOf(testValue).intValue(), intObjs[0].intValue(),"Wrong Int array value");
}
public void testStringToLong()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
String testValue = "123456";
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong string value", testValue, parser.getString("foo"));
+ assertEquals( testValue, parser.getString("foo"),"Wrong string value");
- assertEquals("Wrong long value", Long.parseLong(testValue), parser.getLong("foo"));
- assertEquals("Wrong Long value", Long.valueOf(testValue).longValue(), parser.getLongObject("foo").longValue());
+ assertEquals( Long.parseLong(testValue), parser.getLong("foo"),"Wrong long value");
+ assertEquals( Long.valueOf(testValue).longValue(), parser.getLongObject("foo").longValue(),"Wrong Long value");
long [] longs = parser.getLongs("foo");
- assertEquals("Wrong Array Size", 1, longs.length);
+ assertEquals( 1, longs.length,"Wrong Array Size");
- assertEquals("Wrong long array value", Long.parseLong(testValue), longs[0]);
+ assertEquals( Long.parseLong(testValue), longs[0],"Wrong long array value");
Long [] longObjs = parser.getLongObjects("foo");
- assertEquals("Wrong Array Size", 1, longObjs.length);
+ assertEquals( 1, longObjs.length,"Wrong Array Size");
- assertEquals("Wrong Long array value", Long.valueOf(testValue).longValue(), longObjs[0].longValue());
+ assertEquals( Long.valueOf(testValue).longValue(), longObjs[0].longValue(),"Wrong Long array value");
}
@Test
public void testStringArray()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
String [] testValue = new String [] {
"foo", "bar", "baz"
@@ -1068,53 +1065,53 @@ public class BaseValueParserTest extends
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
String [] res = parser.getStrings("foo");
- assertEquals("Wrong number of elements", 3, res.length);
+ assertEquals( 3, res.length,"Wrong number of elements");
for (int i = 0; i < res.length; i++)
{
- assertEquals("Wrong value", res[i], testValue[i]);
+ assertEquals( res[i], testValue[i],"Wrong value");
}
- assertEquals("Wrong element returned", testValue[0], parser.getString("foo"));
+ assertEquals( testValue[0], parser.getString("foo"),"Wrong element returned");
parser.add("foo", "xxx");
res = parser.getStrings("foo");
- assertEquals("Wrong number of elements", 4, res.length);
+ assertEquals( 4, res.length,"Wrong number of elements");
for (int i = 0; i < 3; i++)
{
- assertEquals("Wrong value", res[i], testValue[i]);
+ assertEquals( res[i], testValue[i],"Wrong value");
}
assertEquals(res[3], "xxx");
// should append at the end.
- assertEquals("Wrong element returned", testValue[0], parser.getString("foo"));
+ assertEquals( testValue[0], parser.getString("foo"),"Wrong element returned");
}
@Test
public void testRemove()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
String testValue = "the quick brown fox";
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong string value", testValue, parser.getString("foo"));
+ assertEquals( testValue, parser.getString("foo"),"Wrong string value");
assertNotNull(parser.remove("foo"));
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
assertNull(parser.getString("foo"));
@@ -1129,32 +1126,32 @@ public class BaseValueParserTest extends
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
String testValue = "the quick brown fox";
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong string value", testValue, parser.getString("foo"));
+ assertEquals( testValue, parser.getString("foo"),"Wrong string value");
String [] res = parser.getStrings("foo");
- assertEquals("Wrong number of elements", 2, res.length);
+ assertEquals( 2, res.length,"Wrong number of elements");
for (int i = 0; i < res.length; i++)
{
- assertEquals("Wrong value", res[i], testValue);
+ assertEquals( res[i], testValue,"Wrong value");
}
parser.remove("foo");
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
assertNull(parser.getString("foo"));
}
@@ -1192,17 +1189,17 @@ public class BaseValueParserTest extends
parser.add("e3", 200);
parser.add("e4", -2.5);
- assertEquals("Value is not true", Boolean.TRUE, parser.getBooleanObject("t1"));
- assertEquals("Value is not true", Boolean.TRUE, parser.getBooleanObject("t2"));
- assertEquals("Value is not true", Boolean.TRUE, parser.getBooleanObject("t3"));
- assertEquals("Value is not true", Boolean.TRUE, parser.getBooleanObject("t4"));
- assertEquals("Value is not true", Boolean.TRUE, parser.getBooleanObject("t5"));
-
- assertEquals("Value is not false", Boolean.FALSE, parser.getBooleanObject("f1"));
- assertEquals("Value is not false", Boolean.FALSE, parser.getBooleanObject("f2"));
- assertEquals("Value is not false", Boolean.FALSE, parser.getBooleanObject("f3"));
- assertEquals("Value is not false", Boolean.FALSE, parser.getBooleanObject("f4"));
- assertEquals("Value is not false", Boolean.FALSE, parser.getBooleanObject("f5"));
+ assertEquals( Boolean.TRUE, parser.getBooleanObject("t1"),"Value is not true");
+ assertEquals( Boolean.TRUE, parser.getBooleanObject("t2"),"Value is not true");
+ assertEquals( Boolean.TRUE, parser.getBooleanObject("t3"),"Value is not true");
+ assertEquals( Boolean.TRUE, parser.getBooleanObject("t4"),"Value is not true");
+ assertEquals( Boolean.TRUE, parser.getBooleanObject("t5"),"Value is not true");
+
+ assertEquals( Boolean.FALSE, parser.getBooleanObject("f1"),"Value is not false");
+ assertEquals( Boolean.FALSE, parser.getBooleanObject("f2"),"Value is not false");
+ assertEquals( Boolean.FALSE, parser.getBooleanObject("f3"),"Value is not false");
+ assertEquals( Boolean.FALSE, parser.getBooleanObject("f4"),"Value is not false");
+ assertEquals( Boolean.FALSE, parser.getBooleanObject("f5"),"Value is not false");
assertNull(parser.getBooleanObject("e1"));
assertNull(parser.getBooleanObject("e2"));
@@ -1238,15 +1235,15 @@ public class BaseValueParserTest extends
parser.add("t1", "true");
parser.add("f1", "false");
- assertEquals("Value is not true", Boolean.TRUE, parser.getBooleanObject("t1"));
- assertEquals("Value is not false", Boolean.FALSE, parser.getBooleanObject("f1"));
+ assertEquals( Boolean.TRUE, parser.getBooleanObject("t1"),"Value is not true");
+ assertEquals( Boolean.FALSE, parser.getBooleanObject("f1"),"Value is not false");
assertNull(parser.getBooleanObject("does not exist"));
- assertEquals("Value is not true", Boolean.TRUE, parser.getBooleanObject("t1", Boolean.FALSE));
- assertEquals("Value is not true", Boolean.TRUE, parser.getBooleanObject("t1", null));
- assertEquals("Value is not false", Boolean.FALSE, parser.getBooleanObject("f1", Boolean.TRUE));
- assertEquals("Value is not false", Boolean.FALSE, parser.getBooleanObject("f1", null));
+ assertEquals( Boolean.TRUE, parser.getBooleanObject("t1", Boolean.FALSE),"Value is not true");
+ assertEquals( Boolean.TRUE, parser.getBooleanObject("t1", null),"Value is not true");
+ assertEquals( Boolean.FALSE, parser.getBooleanObject("f1", Boolean.TRUE),"Value is not false");
+ assertEquals( Boolean.FALSE, parser.getBooleanObject("f1", null),"Value is not false");
assertNull(parser.getBooleanObject("does not exist", null));
}
@@ -1255,7 +1252,7 @@ public class BaseValueParserTest extends
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
double [] testValue = {
1.0, 2.0, 3.0
@@ -1266,64 +1263,64 @@ public class BaseValueParserTest extends
parser.add("foo", testValue[i]);
String [] res = parser.getStrings("foo");
- assertEquals("Wrong number of elements", res.length, i + 1);
+ assertEquals( res.length, i + 1,"Wrong number of elements");
}
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
double [] res = parser.getDoubles("foo");
- assertEquals("Wrong number of elements", 3, res.length);
+ assertEquals( 3, res.length,"Wrong number of elements");
for (int i = 0; i < res.length; i++)
{
- assertEquals("Wrong value", res[i], testValue[i], 0.001);
+ assertEquals( res[i], testValue[i], 0.001,"Wrong value");
}
Double [] resObj = parser.getDoubleObjects("foo");
- assertEquals("Wrong number of elements", 3, resObj.length);
+ assertEquals( 3, resObj.length,"Wrong number of elements");
for (int i = 0; i < resObj.length; i++)
{
- assertEquals("Wrong value", resObj[i].doubleValue(), testValue[i], 0.001);
+ assertEquals( resObj[i].doubleValue(), testValue[i], 0.001,"Wrong value");
}
- assertEquals("Wrong element returned", testValue[0], parser.getDoubleObject("foo").doubleValue(), 0.001);
+ assertEquals( testValue[0], parser.getDoubleObject("foo").doubleValue(), 0.001,"Wrong element returned");
parser.add("foo", 4.0);
res = parser.getDoubles("foo");
- assertEquals("Wrong number of elements", 4, res.length);
+ assertEquals( 4, res.length,"Wrong number of elements");
for (int i = 0; i < 3; i++)
{
- assertEquals("Wrong value", res[i], testValue[i], 0.001);
+ assertEquals( res[i], testValue[i], 0.001,"Wrong value");
}
assertEquals(res[3], 4.0, 0.001);
resObj = parser.getDoubleObjects("foo");
- assertEquals("Wrong number of elements", 4, resObj.length);
+ assertEquals( 4, resObj.length,"Wrong number of elements");
for (int i = 0; i < 3; i++)
{
- assertEquals("Wrong value", resObj[i].doubleValue(), testValue[i], 0.001);
+ assertEquals( resObj[i].doubleValue(), testValue[i], 0.001,"Wrong value");
}
assertEquals(resObj[3].doubleValue(), 4.0, 0.001);
// should append at the end.
- assertEquals("Wrong element returned", testValue[0], parser.getDouble("foo"), 0.001);
+ assertEquals( testValue[0], parser.getDouble("foo"), 0.001,"Wrong element returned");
}
@Test
public void testFloatArray()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
float [] testValue = {
1.0f, 2.0f, 3.0f
@@ -1334,64 +1331,64 @@ public class BaseValueParserTest extends
parser.add("foo", testValue[i]);
String [] res = parser.getStrings("foo");
- assertEquals("Wrong number of elements", res.length, i + 1);
+ assertEquals( res.length, i + 1,"Wrong number of elements");
}
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
float [] res = parser.getFloats("foo");
- assertEquals("Wrong number of elements", 3, res.length);
+ assertEquals( 3, res.length,"Wrong number of elements");
for (int i = 0; i < res.length; i++)
{
- assertEquals("Wrong value", res[i], testValue[i], 0.001f);
+ assertEquals( res[i], testValue[i], 0.001f,"Wrong value");
}
Float [] resObj = parser.getFloatObjects("foo");
- assertEquals("Wrong number of elements", 3, resObj.length);
+ assertEquals( 3, resObj.length,"Wrong number of elements");
for (int i = 0; i < resObj.length; i++)
{
- assertEquals("Wrong value", resObj[i].floatValue(), testValue[i], 0.001f);
+ assertEquals( resObj[i].floatValue(), testValue[i], 0.001f,"Wrong value");
}
- assertEquals("Wrong element returned", testValue[0], parser.getFloatObject("foo").floatValue(), 0.001f);
+ assertEquals( testValue[0], parser.getFloatObject("foo").floatValue(), 0.001f,"Wrong element returned");
parser.add("foo", 4.0f);
res = parser.getFloats("foo");
- assertEquals("Wrong number of elements", 4, res.length);
+ assertEquals( 4, res.length,"Wrong number of elements");
for (int i = 0; i < 3; i++)
{
- assertEquals("Wrong value", res[i], testValue[i], 0.001f);
+ assertEquals( res[i], testValue[i], 0.001f,"Wrong value");
}
assertEquals(res[3], 4.0f, 0.001f);
resObj = parser.getFloatObjects("foo");
- assertEquals("Wrong number of elements", 4, resObj.length);
+ assertEquals( 4, resObj.length,"Wrong number of elements");
for (int i = 0; i < 3; i++)
{
- assertEquals("Wrong value", resObj[i].floatValue(), testValue[i], 0.001f);
+ assertEquals( resObj[i].floatValue(), testValue[i], 0.001f,"Wrong value");
}
assertEquals(resObj[3].floatValue(), 4.0f, 0.001f);
// should append at the end.
- assertEquals("Wrong element returned", testValue[0], parser.getFloat("foo"), 0.001f);
+ assertEquals( testValue[0], parser.getFloat("foo"), 0.001f,"Wrong element returned");
}
@Test
public void testBigDecimalArray()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
long [] testValue = {
12345678,87654321,1092837465,
@@ -1402,44 +1399,44 @@ public class BaseValueParserTest extends
parser.add("foo", testValue[i]);
String [] res = parser.getStrings("foo");
- assertEquals("Wrong number of elements", res.length, i + 1);
+ assertEquals( res.length, i + 1,"Wrong number of elements");
}
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
BigDecimal [] res = parser.getBigDecimals("foo");
- assertEquals("Wrong number of elements", 3, res.length);
+ assertEquals( 3, res.length,"Wrong number of elements");
for (int i = 0; i < res.length; i++)
{
- assertEquals("Wrong value", res[i].longValue(), testValue[i]);
+ assertEquals( res[i].longValue(), testValue[i],"Wrong value");
}
- assertEquals("Wrong element returned", testValue[0], parser.getBigDecimal("foo").longValue());
+ assertEquals( testValue[0], parser.getBigDecimal("foo").longValue(),"Wrong element returned");
parser.add("foo", 77777777);
res = parser.getBigDecimals("foo");
- assertEquals("Wrong number of elements", 4, res.length);
+ assertEquals( 4, res.length,"Wrong number of elements");
for (int i = 0; i < 3; i++)
{
- assertEquals("Wrong value", res[i].longValue(), testValue[i], 0.001);
+ assertEquals( res[i].longValue(), testValue[i], 0.001,"Wrong value");
}
assertEquals(res[3].longValue(), 77777777);
// should append at the end.
- assertEquals("Wrong element returned", testValue[0], parser.getBigDecimal("foo").longValue());
+ assertEquals( testValue[0], parser.getBigDecimal("foo").longValue(),"Wrong element returned");
}
@Test
public void testIntegerArray()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
int [] testValue = {
1, 2, 3
@@ -1450,64 +1447,64 @@ public class BaseValueParserTest extends
parser.add("foo", testValue[i]);
String [] res = parser.getStrings("foo");
- assertEquals("Wrong number of elements", res.length, i + 1);
+ assertEquals( res.length, i + 1,"Wrong number of elements");
}
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
int [] res = parser.getInts("foo");
- assertEquals("Wrong number of elements", 3, res.length);
+ assertEquals( 3, res.length,"Wrong number of elements");
for (int i = 0; i < res.length; i++)
{
- assertEquals("Wrong value", res[i], testValue[i]);
+ assertEquals( res[i], testValue[i],"Wrong value");
}
Integer [] resObj = parser.getIntObjects("foo");
- assertEquals("Wrong number of elements", 3, resObj.length);
+ assertEquals( 3, resObj.length,"Wrong number of elements");
for (int i = 0; i < resObj.length; i++)
{
- assertEquals("Wrong value", resObj[i].intValue(), testValue[i]);
+ assertEquals( resObj[i].intValue(), testValue[i],"Wrong value");
}
- assertEquals("Wrong element returned", testValue[0], parser.getIntObject("foo").intValue());
+ assertEquals( testValue[0], parser.getIntObject("foo").intValue(),"Wrong element returned");
parser.add("foo", 4);
res = parser.getInts("foo");
- assertEquals("Wrong number of elements", 4, res.length);
+ assertEquals( 4, res.length,"Wrong number of elements");
for (int i = 0; i < 3; i++)
{
- assertEquals("Wrong value", res[i], testValue[i]);
+ assertEquals( res[i], testValue[i],"Wrong value");
}
assertEquals(res[3], 4);
resObj = parser.getIntObjects("foo");
- assertEquals("Wrong number of elements", 4, resObj.length);
+ assertEquals( 4, resObj.length,"Wrong number of elements");
for (int i = 0; i < 3; i++)
{
- assertEquals("Wrong value", resObj[i].intValue(), testValue[i]);
+ assertEquals( resObj[i].intValue(), testValue[i],"Wrong value");
}
assertEquals(resObj[3].intValue(), 4);
// should append at the end.
- assertEquals("Wrong element returned", testValue[0], parser.getInt("foo"));
+ assertEquals( testValue[0], parser.getInt("foo"),"Wrong element returned");
}
@Test
public void testLongArray()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
long [] testValue = {
1l, 2l, 3l
@@ -1518,57 +1515,57 @@ public class BaseValueParserTest extends
parser.add("foo", testValue[i]);
String [] res = parser.getStrings("foo");
- assertEquals("Wrong number of elements", res.length, i + 1);
+ assertEquals( res.length, i + 1,"Wrong number of elements");
}
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
long [] res = parser.getLongs("foo");
- assertEquals("Wrong number of elements", 3, res.length);
+ assertEquals( 3, res.length,"Wrong number of elements");
for (int i = 0; i < res.length; i++)
{
- assertEquals("Wrong value", res[i], testValue[i]);
+ assertEquals( res[i], testValue[i],"Wrong value");
}
Long [] resObj = parser.getLongObjects("foo");
- assertEquals("Wrong number of elements", 3, resObj.length);
+ assertEquals( 3, resObj.length,"Wrong number of elements");
for (int i = 0; i < resObj.length; i++)
{
- assertEquals("Wrong value", resObj[i].longValue(), testValue[i]);
+ assertEquals( resObj[i].longValue(), testValue[i],"Wrong value");
}
- assertEquals("Wrong element returned", testValue[0], parser.getLongObject("foo").longValue());
+ assertEquals( testValue[0], parser.getLongObject("foo").longValue(),"Wrong element returned");
parser.add("foo", 4);
res = parser.getLongs("foo");
- assertEquals("Wrong number of elements", 4, res.length);
+ assertEquals( 4, res.length,"Wrong number of elements");
for (int i = 0; i < 3; i++)
{
- assertEquals("Wrong value", res[i], testValue[i]);
+ assertEquals( res[i], testValue[i],"Wrong value");
}
assertEquals(res[3], 4);
resObj = parser.getLongObjects("foo");
- assertEquals("Wrong number of elements", 4, resObj.length);
+ assertEquals( 4, resObj.length,"Wrong number of elements");
for (int i = 0; i < 3; i++)
{
- assertEquals("Wrong value", resObj[i].longValue(), testValue[i]);
+ assertEquals( resObj[i].longValue(), testValue[i],"Wrong value");
}
assertEquals(resObj[3].longValue(), 4);
// should append at the end.
- assertEquals("Wrong element returned", testValue[0], parser.getLong("foo"));
+ assertEquals( testValue[0], parser.getLong("foo"),"Wrong element returned");
}
@Test
public void testByteArray()
@@ -1576,23 +1573,23 @@ public class BaseValueParserTest extends
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
String testValue = "abcdefg";
parser.add("foo", testValue);
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(),"Wrong number of keys");
byte [] res = parser.getBytes("foo");
- assertEquals("Wrong number of elements", 7, res.length);
+ assertEquals( 7, res.length,"Wrong number of elements");
for (int i = 0; i < res.length; i++)
{
byte [] testByte = testValue.substring(i, i + 1).getBytes(parser.getCharacterEncoding());
- assertEquals("More than one byte for a char!", 1, testByte.length);
- assertEquals("Wrong value", res[i], testByte[0]);
+ assertEquals( 1, testByte.length,"More than one byte for a char!");
+ assertEquals( res[i], testByte[0],"Wrong value");
}
}
@Test
@@ -1600,7 +1597,7 @@ public class BaseValueParserTest extends
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
String [] testValue = {
"0", "127", "-1",
@@ -1613,21 +1610,21 @@ public class BaseValueParserTest extends
parser.add("foo" + i, testValue[i]);
}
- assertEquals("Wrong number of keys", 6, parser.keySet().size());
+ assertEquals( 6, parser.keySet().size(),"Wrong number of keys");
- assertEquals("Wrong value", (byte) 0, parser.getByte("foo0"));
- assertEquals("Wrong value", (byte) 127, parser.getByte("foo1"));
- assertEquals("Wrong value", (byte) -1, parser.getByte("foo2"));
- assertEquals("Wrong value", (byte) 0, parser.getByte("foo3"));
- assertEquals("Wrong value", (byte) -127, parser.getByte("foo4"));
- assertEquals("Wrong value", (byte) 100, parser.getByte("foo5"));
-
- assertEquals("Wrong value", new Byte((byte) 0), parser.getByteObject("foo0"));
- assertEquals("Wrong value", new Byte((byte) 127), parser.getByteObject("foo1"));
- assertEquals("Wrong value", new Byte((byte) -1), parser.getByteObject("foo2"));
- assertEquals("Wrong value", new Byte((byte) 0), parser.getByteObject("foo3"));
- assertEquals("Wrong value", new Byte((byte) -127), parser.getByteObject("foo4"));
- assertEquals("Wrong value", new Byte((byte) 100), parser.getByteObject("foo5"));
+ assertEquals( (byte) 0, parser.getByte("foo0"),"Wrong value");
+ assertEquals( (byte) 127, parser.getByte("foo1"),"Wrong value");
+ assertEquals( (byte) -1, parser.getByte("foo2"),"Wrong value");
+ assertEquals( (byte) 0, parser.getByte("foo3"),"Wrong value");
+ assertEquals( (byte) -127, parser.getByte("foo4"),"Wrong value");
+ assertEquals( (byte) 100, parser.getByte("foo5"),"Wrong value");
+
+ assertEquals( new Byte((byte) 0), parser.getByteObject("foo0"),"Wrong value");
+ assertEquals( new Byte((byte) 127), parser.getByteObject("foo1"),"Wrong value");
+ assertEquals( new Byte((byte) -1), parser.getByteObject("foo2"),"Wrong value");
+ assertEquals( new Byte((byte) 0), parser.getByteObject("foo3"),"Wrong value");
+ assertEquals( new Byte((byte) -127), parser.getByteObject("foo4"),"Wrong value");
+ assertEquals( new Byte((byte) 100), parser.getByteObject("foo5"),"Wrong value");
}
@Test
@@ -1635,14 +1632,14 @@ public class BaseValueParserTest extends
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(),"Wrong number of keys");
parser.add("foo", "bar");
- assertEquals("Wrong value found", "bar", parser.getString("foo", "xxx"));
- assertEquals("Wrong value found", "bar", parser.getString("foo", null));
+ assertEquals( "bar", parser.getString("foo", "xxx"),"Wrong value found");
+ assertEquals( "bar", parser.getString("foo", null),"Wrong value found");
- assertEquals("Wrong value found", "baz", parser.getString("does-not-exist", "baz"));
+ assertEquals( "baz", parser.getString("does-not-exist", "baz"),"Wrong value found");
assertNull(parser.getString("does-not-exist", null));
}
@Test
@@ -1650,69 +1647,69 @@ public class BaseValueParserTest extends
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
parser.add("foo", "bar");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
parser.add("bar", "foo");
- assertEquals("Wrong number of keys", 2, parser.keySet().size());
+ assertEquals( 2, parser.keySet().size(), "Wrong number of keys");
parser.add("bar", "baz");
- assertEquals("Wrong number of keys", 2, parser.keySet().size());
+ assertEquals( 2, parser.keySet().size(), "Wrong number of keys");
String [] res = parser.getStrings("bar");
- assertEquals("Wrong number of values", 2, res.length);
- assertEquals("Wrong value found", "foo", res[0]);
- assertEquals("Wrong value found", "baz", res[1]);
+ assertEquals( 2, res.length, "Wrong number of values");
+ assertEquals( "foo", res[0], "Wrong value found");
+ assertEquals( "baz", res[1], "Wrong value found");
parser.setString("bar", "xxx");
- assertEquals("Wrong number of keys", 2, parser.keySet().size());
+ assertEquals( 2, parser.keySet().size(), "Wrong number of keys");
res = parser.getStrings("bar");
- assertEquals("Wrong number of values", 1, res.length);
- assertEquals("Wrong value found", "xxx", res[0]);
+ assertEquals( 1, res.length, "Wrong number of values");
+ assertEquals( "xxx", res[0], "Wrong value found");
}
@Test
public void testSetStrings()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
parser.add("foo", "bar");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
parser.add("bar", "foo");
- assertEquals("Wrong number of keys", 2, parser.keySet().size());
+ assertEquals( 2, parser.keySet().size(), "Wrong number of keys");
parser.add("bar", "baz");
- assertEquals("Wrong number of keys", 2, parser.keySet().size());
+ assertEquals( 2, parser.keySet().size(), "Wrong number of keys");
String [] res = parser.getStrings("bar");
- assertEquals("Wrong number of values", 2, res.length);
- assertEquals("Wrong value found", "foo", res[0]);
- assertEquals("Wrong value found", "baz", res[1]);
+ assertEquals( 2, res.length, "Wrong number of values");
+ assertEquals( "foo", res[0], "Wrong value found");
+ assertEquals( "baz", res[1], "Wrong value found");
String [] newValues = new String [] { "aaa", "bbb", "ccc", "ddd" };
parser.setStrings("bar", newValues);
- assertEquals("Wrong number of keys", 2, parser.keySet().size());
+ assertEquals( 2, parser.keySet().size(),"Wrong number of keys");
res = parser.getStrings("bar");
- assertEquals("Wrong number of values", newValues.length, res.length);
+ assertEquals( newValues.length, res.length,"Wrong number of values");
for (int i = 0 ; i < newValues.length; i++)
{
- assertEquals("Wrong value found", newValues[i], res[i]);
+ assertEquals( newValues[i], res[i],"Wrong value found");
}
}
@Test
@@ -1732,31 +1729,31 @@ public class BaseValueParserTest extends
parser.setProperties(bp);
- assertEquals("Wrong value in bean", "abcdef", bp.getDoNotTouchValue());
- assertEquals("Wrong value in bean", "foobar", bp.getStringValue());
- assertEquals("Wrong value in bean", 200, bp.getIntValue());
- assertEquals("Wrong value in bean", 2.0, bp.getDoubleValue(), 0.001);
- assertEquals("Wrong value in bean", 12345l, bp.getLongValue());
- assertEquals("Wrong value in bean", Boolean.TRUE, bp.getBooleanValue());
+ assertEquals( "abcdef", bp.getDoNotTouchValue(), "Wrong value in bean");
+ assertEquals( "foobar", bp.getStringValue(), "Wrong value in bean");
+ assertEquals( 200, bp.getIntValue(), "Wrong value in bean");
+ assertEquals( 2.0, bp.getDoubleValue(), 0.001, "Wrong value in bean");
+ assertEquals( 12345l, bp.getLongValue(), "Wrong value in bean");
+ assertEquals( Boolean.TRUE, bp.getBooleanValue(), "Wrong value in bean");
}
public void testAddNulls()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
parser.add("foo", (Integer) null);
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
parser.add("foo", (String) null);
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
parser.add("bar", "null");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
}
@Test
@@ -1766,90 +1763,90 @@ public class BaseValueParserTest extends
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
parser.add("foo", new String [] { "foo", "bar" });
res = parser.getStrings("foo");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
- assertEquals("Wrong number of values", 2, res.length);
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
+ assertEquals( 2, res.length,"Wrong number of values");
// null value should not change contents
parser.add("foo", (String) null);
res = parser.getStrings("foo");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
- assertEquals("Wrong number of values", 2, res.length);
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
+ assertEquals( 2, res.length,"Wrong number of values");
// null value should not change contents
parser.add("foo", (String []) null);
res = parser.getStrings("foo");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
- assertEquals("Wrong number of values", 2, res.length);
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
+ assertEquals( 2, res.length,"Wrong number of values");
// empty String array should not change contents
parser.add("foo", new String [0]);
res = parser.getStrings("foo");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
- assertEquals("Wrong number of values", 2, res.length);
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
+ assertEquals( 2, res.length, "Wrong number of values");
// String array with null value should not change contents
parser.add("foo", new String [] { null });
res = parser.getStrings("foo");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
- assertEquals("Wrong number of values", 2, res.length);
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
+ assertEquals( 2, res.length, "Wrong number of values");
// String array with null value should only add non-null values
parser.add("foo", new String [] { "bla", null, "foo" });
res = parser.getStrings("foo");
- assertEquals("Wrong number of keys", 1, parser.keySet().size());
- assertEquals("Wrong number of values", 4, res.length);
+ assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
+ assertEquals( 4, res.length, "Wrong number of values");
}
@Test
public void testNonExistingResults()
{
parser.clear();
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
- assertEquals("Wrong value for non existing key", 0.0, parser.getDouble("foo"), 0.001);
+ assertEquals( 0.0, parser.getDouble("foo"), 0.001, "Wrong value for non existing key");
assertNull(parser.getDoubles("foo"));
assertNull(parser.getDoubleObject("foo"));
assertNull(parser.getDoubleObjects("foo"));
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
assertNull(parser.getString("foo"));
assertNull(parser.getStrings("foo"));
- assertEquals("Wrong value for non existing key", 0.0f, parser.getFloat("foo"), 0.001);
+ assertEquals( 0.0f, parser.getFloat("foo"), 0.001, "Wrong value for non existing key");
assertNull(parser.getFloats("foo"));
assertNull(parser.getFloatObject("foo"));
assertNull(parser.getFloatObjects("foo"));
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
assertNull(parser.getBigDecimal("foo"));
assertNull(parser.getBigDecimals("foo"));
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
- assertEquals("Wrong value for non existing key", 0, parser.getInt("foo"));
+ assertEquals( 0, parser.getInt("foo"), "Wrong value for non existing key");
assertNull(parser.getInts("foo"));
assertNull(parser.getIntObject("foo"));
assertNull(parser.getIntObjects("foo"));
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
- assertEquals("Wrong value for non existing key", 0, parser.getLong("foo"));
+ assertEquals( 0, parser.getLong("foo"), "Wrong value for non existing key");
assertNull(parser.getLongs("foo"));
assertNull(parser.getLongObject("foo"));
assertNull(parser.getLongObjects("foo"));
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
- assertEquals("Wrong value for non existing key", 0, parser.getByte("foo"));
+ assertEquals( 0, parser.getByte("foo"), "Wrong value for non existing key");
assertNull(parser.getByteObject("foo"));
- assertEquals("Wrong number of keys", 0, parser.keySet().size());
+ assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
}
@Test
Modified: turbine/fulcrum/trunk/parser/src/test/org/apache/fulcrum/parser/ParameterParserTest.java
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/parser/src/test/org/apache/fulcrum/parser/ParameterParserTest.java?rev=1848852&r1=1848851&r2=1848852&view=diff
==============================================================================
--- turbine/fulcrum/trunk/parser/src/test/org/apache/fulcrum/parser/ParameterParserTest.java (original)
+++ turbine/fulcrum/trunk/parser/src/test/org/apache/fulcrum/parser/ParameterParserTest.java Thu Dec 13 14:54:04 2018
@@ -19,12 +19,6 @@ package org.apache.fulcrum.parser;
* under the License.
*/
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
@@ -34,22 +28,26 @@ import javax.servlet.http.Part;
import org.apache.avalon.framework.component.ComponentException;
import org.apache.fulcrum.parser.ValueParser.URLCaseFolding;
-import org.apache.fulcrum.testcontainer.BaseUnit4Test;
-import org.junit.Before;
-import org.junit.Test;
+import org.apache.fulcrum.testcontainer.BaseUnit5Test;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
/**
* Basic test that ParameterParser instantiates.
*
* @author <a href="epugh@opensourceconnections.com">Eric Pugh</a>
* @version $Id$
*/
-public class ParameterParserTest extends BaseUnit4Test
+public class ParameterParserTest extends BaseUnit5Test
{
private ParameterParser parameterParser = null;
private Part mockTest;
- @Before
+ @BeforeEach
public void setUpBefore() throws Exception
{
try
@@ -145,9 +143,9 @@ public class ParameterParserTest extends
@Test
public void testRepositoryExists() throws Exception
{
- assertEquals("TRIMMED_and_Not_Modified",parameterParser.convertAndTrim(" TRIMMED_and_Not_Modified ", URLCaseFolding.NONE));
- assertEquals("trimmed_and_lower_case",parameterParser.convertAndTrim(" TRIMMED_and_Lower_Case ", URLCaseFolding.LOWER));
- assertEquals("TRIMMED_AND_UPPER_CASE",parameterParser.convertAndTrim(" TRIMMED_and_Upper_Case ", URLCaseFolding.UPPER));
+ assertEquals(parameterParser.convertAndTrim(" TRIMMED_and_Not_Modified ", URLCaseFolding.NONE),"TRIMMED_and_Not_Modified");
+ assertEquals(parameterParser.convertAndTrim(" TRIMMED_and_Lower_Case ", URLCaseFolding.LOWER),"trimmed_and_lower_case");
+ assertEquals(parameterParser.convertAndTrim(" TRIMMED_and_Upper_Case ", URLCaseFolding.UPPER),"TRIMMED_AND_UPPER_CASE");
}
/**
@@ -160,36 +158,36 @@ public class ParameterParserTest extends
@Test
public void testAddPathInfo() throws Exception
{
- assertEquals("keySet() is not empty!", 0, parameterParser.keySet().size());
+ assertEquals(0, parameterParser.keySet().size(), "keySet() is not empty!");
// Push this into the parser using DefaultParameterParser's add() method.
((DefaultParameterParser) parameterParser).add("upload-field", mockTest);
- assertEquals("Part not found in keySet()!", 1, parameterParser.keySet().size());
+ assertEquals(1, parameterParser.keySet().size(), "Part not found in keySet()!");
Iterator<String> it = parameterParser.keySet().iterator();
assertTrue(it.hasNext());
String name = it.next();
- assertEquals("Wrong name found", "upload-field", name);
+ assertEquals( "upload-field", name,"Wrong name found");
assertFalse(it.hasNext());
parameterParser.add("other-field", "foo");
- assertEquals("Wrong number of fields found ", 2, parameterParser.getKeys().length);
+ assertEquals( 2, parameterParser.getKeys().length, "Wrong number of fields found ");
assertTrue(parameterParser.containsKey("upload-field"));
assertTrue(parameterParser.containsKey("other-field"));
// The following will actually cause a ClassCastException because getStrings() (and others) are not catering for Parts.
- assertNull("The returned should be null because a Part is not a String", parameterParser.getStrings("upload-field"));
+ assertNull(parameterParser.getStrings("upload-field"), "The returned should be null because a Part is not a String");
assertFalse(parameterParser.containsKey("missing-field"));
// The following will actually cause a ClassCastException because getPart() (and others) are not catering for Non-Parts, e.g String.
- assertNull("The returned should be null because a String is not a Part", parameterParser.getPart( "other-field" ));
+ assertNull(parameterParser.getPart( "other-field" ), "The returned should be null because a String is not a Part");
Part uploadField = parameterParser.getPart( "upload-field" );
- assertTrue(uploadField.getName().equals( "upload-field" ));
+ assertEquals("upload-field", uploadField.getName());
}
@@ -201,7 +199,7 @@ public class ParameterParserTest extends
@Test
public void testFilename4Path() throws Exception
{
- assertEquals("keySet() is not empty!", 0, parameterParser.keySet().size());
+ assertEquals(0, parameterParser.keySet().size(), "keySet() is not empty!");
// Push this into the parser using DefaultParameterParser's add() method.
((DefaultParameterParser) parameterParser).add("upload-field", mockTest);
Modified: turbine/fulcrum/trunk/parser/src/test/org/apache/fulcrum/parser/ParserServiceTest.java
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/parser/src/test/org/apache/fulcrum/parser/ParserServiceTest.java?rev=1848852&r1=1848851&r2=1848852&view=diff
==============================================================================
--- turbine/fulcrum/trunk/parser/src/test/org/apache/fulcrum/parser/ParserServiceTest.java (original)
+++ turbine/fulcrum/trunk/parser/src/test/org/apache/fulcrum/parser/ParserServiceTest.java Thu Dec 13 14:54:04 2018
@@ -1,5 +1,10 @@
package org.apache.fulcrum.parser;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
@@ -19,53 +24,35 @@ package org.apache.fulcrum.parser;
* under the License.
*/
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Collection;
-import java.util.HashMap;
import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Vector;
-import javax.servlet.ReadListener;
-import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpSession;
import javax.servlet.http.Part;
import org.apache.avalon.framework.component.ComponentException;
-import org.apache.fulcrum.testcontainer.BaseUnit4Test;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
+import org.apache.fulcrum.testcontainer.BaseUnit5Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Basic test that ParameterParser instantiates.
*
* @author <a href="epugh@opensourceconnections.com">Eric Pugh</a>
* @version $Id: ParameterParserTest.java 1837188 2018-07-31 22:23:27Z tv $
*/
-public class ParserServiceTest extends BaseUnit4Test
+public class ParserServiceTest extends BaseUnit5Test
{
private ParserService parserService;
private ParameterParser parameterParser = null;
private Part test;
- @Before
+ @BeforeEach
public void setUpBefore() throws Exception
{
try
Modified: turbine/fulcrum/trunk/pom.xml
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/pom.xml?rev=1848852&r1=1848851&r2=1848852&view=diff
==============================================================================
--- turbine/fulcrum/trunk/pom.xml (original)
+++ turbine/fulcrum/trunk/pom.xml Thu Dec 13 14:54:04 2018
@@ -22,7 +22,7 @@
<parent>
<artifactId>turbine-parent</artifactId>
<groupId>org.apache.turbine</groupId>
- <version>5</version>
+ <version>6-SNAPSHOT</version>
</parent>
<artifactId>fulcrum</artifactId>
<packaging>pom</packaging>
Modified: turbine/fulcrum/trunk/template/pom.xml
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/template/pom.xml?rev=1848852&r1=1848851&r2=1848852&view=diff
==============================================================================
--- turbine/fulcrum/trunk/template/pom.xml (original)
+++ turbine/fulcrum/trunk/template/pom.xml Thu Dec 13 14:54:04 2018
@@ -35,14 +35,15 @@
<developerConnection>scm:svn:https://svn.apache.org/repos/asf/turbine/fulcrum/trunk/template/</developerConnection>
<url>http://svn.apache.org/viewvc/turbine/fulcrum/trunk/template/</url>
</scm>
-
- <distributionManagement>
+
+ <distributionManagement>
<site>
- <id>apache.website</id>
- <name>Fulcrum Website</name>
- <url>${fulcrum.deployment.protocol}://people.apache.org/www/turbine.apache.org/fulcrum/fulcrum-template/</url>
- </site>
- </distributionManagement>
+ <id>turbine.apache.org</id>
+ <name>Fulcrum Template Website</name>
+ <url>http://turbine.apache.org/fulcrum/fulcrum-template/</url>
+ </site>
+ </distributionManagement>
+
<dependencies>
<dependency>
@@ -60,11 +61,11 @@
<artifactId>commons-email</artifactId>
<version>1.2</version>
</dependency>
- <dependency>
- <groupId>commons-lang</groupId>
- <artifactId>commons-lang</artifactId>
- <version>2.5</version>
- </dependency>
+ <dependency>
+ <groupId>org.apache.commons</groupId>
+ <artifactId>commons-lang3</artifactId>
+ <version>3.8.1</version>
+ </dependency>
<dependency>
<groupId>org.apache.fulcrum</groupId>
<artifactId>fulcrum-yaafi</artifactId>
Modified: turbine/fulcrum/trunk/template/xdocs/index.xml
URL: http://svn.apache.org/viewvc/turbine/fulcrum/trunk/template/xdocs/index.xml?rev=1848852&r1=1848851&r2=1848852&view=diff
==============================================================================
--- turbine/fulcrum/trunk/template/xdocs/index.xml (original)
+++ turbine/fulcrum/trunk/template/xdocs/index.xml Thu Dec 13 14:54:04 2018
@@ -70,7 +70,7 @@
<source><![CDATA[
- GlobalCacheService gs = null;
+ TemplateService gs = null;
try
{
/*
@@ -78,7 +78,7 @@
* If it doesn't exist or the item is stale,
* the cache will throw an exception.
*/
- gs = (GlobalCacheService)avalonComponentService.lookup(GlobalCacheService.ROLE)
+ gs = (TemplateService)avalonComponentService.lookup(TemplateService.ROLE)
CachedObject obj = gs.getObject("cached_object");