001: /*******************************************************************************
002: * Copyright (c) 2007 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: ******************************************************************************/package org.eclipse.core.tests.databinding;
011:
012: import java.math.BigDecimal;
013: import java.math.BigInteger;
014: import java.util.Date;
015:
016: import org.eclipse.core.databinding.UpdateValueStrategy;
017: import org.eclipse.core.databinding.conversion.IConverter;
018: import org.eclipse.core.databinding.conversion.NumberToStringConverter;
019: import org.eclipse.core.databinding.conversion.StringToNumberConverter;
020: import org.eclipse.core.databinding.observable.value.IObservableValue;
021: import org.eclipse.core.databinding.observable.value.WritableValue;
022: import org.eclipse.core.internal.databinding.conversion.DateToStringConverter;
023: import org.eclipse.core.internal.databinding.conversion.IdentityConverter;
024: import org.eclipse.core.internal.databinding.conversion.IntegerToStringConverter;
025: import org.eclipse.core.internal.databinding.conversion.NumberToBigDecimalConverter;
026: import org.eclipse.core.internal.databinding.conversion.NumberToBigIntegerConverter;
027: import org.eclipse.core.internal.databinding.conversion.NumberToByteConverter;
028: import org.eclipse.core.internal.databinding.conversion.NumberToDoubleConverter;
029: import org.eclipse.core.internal.databinding.conversion.NumberToFloatConverter;
030: import org.eclipse.core.internal.databinding.conversion.NumberToIntegerConverter;
031: import org.eclipse.core.internal.databinding.conversion.NumberToLongConverter;
032: import org.eclipse.core.internal.databinding.conversion.NumberToShortConverter;
033: import org.eclipse.core.internal.databinding.conversion.StatusToStringConverter;
034: import org.eclipse.core.internal.databinding.conversion.StringToBooleanConverter;
035: import org.eclipse.core.internal.databinding.conversion.StringToBooleanPrimitiveConverter;
036: import org.eclipse.core.internal.databinding.conversion.StringToByteConverter;
037: import org.eclipse.core.internal.databinding.conversion.StringToCharacterConverter;
038: import org.eclipse.core.internal.databinding.conversion.StringToDateConverter;
039: import org.eclipse.core.internal.databinding.conversion.StringToShortConverter;
040: import org.eclipse.core.runtime.IStatus;
041: import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
042:
043: /**
044: * @since 1.1
045: */
046: public class UpdateStrategyTest extends AbstractDefaultRealmTestCase {
047: public void testDefaultConverterForStringToInteger()
048: throws Exception {
049: assertDefaultConverter(String.class, Integer.class,
050: StringToNumberConverter.class);
051: }
052:
053: public void testDefaultConverterForStringToIntegerPrimitive()
054: throws Exception {
055: assertDefaultConverter(String.class, Integer.TYPE,
056: StringToNumberConverter.class);
057: }
058:
059: public void testDefaultConverterForStringToLong() throws Exception {
060: assertDefaultConverter(String.class, Long.class,
061: StringToNumberConverter.class);
062: }
063:
064: public void testDefaultConverterForStringToLongPrimitive()
065: throws Exception {
066: assertDefaultConverter(String.class, Long.TYPE,
067: StringToNumberConverter.class);
068: }
069:
070: public void testDefaultConverterForStringToDouble()
071: throws Exception {
072: assertDefaultConverter(String.class, Double.class,
073: StringToNumberConverter.class);
074: }
075:
076: public void testDefaultConverterForStringToDoublePrimitive()
077: throws Exception {
078: assertDefaultConverter(String.class, Double.TYPE,
079: StringToNumberConverter.class);
080: }
081:
082: public void testDefaultConverterForStringToFloat() throws Exception {
083: assertDefaultConverter(String.class, Float.class,
084: StringToNumberConverter.class);
085: }
086:
087: public void testDefaultConverterForStringToFloatPrimitive()
088: throws Exception {
089: assertDefaultConverter(String.class, Float.TYPE,
090: StringToNumberConverter.class);
091: }
092:
093: public void testDefaultConverterForStringToBigInteger()
094: throws Exception {
095: assertDefaultConverter(String.class, BigInteger.class,
096: StringToNumberConverter.class);
097: }
098:
099: public void testDefaultConverterForIntegerToString()
100: throws Exception {
101: assertDefaultConverter(Integer.class, String.class,
102: NumberToStringConverter.class);
103: }
104:
105: public void testDefaultConverterForIntegerPrimitiveToString()
106: throws Exception {
107: assertDefaultConverter(Integer.TYPE, String.class,
108: NumberToStringConverter.class);
109: }
110:
111: public void testDefaultConverterForLongToString() throws Exception {
112: assertDefaultConverter(Long.class, String.class,
113: NumberToStringConverter.class);
114: }
115:
116: public void testDefaultConverterForLongPrimitiveToString()
117: throws Exception {
118: assertDefaultConverter(Long.TYPE, String.class,
119: NumberToStringConverter.class);
120: }
121:
122: public void testDefaultConverterForDoubleToString()
123: throws Exception {
124: assertDefaultConverter(Double.class, String.class,
125: NumberToStringConverter.class);
126: }
127:
128: public void testDefaultConverterForDoublePrimitiveToString()
129: throws Exception {
130: assertDefaultConverter(Double.TYPE, String.class,
131: NumberToStringConverter.class);
132: }
133:
134: public void testDefaultConverterForFloatToString() throws Exception {
135: assertDefaultConverter(Float.class, String.class,
136: NumberToStringConverter.class);
137: }
138:
139: public void testDefaultConverterForFloatPrimitiveToString()
140: throws Exception {
141: assertDefaultConverter(Float.TYPE, String.class,
142: NumberToStringConverter.class);
143: }
144:
145: public void testDefaultConverterForBigIntegerToString()
146: throws Exception {
147: assertDefaultConverter(BigInteger.class, String.class,
148: NumberToStringConverter.class);
149: }
150:
151: public void testDefaultConverterForDateToString() throws Exception {
152: assertDefaultConverter(Date.class, String.class,
153: DateToStringConverter.class);
154: }
155:
156: public void testDefaultConverterForStringToBoolean()
157: throws Exception {
158: assertDefaultConverter(String.class, Boolean.class,
159: StringToBooleanConverter.class);
160: }
161:
162: public void testDefaultConverterForStringToBooleanPrimitive()
163: throws Exception {
164: assertDefaultConverter(String.class, Boolean.TYPE,
165: StringToBooleanPrimitiveConverter.class);
166: }
167:
168: public void testDefaultConverterForStringToByte() throws Exception {
169: assertDefaultConverter(String.class, Byte.class,
170: StringToByteConverter.class);
171: }
172:
173: public void testDefaultConverterForStringToBytePrimitive()
174: throws Exception {
175: assertDefaultConverter(String.class, Byte.TYPE,
176: StringToByteConverter.class);
177: }
178:
179: public void testDefaultConverterForStringToCharacter()
180: throws Exception {
181: assertDefaultConverter(String.class, Character.class,
182: StringToCharacterConverter.class);
183: }
184:
185: public void testDefaultConverterForStringToDate() throws Exception {
186: assertDefaultConverter(String.class, Date.class,
187: StringToDateConverter.class);
188: }
189:
190: public void testDefaultConverterForStringToShort() throws Exception {
191: assertDefaultConverter(String.class, Short.class,
192: StringToShortConverter.class);
193: }
194:
195: public void testDefaultConverterForStringToShortPrimitive()
196: throws Exception {
197: assertDefaultConverter(String.class, Short.TYPE,
198: StringToShortConverter.class);
199: }
200:
201: public void testDefaultConverterForByteToString() throws Exception {
202: assertDefaultConverter(Byte.class, String.class,
203: IntegerToStringConverter.class);
204: }
205:
206: public void testDefaultConverterForBytePrimitiveToString()
207: throws Exception {
208: assertDefaultConverter(Byte.TYPE, String.class,
209: IntegerToStringConverter.class);
210: }
211:
212: public void testDefaultConverterForShortToString() throws Exception {
213: assertDefaultConverter(Short.class, String.class,
214: IntegerToStringConverter.class);
215: }
216:
217: public void testDefaultConverterForShortPrimitiveToString()
218: throws Exception {
219: assertDefaultConverter(Short.TYPE, String.class,
220: IntegerToStringConverter.class);
221: }
222:
223: public void testDefaultConverterForStatusToString()
224: throws Exception {
225: assertDefaultConverter(IStatus.class, String.class,
226: StatusToStringConverter.class);
227: }
228:
229: public void testDefaultConverterForNumberToByte() throws Exception {
230: assertFromNumberToNumberConverter(Byte.class, Byte.TYPE,
231: NumberToByteConverter.class);
232: }
233:
234: public void testDefaultConverterForNumberToShort() throws Exception {
235: assertFromNumberToNumberConverter(Short.class, Short.TYPE,
236: NumberToShortConverter.class);
237: }
238:
239: public void testDefaultConverterForNumberToShortPrimitive()
240: throws Exception {
241: assertFromNumberToNumberConverter(Short.TYPE, Short.class,
242: NumberToShortConverter.class);
243: }
244:
245: public void testDefaultConverterForNumberToInteger()
246: throws Exception {
247: assertFromNumberToNumberConverter(Integer.class, Integer.TYPE,
248: NumberToIntegerConverter.class);
249: }
250:
251: public void testDefaultConverterForNumberToIntegerPrimitive()
252: throws Exception {
253: assertFromNumberToNumberConverter(Integer.TYPE, Integer.class,
254: NumberToIntegerConverter.class);
255: }
256:
257: public void testDefaultConverterForNumberToLong() throws Exception {
258: assertFromNumberToNumberConverter(Long.class, Long.TYPE,
259: NumberToLongConverter.class);
260: }
261:
262: public void testDefaultConverterForNumberToLongPrimitive()
263: throws Exception {
264: assertFromNumberToNumberConverter(Long.TYPE, Long.class,
265: NumberToLongConverter.class);
266: }
267:
268: public void testDefaultConverterForNumberToFloat() throws Exception {
269: assertFromNumberToNumberConverter(Float.class, Float.TYPE,
270: NumberToFloatConverter.class);
271: }
272:
273: public void testDefaultConverterForNumberToFloatPrimitive()
274: throws Exception {
275: assertFromNumberToNumberConverter(Float.TYPE, Float.class,
276: NumberToFloatConverter.class);
277: }
278:
279: public void testDefaultConverterForNumberToDouble()
280: throws Exception {
281: assertFromNumberToNumberConverter(Double.class, Double.TYPE,
282: NumberToDoubleConverter.class);
283: }
284:
285: public void testDefaultConverterForNumberToDoublePrimitive()
286: throws Exception {
287: assertFromNumberToNumberConverter(Double.TYPE, Double.class,
288: NumberToDoubleConverter.class);
289: }
290:
291: public void testDefaultConverterForNumberToBigInteger()
292: throws Exception {
293: assertFromNumberToNumberConverter(BigInteger.class, null,
294: NumberToBigIntegerConverter.class);
295: }
296:
297: public void testDefaultConverterForNumberToBigDecimal()
298: throws Exception {
299: assertFromNumberToNumberConverter(BigDecimal.class, null,
300: NumberToBigDecimalConverter.class);
301: }
302:
303: private static Class[] primitiveNumberTypes = new Class[] {
304: Byte.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE,
305: Double.TYPE };
306:
307: private static Class[] boxedNumberTypes = new Class[] { Byte.class,
308: Short.class, Integer.class, Long.class, Float.class,
309: Double.class, BigInteger.class, BigDecimal.class };
310:
311: private void assertFromNumberToNumberConverter(Class toType,
312: Class toCounterPrimitiveType, Class converterType) {
313:
314: for (int i = 0; i < primitiveNumberTypes.length; i++) {
315: Class primitiveType = primitiveNumberTypes[i];
316:
317: if (!primitiveType.equals(toType)
318: && !primitiveType.equals(toCounterPrimitiveType)) {
319: assertDefaultConverter(primitiveType, toType,
320: converterType);
321: } else if (!primitiveType.equals(toType)) {
322: assertDefaultConverter(primitiveType, toType,
323: IdentityConverter.class);
324: }
325: }
326:
327: for (int i = 0; i < boxedNumberTypes.length; i++) {
328: Class boxedType = boxedNumberTypes[i];
329:
330: if (!boxedType.equals(toType)
331: && !boxedType.equals(toCounterPrimitiveType)) {
332: assertDefaultConverter(boxedType, toType, converterType);
333: } else if (!boxedType.equals(toType)) {
334: assertDefaultConverter(boxedType, toType,
335: IdentityConverter.class);
336: }
337: }
338: }
339:
340: private void assertDefaultConverter(Class fromType, Class toType,
341: Class converterType) {
342: WritableValue source = WritableValue.withValueType(fromType);
343: WritableValue destination = WritableValue.withValueType(toType);
344:
345: UpdateStrategyStub strategy = new UpdateStrategyStub();
346: strategy.fillDefaults(source, destination);
347:
348: IConverter converter = strategy.converter;
349: assertNotNull("converter not null", converter);
350: assertEquals("fromType [" + fromType + "]", fromType, converter
351: .getFromType());
352: assertEquals("toType [" + toType + "]", toType, converter
353: .getToType());
354: assertTrue("converter should be instanceof " + converterType
355: + " but was instanceof " + converter.getClass(),
356: converterType.isInstance(converter));
357: }
358:
359: class UpdateStrategyStub extends UpdateValueStrategy {
360: IConverter converter;
361:
362: protected void fillDefaults(IObservableValue source,
363: IObservableValue destination) {
364: super .fillDefaults(source, destination);
365: }
366:
367: /* (non-Javadoc)
368: * @see org.eclipse.core.databinding.UpdateValueStrategy#setConverter(org.eclipse.core.databinding.conversion.IConverter)
369: */
370: public UpdateValueStrategy setConverter(IConverter converter) {
371: this.converter = converter;
372: return super.setConverter(converter);
373: }
374: }
375: }
|