KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > dbunit > dataset > datatype > FloatDataTypeTest


1 /*
2  *
3  * The DbUnit Database Testing Framework
4  * Copyright (C)2002-2004, DbUnit.org
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  *
20  */

21
22 package org.dbunit.dataset.datatype;
23
24 import org.dbunit.database.ExtendedMockSingleRowResultSet;
25 import org.dbunit.dataset.ITable;
26
27 import java.math.BigDecimal JavaDoc;
28 import java.sql.Types JavaDoc;
29
30 /**
31  * @author Manuel Laflamme
32  * @version $Revision: 1.12 $
33  */

34
35 public class FloatDataTypeTest extends AbstractDataTypeTest
36 {
37     private final static DataType THIS_TYPE = DataType.REAL;
38
39     public FloatDataTypeTest(String JavaDoc name)
40     {
41         super(name);
42     }
43
44     public void testToString() throws Exception JavaDoc
45     {
46         assertEquals("name", "REAL", THIS_TYPE.toString());
47     }
48
49     public void testGetTypeClass() throws Exception JavaDoc
50     {
51         assertEquals("class", Float JavaDoc.class, THIS_TYPE.getTypeClass());
52     }
53
54     public void testIsNumber() throws Exception JavaDoc
55     {
56         assertEquals("is number", true, THIS_TYPE.isNumber());
57     }
58
59     public void testIsDateTime() throws Exception JavaDoc
60     {
61         assertEquals("is date/time", false, THIS_TYPE.isDateTime());
62     }
63
64     public void testTypeCast() throws Exception JavaDoc
65     {
66         Object JavaDoc[] values = {
67             null,
68             "5.555",
69             new Double JavaDoc(Float.MAX_VALUE),
70             new Double JavaDoc(Float.MIN_VALUE),
71             "-7500",
72             "2.34E3",
73             new Double JavaDoc(0.666),
74             new Double JavaDoc(5.49879),
75             "-99.9",
76             new BigDecimal JavaDoc(1234),
77         };
78
79         Float JavaDoc[] expected = {
80             null,
81             new Float JavaDoc(5.555),
82             new Float JavaDoc(Float.MAX_VALUE),
83             new Float JavaDoc(Float.MIN_VALUE),
84             new Float JavaDoc(-7500),
85             Float.valueOf("2.34E3"),
86             new Float JavaDoc(0.666),
87             new Float JavaDoc(5.49879),
88             new Float JavaDoc(-99.9),
89             new Float JavaDoc(1234),
90         };
91
92         assertEquals("actual vs expected count", values.length, expected.length);
93
94         for (int i = 0; i < values.length; i++)
95         {
96             assertEquals("typecast " + i, expected[i],
97                     THIS_TYPE.typeCast(values[i]));
98         }
99     }
100
101     public void testTypeCastNone() throws Exception JavaDoc
102     {
103         assertEquals("typecast", null, THIS_TYPE.typeCast(ITable.NO_VALUE));
104     }
105
106     public void testTypeCastInvalid() throws Exception JavaDoc
107     {
108         Object JavaDoc[] values = {new Object JavaDoc(), "bla", new java.util.Date JavaDoc()};
109
110         for (int i = 0; i < values.length; i++)
111         {
112             try
113             {
114                 THIS_TYPE.typeCast(values[i]);
115                 fail("Should throw TypeCastException");
116             }
117             catch (TypeCastException e)
118             {
119             }
120         }
121     }
122
123     public void testCompareEquals() throws Exception JavaDoc
124     {
125         Object JavaDoc[] values1 = {
126             null,
127             "5.555",
128             new Double JavaDoc(Float.MAX_VALUE),
129             new Double JavaDoc(Float.MIN_VALUE),
130             "-7500",
131             "2.34E3",
132             new Double JavaDoc(0.666),
133             new Double JavaDoc(5.49879),
134             "-99.9",
135             new BigDecimal JavaDoc(1234),
136         };
137
138         Float JavaDoc[] values2 = {
139             null,
140             new Float JavaDoc(5.555),
141             new Float JavaDoc(Float.MAX_VALUE),
142             new Float JavaDoc(Float.MIN_VALUE),
143             new Float JavaDoc(-7500),
144             Float.valueOf("2.34E3"),
145             new Float JavaDoc(0.666),
146             new Float JavaDoc(5.49879),
147             new Float JavaDoc(-99.9),
148             new Float JavaDoc(1234),
149         };
150
151         assertEquals("values count", values1.length, values2.length);
152
153         for (int i = 0; i < values1.length; i++)
154         {
155             assertEquals("compare1 " + i, 0, THIS_TYPE.compare(values1[i], values2[i]));
156             assertEquals("compare2 " + i, 0, THIS_TYPE.compare(values2[i], values1[i]));
157         }
158     }
159
160     public void testCompareInvalid() throws Exception JavaDoc
161     {
162         Object JavaDoc[] values1 = {
163             new Object JavaDoc(),
164             "bla",
165             new java.util.Date JavaDoc()
166         };
167         Object JavaDoc[] values2 = {
168             null,
169             null,
170             null
171         };
172
173         assertEquals("values count", values1.length, values2.length);
174
175         for (int i = 0; i < values1.length; i++)
176         {
177             try
178             {
179                 THIS_TYPE.compare(values1[i], values2[i]);
180                 fail("Should throw TypeCastException");
181             }
182             catch (TypeCastException e)
183             {
184             }
185
186             try
187             {
188                 THIS_TYPE.compare(values2[i], values1[i]);
189                 fail("Should throw TypeCastException");
190             }
191             catch (TypeCastException e)
192             {
193             }
194         }
195     }
196
197     public void testCompareDifferent() throws Exception JavaDoc
198     {
199         Object JavaDoc[] less = {
200             null,
201             "-7500",
202             new Double JavaDoc(Float.MIN_VALUE),
203         };
204
205         Object JavaDoc[] greater = {
206             "0",
207             "5.555",
208             new Float JavaDoc(Float.MAX_VALUE),
209         };
210
211         assertEquals("values count", less.length, greater.length);
212
213         for (int i = 0; i < less.length; i++)
214         {
215             assertTrue("less " + i, THIS_TYPE.compare(less[i], greater[i]) < 0);
216             assertTrue("greater " + i, THIS_TYPE.compare(greater[i], less[i]) > 0);
217         }
218     }
219
220     public void testSqlType() throws Exception JavaDoc
221     {
222         assertEquals(THIS_TYPE, DataType.forSqlType(Types.REAL));
223         assertEquals("forSqlTypeName", THIS_TYPE, DataType.forSqlTypeName(THIS_TYPE.toString()));
224         assertEquals(Types.REAL, THIS_TYPE.getSqlType());
225     }
226
227     public void testForObject() throws Exception JavaDoc
228     {
229         assertEquals(THIS_TYPE, DataType.forObject(new Float JavaDoc(1234)));
230     }
231
232     public void testAsString() throws Exception JavaDoc
233     {
234         Object JavaDoc[] values = {
235             new Float JavaDoc("1234"),
236             new Float JavaDoc("12.34"),
237         };
238
239         String JavaDoc[] expected = {
240             "1234.0",
241             "12.34",
242         };
243
244         assertEquals("actual vs expected count", values.length, expected.length);
245
246         for (int i = 0; i < values.length; i++)
247         {
248             assertEquals("asString " + i, expected[i], DataType.asString(values[i]));
249         }
250     }
251
252     public void testGetSqlValue() throws Exception JavaDoc
253     {
254         Float JavaDoc[] expected = {
255             null,
256             new Float JavaDoc(5.555),
257             new Float JavaDoc(Float.MAX_VALUE),
258             new Float JavaDoc(Float.MIN_VALUE),
259             new Float JavaDoc(-7500),
260             Float.valueOf("2.34E3"),
261             new Float JavaDoc(0.666),
262             new Float JavaDoc(5.49879),
263             new Float JavaDoc(-99.9),
264             new Float JavaDoc(1234),
265         };
266
267         ExtendedMockSingleRowResultSet resultSet = new ExtendedMockSingleRowResultSet();
268         resultSet.addExpectedIndexedValues(expected);
269
270         for (int i = 0; i < expected.length; i++)
271         {
272             Object JavaDoc expectedValue = expected[i];
273             Object JavaDoc actualValue = THIS_TYPE.getSqlValue(i + 1, resultSet);
274             assertEquals("value", expectedValue, actualValue);
275         }
276     }
277 }
278
Popular Tags