KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > quilt > reg > TestRegistry


1 /* TestRegistry.java */
2
3 package org.quilt.reg;
4
5 import junit.framework.*;
6
7 public class TestRegistry extends TestCase {
8
9     private Registry reg = null;
10
11     public TestRegistry(String JavaDoc name) {
12         super(name);
13     }
14     
15     String JavaDoc salutation[] = {"hello", "there"};
16
17     String JavaDoc key1[] = {"Quilt", "ARG0"};
18     String JavaDoc key2[] = {"Elvis", "lives"};
19     String JavaDoc key3[] = {"One plus ", "one"};
20     String JavaDoc key4[] = {"Elvis", "wombat"};
21     String JavaDoc key5[] = {"Elvis", "heart-throb"};
22     String JavaDoc obj1 = "froggy boy";
23     String JavaDoc obj2 = "Topeka, Kansas";
24     Integer JavaDoc obj3 = new Integer JavaDoc(3);
25     Boolean JavaDoc obj4 = new Boolean JavaDoc(true);
26     Float JavaDoc obj5 = new Float JavaDoc ((float)5.47);
27
28     public void setUp () {
29         reg = new Registry();
30         reg.clear();
31     }
32
33     public void testEmpty () {
34         assertEquals ("Empty registry has items in it", 0, reg.size());
35         assertNull ("Retrieved item from empty registry",
36                                                 reg.get(salutation) );
37         assertTrue ("Empty registry is not empty", reg.isEmpty() );
38     }
39
40     public void testSimple () {
41         assertNull ("Put with no previous value - ", reg.put(key1, obj1));
42         assertEquals (1, reg.size());
43         assertTrue (reg.containsKey(key1));
44         assertNull ("Put with no previous value - ", reg.put(key2, obj2));
45         assertEquals (2, reg.size());
46         assertTrue (reg.containsKey(key2));
47         assertNull ("Put with no previous value - ", reg.put(key3, obj3));
48         assertEquals (3, reg.size());
49         assertTrue (reg.containsKey(key3));
50
51         // make sure all three are present and have correct values
52
assertEquals ("'Quilt' get returns wrong value", obj1, reg.get(key1));
53         assertEquals ("'Elvis' get returns wrong value", obj2, reg.get(key2));
54         assertEquals ("'One plus' get returns wrong value",
55                                                         obj3, reg.get(key3));
56
57         // overwrite, check return value is previous value
58
assertEquals ("Put did not return previous value",
59                                     obj1, reg.put(key1, obj2));
60         assertEquals (3, reg.size());
61         assertEquals ("Put did not return previous value",
62                                     obj2, reg.put(key2, obj3));
63         assertEquals (3, reg.size());
64         assertEquals ("Put did not return previous value",
65                                     obj3, reg.put(key3, obj1));
66         assertEquals (3, reg.size());
67
68         // check value returned on deletion is stored value
69
assertEquals ("remove did not return value stored",
70                                             obj2, reg.remove (key1));
71         assertTrue ("Item deleted but still present", !reg.containsKey(key1));
72         assertEquals (2, reg.size());
73
74         assertEquals ("remove did not return value stored",
75                                             obj3, reg.remove (key2));
76         assertTrue ("Item deleted but still present", !reg.containsKey(key2));
77         assertEquals (1, reg.size());
78
79         assertEquals ("remove did not return value stored",
80                                             obj1, reg.remove (key3));
81         assertTrue ("Item deleted but still present", !reg.containsKey(key3));
82         assertEquals (0, reg.size());
83         assertTrue ("Empty registry is not empty", reg.isEmpty() );
84     }
85  
86     public void testBoolean () {
87         // put some random stuff in the registry ...
88
assertNull ("Put with no previous value - ", reg.put(key1, obj1));
89         assertEquals (1, reg.size());
90         assertTrue (reg.containsKey(key1));
91         // first Elvis
92
assertNull ("Put with no previous value - ", reg.put(key2, obj2));
93         assertEquals (2, reg.size());
94         assertTrue (reg.containsKey(key2));
95         assertNull ("Put with no previous value - ", reg.put(key3, obj3));
96         assertEquals (3, reg.size());
97         assertTrue (reg.containsKey(key3));
98
99         Boolean JavaDoc t = new Boolean JavaDoc(true);
100         Boolean JavaDoc f = new Boolean JavaDoc(false);
101         String JavaDoc tKey[] = {"the", "truth"};
102         String JavaDoc fKey[] = {"a", "falsehood"};
103         assertNull ("Put with no previous value - ", reg.put(tKey, t));
104         assertEquals (4, reg.size());
105         assertTrue ("No truth in the database", reg.containsKey(tKey));
106         assertNull ("Put with no previous value - ", reg.put(fKey, f));
107         assertEquals (5, reg.size());
108         assertTrue ("No lies in the database", reg.containsKey(fKey));
109
110         assertEquals ("Can't get truth out of the registry", t, reg.get(tKey));
111         assertEquals ("Can't get lies out of the registry" , f, reg.get(fKey));
112         
113         assertTrue ( t.booleanValue() );
114         assertTrue ( ((Boolean JavaDoc)reg.get(tKey)).booleanValue() );
115         assertTrue (!f.booleanValue() );
116         assertTrue (!((Boolean JavaDoc)reg.get(fKey)).booleanValue() );
117     }
118     public void testPartialOverlap() {
119         assertNull ("Put with no previous value - ", reg.put(key1, obj1));
120         assertEquals (1, reg.size());
121         assertTrue (reg.containsKey(key1));
122         // Elvis/lives --> Topeka, Kansas
123
assertNull ("Put with no previous value - ", reg.put(key2, obj2));
124         assertEquals (2, reg.size());
125         assertTrue (reg.containsKey(key2));
126         assertNull ("Put with no previous value - ", reg.put(key3, obj3));
127         assertEquals (3, reg.size());
128         assertTrue (reg.containsKey(key3));
129         
130         // the next two have the same value (Elvis) in key[0]
131
// Elvis/wombat --> Boolean(true)
132
assertNull ("Put with no previous value - ", reg.put(key4, obj4));
133         assertEquals (4, reg.size());
134         assertTrue (reg.containsKey(key4));
135         // Elvis/heart-throb --> Float(5.47)
136
assertNull ("Put with no previous value - ", reg.put(key5, obj5));
137         assertEquals (5, reg.size());
138         assertTrue (reg.containsKey(key5));
139
140         // overwrite, check return value is previous value
141
assertEquals ("Put did not return previous value",
142                                     obj1, reg.put(key1, obj2));
143         assertEquals (5, reg.size());
144         assertEquals ("Put did not return previous value",
145                                     obj2, reg.put(key2, obj3));
146         assertEquals (5, reg.size());
147         assertEquals ("Put did not return previous value",
148                                     obj3, reg.put(key3, obj1));
149         assertEquals (5, reg.size());
150         
151         // Elvis/wombat returns Integer(3)
152
assertEquals ("Elvis/wombat put did not return previous value",
153                                     obj4, reg.put(key4, obj5));
154         assertEquals (5, reg.size());
155         assertEquals ("Elvis/heart-throb put did not return previous value",
156                                     obj5, reg.put(key5, obj4));
157         assertEquals (5, reg.size());
158
159         // check value returned on deletion is stored value
160
// first Elvis ...
161
assertEquals ("remove did not return value stored",
162                                             obj4, reg.remove (key5));
163         assertTrue ("Item deleted but still present", !reg.containsKey(key5));
164         assertEquals (4, reg.size());
165         assertEquals ("remove did not return value stored",
166                                             obj5, reg.remove (key4));
167         assertTrue ("Item deleted but still present", !reg.containsKey(key4));
168         assertEquals (3, reg.size());
169         // then the rest
170
assertEquals ("remove did not return value stored",
171                                             obj2, reg.remove (key1));
172         assertTrue ("Item deleted but still present", !reg.containsKey(key1));
173         assertEquals (2, reg.size());
174
175         assertEquals ("remove did not return value stored",
176                                             obj3, reg.remove (key2));
177         assertTrue ("Item deleted but still present", !reg.containsKey(key2));
178         assertEquals (1, reg.size());
179
180         assertEquals ("remove did not return value stored",
181                                             obj1, reg.remove (key3));
182         assertTrue ("Item deleted but still present", !reg.containsKey(key3));
183         assertEquals (0, reg.size());
184         assertTrue ("Empty registry is not empty", reg.isEmpty() ); // GEEP
185
}
186     public void testElvis () {
187         // keys{2,4,5} have "Elvis" as key[0]
188

189         // Elvis/lives --> Topeka, Kansas
190
assertNull ("Put with no previous value - ", reg.put(key2, obj2));
191         assertEquals (1, reg.size());
192         assertTrue (reg.containsKey(key2));
193         
194         // Elvis/wombat --> Boolean(true)
195
assertNull ("Put with no previous value - ", reg.put(key4, obj4));
196         assertEquals (2, reg.size());
197         assertTrue (reg.containsKey(key4));
198         
199         // Elvis/heart-throb --> Float(5.47)
200
assertNull ("Put with no previous value - ", reg.put(key5, obj5));
201         assertEquals (3, reg.size());
202         assertTrue (reg.containsKey(key5));
203
204         // make sure all three are present and have correct values
205
assertEquals ("Elvis/lives get error", obj2, reg.get(key2));
206         assertEquals ("Elvis/wombat get error", obj4, reg.get(key4));
207         assertEquals ("Elvis/heart-throb get error", obj5, reg.get(key5));
208
209         // overwrite, check return value is previous value
210
assertEquals ("Put did not return previous value",
211                                     obj2, reg.put(key2, obj4));
212         assertEquals (3, reg.size());
213         assertEquals ("Put did not return previous value",
214                                     obj4, reg.put(key4, obj5));
215         assertEquals (3, reg.size());
216         assertEquals ("Put did not return previous value",
217                                     obj5, reg.put(key5, obj2));
218         assertEquals (3, reg.size());
219         
220         // check value returned on deletion is stored value
221
assertEquals ("remove did not return value stored",
222                                             obj4, reg.remove (key2));
223         assertTrue ("Item deleted but still present", !reg.containsKey(key2));
224         assertEquals (2, reg.size());
225
226         assertEquals ("remove did not return value stored",
227                                             obj5, reg.remove (key4));
228         assertTrue ("Item deleted but still present", !reg.containsKey(key4));
229         assertEquals (1, reg.size());
230
231         assertEquals ("remove did not return value stored",
232                                             obj2, reg.remove (key5));
233         assertTrue ("Item deleted but still present", !reg.containsKey(key5));
234         assertEquals (0, reg.size());
235         assertTrue ("Empty registry is not empty", reg.isEmpty() ); // GEEP
236
}
237     public void testRG2 () {
238         // duplicating bug found in the field
239
String JavaDoc keys1[] = {"rg2", "msg"};
240         Boolean JavaDoc val1 = new Boolean JavaDoc(true);
241         String JavaDoc keys2[] = {"rg2", "test"};
242         String JavaDoc val2 = "hope this works";
243        
244         assertEquals(0, reg.size());
245
246         assertNull ("Put with no previous value - ", reg.put(keys1, val1));
247         assertEquals (1, reg.size());
248         assertTrue (reg.containsKey(keys1));
249         
250         assertNull ("Put with no previous value - ", reg.put(keys2, val2));
251         assertEquals (2, reg.size());
252         assertTrue (reg.containsKey(keys2));
253         
254         assertEquals ("rg2/msg get error", val1, reg.get(keys1));
255         assertEquals ("rg2/test get error", val2, reg.get(keys2));
256     }
257     public void testExceptions () {
258         // database is empty
259
try {
260             reg.get(null);
261             fail ("get with null key did not throw exception");
262         } catch (IllegalArgumentException JavaDoc e) { }
263
264         try {
265             reg.put(key1, obj1);
266             reg.put(null, obj2);
267             fail ("put with null key did not throw exception");
268         } catch (IllegalArgumentException JavaDoc e) {
269             assertEquals (1, reg.size());
270         }
271         try {
272             reg.put(key2, obj2);
273             reg.containsKey(null);
274             fail ("containsKey with null key did not throw exception");
275         } catch (IllegalArgumentException JavaDoc e) {
276             assertEquals (2, reg.size());
277         }
278         try {
279             reg.put(key3, obj3);
280             reg.remove(null);
281             fail ("remove with null key did not throw exception");
282         } catch (IllegalArgumentException JavaDoc e) {
283             assertEquals (3, reg.size());
284         }
285     }
286     // COMING ATTRACTIONS:
287
//
288
// test sequential operations
289
//
290
// test set-wise operations
291
//
292
// test sub-map operations
293

294 }
295         
296
Popular Tags