View Javadoc
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;
28  import java.sql.Types;
29  
30  /**
31   * @author Manuel Laflamme
32   * @version $Revision$
33   */
34  
35  public class FloatDataTypeTest extends AbstractDataTypeTest
36  {
37      private final static DataType THIS_TYPE = DataType.REAL;
38  
39      public FloatDataTypeTest(String name)
40      {
41          super(name);
42      }
43  
44      public void testToString() throws Exception
45      {
46          assertEquals("name", "REAL", THIS_TYPE.toString());
47      }
48  
49      public void testGetTypeClass() throws Exception
50      {
51          assertEquals("class", Float.class, THIS_TYPE.getTypeClass());
52      }
53  
54      public void testIsNumber() throws Exception
55      {
56          assertEquals("is number", true, THIS_TYPE.isNumber());
57      }
58  
59      public void testIsDateTime() throws Exception
60      {
61          assertEquals("is date/time", false, THIS_TYPE.isDateTime());
62      }
63  
64      public void testTypeCast() throws Exception
65      {
66          Object[] values = {
67              null,
68              "5.555",
69              new Double(Float.MAX_VALUE),
70              new Double(Float.MIN_VALUE),
71              "-7500",
72              "2.34E3",
73              new Double(0.666),
74              new Double(5.49879),
75              "-99.9",
76              new BigDecimal((double)1234),
77          };
78  
79          Float[] expected = {
80              null,
81              new Float(5.555),
82              new Float(Float.MAX_VALUE),
83              new Float(Float.MIN_VALUE),
84              new Float(-7500),
85              Float.valueOf("2.34E3"),
86              new Float(0.666),
87              new Float(5.49879),
88              new Float(-99.9),
89              new Float(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
102     {
103         assertEquals("typecast", null, THIS_TYPE.typeCast(ITable.NO_VALUE));
104     }
105 
106     public void testTypeCastInvalid() throws Exception
107     {
108         Object[] values = {new Object(), "bla", new java.util.Date()};
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
124     {
125         Object[] values1 = {
126             null,
127             "5.555",
128             new Double(Float.MAX_VALUE),
129             new Double(Float.MIN_VALUE),
130             "-7500",
131             "2.34E3",
132             new Double(0.666),
133             new Double(5.49879),
134             "-99.9",
135             new BigDecimal((double)1234),
136         };
137 
138         Float[] values2 = {
139             null,
140             new Float(5.555),
141             new Float(Float.MAX_VALUE),
142             new Float(Float.MIN_VALUE),
143             new Float(-7500),
144             Float.valueOf("2.34E3"),
145             new Float(0.666),
146             new Float(5.49879),
147             new Float(-99.9),
148             new Float(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
161     {
162         Object[] values1 = {
163             new Object(),
164             "bla",
165             new java.util.Date()
166         };
167         Object[] 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
198     {
199         Object[] less = {
200             null,
201             "-7500",
202             new Double(Float.MIN_VALUE),
203         };
204 
205         Object[] greater = {
206             "0",
207             "5.555",
208             new Float(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
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
228     {
229         assertEquals(THIS_TYPE, DataType.forObject(new Float(1234)));
230     }
231 
232     public void testAsString() throws Exception
233     {
234         Object[] values = {
235             new Float("1234"),
236             new Float("12.34"),
237         };
238 
239         String[] 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
253     {
254         Float[] expected = {
255             null,
256             new Float(5.555),
257             new Float(Float.MAX_VALUE),
258             new Float(Float.MIN_VALUE),
259             new Float(-7500),
260             Float.valueOf("2.34E3"),
261             new Float(0.666),
262             new Float(5.49879),
263             new Float(-99.9),
264             new Float(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 expectedValue = expected[i];
273             Object actualValue = THIS_TYPE.getSqlValue(i + 1, resultSet);
274             assertEquals("value", expectedValue, actualValue);
275         }
276     }
277 }