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.converters;
19  
20  import static org.junit.jupiter.api.Assertions.assertEquals;
21  
22  import org.apache.commons.beanutils2.locale.converters.IntegerLocaleConverter;
23  import org.junit.jupiter.api.BeforeEach;
24  import org.junit.jupiter.api.Test;
25  
26  /**
27   * Test Case for the IntegerLocaleConverter class.
28   */
29  public class IntegerLocaleConverterTest extends AbstractLocaleConverterTest<Integer> {
30  
31      /**
32       * Sets up instance variables required by this test case.
33       */
34      @Override
35      @BeforeEach
36      public void setUp() throws Exception {
37          super.setUp();
38          defaultValue = Integer.valueOf("999");
39          expectedValue = Integer.valueOf(expectedIntegerValue);
40      }
41  
42      /**
43       * Test Converter() constructor
44       *
45       * Uses the default locale, no default value
46       */
47      @Test
48      public void testConstructor_2() {
49          // Construct using default locale
50          converter = IntegerLocaleConverter.builder().get();
51  
52          // Perform Tests
53          convertValueNoPattern(converter, defaultIntegerValue, expectedValue);
54          convertValueWithPattern(converter, defaultIntegerValue, defaultIntegerPattern, expectedValue);
55          convertInvalid(converter, null);
56          convertNull(converter, null);
57      }
58  
59      /**
60       * Test Converter(locPattern) constructor
61       *
62       * Uses the default locale, no default value
63       */
64      @Test
65      public void testConstructor_3() {
66          // Construct using localized pattern (default locale)
67          converter = IntegerLocaleConverter.builder().setLocalizedPattern(true).get();
68  
69          // Perform Tests
70          convertValueNoPattern(converter, defaultIntegerValue, expectedValue);
71          convertValueWithPattern(converter, defaultIntegerValue, defaultIntegerPattern, expectedValue);
72          convertInvalid(converter, null);
73          convertNull(converter, null);
74      }
75  
76      /**
77       * Test Converter(Locale) constructor
78       */
79      @Test
80      public void testConstructor_4() {
81          // Construct using specified Locale
82          converter = IntegerLocaleConverter.builder().setLocale(localizedLocale).get();
83  
84          // Perform Tests
85          convertValueNoPattern(converter, localizedIntegerValue, expectedValue);
86          convertValueWithPattern(converter, localizedIntegerValue, defaultIntegerPattern, expectedValue);
87          convertInvalid(converter, null);
88          convertNull(converter, null);
89      }
90  
91      /**
92       * Test Converter(Locale, locPattern) constructor
93       */
94      @Test
95      public void testConstructor_5() {
96          // Construct using specified Locale
97          converter = IntegerLocaleConverter.builder().setLocale(localizedLocale).setLocalizedPattern(true).get();
98  
99          // Perform Tests
100         convertValueNoPattern(converter, localizedIntegerValue, expectedValue);
101         convertValueWithPattern(converter, localizedIntegerValue, localizedIntegerPattern, expectedValue);
102         convertInvalid(converter, null);
103         convertNull(converter, null);
104     }
105 
106     /**
107      * Test Converter(Locale, pattern) constructor
108      */
109     @Test
110     public void testConstructor_6() {
111         // Construct using specified Locale
112         converter = IntegerLocaleConverter.builder().setLocale(localizedLocale).setPattern(defaultIntegerPattern).get();
113 
114         // Perform Tests
115         convertValueNoPattern(converter, localizedIntegerValue, expectedValue);
116         convertValueWithPattern(converter, localizedIntegerValue, defaultIntegerPattern, expectedValue);
117         convertInvalid(converter, null);
118         convertNull(converter, null);
119     }
120 
121     /**
122      * Test Converter(Locale, pattern, locPattern) constructor
123      */
124     @Test
125     public void testConstructor_7() {
126         // Construct using specified Locale
127         converter = IntegerLocaleConverter.builder().setLocale(localizedLocale).setPattern(localizedIntegerPattern).setLocalizedPattern(true).get();
128 
129         // Perform Tests
130         convertValueNoPattern(converter, localizedIntegerValue, expectedValue);
131         convertValueWithPattern(converter, localizedIntegerValue, localizedIntegerPattern, expectedValue);
132         convertInvalid(converter, null);
133         convertNull(converter, null);
134     }
135 
136     /**
137      * Test Converter(defaultValue) constructor
138      */
139     @Test
140     public void testConstructor_8() {
141         // Construct using specified Locale
142         converter = IntegerLocaleConverter.builder().setDefault(defaultValue).get();
143 
144         // Perform Tests
145         convertValueNoPattern(converter, defaultIntegerValue, expectedValue);
146         convertValueWithPattern(converter, defaultIntegerValue, defaultIntegerPattern, expectedValue);
147         convertInvalid(converter, defaultValue);
148         convertNull(converter, defaultValue);
149     }
150 
151     /**
152      * Test Converter(defaultValue, locPattern) constructor
153      */
154     @Test
155     public void testConstructor_9() {
156         // Construct using specified Locale
157         converter = IntegerLocaleConverter.builder().setDefault(defaultValue).setLocalizedPattern(true).get();
158 
159         // Perform Tests
160         convertValueNoPattern(converter, defaultIntegerValue, expectedValue);
161         convertValueWithPattern(converter, defaultIntegerValue, defaultIntegerPattern, expectedValue);
162         convertInvalid(converter, defaultValue);
163         convertNull(converter, defaultValue);
164     }
165 
166     /**
167      * Test Converter(defaultValue, locale, pattern, localizedPattern) constructor
168      */
169     @Test
170     public void testConstructorMain() {
171 
172         // Construct with localized pattern
173         converter = IntegerLocaleConverter.builder().setDefault(defaultValue).setLocale(localizedLocale).setPattern(localizedIntegerPattern)
174                 .setLocalizedPattern(true).get();
175 
176         convertValueNoPattern(converter, "(A)", localizedIntegerValue, expectedValue);
177         convertValueWithPattern(converter, "(A)", localizedIntegerValue, localizedIntegerPattern, expectedValue);
178         convertInvalid(converter, "(A)", defaultValue);
179         convertNull(converter, "(A)", defaultValue);
180 
181         // **************************************************************************
182         // Convert value in the wrong format - maybe you would expect it to throw an
183         // exception and return the default - it doesn't, DecimalFormat parses it
184         // quite happily turning "1,234" into "1"
185         // I guess this is one of the limitations of DecimalFormat
186         // **************************************************************************
187         convertValueNoPattern(converter, "(B)", defaultIntegerValue, Integer.valueOf("1"));
188 
189         // **************************************************************************
190         // Convert with non-localized pattern - unlike the equivalent BigDecimal Test Case
191         // it doesn't causes an exception in parse() - DecimalFormat parses it
192         // quite happily turning "1,234" into "1"
193         // Again this is one of the limitations of DecimalFormat
194         // **************************************************************************
195         convertValueWithPattern(converter, "(B)", localizedIntegerValue, defaultIntegerPattern, Integer.valueOf("1"));
196 
197         // **************************************************************************
198         // Convert with specified type
199         //
200         // BaseLocaleConverter completely ignores the type - so even if we specify
201         // Double.class here it still returns a Integer.
202         // **** This has been changed due to BEANUTILS-449 ****
203         // **************************************************************************
204         // convertValueToType(converter, "(B)", Double.class, localizedIntegerValue, localizedIntegerPattern, expectedValue);
205 
206         // Construct with non-localized pattern
207         converter = IntegerLocaleConverter.builder().setDefault(defaultValue).setLocale(localizedLocale).setPattern(defaultIntegerPattern)
208                 .setLocalizedPattern(false).get();
209 
210         convertValueNoPattern(converter, "(C)", localizedIntegerValue, expectedValue);
211         convertValueWithPattern(converter, "(C)", localizedIntegerValue, defaultIntegerPattern, expectedValue);
212         convertInvalid(converter, "(C)", defaultValue);
213         convertNull(converter, "(C)", defaultValue);
214     }
215 
216     /**
217      * Test Converting a number
218      */
219     @Test
220     public void testNumber() {
221         // Construct using specified Locale
222         converter = IntegerLocaleConverter.builder().setLocale(localizedLocale).get();
223 
224         final Integer value = Integer.valueOf(1234);
225         assertEquals(value, converter.convert(value), "Convert Integer");
226         assertEquals(value, converter.convert(Long.valueOf(value.intValue())), "Convert Long");
227     }
228 
229     /**
230      * Tests whether a conversion to a primitive type can be performed.
231      */
232     @Test
233     public void testToPrimitiveType() {
234         converter = IntegerLocaleConverter.builder().get();
235         final Integer value = 20131028;
236         final Class<Integer> target = Integer.TYPE;
237         final int result = converter.convert(target, (Object) value.toString());
238         assertEquals(value.intValue(), result, "Wrong result");
239     }
240 }