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: import java.math.BigDecimal;
021:
022: /**
023: * Test Case for the BigDecimalLocaleConverter class.
024: *
025: * @author Niall Pemberton
026: * @version $Revision: 469728 $ $Date: 2006-11-01 01:08:34 +0000 (Wed, 01 Nov 2006) $
027: */
028:
029: public class BigDecimalLocaleConverterTestCase extends
030: BaseLocaleConverterTestCase {
031:
032: // ---------------------------------------------------------- Constructors
033:
034: public BigDecimalLocaleConverterTestCase(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 BigDecimal("9.99");
048: expectedValue = new BigDecimal(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: * Test Converter(defaultValue, locale, pattern, localizedPattern) constructor
063: */
064: public void testConstructorMain() {
065:
066: // ------------- Construct with localized pattern ------------
067: converter = new BigDecimalLocaleConverter(defaultValue,
068: localizedLocale, localizedDecimalPattern, true);
069:
070: convertValueNoPattern(converter, "(A)", localizedDecimalValue,
071: expectedValue);
072: convertValueWithPattern(converter, "(A)",
073: localizedDecimalValue, localizedDecimalPattern,
074: expectedValue);
075: convertInvalid(converter, "(A)", defaultValue);
076: convertNull(converter, "(A)", defaultValue);
077:
078: // **************************************************************************
079: // Convert value in the wrong format - maybe you would expect it to throw an
080: // exception and return the default - it doesn't, DecimalFormat parses it
081: // quite happily turning "1,234.56" into "1.234"
082: // I guess this is one of the limitations of DecimalFormat
083: // **************************************************************************
084: convertValueNoPattern(converter, "(B)", defaultDecimalValue,
085: new BigDecimal("1.234"));
086:
087: // **************************************************************************
088: // Convert with non-localized pattern - this causes an exception in parse()
089: // but it gets swallowed in convert() method and returns default.
090: // **** IS THIS THE EXPECTED BEHAVIOUR? ****
091: // Maybe if the pattern is no good, we should use a default pattern rather
092: // than just returning the default value.
093: // **************************************************************************
094: convertValueWithPattern(converter, "(B)",
095: localizedDecimalValue, defaultDecimalPattern,
096: defaultValue);
097:
098: // **************************************************************************
099: // Convert with specified type
100: //
101: // BaseLocaleConverter completely ignores the type - so even if we specify
102: // Double.class here it still returns a BigDecimal.
103: // **** SHOULD IMPLEMENT THIS BEHAVIOUR ****
104: // **************************************************************************
105: convertValueToType(converter, "(B)", Double.class,
106: localizedDecimalValue, localizedDecimalPattern,
107: expectedValue);
108:
109: // ------------- Construct with non-localized pattern ------------
110: converter = new BigDecimalLocaleConverter(defaultValue,
111: localizedLocale, defaultDecimalPattern, false);
112:
113: convertValueNoPattern(converter, "(C)", localizedDecimalValue,
114: expectedValue);
115: convertValueWithPattern(converter, "(C)",
116: localizedDecimalValue, defaultDecimalPattern,
117: 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 BigDecimalLocaleConverter();
133:
134: // Perform Tests
135: convertValueNoPattern(converter, defaultDecimalValue,
136: expectedValue);
137: convertValueWithPattern(converter, defaultDecimalValue,
138: defaultDecimalPattern, expectedValue);
139: convertInvalid(converter, null);
140: convertNull(converter, null);
141:
142: }
143:
144: /**
145: * Test Converter(locPattern) constructor
146: *
147: * Uses the default locale, no default value
148: *
149: */
150: public void testConstructor_3() {
151:
152: // ------------- Construct using localized pattern (default locale) --------
153: converter = new BigDecimalLocaleConverter(true);
154:
155: // Perform Tests
156: convertValueNoPattern(converter, defaultDecimalValue,
157: expectedValue);
158: convertValueWithPattern(converter, defaultDecimalValue,
159: defaultDecimalPattern, expectedValue);
160: convertInvalid(converter, null);
161: convertNull(converter, null);
162:
163: }
164:
165: /**
166: * Test Converter(Locale) constructor
167: */
168: public void testConstructor_4() {
169:
170: // ------------- Construct using specified Locale --------
171: converter = new BigDecimalLocaleConverter(localizedLocale);
172:
173: // Perform Tests
174: convertValueNoPattern(converter, localizedDecimalValue,
175: expectedValue);
176: convertValueWithPattern(converter, localizedDecimalValue,
177: defaultDecimalPattern, expectedValue);
178: convertInvalid(converter, null);
179: convertNull(converter, null);
180:
181: }
182:
183: /**
184: * Test Converter(Locale, locPattern) constructor
185: */
186: public void testConstructor_5() {
187:
188: // ------------- Construct using specified Locale --------
189: converter = new BigDecimalLocaleConverter(localizedLocale, true);
190:
191: // Perform Tests
192: convertValueNoPattern(converter, localizedDecimalValue,
193: expectedValue);
194: convertValueWithPattern(converter, localizedDecimalValue,
195: localizedDecimalPattern, expectedValue);
196: convertInvalid(converter, null);
197: convertNull(converter, null);
198:
199: }
200:
201: /**
202: * Test Converter(Locale, pattern) constructor
203: */
204: public void testConstructor_6() {
205:
206: // ------------- Construct using specified Locale --------
207: converter = new BigDecimalLocaleConverter(localizedLocale,
208: defaultDecimalPattern);
209:
210: // Perform Tests
211: convertValueNoPattern(converter, localizedDecimalValue,
212: expectedValue);
213: convertValueWithPattern(converter, localizedDecimalValue,
214: defaultDecimalPattern, 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 BigDecimalLocaleConverter(localizedLocale,
227: localizedDecimalPattern, true);
228:
229: // Perform Tests
230: convertValueNoPattern(converter, localizedDecimalValue,
231: expectedValue);
232: convertValueWithPattern(converter, localizedDecimalValue,
233: localizedDecimalPattern, expectedValue);
234: convertInvalid(converter, null);
235: convertNull(converter, null);
236:
237: }
238:
239: /**
240: * Test Converter(defaultValue) constructor
241: */
242: public void testConstructor_8() {
243:
244: // ------------- Construct using specified Locale --------
245: converter = new BigDecimalLocaleConverter(defaultValue);
246:
247: // Perform Tests
248: convertValueNoPattern(converter, defaultDecimalValue,
249: expectedValue);
250: convertValueWithPattern(converter, defaultDecimalValue,
251: defaultDecimalPattern, expectedValue);
252: convertInvalid(converter, defaultValue);
253: convertNull(converter, defaultValue);
254:
255: }
256:
257: /**
258: * Test Converter(defaultValue, locPattern) constructor
259: */
260: public void testConstructor_9() {
261:
262: // ------------- Construct using specified Locale --------
263: converter = new BigDecimalLocaleConverter(defaultValue, true);
264:
265: // Perform Tests
266: convertValueNoPattern(converter, defaultDecimalValue,
267: expectedValue);
268: convertValueWithPattern(converter, defaultDecimalValue,
269: defaultDecimalPattern, expectedValue);
270: convertInvalid(converter, defaultValue);
271: convertNull(converter, defaultValue);
272:
273: }
274:
275: }
|