/** Tests the loading of classes */
@Test
public void testClassloading() throws Exception {
final Store diskStore = createDiskStore();
Long value = Long.valueOf(123L);
diskStore.put(new Element("key1", value));
diskStore.put(new Element("key2", value));
Thread.sleep(1000);
Element element1 = diskStore.get("key1");
Element element2 = diskStore.get("key2");
assertEquals(value, element1.getObjectValue());
assertEquals(value, element2.getObjectValue());
Primitive primitive = new Primitive();
primitive.integerPrimitive = 123;
primitive.longPrimitive = 456L;
primitive.bytePrimitive = "a".getBytes()[0];
primitive.charPrimitive = 'B';
primitive.booleanPrimitive = false;
// test Serializability
ByteArrayOutputStream outstr = new ByteArrayOutputStream();
ObjectOutputStream objstr = new ObjectOutputStream(outstr);
objstr.writeObject(new Element("key", value));
objstr.close();
diskStore.put(new Element("primitive1", primitive));
diskStore.put(new Element("primitive2", primitive));
Thread.sleep(1000);
Element primitive1 = diskStore.get("primitive1");
Element primitive2 = diskStore.get("primitive2");
assertEquals(primitive, primitive1.getObjectValue());
assertEquals(primitive, primitive2.getObjectValue());
}
/** Multi-thread concurrent read remove test. */
@Test
public void testReadRemoveMultipleThreads() throws Exception {
final Random random = new Random();
final Store diskStore = createDiskStore();
diskStore.put(new Element("key", "value"));
// Run a set of threads that get, put and remove an entry
final List executables = new ArrayList();
for (int i = 0; i < 5; i++) {
final Executable executable =
new Executable() {
public void execute() throws Exception {
for (int i = 0; i < 100; i++) {
diskStore.put(new Element("key" + random.nextInt(100), "value"));
}
}
};
executables.add(executable);
}
for (int i = 0; i < 5; i++) {
final Executable executable =
new Executable() {
public void execute() throws Exception {
for (int i = 0; i < 100; i++) {
diskStore.remove("key" + random.nextInt(100));
}
}
};
executables.add(executable);
}
runThreads(executables);
}
/** Any disk store with an auto generated random directory should not be able to be loaded. */
@Test
public void testCannotLoadPersistentStoreWithAutoDir() throws IOException, InterruptedException {
// initialise
String cacheName = "testPersistent";
Store diskStore = createAutoPersistentDiskStore(cacheName);
diskStore.removeAll();
for (int i = 0; i < 100; i++) {
byte[] data = new byte[1024];
diskStore.put(new Element("key" + (i + 100), data));
}
waitLonger();
assertEquals(ELEMENT_ON_DISK_SIZE * 100, diskStore.getOnDiskSizeInBytes());
assertEquals(100, diskStore.getSize());
manager2.removeCache(cacheName);
Thread.sleep(1000);
Cache cache = new Cache(cacheName, 10000, true, false, 5, 1, true, 600);
manager2.addCache(cache);
File dataFile = ((DiskPersistentStore) diskStore).getDataFile();
assertTrue("File exists", dataFile.exists());
assertEquals(0, dataFile.length());
assertEquals(0, cache.getSize());
manager.removeCache(cacheName);
assertTrue("File exists", dataFile.exists());
assertEquals(0, dataFile.length());
}
/** Multi-thread read-only test. Will fail on memory constrained VMs */
@Test
public void testReadOnlyMultipleThreads() throws Exception {
final Store diskStore = createNonExpiringDiskStore();
// Add a couple of elements
diskStore.put(new Element("key0", "value"));
diskStore.put(new Element("key1", "value"));
diskStore.put(new Element("key2", "value"));
diskStore.put(new Element("key3", "value"));
// Wait for the elements to be written
waitShorter();
// Run a set of threads, that attempt to fetch the elements
final List executables = new ArrayList();
for (int i = 0; i < 20; i++) {
final String key = "key" + (i % 4);
final Executable executable =
new Executable() {
public void execute() throws Exception {
final Element element = diskStore.get(key);
assertNotNull(element);
assertEquals("value", element.getObjectValue());
}
};
executables.add(executable);
}
runThreads(executables);
}
/** Tests looking up an entry that does not exist. */
@Test
public void testGetQuietUnknownThenKnown() throws Exception {
final Store diskStore = createDiskStore();
assertNull(diskStore.getQuiet("key1"));
diskStore.put(new Element("key1", "value"));
diskStore.put(new Element("key2", "value"));
assertNotNull(diskStore.getQuiet("key1"));
assertNotNull(diskStore.getQuiet("key2"));
}
/** Tests removing an entry. */
@Test
public void testRemove() throws Exception {
final Store diskStore = createDiskStore();
// Add the entry
final String value = "value";
diskStore.put(new Element("key1", value));
diskStore.put(new Element("key2", value));
// Check the entry is there
assertEquals(1, diskStore.getOnDiskSize());
assertEquals(2, diskStore.getSize());
assertNotNull(diskStore.get("key1"));
assertNotNull(diskStore.get("key2"));
// Remove it
diskStore.remove("key1");
diskStore.remove("key2");
// Check the entry is not there
assertEquals(0, diskStore.getOnDiskSize());
assertEquals(0, diskStore.getSize());
assertNull(diskStore.get("key1"));
assertNull(diskStore.get("key2"));
}
@Test
public void testUsesReentrantLocks() throws TimeoutException {
CacheLockProvider clp = (CacheLockProvider) store.getInternalContext();
SomeKey[] keys = {new SomeKey(0), new SomeKey(1)};
store.put(new Element(keys[0], "VALUE0"));
store.put(new Element(keys[1], "VALUE2"));
Sync[] syncForKeys = clp.getAndWriteLockAllSyncForKeys((Object[]) keys);
assertEquals(1, syncForKeys.length);
assertTrue(
"Segment should now be write locked!",
syncForKeys[0].isHeldByCurrentThread(LockType.WRITE));
try {
for (SomeKey key : keys) {
clp.getSyncForKey(key).unlock(LockType.WRITE);
}
} catch (java.lang.IllegalMonitorStateException e) {
fail(
"This shouldn't throw an IllegalMonitorStateException, segment should have been locked twice!");
}
assertFalse(
"Segment should now be entirely unlocked!",
syncForKeys[0].isHeldByCurrentThread(LockType.WRITE));
syncForKeys = clp.getAndWriteLockAllSyncForKeys(50, (Object[]) keys);
assertEquals(1, syncForKeys.length);
assertTrue(
"Segment should now be write locked!",
syncForKeys[0].isHeldByCurrentThread(LockType.WRITE));
try {
for (SomeKey key : keys) {
clp.getSyncForKey(key).unlock(LockType.WRITE);
}
} catch (java.lang.IllegalMonitorStateException e) {
fail(
"This shouldn't throw an IllegalMonitorStateException, segment should have been locked twice!");
}
assertFalse(
"Segment should now be entirely unlocked!",
syncForKeys[0].isHeldByCurrentThread(LockType.WRITE));
syncForKeys = clp.getAndWriteLockAllSyncForKeys(50, (Object[]) keys);
assertEquals(1, syncForKeys.length);
assertTrue(
"Segment should now be write locked!",
syncForKeys[0].isHeldByCurrentThread(LockType.WRITE));
try {
clp.unlockWriteLockForAllKeys((Object[]) keys);
} catch (java.lang.IllegalMonitorStateException e) {
fail(
"This shouldn't throw an IllegalMonitorStateException, segment should have been locked twice!");
}
assertFalse(
"Segment should now be entirely unlocked!",
syncForKeys[0].isHeldByCurrentThread(LockType.WRITE));
}
@Test
public void testSupportsCopyOnRead() {
Element element = new Element(KEY, "Some String", 1);
xaStore.put(element);
Element copy = xaStore.get(KEY);
assertNotNull(copy);
assertNotSame(copy, xaStore.get(KEY));
assertEquals("Some String", copy.getValue());
assertEquals(copy.getValue(), xaStore.get(KEY).getValue());
assertNotSame(copy.getValue(), xaStore.get(KEY).getValue());
}
@Test
public void testThrowsExceptionOnNonSerializableValue() {
try {
xaStore.put(new Element(KEY, new Object()));
fail("Should have thrown an Exception");
} catch (Exception e) {
assertTrue(
"Expected " + CacheException.class.getName() + ", but was " + e.getClass().getName(),
e instanceof CacheException);
}
assertNull(xaStore.get(KEY));
}
/** This method tries to get the store too leak. */
protected long thrashCache() throws Exception {
long startingSize = measureMemoryUse();
LOG.info("Starting memory used is: " + startingSize);
final String value = "value";
final String key = "key";
// Add the entry
final Element element = new Element(key, value);
store.put(element);
// Create 15 threads that read the keys;
final List executables = new ArrayList();
for (int i = 0; i < 15; i++) {
final LruMemoryStoreTest.Executable executable =
new MemoryStoreTester.Executable() {
public void execute() throws Exception {
for (int i = 0; i < 500; i++) {
final String key = "key" + i;
store.get(key);
}
store.get("key");
}
};
executables.add(executable);
}
// Create 15 threads that are insert 500 keys with large byte[] as values
for (int i = 0; i < 15; i++) {
final MemoryStoreTester.Executable executable =
new MemoryStoreTester.Executable() {
public void execute() throws Exception {
// Add a bunch of entries
for (int i = 0; i < 500; i++) {
// Use a random length value
final String key = "key" + i;
byte[] value = new byte[10000];
Element element = new Element(key, value);
store.put(element);
}
}
};
executables.add(executable);
}
runThreads(executables);
store.removeAll();
long finishingSize = measureMemoryUse();
LOG.info("Ending memory used is: " + finishingSize);
return finishingSize - startingSize;
}
@Test
public void testLFUEvictionFromDiskStore() throws IOException, InterruptedException {
Cache cache =
new Cache(
"testNonPersistent",
1,
MemoryStoreEvictionPolicy.LFU,
true,
null,
false,
2000,
1000,
false,
1,
null,
null,
10);
manager.addCache(cache);
Store store = cache.getStore();
Element element;
assertEquals(0, store.getSize());
for (int i = 0; i < 11; i++) {
element = new Element("key" + i, "value" + i);
cache.put(element);
if (i > 0) {
cache.get("key" + i);
cache.get("key" + i);
cache.get("key" + i);
cache.get("key" + i);
}
}
// allow to move through spool
Thread.sleep(220);
assertEquals(10, store.getOnDiskSize());
element = new Element("keyNew", "valueNew");
store.put(element);
// allow to get out of spool
Thread.sleep(220);
assertEquals(10, store.getOnDiskSize());
// check new element not evicted
assertNotNull(store.get(element.getObjectKey()));
// check evicted honours LFU policy
assertNull(store.get("key0"));
for (int i = 0; i < 2000; i++) {
store.put(new Element("" + i, new Date()));
}
// wait for spool to empty
waitLonger();
assertEquals(10, store.getOnDiskSize());
}
/**
* Default Constructor
*
* @param cache the Terracotta clustered Cache to snapshot
* @param interval the interval to do the snapshots on
* @param doKeySnapshotOnDedicatedThread whether the snapshots have to be done on a dedicated
* thread
* @param rotatingWriter the RotatingSnapshotFile to write to
* @throws IllegalArgumentException if interval is less than or equal to zero
*/
KeySnapshotter(
final Ehcache cache,
final long interval,
final boolean doKeySnapshotOnDedicatedThread,
final RotatingSnapshotFile rotatingWriter)
throws IllegalArgumentException {
final Store store = new CacheStoreHelper((Cache) cache).getStore();
if (!(store instanceof TerracottaStore)) {
throw new IllegalArgumentException(
"Cache '"
+ cache.getName()
+ "' isn't backed by a "
+ TerracottaStore.class.getSimpleName()
+ " but uses a "
+ store.getClass().getName()
+ " instead");
}
if (interval <= 0) {
throw new IllegalArgumentException("Interval needs to be a positive & non-zero value");
}
if (rotatingWriter == null) {
throw new NullPointerException();
}
this.cacheName = cache.getName();
this.rotatingWriter = rotatingWriter;
this.tcStore = (TerracottaStore) store;
if (doKeySnapshotOnDedicatedThread) {
thread = new SnapShottingThread(this, interval, "KeySnapshotter for cache " + cacheName);
thread.start();
} else {
ScheduledExecutorService scheduledExecutorService = INSTANCES.get(cache.getCacheManager());
if (scheduledExecutorService == null) {
scheduledExecutorService = new ScheduledThreadPoolExecutor(POOL_SIZE);
final ScheduledExecutorService previous =
INSTANCES.putIfAbsent(cache.getCacheManager(), scheduledExecutorService);
if (previous != null) {
scheduledExecutorService.shutdownNow();
scheduledExecutorService = previous;
}
}
scheduledExecutorService.scheduleWithFixedDelay(this, interval, interval, TimeUnit.SECONDS);
thread = null;
}
}
/** {@inheritDoc} */
public Set<Object> getKeysInvisibleInContext(
LocalTransactionContext currentTransactionContext, Store underlyingStore) {
Set<Object> invisibleKeys = new HashSet<Object>();
// all new keys added into the store are invisible
invisibleKeys.addAll(getNewKeys());
List<SoftLock> currentTransactionContextSoftLocks =
currentTransactionContext.getSoftLocksForCache(cacheName);
for (SoftLock softLock : currentTransactionContextSoftLocks) {
Element e = underlyingStore.getQuiet(softLock.getKey());
if (e.getObjectValue() instanceof SoftLockID) {
SoftLockID softLockId = (SoftLockID) e.getObjectValue();
if (softLock.getElement(currentTransactionContext.getTransactionId(), softLockId) == null) {
// if the soft lock's element is null in the current transaction then the key is invisible
invisibleKeys.add(softLock.getKey());
} else {
// if the soft lock's element is not null in the current transaction then the key is
// visible
invisibleKeys.remove(softLock.getKey());
}
}
}
return invisibleKeys;
}
/** Multi-thread read-write test. */
@Test
public void testReadWriteThreads() throws Exception {
final String value = "value";
final String key = "key";
// Add the entry
final Element element = new Element(key, value);
store.put(element);
// Run a set of threads that get, put and remove an entry
final List executables = new ArrayList();
for (int i = 0; i < 5; i++) {
final MemoryStoreTester.Executable executable =
new MemoryStoreTester.Executable() {
public void execute() throws Exception {
final Element element = store.get("key");
assertNotNull(element);
}
};
executables.add(executable);
}
for (int i = 0; i < 5; i++) {
final MemoryStoreTester.Executable executable =
new MemoryStoreTester.Executable() {
public void execute() throws Exception {
store.put(element);
}
};
executables.add(executable);
}
runThreads(executables);
}
/** Tests that we can save and load a persistent store in a repeatable way */
@Test
public void testLoadPersistentStore() throws IOException, InterruptedException {
// initialise
String cacheName = "testLoadPersistent";
Store store = createPersistentDiskStore(cacheName);
store.removeAll();
waitShorter();
for (int i = 0; i < 100; i++) {
byte[] data = new byte[1024];
store.put(new Element("key" + (i + 100), data));
}
store.flush();
waitShorter();
assertEquals(ELEMENT_ON_DISK_SIZE * 100, store.getOnDiskSizeInBytes());
assertEquals(100, store.getSize());
manager.removeCache(cacheName);
Thread.sleep(3000);
// check that we can create and dispose several times with no problems and no lost data
for (int i = 0; i < 10; i++) {
store = createPersistentDiskStore(cacheName);
File dataFile = ((DiskPersistentStore) store).getDataFile();
assertTrue("File exists", dataFile.exists());
assertEquals(100 * ELEMENT_ON_DISK_SIZE, dataFile.length());
assertEquals(100, store.getSize());
manager.removeCache(cacheName);
assertTrue("File exists", dataFile.exists());
assertEquals(100 * ELEMENT_ON_DISK_SIZE, dataFile.length());
}
}
/** Tests bulk load. */
@Test
public void testBulkLoad() throws Exception {
final Store diskStore = createDiskStore();
final Random random = new Random();
// Add a bunch of entries
for (int i = 0; i < 500; i++) {
// Use a random length value
final String key = "key" + i;
final String value = "This is a value" + random.nextInt(1000);
// Add an element, and make sure it is present
Element element = new Element(key, value);
diskStore.put(element);
element = diskStore.get(key);
assertNotNull(element);
// Chuck in a delay, to give the spool thread a chance to catch up
Thread.sleep(2);
// Remove the element
diskStore.remove(key);
element = diskStore.get(key);
assertNull(element);
element = new Element(key, value);
diskStore.put(element);
element = diskStore.get(key);
assertNotNull(element);
// Chuck in a delay
Thread.sleep(2);
}
}
/** Benchmark to test speed. */
@Test
public void testBenchmarkPutGet() throws Exception {
final String key = "key";
byte[] value = new byte[500];
StopWatch stopWatch = new StopWatch();
// Add a bunch of entries
for (int i = 0; i < 50000; i++) {
Element element = new Element(key, value);
store.put(element);
}
for (int i = 0; i < 50000; i++) {
store.get(key + i);
}
long time = stopWatch.getElapsedTime();
LOG.info("Time for benchmarkPutGet: " + time);
assertTrue("Too slow. Time was " + time, time < 300);
}
/**
* Tests that a file is created with the right size after puts, and that the file is not deleted
* on disposal
*
* <p>This test uses a preconfigured cache from the test cache.xml. Note that teardown causes an
* exception because the disk store is being shut down twice.
*/
@Test
public void testPersistentStore() throws IOException, InterruptedException, CacheException {
// initialise
Store store = createPersistentDiskStoreFromCacheManager();
store.removeAll();
File dataFile = ((DiskPersistentStore) store).getDataFile();
for (int i = 0; i < 100; i++) {
byte[] data = new byte[1024];
store.put(new Element("key" + (i + 100), data));
}
waitShorter();
assertEquals(100, store.getSize());
store.dispose();
assertTrue("File exists", dataFile.exists());
assertEquals(100 * ELEMENT_ON_DISK_SIZE, dataFile.length());
}
/**
* Checks that the expiry thread runs and expires elements which has the effect of preventing the
* disk store from continously growing. Ran for 6 hours through 10000 outer loops. No memory use
* increase. Using a key of "key" + i * outer) you get early slots that cannot be reused. The
* DiskStore actual size therefore starts at 133890 and ends at 616830. There is quite a lot of
* space that cannot be used because of fragmentation. Question? Should an effort be made to
* coalesce fragmented space? Unlikely in production to get contiguous fragments as in the first
* form of this test.
*
* <p>Using a key of Integer.valueOf(i * outer) the size stays constant at 140800.
*
* @throws InterruptedException
*/
@Test
public void testExpiryWithSize() throws InterruptedException {
Store diskStore = createDiskStore();
diskStore.removeAll();
byte[] data = new byte[1024];
for (int outer = 1; outer <= 10; outer++) {
for (int i = 0; i < 101; i++) {
Element element = new Element(Integer.valueOf(i * outer), data);
element.setTimeToLive(1);
diskStore.put(element);
}
waitLonger();
int predictedSize = (ELEMENT_ON_DISK_SIZE + 68) * 100;
long actualSize = diskStore.getOnDiskSizeInBytes();
LOG.info("Predicted Size: " + predictedSize + " Actual Size: " + actualSize);
assertEquals(predictedSize, actualSize);
LOG.info("Memory Use: " + measureMemoryUse());
}
}
/** Tests adding an entry. */
@Test
public void testPut() throws Exception {
final String value = "value";
final String key = "key";
// Make sure the element is not found
assertEquals(0, store.getSize());
Element element = store.get(key);
assertNull(element);
// Add the element
element = new Element(key, value);
store.put(element);
// Get the element
assertEquals(1, store.getSize());
element = store.get(key);
assertNotNull(element);
assertEquals(value, element.getObjectValue());
}
/** Tests removing all the entries. */
@Test
public void testRemoveAll() throws Exception {
final String value = "value";
final String key = "key";
// Add the entry
Element element = new Element(key, value);
store.put(element);
// Check the entry is there
element = store.get(key);
assertNotNull(element);
// Remove it
store.removeAll();
// Check the entry is not there
assertEquals(0, store.getSize());
element = store.get(key);
assertNull(element);
}
/** Tests for element expiry. */
@Test
public void testExpiry() throws Exception {
// Create a diskStore with a cranked up expiry thread
final Store diskStore = createDiskStore();
// Add an element that will expire.
diskStore.put(new Element("key1", "value", false, 1, 1));
diskStore.put(new Element("key2", "value", false, 1, 1));
assertNotNull(diskStore.get("key1"));
assertNotNull(diskStore.get("key2"));
assertEquals(2, diskStore.getSize());
assertEquals(1, diskStore.getOnDiskSize());
// Wait a couple of seconds
Thread.sleep(3000);
Element e1 = diskStore.get("key1");
Element e2 = diskStore.get("key2");
if (e1 != null) {
assertNull(e2);
} else if (e2 != null) {
assertNull(e1);
} else {
fail("One of the Elements should have been in memory - and hence not be expired");
}
}
/** Tests bulk load. */
@Test
public void testBulkLoad() throws Exception {
final Random random = new Random();
StopWatch stopWatch = new StopWatch();
// Add a bunch of entries
for (int i = 0; i < 500; i++) {
// Use a random length value
final String key = "key" + i;
final String value = "value" + random.nextInt(1000);
// Add an element, and make sure it is present
Element element = new Element(key, value);
store.put(element);
element = store.get(key);
assertNotNull(element);
// Remove the element
store.remove(key);
element = store.get(key);
assertNull(element);
element = new Element(key, value);
store.put(element);
element = store.get(key);
assertNotNull(element);
}
long time = stopWatch.getElapsedTime();
LOG.info("Time for Bulk Load: " + time);
}
/** Tests that we can load a store after the index has been corrupted */
@Test
public void testLoadPersistentStoreAfterCorruption() throws IOException, InterruptedException {
// initialise
String cacheName = "testPersistent";
Store diskStore = createPersistentDiskStore(cacheName);
diskStore.removeAll();
for (int i = 0; i < 100; i++) {
byte[] data = new byte[1024];
diskStore.put(new Element("key" + (i + 100), data));
}
waitShorter();
assertEquals(ELEMENT_ON_DISK_SIZE * 100, diskStore.getOnDiskSizeInBytes());
assertEquals(100, diskStore.getSize());
manager.removeCache(cacheName);
File indexFile = ((DiskPersistentStore) diskStore).getIndexFile();
FileOutputStream fout = new FileOutputStream(indexFile);
// corrupt the index file
fout.write(new byte[] {'q', 'w', 'e', 'r', 't', 'y'});
fout.close();
diskStore = createPersistentDiskStore(cacheName);
File dataFile = ((DiskPersistentStore) diskStore).getDataFile();
assertTrue("File exists", dataFile.exists());
// Make sure the data file got recreated since the index was corrupt
assertEquals("Data file was not recreated", 0, dataFile.length());
assertEquals(0, diskStore.getSize());
}
/** Benchmark to test speed. Original implementation 12seconds This implementation 9 seconds */
public void benchmarkPutGetSuryaTest(long allowedTime) throws Exception {
Random random = new Random();
byte[] value = new byte[500];
StopWatch stopWatch = new StopWatch();
// Add a bunch of entries
for (int i = 0; i < 50000; i++) {
String key = "key" + i;
Element element = new Element(key, value);
store.put(element);
// Access each element random number of times, min:0 maximum:9
int accesses = random.nextInt(5);
for (int j = 0; j <= accesses; j++) {
store.get(key);
}
}
long time = stopWatch.getElapsedTime();
LOG.info("Time for benchmarkPutGetSurya: " + time);
assertTrue("Too slow. Time was " + time, time < allowedTime);
}
/** Multi-thread read-only test. */
@Test
public void testReadOnlyThreads() throws Exception {
// Add a couple of elements
store.put(new Element("key0", "value"));
store.put(new Element("key1", "value"));
// Run a set of threads, that attempt to fetch the elements
final List executables = new ArrayList();
for (int i = 0; i < 10; i++) {
final String key = "key" + (i % 2);
final MemoryStoreTester.Executable executable =
new LruMemoryStoreTest.Executable() {
public void execute() throws Exception {
final Element element = store.get(key);
assertNotNull(element);
assertEquals("value", element.getObjectValue());
}
};
executables.add(executable);
}
runThreads(executables);
}
@Test
public void testSupportsCopyOnWrite() {
AtomicLong atomicLong = new AtomicLong(0);
Element element = new Element(KEY, atomicLong, 1);
atomicLong.getAndIncrement();
xaStore.put(element);
atomicLong.getAndIncrement();
element.setVersion(2);
assertEquals(1, ((AtomicLong) xaStore.get(KEY).getValue()).get());
assertEquals(1, xaStore.get(KEY).getVersion());
xaStore.put(new Element(KEY, atomicLong, 1));
assertEquals(2, ((AtomicLong) xaStore.get(KEY).getValue()).get());
atomicLong.getAndIncrement();
assertEquals(2, ((AtomicLong) xaStore.get(KEY).getValue()).get());
assertEquals(1, xaStore.get(KEY).getVersion());
}
/**
* Tests that a file is created with the right size after puts, and that the file is deleted on
* disposal
*/
@Test
public void testNonPersistentStore() throws IOException, InterruptedException {
Store diskStore = createNonExpiringDiskStore();
File dataFile = ((OverflowToDiskStore) diskStore).getDataFile();
// 100 + 1 for the in-memory capacity
for (int i = 0; i < 101; i++) {
byte[] data = new byte[1024];
diskStore.put(new Element("key" + (i + 100), data));
}
waitShorter();
assertEquals(ELEMENT_ON_DISK_SIZE * 100, diskStore.getOnDiskSizeInBytes());
assertEquals(100, diskStore.getOnDiskSize());
assertEquals(101, diskStore.getSize());
diskStore.dispose();
Thread.sleep(1);
assertFalse("File exists", dataFile.exists());
}
/** Tests adding an entry. */
@Test
public void testPut() throws Exception {
final Store diskStore = createDiskStore();
// Make sure the element is not found
assertEquals(0, diskStore.getSize());
assertNull(diskStore.get("key"));
// Add the element
final String value = "value";
diskStore.put(new Element("key1", value));
diskStore.put(new Element("key2", value));
// Get the element
assertEquals(2, diskStore.getSize());
assertEquals(1, diskStore.getOnDiskSize());
Element element1 = diskStore.get("key1");
Element element2 = diskStore.get("key2");
assertNotNull(element1);
assertNotNull(element2);
assertEquals(value, element1.getObjectValue());
assertEquals(value, element2.getObjectValue());
}
/** Tests looking up an entry that does not exist. */
@Test
public void testGetUnknown() throws Exception {
final Element element = store.get("key");
assertNull(element);
}
