KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > commons > beanutils > DynaRowSetTestCase


1 /*
2  * Copyright 2001-2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17
18 package org.apache.commons.beanutils;
19
20
21 import java.lang.reflect.InvocationTargetException JavaDoc;
22 import java.math.BigDecimal JavaDoc;
23 import java.util.ArrayList JavaDoc;
24 import java.util.HashMap JavaDoc;
25 import java.util.Iterator JavaDoc;
26 import java.util.List JavaDoc;
27 import java.util.Map JavaDoc;
28
29 import junit.framework.TestCase;
30 import junit.framework.Test;
31 import junit.framework.TestSuite;
32
33
34 /**
35  * Test accessing RowSets via DynaBeans.
36  *
37  * @author Craig R. McClanahan
38  * @version $Revision: 1.5 $ $Date: 2004/02/28 13:18:36 $
39  */
40
41 public class DynaRowSetTestCase extends TestCase {
42
43
44     // ----------------------------------------------------- Instance Variables
45
46
47     /**
48      * The mock result set DynaClass to be tested.
49      */
50     protected RowSetDynaClass dynaClass = null;
51
52
53     /**
54      * Names of the columns for this test. Must match the order they are
55      * defined in {@link TestResultSetMetaData}, and must be all lower case.
56      */
57     protected String JavaDoc columns[] =
58     { "bigdecimalproperty", "booleanproperty",
59       "byteproperty", "dateproperty",
60       "doubleproperty", "floatproperty",
61       "intproperty", "longproperty",
62       "nullproperty", "shortproperty",
63       "stringproperty", "timeproperty",
64       "timestampproperty" };
65
66
67     // ----------------------------------------------------------- Constructors
68
69
70     /**
71      * Construct a new instance of this test case.
72      *
73      * @param name Name of the test case
74      */
75     public DynaRowSetTestCase(String JavaDoc name) {
76
77         super(name);
78
79     }
80
81
82     // --------------------------------------------------- Overall Test Methods
83
84
85     /**
86      * Set up instance variables required by this test case.
87      */
88     public void setUp() throws Exception JavaDoc {
89
90         dynaClass = new RowSetDynaClass(new TestResultSet());
91
92     }
93
94
95     /**
96      * Return the tests included in this test suite.
97      */
98     public static Test suite() {
99
100         return (new TestSuite(DynaRowSetTestCase.class));
101
102     }
103
104
105     /**
106      * Tear down instance variables required by this test case.
107      */
108     public void tearDown() {
109
110         dynaClass = null;
111
112     }
113
114
115
116     // ------------------------------------------------ Individual Test Methods
117
118
119     public void testGetName() {
120
121         assertEquals("DynaClass name",
122                      "org.apache.commons.beanutils.RowSetDynaClass",
123                      dynaClass.getName());
124
125
126     }
127
128
129     public void testGetDynaProperty() {
130
131         // Invalid argument test
132 try {
133             dynaClass.getDynaProperty(null);
134             fail("Did not throw IllegaArgumentException");
135         } catch (IllegalArgumentException JavaDoc e) {
136             ; // Expected result
137 }
138
139         // Negative test
140 DynaProperty dynaProp = dynaClass.getDynaProperty("unknownProperty");
141         assertTrue("unknown property returns null",
142                    (dynaProp == null));
143
144         // Positive test
145 dynaProp = dynaClass.getDynaProperty("stringproperty");
146         assertNotNull("string property exists", dynaProp);
147         assertEquals("string property name", "stringproperty",
148                      dynaProp.getName());
149         assertEquals("string property class", String JavaDoc.class,
150                      dynaProp.getType());
151
152     }
153
154
155     public void testGetDynaProperties() {
156
157         DynaProperty dynaProps[] = dynaClass.getDynaProperties();
158         assertNotNull("dynaProps exists", dynaProps);
159         assertEquals("dynaProps length", columns.length, dynaProps.length);
160         for (int i = 0; i < columns.length; i++) {
161             assertEquals("Property " + columns[i],
162                          columns[i], dynaProps[i].getName());
163         }
164
165     }
166
167
168     public void testNewInstance() {
169
170         try {
171             dynaClass.newInstance();
172             fail("Did not throw UnsupportedOperationException()");
173         } catch (UnsupportedOperationException JavaDoc e) {
174             ; // Expected result
175 } catch (Exception JavaDoc e) {
176             fail("Threw exception " + e);
177         }
178
179     }
180
181
182     public void testListCount() {
183
184         List JavaDoc rows = dynaClass.getRows();
185         assertNotNull("list exists", rows);
186         assertEquals("list row count", 5, rows.size());
187
188     }
189
190
191     public void testListResults() {
192
193         // Grab the third row
194 List JavaDoc rows = dynaClass.getRows();
195         DynaBean row = (DynaBean) rows.get(2);
196
197         // Invalid argument test
198 try {
199             row.get("unknownProperty");
200             fail("Did not throw IllegalArgumentException");
201         } catch (IllegalArgumentException JavaDoc e) {
202             ; // Expected result
203 }
204
205         // Verify property values
206
207         Object JavaDoc bigDecimalProperty = row.get("bigdecimalproperty");
208         assertNotNull("bigDecimalProperty exists", bigDecimalProperty);
209         assertTrue("bigDecimalProperty type",
210                    bigDecimalProperty instanceof BigDecimal JavaDoc);
211         assertEquals("bigDecimalProperty value",
212                      123.45,
213                      ((BigDecimal JavaDoc) bigDecimalProperty).doubleValue(),
214                      0.005);
215
216         Object JavaDoc intProperty = row.get("intproperty");
217         assertNotNull("intProperty exists", intProperty);
218         assertTrue("intProperty type",
219                    intProperty instanceof Integer JavaDoc);
220         assertEquals("intProperty value",
221                      103,
222                      ((Integer JavaDoc) intProperty).intValue());
223
224         Object JavaDoc nullProperty = row.get("nullproperty");
225         assertNull("nullProperty null", nullProperty);
226
227         Object JavaDoc stringProperty = row.get("stringproperty");
228         assertNotNull("stringProperty exists", stringProperty);
229         assertTrue("stringProperty type",
230                    stringProperty instanceof String JavaDoc);
231         assertEquals("stringProperty value",
232                      "This is a string",
233                      (String JavaDoc) stringProperty);
234
235
236     }
237
238     public void testLimitedRows() throws Exception JavaDoc {
239         
240         // created one with low limit
241 RowSetDynaClass limitedDynaClass = new RowSetDynaClass(new TestResultSet(), 3);
242         List JavaDoc rows = limitedDynaClass.getRows();
243         assertNotNull("list exists", rows);
244         assertEquals("limited row count", 3, rows.size());
245         
246     }
247 }
248
Popular Tags