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