1/*-
2 * See the file LICENSE for redistribution information.
3 *
4 * Copyright (c) 2002,2008 Oracle.  All rights reserved.
5 *
6 * $Id: SequenceTest.java,v 1.1 2008/02/07 17:12:32 mark Exp $
7 */
8
9package com.sleepycat.persist.test;
10
11import java.io.File;
12import java.io.IOException;
13
14import junit.framework.TestCase;
15
16import com.sleepycat.db.DatabaseException;
17import com.sleepycat.db.Environment;
18import com.sleepycat.db.EnvironmentConfig;
19import com.sleepycat.persist.EntityStore;
20import com.sleepycat.persist.PrimaryIndex;
21import com.sleepycat.persist.StoreConfig;
22import com.sleepycat.persist.model.Entity;
23import com.sleepycat.persist.model.KeyField;
24import com.sleepycat.persist.model.Persistent;
25import com.sleepycat.persist.model.PrimaryKey;
26import com.sleepycat.util.test.SharedTestUtils;
27import com.sleepycat.util.test.TestEnv;
28
29/**
30 * @author Mark Hayes
31 */
32public class SequenceTest extends TestCase {
33
34    private File envHome;
35    private Environment env;
36
37    public void setUp()
38        throws IOException {
39
40        envHome = new File(System.getProperty(SharedTestUtils.DEST_DIR));
41        SharedTestUtils.emptyDir(envHome);
42    }
43
44    public void tearDown()
45        throws IOException {
46
47        if (env != null) {
48            try {
49                env.close();
50            } catch (DatabaseException e) {
51                System.out.println("During tearDown: " + e);
52            }
53        }
54        try {
55            SharedTestUtils.emptyDir(envHome);
56        } catch (Error e) {
57            System.out.println("During tearDown: " + e);
58        }
59        envHome = null;
60        env = null;
61    }
62
63    public void testSequenceKeys()
64        throws Exception {
65
66        Class[] classes = {
67            SequenceEntity_Long.class,
68            SequenceEntity_Integer.class,
69            SequenceEntity_Short.class,
70            SequenceEntity_Byte.class,
71            SequenceEntity_tlong.class,
72            SequenceEntity_tint.class,
73            SequenceEntity_tshort.class,
74            SequenceEntity_tbyte.class,
75            SequenceEntity_Long_composite.class,
76            SequenceEntity_Integer_composite.class,
77            SequenceEntity_Short_composite.class,
78            SequenceEntity_Byte_composite.class,
79            SequenceEntity_tlong_composite.class,
80            SequenceEntity_tint_composite.class,
81            SequenceEntity_tshort_composite.class,
82            SequenceEntity_tbyte_composite.class,
83        };
84
85        EnvironmentConfig envConfig = TestEnv.BDB.getConfig();
86        envConfig.setAllowCreate(true);
87        env = new Environment(envHome, envConfig);
88
89        StoreConfig storeConfig = new StoreConfig();
90        storeConfig.setAllowCreate(true);
91        EntityStore store = new EntityStore(env, "foo", storeConfig);
92
93        long seq = 0;
94
95        for (int i = 0; i < classes.length; i += 1) {
96            Class entityCls = classes[i];
97            SequenceEntity entity = (SequenceEntity) entityCls.newInstance();
98            Class keyCls = entity.getKeyClass();
99
100            PrimaryIndex<Object,SequenceEntity> index =
101                store.getPrimaryIndex(keyCls, entityCls);
102            index.putNoReturn(entity);
103            seq += 1;
104            assertEquals(seq, entity.getKey());
105
106            index.putNoReturn(entity);
107            assertEquals(seq, entity.getKey());
108
109            entity.nullifyKey();
110            index.putNoReturn(entity);
111            seq += 1;
112            assertEquals(seq, entity.getKey());
113        }
114
115        store.close();
116        env.close();
117        env = null;
118    }
119
120    interface SequenceEntity {
121        Class getKeyClass();
122        long getKey();
123        void nullifyKey();
124    }
125
126    @Entity
127    static class SequenceEntity_Long implements SequenceEntity {
128
129        @PrimaryKey(sequence="X")
130        Long priKey;
131
132        public Class getKeyClass() {
133            return Long.class;
134        }
135
136        public long getKey() {
137            return priKey;
138        }
139
140        public void nullifyKey() {
141            priKey = null;
142        }
143    }
144
145    @Entity
146    static class SequenceEntity_Integer implements SequenceEntity {
147
148        @PrimaryKey(sequence="X")
149        Integer priKey;
150
151        public Class getKeyClass() {
152            return Integer.class;
153        }
154
155        public long getKey() {
156            return priKey;
157        }
158
159        public void nullifyKey() {
160            priKey = null;
161        }
162    }
163
164    @Entity
165    static class SequenceEntity_Short implements SequenceEntity {
166
167        @PrimaryKey(sequence="X")
168        Short priKey;
169
170        public Class getKeyClass() {
171            return Short.class;
172        }
173
174        public long getKey() {
175            return priKey;
176        }
177
178        public void nullifyKey() {
179            priKey = null;
180        }
181    }
182
183    @Entity
184    static class SequenceEntity_Byte implements SequenceEntity {
185
186        @PrimaryKey(sequence="X")
187        Byte priKey;
188
189        public Class getKeyClass() {
190            return Byte.class;
191        }
192
193        public long getKey() {
194            return priKey;
195        }
196
197        public void nullifyKey() {
198            priKey = null;
199        }
200    }
201
202    @Entity
203    static class SequenceEntity_tlong implements SequenceEntity {
204
205        @PrimaryKey(sequence="X")
206        long priKey;
207
208        public Class getKeyClass() {
209            return Long.class;
210        }
211
212        public long getKey() {
213            return priKey;
214        }
215
216        public void nullifyKey() {
217            priKey = 0;
218        }
219    }
220
221    @Entity
222    static class SequenceEntity_tint implements SequenceEntity {
223
224        @PrimaryKey(sequence="X")
225        int priKey;
226
227        public Class getKeyClass() {
228            return Integer.class;
229        }
230
231        public long getKey() {
232            return priKey;
233        }
234
235        public void nullifyKey() {
236            priKey = 0;
237        }
238    }
239
240    @Entity
241    static class SequenceEntity_tshort implements SequenceEntity {
242
243        @PrimaryKey(sequence="X")
244        short priKey;
245
246        public Class getKeyClass() {
247            return Short.class;
248        }
249
250        public long getKey() {
251            return priKey;
252        }
253
254        public void nullifyKey() {
255            priKey = 0;
256        }
257    }
258
259    @Entity
260    static class SequenceEntity_tbyte implements SequenceEntity {
261
262        @PrimaryKey(sequence="X")
263        byte priKey;
264
265        public Class getKeyClass() {
266            return Byte.class;
267        }
268
269        public long getKey() {
270            return priKey;
271        }
272
273        public void nullifyKey() {
274            priKey = 0;
275        }
276    }
277
278    @Entity
279    static class SequenceEntity_Long_composite implements SequenceEntity {
280
281        @PrimaryKey(sequence="X")
282        Key priKey;
283
284        @Persistent
285        static class Key {
286            @KeyField(1)
287            Long priKey;
288        }
289
290        public Class getKeyClass() {
291            return Key.class;
292        }
293
294        public long getKey() {
295            return priKey.priKey;
296        }
297
298        public void nullifyKey() {
299            priKey = null;
300        }
301    }
302
303    @Entity
304    static class SequenceEntity_Integer_composite implements SequenceEntity {
305
306        @PrimaryKey(sequence="X")
307        Key priKey;
308
309        @Persistent
310        static class Key {
311            @KeyField(1)
312            Integer priKey;
313        }
314
315        public Class getKeyClass() {
316            return Key.class;
317        }
318
319        public long getKey() {
320            return priKey.priKey;
321        }
322
323        public void nullifyKey() {
324            priKey = null;
325        }
326    }
327
328    @Entity
329    static class SequenceEntity_Short_composite implements SequenceEntity {
330
331        @PrimaryKey(sequence="X")
332        Key priKey;
333
334        @Persistent
335        static class Key {
336            @KeyField(1)
337            Short priKey;
338        }
339
340        public Class getKeyClass() {
341            return Key.class;
342        }
343
344        public long getKey() {
345            return priKey.priKey;
346        }
347
348        public void nullifyKey() {
349            priKey = null;
350        }
351    }
352
353    @Entity
354    static class SequenceEntity_Byte_composite implements SequenceEntity {
355
356        @PrimaryKey(sequence="X")
357        Key priKey;
358
359        @Persistent
360        static class Key {
361            @KeyField(1)
362            Byte priKey;
363        }
364
365        public Class getKeyClass() {
366            return Key.class;
367        }
368
369        public long getKey() {
370            return priKey.priKey;
371        }
372
373        public void nullifyKey() {
374            priKey = null;
375        }
376    }
377
378    @Entity
379    static class SequenceEntity_tlong_composite implements SequenceEntity {
380
381        @PrimaryKey(sequence="X")
382        Key priKey;
383
384        @Persistent
385        static class Key {
386            @KeyField(1)
387            long priKey;
388        }
389
390        public Class getKeyClass() {
391            return Key.class;
392        }
393
394        public long getKey() {
395            return priKey.priKey;
396        }
397
398        public void nullifyKey() {
399            priKey = null;
400        }
401    }
402
403    @Entity
404    static class SequenceEntity_tint_composite implements SequenceEntity {
405
406        @PrimaryKey(sequence="X")
407        Key priKey;
408
409        @Persistent
410        static class Key {
411            @KeyField(1)
412            int priKey;
413        }
414
415        public Class getKeyClass() {
416            return Key.class;
417        }
418
419        public long getKey() {
420            return priKey.priKey;
421        }
422
423        public void nullifyKey() {
424            priKey = null;
425        }
426    }
427
428    @Entity
429    static class SequenceEntity_tshort_composite implements SequenceEntity {
430
431        @PrimaryKey(sequence="X")
432        Key priKey;
433
434        @Persistent
435        static class Key {
436            @KeyField(1)
437            short priKey;
438        }
439
440        public Class getKeyClass() {
441            return Key.class;
442        }
443
444        public long getKey() {
445            return priKey.priKey;
446        }
447
448        public void nullifyKey() {
449            priKey = null;
450        }
451    }
452
453    @Entity
454    static class SequenceEntity_tbyte_composite implements SequenceEntity {
455
456        @PrimaryKey(sequence="X")
457        Key priKey;
458
459        @Persistent
460        static class Key {
461            @KeyField(1)
462            byte priKey;
463        }
464
465        public Class getKeyClass() {
466            return Key.class;
467        }
468
469        public long getKey() {
470            return priKey.priKey;
471        }
472
473        public void nullifyKey() {
474            priKey = null;
475        }
476    }
477}
478