You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by ds...@apache.org on 2016/01/19 19:54:06 UTC
incubator-geode git commit: GEODE-783: add unit test for
SyncChunkStack
Repository: incubator-geode
Updated Branches:
refs/heads/develop 5eeb3313c -> aad3ef739
GEODE-783: add unit test for SyncChunkStack
Project: http://git-wip-us.apache.org/repos/asf/incubator-geode/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-geode/commit/aad3ef73
Tree: http://git-wip-us.apache.org/repos/asf/incubator-geode/tree/aad3ef73
Diff: http://git-wip-us.apache.org/repos/asf/incubator-geode/diff/aad3ef73
Branch: refs/heads/develop
Commit: aad3ef73974236c3ab2abb8fe116c9b2462e8df5
Parents: 5eeb331
Author: Darrel Schneider <ds...@pivotal.io>
Authored: Mon Jan 18 16:42:40 2016 -0800
Committer: Darrel Schneider <ds...@pivotal.io>
Committed: Tue Jan 19 10:42:17 2016 -0800
----------------------------------------------------------------------
.../internal/offheap/SyncChunkStack.java | 13 +-
.../offheap/SyncChunkStackJUnitTest.java | 273 +++++++++++++++++++
2 files changed, 285 insertions(+), 1 deletion(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/aad3ef73/gemfire-core/src/main/java/com/gemstone/gemfire/internal/offheap/SyncChunkStack.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/offheap/SyncChunkStack.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/offheap/SyncChunkStack.java
index a615af0..7ba28a2 100644
--- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/offheap/SyncChunkStack.java
+++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/offheap/SyncChunkStack.java
@@ -87,6 +87,7 @@ public class SyncChunkStack {
while (addr != 0L) {
int curSize = Chunk.getSize(addr);
addr = Chunk.getNext(addr);
+ testHookDoConcurrentModification();
long curHead = this.topAddr;
if (curHead != headAddr) {
headAddr = curHead;
@@ -97,7 +98,7 @@ public class SyncChunkStack {
break;
}
// TODO construct a single log msg
- // that gets reset on the concurrent mad.
+ // that gets reset when concurrentModDetected.
lw.info(msg + curSize);
}
} while (concurrentModDetected);
@@ -114,6 +115,7 @@ public class SyncChunkStack {
while (addr != 0L) {
result += Chunk.getSize(addr);
addr = Chunk.getNext(addr);
+ testHookDoConcurrentModification();
long curHead = this.topAddr;
if (curHead != headAddr) {
headAddr = curHead;
@@ -127,4 +129,13 @@ public class SyncChunkStack {
} while (concurrentModDetected);
return result;
}
+
+ /**
+ * This method allows tests to override it
+ * and do a concurrent modification to the stack.
+ * For production code it will be a noop.
+ */
+ protected void testHookDoConcurrentModification() {
+ // nothing needed in production code
+ }
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/aad3ef73/gemfire-core/src/test/java/com/gemstone/gemfire/internal/offheap/SyncChunkStackJUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/internal/offheap/SyncChunkStackJUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/internal/offheap/SyncChunkStackJUnitTest.java
new file mode 100644
index 0000000..f8e93a7
--- /dev/null
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/internal/offheap/SyncChunkStackJUnitTest.java
@@ -0,0 +1,273 @@
+package com.gemstone.gemfire.internal.offheap;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.MethodInvocationReport;
+
+import com.gemstone.gemfire.LogWriter;
+import com.gemstone.gemfire.test.junit.categories.UnitTest;
+
+@Category(UnitTest.class)
+public class SyncChunkStackJUnitTest {
+ static {
+ ClassLoader.getSystemClassLoader().setDefaultAssertionStatus(true);
+ }
+
+ @BeforeClass
+ public static void setUpBeforeClass() throws Exception {
+ }
+
+ @AfterClass
+ public static void tearDownAfterClass() throws Exception {
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ }
+
+ @Test
+ public void addressZeroCausesStackToBeEmpty() {
+ SyncChunkStack stack = new SyncChunkStack(0L);
+ assertEquals(true, stack.isEmpty());
+ }
+
+ @Test
+ public void defaultStackIsEmpty() {
+ SyncChunkStack stack = new SyncChunkStack();
+ assertEquals(true, stack.isEmpty());
+ }
+
+ @Test
+ public void defaultStackReturnsZeroFromTop() {
+ SyncChunkStack stack = new SyncChunkStack();
+ assertEquals(0L, stack.getTopAddress());
+ }
+
+ @Test
+ public void defaultStackReturnsZeroFromPoll() {
+ SyncChunkStack stack = new SyncChunkStack();
+ assertEquals(0L, stack.poll());
+ }
+
+ @Test
+ public void defaultStackReturnsZeroFromClear() {
+ SyncChunkStack stack = new SyncChunkStack();
+ assertEquals(0L, stack.clear());
+ assertEquals(true, stack.isEmpty());
+ }
+
+ @Test
+ public void defaultStackLogsNothing() {
+ SyncChunkStack stack = new SyncChunkStack();
+ LogWriter lw = mock(LogWriter.class, withSettings().invocationListeners(new InvocationListener() {
+ @Override
+ public void reportInvocation(MethodInvocationReport methodInvocationReport) {
+ fail("Unexpected invocation");
+ }
+ }));
+ stack.logSizes(lw, "should not be used");
+ }
+
+ @Test
+ public void defaultStackComputeSizeIsZero() {
+ SyncChunkStack stack = new SyncChunkStack();
+ assertEquals(0L, stack.computeTotalSize());
+ }
+
+ @Test
+ public void stackCreatedWithAddressIsNotEmpty() {
+ UnsafeMemoryChunk slab = new UnsafeMemoryChunk(1024);
+ try {
+ SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.create(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new UnsafeMemoryChunk[]{slab});
+ Chunk chunk = (Chunk) ma.allocate(100, null);
+
+ SyncChunkStack stack = new SyncChunkStack(chunk.getMemoryAddress());
+ assertEquals(false, stack.isEmpty());
+ } finally {
+ SimpleMemoryAllocatorImpl.freeOffHeapMemory();
+ }
+ }
+
+ @Test
+ public void stackWithChunkIsNotEmpty() {
+ UnsafeMemoryChunk slab = new UnsafeMemoryChunk(1024);
+ try {
+ SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.create(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new UnsafeMemoryChunk[]{slab});
+ Chunk chunk = (Chunk) ma.allocate(100, null);
+
+ SyncChunkStack stack = new SyncChunkStack();
+ stack.offer(chunk.getMemoryAddress());
+ assertEquals(false, stack.isEmpty());
+ } finally {
+ SimpleMemoryAllocatorImpl.freeOffHeapMemory();
+ }
+ }
+
+ @Test
+ public void stackWithChunkTopEqualsAddress() {
+ UnsafeMemoryChunk slab = new UnsafeMemoryChunk(1024);
+ try {
+ SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.create(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new UnsafeMemoryChunk[]{slab});
+ Chunk chunk = (Chunk) ma.allocate(100, null);
+
+ long addr = chunk.getMemoryAddress();
+ SyncChunkStack stack = new SyncChunkStack();
+ stack.offer(addr);
+ assertEquals(addr, stack.getTopAddress());
+ } finally {
+ SimpleMemoryAllocatorImpl.freeOffHeapMemory();
+ }
+ }
+
+ @Test
+ public void addressZeroOfferCausesFailedAssertion() {
+ SyncChunkStack stack = new SyncChunkStack(0L);
+ try {
+ stack.offer(0);
+ fail("expected AssertionError");
+ } catch (AssertionError expected) {
+ }
+ }
+
+
+ @Test
+ public void stackWithChunkClearReturnsAddressAndEmptiesStack() {
+ UnsafeMemoryChunk slab = new UnsafeMemoryChunk(1024);
+ try {
+ SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.create(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new UnsafeMemoryChunk[]{slab});
+ Chunk chunk = (Chunk) ma.allocate(100, null);
+
+ long addr = chunk.getMemoryAddress();
+ SyncChunkStack stack = new SyncChunkStack();
+ stack.offer(addr);
+ long clearAddr = stack.clear();
+ assertEquals(addr, clearAddr);
+ assertEquals(true, stack.isEmpty());
+ } finally {
+ SimpleMemoryAllocatorImpl.freeOffHeapMemory();
+ }
+ }
+
+ @Test
+ public void stackWithChunkPollReturnsAddressAndEmptiesStack() {
+ UnsafeMemoryChunk slab = new UnsafeMemoryChunk(1024);
+ try {
+ SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.create(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new UnsafeMemoryChunk[]{slab});
+ Chunk chunk = (Chunk) ma.allocate(100, null);
+
+ long addr = chunk.getMemoryAddress();
+ SyncChunkStack stack = new SyncChunkStack();
+ stack.offer(addr);
+ long pollAddr = stack.poll();
+ assertEquals(addr, pollAddr);
+ assertEquals(true, stack.isEmpty());
+ } finally {
+ SimpleMemoryAllocatorImpl.freeOffHeapMemory();
+ }
+ }
+
+ @Test
+ public void stackWithChunkTotalSizeIsChunkSize() {
+ UnsafeMemoryChunk slab = new UnsafeMemoryChunk(1024);
+ try {
+ SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.create(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new UnsafeMemoryChunk[]{slab});
+ Chunk chunk = (Chunk) ma.allocate(100, null);
+ int chunkSize = chunk.getSize();
+
+ long addr = chunk.getMemoryAddress();
+ SyncChunkStack stack = new SyncChunkStack();
+ stack.offer(addr);
+ assertEquals(chunkSize, stack.computeTotalSize());
+ } finally {
+ SimpleMemoryAllocatorImpl.freeOffHeapMemory();
+ }
+ }
+
+
+ @Test
+ public void stackWithChunkLogShowsMsgAndSize() {
+ UnsafeMemoryChunk slab = new UnsafeMemoryChunk(1024);
+ try {
+ SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.create(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new UnsafeMemoryChunk[]{slab});
+ Chunk chunk = (Chunk) ma.allocate(100, null);
+ int chunkSize = chunk.getSize();
+
+ long addr = chunk.getMemoryAddress();
+ SyncChunkStack stack = new SyncChunkStack();
+ stack.offer(addr);
+ LogWriter lw = mock(LogWriter.class);
+ stack.logSizes(lw, "foo");
+ verify(lw).info("foo"+chunkSize);
+ } finally {
+ SimpleMemoryAllocatorImpl.freeOffHeapMemory();
+ }
+ }
+
+ private class TestableSyncChunkStack extends SyncChunkStack {
+ public boolean doConcurrentMod = true;
+ public int chunk2Size;
+ private SimpleMemoryAllocatorImpl ma;
+ TestableSyncChunkStack(SimpleMemoryAllocatorImpl ma) {
+ this.ma = ma;
+ }
+ @Override
+ protected void testHookDoConcurrentModification() {
+ if (doConcurrentMod) {
+ doConcurrentMod = false;
+ Chunk chunk2 = (Chunk) ma.allocate(50, null);
+ this.chunk2Size = chunk2.getSize();
+ this.offer(chunk2.getMemoryAddress());
+ }
+ }
+ }
+ @Test
+ public void stackWithChunkTotalSizeIsChunkSizeWithConcurrentMod() {
+ UnsafeMemoryChunk slab = new UnsafeMemoryChunk(1024);
+ try {
+ SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.create(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new UnsafeMemoryChunk[]{slab});
+ Chunk chunk = (Chunk) ma.allocate(100, null);
+ int chunkSize = chunk.getSize();
+
+ long addr = chunk.getMemoryAddress();
+ TestableSyncChunkStack stack = new TestableSyncChunkStack(ma);
+ stack.offer(addr);
+ long totalSize = stack.computeTotalSize();
+ assertEquals("chunkSize=" + chunkSize + " chunk2Size=" + stack.chunk2Size, chunkSize + stack.chunk2Size, totalSize);
+ } finally {
+ SimpleMemoryAllocatorImpl.freeOffHeapMemory();
+ }
+ }
+
+
+ @Test
+ public void stackWithChunkLogShowsMsgAndSizeWithConcurrentMod() {
+ UnsafeMemoryChunk slab = new UnsafeMemoryChunk(1024);
+ try {
+ SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.create(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new UnsafeMemoryChunk[]{slab});
+ Chunk chunk = (Chunk) ma.allocate(100, null);
+ int chunkSize = chunk.getSize();
+
+ long addr = chunk.getMemoryAddress();
+ TestableSyncChunkStack stack = new TestableSyncChunkStack(ma);
+ stack.offer(addr);
+ LogWriter lw = mock(LogWriter.class);
+ stack.logSizes(lw, "foo");
+ verify(lw).info("foo"+chunkSize);
+ verify(lw).info("foo"+stack.chunk2Size);
+ } finally {
+ SimpleMemoryAllocatorImpl.freeOffHeapMemory();
+ }
+ }
+}