diff options
Diffstat (limited to 'src/test/java')
17 files changed, 3245 insertions, 0 deletions
diff --git a/src/test/java/com/amazon/carbonado/TestStorables.java b/src/test/java/com/amazon/carbonado/TestStorables.java new file mode 100644 index 0000000..90048d7 --- /dev/null +++ b/src/test/java/com/amazon/carbonado/TestStorables.java @@ -0,0 +1,2263 @@ +/* + * Copyright 2006 Amazon Technologies, Inc. or its affiliates. + * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks + * of Amazon Technologies, Inc. or its affiliates. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.amazon.carbonado; + +import java.util.Comparator; +import java.util.List; + +import junit.framework.TestCase; + +import org.joda.time.DateTime; +import org.joda.time.DateTimeZone; + +import com.amazon.carbonado.ConstraintException; +import com.amazon.carbonado.Cursor; +import com.amazon.carbonado.FetchException; +import com.amazon.carbonado.FetchNoneException; +import com.amazon.carbonado.OptimisticLockException; +import com.amazon.carbonado.PersistException; +import com.amazon.carbonado.PersistMultipleException; +import com.amazon.carbonado.PersistNoneException; +import com.amazon.carbonado.PrimaryKey; +import com.amazon.carbonado.Query; +import com.amazon.carbonado.Repository; +import com.amazon.carbonado.RepositoryException; +import com.amazon.carbonado.Storable; +import com.amazon.carbonado.Storage; +import com.amazon.carbonado.Trigger; +import com.amazon.carbonado.UniqueConstraintException; + +import com.amazon.carbonado.cursor.SortedCursor; + +import com.amazon.carbonado.spi.RepairExecutor; +import com.amazon.carbonado.spi.WrappedSupport; + +import com.amazon.carbonado.stored.*; + +/** + * Runs an extensive set of acceptance tests for a repository. Must be + * subclassed to specify a repository to use. + * + * @author Don Schneider + * @author Brian S O'Neill + */ +public abstract class TestStorables extends TestCase { + + public static final long sSetId = 0x1L << 0; // 0x0001 + public static final long sGetStringProp = 0x1L << 1; // 0x0002 + public static final long sSetStringProp = 0x1L << 2; // 0x0004 + public static final long sGetIntProp = 0x1L << 3; // 0x0008 + public static final long sSetIntProp = 0x1L << 4; // 0x0010 + public static final long sGetLongProp = 0x1L << 5; // 0x0020 + public static final long sSetLongProp = 0x1L << 6; // 0x0040 + public static final long sGetDoubleProp = 0x1L << 7; // 0x0080 + public static final long sSetDoubleProp = 0x1L << 8; // 0x0100 + public static final long sLoad = 0x1L << 9; // 0x0200 + public static final long sTryLoad = 0x1L << 10; // 0x0400 + public static final long sInsert = 0x1L << 11; // 0x0800 + public static final long sTryInsert = 0x1L << 31; // 0x8000 0000 + public static final long sUpdate = 0x1L << 32; // 0x0001 0000 0000 + public static final long sTryUpdate = 0x1L << 12; // 0x1000 + public static final long sDelete = 0x1L << 33; // 0x0002 0000 0000 + public static final long sTryDelete = 0x1L << 13; // 0x2000 + public static final long sStorage = 0x1L << 14; // 0x4000 + public static final long sCopy = 0x1L << 15; // 0x8000 + public static final long sToStringKeyOnly = 0x1L << 16; // 0x0001 0000 + public static final long sGetId = 0x1L << 17; // 0x0002 0000 + public static final long sCopyAllProperties = 0x1L << 18; // 0x0004 0000 + public static final long sCopyPrimaryKeyProperties = 0x1L << 19; // 0x0080 0000 + public static final long sCopyUnequalProperties = 0x1L << 20; // 0x0010 0000 + public static final long sCopyDirtyProperties = 0x1L << 21; // 0x0020 0000 + public static final long sHasDirtyProperties = 0x1L << 25; // 0x0040 0000 + public static final long sEqualKeys = 0x1L << 22; // 0x0080 0000 + public static final long sEqualProperties = 0x1L << 23; // 0x0100 0000 + public static final long sCopyVersionProperty = 0x1L << 24; // 0x0200 0000 + public static final long sMarkPropertiesClean = 0x1L << 26; // 0x0400 0000 + public static final long sMarkAllPropertiesClean = 0x1L << 27; // 0x0800 0000 + public static final long sMarkPropertiesDirty = 0x1L << 28; // 0x1000 0000 + public static final long sMarkAllPropertiesDirty = 0x1L << 29; // 0x2000 0000 + public static final long sStorableType = 0x1L << 30; // 0x4000 0000 + + public static final long ALL_SET_METHODS = // 0x00000155; + sSetId + sSetStringProp + sSetIntProp + sSetLongProp + sSetDoubleProp; + public static final long ALL_GET_METHODS = // 0x000200AA; + sGetId + sGetStringProp + sGetIntProp + sGetLongProp + sGetDoubleProp; + public static final long ALL_PRIMARY_KEYS = sSetId; // 0x00000001; + public static final long ALL_COPY_PROP_METHODS = // 0x003C0000; + sCopyAllProperties + sCopyPrimaryKeyProperties + sCopyUnequalProperties + + sCopyDirtyProperties + sCopyVersionProperty; + public static final long ALL_INTERFACE_METHODS = // 0x43C1FE00; + sLoad + sTryLoad + sInsert + sUpdate + sDelete + sStorage + sCopy + sToStringKeyOnly + + ALL_COPY_PROP_METHODS + sHasDirtyProperties + sEqualKeys + sEqualProperties + + sMarkPropertiesClean + sMarkPropertiesDirty + + sMarkAllPropertiesClean + sMarkAllPropertiesDirty + sStorableType; + + private Repository mRepository; + private static int s_Ids = 0; + + public TestStorables(String s) { + super(s); + } + + protected void setUp() throws Exception { + super.setUp(); + } + + protected void tearDown() throws Exception { + super.tearDown(); + if (mRepository != null) { + // The test may have thrown exceptions which cause some + // repositories to kick off asynchronous repairs. They will + // immediately fail since the repository is about to be + // closed. This just eliminates uninteresting errors from being + // logged. + try { + RepairExecutor.waitForRepairsToFinish(10000); + } + catch (InterruptedException e) { + } + + mRepository.close(); + mRepository = null; + } + } + + /** + * Subclasses must implement this method to specify a repository. + */ + protected abstract Repository newRepository(boolean isMaster) + throws RepositoryException; + + /** + * provide subsequent access to the repository so the tests can do fancy things if + * interested. + * @return + */ + protected Repository getRepository() throws RepositoryException { + if (mRepository == null) { + mRepository = newRepository(true); + } + return mRepository; + } + + /** + * Create a random ID to eliminate optimistic lock conflicts due to ID collisions + * @param seed + * @return + */ + private int generateId(int seed) { + return seed*10000 + ((int)System.currentTimeMillis()) + s_Ids++; + } + + public void test_createAndRetrieve() throws Exception { + Storage<StorableTestBasic> storageSB = + getRepository().storageFor(StorableTestBasic.class); + + StorableTestBasic sb = storageSB.prepare(); + final int id = generateId(0); + sb.setId(id); + sb.setIntProp(1); + sb.setLongProp(1); + sb.setDoubleProp(1.1); + sb.setStringProp("one"); + sb.setDate(new DateTime("2005-08-26T08:09:00.000")); + sb.insert(); + + StorableTestBasic sb_load = storageSB.prepare(); + sb_load.setId(id); + sb_load.load(); + assertEquals(sb, sb_load); + + // Try re-inserting + // First, make sure the system disallows setting pk for loaded object + try { + sb.setId(id); + fail("successfully set pk on loaded object"); + } + catch (Exception e) { + } + + // Then the more common way: just create an identical new one + StorableTestBasic sbr = storageSB.prepare(); + sbr.setId(id); + sbr.setIntProp(1); + sbr.setLongProp(1); + sbr.setDoubleProp(1.1); + sbr.setStringProp("one"); + sb.setDate(new DateTime("2005-08-26T08:09:00.000")); + try { + sbr.insert(); + fail("PK constraint violation ignored"); + } + catch (UniqueConstraintException e) { + } + + + Storage<StorableTestMultiPK> storageMPK = + getRepository().storageFor(StorableTestMultiPK.class); + StorableTestMultiPK smpk = storageMPK.prepare(); + smpk.setIdPK(0); + smpk.setStringPK("zero"); + smpk.setStringData("and some data"); + smpk.insert(); + + StorableTestMultiPK smpk_load = storageMPK.prepare(); + smpk_load.setIdPK(0); + smpk_load.setStringPK("zero"); + smpk_load.load(); + assertEquals(smpk, smpk_load); + } + + public void test_storableStorableStates() throws Exception { + + Storage<StorableTestKeyValue> storageMinimal = + getRepository().storageFor(StorableTestKeyValue.class); + + // Start by just putting some targets in the repository + for (int i = 0; i < 10; i++) { + insert(storageMinimal, 100+i, 200+i); + } + + StorableTestKeyValue s = storageMinimal.prepare(); + StorableTestKeyValue s2 = storageMinimal.prepare(); + + // State: unloaded + // pk incomplete + assertInoperable(s, "new - untouched"); + assertFalse(s.hasDirtyProperties()); + + // new --set(pk)--> loadable incomplete + s.setKey1(0); + assertInoperable(s, "Loadable Incomplete"); + assertFalse(s.hasDirtyProperties()); + + s.setKey1(101); + assertInoperable(s, "loadable incomplete (2nd)"); + assertFalse(s.hasDirtyProperties()); + + // loadable incomplete --pkFilled--> loadable ready + s.setKey2(201); + assertEquals(true, s.tryDelete()); + assertFalse(s.hasDirtyProperties()); + + s.setKey1(102); + s.setKey2(202); + assertEquals(true, s.tryDelete()); + assertFalse(s.hasDirtyProperties()); + + // loadable ready --load()--> loaded + s.setKey1(103); + s.setKey2(203); + s.load(); + assertEquals(s.getValue1(), 1030); + assertEquals(s.getValue2(), 20300); + assertNoInsert(s, "written"); + assertNoSetPK(s, "written"); + assertFalse(s.hasDirtyProperties()); + + s2.setKey1(103); + s2.setKey2(203); + assertFalse(s2.hasDirtyProperties()); + s2.load(); + assertFalse(s2.hasDirtyProperties()); + + assertTrue(s.equalPrimaryKeys(s2)); + assertTrue(s.equalProperties(s2)); + assertEquals(s.storableType(), s2.storableType()); + assertTrue(s.equals(s2)); + assertEquals(s, s2); + s.setValue1(11); + s.setValue2(11111); + assertEquals(true, s.tryUpdate()); + assertEquals(11, s.getValue1()); + assertEquals(11111, s.getValue2()); + s2.load(); + assertEquals(s, s2); + + StorableTestKeyValue s3 = storageMinimal.prepare(); + s.copyPrimaryKeyProperties(s3); + s3.tryUpdate(); + assertEquals(s, s3); + + s.setValue2(222222); + assertTrue(s.hasDirtyProperties()); + s.load(); + assertFalse(s.hasDirtyProperties()); + assertEquals(s, s2); + + // Update should return true, even though it probably didn't actually + // touch the storage layer. + assertEquals(true, s.tryUpdate()); + + s.tryDelete(); + assertNoLoad(s, "deleted"); + // After delete, saved properties remain dirty. + assertTrue(s.hasDirtyProperties()); + + s.insert(); + assertFalse(s.hasDirtyProperties()); + s.load(); + assertFalse(s.hasDirtyProperties()); + assertEquals(s, s2); + } + + public void test_storableInteractions() throws Exception { + Storage<StorableTestBasic> storage = getRepository().storageFor(StorableTestBasic.class); + StorableTestBasic s = storage.prepare(); + final int id = generateId(111); + s.setId(id); + s.initBasicProperties(); + assertTrue(s.hasDirtyProperties()); + s.insert(); + assertFalse(s.hasDirtyProperties()); + + StorableTestBasic s2 = storage.prepare(); + s2.setId(id); + s2.load(); + assertTrue(s2.equalPrimaryKeys(s)); + assertTrue(s2.equalProperties(s)); + assertTrue(s2.equals(s)); + + StorableTestBasic s3 = storage.prepare(); + s3.setId(id); + s3.tryDelete(); + + // Should be able to re-insert. + s2.insert(); + s2.load(); + assertTrue(s2.equalPrimaryKeys(s)); + assertTrue(s2.equalProperties(s)); + assertTrue(s2.equals(s)); + + // Delete in preparation for next test. + s3.tryDelete(); + + s.setStringProp("updated by s"); + // The object is gone, we can't update it + assertEquals(false, s.tryUpdate()); + // ...or load it + try { + s2.load(); + fail("shouldn't be able to load a deleted object"); + } + catch (FetchException e) { + } + } + + public void test_assymetricStorable() throws Exception { + try { + Storage<StorableTestAssymetric> storage = + getRepository().storageFor(StorableTestAssymetric.class); + } + catch (Exception e) { + fail("exception creating storable with assymetric concrete getter?" + e); + } + try { + Storage<StorableTestAssymetricGet> storage = + getRepository().storageFor(StorableTestAssymetricGet.class); + fail("Created assymetric storabl`e"); + } + catch (Exception e) { + } + try { + Storage<StorableTestAssymetricSet> storage = + getRepository().storageFor(StorableTestAssymetricSet.class); + fail("Created assymetric storable"); + } + catch (Exception e) { + } + try { + Storage<StorableTestAssymetricGetSet> storage = + getRepository().storageFor(StorableTestAssymetricGetSet.class); + fail("Created assymetric storable"); + } + catch (Exception e) { + } + } + + private void assertNoSetPK(StorableTestKeyValue aStorableTestKeyValue, + String aState) + { + try { + aStorableTestKeyValue.setKey1(1111); + fail("'set pk' for '" + aState + "' succeeded"); + } + catch (Exception e) { + } + } + + private void assertInoperable(Storable aStorable, String aState) { + assertNoInsert(aStorable, aState); + assertNoUpdate(aStorable, aState); + assertNoLoad(aStorable, aState); + assertNoDelete(aStorable, aState); + } + + private void assertNoDelete(Storable aStorable, String aState) { + try { + aStorable.tryDelete(); + fail("'delete' for '" + aState + "' succeeded"); + } + catch (PersistException e) { + } + catch (IllegalStateException e) { + } + } + + private void assertNoLoad(Storable aStorable, String aState) { + try { + aStorable.load(); + fail("'load' for '" + aState + "' succeeded"); + } + catch (FetchException e) { + } + catch (IllegalStateException e) { + } + } + + private void assertNoInsert(Storable aStorable, String aState) { + try { + aStorable.insert(); + fail("'insert' for '" + aState + "' succeeded"); + } + catch (PersistException e) { + } + catch (IllegalStateException e) { + } + } + + private void assertNoUpdate(Storable aStorable, String aState) { + try { + aStorable.tryUpdate(); + fail("'update' for '" + aState + "' succeeded"); + } + catch (PersistException e) { + } + catch (IllegalStateException e) { + } + } + + private void insert(Storage<StorableTestKeyValue> aStorageMinimal, + int key1, + int key2) throws PersistException + { + StorableTestKeyValue s = aStorageMinimal.prepare(); + s.setKey1(key1); + s.setKey2(key2); + s.setValue1(key1*10); + s.setValue2(key2*100); + s.insert(); + } + + public void test_copyStorableProperties() throws Exception { + Storage<StorableTestBasic> storage = getRepository().storageFor(StorableTestBasic.class); + StorableTestBasic storable = storage.prepare(); + + InvocationTracker tracker = new InvocationTracker("tracker", false); + storable.copyAllProperties(tracker); + // unloaded, untouched; nothing happens + tracker.assertTrack(0); + + storable.setId(generateId(1)); + storable.setIntProp(1); + storable.copyAllProperties(tracker); + tracker.assertTrack(0x1 + 0x10); + tracker.clearTracks(); + + storable.initBasicProperties(); + storable.copyAllProperties(tracker); + tracker.assertTrack(ALL_SET_METHODS); + tracker.clearTracks(); + + storable = storage.prepare(); + storable.copyPrimaryKeyProperties(tracker); + tracker.assertTrack(0); + storable.initPrimaryKeyProperties(); + storable.copyPrimaryKeyProperties(tracker); + tracker.assertTrack(ALL_PRIMARY_KEYS); + tracker.clearTracks(); + + storable = storage.prepare(); + storable.copyUnequalProperties(tracker); + tracker.assertTrack(0); + storable.setIntProp(0); // this will now be dirty, and equal + storable.copyUnequalProperties(tracker); + tracker.assertTrack(0x8); + storable.setIntProp(1); // this will now be dirty and not equal + storable.copyUnequalProperties(tracker); + tracker.assertTrack(0x8 | 0x10); + + // get a fresh one + storable = storage.prepare(); + storable.setStringProp("hi"); + storable.setId(22); + storable.copyPrimaryKeyProperties(tracker); + storable.copyDirtyProperties(tracker); + tracker.assertTrack(0x05); + } + + public void test_copy() throws Exception { + Storage<StorableTestBasic> storage = getRepository().storageFor(StorableTestBasic.class); + StorableTestBasic storable = storage.prepare(); + + storable.setId(5); + storable.setStringProp("hello"); + storable.setIntProp(512); + storable.setLongProp(45354L); + storable.setDoubleProp(56734.234); + + Storable copy = storable.copy(); + + assertEquals(storable.getClass(), copy.getClass()); + assertEquals(storable, copy); + + StorableTestBasic castedCopy = (StorableTestBasic) copy; + + assertEquals(storable.getId(), castedCopy.getId()); + assertEquals(storable.getStringProp(), castedCopy.getStringProp()); + assertEquals(storable.getIntProp(), castedCopy.getIntProp()); + assertEquals(storable.getLongProp(), castedCopy.getLongProp()); + assertEquals(storable.getDoubleProp(), castedCopy.getDoubleProp()); + } + + public void test_invalidStorables() throws Exception { + try { + getRepository().storageFor(StorableTestInvalid.class); + fail("prepared invalid storable"); + } + catch (RepositoryException e) { + } + } + + public void test_invalidPatterns() throws Exception { + // Minimal -- try setting with no PK + Storage<StorableTestMinimal> storageMinimal = + getRepository().storageFor(StorableTestMinimal.class); + StorableTestMinimal s = storageMinimal.prepare(); + assertNoInsert(s, "new (minimal)"); + + s.setId(generateId(0)); + s.insert(); + + // Basic -- try combinations of PK, fields + // First, fill in all the fields but no PK + Storage<StorableTestBasic> storageBasic = + getRepository().storageFor(StorableTestBasic.class); + StorableTestBasic sb = storageBasic.prepare(); + assertNoInsert(sb, "new (basic)");; + + sb.setIntProp(0); + sb.setIntProp(1); + sb.setLongProp(1); + sb.setDoubleProp(1.1); + sb.setStringProp("one"); + sb.setDate(new DateTime("2005-08-26T08:09:00.000")); + assertNoInsert(sb, "SB: Storable incomplete (pkMissing)"); + + sb.setId(generateId(2)); + sb.insert(); + + // Now try leaving one of the fields empty. + sb = storageBasic.prepare(); + final int id = generateId(3); + sb.setId(id); + sb.setIntProp(0); + sb.setIntProp(1); + sb.setLongProp(1); + sb.setDoubleProp(1.1); + try { + sb.insert(); + fail(); + } catch (ConstraintException e) { + } + + sb = storageBasic.prepare(); + sb.setId(id); + try { + sb.load(); + fail(); + } catch (FetchNoneException e) { + } + } + + public void test_nonDestructiveUpdate() throws Exception { + Storage<StorableTestBasic> storage = getRepository().storageFor(StorableTestBasic.class); + StorableTestBasic s = storage.prepare(); + + int id = generateId(3943945); + s.setId(id); + s.setStringProp("hello"); + s.setIntProp(56); + s.setLongProp(99999999999999999L); + s.setDoubleProp(Double.NaN); + + s.insert(); + + s = storage.prepare(); + + s.setId(id); + s.setIntProp(100); + assertEquals(true, s.tryUpdate()); + + assertEquals("hello", s.getStringProp()); + assertEquals(100, s.getIntProp()); + assertEquals(99999999999999999L, s.getLongProp()); + assertEquals(Double.NaN, s.getDoubleProp()); + + s = storage.prepare(); + + s.setId(id); + s.load(); + + assertEquals("hello", s.getStringProp()); + assertEquals(100, s.getIntProp()); + assertEquals(99999999999999999L, s.getLongProp()); + assertEquals(Double.NaN, s.getDoubleProp()); + } + + public void test_updateLoadSideEffect() throws Exception { + Storage<StorableTestBasic> storage = getRepository().storageFor(StorableTestBasic.class); + + StorableTestBasic s = storage.prepare(); + final int id = generateId(500); + s.setId(id); + s.setStringProp("hello"); + s.setIntProp(10); + s.setLongProp(123456789012345L); + s.setDoubleProp(Double.POSITIVE_INFINITY); + s.insert(); + + s = storage.prepare(); + s.setId(id); + + assertEquals(id, s.getId()); + assertEquals(0, s.getIntProp()); + assertEquals(0L, s.getLongProp()); + assertEquals(0.0, s.getDoubleProp()); + + assertFalse(s.hasDirtyProperties()); + + // Even if nothing was updated, must load fresh copy. + assertTrue(s.tryUpdate()); + assertEquals(id, s.getId()); + assertEquals(10, s.getIntProp()); + assertEquals(123456789012345L, s.getLongProp()); + assertEquals(Double.POSITIVE_INFINITY, s.getDoubleProp()); + } + + public void test_versioning() throws Exception { + Storage<StorableVersioned> storage = getRepository().storageFor(StorableVersioned.class); + + StorableVersioned s = storage.prepare(); + s.setID(500); + s.setValue("hello"); + try { + // Require version property to be set. + s.tryUpdate(); + fail(); + } catch (IllegalStateException e) { + } + + s.setVersion(1); + try { + // Cannot update that which does not exist. + s.update(); + fail(); + } catch (PersistNoneException e) { + } + + s.insert(); + + s.setVersion(2); + try { + // Record version mismatch. + s.tryUpdate(); + fail(); + } catch (OptimisticLockException e) { + } + + s.setVersion(1); + s.setValue("world"); + s.tryUpdate(); + + assertEquals(2, s.getVersion()); + assertEquals("world", s.getValue()); + + // Since no properties changed, update does not increase version. + assertEquals(true, s.tryUpdate()); + assertEquals(2, s.getVersion()); + + // Simple test to ensure that version property doesn't need to be + // dirtied. + s = storage.prepare(); + s.setID(500); + s.load(); + s.setValue("hello"); + assertTrue(s.tryUpdate()); + } + + public void test_versioningWithLong() throws Exception { + Storage<StorableVersionedWithLong> storage = + getRepository().storageFor(StorableVersionedWithLong.class); + + StorableVersionedWithLong s = storage.prepare(); + s.setID(500); + s.setValue("hello"); + try { + // Require version property to be set. + s.tryUpdate(); + fail(); + } catch (IllegalStateException e) { + } + + s.setVersion(1); + try { + // Cannot update that which does not exist. + s.update(); + fail(); + } catch (PersistNoneException e) { + } + + s.insert(); + + s.setVersion(2); + try { + // Record version mismatch. + s.tryUpdate(); + fail(); + } catch (OptimisticLockException e) { + } + + s.setVersion(1); + s.setValue("world"); + s.tryUpdate(); + + assertEquals(2, s.getVersion()); + assertEquals("world", s.getValue()); + + // Since no properties changed, update does not increase version. + assertEquals(true, s.tryUpdate()); + assertEquals(2, s.getVersion()); + } + + public void test_versioningWithObj() throws Exception { + Storage<StorableVersionedWithObj> storage = + getRepository().storageFor(StorableVersionedWithObj.class); + + StorableVersionedWithObj s = storage.prepare(); + s.setID(generateId(500)); + s.setValue("hello"); + try { + // Require version property to be set. + s.tryUpdate(); + fail(); + } catch (IllegalStateException e) { + } + + s.setVersion(null); + try { + // Cannot update that which does not exist. + s.update(); + fail(); + } catch (PersistNoneException e) { + } + + s.insert(); + + assertNull(s.getVersion()); + + s.setVersion(2); + try { + // Record version mismatch. + s.tryUpdate(); + fail(); + } catch (OptimisticLockException e) { + } + + s.setVersion(null); + s.setValue("world"); + s.tryUpdate(); + + assertEquals((Integer) 1, s.getVersion()); + assertEquals("world", s.getValue()); + + s.setValue("value"); + s.tryUpdate(); + + assertEquals((Integer) 2, s.getVersion()); + assertEquals("value", s.getValue()); + + // Since no properties changed, update does not increase version. + assertEquals(true, s.tryUpdate()); + assertEquals((Integer) 2, s.getVersion()); + } + + public void test_versioningWithLongObj() throws Exception { + Storage<StorableVersionedWithLongObj> storage = + getRepository().storageFor(StorableVersionedWithLongObj.class); + + StorableVersionedWithLongObj s = storage.prepare(); + s.setID(500); + s.setValue("hello"); + try { + // Require version property to be set. + s.tryUpdate(); + fail(); + } catch (IllegalStateException e) { + } + + s.setVersion(null); + try { + // Cannot update that which does not exist. + s.update(); + fail(); + } catch (PersistNoneException e) { + } + + s.insert(); + + assertNull(s.getVersion()); + + s.setVersion(2L); + try { + // Record version mismatch. + s.tryUpdate(); + fail(); + } catch (OptimisticLockException e) { + } + + s.setVersion(null); + s.setValue("world"); + s.tryUpdate(); + + assertEquals((Long) 1L, s.getVersion()); + assertEquals("world", s.getValue()); + + s.setValue("value"); + s.tryUpdate(); + + assertEquals((Long) 2L, s.getVersion()); + assertEquals("value", s.getValue()); + + // Since no properties changed, update does not increase version. + assertEquals(true, s.tryUpdate()); + assertEquals((Long) 2L, s.getVersion()); + } + + public void test_initialVersion() throws Exception { + Storage<StorableVersioned> storage = getRepository().storageFor(StorableVersioned.class); + + StorableVersioned s = storage.prepare(); + s.setID(987); + s.setValue("hello"); + assertEquals(0, s.getVersion()); + s.insert(); + assertEquals(1, s.getVersion()); + + s = storage.prepare(); + s.setID(12345); + s.setValue("world"); + assertEquals(0, s.getVersion()); + s.setVersion(56); + assertEquals(56, s.getVersion()); + s.insert(); + assertEquals(56, s.getVersion()); + } + + public void test_initialVersionWithLong() throws Exception { + Storage<StorableVersionedWithLong> storage = + getRepository().storageFor(StorableVersionedWithLong.class); + + StorableVersionedWithLong s = storage.prepare(); + s.setID(987); + s.setValue("hello"); + assertEquals(0, s.getVersion()); + s.insert(); + assertEquals(1, s.getVersion()); + + s = storage.prepare(); + s.setID(12345); + s.setValue("world"); + assertEquals(0, s.getVersion()); + s.setVersion(56); + assertEquals(56, s.getVersion()); + s.insert(); + assertEquals(56, s.getVersion()); + } + + public void test_initialVersionWithObj() throws Exception { + Storage<StorableVersionedWithObj> storage = + getRepository().storageFor(StorableVersionedWithObj.class); + + StorableVersionedWithObj s = storage.prepare(); + s.setID(987); + s.setValue("hello"); + assertNull(s.getVersion()); + s.insert(); + assertEquals((Integer) 1, s.getVersion()); + + s = storage.prepare(); + s.setID(12345); + s.setValue("world"); + assertNull(s.getVersion()); + s.setVersion(56); + assertEquals((Integer) 56, s.getVersion()); + s.insert(); + assertEquals((Integer) 56, s.getVersion()); + } + + public void test_initialVersionWithLongObj() throws Exception { + Storage<StorableVersionedWithLongObj> storage = + getRepository().storageFor(StorableVersionedWithLongObj.class); + + StorableVersionedWithLongObj s = storage.prepare(); + s.setID(987); + s.setValue("hello"); + assertNull(s.getVersion()); + s.insert(); + assertEquals((Long) 1L, s.getVersion()); + + s = storage.prepare(); + s.setID(12345); + s.setValue("world"); + assertNull(s.getVersion()); + s.setVersion(56L); + assertEquals((Long) 56L, s.getVersion()); + s.insert(); + assertEquals((Long) 56L, s.getVersion()); + } + + public void test_versioningMissingRecord() throws Exception { + Storage<StorableVersioned> storage = getRepository().storageFor(StorableVersioned.class); + + StorableVersioned s = storage.prepare(); + s.setID(500); + s.setValue("hello"); + s.insert(); + + // Now delete it from under our feet. + StorableVersioned s2 = storage.prepare(); + s2.setID(500); + s2.delete(); + + s.setValue("world"); + s.tryUpdate(); + + s.insert(); + + // Delete it again. + s2.delete(); + + // Update without changing and properties must still reload, which should fail. + assertFalse(s.tryUpdate()); + } + + public void test_versioningDisabled() throws Exception { + // Make sure repository works properly when configured as non-master. + Repository repo = newRepository(false); + Storage<StorableVersioned> storage = repo.storageFor(StorableVersioned.class); + + StorableVersioned s = storage.prepare(); + s.setID(500); + s.setValue("hello"); + try { + // Require version property to be set. + s.tryUpdate(); + fail(); + } catch (IllegalStateException e) { + } + + s.setVersion(1); + assertEquals(false, s.tryUpdate()); + + s.insert(); + + s.setVersion(2); + assertEquals(true, s.tryUpdate()); + + s.setVersion(1); + s.setValue("world"); + s.tryUpdate(); + + assertEquals(1, s.getVersion()); + assertEquals("world", s.getValue()); + + RepairExecutor.waitForRepairsToFinish(10000); + + repo.close(); + repo = null; + } + + public void test_sequences() throws Exception { + Storage<StorableSequenced> storage = getRepository().storageFor(StorableSequenced.class); + + StorableSequenced seq = storage.prepare(); + seq.setData("hello"); + seq.insert(); + + assertEquals(1L, seq.getID()); + assertEquals(1, seq.getSomeInt()); + assertEquals(Integer.valueOf(1), seq.getSomeIntegerObj()); + assertEquals(1L, seq.getSomeLong()); + assertEquals(Long.valueOf(1L), seq.getSomeLongObj()); + assertEquals("1", seq.getSomeString()); + assertEquals("hello", seq.getData()); + + seq = storage.prepare(); + seq.setData("foo"); + seq.insert(); + + assertEquals(2L, seq.getID()); + assertEquals(2, seq.getSomeInt()); + assertEquals(Integer.valueOf(2), seq.getSomeIntegerObj()); + assertEquals(2L, seq.getSomeLong()); + assertEquals(Long.valueOf(2L), seq.getSomeLongObj()); + assertEquals("2", seq.getSomeString()); + assertEquals("foo", seq.getData()); + + seq = storage.prepare(); + seq.setSomeInt(100); + seq.setSomeLongObj(null); + seq.setData("data"); + seq.insert(); + + assertEquals(3L, seq.getID()); + assertEquals(100, seq.getSomeInt()); + assertEquals(null, seq.getSomeLongObj()); + + seq = storage.prepare(); + seq.setData("world"); + seq.insert(); + + assertEquals(4L, seq.getID()); + assertEquals(3, seq.getSomeInt()); + assertEquals(Integer.valueOf(4), seq.getSomeIntegerObj()); + assertEquals(4L, seq.getSomeLong()); + assertEquals(Long.valueOf(3L), seq.getSomeLongObj()); + assertEquals("4", seq.getSomeString()); + } + + public void test_oldIndexEntryDeletion() throws Exception { + // Very simple test that ensures that old index entries are deleted + // when the master record is updated. There is no guarantee that the + // chosen repository supports indexes, and there is no guarantee that + // it is selecting the desired index. Since the index set is simple and + // so are the queries, I think it is safe to assume that the selected + // index is what I expect it to be. Repositories that support + // custom indexing should have more rigorous tests. + + Storage<StorableTestBasicIndexed> storage = + getRepository().storageFor(StorableTestBasicIndexed.class); + + StorableTestBasicIndexed s = storage.prepare(); + final int id1 = generateId(1); + s.setId(id1); + s.setStringProp("hello"); + s.setIntProp(3); + s.setLongProp(4); + s.setDoubleProp(5); + s.insert(); + + s = storage.prepare(); + final int id6 = generateId(6); + s.setId(id6); + s.setStringProp("hello"); + s.setIntProp(8); + s.setLongProp(9); + s.setDoubleProp(10); + s.insert(); + + s = storage.prepare(); + final int id11 = generateId(11); + s.setId(id11); + s.setStringProp("world"); + s.setIntProp(3); + s.setLongProp(14); + s.setDoubleProp(15); + s.insert(); + + // First verify that queries report what we expect. Don't perform an + // orderBy on query, as that might interfere with index selection. + Query<StorableTestBasicIndexed> q = storage.query("stringProp = ?").with("hello"); + List<StorableTestBasicIndexed> list = q.fetch().toList(); + assertEquals(2, list.size()); + if (list.get(0).getId() == id1) { + assertEquals(id6, list.get(1).getId()); + } else { + assertEquals(id6, list.get(0).getId()); + } + + q = storage.query("stringProp = ?").with("world"); + list = q.fetch().toList(); + assertEquals(1, list.size()); + assertEquals(id11, list.get(0).getId()); + + q = storage.query("intProp = ?").with(3); + list = q.fetch().toList(); + assertEquals(2, list.size()); + if (list.get(0).getId() == id1) { + assertEquals(id11, list.get(1).getId()); + } else { + assertEquals(id11, list.get(0).getId()); + } + + // Now update and verify changes to query results. + s = storage.prepare(); + s.setId(id1); + s.load(); + s.setStringProp("world"); + s.tryUpdate(); + + q = storage.query("stringProp = ?").with("hello"); + list = q.fetch().toList(); + assertEquals(1, list.size()); + assertEquals(id6, list.get(0).getId()); + + q = storage.query("stringProp = ?").with("world"); + list = q.fetch().toList(); + assertEquals(2, list.size()); + if (list.get(0).getId() == id1) { + assertEquals(id11, list.get(1).getId()); + } else { + assertEquals(id11, list.get(0).getId()); + } + + q = storage.query("intProp = ?").with(3); + list = q.fetch().toList(); + assertEquals(2, list.size()); + if (list.get(0).getId() == id1) { + assertEquals(id11, list.get(1).getId()); + } else { + assertEquals(id11, list.get(0).getId()); + } + } + + public void test_falseDoubleUpdate() throws Exception { + Storage<StorableTestBasic> storage = getRepository().storageFor(StorableTestBasic.class); + + StorableTestBasic s = storage.prepare(); + s.setId(56789); + + assertFalse(s.tryUpdate()); + assertFalse(s.tryUpdate()); + } + + public void test_dateTimeIndex() throws Exception { + Storage<StorableDateIndex> storage = getRepository().storageFor(StorableDateIndex.class); + + DateTimeZone original = DateTimeZone.getDefault(); + // Set time zone different than defined in storable. + DateTimeZone.setDefault(DateTimeZone.forID("America/Los_Angeles")); + try { + DateTime now = new DateTime(); + + StorableDateIndex sdi = storage.prepare(); + sdi.setID(1); + sdi.setOrderDate(now); + sdi.insert(); + + sdi.load(); + + assertEquals(now.getMillis(), sdi.getOrderDate().getMillis()); + // Time zones will differ, since adapter is applied upon load. + assertFalse(now.equals(sdi.getOrderDate())); + + Query<StorableDateIndex> query = storage.query("orderDate=?").with(now); + // Tests that adapter is applied to index. Otherwise, consistency + // check will reject loaded storable. + StorableDateIndex sdi2 = query.tryLoadOne(); + assertNotNull(sdi2); + } finally { + DateTimeZone.setDefault(original); + } + } + + public void test_joinCache() throws Exception { + Storage<UserAddress> uaStorage = getRepository().storageFor(UserAddress.class); + Storage<UserInfo> uiStorage = getRepository().storageFor(UserInfo.class); + + UserAddress addr = uaStorage.prepare(); + addr.setAddressID(5); + addr.setLine1("123"); + addr.setCity("Seattle"); + addr.setState("WA"); + addr.setCountry("USA"); + addr.insert(); + + UserInfo user = uiStorage.prepare(); + user.setUserID(1); + user.setStateID(1); + user.setFirstName("John"); + user.setLastName("Smith"); + user.setAddress(addr); + + assertEquals("Seattle", user.getAddress().getCity()); + + user.insert(); + + addr.setCity("Bellevue"); + addr.tryUpdate(); + + // Should still refer to same address instance. + assertEquals("Bellevue", user.getAddress().getCity()); + + UserAddress addr2 = uaStorage.prepare(); + addr2.setAddressID(5); + addr2.setCity("Kirkland"); + addr2.tryUpdate(); + + // Should still refer to same address instance. + assertEquals("Bellevue", user.getAddress().getCity()); + + // Force reload of user should flush cache. + user.load(); + + assertEquals("Kirkland", user.getAddress().getCity()); + + addr2.setCity("Redmond"); + addr2.tryUpdate(); + + // Should still refer to same address instance. + assertEquals("Kirkland", user.getAddress().getCity()); + + // Update of user should flush cache (even if nothing changed) + assertEquals(true, user.tryUpdate()); + + assertEquals("Redmond", user.getAddress().getCity()); + + addr2.setCity("Renton"); + addr2.tryUpdate(); + + // Should still refer to same address instance. + assertEquals("Redmond", user.getAddress().getCity()); + + // Update of user should flush cache (when something changed) + user.setFirstName("Jim"); + assertEquals(true, user.tryUpdate()); + + assertEquals("Renton", user.getAddress().getCity()); + + addr2.setCity("Tacoma"); + addr2.tryUpdate(); + + // Should still refer to same address instance. + assertEquals("Renton", user.getAddress().getCity()); + + // Delete of user should flush cache + assertEquals(true, user.tryDelete()); + + assertEquals("Tacoma", user.getAddress().getCity()); + + addr2.setCity("Shoreline"); + addr2.tryUpdate(); + + // Should still refer to same address instance. + assertEquals("Tacoma", user.getAddress().getCity()); + + // Failed load of user should flush cache + assertEquals(false, user.tryLoad()); + + assertEquals("Shoreline", user.getAddress().getCity()); + + addr2.setCity("Vancouver"); + addr2.tryUpdate(); + + // Should still refer to same address instance. + assertEquals("Shoreline", user.getAddress().getCity()); + + // Insert of user should flush cache + user.insert(); + + assertEquals("Vancouver", user.getAddress().getCity()); + } + + public void test_updateReload() throws Exception { + Storage<UserInfo> uiStorage = getRepository().storageFor(UserInfo.class); + + UserInfo user = uiStorage.prepare(); + user.setUserID(1); + user.setStateID(1); + user.setFirstName("John"); + user.setLastName("Smith"); + user.setAddressID(0); + user.insert(); + + UserInfo user2 = uiStorage.prepare(); + user2.setUserID(1); + user2.setFirstName("Jim"); + user2.tryUpdate(); + + assertEquals("John", user.getFirstName()); + user.tryUpdate(); + assertEquals("Jim", user.getFirstName()); + + user2.setFirstName("Bob"); + user2.tryUpdate(); + + assertEquals("Jim", user.getFirstName()); + user.setLastName("Jones"); + user.tryUpdate(); + assertEquals("Bob", user.getFirstName()); + assertEquals("Jones", user.getLastName()); + } + + public void test_deleteState() throws Exception { + Storage<UserInfo> uiStorage = getRepository().storageFor(UserInfo.class); + + UserInfo user = uiStorage.prepare(); + user.setUserID(1); + user.setStateID(1); + user.setFirstName("John"); + user.setLastName("Smith"); + user.setAddressID(0); + user.insert(); + + UserInfo user2 = uiStorage.prepare(); + user2.setUserID(1); + user2.tryDelete(); + + assertFalse(user.tryLoad()); + + // Should be able to change pk now. + user.setUserID(2); + assertFalse(user.tryUpdate()); + user.setUserID(1); + user.insert(); + + user2.tryDelete(); + + assertFalse(user.tryUpdate()); + + // Should be able to change pk now. + user.setUserID(2); + assertFalse(user.tryUpdate()); + user.setUserID(1); + user.insert(); + user2.tryDelete(); + + user.setFirstName("Jim"); + assertFalse(user.tryUpdate()); + + // Should be able to change pk now. + user.setUserID(2); + assertFalse(user.tryUpdate()); + user.setUserID(1); + user.insert(); + assertEquals("Jim", user.getFirstName()); + } + + public void test_deleteUpdate() throws Exception { + Storage<UserInfo> uiStorage = getRepository().storageFor(UserInfo.class); + + UserInfo user = uiStorage.prepare(); + user.setUserID(1); + user.setStateID(1); + user.setFirstName("John"); + user.setLastName("Smith"); + user.setAddressID(0); + user.insert(); + + // Just want to change first name now + user.setFirstName("Bob"); + + // Concurrently, someone else deletes the user + UserInfo user2 = uiStorage.prepare(); + user2.setUserID(1); + assertTrue(user2.tryDelete()); + + assertFalse(user.tryUpdate()); + + // Update failed... perhaps we should try again... (wrong decision) + + // Concurrently, someone inserts a different user with re-used id. (wrong decision) + user2 = uiStorage.prepare(); + user2.setUserID(1); + user2.setStateID(1); + user2.setFirstName("Mike"); + user2.setLastName("Jones"); + user2.setAddressID(0); + user2.insert(); + + // Trying the failed update again should totally blow away the sneaked in insert. + assertTrue(user.tryUpdate()); + + assertEquals("Bob", user.getFirstName()); + assertEquals("Smith", user.getLastName()); + + // The failed update earlier dirtied all the properties, including ones + // that were not modified. As a result, the second update replaces all + // properties. This is a special edge case destructive update for which + // there is no clear solution. If just the one property was changed as + // instructed earlier, then the record would have been corrupted. This + // feels much worse. This can still happen if the record was not + // originally fully clean. + + // The cause of the error is the user creating a new record with a + // re-used id. This problem could be prevented using transactions, or + // it might be detected with optimistic locking. + } + + public void test_deleteOne() throws Exception { + Storage<UserInfo> uiStorage = getRepository().storageFor(UserInfo.class); + + UserInfo user = uiStorage.prepare(); + user.setUserID(1); + user.setStateID(1); + user.setFirstName("Bob"); + user.setLastName("Smith"); + user.setAddressID(0); + user.insert(); + + user = uiStorage.prepare(); + user.setUserID(2); + user.setStateID(1); + user.setFirstName("Bob"); + user.setLastName("Jones"); + user.setAddressID(0); + user.insert(); + + user = uiStorage.prepare(); + user.setUserID(3); + user.setStateID(1); + user.setFirstName("Indiana"); + user.setLastName("Jones"); + user.setAddressID(0); + user.insert(); + + try { + uiStorage.query("lastName = ?").with("Jones").deleteOne(); + fail(); + } catch (PersistMultipleException e) { + } + + List<UserInfo> list = uiStorage.query().fetch().toList(); + assertEquals(3, list.size()); + + uiStorage.query("lastName = ? & firstName = ?").with("Jones").with("Bob").deleteOne(); + + list = uiStorage.query().orderBy("userID").fetch().toList(); + assertEquals(2, list.size()); + + assertEquals("Bob", list.get(0).getFirstName()); + assertEquals("Smith", list.get(0).getLastName()); + assertEquals("Indiana", list.get(1).getFirstName()); + assertEquals("Jones", list.get(1).getLastName()); + } + + public void test_triggers() throws Exception { + Storage<StorableVersioned> storage = getRepository().storageFor(StorableVersioned.class); + + class InsertTrigger extends Trigger<StorableVersioned> { + Object mState; + + @Override + public Object beforeInsert(StorableVersioned s) { + assertEquals(1, s.getID()); + mState = new Object(); + return mState; + } + + @Override + public void afterInsert(StorableVersioned s, Object state) { + assertEquals(1, s.getID()); + assertEquals(mState, state); + } + }; + + InsertTrigger it = new InsertTrigger(); + + assertTrue(storage.addTrigger(it)); + + StorableVersioned s = storage.prepare(); + s.setID(1); + s.setValue("value"); + s.insert(); + + assertTrue(it.mState != null); + + assertTrue(storage.removeTrigger(it)); + + class UpdateTrigger extends Trigger<StorableVersioned> { + Object mState; + int mVersion; + + @Override + public Object beforeUpdate(StorableVersioned s) { + assertEquals(1, s.getID()); + mState = new Object(); + mVersion = s.getVersion(); + return mState; + } + + @Override + public void afterUpdate(StorableVersioned s, Object state) { + assertEquals(1, s.getID()); + assertEquals(mState, state); + assertEquals(mVersion + 1, s.getVersion()); + } + }; + + UpdateTrigger ut = new UpdateTrigger(); + + assertTrue(storage.addTrigger(ut)); + + s.setValue("value2"); + s.update(); + + assertTrue(ut.mState != null); + + assertTrue(storage.removeTrigger(ut)); + + class DeleteTrigger extends Trigger<StorableVersioned> { + Object mState; + + @Override + public Object beforeDelete(StorableVersioned s) { + assertEquals(1, s.getID()); + mState = new Object(); + return mState; + } + + @Override + public void afterDelete(StorableVersioned s, Object state) { + assertEquals(1, s.getID()); + assertEquals(mState, state); + } + }; + + DeleteTrigger dt = new DeleteTrigger(); + + assertTrue(storage.addTrigger(dt)); + + s.delete(); + + assertTrue(dt.mState != null); + + assertTrue(storage.removeTrigger(dt)); + } + + public void test_triggerFailure() throws Exception { + Storage<StorableVersioned> storage = getRepository().storageFor(StorableVersioned.class); + + class InsertTrigger extends Trigger<StorableVersioned> { + boolean failed; + + @Override + public Object beforeInsert(StorableVersioned s) { + throw new RuntimeException(); + } + + @Override + public void afterInsert(StorableVersioned s, Object state) { + fail(); + } + + @Override + public void failedInsert(StorableVersioned s, Object state) { + failed = true; + } + }; + + InsertTrigger it = new InsertTrigger(); + + assertTrue(storage.addTrigger(it)); + + StorableVersioned s = storage.prepare(); + s.setID(1); + s.setValue("value"); + try { + s.insert(); + fail(); + } catch (RuntimeException e) { + } + + assertTrue(it.failed); + + class UpdateTrigger extends Trigger<StorableVersioned> { + boolean failed; + + @Override + public Object beforeUpdate(StorableVersioned s) { + throw new RuntimeException(); + } + + @Override + public void afterUpdate(StorableVersioned s, Object state) { + fail(); + } + + @Override + public void failedUpdate(StorableVersioned s, Object state) { + failed = true; + } + }; + + UpdateTrigger ut = new UpdateTrigger(); + + assertTrue(storage.addTrigger(ut)); + + s = storage.prepare(); + s.setID(1); + s.setVersion(3); + s.setValue("value"); + try { + s.update(); + fail(); + } catch (RuntimeException e) { + } + + assertTrue(ut.failed); + + class DeleteTrigger extends Trigger<StorableVersioned> { + boolean failed; + + @Override + public Object beforeDelete(StorableVersioned s) { + throw new RuntimeException(); + } + + @Override + public void afterDelete(StorableVersioned s, Object state) { + fail(); + } + + @Override + public void failedDelete(StorableVersioned s, Object state) { + failed = true; + } + }; + + DeleteTrigger dt = new DeleteTrigger(); + + assertTrue(storage.addTrigger(dt)); + + s = storage.prepare(); + s.setID(1); + try { + s.delete(); + fail(); + } catch (RuntimeException e) { + } + + assertTrue(dt.failed); + } + + public void test_triggerChecks() throws Exception { + Storage<StorableTimestamped> storage = + getRepository().storageFor(StorableTimestamped.class); + + StorableTimestamped st = storage.prepare(); + st.setId(1); + st.setValue("value"); + + try { + st.insert(); + fail(); + } catch (ConstraintException e) { + // We forgot to set submitDate and modifyDate. + } + + // Install trigger that sets the timestamp properties. + + storage.addTrigger(new Trigger<Timestamped>() { + @Override + public Object beforeInsert(Timestamped st) { + DateTime now = new DateTime(); + st.setSubmitDateTime(now); + st.setModifyDateTime(now); + return null; + } + + @Override + public Object beforeUpdate(Timestamped st) { + DateTime now = new DateTime(); + st.setModifyDateTime(now); + return null; + } + }); + + st.insert(); + + assertNotNull(st.getSubmitDateTime()); + assertNotNull(st.getModifyDateTime()); + + DateTime dt = st.getModifyDateTime(); + + Thread.sleep(500); + + st.setValue("foo"); + st.update(); + + assertTrue(st.getModifyDateTime().getMillis() >= dt.getMillis() + 450); + } + + public void test_hashCode() throws Exception { + Storage<StorableTestBasic> storage = + getRepository().storageFor(StorableTestBasic.class); + + StorableTestBasic stb = storage.prepare(); + // Just tests to make sure generated code doesn't throw an error. + int hashCode = stb.hashCode(); + } + + public void test_stateMethods() throws Exception { + Storage<Order> storage = getRepository().storageFor(Order.class); + + Order order = storage.prepare(); + + assertUninitialized(true, order, "orderID", "orderNumber", "orderTotal", "orderComments"); + assertDirty(false, order, "orderID", "orderNumber", "orderTotal", "orderComments"); + assertClean(false, order, "orderID", "orderNumber", "orderTotal", "orderComments"); + + order.setOrderID(1); + + assertUninitialized(false, order, "orderID"); + assertUninitialized(true, order, "orderNumber", "orderTotal", "orderComments"); + assertDirty(false, order, "orderNumber", "orderTotal", "orderComments"); + assertDirty(true, order, "orderID"); + assertClean(false, order, "orderID", "orderNumber", "orderTotal", "orderComments"); + + order.setOrderNumber("123"); + order.setOrderTotal(456); + order.setAddressID(789); + + assertUninitialized(false, order, "orderID", "orderNumber", "orderTotal"); + assertUninitialized(true, order, "orderComments"); + assertDirty(true, order, "orderID", "orderNumber", "orderTotal"); + assertDirty(false, order, "orderComments"); + assertClean(false, order, "orderID", "orderNumber", "orderTotal", "orderComments"); + + // Get unknown property + try { + order.isPropertyUninitialized("foo"); + fail(); + } catch (IllegalArgumentException e) { + } + + // Get unknown property + try { + order.isPropertyDirty("foo"); + fail(); + } catch (IllegalArgumentException e) { + } + + // Get unknown property + try { + order.isPropertyClean("foo"); + fail(); + } catch (IllegalArgumentException e) { + } + + // Get join property + try { + order.isPropertyUninitialized("address"); + fail(); + } catch (IllegalArgumentException e) { + } + + // Get join property + try { + order.isPropertyDirty("address"); + fail(); + } catch (IllegalArgumentException e) { + } + + // Get join property + try { + order.isPropertyClean("address"); + fail(); + } catch (IllegalArgumentException e) { + } + + order.insert(); + + assertUninitialized(false, order, "orderID", "orderNumber", "orderTotal", "orderComments"); + assertDirty(false, order, "orderID", "orderNumber", "orderTotal", "orderComments"); + assertClean(true, order, "orderID", "orderNumber", "orderTotal", "orderComments"); + } + + public void test_count() throws Exception { + test_count(false); + } + public void test_countIndexed() throws Exception { + test_count(true); + } + + private void test_count(boolean indexed) throws Exception { + Storage<? extends StorableTestBasic> storage; + if (indexed) { + storage = getRepository().storageFor(StorableTestBasicIndexed.class); + } else { + storage = getRepository().storageFor(StorableTestBasic.class); + } + + assertEquals(0, storage.query().count()); + + StorableTestBasic sb = storage.prepare(); + sb.setId(1); + sb.setIntProp(1); + sb.setLongProp(1); + sb.setDoubleProp(1.1); + sb.setStringProp("one"); + sb.insert(); + + assertEquals(1, storage.query().count()); + assertEquals(0, storage.query().not().count()); + assertEquals(1, storage.query("stringProp = ?").with("one").count()); + assertEquals(0, storage.query("stringProp = ?").with("two").count()); + + sb = storage.prepare(); + sb.setId(2); + sb.setIntProp(2); + sb.setLongProp(2); + sb.setDoubleProp(2.1); + sb.setStringProp("two"); + sb.insert(); + + sb = storage.prepare(); + sb.setId(3); + sb.setIntProp(3); + sb.setLongProp(3); + sb.setDoubleProp(3.1); + sb.setStringProp("three"); + sb.insert(); + + assertEquals(3, storage.query().count()); + assertEquals(0, storage.query().not().count()); + assertEquals(1, storage.query("stringProp = ?").with("one").count()); + assertEquals(1, storage.query("stringProp = ?").with("two").count()); + assertEquals(1, storage.query("stringProp = ?").with("three").count()); + assertEquals(2, storage.query("stringProp = ?").not().with("one").count()); + assertEquals(2, storage.query("stringProp = ?").not().with("two").count()); + assertEquals(2, storage.query("stringProp = ?").not().with("three").count()); + assertEquals(2, storage.query("stringProp > ?").with("one").count()); + assertEquals(0, storage.query("stringProp > ?").with("two").count()); + assertEquals(1, storage.query("stringProp > ?").with("three").count()); + } + + public void test_fetchAfter() throws Exception { + Storage<ManyKeys2> storage = getRepository().storageFor(ManyKeys2.class); + + final int groupSize = 4; + final int aliasing = groupSize + 1; + + int total = 0; + for (int a=0; a<groupSize; a++) { + for (int b=0; b<groupSize; b++) { + for (int c=0; c<groupSize; c++) { + for (int d=0; d<groupSize; d++) { + for (int e=0; e<groupSize; e++) { + for (int f=0; f<groupSize; f++) { + ManyKeys2 obj = storage.prepare(); + obj.setA(a); + obj.setB(b); + obj.setC(c); + obj.setD(d); + obj.setE(e); + obj.setF(f); + obj.insert(); + total++; + } + } + } + } + } + } + + String[] orderBy = {"a", "b", "c", "d", "e", "f"}; + Query<ManyKeys2> query = storage.query().orderBy(orderBy); + Cursor<ManyKeys2> cursor = query.fetch(); + Comparator<ManyKeys2> comparator = SortedCursor.createComparator(ManyKeys2.class, orderBy); + + int actual = 0; + ManyKeys2 last = null; + while (cursor.hasNext()) { + actual++; + ManyKeys2 obj = cursor.next(); + if (last != null) { + assertTrue(comparator.compare(last, obj) < 0); + } + if (actual % aliasing == 0) { + cursor.close(); + cursor = query.fetchAfter(obj); + } + last = obj; + } + + assertEquals(total, actual); + + // Try again in reverse + + orderBy = new String[] {"-a", "-b", "-c", "-d", "-e", "-f"}; + query = storage.query().orderBy(orderBy); + cursor = query.fetch(); + + actual = 0; + last = null; + while (cursor.hasNext()) { + actual++; + ManyKeys2 obj = cursor.next(); + if (last != null) { + assertTrue(comparator.compare(last, obj) > 0); + } + if (actual % aliasing == 0) { + cursor.close(); + cursor = query.fetchAfter(obj); + } + last = obj; + } + + assertEquals(total, actual); + + // Try again with funny mix of orderings. This will likely cause sort + // operations to be performed, thus making it very slow. + + orderBy = new String[] {"-a", "b", "-c", "d", "-e", "f"}; + query = storage.query().orderBy(orderBy); + cursor = query.fetch(); + comparator = SortedCursor.createComparator(ManyKeys2.class, orderBy); + + actual = 0; + last = null; + while (cursor.hasNext()) { + actual++; + ManyKeys2 obj = cursor.next(); + if (last != null) { + assertTrue(comparator.compare(last, obj) < 0); + } + if (actual % aliasing == 0) { + cursor.close(); + cursor = query.fetchAfter(obj); + } + last = obj; + } + + assertEquals(total, actual); + } + + private void assertUninitialized(boolean expected, Storable storable, String... properties) { + for (String property : properties) { + assertEquals(expected, storable.isPropertyUninitialized(property)); + } + } + + private void assertDirty(boolean expected, Storable storable, String... properties) { + for (String property : properties) { + assertEquals(expected, storable.isPropertyDirty(property)); + } + } + + private void assertClean(boolean expected, Storable storable, String... properties) { + for (String property : properties) { + assertEquals(expected, storable.isPropertyClean(property)); + } + } + + @PrimaryKey("id") + public interface StorableTestAssymetricGet extends Storable{ + public abstract int getId(); + public abstract void setId(int id); + + public abstract int getAssymetricGET(); + } + + @PrimaryKey("id") + public interface StorableTestAssymetricSet extends Storable{ + public abstract int getId(); + public abstract void setId(int id); + + public abstract int setAssymetricSET(); + } + + @PrimaryKey("id") + public interface StorableTestAssymetricGetSet extends Storable{ + public abstract int getId(); + public abstract void setId(int id); + + public abstract int getAssymetricGET(); + + public abstract int setAssymetricSET(); + } + + public static class InvocationTracker extends StorableTestBasic implements WrappedSupport { + String mName; + long mInvocationTracks; + + boolean mTrace; + + public InvocationTracker(String name) { + this(name, false); + } + + public InvocationTracker(final String name, boolean trace) { + mName = name; + mTrace = trace; + clearTracks(); + } + + public void clearTracks() { + mInvocationTracks = 0; + } + + public long getTracks() { + return mInvocationTracks; + } + + public void assertTrack(long value) { + assertEquals(value, getTracks()); + clearTracks(); + } + + + public void setId(int id) { + if (mTrace) System.out.println("setId"); + mInvocationTracks |= sSetId; + } + + // Basic coverage of the primitives + public String getStringProp() { + if (mTrace) System.out.println("getStringProp"); + mInvocationTracks |= sGetStringProp; // 0x2 + return null; + } + + public void setStringProp(String aStringThing) { + if (mTrace) System.out.println("setStringProp"); + mInvocationTracks |= sSetStringProp; // 0x4 + } + + public int getIntProp() { + if (mTrace) System.out.println("getIntProp"); + mInvocationTracks |= sGetIntProp; // 0x8 + return 0; + } + + public void setIntProp(int anInt) { + if (mTrace) System.out.println("setIntProp"); + mInvocationTracks |= sSetIntProp; // 0x10 + } + + public long getLongProp() { + if (mTrace) System.out.println("getLongProp"); + mInvocationTracks |= sGetLongProp; // 0x20 + return 0; + } + + public void setLongProp(long aLong) { + if (mTrace) System.out.println("setLongProp"); + mInvocationTracks |= sSetLongProp; // 0x40 + } + + public double getDoubleProp() { + if (mTrace) System.out.println("getDoubleProp"); + mInvocationTracks |= sGetDoubleProp; // 0x80 + return 0; + } + + public void setDoubleProp(double aDouble) { + if (mTrace) System.out.println("setDoubleProp"); + mInvocationTracks |= sSetDoubleProp; // 0x100 + } + + public DateTime getDate() { + return null; + } + + public void setDate(DateTime date) { + } + + public void load() throws FetchException { + if (mTrace) System.out.println("load"); + mInvocationTracks |= sLoad; // 0x200 + } + + public boolean tryLoad() throws FetchException { + if (mTrace) System.out.println("tryLoad"); + mInvocationTracks |= sTryLoad; // 0x400 + return false; + } + + public void insert() throws PersistException { + if (mTrace) System.out.println("insert"); + mInvocationTracks |= sInsert; // 0x800 + } + + public boolean tryInsert() throws PersistException { + if (mTrace) System.out.println("tryInsert"); + mInvocationTracks |= sTryInsert; + return false; + } + + public void update() throws PersistException { + if (mTrace) System.out.println("update"); + mInvocationTracks |= sUpdate; + } + + public boolean tryUpdate() throws PersistException { + if (mTrace) System.out.println("tryUpdate"); + mInvocationTracks |= sTryUpdate; // 0x1000 + return false; + } + + public void delete() throws PersistException { + if (mTrace) System.out.println("delete"); + mInvocationTracks |= sDelete; + } + + public boolean tryDelete() throws PersistException { + if (mTrace) System.out.println("tryDelete"); + mInvocationTracks |= sTryDelete; // 0x2000 + return false; + } + + public WrappedSupport createSupport(Storable storable) { + return new InvocationTracker(mName, mTrace); + } + + public Storage storage() { + if (mTrace) System.out.println("storage"); + mInvocationTracks |= sStorage; // 0x4000 + return null; + } + + public Storable copy() { + if (mTrace) System.out.println("copy"); + mInvocationTracks |= sCopy; // 0x8000 + return null; + } + + public String toStringKeyOnly() { + if (mTrace) System.out.println("toStringKeyOnly"); + mInvocationTracks |= sToStringKeyOnly; // 0x10000 + return null; + } + + public int getId() { + if (mTrace) System.out.println("getId"); + mInvocationTracks |= sGetId; // 0x20000 + return 0; + } + + public void copyAllProperties(Storable storable) { + if (mTrace) System.out.println("copyAllProperties"); + mInvocationTracks |= sCopyAllProperties; // 0x40000 + } + + public void copyPrimaryKeyProperties(Storable storable) { + if (mTrace) System.out.println("copyPrimaryKeyProperties"); + mInvocationTracks |= sCopyPrimaryKeyProperties; // 0x80000 + } + + public void copyUnequalProperties(Storable storable) { + if (mTrace) System.out.println("copyUnequalProperties"); + mInvocationTracks |= sCopyUnequalProperties; // 0x10 0000 + } + + public void copyDirtyProperties(Storable storable) { + if (mTrace) System.out.println("copyDirtyProperties"); + mInvocationTracks |= sCopyDirtyProperties; // 0x20 0000 + } + + public boolean hasDirtyProperties() { + if (mTrace) System.out.println("hasDirtyProperties"); + mInvocationTracks |= sHasDirtyProperties; // 0x200 0000 + return false; + } + + public boolean equalPrimaryKeys(Object obj) { + if (mTrace) System.out.println("equalPrimaryKeys"); + mInvocationTracks |= sEqualKeys; // 0x40 0000 + return true; + } + + public boolean equalProperties(Object obj) { + if (mTrace) System.out.println("equalProperties"); + mInvocationTracks |= sEqualProperties; // 0x80 0000 + return true; + } + + public void copyVersionProperty(Storable storable) { + if (mTrace) System.out.println("copyVersionProperty"); + mInvocationTracks |= sCopyVersionProperty; // 0x100 0000 + } + + public void markPropertiesClean() { + if (mTrace) System.out.println("markPropertiesClean"); + mInvocationTracks |= sMarkPropertiesClean; // 0x400 0000 + } + + public void markAllPropertiesClean() { + if (mTrace) System.out.println("markAllPropertiesClean"); + mInvocationTracks |= sMarkAllPropertiesClean; // 0x800 0000 + } + + public void markPropertiesDirty() { + if (mTrace) System.out.println("markPropertiesDirty"); + mInvocationTracks |= sMarkPropertiesDirty; // 0x1000 0000 + } + + public void markAllPropertiesDirty() { + if (mTrace) System.out.println("markAllPropertiesDirty"); + mInvocationTracks |= sMarkAllPropertiesDirty; // 0x2000 0000 + } + + public Class storableType() { + if (mTrace) System.out.println("storableType"); + mInvocationTracks |= sStorableType; // 0x4000 0000 + return Storable.class; + } + + public boolean isPropertyUninitialized(String name) { + if (mTrace) System.out.println("isPropertyUninitialized"); + return false; + } + + public boolean isPropertyDirty(String name) { + if (mTrace) System.out.println("isPropertyDirty"); + return false; + } + + public boolean isPropertyClean(String name) { + if (mTrace) System.out.println("isPropertyClean"); + return false; + } + + public boolean isPropertySupported(String name) { + if (mTrace) System.out.println("isPropertySupported"); + return false; + } + + public Repository getRootRepository() { + return null; + } + + public Trigger getInsertTrigger() { + return null; + } + + public Trigger getUpdateTrigger() { + return null; + } + + public Trigger getDeleteTrigger() { + return null; + } + } + +} diff --git a/src/test/java/com/amazon/carbonado/spi/TestSequenceValueGenerator.java b/src/test/java/com/amazon/carbonado/spi/TestSequenceValueGenerator.java new file mode 100644 index 0000000..ae17e5d --- /dev/null +++ b/src/test/java/com/amazon/carbonado/spi/TestSequenceValueGenerator.java @@ -0,0 +1,258 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.spi;
+
+import java.util.Random;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import com.amazon.carbonado.PersistException;
+import com.amazon.carbonado.Repository;
+import com.amazon.carbonado.Storage;
+
+import com.amazon.carbonado.repo.toy.ToyRepository;
+
+import com.amazon.carbonado.stored.StorableTestBasic;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+public class TestSequenceValueGenerator extends TestCase {
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run(suite());
+ }
+
+ public static TestSuite suite() {
+ return new TestSuite(TestSequenceValueGenerator.class);
+ }
+
+ private Repository mRepository;
+
+ public TestSequenceValueGenerator(String name) {
+ super(name);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ mRepository = new ToyRepository();
+ }
+
+ protected void tearDown() throws Exception {
+ super.tearDown();
+ }
+
+ public void test_basics() throws Exception {
+ SequenceValueGenerator generator = new SequenceValueGenerator(mRepository, "foo");
+
+ for (int i=1; i<=950; i++) {
+ assertEquals(i, generator.nextLongValue());
+ }
+
+ generator.reset(1);
+
+ for (int i=1; i<=950; i++) {
+ assertEquals(i, generator.nextIntValue());
+ }
+
+ generator.reset(1);
+
+ for (int i=1; i<=950; i++) {
+ assertEquals(String.valueOf(i), generator.nextDecimalValue());
+ }
+
+ // Make sure data is persisted
+
+ generator = new SequenceValueGenerator(mRepository, "foo");
+
+ assertTrue(generator.nextLongValue() > 950);
+
+ // Make sure data is isolated
+
+ generator = new SequenceValueGenerator(mRepository, "another");
+
+ for (int i=1; i<=1050; i++) {
+ assertEquals(i, generator.nextLongValue());
+ }
+
+ // Make sure reserved values can be returned
+
+ generator.returnReservedValues();
+ generator = new SequenceValueGenerator(mRepository, "another");
+
+ assertEquals(1051, generator.nextLongValue());
+ }
+
+ public void test_highIncrement() throws Exception {
+ SequenceValueGenerator generator =
+ new SequenceValueGenerator(mRepository, "foo", 1, 125);
+
+ for (int i=0; i<950; i++) {
+ assertEquals(i * 125 + 1, generator.nextLongValue());
+ }
+ }
+
+ public void test_highInitialAndHighIncrement() throws Exception {
+ SequenceValueGenerator generator =
+ new SequenceValueGenerator(mRepository, "foo", 0x500000000L, 125);
+
+ for (int i=0; i<950; i++) {
+ assertEquals(i * 125 + 0x500000000L, generator.nextLongValue());
+ }
+
+ try {
+ // Doesn't fit in an int.
+ generator.nextIntValue();
+ fail();
+ } catch (PersistException e) {
+ }
+ }
+
+ public void test_lowReserve() throws Exception {
+ SequenceValueGenerator generator =
+ new SequenceValueGenerator(mRepository, "goo", 1, 1, 1);
+
+ for (int i=1; i<=950; i++) {
+ assertEquals(i, generator.nextLongValue());
+ }
+ }
+
+ public void test_overflow() throws Exception {
+ Storage<StoredSequence> storage = mRepository.storageFor(StoredSequence.class);
+ StoredSequence seq = storage.prepare();
+ seq.setName("overflow");
+ seq.setInitialValue(1);
+ seq.setNextValue(Long.MAX_VALUE - 50);
+ seq.insert();
+
+ SequenceValueGenerator generator = new SequenceValueGenerator(mRepository, "overflow");
+
+ for (int i=-50; i<=-1; i++) {
+ assertEquals(i, generator.nextLongValue());
+ }
+
+ // Although next value could be zero, overflow logic doesn't work this
+ // way. Its not really worth the trouble to allow zero to be returned
+ // before overflowing.
+
+ try {
+ // Overflow.
+ generator.nextLongValue();
+ fail();
+ } catch (PersistException e) {
+ }
+ }
+
+ public void test_largeNumericalValue() throws Exception {
+ // Tests string conversion to ensure large unsigned values are properly
+ // generated.
+
+ SequenceValueGenerator generator =
+ new SequenceValueGenerator(mRepository, "goo", Long.MAX_VALUE, 1);
+
+ assertEquals("9223372036854775807", generator.nextDecimalValue());
+ // Next values are too large to fit in an unsigned long
+ assertEquals("9223372036854775808", generator.nextDecimalValue());
+ assertEquals("9223372036854775809", generator.nextDecimalValue());
+ }
+
+ public void test_radix() throws Exception {
+ SequenceValueGenerator generator = new SequenceValueGenerator(mRepository, "goo");
+
+ for (int i=1; i<=1000; i++) {
+ assertEquals(Integer.toString(i, 36), generator.nextNumericalValue(36, 1));
+ }
+ }
+
+ public void test_pad() throws Exception {
+ SequenceValueGenerator generator = new SequenceValueGenerator(mRepository, "goo");
+
+ for (int i=1; i<=2000; i++) {
+ String next = generator.nextNumericalValue(10, 3);
+ assertTrue(next.length() >= 3);
+ int value = Integer.parseInt(next);
+ assertEquals(i, value);
+ }
+ }
+
+ public void test_concurrentAccess() throws Exception {
+ // Simple test ensuring that values are reserved properly even when
+ // multiple processes may be sharing the sequence.
+
+ SequenceValueGenerator g1 = new SequenceValueGenerator(mRepository, "goo", 1, 1, 100);
+ SequenceValueGenerator g2 = new SequenceValueGenerator(mRepository, "goo", 1, 1, 100);
+
+ for (int i=1; i<=100; i++) {
+ assertEquals(i, g1.nextLongValue());
+ assertEquals(i + 100, g2.nextLongValue());
+ }
+
+ for (int i=201; i<=300; i++) {
+ assertEquals(i, g2.nextLongValue());
+ assertEquals(i + 100, g1.nextLongValue());
+ }
+
+ assertTrue(g1.returnReservedValues());
+ assertFalse(g2.returnReservedValues());
+ }
+
+ // FIXME: move this test somewhere else
+ /* Takes too long
+ public void test_heavyConcurrentAccess() throws Exception {
+ // Heavy test with multiple processes sharing the sequence.
+
+ final Storage<StorableTestBasic> storage =
+ mRepository.storageFor(StorableTestBasic.class);
+ final Random rnd = new Random(376296292);
+ final int loopCount = 10000;
+
+ Thread[] threads = new Thread[10];
+ for (int i=0; i<threads.length; i++) {
+ threads[i] = new Thread() {
+ public void run() {
+ try {
+ SequenceValueGenerator generator =
+ new SequenceValueGenerator(mRepository, "seq");
+ for (int i=0; i<loopCount; i++) {
+ StorableTestBasic stb = storage.prepare();
+ stb.setId(generator.nextIntValue());
+ stb.initBasicProperties();
+ stb.insert();
+ if (rnd.nextInt(500) == 0) {
+ generator.returnReservedValues();
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace(System.out);
+ fail(e.toString());
+ }
+ }
+ };
+
+ threads[i].start();
+ }
+
+ for (Thread t : threads) {
+ t.join();
+ }
+ }
+ */
+}
diff --git a/src/test/java/com/amazon/carbonado/stored/FileInfo.java b/src/test/java/com/amazon/carbonado/stored/FileInfo.java new file mode 100644 index 0000000..7d35faf --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/FileInfo.java @@ -0,0 +1,109 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.stored;
+
+import java.io.*;
+
+import org.joda.time.DateTime;
+
+import com.amazon.carbonado.*;
+import com.amazon.carbonado.lob.*;
+import com.amazon.carbonado.adapter.*;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+@Indexes({
+ @Index("name"),
+ @Index({"length", "lastModified"}),
+ @Index("lastModified"),
+ @Index("parentID")
+})
+@Alias("CBN_TEST_FILE_INFO")
+@AlternateKeys({
+ @Key({"parentID", "name"})
+})
+@PrimaryKey("ID")
+public abstract class FileInfo implements Storable {
+ @Sequence("com.amazon.carbonado.storables.FileInfo")
+ public abstract int getID();
+
+ public abstract void setID(int value);
+
+ @Nullable
+ public abstract Integer getParentID();
+
+ public abstract void setParentID(Integer id);
+
+ @Nullable
+ @Join(internal="parentID", external="ID")
+ public abstract FileInfo getParent() throws FetchException;
+
+ public abstract void setParent(FileInfo value);
+
+ @Join(internal="ID", external="parentID")
+ public abstract Query<FileInfo> getChildren() throws FetchException;
+
+ @Alias("FILE_NAME")
+ public abstract String getName();
+
+ public abstract void setName(String value);
+
+ @YesNoAdapter
+ public abstract boolean isDirectory();
+
+ public abstract void setDirectory(boolean value);
+
+ @Alias("FILE_LENGTH")
+ public abstract long getLength();
+
+ public abstract void setLength(long value);
+
+ @Nullable
+ public abstract DateTime getLastModified();
+
+ public abstract void setLastModified(DateTime value);
+
+ @Version
+ @Alias("RECORD_VERSION_NUMBER")
+ public abstract int getVersionNumber();
+
+ public abstract void setVersionNumber(int version);
+
+ @Nullable
+ public abstract Blob getFileData();
+
+ public abstract void setFileData(Blob data);
+
+ public String getFullPath() throws FetchException {
+ FileInfo parent;
+ try {
+ parent = getParent();
+ } catch (FetchNoneException e) {
+ parent = null;
+ }
+ if (parent == null) {
+ return getName();
+ } else {
+ return parent.getFullPath() + '/' + getName();
+ }
+ }
+}
diff --git a/src/test/java/com/amazon/carbonado/stored/ManyKeys2.java b/src/test/java/com/amazon/carbonado/stored/ManyKeys2.java new file mode 100644 index 0000000..282ff02 --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/ManyKeys2.java @@ -0,0 +1,47 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.stored;
+
+import com.amazon.carbonado.*;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+@PrimaryKey({"a", "b", "c", "d", "e", "f"})
+public interface ManyKeys2 extends Storable {
+ int getA();
+ void setA(int value);
+
+ int getB();
+ void setB(int value);
+
+ int getC();
+ void setC(int value);
+
+ int getD();
+ void setD(int value);
+
+ int getE();
+ void setE(int value);
+
+ int getF();
+ void setF(int value);
+}
diff --git a/src/test/java/com/amazon/carbonado/stored/StorableDateIndex.java b/src/test/java/com/amazon/carbonado/stored/StorableDateIndex.java new file mode 100644 index 0000000..5e7d063 --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/StorableDateIndex.java @@ -0,0 +1,46 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.stored;
+
+import org.joda.time.DateTime;
+
+
+import com.amazon.carbonado.Index;
+import com.amazon.carbonado.Indexes;
+import com.amazon.carbonado.PrimaryKey;
+import com.amazon.carbonado.Storable;
+import com.amazon.carbonado.adapter.DateTimeAdapter;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+@Indexes(@Index("orderDate"))
+@PrimaryKey("ID")
+public interface StorableDateIndex extends Storable {
+ int getID();
+
+ void setID(int id);
+
+ @DateTimeAdapter(timeZone="America/New_York")
+ DateTime getOrderDate();
+
+ void setOrderDate(DateTime date);
+}
diff --git a/src/test/java/com/amazon/carbonado/stored/StorableSequenced.java b/src/test/java/com/amazon/carbonado/stored/StorableSequenced.java new file mode 100644 index 0000000..770d6f0 --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/StorableSequenced.java @@ -0,0 +1,67 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.stored;
+
+import com.amazon.carbonado.Nullable;
+import com.amazon.carbonado.PrimaryKey;
+import com.amazon.carbonado.Sequence;
+import com.amazon.carbonado.Storable;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+@PrimaryKey("ID")
+public interface StorableSequenced extends Storable<StorableSequenced> {
+ @Sequence("pk")
+ long getID();
+
+ void setID(long id);
+
+ @Sequence("some_int")
+ int getSomeInt();
+
+ void setSomeInt(int i);
+
+ @Sequence("some_IntegerObj")
+ Integer getSomeIntegerObj();
+
+ void setSomeIntegerObj(Integer i);
+
+ @Sequence("some_long")
+ long getSomeLong();
+
+ void setSomeLong(long i);
+
+ @Sequence("some_LongObj")
+ @Nullable
+ Long getSomeLongObj();
+
+ void setSomeLongObj(Long i);
+
+ @Sequence("some_String")
+ String getSomeString();
+
+ void setSomeString(String str);
+
+ String getData();
+
+ void setData(String data);
+}
diff --git a/src/test/java/com/amazon/carbonado/stored/StorableTestAssymetric.java b/src/test/java/com/amazon/carbonado/stored/StorableTestAssymetric.java new file mode 100644 index 0000000..3808c1f --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/StorableTestAssymetric.java @@ -0,0 +1,38 @@ +/* + * Copyright 2006 Amazon Technologies, Inc. or its affiliates. + * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks + * of Amazon Technologies, Inc. or its affiliates. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.amazon.carbonado.stored; + +import com.amazon.carbonado.Storable; +import com.amazon.carbonado.PrimaryKey; + +/* + * StorableTestAssymetric + * + * @author Don Schneider + */ +@PrimaryKey("id") +public abstract class StorableTestAssymetric implements Storable { + public abstract int getId(); + public abstract void setId(int id); + + public int getAssymetricGet() + { + return getId()*3; + }; +} diff --git a/src/test/java/com/amazon/carbonado/stored/StorableTestInvalid.java b/src/test/java/com/amazon/carbonado/stored/StorableTestInvalid.java new file mode 100644 index 0000000..bd9fed2 --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/StorableTestInvalid.java @@ -0,0 +1,40 @@ +/* + * Copyright 2006 Amazon Technologies, Inc. or its affiliates. + * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks + * of Amazon Technologies, Inc. or its affiliates. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.amazon.carbonado.stored; + +import com.amazon.carbonado.Storable; +import com.amazon.carbonado.PrimaryKey; + +/** + * StorableTestInvalid + * + * @author Don Schneider + */ +@PrimaryKey("pk") +public interface StorableTestInvalid extends Storable { + int getPk(); + void setPk(int id); + + Custom getCustom(); + void setCustom(Custom aCustom); + + + // Probably more than is needed + class Custom { } +} diff --git a/src/test/java/com/amazon/carbonado/stored/StorableTestKeyValue.java b/src/test/java/com/amazon/carbonado/stored/StorableTestKeyValue.java new file mode 100644 index 0000000..44ecc2f --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/StorableTestKeyValue.java @@ -0,0 +1,43 @@ +/* + * Copyright 2006 Amazon Technologies, Inc. or its affiliates. + * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks + * of Amazon Technologies, Inc. or its affiliates. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.amazon.carbonado.stored; + +import com.amazon.carbonado.Storable; +import com.amazon.carbonado.PrimaryKey; + +/** + * StorableTestKeyValue + * + * @author Don Schneider + */ +@PrimaryKey({"key1", "key2"}) +public interface StorableTestKeyValue extends Storable { + int getKey1(); + void setKey1(int id); + + int getKey2(); + void setKey2(int id); + + int getValue1(); + void setValue1(int value); + + int getValue2(); + void setValue2(int value); + +} diff --git a/src/test/java/com/amazon/carbonado/stored/StorableTestMultiPK.java b/src/test/java/com/amazon/carbonado/stored/StorableTestMultiPK.java new file mode 100644 index 0000000..ace031b --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/StorableTestMultiPK.java @@ -0,0 +1,40 @@ +/* + * Copyright 2006 Amazon Technologies, Inc. or its affiliates. + * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks + * of Amazon Technologies, Inc. or its affiliates. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.amazon.carbonado.stored; + +import com.amazon.carbonado.PrimaryKey; +import com.amazon.carbonado.Storable; + +/** + * StorableTestMultiPK + * + * @author Don Schneider + */ +@PrimaryKey({"idPK", "stringPK"}) +public interface StorableTestMultiPK extends Storable { + int getIdPK(); + void setIdPK(int id); + + // Basic coverage of the primitives + String getStringPK(); + void setStringPK(String aString); + + String getStringData(); + void setStringData(String aData); +} diff --git a/src/test/java/com/amazon/carbonado/stored/StorableTimestamped.java b/src/test/java/com/amazon/carbonado/stored/StorableTimestamped.java new file mode 100644 index 0000000..d93ffeb --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/StorableTimestamped.java @@ -0,0 +1,38 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.stored;
+
+import org.joda.time.DateTime;
+
+import com.amazon.carbonado.Storable;
+import com.amazon.carbonado.PrimaryKey;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+@PrimaryKey("id")
+public interface StorableTimestamped extends Storable, Timestamped {
+ int getId();
+ void setId(int id);
+
+ String getValue();
+ void setValue(String str);
+}
diff --git a/src/test/java/com/amazon/carbonado/stored/StorableVersioned.java b/src/test/java/com/amazon/carbonado/stored/StorableVersioned.java new file mode 100644 index 0000000..2de9640 --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/StorableVersioned.java @@ -0,0 +1,50 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.stored;
+
+import com.amazon.carbonado.Nullable;
+import com.amazon.carbonado.Storable;
+import com.amazon.carbonado.PrimaryKey;
+import com.amazon.carbonado.Version;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+@PrimaryKey("ID")
+public interface StorableVersioned extends Storable {
+ int getID();
+
+ void setID(int id);
+
+ String getValue();
+
+ void setValue(String value);
+
+ @Nullable
+ String getName();
+
+ void setName(String name);
+
+ @Version
+ int getVersion();
+
+ void setVersion(int version);
+}
diff --git a/src/test/java/com/amazon/carbonado/stored/StorableVersionedIndexed.java b/src/test/java/com/amazon/carbonado/stored/StorableVersionedIndexed.java new file mode 100644 index 0000000..906e8be --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/StorableVersionedIndexed.java @@ -0,0 +1,36 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.stored;
+
+import com.amazon.carbonado.Index;
+import com.amazon.carbonado.Indexes;
+import com.amazon.carbonado.PrimaryKey;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+@Indexes({
+ @Index("value"),
+ @Index("name")
+})
+@PrimaryKey("ID")
+public interface StorableVersionedIndexed extends StorableVersioned {
+}
diff --git a/src/test/java/com/amazon/carbonado/stored/StorableVersionedWithLong.java b/src/test/java/com/amazon/carbonado/stored/StorableVersionedWithLong.java new file mode 100644 index 0000000..6d55d54 --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/StorableVersionedWithLong.java @@ -0,0 +1,44 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.stored;
+
+import com.amazon.carbonado.Storable;
+import com.amazon.carbonado.PrimaryKey;
+import com.amazon.carbonado.Version;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+@PrimaryKey("ID")
+public interface StorableVersionedWithLong extends Storable {
+ int getID();
+
+ void setID(int id);
+
+ String getValue();
+
+ void setValue(String value);
+
+ @Version
+ long getVersion();
+
+ void setVersion(long version);
+}
diff --git a/src/test/java/com/amazon/carbonado/stored/StorableVersionedWithLongObj.java b/src/test/java/com/amazon/carbonado/stored/StorableVersionedWithLongObj.java new file mode 100644 index 0000000..2acfdf8 --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/StorableVersionedWithLongObj.java @@ -0,0 +1,46 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.stored;
+
+import com.amazon.carbonado.Nullable;
+import com.amazon.carbonado.Storable;
+import com.amazon.carbonado.PrimaryKey;
+import com.amazon.carbonado.Version;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+@PrimaryKey("ID")
+public interface StorableVersionedWithLongObj extends Storable {
+ int getID();
+
+ void setID(int id);
+
+ String getValue();
+
+ void setValue(String value);
+
+ @Version
+ @Nullable
+ Long getVersion();
+
+ void setVersion(Long version);
+}
diff --git a/src/test/java/com/amazon/carbonado/stored/StorableVersionedWithObj.java b/src/test/java/com/amazon/carbonado/stored/StorableVersionedWithObj.java new file mode 100644 index 0000000..29f313c --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/StorableVersionedWithObj.java @@ -0,0 +1,46 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.stored;
+
+import com.amazon.carbonado.Nullable;
+import com.amazon.carbonado.Storable;
+import com.amazon.carbonado.PrimaryKey;
+import com.amazon.carbonado.Version;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+@PrimaryKey("ID")
+public interface StorableVersionedWithObj extends Storable {
+ int getID();
+
+ void setID(int id);
+
+ String getValue();
+
+ void setValue(String value);
+
+ @Version
+ @Nullable
+ Integer getVersion();
+
+ void setVersion(Integer version);
+}
diff --git a/src/test/java/com/amazon/carbonado/stored/Timestamped.java b/src/test/java/com/amazon/carbonado/stored/Timestamped.java new file mode 100644 index 0000000..b38ee28 --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/Timestamped.java @@ -0,0 +1,34 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.stored;
+
+import org.joda.time.DateTime;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+public interface Timestamped {
+ DateTime getSubmitDateTime();
+ void setSubmitDateTime(DateTime dt);
+
+ DateTime getModifyDateTime();
+ void setModifyDateTime(DateTime dt);
+}
|