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 * http://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.beanutils.locale.converters;
19
20
21 /**
22 * Test Case for the ByteLocaleConverter class.
23 *
24 * @version $Id$
25 */
26
27 public class ByteLocaleConverterTestCase extends BaseLocaleConverterTestCase {
28
29 // ---------------------------------------------------------- Constructors
30
31 public ByteLocaleConverterTestCase(final String name) {
32 super(name);
33 }
34
35 // -------------------------------------------------- Overall Test Methods
36
37 /**
38 * Set up instance variables required by this test case.
39 */
40 @Override
41 public void setUp() throws Exception {
42
43 super.setUp();
44
45 defaultIntegerPattern = "#,###";
46 defaultIntegerValue = ",123";
47
48 localizedIntegerPattern = "#.###";
49 localizedIntegerValue = ".123";
50
51 // Expected Values
52 expectedDecimalValue = "123.56";
53 expectedIntegerValue = "123";
54
55
56 defaultValue = new Byte("99");
57 expectedValue = new Byte(expectedIntegerValue);
58
59 }
60
61 /**
62 * Tear down instance variables required by this test case.
63 */
64 @Override
65 public void tearDown() {
66 super.tearDown();
67 }
68
69
70 // ------------------------------------------------------------------------
71
72 /**
73 * Test Converter(defaultValue, locale, pattern, localizedPattern) constructor
74 */
75 public void testConstructorMain() {
76
77 // ------------- Construct with localized pattern ------------
78 converter = new ByteLocaleConverter(defaultValue,
79 localizedLocale,
80 localizedIntegerPattern,
81 true);
82
83
84 convertValueNoPattern(converter, "(A)", localizedIntegerValue, expectedValue);
85 convertValueWithPattern(converter, "(A)", localizedIntegerValue, localizedIntegerPattern, expectedValue);
86 convertInvalid(converter, "(A)", defaultValue);
87 convertNull(converter, "(A)", defaultValue);
88
89
90 // **************************************************************************
91 // Convert value in the wrong format - maybe you would expect it to throw an
92 // exception and return the default - it doesn't, DecimalFormat parses it
93 // quite happily turning ",123" into "0"
94 // I guess this is one of the limitations of DecimalFormat
95 // **************************************************************************
96 convertValueNoPattern(converter, "(B)", defaultIntegerValue, new Byte("0"));
97
98
99 // **************************************************************************
100 // Convert with non-localized pattern
101 // **************************************************************************
102 convertValueWithPattern(converter, "(B)", "123", defaultIntegerPattern, new Byte("123"));
103 convertValueWithPattern(converter, "(B-2)", localizedIntegerValue, defaultIntegerPattern, defaultValue);
104
105
106 // **************************************************************************
107 // Convert with specified type
108 //
109 // BaseLocaleConverter completely ignores the type - so even if we specify
110 // Double.class here it still returns a Byte.
111 // **** This has been changed due to BEANUTILS-449 ****
112 // **************************************************************************
113 //convertValueToType(converter, "(B)", Double.class, localizedIntegerValue, localizedIntegerPattern, expectedValue);
114
115
116 // ------------- Construct with non-localized pattern ------------
117 converter = new ByteLocaleConverter(defaultValue,
118 localizedLocale,
119 defaultIntegerPattern,
120 false);
121
122
123 convertValueNoPattern(converter, "(C)", localizedIntegerValue, expectedValue);
124 convertValueWithPattern(converter, "(C)", localizedIntegerValue, defaultIntegerPattern, expectedValue);
125 convertInvalid(converter, "(C)", defaultValue);
126 convertNull(converter, "(C)", defaultValue);
127
128 }
129
130 /**
131 * Test Converter() constructor
132 *
133 * Uses the default locale, no default value
134 *
135 */
136 public void testConstructor_2() {
137
138 // ------------- Construct using default locale ------------
139 converter = new ByteLocaleConverter();
140
141 // Perform Tests
142 convertValueNoPattern(converter, defaultIntegerValue, expectedValue);
143 convertValueWithPattern(converter, defaultIntegerValue, defaultIntegerPattern, expectedValue);
144 convertInvalid(converter, null);
145 convertNull(converter, null);
146
147 }
148
149 /**
150 * Test Converter(locPattern) constructor
151 *
152 * Uses the default locale, no default value
153 *
154 */
155 public void testConstructor_3() {
156
157 // ------------- Construct using localized pattern (default locale) --------
158 converter = new ByteLocaleConverter(true);
159
160 // Perform Tests
161 convertValueNoPattern(converter, defaultIntegerValue, expectedValue);
162 convertValueWithPattern(converter, defaultIntegerValue, defaultIntegerPattern, expectedValue);
163 convertInvalid(converter, null);
164 convertNull(converter, null);
165
166
167 }
168
169 /**
170 * Test Converter(Locale) constructor
171 */
172 public void testConstructor_4() {
173
174 // ------------- Construct using specified Locale --------
175 converter = new ByteLocaleConverter(localizedLocale);
176
177 // Perform Tests
178 convertValueNoPattern(converter, localizedIntegerValue, expectedValue);
179 convertValueWithPattern(converter, localizedIntegerValue, defaultIntegerPattern, expectedValue);
180 convertInvalid(converter, null);
181 convertNull(converter, null);
182
183
184 }
185
186
187 /**
188 * Test Converter(Locale, locPattern) constructor
189 */
190 public void testConstructor_5() {
191
192 // ------------- Construct using specified Locale --------
193 converter = new ByteLocaleConverter(localizedLocale, true);
194
195 // Perform Tests
196 convertValueNoPattern(converter, localizedIntegerValue, expectedValue);
197 convertValueWithPattern(converter, localizedIntegerValue, localizedIntegerPattern, expectedValue);
198 convertInvalid(converter, null);
199 convertNull(converter, null);
200
201
202 }
203
204 /**
205 * Test Converter(Locale, pattern) constructor
206 */
207 public void testConstructor_6() {
208
209 // ------------- Construct using specified Locale --------
210 converter = new ByteLocaleConverter(localizedLocale, defaultIntegerPattern);
211
212 // Perform Tests
213 convertValueNoPattern(converter, localizedIntegerValue, expectedValue);
214 convertValueWithPattern(converter, localizedIntegerValue, defaultIntegerPattern, expectedValue);
215 convertInvalid(converter, null);
216 convertNull(converter, null);
217
218 }
219
220 /**
221 * Test Converter(Locale, pattern, locPattern) constructor
222 */
223 public void testConstructor_7() {
224
225 // ------------- Construct using specified Locale --------
226 converter = new ByteLocaleConverter(localizedLocale, localizedIntegerPattern, true);
227
228 // Perform Tests
229 convertValueNoPattern(converter, localizedIntegerValue, expectedValue);
230 convertValueWithPattern(converter, localizedIntegerValue, localizedIntegerPattern, expectedValue);
231 convertInvalid(converter, null);
232 convertNull(converter, null);
233
234 }
235
236 /**
237 * Test Converter(defaultValue) constructor
238 */
239 public void testConstructor_8() {
240
241 // ------------- Construct using specified Locale --------
242 converter = new ByteLocaleConverter(defaultValue);
243
244 // Perform Tests
245 convertValueNoPattern(converter, defaultIntegerValue, expectedValue);
246 convertValueWithPattern(converter, defaultIntegerValue, defaultIntegerPattern, expectedValue);
247 convertInvalid(converter, defaultValue);
248 convertNull(converter, defaultValue);
249
250 }
251
252 /**
253 * Test Converter(defaultValue, locPattern) constructor
254 */
255 public void testConstructor_9() {
256
257 // ------------- Construct using specified Locale --------
258 converter = new ByteLocaleConverter(defaultValue, true);
259
260 // Perform Tests
261 convertValueNoPattern(converter, defaultIntegerValue, expectedValue);
262 convertValueWithPattern(converter, defaultIntegerValue, defaultIntegerPattern, expectedValue);
263 convertInvalid(converter, defaultValue);
264 convertNull(converter, defaultValue);
265
266 }
267
268
269
270 }
271