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