View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      https://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.commons.beanutils2;
19  
20  import static org.junit.jupiter.api.Assertions.assertEquals;
21  import static org.junit.jupiter.api.Assertions.assertInstanceOf;
22  import static org.junit.jupiter.api.Assertions.assertNotNull;
23  import static org.junit.jupiter.api.Assertions.assertNull;
24  import static org.junit.jupiter.api.Assertions.assertSame;
25  import static org.junit.jupiter.api.Assertions.assertThrows;
26  
27  import java.sql.Date;
28  import java.sql.Time;
29  import java.sql.Timestamp;
30  import java.text.DateFormat;
31  import java.text.SimpleDateFormat;
32  import java.util.Locale;
33  
34  import org.apache.commons.beanutils2.converters.DateConverter;
35  import org.apache.commons.lang3.ArrayUtils;
36  import org.junit.jupiter.api.AfterEach;
37  import org.junit.jupiter.api.BeforeEach;
38  import org.junit.jupiter.api.Test;
39  
40  public class ConvertUtilsTest {
41  
42      private void checkIntegerArray(final Object value, final int[] intArray) {
43  
44          assertNotNull(value, "Returned value is not null");
45          assertEquals(intArray.getClass(), value.getClass(), "Returned value is int[]");
46          final int[] results = (int[]) value;
47          assertEquals(intArray.length, results.length, "Returned array length");
48          for (int i = 0; i < intArray.length; i++) {
49              assertEquals(intArray[i], results[i], "Returned array value " + i);
50          }
51  
52      }
53  
54      private void checkStringArray(final Object value, final String[] stringArray) {
55  
56          assertNotNull(value, "Returned value is not null");
57          assertEquals(stringArray.getClass(), value.getClass(), "Returned value is String[]");
58          final String[] results = (String[]) value;
59          assertEquals(stringArray.length, results.length, "Returned array length");
60          for (int i = 0; i < stringArray.length; i++) {
61              assertEquals(stringArray[i], results[i], "Returned array value " + i);
62          }
63  
64      }
65  
66      /**
67       * Sets up instance variables required by this test case.
68       */
69      @BeforeEach
70      public void setUp() {
71          BeanUtilsBean.setInstance(new BeanUtilsBean());
72          ConvertUtils.deregister();
73  
74      }
75  
76      /**
77       * Tear down instance variables required by this test case.
78       */
79      @AfterEach
80      public void tearDown() {
81          // No action required
82      }
83  
84      @Test
85      @SuppressWarnings({ "unchecked", "rawtypes" })
86      // We need to use raw types in order to test legacy converters
87      public void testConvertToString() throws Exception {
88          final Converter dummyConverter = (type, value) -> value;
89  
90          final Converter fooConverter = (type, value) -> "Foo-Converter";
91  
92          final DateConverter dateConverter = new DateConverter();
93          dateConverter.setLocale(Locale.US);
94  
95          final ConvertUtilsBean utils = new ConvertUtilsBean();
96          utils.register(dateConverter, java.util.Date.class);
97          utils.register(fooConverter, String.class);
98  
99          // Convert using registered DateConverter
100         final java.util.Date today = new java.util.Date();
101         final DateFormat fmt = new SimpleDateFormat("M/d/yy"); /* US Short Format */
102         final String expected = fmt.format(today);
103         assertEquals(expected, utils.convert(today, String.class), "DateConverter M/d/yy");
104 
105         // Date converter doesn't do String conversion - use String Converter
106         utils.register(dummyConverter, java.util.Date.class);
107         assertEquals("Foo-Converter", utils.convert(today, String.class), "Date Converter doesn't do String conversion");
108 
109         // No registered Date converter - use String Converter
110         utils.deregister(java.util.Date.class);
111         assertEquals("Foo-Converter", utils.convert(today, String.class), "No registered Date converter");
112 
113         // String Converter doesn't do Strings!!!
114         utils.register(dummyConverter, String.class);
115         assertEquals(today.toString(), utils.convert(today, String.class), "String Converter doesn't do Strings!!!");
116 
117         // No registered Date or String converter - use Object's toString()
118         utils.deregister(String.class);
119         assertEquals(today.toString(), utils.convert(today, String.class), "Object's toString()");
120 
121     }
122 
123     /**
124      * Tests a conversion to an unsupported target type.
125      */
126     @Test
127     public void testConvertUnsupportedTargetType() {
128         final ConvertUtilsBean utils = new ConvertUtilsBean();
129         final Object value = "A test value";
130         assertSame(value, utils.convert(value, getClass()), "Got different object");
131     }
132 
133     @Test
134     public void testDeregisteringSingleConverter() throws Exception {
135         // make sure that the test work ok before anything's changed
136         final Object value = ConvertUtils.convert("true", Boolean.TYPE);
137         assertInstanceOf(Boolean.class, value);
138         assertEquals(((Boolean) value).booleanValue(), true, "Standard conversion failed (1)");
139 
140         // we'll test deregister
141         ConvertUtils.deregister(Boolean.TYPE);
142         assertNull(ConvertUtils.lookup(Boolean.TYPE), "Converter should be null");
143 
144     }
145 
146     /**
147      * Negative String to primitive integer array tests.
148      */
149     @Test
150     public void testNegativeIntegerArray() {
151 
152         Object value;
153         final int[] intArray = {};
154 
155         value = ConvertUtils.convert((String) null, intArray.getClass());
156         checkIntegerArray(value, intArray);
157         value = ConvertUtils.convert("a", intArray.getClass());
158         checkIntegerArray(value, intArray);
159         value = ConvertUtils.convert("{ a }", intArray.getClass());
160         checkIntegerArray(value, intArray);
161         value = ConvertUtils.convert("1a3", intArray.getClass());
162         checkIntegerArray(value, intArray);
163         value = ConvertUtils.convert("{ 1a3 }", intArray.getClass());
164         checkIntegerArray(value, intArray);
165         value = ConvertUtils.convert("0,1a3", intArray.getClass());
166         checkIntegerArray(value, intArray);
167         value = ConvertUtils.convert("{ 0, 1a3 }", intArray.getClass());
168         checkIntegerArray(value, intArray);
169 
170     }
171 
172     /**
173      * Negative scalar conversion tests. These rely on the standard default value conversions in ConvertUtils.
174      */
175     @Test
176     public void testNegativeScalar() {
177 
178         Object value;
179 
180         value = ConvertUtils.convert("foo", Boolean.TYPE);
181         assertInstanceOf(Boolean.class, value);
182         assertEquals(((Boolean) value).booleanValue(), false);
183 
184         value = ConvertUtils.convert("foo", Boolean.class);
185         assertInstanceOf(Boolean.class, value);
186         assertEquals(((Boolean) value).booleanValue(), false);
187 
188         value = ConvertUtils.convert("foo", Byte.TYPE);
189         assertInstanceOf(Byte.class, value);
190         assertEquals(((Byte) value).byteValue(), (byte) 0);
191 
192         value = ConvertUtils.convert("foo", Byte.class);
193         assertInstanceOf(Byte.class, value);
194         assertEquals(((Byte) value).byteValue(), (byte) 0);
195 
196         assertThrows(ConversionException.class, () -> ConvertUtils.convert("org.apache.commons.beanutils2.Undefined", Class.class));
197 
198         value = ConvertUtils.convert("foo", Double.TYPE);
199         assertInstanceOf(Double.class, value);
200         assertEquals(((Double) value).doubleValue(), 0.0, 0.005);
201 
202         value = ConvertUtils.convert("foo", Double.class);
203         assertInstanceOf(Double.class, value);
204         assertEquals(((Double) value).doubleValue(), 0.0, 0.005);
205 
206         value = ConvertUtils.convert("foo", Float.TYPE);
207         assertInstanceOf(Float.class, value);
208         assertEquals(((Float) value).floatValue(), (float) 0.0, (float) 0.005);
209 
210         value = ConvertUtils.convert("foo", Float.class);
211         assertInstanceOf(Float.class, value);
212         assertEquals(((Float) value).floatValue(), (float) 0.0, (float) 0.005);
213 
214         value = ConvertUtils.convert("foo", Integer.TYPE);
215         assertInstanceOf(Integer.class, value);
216         assertEquals(((Integer) value).intValue(), 0);
217 
218         value = ConvertUtils.convert("foo", Integer.class);
219         assertInstanceOf(Integer.class, value);
220         assertEquals(((Integer) value).intValue(), 0);
221 
222         value = ConvertUtils.convert("foo", Byte.TYPE);
223         assertInstanceOf(Byte.class, value);
224         assertEquals(((Byte) value).byteValue(), (byte) 0);
225 
226         value = ConvertUtils.convert("foo", Long.class);
227         assertInstanceOf(Long.class, value);
228         assertEquals(((Long) value).longValue(), 0);
229 
230         value = ConvertUtils.convert("foo", Short.TYPE);
231         assertInstanceOf(Short.class, value);
232         assertEquals(((Short) value).shortValue(), (short) 0);
233 
234         value = ConvertUtils.convert("foo", Short.class);
235         assertInstanceOf(Short.class, value);
236         assertEquals(((Short) value).shortValue(), (short) 0);
237 
238     }
239 
240     /**
241      * Negative String to String array tests.
242      */
243     @Test
244     public void testNegativeStringArray() {
245 
246         Object value;
247         final String[] stringArray = {};
248 
249         value = ConvertUtils.convert((String) null, stringArray.getClass());
250         checkStringArray(value, stringArray);
251 
252     }
253 
254     /**
255      * Test conversion of object to string for arrays.
256      */
257     @Test
258     public void testObjectToStringArray() {
259 
260         final int[] intArray0 = {};
261         final int[] intArray1 = { 123 };
262         final int[] intArray2 = { 123, 456 };
263         final String[] stringArray0 = {};
264         final String[] stringArray1 = { "abc" };
265         final String[] stringArray2 = { "abc", "def" };
266 
267         assertEquals(null, ConvertUtils.convert(intArray0), "intArray0");
268         assertEquals("123", ConvertUtils.convert(intArray1), "intArray1");
269         assertEquals("123", ConvertUtils.convert(intArray2), "intArray2");
270 
271         assertEquals(null, ConvertUtils.convert(stringArray0), "stringArray0");
272         assertEquals("abc", ConvertUtils.convert(stringArray1), "stringArray1");
273         assertEquals("abc", ConvertUtils.convert(stringArray2), "stringArray2");
274 
275     }
276 
277     /**
278      * Test conversion of object to string for scalars.
279      */
280     @Test
281     public void testObjectToStringScalar() {
282 
283         assertEquals("false", ConvertUtils.convert(Boolean.FALSE), "Boolean->String");
284         assertEquals("true", ConvertUtils.convert(Boolean.TRUE), "Boolean->String");
285         assertEquals("123", ConvertUtils.convert(Byte.valueOf((byte) 123)), "Byte->String");
286         assertEquals("a", ConvertUtils.convert(Character.valueOf('a')), "Character->String");
287         assertEquals("123.0", ConvertUtils.convert(Double.valueOf(123.0)), "Double->String");
288         assertEquals("123.0", ConvertUtils.convert(Float.valueOf((float) 123.0)), "Float->String");
289         assertEquals("123", ConvertUtils.convert(Integer.valueOf(123)), "Integer->String");
290         assertEquals("123", ConvertUtils.convert(Long.valueOf(123)), "Long->String");
291         assertEquals("123", ConvertUtils.convert(Short.valueOf((short) 123)), "Short->String");
292         assertEquals("abc", ConvertUtils.convert("abc"), "String->String");
293         assertEquals(null, ConvertUtils.convert(null), "String->String null");
294 
295     }
296 
297     /**
298      * Positive array conversion tests.
299      */
300     @Test
301     public void testPositiveArray() {
302         // check 1
303         final String[] values1 = { "10", "20", "30" };
304         final int[] shape = ArrayUtils.EMPTY_INT_ARRAY;
305         Object value = ConvertUtils.convert(values1, shape.getClass());
306         assertEquals(shape.getClass(), value.getClass());
307         final int[] results1 = (int[]) value;
308         assertEquals(10, results1[0]);
309         assertEquals(20, results1[1]);
310         assertEquals(30, results1[2]);
311         // check 2
312         final String[] values2 = { "100", "200", "300" };
313         value = ConvertUtils.convert(values2, shape.getClass());
314         assertEquals(shape.getClass(), value.getClass());
315         final int[] results2 = (int[]) value;
316         assertEquals(100, results2[0]);
317         assertEquals(200, results2[1]);
318         assertEquals(300, results2[2]);
319         // check 3
320         value = ConvertUtils.convert(values1, Integer.TYPE);
321         assertEquals(Integer.class, value.getClass());
322         assertEquals(Integer.valueOf(10), value);
323     }
324 
325     /**
326      * Positive String to primitive integer array tests.
327      */
328     @Test
329     public void testPositiveIntegerArray() {
330         Object value;
331         final int[] intArray = {};
332         final int[] intArray1 = { 0 };
333         final int[] intArray2 = { 0, 10 };
334 
335         final Class<? extends int[]> intArrayClass = intArray.getClass();
336         value = ConvertUtils.convert("{  }", intArrayClass);
337         checkIntegerArray(value, intArray);
338 
339         value = ConvertUtils.convert("0", intArrayClass);
340         checkIntegerArray(value, intArray1);
341         value = ConvertUtils.convert(" 0 ", intArrayClass);
342         checkIntegerArray(value, intArray1);
343         value = ConvertUtils.convert("{ 0 }", intArrayClass);
344         checkIntegerArray(value, intArray1);
345 
346         value = ConvertUtils.convert("0,10", intArrayClass);
347         checkIntegerArray(value, intArray2);
348         value = ConvertUtils.convert("0 10", intArrayClass);
349         checkIntegerArray(value, intArray2);
350         value = ConvertUtils.convert("{0,10}", intArrayClass);
351         checkIntegerArray(value, intArray2);
352         value = ConvertUtils.convert("{0 10}", intArrayClass);
353         checkIntegerArray(value, intArray2);
354         value = ConvertUtils.convert("{ 0, 10 }", intArrayClass);
355         checkIntegerArray(value, intArray2);
356         value = ConvertUtils.convert("{ 0 10 }", intArrayClass);
357         checkIntegerArray(value, intArray2);
358     }
359 
360     /**
361      * Positive scalar conversion tests.
362      */
363     @Test
364     public void testPositiveScalar() {
365 
366         Object value;
367 
368         value = ConvertUtils.convert("true", Boolean.TYPE);
369         assertInstanceOf(Boolean.class, value);
370         assertEquals(((Boolean) value).booleanValue(), true);
371 
372         value = ConvertUtils.convert("true", Boolean.class);
373         assertInstanceOf(Boolean.class, value);
374         assertEquals(((Boolean) value).booleanValue(), true);
375 
376         value = ConvertUtils.convert("yes", Boolean.TYPE);
377         assertInstanceOf(Boolean.class, value);
378         assertEquals(((Boolean) value).booleanValue(), true);
379 
380         value = ConvertUtils.convert("yes", Boolean.class);
381         assertInstanceOf(Boolean.class, value);
382         assertEquals(((Boolean) value).booleanValue(), true);
383 
384         value = ConvertUtils.convert("y", Boolean.TYPE);
385         assertInstanceOf(Boolean.class, value);
386         assertEquals(((Boolean) value).booleanValue(), true);
387 
388         value = ConvertUtils.convert("y", Boolean.class);
389         assertInstanceOf(Boolean.class, value);
390         assertEquals(((Boolean) value).booleanValue(), true);
391 
392         value = ConvertUtils.convert("on", Boolean.TYPE);
393         assertInstanceOf(Boolean.class, value);
394         assertEquals(((Boolean) value).booleanValue(), true);
395 
396         value = ConvertUtils.convert("on", Boolean.class);
397         assertInstanceOf(Boolean.class, value);
398         assertEquals(((Boolean) value).booleanValue(), true);
399 
400         value = ConvertUtils.convert("false", Boolean.TYPE);
401         assertInstanceOf(Boolean.class, value);
402         assertEquals(((Boolean) value).booleanValue(), false);
403 
404         value = ConvertUtils.convert("false", Boolean.class);
405         assertInstanceOf(Boolean.class, value);
406         assertEquals(((Boolean) value).booleanValue(), false);
407 
408         value = ConvertUtils.convert("no", Boolean.TYPE);
409         assertInstanceOf(Boolean.class, value);
410         assertEquals(((Boolean) value).booleanValue(), false);
411 
412         value = ConvertUtils.convert("no", Boolean.class);
413         assertInstanceOf(Boolean.class, value);
414         assertEquals(((Boolean) value).booleanValue(), false);
415 
416         value = ConvertUtils.convert("n", Boolean.TYPE);
417         assertInstanceOf(Boolean.class, value);
418         assertEquals(((Boolean) value).booleanValue(), false);
419 
420         value = ConvertUtils.convert("n", Boolean.class);
421         assertInstanceOf(Boolean.class, value);
422         assertEquals(((Boolean) value).booleanValue(), false);
423 
424         value = ConvertUtils.convert("off", Boolean.TYPE);
425         assertInstanceOf(Boolean.class, value);
426         assertEquals(((Boolean) value).booleanValue(), false);
427 
428         value = ConvertUtils.convert("off", Boolean.class);
429         assertInstanceOf(Boolean.class, value);
430         assertEquals(((Boolean) value).booleanValue(), false);
431 
432         value = ConvertUtils.convert("123", Byte.TYPE);
433         assertInstanceOf(Byte.class, value);
434         assertEquals(((Byte) value).byteValue(), (byte) 123);
435 
436         value = ConvertUtils.convert("123", Byte.class);
437         assertInstanceOf(Byte.class, value);
438         assertEquals(((Byte) value).byteValue(), (byte) 123);
439 
440         value = ConvertUtils.convert("a", Character.TYPE);
441         assertInstanceOf(Character.class, value);
442         assertEquals(((Character) value).charValue(), 'a');
443 
444         value = ConvertUtils.convert("a", Character.class);
445         assertInstanceOf(Character.class, value);
446         assertEquals(((Character) value).charValue(), 'a');
447 
448         value = ConvertUtils.convert("java.lang.String", Class.class);
449         assertInstanceOf(Class.class, value);
450         assertEquals(String.class, value);
451 
452         value = ConvertUtils.convert("123.456", Double.TYPE);
453         assertInstanceOf(Double.class, value);
454         assertEquals(((Double) value).doubleValue(), 123.456, 0.005);
455 
456         value = ConvertUtils.convert("123.456", Double.class);
457         assertInstanceOf(Double.class, value);
458         assertEquals(((Double) value).doubleValue(), 123.456, 0.005);
459 
460         value = ConvertUtils.convert("123.456", Float.TYPE);
461         assertInstanceOf(Float.class, value);
462         assertEquals(((Float) value).floatValue(), (float) 123.456, (float) 0.005);
463 
464         value = ConvertUtils.convert("123.456", Float.class);
465         assertInstanceOf(Float.class, value);
466         assertEquals(((Float) value).floatValue(), (float) 123.456, (float) 0.005);
467 
468         value = ConvertUtils.convert("123", Integer.TYPE);
469         assertInstanceOf(Integer.class, value);
470         assertEquals(((Integer) value).intValue(), 123);
471 
472         value = ConvertUtils.convert("123", Integer.class);
473         assertInstanceOf(Integer.class, value);
474         assertEquals(((Integer) value).intValue(), 123);
475 
476         value = ConvertUtils.convert("123", Long.TYPE);
477         assertInstanceOf(Long.class, value);
478         assertEquals(((Long) value).longValue(), 123);
479 
480         value = ConvertUtils.convert("123", Long.class);
481         assertInstanceOf(Long.class, value);
482         assertEquals(((Long) value).longValue(), 123);
483 
484         value = ConvertUtils.convert("123", Short.TYPE);
485         assertInstanceOf(Short.class, value);
486         assertEquals(((Short) value).shortValue(), (short) 123);
487 
488         value = ConvertUtils.convert("123", Short.class);
489         assertInstanceOf(Short.class, value);
490         assertEquals(((Short) value).shortValue(), (short) 123);
491 
492         String input;
493 
494         input = "2002-03-17";
495         value = ConvertUtils.convert(input, Date.class);
496         assertInstanceOf(Date.class, value);
497         assertEquals(input, value.toString());
498 
499         input = "20:30:40";
500         value = ConvertUtils.convert(input, Time.class);
501         assertInstanceOf(Time.class, value);
502         assertEquals(input, value.toString());
503 
504         input = "2002-03-17 20:30:40.0";
505         value = ConvertUtils.convert(input, Timestamp.class);
506         assertInstanceOf(Timestamp.class, value);
507         assertEquals(input, value.toString());
508 
509     }
510 
511     /**
512      * Positive String to String array tests.
513      */
514     @Test
515     public void testPositiveStringArray() {
516 
517         Object value;
518         final String[] stringArray = {};
519         final String[] stringArray1 = { "abc" };
520         final String[] stringArray2 = { "abc", "de,f" };
521 
522         value = ConvertUtils.convert("", stringArray.getClass());
523         checkStringArray(value, stringArray);
524         value = ConvertUtils.convert(" ", stringArray.getClass());
525         checkStringArray(value, stringArray);
526         value = ConvertUtils.convert("{}", stringArray.getClass());
527         checkStringArray(value, stringArray);
528         value = ConvertUtils.convert("{  }", stringArray.getClass());
529         checkStringArray(value, stringArray);
530 
531         value = ConvertUtils.convert("abc", stringArray.getClass());
532         checkStringArray(value, stringArray1);
533         value = ConvertUtils.convert("{abc}", stringArray.getClass());
534         checkStringArray(value, stringArray1);
535         value = ConvertUtils.convert("\"abc\"", stringArray.getClass());
536         checkStringArray(value, stringArray1);
537         value = ConvertUtils.convert("{\"abc\"}", stringArray.getClass());
538         checkStringArray(value, stringArray1);
539         value = ConvertUtils.convert("'abc'", stringArray.getClass());
540         checkStringArray(value, stringArray1);
541         value = ConvertUtils.convert("{'abc'}", stringArray.getClass());
542         checkStringArray(value, stringArray1);
543 
544         value = ConvertUtils.convert("abc 'de,f'", stringArray.getClass());
545         checkStringArray(value, stringArray2);
546         value = ConvertUtils.convert("{abc, 'de,f'}", stringArray.getClass());
547         checkStringArray(value, stringArray2);
548         value = ConvertUtils.convert("\"abc\",\"de,f\"", stringArray.getClass());
549         checkStringArray(value, stringArray2);
550         value = ConvertUtils.convert("{\"abc\" 'de,f'}", stringArray.getClass());
551         checkStringArray(value, stringArray2);
552         value = ConvertUtils.convert("'abc' 'de,f'", stringArray.getClass());
553         checkStringArray(value, stringArray2);
554         value = ConvertUtils.convert("{'abc', \"de,f\"}", stringArray.getClass());
555         checkStringArray(value, stringArray2);
556 
557     }
558 
559     @Test
560     public void testSeparateConvertInstances() throws Exception {
561         final ConvertUtilsBean utilsOne = new ConvertUtilsBean();
562         final ConvertUtilsBean utilsTwo = new ConvertUtilsBean();
563 
564         // make sure that the test work ok before anything's changed
565         Object value = utilsOne.convert("true", Boolean.TYPE);
566         assertInstanceOf(Boolean.class, value);
567         assertEquals(((Boolean) value).booleanValue(), true, "Standard conversion failed (1)");
568 
569         value = utilsTwo.convert("true", Boolean.TYPE);
570         assertInstanceOf(Boolean.class, value);
571         assertEquals(((Boolean) value).booleanValue(), true, "Standard conversion failed (2)");
572 
573         // now register a test
574         utilsOne.register(new ThrowExceptionConverter(), Boolean.TYPE);
575         assertThrows(PassTestException.class, () -> utilsOne.convert("true", Boolean.TYPE));
576 
577         // nothing should have changed
578         value = utilsTwo.convert("true", Boolean.TYPE);
579         assertInstanceOf(Boolean.class, value);
580         assertEquals(((Boolean) value).booleanValue(), true, "Standard conversion failed (3)");
581 
582         // nothing we'll test deregister
583         utilsOne.deregister();
584         value = utilsOne.convert("true", Boolean.TYPE);
585         assertInstanceOf(Boolean.class, value);
586         assertEquals(((Boolean) value).booleanValue(), true, "Instance deregister failed.");
587 
588         value = utilsTwo.convert("true", Boolean.TYPE);
589         assertInstanceOf(Boolean.class, value);
590         assertEquals(((Boolean) value).booleanValue(), true, "Standard conversion failed (4)");
591     }
592 
593 }