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.locale;
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.assertThrows;
24  
25  import java.sql.Date;
26  import java.sql.Time;
27  import java.sql.Timestamp;
28  import java.text.NumberFormat;
29  
30  import org.apache.commons.beanutils2.ConversionException;
31  import org.junit.jupiter.api.AfterEach;
32  import org.junit.jupiter.api.BeforeEach;
33  import org.junit.jupiter.api.Disabled;
34  import org.junit.jupiter.api.Test;
35  
36  /**
37   * <p>
38   * Test Case for the LocaleConvertUtils class. See unimplemented functionality of the convert utils in the method begining with fixme
39   * </p>
40   */
41  public class LocaleConvertUtilsTest {
42  
43      private char decimalSeparator;
44  
45      private void checkIntegerArray(final Object value, final int[] intArray) {
46  
47          assertNotNull(value, "Returned value is not null");
48          assertEquals(intArray.getClass(), value.getClass(), "Returned value is int[]");
49          final int[] results = (int[]) value;
50          assertEquals(intArray.length, results.length, "Returned array length");
51          for (int i = 0; i < intArray.length; i++) {
52              assertEquals(intArray[i], results[i], "Returned array value " + i);
53          }
54  
55      }
56  
57      private void checkStringArray(final Object value, final String[] stringArray) {
58  
59          assertNotNull(value, "Returned value is not null");
60          assertEquals(stringArray.getClass(), value.getClass(), "Returned value is String[]");
61          final String[] results = (String[]) value;
62          assertEquals(stringArray.length, results.length, "Returned array length");
63          for (int i = 0; i < stringArray.length; i++) {
64              assertEquals(stringArray[i], results[i], "Returned array value " + i);
65          }
66  
67      }
68  
69      /**
70       * Negative String to primitive integer array tests.
71       */
72      @Test
73      @Disabled("Array conversions not implemented yet.")
74      public void fixmetestNegativeIntegerArray() {
75  
76          Object value;
77          final int[] intArray = {};
78  
79          value = LocaleConvertUtils.convert((String) null, intArray.getClass());
80          checkIntegerArray(value, intArray);
81          value = LocaleConvertUtils.convert("a", intArray.getClass());
82          checkIntegerArray(value, intArray);
83          value = LocaleConvertUtils.convert("{ a }", intArray.getClass());
84          checkIntegerArray(value, intArray);
85          value = LocaleConvertUtils.convert("1a3", intArray.getClass());
86          checkIntegerArray(value, intArray);
87          value = LocaleConvertUtils.convert("{ 1a3 }", intArray.getClass());
88          checkIntegerArray(value, intArray);
89          value = LocaleConvertUtils.convert("0,1a3", intArray.getClass());
90          checkIntegerArray(value, intArray);
91          value = LocaleConvertUtils.convert("{ 0, 1a3 }", intArray.getClass());
92          checkIntegerArray(value, intArray);
93  
94      }
95  
96      /**
97       * Negative String to String array tests.
98       */
99      @Test
100     @Disabled("Array conversions not implemented yet.")
101     public void fixmetestNegativeStringArray() {
102 
103         Object value;
104         final String[] stringArray = {};
105 
106         value = LocaleConvertUtils.convert((String) null, stringArray.getClass());
107         checkStringArray(value, stringArray);
108     }
109 
110     /**
111      * Test conversion of object to string for arrays - .
112      */
113     @Test
114     @Disabled("Array conversions not implemented yet.")
115     public void fixmetestObjectToStringArray() {
116 
117         final int[] intArray0 = {};
118         final int[] intArray1 = { 123 };
119         final int[] intArray2 = { 123, 456 };
120         final String[] stringArray0 = {};
121         final String[] stringArray1 = { "abc" };
122         final String[] stringArray2 = { "abc", "def" };
123 
124         assertEquals(null, LocaleConvertUtils.convert(intArray0), "intArray0");
125         assertEquals("123", LocaleConvertUtils.convert(intArray1), "intArray1");
126         assertEquals("123", LocaleConvertUtils.convert(intArray2), "intArray2");
127 
128         assertEquals(null, LocaleConvertUtils.convert(stringArray0), "stringArray0");
129         assertEquals("abc", LocaleConvertUtils.convert(stringArray1), "stringArray1");
130         assertEquals("abc", LocaleConvertUtils.convert(stringArray2), "stringArray2");
131 
132     }
133 
134     /**
135      * Positive array conversion tests.
136      */
137     @Test
138     @Disabled("Array conversions not implemented yet.")
139     public void fixmetestPositiveArray() {
140 
141         final String[] values1 = { "10", "20", "30" };
142         Object value = LocaleConvertUtils.convert(values1, Integer.TYPE);
143         final int[] shape = {};
144         assertEquals(shape.getClass(), value.getClass());
145         final int[] results1 = (int[]) value;
146         assertEquals(results1[0], 10);
147         assertEquals(results1[1], 20);
148         assertEquals(results1[2], 30);
149 
150         final String[] values2 = { "100", "200", "300" };
151         value = LocaleConvertUtils.convert(values2, shape.getClass());
152         assertEquals(shape.getClass(), value.getClass());
153         final int[] results2 = (int[]) value;
154         assertEquals(results2[0], 100);
155         assertEquals(results2[1], 200);
156         assertEquals(results2[2], 300);
157     }
158 
159     /**
160      * Positive String to primitive integer array tests.
161      */
162     @Test
163     @Disabled("Array conversions not implemented yet.")
164     public void fixmetestPositiveIntegerArray() {
165 
166         Object value;
167         final int[] intArray = {};
168         final int[] intArray1 = { 0 };
169         final int[] intArray2 = { 0, 10 };
170 
171         value = LocaleConvertUtils.convert("{  }", intArray.getClass());
172         checkIntegerArray(value, intArray);
173 
174         value = LocaleConvertUtils.convert("0", intArray.getClass());
175         checkIntegerArray(value, intArray1);
176         value = LocaleConvertUtils.convert(" 0 ", intArray.getClass());
177         checkIntegerArray(value, intArray1);
178         value = LocaleConvertUtils.convert("{ 0 }", intArray.getClass());
179         checkIntegerArray(value, intArray1);
180 
181         value = LocaleConvertUtils.convert("0,10", intArray.getClass());
182         checkIntegerArray(value, intArray2);
183         value = LocaleConvertUtils.convert("0 10", intArray.getClass());
184         checkIntegerArray(value, intArray2);
185         value = LocaleConvertUtils.convert("{0,10}", intArray.getClass());
186         checkIntegerArray(value, intArray2);
187         value = LocaleConvertUtils.convert("{0 10}", intArray.getClass());
188         checkIntegerArray(value, intArray2);
189         value = LocaleConvertUtils.convert("{ 0, 10 }", intArray.getClass());
190         checkIntegerArray(value, intArray2);
191         value = LocaleConvertUtils.convert("{ 0 10 }", intArray.getClass());
192         checkIntegerArray(value, intArray2);
193     }
194 
195     /**
196      * Positive String to String array tests.
197      */
198     @Test
199     @Disabled("Array conversions not implemented yet.")
200     public void fixmetestPositiveStringArray() {
201 
202         Object value;
203         final String[] stringArray = {};
204         final String[] stringArray1 = { "abc" };
205         final String[] stringArray2 = { "abc", "de,f" };
206 
207         value = LocaleConvertUtils.convert("", stringArray.getClass());
208         checkStringArray(value, stringArray);
209         value = LocaleConvertUtils.convert(" ", stringArray.getClass());
210         checkStringArray(value, stringArray);
211         value = LocaleConvertUtils.convert("{}", stringArray.getClass());
212         checkStringArray(value, stringArray);
213         value = LocaleConvertUtils.convert("{  }", stringArray.getClass());
214         checkStringArray(value, stringArray);
215 
216         value = LocaleConvertUtils.convert("abc", stringArray.getClass());
217         checkStringArray(value, stringArray1);
218         value = LocaleConvertUtils.convert("{abc}", stringArray.getClass());
219         checkStringArray(value, stringArray1);
220         value = LocaleConvertUtils.convert("\"abc\"", stringArray.getClass());
221         checkStringArray(value, stringArray1);
222         value = LocaleConvertUtils.convert("{\"abc\"}", stringArray.getClass());
223         checkStringArray(value, stringArray1);
224         value = LocaleConvertUtils.convert("'abc'", stringArray.getClass());
225         checkStringArray(value, stringArray1);
226         value = LocaleConvertUtils.convert("{'abc'}", stringArray.getClass());
227         checkStringArray(value, stringArray1);
228 
229         value = LocaleConvertUtils.convert("abc 'de,f'", stringArray.getClass());
230         checkStringArray(value, stringArray2);
231         value = LocaleConvertUtils.convert("{abc, 'de,f'}", stringArray.getClass());
232         checkStringArray(value, stringArray2);
233         value = LocaleConvertUtils.convert("\"abc\",\"de,f\"", stringArray.getClass());
234         checkStringArray(value, stringArray2);
235         value = LocaleConvertUtils.convert("{\"abc\" 'de,f'}", stringArray.getClass());
236         checkStringArray(value, stringArray2);
237         value = LocaleConvertUtils.convert("'abc' 'de,f'", stringArray.getClass());
238         checkStringArray(value, stringArray2);
239         value = LocaleConvertUtils.convert("{'abc', \"de,f\"}", stringArray.getClass());
240         checkStringArray(value, stringArray2);
241 
242     }
243 
244     /**
245      * Sets up instance variables required by this test case.
246      */
247     @BeforeEach
248     public void setUp() {
249 
250         LocaleConvertUtils.deregister();
251 
252         final NumberFormat nf = NumberFormat.getNumberInstance();
253         final String result = nf.format(1.1);
254 
255         // could be commas instead of stops in Europe.
256         decimalSeparator = result.charAt(1);
257 
258     }
259 
260     /**
261      * Tear down instance variables required by this test case.
262      */
263     @AfterEach
264     public void tearDown() {
265         // No action required
266     }
267 
268     /**
269      * Test conversion of a String array using a Locale and pattern.
270      */
271     @Test
272     public void testConvertStringArrayLocaleNull() {
273         final Object result = LocaleConvertUtils.convert(new String[] { "123" }, Integer[].class, null, "#,###");
274         assertNotNull(result, "Null Result");
275         assertEquals(Integer[].class, result.getClass(), "Integer Array Type");
276         assertEquals(1, ((Integer[]) result).length, "Integer Array Length");
277         assertEquals(Integer.valueOf(123), ((Integer[]) result)[0], "Integer Array Value");
278     }
279 
280     /**
281      * Test conversion of a String using a Locale and pattern.
282      */
283     @Test
284     public void testConvertStringLocaleNull() {
285         final Object result = LocaleConvertUtils.convert("123", Integer.class, null, "#,###");
286         assertNotNull(result, "Null Result");
287         assertEquals(Integer.class, result.getClass(), "Integer Type");
288         assertEquals(Integer.valueOf(123), result, "Integer Value");
289     }
290 
291     /**
292      * Tests a conversion if there is no suitable converter registered. In this case, the string converter is used, and the passed in target type is ignored.
293      * (This test is added to prevent a regression after the locale converters have been generified.)
294      */
295     @Test
296     public void testDefaultToStringConversionUnsupportedType() {
297         final Integer value = 20131101;
298         assertEquals(value.toString(), LocaleConvertUtils.convert(value.toString(), getClass()), "Wrong result");
299     }
300 
301     /**
302      * Negative scalar conversion tests. These rely on the standard default value conversions in LocaleConvertUtils.
303      */
304     @Test
305     public void testNegativeScalar() {
306         /*
307          * fixme Boolean converters not implemented at this point value = LocaleConvertUtils.convert("foo", Boolean.TYPE); ...
308          *
309          * value = LocaleConvertUtils.convert("foo", Boolean.class); ...
310          */
311         assertThrows(ConversionException.class, () -> LocaleConvertUtils.convert("foo", Byte.TYPE));
312         assertThrows(ConversionException.class, () -> LocaleConvertUtils.convert("foo", Byte.class));
313         /*
314          * fixme - not implemented try { value = LocaleConvertUtils.convert("org.apache.commons.beanutils2.Undefined", Class.class);
315          * fail("Should have thrown conversion exception"); } catch (ConversionException e) { ; // Expected result }
316          */
317         assertThrows(ConversionException.class, () -> LocaleConvertUtils.convert("foo", Double.TYPE));
318         assertThrows(ConversionException.class, () -> LocaleConvertUtils.convert("foo", Double.class));
319         assertThrows(ConversionException.class, () -> LocaleConvertUtils.convert("foo", Float.TYPE));
320         assertThrows(ConversionException.class, () -> LocaleConvertUtils.convert("foo", Float.class));
321         assertThrows(ConversionException.class, () -> LocaleConvertUtils.convert("foo", Integer.TYPE));
322         assertThrows(ConversionException.class, () -> LocaleConvertUtils.convert("foo", Integer.class));
323         assertThrows(ConversionException.class, () -> LocaleConvertUtils.convert("foo", Byte.TYPE));
324         assertThrows(ConversionException.class, () -> LocaleConvertUtils.convert("foo", Long.class));
325         assertThrows(ConversionException.class, () -> LocaleConvertUtils.convert("foo", Short.TYPE));
326         assertThrows(ConversionException.class, () -> LocaleConvertUtils.convert("foo", Short.class));
327     }
328 
329     /**
330      * Test conversion of object to string for scalars.
331      */
332     @Test
333     public void testObjectToStringScalar() {
334 
335         assertEquals("false", LocaleConvertUtils.convert(Boolean.FALSE), "Boolean->String");
336         assertEquals("true", LocaleConvertUtils.convert(Boolean.TRUE), "Boolean->String");
337         assertEquals("123", LocaleConvertUtils.convert(Byte.valueOf((byte) 123)), "Byte->String");
338         assertEquals("a", LocaleConvertUtils.convert(Character.valueOf('a')), "Character->String");
339         assertEquals("123" + decimalSeparator + "4", LocaleConvertUtils.convert(Double.valueOf(123.4)), "Double->String");
340         assertEquals("123" + decimalSeparator + "4", LocaleConvertUtils.convert(Float.valueOf((float) 123.4)), "Float->String");
341         assertEquals("123", LocaleConvertUtils.convert(Integer.valueOf(123)), "Integer->String");
342         assertEquals("123", LocaleConvertUtils.convert(Long.valueOf(123)), "Long->String");
343         assertEquals("123", LocaleConvertUtils.convert(Short.valueOf((short) 123)), "Short->String");
344         assertEquals("abc", LocaleConvertUtils.convert("abc"), "String->String");
345         assertEquals(null, LocaleConvertUtils.convert(null), "String->String null");
346 
347     }
348 
349     /**
350      * Positive scalar conversion tests.
351      */
352     @Test
353     public void testPositiveScalar() {
354         Object value;
355 
356         /*
357          * fixme Boolean converters not implemented value = LocaleConvertUtils.convert("true", Boolean.TYPE); assertInstanceOf(Boolean.class, value);
358          * assertEquals(((Boolean) value).booleanValue(), true);
359          *
360          * value = LocaleConvertUtils.convert("true", Boolean.class); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(),
361          * true);
362          *
363          * value = LocaleConvertUtils.convert("yes", Boolean.TYPE); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(),
364          * true);
365          *
366          * value = LocaleConvertUtils.convert("yes", Boolean.class); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(),
367          * true);
368          *
369          * value = LocaleConvertUtils.convert("y", Boolean.TYPE); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(), true);
370          *
371          * value = LocaleConvertUtils.convert("y", Boolean.class); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(), true);
372          *
373          * value = LocaleConvertUtils.convert("on", Boolean.TYPE); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(), true);
374          *
375          * value = LocaleConvertUtils.convert("on", Boolean.class); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(),
376          * true);
377          *
378          * value = LocaleConvertUtils.convert("false", Boolean.TYPE); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(),
379          * false);
380          *
381          * value = LocaleConvertUtils.convert("false", Boolean.class); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(),
382          * false);
383          *
384          * value = LocaleConvertUtils.convert("no", Boolean.TYPE); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(),
385          * false);
386          *
387          * value = LocaleConvertUtils.convert("no", Boolean.class); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(),
388          * false);
389          *
390          * value = LocaleConvertUtils.convert("n", Boolean.TYPE); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(), false);
391          *
392          * value = LocaleConvertUtils.convert("n", Boolean.class); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(),
393          * false);
394          *
395          * value = LocaleConvertUtils.convert("off", Boolean.TYPE); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(),
396          * false);
397          *
398          * value = LocaleConvertUtils.convert("off", Boolean.class); assertInstanceOf(Boolean.class, value); assertEquals(((Boolean) value).booleanValue(),
399          * false);
400          */
401 
402         value = LocaleConvertUtils.convert("123", Byte.TYPE);
403         assertInstanceOf(Byte.class, value);
404         assertEquals(((Byte) value).byteValue(), (byte) 123);
405 
406         value = LocaleConvertUtils.convert("123", Byte.class);
407         assertInstanceOf(Byte.class, value);
408         assertEquals(((Byte) value).byteValue(), (byte) 123);
409 
410         /*
411          * fixme Character conversion not implemented yet value = LocaleConvertUtils.convert("a", Character.TYPE); assertInstanceOf(Character.class, value);
412          * assertEquals(((Character) value).charValue(), 'a');
413          *
414          * value = LocaleConvertUtils.convert("a", Character.class); assertInstanceOf(Character.class, value); assertEquals(((Character) value).charValue(),
415          * 'a');
416          */
417         /*
418          * fixme - this is a discrepancy with standard converters ( probably not major issue ) value = LocaleConvertUtils.convert("java.lang.String",
419          * Class.class); assertInstanceOf(Class.class, value); assertEquals(String.class, (Class) value);
420          */
421 
422         value = LocaleConvertUtils.convert("123" + decimalSeparator + "456", Double.TYPE);
423         assertInstanceOf(Double.class, value);
424         assertEquals(((Double) value).doubleValue(), 123.456, 0.005);
425 
426         value = LocaleConvertUtils.convert("123" + decimalSeparator + "456", Double.class);
427         assertInstanceOf(Double.class, value);
428         assertEquals(((Double) value).doubleValue(), 123.456, 0.005);
429 
430         value = LocaleConvertUtils.convert("123" + decimalSeparator + "456", Float.TYPE);
431         assertInstanceOf(Float.class, value);
432         assertEquals(((Float) value).floatValue(), (float) 123.456, (float) 0.005);
433 
434         value = LocaleConvertUtils.convert("123" + decimalSeparator + "456", Float.class);
435         assertInstanceOf(Float.class, value);
436         assertEquals(((Float) value).floatValue(), (float) 123.456, (float) 0.005);
437 
438         value = LocaleConvertUtils.convert("123", Integer.TYPE);
439         assertInstanceOf(Integer.class, value);
440         assertEquals(((Integer) value).intValue(), 123);
441 
442         value = LocaleConvertUtils.convert("123", Integer.class);
443         assertInstanceOf(Integer.class, value);
444         assertEquals(((Integer) value).intValue(), 123);
445 
446         value = LocaleConvertUtils.convert("123", Long.TYPE);
447         assertInstanceOf(Long.class, value);
448         assertEquals(((Long) value).longValue(), 123);
449 
450         value = LocaleConvertUtils.convert("123456", Long.class);
451         assertInstanceOf(Long.class, value);
452         assertEquals(((Long) value).longValue(), 123456);
453 
454         /*
455          * fixme - Short conversion not implemented at this point value = LocaleConvertUtils.convert("123", Short.TYPE); assertInstanceOf(Short.class, value);
456          * assertEquals(((Short) value).shortValue(), (short) 123);
457          *
458          * value = LocaleConvertUtils.convert("123", Short.class); assertInstanceOf(Short.class, value); assertEquals(((Short) value).shortValue(), (short)
459          * 123);
460          */
461 
462         String input;
463 
464         input = "2002-03-17";
465         value = LocaleConvertUtils.convert(input, Date.class);
466         assertInstanceOf(Date.class, value);
467         assertEquals(input, value.toString());
468 
469         input = "20:30:40";
470         value = LocaleConvertUtils.convert(input, Time.class);
471         assertInstanceOf(Time.class, value);
472         assertEquals(input, value.toString());
473 
474         input = "2002-03-17 20:30:40.0";
475         value = LocaleConvertUtils.convert(input, Timestamp.class);
476         assertInstanceOf(Timestamp.class, value);
477         assertEquals(input, value.toString());
478 
479     }
480 
481 }