Source code: com/lutris/util/tests/KeywordValueTableTests.java
1 /*
2 * Enhydra Java Application Server Project
3 *
4 * The contents of this file are subject to the Enhydra Public License
5 * Version 1.1 (the "License"); you may not use this file except in
6 * compliance with the License. You may obtain a copy of the License on
7 * the Enhydra web site ( http://www.enhydra.org/ ).
8 *
9 * Software distributed under the License is distributed on an "AS IS"
10 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
11 * the License for the specific terms governing rights and limitations
12 * under the License.
13 *
14 * The Initial Developer of the Enhydra Application Server is Lutris
15 * Technologies, Inc. The Enhydra Application Server and portions created
16 * by Lutris Technologies, Inc. are Copyright Lutris Technologies, Inc.
17 * All Rights Reserved.
18 *
19 * Contributor(s):
20 *
21 * $Id: KeywordValueTableTests.java,v 1.11.8.1 2000/10/19 17:58:53 jasona Exp $
22 */
23
24
25
26
27
28 package com.lutris.util.tests;
29 import com.lutris.util.*;
30 import com.lutris.testFramework.*;
31
32 /**
33 * Tests for KeywordValue Table.
34 *
35 * @version $Revision: 1.11.8.1 $
36 * @author Mark Diekhans
37 * @since Jolt1.0
38 */
39 public class KeywordValueTableTests {
40 /*
41 * Merge two keyword parts into a single keyword.
42 */
43 static String mergeKey (String part1,
44 String part2) {
45 if ((part1 == null) || (part1.length () == 0)) {
46 return part2;
47 }
48 return part1 + "." + part2;
49 }
50
51 /*
52 * Given a base keyword, run a series of tests. The base has keywords
53 * appended to it to form a path. This is done so the same test can
54 * be used against a single level table and a nested table.
55 */
56 static void basicTests (String baseDesc,
57 String baseKey,
58 Tester tester) {
59 KeywordValueTable keyTab = new KeywordValueTable ();
60
61 //------------------------------------------------------------------
62 // Empty table
63 try {
64 tester.check (baseDesc + " #1.1",
65 keyTab.keys (),
66 new String [0]);
67 } catch (Throwable except) {
68 tester.unexpectedException (baseDesc + " #1.2",
69 except);
70 }
71
72 //------------------------------------------------------------------
73 // Key with string value.
74 String key1 = mergeKey (baseKey,
75 "key1");
76 try {
77 String [] key1Paths = KeywordParser.parse (key1);
78 String [] expect = {key1Paths [0]};
79
80 keyTab.set (key1,
81 "value1");
82 tester.check (baseDesc + " #2.1",
83 keyTab.keys (),
84 expect);
85 } catch (Throwable except) {
86 tester.unexpectedException (baseDesc + " #2.2",
87 except);
88 }
89
90
91 //------------------------------------------------------------------
92 // Verify full path.
93 try {
94 String [] expect = {key1};
95 tester.check (baseDesc + " #3.1",
96 keyTab.leafKeys (),
97 expect);
98 } catch (Throwable except) {
99 tester.unexpectedException (baseDesc + " #3.2",
100 except);
101 }
102
103
104 //------------------------------------------------------------------
105 // Check value.
106 try {
107 tester.check (baseDesc + " #4.1",
108 (String) keyTab.get (key1),
109 "value1");
110 } catch (Throwable except) {
111 tester.unexpectedException (baseDesc + " #4.2",
112 except);
113 }
114
115 //------------------------------------------------------------------
116 // Check value using getString.
117 try {
118 tester.check (baseDesc + " #5.1",
119 keyTab.getString (key1),
120 "value1");
121 } catch (Throwable except) {
122 tester.unexpectedException (baseDesc + " #5.2",
123 except);
124 }
125
126 //------------------------------------------------------------------
127 // Second key, string value.
128 String key2 = mergeKey (baseKey,
129 "key2");
130 try {
131 keyTab.set (key2,
132 "value2");
133 String [] expect = {key1, key2};
134 String [] result;
135
136 // Try both ways to test interfaces.
137 if (baseKey != null) {
138 result = (String []) keyTab.leafKeys ();
139 } else {
140 result = (String []) keyTab.keys ();
141 }
142
143 tester.check (baseDesc + " #6.1",
144 Sorter.sort (result),
145 expect);
146 } catch (Throwable except) {
147 tester.unexpectedException (baseDesc + " #6.2",
148 except);
149 }
150
151 //------------------------------------------------------------------
152 // Check values.
153 try {
154 String result [] = new String [2];
155 result [0] = (String) keyTab.get (key1);
156 result [1] = (String) keyTab.get (key2);
157
158 String [] expect = {"value1", "value2"};
159 tester.check (baseDesc + " #7.1",
160 Sorter.sort ((String []) result),
161 expect);
162 } catch (Throwable except) {
163 tester.unexpectedException (baseDesc + " #7.2",
164 except);
165 }
166
167 //------------------------------------------------------------------
168 // Float value.
169 String key3 = mergeKey (baseKey,
170 "key3");
171 try {
172 keyTab.set (key3,
173 new Float (100.001));
174 String [] expect;
175 if (baseKey == null) {
176 expect = new String [] {key1, key2, key3};
177 } else {
178 expect = new String [] {KeywordParser.parse (key1) [0]};
179 }
180 tester.check (baseDesc + " #8.1",
181 Sorter.sort ((String []) keyTab.keys ()),
182 expect);
183 } catch (Throwable except) {
184 tester.unexpectedException (baseDesc + " #8.2",
185 except);
186 }
187
188 //------------------------------------------------------------------
189 // Try full key paths.
190 try {
191 keyTab.set (key3,
192 new Float (100.001));
193
194 String [] expect = {key1, key2, key3};
195 tester.check (baseDesc + " #9.1",
196 Sorter.sort ((String []) keyTab.leafKeys ()),
197 expect);
198 } catch (Throwable except) {
199 tester.unexpectedException (baseDesc + " #9.2",
200 except);
201 }
202
203 //------------------------------------------------------------------
204 // Check value.
205 try {
206 tester.check (baseDesc + " #10.1",
207 keyTab.get (key3),
208 new Float (100.001));
209 } catch (Throwable except) {
210 tester.unexpectedException (baseDesc + " #10.2",
211 except);
212 }
213
214 //------------------------------------------------------------------
215 // Second key, string value.
216 String key4 = mergeKey (baseKey,
217 "key4");
218 try {
219 keyTab.set (key4,
220 new Float (100.002));
221 String [] expect = {key1, key2, key3, key4};
222 tester.check (baseDesc + " #11.1",
223 Sorter.sort ((String []) keyTab.leafKeys ()),
224 expect);
225
226 } catch (Throwable except) {
227 tester.unexpectedException (baseDesc + " #11.2",
228 except);
229 }
230
231 //------------------------------------------------------------------
232 // Check values.
233 try {
234 Float result [] = new Float [2];
235 result [0] = (Float) keyTab.get (key3);
236 result [1] = (Float) keyTab.get (key4);
237
238 Float [] expect = {new Float (100.001),
239 new Float (100.002)};
240 tester.check (baseDesc + " #12.1",
241 Sorter.sort ((Float []) result),
242 expect);
243 } catch (Throwable except) {
244 tester.unexpectedException (baseDesc + " #12.2",
245 except);
246 }
247
248 //------------------------------------------------------------------
249 // Section access, but only if a base key is creating nested tables.
250 if (baseKey != null) {
251 try {
252 KeywordValueTable section = keyTab.getSection (baseKey);
253 String [] expect = {"key1", "key2", "key3", "key4"};
254
255 tester.check (baseDesc + " #13.1",
256 Sorter.sort (section.keys ()),
257 expect);
258 } catch (Throwable except) {
259 tester.unexpectedException (baseDesc + " #13.2",
260 except);
261 }
262
263 }
264
265 //------------------------------------------------------------------
266 // Test updating values.
267 try {
268 keyTab.set (key1, "new-value1");
269
270 tester.check (baseDesc + " #14.1",
271 keyTab.get (key1),
272 "new-value1");
273 } catch (Throwable except) {
274 tester.unexpectedException (baseDesc + " #14.2",
275 except);
276 }
277
278 //------------------------------------------------------------------
279 try {
280 keyTab.set (key2, new Double (3.14159));
281
282 tester.check (baseDesc + " #15.1",
283 keyTab.get (key2),
284 new Double (3.14159));
285 } catch (Throwable except) {
286 tester.unexpectedException (baseDesc + " #15.2",
287 except);
288 }
289
290 //------------------------------------------------------------------
291 // Converting a type to a section.
292 try {
293 String key2b = KeywordParser.concat (key2,
294 "subkey2.subkey3.subkey4");
295 keyTab.set (key2b, new Double (6248.1));
296
297 tester.check (baseDesc + " #16.1",
298 keyTab.get (key2b),
299 new Double (6248.1));
300 } catch (Throwable except) {
301 tester.unexpectedException (baseDesc + " #16.2",
302 except);
303 }
304
305 //------------------------------------------------------------------
306 try {
307 tester.check (baseDesc + " #17.1",
308 keyTab.get (key2).getClass (),
309 keyTab.getClass ());
310 } catch (Throwable except) {
311 tester.unexpectedException (baseDesc + " #17.2",
312 except);
313 }
314
315 //------------------------------------------------------------------
316 try {
317 tester.check (baseDesc + " #18.1",
318 new Boolean (keyTab.containsKey (key1)),
319 new Boolean (true));
320 } catch (Throwable except) {
321 tester.unexpectedException (baseDesc + " #18.2",
322 except);
323 }
324
325
326 //------------------------------------------------------------------
327 try {
328 tester.check (baseDesc + " #19.1",
329 new Boolean (keyTab.containsKey ("fookey1")),
330 new Boolean (false));
331 } catch (Throwable except) {
332 tester.unexpectedException (baseDesc + " #19.2",
333 except);
334 }
335
336
337 //------------------------------------------------------------------
338 // Deleting fields.
339 try {
340 tester.check (baseDesc + " #20.1",
341 new Boolean (keyTab.containsKey (key3)),
342 new Boolean (true));
343 keyTab.remove (key3);
344 tester.check (baseDesc + " #20.2",
345 new Boolean (keyTab.containsKey (key3)),
346 new Boolean (false));
347 keyTab.remove (key3);
348 tester.check (baseDesc + " #20.3",
349 new Boolean (keyTab.containsKey (key3)),
350 new Boolean (false));
351 } catch (Throwable except) {
352 tester.unexpectedException (baseDesc + " #20.4",
353 except);
354 }
355
356 //------------------------------------------------------------------
357 try {
358 String key4b1 = KeywordParser.concat (key4,
359 "subkey5");
360 String key4b2 = KeywordParser.concat (key4,
361 "subkey5.subkey6");
362 String key4b3 = KeywordParser.concat (key4,
363 "subkey5.subkey6.subkey7");
364 keyTab.set (key4b3,
365 "Long key here");
366 tester.check (baseDesc + " #21.1",
367 new Boolean (keyTab.containsKey (key4b3)),
368 new Boolean (true));
369 tester.check (baseDesc + " #21.2",
370 new Boolean (keyTab.containsKey (key4b2)),
371 new Boolean (true));
372 tester.check (baseDesc + " #21.3",
373 new Boolean (keyTab.containsKey (key4b1)),
374 new Boolean (true));
375
376 keyTab.remove (key4b2);
377 keyTab.remove (key4b2); // No-op
378
379 tester.check (baseDesc + " #21.4",
380 new Boolean (keyTab.containsKey (key4b3)),
381 new Boolean (false));
382 tester.check (baseDesc + " #21.5",
383 new Boolean (keyTab.containsKey (key4b2)),
384 new Boolean (false));
385 tester.check (baseDesc + " #21.6",
386 new Boolean (keyTab.containsKey (key4b1)),
387 new Boolean (true));
388 } catch (Throwable except) {
389 tester.unexpectedException (baseDesc + " #21.7",
390 except);
391 }
392
393 //------------------------------------------------------------------
394 // Access to missing fields.
395 try {
396 tester.check (baseDesc + " #22.1",
397 keyTab.get ("nokey"),
398 null);
399 } catch (Throwable except) {
400 tester.unexpectedException (baseDesc + " #22.2",
401 except);
402 }
403
404 try {
405 tester.check (baseDesc + " #22.3",
406 keyTab.get ("nokey", "Foo!"),
407 "Foo!");
408 } catch (Throwable except) {
409 tester.unexpectedException (baseDesc + " #22.4",
410 except);
411 }
412
413 }
414
415 /**
416 * Test error handling.
417 */
418 static void errorTests (String baseDesc,
419 String baseKey,
420 Tester tester) {
421 KeywordValueTable keyTab = new KeywordValueTable ();
422
423 //------------------------------------------------------------------
424 // Non-existant field
425 String key2a = mergeKey (baseKey,
426 "key2");
427 String key2b = mergeKey (baseKey,
428 "key2.subkey2");
429 int level = 0;
430 try {
431 level = KeywordParser.parse (key2b).length - 2;
432 keyTab.set (key2a,
433 new Double (1.2));
434 tester.check (baseDesc + " #2.1",
435 keyTab.get (key2a),
436 new Double (1.2));
437 keyTab.get (key2b);
438 throw new Throwable (baseDesc + ": #2.2 should have failed");
439 } catch (Throwable except) {
440 String msg = "keyword specifies a non-leaf component that is " +
441 "not a KeywordValueTable: " + key2b + " (component #" +
442 level + ")";
443 tester.checkExcept (baseDesc + " #2.3",
444 except,
445 new KeywordValueException (msg));
446 }
447
448 //------------------------------------------------------------------
449 // Illegal keywords.
450 String key3 = mergeKey (baseKey,
451 "");
452 try {
453 keyTab.set (key3,
454 new Double (1.2));
455 throw new Throwable (baseDesc + ": #3.1 should have failed");
456 } catch (Throwable except) {
457 String msg = "keyword component must be single word or words " +
458 "separated by '.': \"" + key3 + "\"";
459 tester.checkExcept (baseDesc + " #3.2",
460 except,
461 new KeywordValueException (msg));
462 }
463
464 //------------------------------------------------------------------
465 String key4 = ".";
466 try {
467 keyTab.set (key4,
468 new Double (1.2));
469 throw new Throwable (baseDesc + ": #4.1 should have failed");
470 } catch (Throwable except) {
471 String msg =
472 "keyword should not start with a '.' separator: \".\"";
473 tester.checkExcept (baseDesc + " #4.2",
474 except,
475 new KeywordValueException (msg));
476 }
477
478 //------------------------------------------------------------------
479 String key5 = ".a";
480 try {
481 keyTab.set (key5,
482 new Double (1.2));
483 throw new Throwable (baseDesc + ": #5.1 should have failed");
484 } catch (Throwable except) {
485 String msg = "keyword component must be single word or words " +
486 "separated by '.': \".a\"";
487 tester.checkExcept (baseDesc + " #5.2",
488 except,
489 new KeywordValueException (msg));
490 }
491
492 //------------------------------------------------------------------
493 String key6 = "";
494 try {
495 keyTab.set (key6,
496 new Double (1.2));
497 throw new Throwable (baseDesc + ": #6.1 should have failed");
498 } catch (Throwable except) {
499 String msg = "keyword component must be single word or words " +
500 "separated by '.': \"\"";
501 tester.checkExcept (baseDesc + " #6.2",
502 except,
503 new KeywordValueException (msg));
504 }
505
506 //------------------------------------------------------------------
507 String key7 = mergeKey (baseKey,
508 "a..b");
509 try {
510 keyTab.set (key7,
511 new Double (1.2));
512 throw new Throwable (baseDesc + ": #7.1 should have failed");
513 } catch (Throwable except) {
514 String msg = "keyword component must be single word or words " +
515 "separated by '.': \"" + key7 + "\"";
516 tester.checkExcept (baseDesc + " #7.2",
517 except,
518 new KeywordValueException (msg));
519 }
520
521 //------------------------------------------------------------------
522 String key8 = mergeKey (baseKey,
523 "102B");
524 try {
525 keyTab.set (key8,
526 new Double (1.2));
527 throw new Throwable (baseDesc + ": #8.1 should have failed");
528 } catch (Throwable except) {
529 String msg = "keyword component must be a legal Java identifier " +
530 "component \"102B\": \"" + key8 + "\"";
531 tester.checkExcept (baseDesc + " #8.2",
532 except,
533 new KeywordValueException (msg));
534 }
535
536 //------------------------------------------------------------------
537 String key9 = mergeKey (baseKey,
538 "A#b");
539 try {
540 keyTab.set (key9,
541 new Double (1.2));
542 throw new Throwable (baseDesc + ": #9.1 should have failed");
543 } catch (Throwable except) {
544 String msg = "keyword component must be a legal Java identifier " +
545 "component \"A#b\": \"" + key9 + "\"";
546 tester.checkExcept (baseDesc + " #9.2",
547 except,
548 new KeywordValueException (msg));
549 }
550
551 //------------------------------------------------------------------
552 String key10 = mergeKey (baseKey,
553 "A.");
554 try {
555 keyTab.set (key10,
556 new Double (1.2));
557 throw new Throwable (baseDesc + ": #10.1 should have failed");
558 } catch (Throwable except) {
559 String msg = "keyword component must be single word or words " +
560 "separated by '.': \"" + key10 + "\"";
561 tester.checkExcept (baseDesc + " #10.2",
562 except,
563 new KeywordValueException (msg));
564 }
565 }
566
567
568
569 public static void runTests () {
570 Tester tester = new Tester ();
571
572 basicTests ("Simple table",
573 null,
574 tester);
575 basicTests ("One level nested table",
576 "Top1",
577 tester);
578 basicTests ("Two level nested table",
579 "Top1.mid1",
580 tester);
581 errorTests ("Simple error tests",
582 null,
583 tester);
584 errorTests ("One level error tests",
585 "Top1",
586 tester);
587 errorTests ("Two level error tests",
588 "Top1.mid1",
589 tester);
590
591 if (tester.errorCnt > 0) {
592 System.err.println ("\n **** " + tester.errorCnt +
593 " keyword/value table tests failed ****\n");
594 System.exit (1);
595 } else {
596 System.out.println ("\nAll keyword/value table tests succeeded :-)\n");
597 }
598 }
599
600 public static void main (String args []) {
601 runTests();
602 }
603
604 }