1/*-
2 * See the file LICENSE for redistribution information.
3 *
4 * Copyright (c) 2000,2008 Oracle.  All rights reserved.
5 *
6 * $Id: EvolveCase.java,v 1.1 2008/02/07 17:12:32 mark Exp $
7 */
8package com.sleepycat.persist.test;
9
10import java.util.Iterator;
11import java.util.List;
12
13import junit.framework.TestCase;
14
15import com.sleepycat.db.DatabaseException;
16import com.sleepycat.db.Environment;
17import com.sleepycat.persist.EntityStore;
18import com.sleepycat.persist.StoreConfig;
19import com.sleepycat.persist.evolve.Mutations;
20import com.sleepycat.persist.model.ClassMetadata;
21import com.sleepycat.persist.model.EntityModel;
22import com.sleepycat.persist.model.Persistent;
23import com.sleepycat.persist.raw.RawStore;
24import com.sleepycat.persist.raw.RawType;
25
26@Persistent
27abstract class EvolveCase {
28
29    static final String STORE_NAME = "foo";
30
31    transient boolean updated;
32
33    Mutations getMutations() {
34        return null;
35    }
36
37    void configure(EntityModel model, StoreConfig config) {
38    }
39
40    String getStoreOpenException() {
41        return null;
42    }
43
44    int getNRecordsExpected() {
45        return 1;
46    }
47
48    void checkUnevolvedModel(EntityModel model, Environment env) {
49    }
50
51    void checkEvolvedModel(EntityModel model,
52                           Environment env,
53                           boolean oldTypesExist) {
54    }
55
56    void writeObjects(EntityStore store)
57        throws DatabaseException {
58    }
59
60    void readObjects(EntityStore store, boolean doUpdate)
61        throws DatabaseException {
62    }
63
64    void readRawObjects(RawStore store,
65                        boolean expectEvolved,
66                        boolean expectUpdated)
67        throws DatabaseException {
68    }
69
70    void copyRawObjects(RawStore rawStore, EntityStore newStore)
71        throws DatabaseException {
72    }
73
74    /**
75     * Checks for equality and prints the entire values rather than
76     * abbreviated values like TestCase.assertEquals does.
77     */
78    static void checkEquals(Object expected, Object got) {
79        if ((expected != null) ? (!expected.equals(got)) : (got != null)) {
80            TestCase.fail("Expected:\n" + expected + "\nBut got:\n" + got);
81        }
82    }
83
84    /**
85     * Asserts than an entity database exists or does not exist.
86     */
87    static void assertDbExists(boolean expectExists,
88                               Environment env,
89                               String entityClassName) {
90        assertDbExists(expectExists, env, entityClassName, null);
91    }
92
93    /**
94     * Checks that an entity class exists or does not exist.
95     */
96    static void checkEntity(boolean exists,
97                            EntityModel model,
98                            Environment env,
99                            String className,
100                            int version,
101                            String secKeyName) {
102        if (exists) {
103            TestCase.assertNotNull(model.getEntityMetadata(className));
104            ClassMetadata meta = model.getClassMetadata(className);
105            TestCase.assertNotNull(meta);
106            TestCase.assertEquals(version, meta.getVersion());
107            TestCase.assertTrue(meta.isEntityClass());
108
109            RawType raw = model.getRawType(className);
110            TestCase.assertNotNull(raw);
111            TestCase.assertEquals(version, raw.getVersion());
112        } else {
113            TestCase.assertNull(model.getEntityMetadata(className));
114            TestCase.assertNull(model.getClassMetadata(className));
115            TestCase.assertNull(model.getRawType(className));
116        }
117
118        assertDbExists(exists, env, className);
119        if (secKeyName != null) {
120            assertDbExists(exists, env, className, secKeyName);
121        }
122    }
123
124    /**
125     * Checks that a non-entity class exists or does not exist.
126     */
127    static void checkNonEntity(boolean exists,
128                               EntityModel model,
129                               Environment env,
130                               String className,
131                               int version) {
132        if (exists) {
133            ClassMetadata meta = model.getClassMetadata(className);
134            TestCase.assertNotNull(meta);
135            TestCase.assertEquals(version, meta.getVersion());
136            TestCase.assertTrue(!meta.isEntityClass());
137
138            RawType raw = model.getRawType(className);
139            TestCase.assertNotNull(raw);
140            TestCase.assertEquals(version, raw.getVersion());
141        } else {
142            TestCase.assertNull(model.getClassMetadata(className));
143            TestCase.assertNull(model.getRawType(className));
144        }
145
146        TestCase.assertNull(model.getEntityMetadata(className));
147        assertDbExists(false, env, className);
148    }
149
150    /**
151     * Asserts than a database expectExists or does not exist. If keyName is
152     * null, checks an entity database.  If keyName is non-null, checks a
153     * secondary database.
154     */
155    static void assertDbExists(boolean expectExists,
156                               Environment env,
157                               String entityClassName,
158                               String keyName) {
159        PersistTestUtils.assertDbExists
160            (expectExists, env, STORE_NAME, entityClassName, keyName);
161    }
162
163    static void checkVersions(EntityModel model, String name, int version) {
164        checkVersions(model, new String[] {name}, new int[] {version});
165    }
166
167    static void checkVersions(EntityModel model,
168                              String name1,
169                              int version1,
170                              String name2,
171                              int version2) {
172        checkVersions
173            (model, new String[] {name1, name2},
174             new int[] {version1, version2});
175    }
176
177    private static void checkVersions(EntityModel model,
178                                      String[] names,
179                                      int[] versions) {
180        List<RawType> all = model.getAllRawTypeVersions(names[0]);
181        TestCase.assertNotNull(all);
182
183        assert names.length == versions.length;
184        TestCase.assertEquals(names.length, all.size());
185
186        Iterator<RawType> iter = all.iterator();
187        for (int i = 0; i < names.length; i += 1) {
188            RawType type = iter.next();
189            TestCase.assertEquals(versions[i], type.getVersion());
190            TestCase.assertEquals(names[i], type.getClassName());
191        }
192    }
193}
194