| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF 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 |
| * |
| * https://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.apache.commons.beanutils2; |
| |
| import static org.junit.jupiter.api.Assertions.assertEquals; |
| import static org.junit.jupiter.api.Assertions.assertInstanceOf; |
| import static org.junit.jupiter.api.Assertions.assertNotNull; |
| import static org.junit.jupiter.api.Assertions.assertNull; |
| import static org.junit.jupiter.api.Assertions.assertSame; |
| import static org.junit.jupiter.api.Assertions.assertThrows; |
| |
| import java.sql.Date; |
| import java.sql.Time; |
| import java.sql.Timestamp; |
| import java.text.DateFormat; |
| import java.text.SimpleDateFormat; |
| import java.util.Locale; |
| |
| import org.apache.commons.beanutils2.converters.DateConverter; |
| import org.apache.commons.lang3.ArrayUtils; |
| import org.junit.jupiter.api.AfterEach; |
| import org.junit.jupiter.api.BeforeEach; |
| import org.junit.jupiter.api.Test; |
| |
| class ConvertUtilsTest { |
| |
| private void checkIntegerArray(final Object value, final int[] intArray) { |
| |
| assertNotNull(value, "Returned value is not null"); |
| assertEquals(intArray.getClass(), value.getClass(), "Returned value is int[]"); |
| final int[] results = (int[]) value; |
| assertEquals(intArray.length, results.length, "Returned array length"); |
| for (int i = 0; i < intArray.length; i++) { |
| assertEquals(intArray[i], results[i], "Returned array value " + i); |
| } |
| |
| } |
| |
| private void checkStringArray(final Object value, final String[] stringArray) { |
| |
| assertNotNull(value, "Returned value is not null"); |
| assertEquals(stringArray.getClass(), value.getClass(), "Returned value is String[]"); |
| final String[] results = (String[]) value; |
| assertEquals(stringArray.length, results.length, "Returned array length"); |
| for (int i = 0; i < stringArray.length; i++) { |
| assertEquals(stringArray[i], results[i], "Returned array value " + i); |
| } |
| |
| } |
| |
| /** |
| * Sets up instance variables required by this test case. |
| */ |
| @BeforeEach |
| public void setUp() { |
| BeanUtilsBean.setInstance(new BeanUtilsBean()); |
| ConvertUtils.deregister(); |
| |
| } |
| |
| /** |
| * Tear down instance variables required by this test case. |
| */ |
| @AfterEach |
| public void tearDown() { |
| // No action required |
| } |
| |
| @Test |
| @SuppressWarnings({ "rawtypes" }) |
| // We need to use raw types in order to test legacy converters |
| void testConvertToString() throws Exception { |
| final Converter dummyConverter = (type, value) -> value; |
| |
| final Converter fooConverter = (type, value) -> "Foo-Converter"; |
| |
| final DateConverter dateConverter = new DateConverter(); |
| dateConverter.setLocale(Locale.US); |
| |
| final ConvertUtilsBean utils = new ConvertUtilsBean(); |
| utils.register(dateConverter, java.util.Date.class); |
| utils.register(fooConverter, String.class); |
| |
| // Convert using registered DateConverter |
| final java.util.Date today = new java.util.Date(); |
| final DateFormat fmt = new SimpleDateFormat("M/d/yy"); /* US Short Format */ |
| final String expected = fmt.format(today); |
| assertEquals(expected, utils.convert(today, String.class), "DateConverter M/d/yy"); |
| |
| // Date converter doesn't do String conversion - use String Converter |
| utils.register(dummyConverter, java.util.Date.class); |
| assertEquals("Foo-Converter", utils.convert(today, String.class), "Date Converter doesn't do String conversion"); |
| |
| // No registered Date converter - use String Converter |
| utils.deregister(java.util.Date.class); |
| assertEquals("Foo-Converter", utils.convert(today, String.class), "No registered Date converter"); |
| |
| // String Converter doesn't do Strings!!! |
| utils.register(dummyConverter, String.class); |
| assertEquals(today.toString(), utils.convert(today, String.class), "String Converter doesn't do Strings!!!"); |
| |
| // No registered Date or String converter - use Object's toString() |
| utils.deregister(String.class); |
| assertEquals(today.toString(), utils.convert(today, String.class), "Object's toString()"); |
| |
| } |
| |
| /** |
| * Tests a conversion to an unsupported target type. |
| */ |
| @Test |
| void testConvertUnsupportedTargetType() { |
| final ConvertUtilsBean utils = new ConvertUtilsBean(); |
| final Object value = "A test value"; |
| assertSame(value, utils.convert(value, getClass()), "Got different object"); |
| } |
| |
| @Test |
| void testDeregisteringSingleConverter() throws Exception { |
| // make sure that the test work ok before anything's changed |
| final Object value = ConvertUtils.convert("true", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true, "Standard conversion failed (1)"); |
| |
| // we'll test deregister |
| ConvertUtils.deregister(Boolean.TYPE); |
| assertNull(ConvertUtils.lookup(Boolean.TYPE), "Converter should be null"); |
| |
| } |
| |
| /** |
| * Negative String to primitive integer array tests. |
| */ |
| @Test |
| void testNegativeIntegerArray() { |
| |
| Object value; |
| final int[] intArray = {}; |
| |
| value = ConvertUtils.convert((String) null, intArray.getClass()); |
| checkIntegerArray(value, intArray); |
| value = ConvertUtils.convert("a", intArray.getClass()); |
| checkIntegerArray(value, intArray); |
| value = ConvertUtils.convert("{ a }", intArray.getClass()); |
| checkIntegerArray(value, intArray); |
| value = ConvertUtils.convert("1a3", intArray.getClass()); |
| checkIntegerArray(value, intArray); |
| value = ConvertUtils.convert("{ 1a3 }", intArray.getClass()); |
| checkIntegerArray(value, intArray); |
| value = ConvertUtils.convert("0,1a3", intArray.getClass()); |
| checkIntegerArray(value, intArray); |
| value = ConvertUtils.convert("{ 0, 1a3 }", intArray.getClass()); |
| checkIntegerArray(value, intArray); |
| |
| } |
| |
| /** |
| * Negative scalar conversion tests. These rely on the standard default value conversions in ConvertUtils. |
| */ |
| @Test |
| void testNegativeScalar() { |
| |
| Object value; |
| |
| value = ConvertUtils.convert("foo", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), false); |
| |
| value = ConvertUtils.convert("foo", Boolean.class); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), false); |
| |
| value = ConvertUtils.convert("foo", Byte.TYPE); |
| assertInstanceOf(Byte.class, value); |
| assertEquals(((Byte) value).byteValue(), (byte) 0); |
| |
| value = ConvertUtils.convert("foo", Byte.class); |
| assertInstanceOf(Byte.class, value); |
| assertEquals(((Byte) value).byteValue(), (byte) 0); |
| |
| assertThrows(ConversionException.class, () -> ConvertUtils.convert("org.apache.commons.beanutils2.Undefined", Class.class)); |
| |
| value = ConvertUtils.convert("foo", Double.TYPE); |
| assertInstanceOf(Double.class, value); |
| assertEquals(((Double) value).doubleValue(), 0.0, 0.005); |
| |
| value = ConvertUtils.convert("foo", Double.class); |
| assertInstanceOf(Double.class, value); |
| assertEquals(((Double) value).doubleValue(), 0.0, 0.005); |
| |
| value = ConvertUtils.convert("foo", Float.TYPE); |
| assertInstanceOf(Float.class, value); |
| assertEquals(((Float) value).floatValue(), (float) 0.0, (float) 0.005); |
| |
| value = ConvertUtils.convert("foo", Float.class); |
| assertInstanceOf(Float.class, value); |
| assertEquals(((Float) value).floatValue(), (float) 0.0, (float) 0.005); |
| |
| value = ConvertUtils.convert("foo", Integer.TYPE); |
| assertInstanceOf(Integer.class, value); |
| assertEquals(((Integer) value).intValue(), 0); |
| |
| value = ConvertUtils.convert("foo", Integer.class); |
| assertInstanceOf(Integer.class, value); |
| assertEquals(((Integer) value).intValue(), 0); |
| |
| value = ConvertUtils.convert("foo", Byte.TYPE); |
| assertInstanceOf(Byte.class, value); |
| assertEquals(((Byte) value).byteValue(), (byte) 0); |
| |
| value = ConvertUtils.convert("foo", Long.class); |
| assertInstanceOf(Long.class, value); |
| assertEquals(((Long) value).longValue(), 0); |
| |
| value = ConvertUtils.convert("foo", Short.TYPE); |
| assertInstanceOf(Short.class, value); |
| assertEquals(((Short) value).shortValue(), (short) 0); |
| |
| value = ConvertUtils.convert("foo", Short.class); |
| assertInstanceOf(Short.class, value); |
| assertEquals(((Short) value).shortValue(), (short) 0); |
| |
| } |
| |
| /** |
| * Negative String to String array tests. |
| */ |
| @Test |
| void testNegativeStringArray() { |
| |
| Object value; |
| final String[] stringArray = {}; |
| |
| value = ConvertUtils.convert((String) null, stringArray.getClass()); |
| checkStringArray(value, stringArray); |
| |
| } |
| |
| /** |
| * Test conversion of object to string for arrays. |
| */ |
| @Test |
| void testObjectToStringArray() { |
| |
| final int[] intArray0 = {}; |
| final int[] intArray1 = { 123 }; |
| final int[] intArray2 = { 123, 456 }; |
| final String[] stringArray0 = {}; |
| final String[] stringArray1 = { "abc" }; |
| final String[] stringArray2 = { "abc", "def" }; |
| |
| assertEquals(null, ConvertUtils.convert(intArray0), "intArray0"); |
| assertEquals("123", ConvertUtils.convert(intArray1), "intArray1"); |
| assertEquals("123", ConvertUtils.convert(intArray2), "intArray2"); |
| |
| assertEquals(null, ConvertUtils.convert(stringArray0), "stringArray0"); |
| assertEquals("abc", ConvertUtils.convert(stringArray1), "stringArray1"); |
| assertEquals("abc", ConvertUtils.convert(stringArray2), "stringArray2"); |
| |
| } |
| |
| /** |
| * Test conversion of object to string for scalars. |
| */ |
| @Test |
| void testObjectToStringScalar() { |
| |
| assertEquals("false", ConvertUtils.convert(Boolean.FALSE), "Boolean->String"); |
| assertEquals("true", ConvertUtils.convert(Boolean.TRUE), "Boolean->String"); |
| assertEquals("123", ConvertUtils.convert(Byte.valueOf((byte) 123)), "Byte->String"); |
| assertEquals("a", ConvertUtils.convert(Character.valueOf('a')), "Character->String"); |
| assertEquals("123.0", ConvertUtils.convert(Double.valueOf(123.0)), "Double->String"); |
| assertEquals("123.0", ConvertUtils.convert(Float.valueOf((float) 123.0)), "Float->String"); |
| assertEquals("123", ConvertUtils.convert(Integer.valueOf(123)), "Integer->String"); |
| assertEquals("123", ConvertUtils.convert(Long.valueOf(123)), "Long->String"); |
| assertEquals("123", ConvertUtils.convert(Short.valueOf((short) 123)), "Short->String"); |
| assertEquals("abc", ConvertUtils.convert("abc"), "String->String"); |
| assertEquals(null, ConvertUtils.convert(null), "String->String null"); |
| |
| } |
| |
| /** |
| * Positive array conversion tests. |
| */ |
| @Test |
| void testPositiveArray() { |
| // check 1 |
| final String[] values1 = { "10", "20", "30" }; |
| final int[] shape = ArrayUtils.EMPTY_INT_ARRAY; |
| Object value = ConvertUtils.convert(values1, shape.getClass()); |
| assertEquals(shape.getClass(), value.getClass()); |
| final int[] results1 = (int[]) value; |
| assertEquals(10, results1[0]); |
| assertEquals(20, results1[1]); |
| assertEquals(30, results1[2]); |
| // check 2 |
| final String[] values2 = { "100", "200", "300" }; |
| value = ConvertUtils.convert(values2, shape.getClass()); |
| assertEquals(shape.getClass(), value.getClass()); |
| final int[] results2 = (int[]) value; |
| assertEquals(100, results2[0]); |
| assertEquals(200, results2[1]); |
| assertEquals(300, results2[2]); |
| // check 3 |
| value = ConvertUtils.convert(values1, Integer.TYPE); |
| assertEquals(Integer.class, value.getClass()); |
| assertEquals(Integer.valueOf(10), value); |
| } |
| |
| /** |
| * Positive String to primitive integer array tests. |
| */ |
| @Test |
| void testPositiveIntegerArray() { |
| Object value; |
| final int[] intArray = {}; |
| final int[] intArray1 = { 0 }; |
| final int[] intArray2 = { 0, 10 }; |
| |
| final Class<? extends int[]> intArrayClass = intArray.getClass(); |
| value = ConvertUtils.convert("{ }", intArrayClass); |
| checkIntegerArray(value, intArray); |
| |
| value = ConvertUtils.convert("0", intArrayClass); |
| checkIntegerArray(value, intArray1); |
| value = ConvertUtils.convert(" 0 ", intArrayClass); |
| checkIntegerArray(value, intArray1); |
| value = ConvertUtils.convert("{ 0 }", intArrayClass); |
| checkIntegerArray(value, intArray1); |
| |
| value = ConvertUtils.convert("0,10", intArrayClass); |
| checkIntegerArray(value, intArray2); |
| value = ConvertUtils.convert("0 10", intArrayClass); |
| checkIntegerArray(value, intArray2); |
| value = ConvertUtils.convert("{0,10}", intArrayClass); |
| checkIntegerArray(value, intArray2); |
| value = ConvertUtils.convert("{0 10}", intArrayClass); |
| checkIntegerArray(value, intArray2); |
| value = ConvertUtils.convert("{ 0, 10 }", intArrayClass); |
| checkIntegerArray(value, intArray2); |
| value = ConvertUtils.convert("{ 0 10 }", intArrayClass); |
| checkIntegerArray(value, intArray2); |
| } |
| |
| /** |
| * Positive scalar conversion tests. |
| */ |
| @Test |
| void testPositiveScalar() { |
| |
| Object value; |
| |
| value = ConvertUtils.convert("true", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true); |
| |
| value = ConvertUtils.convert("true", Boolean.class); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true); |
| |
| value = ConvertUtils.convert("yes", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true); |
| |
| value = ConvertUtils.convert("yes", Boolean.class); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true); |
| |
| value = ConvertUtils.convert("y", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true); |
| |
| value = ConvertUtils.convert("y", Boolean.class); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true); |
| |
| value = ConvertUtils.convert("on", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true); |
| |
| value = ConvertUtils.convert("on", Boolean.class); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true); |
| |
| value = ConvertUtils.convert("false", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), false); |
| |
| value = ConvertUtils.convert("false", Boolean.class); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), false); |
| |
| value = ConvertUtils.convert("no", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), false); |
| |
| value = ConvertUtils.convert("no", Boolean.class); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), false); |
| |
| value = ConvertUtils.convert("n", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), false); |
| |
| value = ConvertUtils.convert("n", Boolean.class); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), false); |
| |
| value = ConvertUtils.convert("off", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), false); |
| |
| value = ConvertUtils.convert("off", Boolean.class); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), false); |
| |
| value = ConvertUtils.convert("123", Byte.TYPE); |
| assertInstanceOf(Byte.class, value); |
| assertEquals(((Byte) value).byteValue(), (byte) 123); |
| |
| value = ConvertUtils.convert("123", Byte.class); |
| assertInstanceOf(Byte.class, value); |
| assertEquals(((Byte) value).byteValue(), (byte) 123); |
| |
| value = ConvertUtils.convert("a", Character.TYPE); |
| assertInstanceOf(Character.class, value); |
| assertEquals(((Character) value).charValue(), 'a'); |
| |
| value = ConvertUtils.convert("a", Character.class); |
| assertInstanceOf(Character.class, value); |
| assertEquals(((Character) value).charValue(), 'a'); |
| |
| value = ConvertUtils.convert("java.lang.String", Class.class); |
| assertInstanceOf(Class.class, value); |
| assertEquals(String.class, value); |
| |
| value = ConvertUtils.convert("123.456", Double.TYPE); |
| assertInstanceOf(Double.class, value); |
| assertEquals(((Double) value).doubleValue(), 123.456, 0.005); |
| |
| value = ConvertUtils.convert("123.456", Double.class); |
| assertInstanceOf(Double.class, value); |
| assertEquals(((Double) value).doubleValue(), 123.456, 0.005); |
| |
| value = ConvertUtils.convert("123.456", Float.TYPE); |
| assertInstanceOf(Float.class, value); |
| assertEquals(((Float) value).floatValue(), (float) 123.456, (float) 0.005); |
| |
| value = ConvertUtils.convert("123.456", Float.class); |
| assertInstanceOf(Float.class, value); |
| assertEquals(((Float) value).floatValue(), (float) 123.456, (float) 0.005); |
| |
| value = ConvertUtils.convert("123", Integer.TYPE); |
| assertInstanceOf(Integer.class, value); |
| assertEquals(((Integer) value).intValue(), 123); |
| |
| value = ConvertUtils.convert("123", Integer.class); |
| assertInstanceOf(Integer.class, value); |
| assertEquals(((Integer) value).intValue(), 123); |
| |
| value = ConvertUtils.convert("123", Long.TYPE); |
| assertInstanceOf(Long.class, value); |
| assertEquals(((Long) value).longValue(), 123); |
| |
| value = ConvertUtils.convert("123", Long.class); |
| assertInstanceOf(Long.class, value); |
| assertEquals(((Long) value).longValue(), 123); |
| |
| value = ConvertUtils.convert("123", Short.TYPE); |
| assertInstanceOf(Short.class, value); |
| assertEquals(((Short) value).shortValue(), (short) 123); |
| |
| value = ConvertUtils.convert("123", Short.class); |
| assertInstanceOf(Short.class, value); |
| assertEquals(((Short) value).shortValue(), (short) 123); |
| |
| String input; |
| |
| input = "2002-03-17"; |
| value = ConvertUtils.convert(input, Date.class); |
| assertInstanceOf(Date.class, value); |
| assertEquals(input, value.toString()); |
| |
| input = "20:30:40"; |
| value = ConvertUtils.convert(input, Time.class); |
| assertInstanceOf(Time.class, value); |
| assertEquals(input, value.toString()); |
| |
| input = "2002-03-17 20:30:40.0"; |
| value = ConvertUtils.convert(input, Timestamp.class); |
| assertInstanceOf(Timestamp.class, value); |
| assertEquals(input, value.toString()); |
| |
| } |
| |
| /** |
| * Positive String to String array tests. |
| */ |
| @Test |
| void testPositiveStringArray() { |
| |
| Object value; |
| final String[] stringArray = {}; |
| final String[] stringArray1 = { "abc" }; |
| final String[] stringArray2 = { "abc", "de,f" }; |
| |
| value = ConvertUtils.convert("", stringArray.getClass()); |
| checkStringArray(value, stringArray); |
| value = ConvertUtils.convert(" ", stringArray.getClass()); |
| checkStringArray(value, stringArray); |
| value = ConvertUtils.convert("{}", stringArray.getClass()); |
| checkStringArray(value, stringArray); |
| value = ConvertUtils.convert("{ }", stringArray.getClass()); |
| checkStringArray(value, stringArray); |
| |
| value = ConvertUtils.convert("abc", stringArray.getClass()); |
| checkStringArray(value, stringArray1); |
| value = ConvertUtils.convert("{abc}", stringArray.getClass()); |
| checkStringArray(value, stringArray1); |
| value = ConvertUtils.convert("\"abc\"", stringArray.getClass()); |
| checkStringArray(value, stringArray1); |
| value = ConvertUtils.convert("{\"abc\"}", stringArray.getClass()); |
| checkStringArray(value, stringArray1); |
| value = ConvertUtils.convert("'abc'", stringArray.getClass()); |
| checkStringArray(value, stringArray1); |
| value = ConvertUtils.convert("{'abc'}", stringArray.getClass()); |
| checkStringArray(value, stringArray1); |
| |
| value = ConvertUtils.convert("abc 'de,f'", stringArray.getClass()); |
| checkStringArray(value, stringArray2); |
| value = ConvertUtils.convert("{abc, 'de,f'}", stringArray.getClass()); |
| checkStringArray(value, stringArray2); |
| value = ConvertUtils.convert("\"abc\",\"de,f\"", stringArray.getClass()); |
| checkStringArray(value, stringArray2); |
| value = ConvertUtils.convert("{\"abc\" 'de,f'}", stringArray.getClass()); |
| checkStringArray(value, stringArray2); |
| value = ConvertUtils.convert("'abc' 'de,f'", stringArray.getClass()); |
| checkStringArray(value, stringArray2); |
| value = ConvertUtils.convert("{'abc', \"de,f\"}", stringArray.getClass()); |
| checkStringArray(value, stringArray2); |
| |
| } |
| |
| @Test |
| void testSeparateConvertInstances() throws Exception { |
| final ConvertUtilsBean utilsOne = new ConvertUtilsBean(); |
| final ConvertUtilsBean utilsTwo = new ConvertUtilsBean(); |
| |
| // make sure that the test work ok before anything's changed |
| Object value = utilsOne.convert("true", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true, "Standard conversion failed (1)"); |
| |
| value = utilsTwo.convert("true", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true, "Standard conversion failed (2)"); |
| |
| // now register a test |
| utilsOne.register(new ThrowExceptionConverter(), Boolean.TYPE); |
| assertThrows(PassTestException.class, () -> utilsOne.convert("true", Boolean.TYPE)); |
| |
| // nothing should have changed |
| value = utilsTwo.convert("true", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true, "Standard conversion failed (3)"); |
| |
| // nothing we'll test deregister |
| utilsOne.deregister(); |
| value = utilsOne.convert("true", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true, "Instance deregister failed."); |
| |
| value = utilsTwo.convert("true", Boolean.TYPE); |
| assertInstanceOf(Boolean.class, value); |
| assertEquals(((Boolean) value).booleanValue(), true, "Standard conversion failed (4)"); |
| } |
| |
| } |
