001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018 package org.apache.commons.beanutils.locale.converters;
019
020
021 /**
022 * Test Case for the DoubleLocaleConverter class.
023 *
024 * @author Niall Pemberton
025 * @version $Revision: 469728 $ $Date: 2006-11-01 01:08:34 +0000 (Wed, 01 Nov 2006) $
026 */
027
028 public class DoubleLocaleConverterTestCase extends BaseLocaleConverterTestCase {
029
030
031
032 // ---------------------------------------------------------- Constructors
033
034 public DoubleLocaleConverterTestCase(String name) {
035 super(name);
036 }
037
038 // -------------------------------------------------- Overall Test Methods
039
040 /**
041 * Set up instance variables required by this test case.
042 */
043 public void setUp() throws Exception {
044
045 super.setUp();
046
047 defaultValue = new Double("9.99");
048 expectedValue = new Double(expectedDecimalValue);
049
050 }
051
052 /**
053 * Tear down instance variables required by this test case.
054 */
055 public void tearDown() {
056 super.tearDown();
057 }
058
059
060 // ------------------------------------------------------------------------
061
062 /**
063 * Test Converter(defaultValue, locale, pattern, localizedPattern) constructor
064 */
065 public void testConstructorMain() {
066
067 // ------------- Construct with localized pattern ------------
068 converter = new DoubleLocaleConverter(defaultValue,
069 localizedLocale,
070 localizedDecimalPattern,
071 true);
072
073
074 convertValueNoPattern(converter, "(A)", localizedDecimalValue, expectedValue);
075 convertValueWithPattern(converter, "(A)", localizedDecimalValue, localizedDecimalPattern, expectedValue);
076 convertInvalid(converter, "(A)", defaultValue);
077 convertNull(converter, "(A)", defaultValue);
078
079
080 // **************************************************************************
081 // Convert value in the wrong format - maybe you would expect it to throw an
082 // exception and return the default - it doesn't, DecimalFormat parses it
083 // quite happily turning "1,234.56" into "1.234"
084 // I guess this is one of the limitations of DecimalFormat
085 // **************************************************************************
086 convertValueNoPattern(converter, "(B)", defaultDecimalValue, new Double("1.234"));
087
088
089 // **************************************************************************
090 // Convert with non-localized pattern - this causes an exception in parse()
091 // but it gets swallowed in convert() method and returns default.
092 // **** IS THIS THE EXPECTED BEHAVIOUR? ****
093 // Maybe if the pattern is no good, we should use a default pattern rather
094 // than just returning the default value.
095 // **************************************************************************
096 convertValueWithPattern(converter, "(B)", localizedDecimalValue, defaultDecimalPattern, defaultValue);
097
098
099 // **************************************************************************
100 // Convert with specified type
101 //
102 // BaseLocaleConverter completely ignores the type - so even if we specify
103 // Double.class here it still returns a Double.
104 // **** SHOULD IMPLEMENT THIS BEHAVIOUR ****
105 // **************************************************************************
106 convertValueToType(converter, "(B)", Integer.class, localizedDecimalValue, localizedDecimalPattern, expectedValue);
107
108
109 // ------------- Construct with non-localized pattern ------------
110 converter = new DoubleLocaleConverter(defaultValue,
111 localizedLocale,
112 defaultDecimalPattern,
113 false);
114
115
116 convertValueNoPattern(converter, "(C)", localizedDecimalValue, expectedValue);
117 convertValueWithPattern(converter, "(C)", localizedDecimalValue, defaultDecimalPattern, expectedValue);
118 convertInvalid(converter, "(C)", defaultValue);
119 convertNull(converter, "(C)", defaultValue);
120
121 }
122
123 /**
124 * Test Converter() constructor
125 *
126 * Uses the default locale, no default value
127 *
128 */
129 public void testConstructor_2() {
130
131 // ------------- Construct using default locale ------------
132 converter = new DoubleLocaleConverter();
133
134 // Perform Tests
135 convertValueNoPattern(converter, defaultDecimalValue, expectedValue);
136 convertValueWithPattern(converter, defaultDecimalValue, defaultDecimalPattern, expectedValue);
137 convertInvalid(converter, null);
138 convertNull(converter, null);
139
140 }
141
142 /**
143 * Test Converter(locPattern) constructor
144 *
145 * Uses the default locale, no default value
146 *
147 */
148 public void testConstructor_3() {
149
150 // ------------- Construct using localized pattern (default locale) --------
151 converter = new DoubleLocaleConverter(true);
152
153 // Perform Tests
154 convertValueNoPattern(converter, defaultDecimalValue, expectedValue);
155 convertValueWithPattern(converter, defaultDecimalValue, defaultDecimalPattern, expectedValue);
156 convertInvalid(converter, null);
157 convertNull(converter, null);
158
159
160 }
161
162 /**
163 * Test Converter(Locale) constructor
164 */
165 public void testConstructor_4() {
166
167 // ------------- Construct using specified Locale --------
168 converter = new DoubleLocaleConverter(localizedLocale);
169
170 // Perform Tests
171 convertValueNoPattern(converter, localizedDecimalValue, expectedValue);
172 convertValueWithPattern(converter, localizedDecimalValue, defaultDecimalPattern, expectedValue);
173 convertInvalid(converter, null);
174 convertNull(converter, null);
175
176
177 }
178
179
180 /**
181 * Test Converter(Locale, locPattern) constructor
182 */
183 public void testConstructor_5() {
184
185 // ------------- Construct using specified Locale --------
186 converter = new DoubleLocaleConverter(localizedLocale, true);
187
188 // Perform Tests
189 convertValueNoPattern(converter, localizedDecimalValue, expectedValue);
190 convertValueWithPattern(converter, localizedDecimalValue, localizedDecimalPattern, expectedValue);
191 convertInvalid(converter, null);
192 convertNull(converter, null);
193
194
195 }
196
197 /**
198 * Test Converter(Locale, pattern) constructor
199 */
200 public void testConstructor_6() {
201
202 // ------------- Construct using specified Locale --------
203 converter = new DoubleLocaleConverter(localizedLocale, defaultDecimalPattern);
204
205 // Perform Tests
206 convertValueNoPattern(converter, localizedDecimalValue, expectedValue);
207 convertValueWithPattern(converter, localizedDecimalValue, defaultDecimalPattern, expectedValue);
208 convertInvalid(converter, null);
209 convertNull(converter, null);
210
211 }
212
213 /**
214 * Test Converter(Locale, pattern, locPattern) constructor
215 */
216 public void testConstructor_7() {
217
218 // ------------- Construct using specified Locale --------
219 converter = new DoubleLocaleConverter(localizedLocale, localizedDecimalPattern, true);
220
221 // Perform Tests
222 convertValueNoPattern(converter, localizedDecimalValue, expectedValue);
223 convertValueWithPattern(converter, localizedDecimalValue, localizedDecimalPattern, expectedValue);
224 convertInvalid(converter, null);
225 convertNull(converter, null);
226
227 }
228
229 /**
230 * Test Converter(defaultValue) constructor
231 */
232 public void testConstructor_8() {
233
234 // ------------- Construct using specified Locale --------
235 converter = new DoubleLocaleConverter(defaultValue);
236
237 // Perform Tests
238 convertValueNoPattern(converter, defaultDecimalValue, expectedValue);
239 convertValueWithPattern(converter, defaultDecimalValue, defaultDecimalPattern, expectedValue);
240 convertInvalid(converter, defaultValue);
241 convertNull(converter, defaultValue);
242
243 }
244
245 /**
246 * Test Converter(defaultValue, locPattern) constructor
247 */
248 public void testConstructor_9() {
249
250 // ------------- Construct using specified Locale --------
251 converter = new DoubleLocaleConverter(defaultValue, true);
252
253 // Perform Tests
254 convertValueNoPattern(converter, defaultDecimalValue, expectedValue);
255 convertValueWithPattern(converter, defaultDecimalValue, defaultDecimalPattern, expectedValue);
256 convertInvalid(converter, defaultValue);
257 convertNull(converter, defaultValue);
258
259 }
260
261
262
263 }
264