KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > db4o > test > legacy > soda > SodaTest


1 /* Copyright (C) 2004 - 2006 db4objects Inc. http://www.db4o.com
2
3 This file is part of the db4o open source object database.
4
5 db4o is free software; you can redistribute it and/or modify it under
6 the terms of version 2 of the GNU General Public License as published
7 by the Free Software Foundation and as clarified by db4objects' GPL
8 interpretation policy, available at
9 http://www.db4o.com/about/company/legalpolicies/gplinterpretation/
10 Alternatively you can write to db4objects, Inc., 1900 S Norfolk Street,
11 Suite 350, San Mateo, CA 94403, USA.
12
13 db4o is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */

21 package com.db4o.test.legacy.soda;
22
23 import java.lang.reflect.*;
24
25 import com.db4o.*;
26 import com.db4o.foundation.*;
27 import com.db4o.query.*;
28 import com.db4o.test.legacy.soda.arrays.object.*;
29 import com.db4o.test.legacy.soda.arrays.typed.*;
30 import com.db4o.test.legacy.soda.arrays.untyped.*;
31 import com.db4o.test.legacy.soda.classes.simple.*;
32 import com.db4o.test.legacy.soda.classes.typedhierarchy.*;
33 import com.db4o.test.legacy.soda.classes.untypedhierarchy.*;
34 import com.db4o.test.legacy.soda.engines.db4o.*;
35 import com.db4o.test.legacy.soda.joins.typed.*;
36 import com.db4o.test.legacy.soda.joins.untyped.*;
37 import com.db4o.test.legacy.soda.ordered.*;
38 import com.db4o.test.legacy.soda.wrapper.typed.*;
39 import com.db4o.test.legacy.soda.wrapper.untyped.*;
40 import com.db4o.test.lib.*;
41
42
43 public class SodaTest {
44
45     private static final STEngine[] ENGINES = new STEngine[] {
46         new STDb4o(),
47         // new STDb4oClientServer()
48
};
49
50     public static final STClass[] CLASSES =
51         new STClass[] {
52             new STArrMixed(),
53             new STArrStringO(),
54             new STArrStringON(),
55             new STArrStringT(),
56             new STArrStringTN(),
57             new STArrStringU(),
58             new STArrStringUN(),
59             new STArrIntegerO(),
60             new STArrIntegerON(),
61             new STArrIntegerT(),
62             new STArrIntegerTN(),
63             new STArrIntegerU(),
64             new STArrIntegerUN(),
65             new STArrIntegerWT(),
66             new STArrIntegerWTON(),
67             new STArrIntegerWUON(),
68             new STBoolean(),
69             new STBooleanWT(),
70             new STBooleanWU(),
71             new STByte(),
72             new STByteWT(),
73             new STByteWU(),
74             new STChar(),
75             new STCharWT(),
76             new STCharWU(),
77             new STDate(),
78             new STDateU(),
79             new STDouble(),
80             new STDoubleWT(),
81             new STDoubleWU(),
82             new STETH1(),
83             new STFloat(),
84             new STFloatWT(),
85             new STFloatWU(),
86             new STInteger(),
87             new STIntegerWT(),
88             new STIntegerWU(),
89             new STLong(),
90             new STLongWT(),
91             new STLongWU(),
92             new STOrT(),
93             new STOrU(),
94             new STOString(),
95             new STOInteger(),
96             new STOIntegerWT(),
97             new STRTH1(),
98             new STSDFT1(),
99             new STShort(),
100             new STShortWT(),
101             new STShortWU(),
102             new STStringU(),
103             new STRUH1(),
104             new STTH1(),
105             new STUH1(),
106        };
107
108         protected static final boolean quiet = false;
109         protected static STEngine engine;
110         private static int testCases;
111         private STClass currentTestClass;
112         protected static Collection4 failedTestClasses = new Collection4();
113         private final TCompare comparer = new TCompare();
114         static long time;
115
116         public static void main(String JavaDoc[] args) { time = System.currentTimeMillis();
117             SodaTest st = new SodaTest();
118             st.run(CLASSES, ENGINES, quiet);
119             st.completed();
120         }
121
122         protected void completed() {
123             time = System.currentTimeMillis() - time;
124             System.out.println(name() + " completed. " + time + " ms");
125             System.out.println("Test cases: " + testCases);
126         }
127
128         protected String JavaDoc name() {
129             return "S.O.D.A. functionality test";
130         }
131         
132         protected static void begin(){
133             failedTestClasses = new Collection4();
134             testCases = 0;
135         }
136
137         public void run(STClass[] classes, STEngine[] engines, boolean a_quiet) {
138             begin();
139             setSodaTestOn(classes);
140
141             for (int i = 0; i < engines.length; i++) {
142                 engine = engines[i];
143                 engine.reset();
144                 engine.open();
145                 store(classes);
146                 engine.commit();
147                 engine.close();
148                 engine.open();
149                 test(classes);
150                 engine.close();
151                 engine.reset();
152             }
153
154             if (failedTestClasses.size() > 0) {
155                 System.err.println("\nFailed test classes:\n");
156                 Iterator4 i = failedTestClasses.iterator();
157                 while (i.moveNext()) {
158                     System.err.println(i.current().getClass().getName());
159                 }
160                 System.err.println("\n");
161             }
162         }
163         
164         protected void store(STClass[] classes) {
165             for (int i = 0; i < classes.length; i++) {
166                 if (jdkOK(classes[i])) {
167                     Object JavaDoc[] objects = classes[i].store();
168                     if (objects != null) {
169                         for (int j = 0; j < objects.length; j++) {
170                             engine.store(objects[j]);
171                         }
172                     }
173                 }
174             }
175         }
176
177         /** dynamic execution of all public methods that begin with "test" in all CLASSES */
178         protected void test(STClass[] classes) {
179             for (int i = 0; i < classes.length; i++) {
180                 if (jdkOK(classes[i])) {
181                     System.out.println(" S.O.D.A. testing " + classes[i].getClass().getName());
182                     currentTestClass = classes[i];
183                     Method[] methods = classes[i].getClass().getDeclaredMethods();
184                     for (int j = 0; j < methods.length; j++) {
185                         Method method = methods[j];
186                         if (method.getName().startsWith("test")) {
187                             try {
188                                 method.invoke(classes[i], (Object JavaDoc[])null);
189                             } catch (Exception JavaDoc e) {
190                                 e.printStackTrace();
191                             }
192                         }
193                     }
194                 }
195             }
196         }
197
198         protected static boolean jdkOK(Object JavaDoc obj) {
199             return Platform4.jdk().ver() >= 2
200                 || STClass1.class.isAssignableFrom(obj.getClass());
201         }
202
203         public Query query() {
204             return engine.query();
205         }
206
207         public void expectOne(Query query, Object JavaDoc object) {
208             expect(query, new Object JavaDoc[] { object });
209         }
210
211         public void expectNone(Query query) {
212             expect(query, null);
213         }
214
215         public void expect(Query query, Object JavaDoc[] results) {
216             expect(query, results, false);
217         }
218
219         public void expectOrdered(Query query, Object JavaDoc[] results) {
220             expect(query, results, true);
221         }
222
223         private void expect(Query query, Object JavaDoc[] results, boolean ordered) {
224             testCases++;
225             ObjectSet set = query.execute();
226             if (results == null || results.length == 0) {
227                 if (set.size() > 0) {
228                     error("No content expected.");
229                 }
230                 return;
231             }
232             int j = 0;
233             if (set.size() == results.length) {
234                 while (set.hasNext()) {
235                     Object JavaDoc obj = set.next();
236                     boolean found = false;
237                     if (ordered) {
238                         if (comparer.isEqual(results[j], obj)) {
239                             results[j] = null;
240                             found = true;
241                         }
242                         j++;
243                     } else {
244                         for (int i = 0; i < results.length; i++) {
245                             if (results[i] != null) {
246                                 if (comparer.isEqual(results[i], obj)) {
247                                     results[i] = null;
248                                     found = true;
249                                     break;
250                                 }
251                             }
252                         }
253                     }
254                     if (!found) {
255                         error("Object not expected: " + obj);
256                     }
257                 }
258                 for (int i = 0; i < results.length; i++) {
259                     if (results[i] != null) {
260                         error("Expected object not returned: " + results[i]);
261                     }
262                 }
263             } else {
264                 error(
265                     "Unexpected size returned.\nExpected: "
266                         + results.length
267                         + " Returned: "
268                         + set.size());
269             }
270         }
271
272         public void error(String JavaDoc msg) {
273             if (!failedTestClasses.contains(currentTestClass)) {
274                 failedTestClasses.add(currentTestClass);
275             }
276             if (!quiet) {
277                 System.err.println(msg);
278                 new ExpectationFailed().printStackTrace();
279                 System.err.println();
280             }
281         }
282         
283         public static int failedClassesSize(){
284             return failedTestClasses.size();
285         }
286         
287         public static int testCaseCount(){
288             return testCases;
289         }
290
291         public void log(Query query) {
292             ObjectSet set = query.execute();
293             while (set.hasNext()) {
294                 TLogger.log(set.next());
295             }
296         }
297
298         protected void setSodaTestOn(STClass[] classes) {
299             for (int i = 0; i < classes.length; i++) {
300                 try {
301                     Field field = classes[i].getClass().getDeclaredField("st");
302                     try {
303                         Platform4.setAccessible(field);
304                     } catch (Throwable JavaDoc t) {
305                         // JDK 1.x has no setAccessible
306
}
307                     field.set(classes[i], this);
308                 } catch (Exception JavaDoc e) {
309                     System.err.println(
310                         "Add the following line to Class " + classes[i].getClass().getName());
311                     System.err.println("public static transient SodaTest st;");
312                 }
313             }
314         }
315
316     }
317
318     class ExpectationFailed extends Exception JavaDoc {
319         ExpectationFailed() {
320         }
321     }
322
Popular Tags