1/*- 2 * See the file LICENSE for redistribution information. 3 * 4 * Copyright (c) 2000,2008 Oracle. All rights reserved. 5 * 6 * $Id: EvolveTest.java,v 1.1 2008/02/07 17:12:32 mark Exp $ 7 */ 8package com.sleepycat.persist.test; 9 10import java.io.IOException; 11 12import junit.framework.Test; 13 14import com.sleepycat.persist.evolve.EvolveConfig; 15import com.sleepycat.persist.evolve.EvolveEvent; 16import com.sleepycat.persist.evolve.EvolveListener; 17import com.sleepycat.persist.evolve.EvolveStats; 18import com.sleepycat.persist.impl.PersistCatalog; 19import com.sleepycat.util.test.SharedTestUtils; 20 21/** 22 * Runs part two of the EvolveTest. This part is run with the new/updated 23 * version of EvolveClasses in the classpath. It uses the environment and 24 * store created by EvolveTestInit. It verifies that it can read/write/evolve 25 * objects serialized using the old class format, and that it can create new 26 * objects with the new class format. 27 * 28 * @author Mark Hayes 29 */ 30public class EvolveTest extends EvolveTestBase { 31 32 public static Test suite() 33 throws Exception { 34 35 return getSuite(EvolveTest.class); 36 } 37 38 private int evolveNRead; 39 private int evolveNConverted; 40 41 boolean useEvolvedClass() { 42 return true; 43 } 44 45 @Override 46 public void setUp() 47 throws IOException { 48 49 /* Copy the log files created by EvolveTestInit. */ 50 envHome = getTestInitHome(true /*evolved*/); 51 envHome.mkdirs(); 52 SharedTestUtils.emptyDir(envHome); 53 SharedTestUtils.copyFiles(getTestInitHome(false /*evolved*/), envHome); 54 } 55 56 public void testLazyEvolve() 57 throws Exception { 58 59 openEnv(); 60 61 /* 62 * Open in raw mode to check unevolved raw object and formats. This 63 * is possible whether or not we can open the store further below to 64 * evolve formats without errors. 65 */ 66 openRawStore(); 67 caseObj.checkUnevolvedModel(rawStore.getModel(), env); 68 caseObj.readRawObjects 69 (rawStore, false /*expectEvolved*/, false /*expectUpdated*/); 70 closeRawStore(); 71 72 if (openStoreReadWrite()) { 73 74 /* 75 * When opening read-write, formats are evolved lazily. Check by 76 * reading evolved objects. 77 */ 78 caseObj.checkEvolvedModel 79 (store.getModel(), env, true /*oldTypesExist*/); 80 caseObj.readObjects(store, false /*doUpdate*/); 81 closeStore(); 82 83 /* 84 * Read raw objects again to check that the evolved objects are 85 * returned even though the stored objects were not evolved. 86 */ 87 openRawStore(); 88 caseObj.checkEvolvedModel 89 (rawStore.getModel(), env, true /*oldTypesExist*/); 90 caseObj.readRawObjects 91 (rawStore, true /*expectEvolved*/, false /*expectUpdated*/); 92 closeRawStore(); 93 94 /* 95 * Open read-only to ensure that the catalog does not need to 96 * change (evolve formats) unnecessarily. 97 */ 98 PersistCatalog.expectNoClassChanges = true; 99 try { 100 openStoreReadOnly(); 101 } finally { 102 PersistCatalog.expectNoClassChanges = false; 103 } 104 caseObj.checkEvolvedModel 105 (store.getModel(), env, true /*oldTypesExist*/); 106 caseObj.readObjects(store, false /*doUpdate*/); 107 closeStore(); 108 109 /* 110 * Open read-write to update objects and store them in evolved 111 * format. 112 */ 113 openStoreReadWrite(); 114 caseObj.checkEvolvedModel 115 (store.getModel(), env, true /*oldTypesExist*/); 116 caseObj.readObjects(store, true /*doUpdate*/); 117 caseObj.checkEvolvedModel 118 (store.getModel(), env, true /*oldTypesExist*/); 119 closeStore(); 120 121 /* 122 * Check raw objects again after the evolved objects were stored. 123 */ 124 openRawStore(); 125 caseObj.checkEvolvedModel 126 (rawStore.getModel(), env, true /*oldTypesExist*/); 127 caseObj.readRawObjects 128 (rawStore, true /*expectEvolved*/, true /*expectUpdated*/); 129 closeRawStore(); 130 } 131 132 closeAll(); 133 } 134 135 public void testEagerEvolve() 136 throws Exception { 137 138 /* If the store cannot be opened, this test is not appropriate. */ 139 if (caseObj.getStoreOpenException() != null) { 140 return; 141 } 142 143 EvolveConfig config = new EvolveConfig(); 144 config.setEvolveListener(new EvolveListener() { 145 public boolean evolveProgress(EvolveEvent event) { 146 EvolveStats stats = event.getStats(); 147 evolveNRead = stats.getNRead(); 148 evolveNConverted = stats.getNConverted(); 149 return true; 150 } 151 }); 152 153 openEnv(); 154 155 openStoreReadWrite(); 156 157 /* 158 * Evolve and expect that the expected number of entities are 159 * converted. 160 */ 161 int nExpected = caseObj.getNRecordsExpected(); 162 evolveNRead = 0; 163 evolveNConverted = 0; 164 PersistCatalog.unevolvedFormatsEncountered = false; 165 EvolveStats stats = store.evolve(config); 166 if (nExpected > 0) { 167 assertTrue(PersistCatalog.unevolvedFormatsEncountered); 168 } 169 assertTrue(evolveNRead == nExpected); 170 assertTrue(evolveNConverted == nExpected); 171 assertTrue(evolveNConverted >= evolveNRead); 172 assertEquals(evolveNRead, stats.getNRead()); 173 assertEquals(evolveNConverted, stats.getNConverted()); 174 175 /* Evolve again and expect that no entities are converted. */ 176 evolveNRead = 0; 177 evolveNConverted = 0; 178 PersistCatalog.unevolvedFormatsEncountered = false; 179 stats = store.evolve(config); 180 assertTrue(!PersistCatalog.unevolvedFormatsEncountered); 181 assertTrue(evolveNRead == 0); 182 assertTrue(evolveNConverted == 0); 183 assertEquals(0, stats.getNRead()); 184 assertEquals(0, stats.getNConverted()); 185 186 /* Ensure that we can read all entities without evolution. */ 187 PersistCatalog.unevolvedFormatsEncountered = false; 188 caseObj.readObjects(store, false /*doUpdate*/); 189 assertTrue(!PersistCatalog.unevolvedFormatsEncountered); 190 191 /* 192 * When automatic unused type deletion is implemented in the future the 193 * oldTypesExist parameters below should be changed to false. 194 */ 195 196 /* Open again and try an update. */ 197 caseObj.checkEvolvedModel 198 (store.getModel(), env, true /*oldTypesExist*/); 199 caseObj.readObjects(store, true /*doUpdate*/); 200 caseObj.checkEvolvedModel 201 (store.getModel(), env, true /*oldTypesExist*/); 202 closeStore(); 203 204 /* Open read-only and double check that everything is OK. */ 205 openStoreReadOnly(); 206 caseObj.checkEvolvedModel 207 (store.getModel(), env, true /*oldTypesExist*/); 208 caseObj.readObjects(store, false /*doUpdate*/); 209 caseObj.checkEvolvedModel 210 (store.getModel(), env, true /*oldTypesExist*/); 211 closeStore(); 212 213 /* Check raw objects. */ 214 openRawStore(); 215 caseObj.checkEvolvedModel 216 (rawStore.getModel(), env, true /*oldTypesExist*/); 217 caseObj.readRawObjects 218 (rawStore, true /*expectEvolved*/, true /*expectUpdated*/); 219 220 /* 221 * Test copy raw object to new store via convertRawObject. In this 222 * test we can pass false for oldTypesExist because newStore starts 223 * with the new/evolved class model. 224 */ 225 openNewStore(); 226 caseObj.copyRawObjects(rawStore, newStore); 227 caseObj.readObjects(newStore, true /*doUpdate*/); 228 caseObj.checkEvolvedModel 229 (newStore.getModel(), env, false /*oldTypesExist*/); 230 closeNewStore(); 231 closeRawStore(); 232 233 closeAll(); 234 } 235} 236