geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dschnei...@apache.org
Subject [26/38] incubator-geode git commit: collapsed AddressableStoredObject into StoredObject changed product code to use the StoredObject interface instead of internal class implementations of it
Date Sat, 05 Mar 2016 00:51:26 GMT
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/FreeListManagerTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/FreeListManagerTest.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/FreeListManagerTest.java
index 35befc4..4c91918 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/FreeListManagerTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/FreeListManagerTest.java
@@ -121,7 +121,7 @@ public class FreeListManagerTest {
     int tinySize = 10;
     
     ObjectStoredInMemory c = this.freeListManager.allocate(tinySize);
-    ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
     c = this.freeListManager.allocate(tinySize);
 
     validateChunkSizes(c, tinySize);
@@ -133,7 +133,7 @@ public class FreeListManagerTest {
     int dataSize = 10;
     
     ObjectStoredInMemory c = this.freeListManager.allocate(dataSize);
-    ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
     this.freeListManager.allocate(dataSize);
     // free list will now be empty
     c = this.freeListManager.allocate(dataSize);
@@ -157,7 +157,7 @@ public class FreeListManagerTest {
     int dataSize = FreeListManager.MAX_TINY+1;
     
     ObjectStoredInMemory c = this.freeListManager.allocate(dataSize);
-    ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
     this.freeListManager.allocate(dataSize);
     // free list will now be empty
     c = this.freeListManager.allocate(dataSize);
@@ -171,7 +171,7 @@ public class FreeListManagerTest {
     int dataSize = FreeListManager.MAX_TINY+1+1024;
     
     ObjectStoredInMemory c = this.freeListManager.allocate(dataSize);
-    ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
     dataSize = FreeListManager.MAX_TINY+1;
     c = this.freeListManager.allocate(dataSize);
     
@@ -189,7 +189,7 @@ public class FreeListManagerTest {
     int dataSize = 10;
     
     ObjectStoredInMemory c = this.freeListManager.allocate(dataSize);
-    ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
     
     assertThat(this.freeListManager.getFreeTinyMemory()).isEqualTo(computeExpectedSize(dataSize));
   }
@@ -200,12 +200,12 @@ public class FreeListManagerTest {
     int dataSize = 10;
     
     ObjectStoredInMemory c = this.freeListManager.allocate(dataSize);
-    ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
     
     int dataSize2 = 100;
     
     ObjectStoredInMemory c2 = this.freeListManager.allocate(dataSize2);
-    ObjectStoredInMemory.release(c2.getMemoryAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c2.getAddress(), this.freeListManager);
     
     assertThat(this.freeListManager.getFreeTinyMemory()).isEqualTo(computeExpectedSize(dataSize)+computeExpectedSize(dataSize2));
   }
@@ -222,7 +222,7 @@ public class FreeListManagerTest {
     int dataSize = FreeListManager.MAX_TINY+1+1024;
     
     ObjectStoredInMemory c = this.freeListManager.allocate(dataSize);
-    ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
     
     assertThat(this.freeListManager.getFreeHugeMemory()).isEqualTo(computeExpectedSize(dataSize));
   }
@@ -294,7 +294,7 @@ public class FreeListManagerTest {
     chunks.add(this.freeListManager.allocate(DEFAULT_SLAB_SIZE/2-8));
     chunks.add(this.freeListManager.allocate(SMALL_SLAB-8+1));
     for (ObjectStoredInMemory c: chunks) {
-      ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+      ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
     }
     this.freeListManager.firstCompact = false;
     assertThat(this.freeListManager.compact(DEFAULT_SLAB_SIZE+1)).isFalse();
@@ -316,7 +316,7 @@ public class FreeListManagerTest {
     chunks.add(this.freeListManager.allocate(DEFAULT_SLAB_SIZE/2-8));
     chunks.add(this.freeListManager.allocate(SMALL_SLAB-8+1));
     for (ObjectStoredInMemory c: chunks) {
-      ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+      ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
     }
     
     assertThat(this.freeListManager.compact(DEFAULT_SLAB_SIZE)).isTrue();
@@ -339,7 +339,7 @@ public class FreeListManagerTest {
     chunks.add(this.freeListManager.allocate(DEFAULT_SLAB_SIZE/2-8));
     this.freeListManager.allocate(SMALL_SLAB-8+1);
     for (ObjectStoredInMemory c: chunks) {
-      ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+      ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
     }
     
     assertThat(this.freeListManager.compact(DEFAULT_SLAB_SIZE/2)).isTrue();
@@ -379,26 +379,26 @@ public class FreeListManagerTest {
     ObjectStoredInMemory mediumChunk1 = freeListManager.allocate(128-8);
     ObjectStoredInMemory mediumChunk2 = freeListManager.allocate(128-8);
 
-    ObjectStoredInMemory.release(bigChunk.getMemoryAddress(), freeListManager);
+    ObjectStoredInMemory.release(bigChunk.getAddress(), freeListManager);
     int s = chunksToFree.size();
     for (int i=s/2; i >=0; i--) {
       ObjectStoredInMemory c = chunksToFree.get(i);
-      ObjectStoredInMemory.release(c.getMemoryAddress(), freeListManager);
+      ObjectStoredInMemory.release(c.getAddress(), freeListManager);
     }
     for (int i=(s/2)+1; i < s; i++) {
       ObjectStoredInMemory c = chunksToFree.get(i);
-      ObjectStoredInMemory.release(c.getMemoryAddress(), freeListManager);
+      ObjectStoredInMemory.release(c.getAddress(), freeListManager);
     }
-    ObjectStoredInMemory.release(c3.getMemoryAddress(), freeListManager);
-    ObjectStoredInMemory.release(c1.getMemoryAddress(), freeListManager);
-    ObjectStoredInMemory.release(c2.getMemoryAddress(), freeListManager);
-    ObjectStoredInMemory.release(c4.getMemoryAddress(), freeListManager);
-    ObjectStoredInMemory.release(mediumChunk1.getMemoryAddress(), freeListManager);
-    ObjectStoredInMemory.release(mediumChunk2.getMemoryAddress(), freeListManager);
+    ObjectStoredInMemory.release(c3.getAddress(), freeListManager);
+    ObjectStoredInMemory.release(c1.getAddress(), freeListManager);
+    ObjectStoredInMemory.release(c2.getAddress(), freeListManager);
+    ObjectStoredInMemory.release(c4.getAddress(), freeListManager);
+    ObjectStoredInMemory.release(mediumChunk1.getAddress(), freeListManager);
+    ObjectStoredInMemory.release(mediumChunk2.getAddress(), freeListManager);
     this.freeListManager.firstCompact = false;
     assertThat(freeListManager.compact(DEFAULT_SLAB_SIZE-(ALLOCATE_COUNT*32))).isFalse();
     for (int i=0; i < ((256*2)/96); i++) {
-      ObjectStoredInMemory.release(chunksToFreeLater.get(i).getMemoryAddress(), freeListManager);
+      ObjectStoredInMemory.release(chunksToFreeLater.get(i).getAddress(), freeListManager);
     }
     assertThat(freeListManager.compact(DEFAULT_SLAB_SIZE-(ALLOCATE_COUNT*32))).isTrue();
   }
@@ -412,9 +412,9 @@ public class FreeListManagerTest {
     ObjectStoredInMemory bigChunk3 = freeListManager.allocate(slabSize/3-8);
     this.freeListManager.firstCompact = false;
     assertThat(freeListManager.compact(1)).isFalse();
-    ObjectStoredInMemory.release(bigChunk3.getMemoryAddress(), freeListManager);
-    ObjectStoredInMemory.release(bigChunk2.getMemoryAddress(), freeListManager);
-    ObjectStoredInMemory.release(bigChunk1.getMemoryAddress(), freeListManager);
+    ObjectStoredInMemory.release(bigChunk3.getAddress(), freeListManager);
+    ObjectStoredInMemory.release(bigChunk2.getAddress(), freeListManager);
+    ObjectStoredInMemory.release(bigChunk1.getAddress(), freeListManager);
     assertThat(freeListManager.compact(slabSize)).isTrue();
   }
   
@@ -423,14 +423,14 @@ public class FreeListManagerTest {
     setUpSingleSlabManager();
     Fragment originalFragment = this.freeListManager.getFragmentList().get(0);
     ObjectStoredInMemory c = freeListManager.allocate(16);
-    ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
     c = freeListManager.allocate(16);
     this.freeListManager.firstCompact = false;
     assertThat(this.freeListManager.compact(1)).isTrue();
     assertThat(this.freeListManager.getFragmentList()).hasSize(1);
     Fragment compactedFragment = this.freeListManager.getFragmentList().get(0);
     assertThat(compactedFragment.getSize()).isEqualTo(originalFragment.getSize()-(16+8));
-    assertThat(compactedFragment.getMemoryAddress()).isEqualTo(originalFragment.getMemoryAddress()+(16+8));
+    assertThat(compactedFragment.getAddress()).isEqualTo(originalFragment.getAddress()+(16+8));
   }
   
   @Test
@@ -663,7 +663,7 @@ public class FreeListManagerTest {
     this.freeListManager = createFreeListManager(ma, new Slab[] {chunk});
     List<MemoryBlock> ob = this.freeListManager.getOrderedBlocks();
     assertThat(ob).hasSize(1);
-    assertThat(ob.get(0).getMemoryAddress()).isEqualTo(address);
+    assertThat(ob.get(0).getAddress()).isEqualTo(address);
     assertThat(ob.get(0).getBlockSize()).isEqualTo(10);
   }
   
@@ -674,7 +674,7 @@ public class FreeListManagerTest {
     this.freeListManager = createFreeListManager(ma, new Slab[] {chunk});
     ObjectStoredInMemory c = this.freeListManager.allocate(24);
     ObjectStoredInMemory c2 = this.freeListManager.allocate(24);
-    ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
 
     List<MemoryBlock> ob = this.freeListManager.getOrderedBlocks();
     assertThat(ob).hasSize(3);
@@ -693,7 +693,7 @@ public class FreeListManagerTest {
     Slab chunk = new SlabImpl(96);
     this.freeListManager = createFreeListManager(ma, new Slab[] {chunk});
     ObjectStoredInMemory c = this.freeListManager.allocate(24);
-    ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
     List<MemoryBlock> ob = this.freeListManager.getAllocatedBlocks();
     assertThat(ob).hasSize(0);
   }
@@ -705,7 +705,7 @@ public class FreeListManagerTest {
     ObjectStoredInMemory c = this.freeListManager.allocate(24);
     List<MemoryBlock> ob = this.freeListManager.getAllocatedBlocks();
     assertThat(ob).hasSize(1);
-    assertThat(ob.get(0).getMemoryAddress()).isEqualTo(c.getMemoryAddress());
+    assertThat(ob.get(0).getAddress()).isEqualTo(c.getAddress());
   }
   
   @Test
@@ -733,8 +733,8 @@ public class FreeListManagerTest {
     this.freeListManager = createFreeListManager(ma, new Slab[] {chunk, chunk2});
     ObjectStoredInMemory c = this.freeListManager.allocate(24);
     ObjectStoredInMemory c2 = this.freeListManager.allocate(1024*1024);
-    ObjectStoredInMemory.release(c.getMemoryAddress(), this.freeListManager);
-    ObjectStoredInMemory.release(c2.getMemoryAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c.getAddress(), this.freeListManager);
+    ObjectStoredInMemory.release(c2.getAddress(), this.freeListManager);
     
     LogWriter lw = mock(LogWriter.class);
     this.freeListManager.logOffHeapState(lw, 1024);

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/MemoryBlockNodeJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/MemoryBlockNodeJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/MemoryBlockNodeJUnitTest.java
index 1bc3d1c..255ee7c 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/MemoryBlockNodeJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/MemoryBlockNodeJUnitTest.java
@@ -53,7 +53,7 @@ public class MemoryBlockNodeJUnitTest {
       new SlabImpl((int)OffHeapStorage.MIN_SLAB_SIZE), 
       new SlabImpl((int)OffHeapStorage.MIN_SLAB_SIZE * 2)
   };
-  private AddressableStoredObject storedObject = null;
+  private StoredObject storedObject = null;
 
   static {
     ClassLoader.getSystemClassLoader().setDefaultAssertionStatus(true);
@@ -94,11 +94,11 @@ public class MemoryBlockNodeJUnitTest {
     return Long.valueOf(Long.MAX_VALUE);
   }
 
-  protected AddressableStoredObject createValueAsUnserializedStoredObject(Object value) {
-    AddressableStoredObject createdObject = createValueAsUnserializedStoredObject(value, false);
+  protected StoredObject createValueAsUnserializedStoredObject(Object value) {
+    StoredObject createdObject = createValueAsUnserializedStoredObject(value, false);
     return createdObject;
   }
-  protected AddressableStoredObject createValueAsUnserializedStoredObject(Object value, boolean isCompressed) {
+  protected StoredObject createValueAsUnserializedStoredObject(Object value, boolean isCompressed) {
     byte[] valueInByteArray;
     if (value instanceof Long) {
       valueInByteArray = convertValueToByteArray(value);
@@ -108,7 +108,7 @@ public class MemoryBlockNodeJUnitTest {
 
     boolean isSerialized = false;
 
-    AddressableStoredObject createdObject = createChunk(valueInByteArray, isSerialized, isCompressed);
+    StoredObject createdObject = createChunk(valueInByteArray, isSerialized, isCompressed);
     return createdObject;
   }
 
@@ -116,23 +116,23 @@ public class MemoryBlockNodeJUnitTest {
     return ByteBuffer.allocate(Long.SIZE / Byte.SIZE).putLong((Long) value).array();
   }
 
-  private AddressableStoredObject createChunk(byte[] v, boolean isSerialized, boolean isCompressed) {
-    AddressableStoredObject chunk = (AddressableStoredObject) ma.allocateAndInitialize(v, isSerialized, isCompressed);
+  private StoredObject createChunk(byte[] v, boolean isSerialized, boolean isCompressed) {
+    StoredObject chunk = (StoredObject) ma.allocateAndInitialize(v, isSerialized, isCompressed);
     return chunk;
   }
 
 
-  protected AddressableStoredObject createValueAsSerializedStoredObject(Object value) {
-    AddressableStoredObject createdObject = createValueAsSerializedStoredObject(value, false);
+  protected StoredObject createValueAsSerializedStoredObject(Object value) {
+    StoredObject createdObject = createValueAsSerializedStoredObject(value, false);
     return createdObject;
   }
   
-  protected AddressableStoredObject createValueAsSerializedStoredObject(Object value, boolean isCompressed) {
+  protected StoredObject createValueAsSerializedStoredObject(Object value, boolean isCompressed) {
     byte[] valueInSerializedByteArray = EntryEventImpl.serialize(value);
 
     boolean isSerialized = true;
 
-    AddressableStoredObject createdObject = createChunk(valueInSerializedByteArray, isSerialized, isCompressed);
+    StoredObject createdObject = createChunk(valueInSerializedByteArray, isSerialized, isCompressed);
     return createdObject;
   }
   
@@ -147,7 +147,7 @@ public class MemoryBlockNodeJUnitTest {
     expectedException.expect(NullPointerException.class);
     
     MemoryBlock mb = new MemoryBlockNode(ma, null);
-    Long addr = mb.getMemoryAddress();
+    Long addr = mb.getAddress();
     fail("Operations on MemoryBlockNodes with null block argument expected to throw NullPointerException ");
   }
   
@@ -171,7 +171,7 @@ public class MemoryBlockNodeJUnitTest {
   public void getMemoryAddressReturnsAddressOfBlock() {
     Fragment fragment = new Fragment(slabs[0].getMemoryAddress(), slabs[0].getSize());
     MemoryBlock mb = new MemoryBlockNode(ma, fragment);
-    softly.assertThat(mb.getMemoryAddress()).isEqualTo(fragment.getMemoryAddress());
+    softly.assertThat(mb.getAddress()).isEqualTo(fragment.getAddress());
  }
   
   @Test

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectChunkJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectChunkJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectChunkJUnitTest.java
index 6603867..a9390c1 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectChunkJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectChunkJUnitTest.java
@@ -134,7 +134,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
     ObjectStoredInMemory newChunk = new ObjectStoredInMemory(chunk);
 
     assertNotNull(newChunk);
-    assertThat(newChunk.getMemoryAddress()).isEqualTo(chunk.getMemoryAddress());
+    assertThat(newChunk.getAddress()).isEqualTo(chunk.getAddress());
 
     chunk.release();
   }
@@ -143,10 +143,10 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
   public void chunkCanBeCreatedWithOnlyMemoryAddress() {
     ObjectStoredInMemory chunk = createValueAsUnserializedStoredObject(getValue());
 
-    ObjectStoredInMemory newChunk = new ObjectStoredInMemory(chunk.getMemoryAddress());
+    ObjectStoredInMemory newChunk = new ObjectStoredInMemory(chunk.getAddress());
 
     assertNotNull(newChunk);
-    assertThat(newChunk.getMemoryAddress()).isEqualTo(chunk.getMemoryAddress());
+    assertThat(newChunk.getAddress()).isEqualTo(chunk.getAddress());
 
     chunk.release();
   }
@@ -162,7 +162,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
 
     assertNotNull(newChunk);
     assertThat(newChunk.getClass()).isEqualTo(ObjectChunkSlice.class);
-    assertThat(newChunk.getMemoryAddress()).isEqualTo(chunk.getMemoryAddress());
+    assertThat(newChunk.getAddress()).isEqualTo(chunk.getAddress());
 
     chunk.release();
   }
@@ -178,7 +178,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
     byte serializedUserBits = 1;
     chunk.fillSerializedValue(wrapper, userBits);
 
-    verify(wrapper, times(1)).setChunkData(chunk, serializedUserBits);
+    verify(wrapper, times(1)).setOffHeapData(chunk, serializedUserBits);
 
     chunk.release();
   }
@@ -193,7 +193,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
     byte userBits = 1;
     chunk.fillSerializedValue(wrapper, userBits);
 
-    verify(wrapper, times(1)).setChunkData(chunk, userBits);
+    verify(wrapper, times(1)).setOffHeapData(chunk, userBits);
 
     chunk.release();
   }
@@ -210,7 +210,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
   public void chunksAreEqualsOnlyByAddress() {
     ObjectStoredInMemory chunk = createValueAsSerializedStoredObject(getValue());
 
-    ObjectStoredInMemory newChunk = new ObjectStoredInMemory(chunk.getMemoryAddress());
+    ObjectStoredInMemory newChunk = new ObjectStoredInMemory(chunk.getAddress());
     assertThat(chunk.equals(newChunk)).isTrue();
 
     ObjectStoredInMemory chunkWithSameValue = createValueAsUnserializedStoredObject(getValue());
@@ -231,7 +231,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
     assertThat(chunk1.compareTo(chunk2)).isEqualTo(0);
 
     ObjectStoredInMemory chunkWithSameValue = createValueAsSerializedStoredObject(getValue());
-    assertThat(chunk1.compareTo(chunkWithSameValue)).isEqualTo(Long.signum(chunk1.getMemoryAddress() - chunkWithSameValue.getMemoryAddress()));
+    assertThat(chunk1.compareTo(chunkWithSameValue)).isEqualTo(Long.signum(chunk1.getAddress() - chunkWithSameValue.getAddress()));
 
     ObjectStoredInMemory chunk3 = createValueAsSerializedStoredObject(Long.MAX_VALUE);
     ObjectStoredInMemory chunk4 = createValueAsSerializedStoredObject(Long.MAX_VALUE);
@@ -255,7 +255,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
 
     ObjectStoredInMemory chunk = (ObjectStoredInMemory) ma.allocateAndInitialize(regionEntryValueAsBytes, isSerialized, isCompressed);
 
-    int headerBeforeSerializedBitSet = AddressableMemoryManager.readIntVolatile(chunk.getMemoryAddress() + ObjectStoredInMemory.REF_COUNT_OFFSET);
+    int headerBeforeSerializedBitSet = AddressableMemoryManager.readIntVolatile(chunk.getAddress() + ObjectStoredInMemory.REF_COUNT_OFFSET);
 
     assertThat(chunk.isSerialized()).isFalse();
 
@@ -263,7 +263,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
 
     assertThat(chunk.isSerialized()).isTrue();
 
-    int headerAfterSerializedBitSet = AddressableMemoryManager.readIntVolatile(chunk.getMemoryAddress() + ObjectStoredInMemory.REF_COUNT_OFFSET);
+    int headerAfterSerializedBitSet = AddressableMemoryManager.readIntVolatile(chunk.getAddress() + ObjectStoredInMemory.REF_COUNT_OFFSET);
 
     assertThat(headerAfterSerializedBitSet).isEqualTo(headerBeforeSerializedBitSet | ObjectStoredInMemory.IS_SERIALIZED_BIT);
 
@@ -289,7 +289,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
 
     ObjectStoredInMemory chunk = (ObjectStoredInMemory) ma.allocateAndInitialize(regionEntryValueAsBytes, isSerialized, isCompressed);
 
-    int headerBeforeCompressedBitSet = AddressableMemoryManager.readIntVolatile(chunk.getMemoryAddress() + ObjectStoredInMemory.REF_COUNT_OFFSET);
+    int headerBeforeCompressedBitSet = AddressableMemoryManager.readIntVolatile(chunk.getAddress() + ObjectStoredInMemory.REF_COUNT_OFFSET);
 
     assertThat(chunk.isCompressed()).isFalse();
 
@@ -297,7 +297,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
 
     assertThat(chunk.isCompressed()).isTrue();
 
-    int headerAfterCompressedBitSet = AddressableMemoryManager.readIntVolatile(chunk.getMemoryAddress() + ObjectStoredInMemory.REF_COUNT_OFFSET);
+    int headerAfterCompressedBitSet = AddressableMemoryManager.readIntVolatile(chunk.getAddress() + ObjectStoredInMemory.REF_COUNT_OFFSET);
 
     assertThat(headerAfterCompressedBitSet).isEqualTo(headerBeforeCompressedBitSet | ObjectStoredInMemory.IS_COMPRESSED_BIT);
 
@@ -607,10 +607,10 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
     ObjectStoredInMemory chunk = createValueAsUnserializedStoredObject(regionEntryValue);
 
     ByteBuffer buffer = chunk.createDirectByteBuffer();
-    long bufferAddress = ObjectStoredInMemory.getDirectByteBufferAddress(buffer);
+    long bufferAddress = AddressableMemoryManager.getDirectByteBufferAddress(buffer);
 
     // returned address should be starting of the value (after skipping HEADER_SIZE bytes)
-    assertEquals(chunk.getMemoryAddress() + ObjectStoredInMemory.HEADER_SIZE, bufferAddress);
+    assertEquals(chunk.getAddress() + ObjectStoredInMemory.HEADER_SIZE, bufferAddress);
 
     chunk.release();
   }
@@ -618,7 +618,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
   @Test(expected = AssertionError.class)
   public void getAddressForReadingShouldFailIfItsOutsideOfChunk() {
     ObjectStoredInMemory chunk = createValueAsSerializedStoredObject(getValue());
-    chunk.getAddressForReading(0, chunk.getDataSize() + 1);
+    chunk.getAddressForReadingData(0, chunk.getDataSize() + 1);
 
     chunk.release();
   }
@@ -628,7 +628,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
     ObjectStoredInMemory chunk = createValueAsSerializedStoredObject(getValue());
 
     int offset = 1;
-    long requestedAddress = chunk.getAddressForReading(offset, 1);
+    long requestedAddress = chunk.getAddressForReadingData(offset, 1);
 
     assertThat(requestedAddress).isEqualTo(chunk.getBaseDataAddress() + offset);
 
@@ -772,7 +772,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
   public void testToString() {
     ObjectStoredInMemory chunk = createValueAsUnserializedStoredObject(getValue());
 
-    String expected = ":<dataSize=" + chunk.getDataSize() + " refCount=" + chunk.getRefCount() + " addr=" + Long.toHexString(chunk.getMemoryAddress()) + ">";
+    String expected = ":<dataSize=" + chunk.getDataSize() + " refCount=" + chunk.getRefCount() + " addr=" + Long.toHexString(chunk.getAddress()) + ">";
     assertThat(chunk.toString()).endsWith(expected);
 
     chunk.release();
@@ -879,7 +879,7 @@ public class ObjectChunkJUnitTest extends AbstractStoredObjectTestBase {
     ObjectStoredInMemory chunk = (ObjectStoredInMemory) ma.allocateAndInitialize(new byte[100], isSerialized, isCompressed);
 
     // first fill the unused part with FILL_PATTERN
-    ObjectStoredInMemory.fill(chunk.getMemoryAddress());
+    ObjectStoredInMemory.fill(chunk.getAddress());
 
     // Validate that it is filled
     chunk.validateFill();

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectChunkWithHeapFormJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectChunkWithHeapFormJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectChunkWithHeapFormJUnitTest.java
index c6693d1..aa1df16 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectChunkWithHeapFormJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectChunkWithHeapFormJUnitTest.java
@@ -57,7 +57,7 @@ public class ObjectChunkWithHeapFormJUnitTest extends ObjectChunkJUnitTest {
 
     assertEquals(chunk, heapForm.getChunkWithoutHeapForm());
 
-    assertEquals(chunk.getMemoryAddress(), chunkWithOutHeapForm.getMemoryAddress());
+    assertEquals(chunk.getAddress(), chunkWithOutHeapForm.getAddress());
     assertArrayEquals(chunk.getRawBytes(), chunkWithOutHeapForm.getRawBytes());
     assertNotSame(valueInBytes, chunkWithOutHeapForm.getRawBytes());
   }

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectStoredAsAddressJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectStoredAsAddressJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectStoredAsAddressJUnitTest.java
index 74964df..cc23e91 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectStoredAsAddressJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/ObjectStoredAsAddressJUnitTest.java
@@ -104,11 +104,11 @@ public class ObjectStoredAsAddressJUnitTest extends AbstractStoredObjectTestBase
 
         ObjectStoredAsAddress address1 = new ObjectStoredAsAddress(10001L);
         assertNotNull(address1);
-        assertEquals("Encoding address should be:", 10001, address1.getEncodedAddress());
+        assertEquals("Encoding address should be:", 10001, address1.getAddress());
 
         ObjectStoredAsAddress address2 = new ObjectStoredAsAddress(10002L);
         assertNotNull(address2);
-        assertEquals("Returning always 10001 expected 10002", 10002, address2.getEncodedAddress());
+        assertEquals("Returning always 10001 expected 10002", 10002, address2.getAddress());
     }
 
     @Test

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapHelperJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapHelperJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapHelperJUnitTest.java
index 8af255a..4517206 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapHelperJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapHelperJUnitTest.java
@@ -38,7 +38,7 @@ import com.gemstone.gemfire.test.junit.categories.UnitTest;
 @Category(UnitTest.class)
 public class OffHeapHelperJUnitTest extends AbstractStoredObjectTestBase {
 
-  private AddressableStoredObject storedObject                 = null;
+  private StoredObject storedObject                 = null;
   private Object                  deserializedRegionEntryValue = null;
   private byte[]                  serializedRegionEntryValue   = null;
   private MemoryAllocator         ma;
@@ -102,7 +102,7 @@ public class OffHeapHelperJUnitTest extends AbstractStoredObjectTestBase {
   }
 
   @Override
-  protected AddressableStoredObject createValueAsUnserializedStoredObject(Object value) {
+  protected StoredObject createValueAsUnserializedStoredObject(Object value) {
     byte[] valueInByteArray;
     if (value instanceof Long) {
       valueInByteArray = convertValueToByteArray(value);
@@ -113,18 +113,18 @@ public class OffHeapHelperJUnitTest extends AbstractStoredObjectTestBase {
     boolean isSerialized = false;
     boolean isCompressed = false;
 
-    AddressableStoredObject createdObject = createChunk(valueInByteArray, isSerialized, isCompressed);
+    StoredObject createdObject = createChunk(valueInByteArray, isSerialized, isCompressed);
     return createdObject;
   }
 
   @Override
-  protected AddressableStoredObject createValueAsSerializedStoredObject(Object value) {
+  protected StoredObject createValueAsSerializedStoredObject(Object value) {
     byte[] valueInSerializedByteArray = EntryEventImpl.serialize(value);
 
     boolean isSerialized = true;
     boolean isCompressed = false;
 
-    AddressableStoredObject createdObject = createChunk(valueInSerializedByteArray, isSerialized, isCompressed);
+    StoredObject createdObject = createChunk(valueInSerializedByteArray, isSerialized, isCompressed);
     return createdObject;
   }
 

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapRegionBase.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapRegionBase.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapRegionBase.java
index 57f770a..a167414 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapRegionBase.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapRegionBase.java
@@ -92,7 +92,7 @@ public abstract class OffHeapRegionBase {
       assertNotNull(ma);
       final long offHeapSize = ma.getFreeMemory();
       assertEquals(0, ma.getUsedMemory());
-      AddressableStoredObject mc1 = ma.allocate(64);
+      StoredObject mc1 = ma.allocate(64);
       assertEquals(64+perObjectOverhead(), ma.getUsedMemory());
       assertEquals(offHeapSize-(64+perObjectOverhead()), ma.getFreeMemory());
       mc1.release();
@@ -123,7 +123,7 @@ public abstract class OffHeapRegionBase {
       assertNotNull(ma);
       final long offHeapSize = ma.getFreeMemory();
       assertEquals(0, ma.getUsedMemory());
-      AddressableStoredObject mc1 = ma.allocate(64);
+      StoredObject mc1 = ma.allocate(64);
       assertEquals(64+perObjectOverhead(), ma.getUsedMemory());
       assertEquals(offHeapSize-(64+perObjectOverhead()), ma.getFreeMemory());
       mc1.release();
@@ -163,7 +163,7 @@ public abstract class OffHeapRegionBase {
       final long offHeapSize = ma.getFreeMemory();
       assertEquals(0, ma.getUsedMemory());
       byte[] data = new byte[] {1,2,3,4,5,6,7,8};
-      AddressableStoredObject mc1 = (AddressableStoredObject)ma.allocateAndInitialize(data, false, false);
+      StoredObject mc1 = (StoredObject)ma.allocateAndInitialize(data, false, false);
       assertEquals(data.length+perObjectOverhead(), ma.getUsedMemory());
       assertEquals(offHeapSize-(data.length+perObjectOverhead()), ma.getFreeMemory());
       byte[] data2 = new byte[data.length];

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapRegionEntryHelperJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapRegionEntryHelperJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapRegionEntryHelperJUnitTest.java
index 4ed2d41..1b6bd02 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapRegionEntryHelperJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapRegionEntryHelperJUnitTest.java
@@ -295,7 +295,7 @@ public class OffHeapRegionEntryHelperJUnitTest {
   @Test
   public void isOffHeapShouldReturnTrueIfAddressIsOnOffHeap() {
     ObjectStoredInMemory value = createChunk(Long.MAX_VALUE);
-    assertThat(OffHeapRegionEntryHelper.isOffHeap(value.getMemoryAddress())).isTrue();
+    assertThat(OffHeapRegionEntryHelper.isOffHeap(value.getAddress())).isTrue();
   }
 
   @Test
@@ -330,13 +330,13 @@ public class OffHeapRegionEntryHelperJUnitTest {
     ObjectStoredInMemory newValue = createChunk(Long.MAX_VALUE);
     // mock region entry methods required for test
     when(re.getAddress()).thenReturn(oldAddress);
-    when(re.setAddress(oldAddress, newValue.getMemoryAddress())).thenReturn(Boolean.TRUE);
+    when(re.setAddress(oldAddress, newValue.getAddress())).thenReturn(Boolean.TRUE);
 
     // invoke the method under test
     OffHeapRegionEntryHelper.setValue(re, newValue);
 
     // verify oldAddress is replaced with newAddress
-    verify(re, times(1)).setAddress(oldAddress, newValue.getMemoryAddress());
+    verify(re, times(1)).setAddress(oldAddress, newValue.getAddress());
     // resetting the spy in-order to re-use
     reset(re);
 
@@ -344,11 +344,11 @@ public class OffHeapRegionEntryHelperJUnitTest {
     ObjectStoredAsAddress newAddress1 = new ObjectStoredAsAddress(2L);
     // mock region entry methods required for test
     when(re.getAddress()).thenReturn(oldAddress);
-    when(re.setAddress(oldAddress, newAddress1.getEncodedAddress())).thenReturn(Boolean.TRUE);
+    when(re.setAddress(oldAddress, newAddress1.getAddress())).thenReturn(Boolean.TRUE);
     OffHeapRegionEntryHelper.setValue(re, newAddress1);
 
     // verify oldAddress is replaced with newAddress
-    verify(re, times(1)).setAddress(oldAddress, newAddress1.getEncodedAddress());
+    verify(re, times(1)).setAddress(oldAddress, newAddress1.getAddress());
     reset(re);
 
     // Testing when newValue is Token Objects
@@ -446,21 +446,21 @@ public class OffHeapRegionEntryHelperJUnitTest {
     // mock Chunk static methods - in-order to verify that release is called
     PowerMockito.spy(ObjectStoredInMemory.class);
     PowerMockito.doNothing().when(ObjectStoredInMemory.class);
-    ObjectStoredInMemory.release(oldValue.getMemoryAddress());
+    ObjectStoredInMemory.release(oldValue.getAddress());
 
     // mock region entry methods required for test
-    when(re.getAddress()).thenReturn(oldValue.getMemoryAddress());
-    when(re.setAddress(oldValue.getMemoryAddress(), newValue.getMemoryAddress())).thenReturn(Boolean.TRUE);
+    when(re.getAddress()).thenReturn(oldValue.getAddress());
+    when(re.setAddress(oldValue.getAddress(), newValue.getAddress())).thenReturn(Boolean.TRUE);
 
     // invoke the method under test
     OffHeapRegionEntryHelper.setValue(re, newValue);
 
     // verify oldAddress is changed to newAddress
-    verify(re, times(1)).setAddress(oldValue.getMemoryAddress(), newValue.getMemoryAddress());
+    verify(re, times(1)).setAddress(oldValue.getAddress(), newValue.getAddress());
 
     // verify oldAddress is released
     PowerMockito.verifyStatic();
-    ObjectStoredInMemory.release(oldValue.getMemoryAddress());
+    ObjectStoredInMemory.release(oldValue.getAddress());
   }
 
   @Test
@@ -481,13 +481,13 @@ public class OffHeapRegionEntryHelperJUnitTest {
 
     // mock region entry methods required for test
     when(re.getAddress()).thenReturn(oldAddress);
-    when(re.setAddress(oldAddress, newAddress.getEncodedAddress())).thenReturn(Boolean.TRUE);
+    when(re.setAddress(oldAddress, newAddress.getAddress())).thenReturn(Boolean.TRUE);
 
     // invoke the method under test
     OffHeapRegionEntryHelper.setValue(re, newAddress);
 
     // verify oldAddress is changed to newAddress
-    verify(re, times(1)).setAddress(oldAddress, newAddress.getEncodedAddress());
+    verify(re, times(1)).setAddress(oldAddress, newAddress.getAddress());
 
     // verify that release is never called as the old address is not on offheap
     PowerMockito.verifyStatic(never());
@@ -544,7 +544,7 @@ public class OffHeapRegionEntryHelperJUnitTest {
     ObjectStoredInMemory chunk = createChunk(Long.MAX_VALUE);
 
     // mock region entry methods required for test
-    when(re.getAddress()).thenReturn(chunk.getMemoryAddress());
+    when(re.getAddress()).thenReturn(chunk.getAddress());
     Token token = OffHeapRegionEntryHelper.getValueAsToken(re);
 
     assertThat(token).isEqualTo(Token.NOT_A_TOKEN);
@@ -628,7 +628,7 @@ public class OffHeapRegionEntryHelperJUnitTest {
   @Test
   public void addressToObjectShouldReturnValueFromChunk() {
     ObjectStoredInMemory expected = createChunk(Long.MAX_VALUE);
-    Object actual = OffHeapRegionEntryHelper.addressToObject(expected.getMemoryAddress(), false, null);
+    Object actual = OffHeapRegionEntryHelper.addressToObject(expected.getAddress(), false, null);
 
     assertThat(actual).isInstanceOf(ObjectStoredInMemory.class);
     assertThat(actual).isEqualTo(expected);
@@ -655,7 +655,7 @@ public class OffHeapRegionEntryHelperJUnitTest {
     when(regionContext.getCachePerfStats()).thenReturn(cacheStats);
     when(cacheStats.startDecompression()).thenReturn(startTime);
 
-    Object actual = OffHeapRegionEntryHelper.addressToObject(chunk.getMemoryAddress(), true, regionContext);
+    Object actual = OffHeapRegionEntryHelper.addressToObject(chunk.getAddress(), true, regionContext);
 
     assertThat(actual).isInstanceOf(VMCachedDeserializable.class);
 
@@ -684,7 +684,7 @@ public class OffHeapRegionEntryHelperJUnitTest {
     when(regionContext.getCachePerfStats()).thenReturn(cacheStats);
     when(cacheStats.startDecompression()).thenReturn(startTime);
 
-    Object actual = OffHeapRegionEntryHelper.addressToObject(chunk.getMemoryAddress(), true, regionContext);
+    Object actual = OffHeapRegionEntryHelper.addressToObject(chunk.getAddress(), true, regionContext);
 
     assertThat(actual).isInstanceOf(byte[].class);
     assertThat(actual).isEqualTo(data);

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapValidationJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapValidationJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapValidationJUnitTest.java
index a9e8e5f..49cf900 100755
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapValidationJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/OffHeapValidationJUnitTest.java
@@ -122,7 +122,7 @@ public class OffHeapValidationJUnitTest {
       assertEquals(1024*1024*2, firstBlock.getBlockSize());
       assertEquals("N/A", firstBlock.getDataType());
       assertEquals(-1, firstBlock.getFreeListId());
-      assertTrue(firstBlock.getMemoryAddress() > 0);
+      assertTrue(firstBlock.getAddress() > 0);
       assertNull(firstBlock.getNextBlock());
       assertEquals(0, firstBlock.getRefCount());
       assertEquals(0, firstBlock.getSlabId());
@@ -202,7 +202,7 @@ public class OffHeapValidationJUnitTest {
       assertEquals(i + ":" + values.dataType, values.blockSize, block.getBlockSize());
       assertEquals(i + ":" + values.dataType, values.dataType, block.getDataType());
       assertEquals(i + ":" + values.dataType, values.freeListId, block.getFreeListId());
-      assertEquals(i + ":" + values.dataType, values.memoryAddress, block.getMemoryAddress());
+      assertEquals(i + ":" + values.dataType, values.memoryAddress, block.getAddress());
       assertEquals(i + ":" + values.dataType, values.refCount, block.getRefCount());
       assertEquals(i + ":" + values.dataType, values.slabId, block.getSlabId());
       assertEquals(i + ":" + values.dataType, values.isCompressed, block.isCompressed());
@@ -297,7 +297,7 @@ public class OffHeapValidationJUnitTest {
   private long getMemoryAddress(Region region, String key) {
     Object entry = ((LocalRegion) region).getRegionEntry(key)._getValue();
     assertTrue(entry instanceof ObjectStoredInMemory);
-    long memoryAddress = ((ObjectStoredInMemory)entry).getMemoryAddress();
+    long memoryAddress = ((ObjectStoredInMemory)entry).getAddress();
     assertTrue(memoryAddress > 0);
     return memoryAddress;
   }

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SimpleMemoryAllocatorFillPatternJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SimpleMemoryAllocatorFillPatternJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SimpleMemoryAllocatorFillPatternJUnitTest.java
index 9d89d6d..d28f989 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SimpleMemoryAllocatorFillPatternJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SimpleMemoryAllocatorFillPatternJUnitTest.java
@@ -135,7 +135,7 @@ public class SimpleMemoryAllocatorFillPatternJUnitTest {
     
     catchException(chunk).validateFill();
     assertTrue(caughtException() instanceof IllegalStateException);
-    assertEquals("Fill pattern violated for chunk " + chunk.getMemoryAddress() + " with size " + chunk.getSize(), caughtException().getMessage());
+    assertEquals("Fill pattern violated for chunk " + chunk.getAddress() + " with size " + chunk.getSize(), caughtException().getMessage());
     
   }
 

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SimpleMemoryAllocatorJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SimpleMemoryAllocatorJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SimpleMemoryAllocatorJUnitTest.java
index 72bee62..4fb5263 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SimpleMemoryAllocatorJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SimpleMemoryAllocatorJUnitTest.java
@@ -202,10 +202,10 @@ public class SimpleMemoryAllocatorJUnitTest {
       assertEquals(TOTAL_MEM, ma.freeList.getFreeFragmentMemory());
       assertEquals(0, ma.freeList.getFreeTinyMemory());
       assertEquals(0, ma.freeList.getFreeHugeMemory());
-      AddressableStoredObject tinymc = ma.allocate(maxTiny);
+      StoredObject tinymc = ma.allocate(maxTiny);
       assertEquals(TOTAL_MEM-round(TINY_MULTIPLE, maxTiny+perObjectOverhead), ma.getFreeMemory());
       assertEquals(round(TINY_MULTIPLE, maxTiny+perObjectOverhead)*(BATCH_SIZE-1), ma.freeList.getFreeTinyMemory());
-      AddressableStoredObject hugemc = ma.allocate(minHuge);
+      StoredObject hugemc = ma.allocate(minHuge);
       assertEquals(TOTAL_MEM-round(TINY_MULTIPLE, minHuge+perObjectOverhead)/*-round(BIG_MULTIPLE, maxBig+perObjectOverhead)*/-round(TINY_MULTIPLE, maxTiny+perObjectOverhead), ma.getFreeMemory());
       long freeSlab = ma.freeList.getFreeFragmentMemory();
       long oldFreeHugeMemory = ma.freeList.getFreeHugeMemory();
@@ -249,7 +249,7 @@ public class SimpleMemoryAllocatorJUnitTest {
       hugemc = ma.allocate(minHuge);
       assertEquals(round(TINY_MULTIPLE, minHuge+perObjectOverhead)*(BATCH_SIZE-1), ma.freeList.getFreeHugeMemory());
       if (BATCH_SIZE > 1) {
-        AddressableStoredObject hugemc2 = ma.allocate(minHuge);
+        StoredObject hugemc2 = ma.allocate(minHuge);
         assertEquals(round(TINY_MULTIPLE, minHuge+perObjectOverhead)*(BATCH_SIZE-2), ma.freeList.getFreeHugeMemory());
         hugemc2.release();
         assertEquals(round(TINY_MULTIPLE, minHuge+perObjectOverhead)*(BATCH_SIZE-1), ma.freeList.getFreeHugeMemory());
@@ -382,7 +382,7 @@ public class SimpleMemoryAllocatorJUnitTest {
         assertEquals(1024*1024, firstBlock.getBlockSize());
         assertEquals("N/A", firstBlock.getDataType());
         assertEquals(-1, firstBlock.getFreeListId());
-        assertTrue(firstBlock.getMemoryAddress() > 0);
+        assertTrue(firstBlock.getAddress() > 0);
         assertNull(firstBlock.getNextBlock());
         assertEquals(0, firstBlock.getRefCount());
         assertEquals(0, firstBlock.getSlabId());
@@ -434,16 +434,16 @@ public class SimpleMemoryAllocatorJUnitTest {
     SlabImpl slab = new SlabImpl(TOTAL_MEM);
     try {
       SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.createForUnitTest(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new SlabImpl[]{slab});
-      AddressableStoredObject bmc = ma.allocate(BIG_ALLOC_SIZE-perObjectOverhead);
+      StoredObject bmc = ma.allocate(BIG_ALLOC_SIZE-perObjectOverhead);
       try {
-        AddressableStoredObject smc = ma.allocate(SMALL_ALLOC_SIZE-perObjectOverhead);
+        StoredObject smc = ma.allocate(SMALL_ALLOC_SIZE-perObjectOverhead);
         fail("Expected out of memory");
       } catch (OutOfOffHeapMemoryException expected) {
       }
       bmc.release();
       assertEquals(TOTAL_MEM, ma.freeList.getFreeMemory());
-      AddressableStoredObject smc1 = ma.allocate(SMALL_ALLOC_SIZE-perObjectOverhead);
-      AddressableStoredObject smc2 = ma.allocate(SMALL_ALLOC_SIZE-perObjectOverhead);
+      StoredObject smc1 = ma.allocate(SMALL_ALLOC_SIZE-perObjectOverhead);
+      StoredObject smc2 = ma.allocate(SMALL_ALLOC_SIZE-perObjectOverhead);
       smc2.release();
       assertEquals(TOTAL_MEM-SMALL_ALLOC_SIZE, ma.freeList.getFreeMemory());
       try {
@@ -456,7 +456,7 @@ public class SimpleMemoryAllocatorJUnitTest {
       bmc = ma.allocate(BIG_ALLOC_SIZE-perObjectOverhead);
       bmc.release();
       assertEquals(TOTAL_MEM, ma.freeList.getFreeMemory());
-      ArrayList<AddressableStoredObject> mcs = new ArrayList<AddressableStoredObject>();
+      ArrayList<StoredObject> mcs = new ArrayList<StoredObject>();
       for (int i=0; i < BIG_ALLOC_SIZE/(8+perObjectOverhead); i++) {
         mcs.add(ma.allocate(8));
       }
@@ -492,11 +492,11 @@ public class SimpleMemoryAllocatorJUnitTest {
       assertEquals((8+perObjectOverhead)*6, ma.freeList.getFreeMemory());
       checkMcs(mcs);
       // At this point I should have 8*6 + perObjectOverhead*6 of free memory
-      AddressableStoredObject mc24 = ma.allocate(24);
+      StoredObject mc24 = ma.allocate(24);
       checkMcs(mcs);
       assertEquals((8+perObjectOverhead)*6 - (24+perObjectOverhead), ma.freeList.getFreeMemory());
       // At this point I should have 8*3 + perObjectOverhead*5 of free memory
-      AddressableStoredObject mc16 = ma.allocate(16);
+      StoredObject mc16 = ma.allocate(16);
       checkMcs(mcs);
       assertEquals((8+perObjectOverhead)*6 - (24+perObjectOverhead) - (16+perObjectOverhead), ma.freeList.getFreeMemory());
       // At this point I should have 8*1 + perObjectOverhead*4 of free memory
@@ -504,7 +504,7 @@ public class SimpleMemoryAllocatorJUnitTest {
       checkMcs(mcs);
       assertEquals((8+perObjectOverhead)*6 - (24+perObjectOverhead) - (16+perObjectOverhead) - (8+perObjectOverhead), ma.freeList.getFreeMemory());
       // At this point I should have 8*0 + perObjectOverhead*3 of free memory
-      AddressableStoredObject mcDO = ma.allocate(perObjectOverhead*2);
+      StoredObject mcDO = ma.allocate(perObjectOverhead*2);
       checkMcs(mcs);
       // At this point I should have 8*0 + perObjectOverhead*0 of free memory
       assertEquals(0, ma.freeList.getFreeMemory());
@@ -525,7 +525,7 @@ public class SimpleMemoryAllocatorJUnitTest {
       assertEquals((perObjectOverhead*3)+(8+perObjectOverhead)+(16+perObjectOverhead)+(24+perObjectOverhead), ma.freeList.getFreeMemory());
       
       long freeMem = ma.freeList.getFreeMemory();
-      for (AddressableStoredObject mc: mcs) {
+      for (StoredObject mc: mcs) {
         mc.release();
         assertEquals(freeMem+(8+perObjectOverhead), ma.freeList.getFreeMemory());
         freeMem += (8+perObjectOverhead);
@@ -559,7 +559,7 @@ public class SimpleMemoryAllocatorJUnitTest {
       
       this.expectedMemoryUsage = SMALL_ALLOC_SIZE;
       this.memoryUsageEventReceived = false;
-      AddressableStoredObject smc = ma.allocate(SMALL_ALLOC_SIZE-perObjectOverhead);
+      StoredObject smc = ma.allocate(SMALL_ALLOC_SIZE-perObjectOverhead);
       assertEquals(true, this.memoryUsageEventReceived);
       
       this.expectedMemoryUsage = SMALL_ALLOC_SIZE * 2;
@@ -588,8 +588,8 @@ public class SimpleMemoryAllocatorJUnitTest {
       SimpleMemoryAllocatorImpl.freeOffHeapMemory();
     }
   }
-  private void checkMcs(ArrayList<AddressableStoredObject> mcs) {
-    for (AddressableStoredObject mc: mcs) {
+  private void checkMcs(ArrayList<StoredObject> mcs) {
+    for (StoredObject mc: mcs) {
       assertEquals(8+8, mc.getSize());
     }
   }
@@ -614,11 +614,11 @@ public class SimpleMemoryAllocatorJUnitTest {
     try {
       SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.createForUnitTest(oooml, new NullOffHeapMemoryStats(), new SlabImpl[]{slab});
       // make a big allocation
-      AddressableStoredObject bmc = ma.allocate(BIG_ALLOC_SIZE-perObjectOverhead);
+      StoredObject bmc = ma.allocate(BIG_ALLOC_SIZE-perObjectOverhead);
       assertNull(ooom.get());
       // drive the ma to ooom with small allocations
       try {
-        AddressableStoredObject smc = ma.allocate(SMALL_ALLOC_SIZE-perObjectOverhead);
+        StoredObject smc = ma.allocate(SMALL_ALLOC_SIZE-perObjectOverhead);
         fail("Expected out of memory");
       } catch (OutOfOffHeapMemoryException expected) {
       }

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SyncChunkStackJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SyncChunkStackJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SyncChunkStackJUnitTest.java
index 71bac49..e24ff9f 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SyncChunkStackJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/SyncChunkStackJUnitTest.java
@@ -109,7 +109,7 @@ public class SyncChunkStackJUnitTest {
       SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.createForUnitTest(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new SlabImpl[]{slab});
       ObjectStoredInMemory chunk = (ObjectStoredInMemory) ma.allocate(100);
 
-      SyncChunkStack stack = new SyncChunkStack(chunk.getMemoryAddress());
+      SyncChunkStack stack = new SyncChunkStack(chunk.getAddress());
       assertEquals(false, stack.isEmpty());
     } finally {
       SimpleMemoryAllocatorImpl.freeOffHeapMemory();
@@ -124,7 +124,7 @@ public class SyncChunkStackJUnitTest {
       ObjectStoredInMemory chunk = (ObjectStoredInMemory) ma.allocate(100);
 
       SyncChunkStack stack = new SyncChunkStack();
-      stack.offer(chunk.getMemoryAddress());
+      stack.offer(chunk.getAddress());
       assertEquals(false, stack.isEmpty());
     } finally {
       SimpleMemoryAllocatorImpl.freeOffHeapMemory();
@@ -138,7 +138,7 @@ public class SyncChunkStackJUnitTest {
       SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.createForUnitTest(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new SlabImpl[]{slab});
       ObjectStoredInMemory chunk = (ObjectStoredInMemory) ma.allocate(100);
 
-      long addr = chunk.getMemoryAddress();
+      long addr = chunk.getAddress();
       SyncChunkStack stack = new SyncChunkStack();
       stack.offer(addr);
       assertEquals(addr, stack.getTopAddress());
@@ -165,7 +165,7 @@ public class SyncChunkStackJUnitTest {
       SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.createForUnitTest(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new SlabImpl[]{slab});
       ObjectStoredInMemory chunk = (ObjectStoredInMemory) ma.allocate(100);
 
-      long addr = chunk.getMemoryAddress();
+      long addr = chunk.getAddress();
       SyncChunkStack stack = new SyncChunkStack();
       stack.offer(addr);
       long clearAddr = stack.clear();
@@ -183,7 +183,7 @@ public class SyncChunkStackJUnitTest {
       SimpleMemoryAllocatorImpl ma = SimpleMemoryAllocatorImpl.createForUnitTest(new NullOutOfOffHeapMemoryListener(), new NullOffHeapMemoryStats(), new SlabImpl[]{slab});
       ObjectStoredInMemory chunk = (ObjectStoredInMemory) ma.allocate(100);
 
-      long addr = chunk.getMemoryAddress();
+      long addr = chunk.getAddress();
       SyncChunkStack stack = new SyncChunkStack();
       stack.offer(addr);
       long pollAddr = stack.poll();
@@ -202,7 +202,7 @@ public class SyncChunkStackJUnitTest {
       ObjectStoredInMemory chunk = (ObjectStoredInMemory) ma.allocate(100);
       int chunkSize = chunk.getSize();
 
-      long addr = chunk.getMemoryAddress();
+      long addr = chunk.getAddress();
       SyncChunkStack stack = new SyncChunkStack();
       stack.offer(addr);
       assertEquals(chunkSize, stack.computeTotalSize());
@@ -220,7 +220,7 @@ public class SyncChunkStackJUnitTest {
       ObjectStoredInMemory chunk = (ObjectStoredInMemory) ma.allocate(100);
       int chunkSize = chunk.getSize();
 
-      long addr = chunk.getMemoryAddress();
+      long addr = chunk.getAddress();
       SyncChunkStack stack = new SyncChunkStack();
       stack.offer(addr);
       LogWriter lw = mock(LogWriter.class);
@@ -244,7 +244,7 @@ public class SyncChunkStackJUnitTest {
         doConcurrentMod = false;
         ObjectStoredInMemory chunk2 = (ObjectStoredInMemory) ma.allocate(50);
         this.chunk2Size = chunk2.getSize();
-        this.offer(chunk2.getMemoryAddress());
+        this.offer(chunk2.getAddress());
       }
     }
   }
@@ -256,7 +256,7 @@ public class SyncChunkStackJUnitTest {
       ObjectStoredInMemory chunk = (ObjectStoredInMemory) ma.allocate(100);
       int chunkSize = chunk.getSize();
 
-      long addr = chunk.getMemoryAddress();
+      long addr = chunk.getAddress();
       TestableSyncChunkStack stack = new TestableSyncChunkStack(ma);
       stack.offer(addr);
       long totalSize = stack.computeTotalSize();
@@ -275,7 +275,7 @@ public class SyncChunkStackJUnitTest {
       ObjectStoredInMemory chunk = (ObjectStoredInMemory) ma.allocate(100);
       int chunkSize = chunk.getSize();
 
-      long addr = chunk.getMemoryAddress();
+      long addr = chunk.getAddress();
       TestableSyncChunkStack stack = new TestableSyncChunkStack(ma);
       stack.offer(addr);
       LogWriter lw = mock(LogWriter.class);

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/TinyMemoryBlockJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/TinyMemoryBlockJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/TinyMemoryBlockJUnitTest.java
index 7c87079..a4caa9e 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/TinyMemoryBlockJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/internal/offheap/TinyMemoryBlockJUnitTest.java
@@ -85,17 +85,17 @@ public class TinyMemoryBlockJUnitTest {
     return Long.valueOf(Long.MAX_VALUE);
   }
 
-  private AddressableStoredObject createChunk(byte[] v, boolean isSerialized, boolean isCompressed) {
-    AddressableStoredObject chunk = (AddressableStoredObject) ma.allocateAndInitialize(v, isSerialized, isCompressed);
+  private StoredObject createChunk(byte[] v, boolean isSerialized, boolean isCompressed) {
+    StoredObject chunk = (StoredObject) ma.allocateAndInitialize(v, isSerialized, isCompressed);
     return chunk;
   }
 
-  private AddressableStoredObject createValueAsSerializedStoredObject(Object value, boolean isCompressed) {
+  private StoredObject createValueAsSerializedStoredObject(Object value, boolean isCompressed) {
     byte[] valueInSerializedByteArray = EntryEventImpl.serialize(value);
 
     boolean isSerialized = true;
 
-    AddressableStoredObject createdObject = createChunk(valueInSerializedByteArray, isSerialized, isCompressed);
+    StoredObject createdObject = createChunk(valueInSerializedByteArray, isSerialized, isCompressed);
     return createdObject;
   }
 
@@ -103,7 +103,7 @@ public class TinyMemoryBlockJUnitTest {
     return ByteBuffer.allocate(Long.SIZE / Byte.SIZE).putLong((Long) value).array();
   }
 
-  private AddressableStoredObject createValueAsUnserializedStoredObject(Object value, boolean isCompressed) {
+  private StoredObject createValueAsUnserializedStoredObject(Object value, boolean isCompressed) {
     byte[] valueInByteArray;
     if (value instanceof Long) {
       valueInByteArray = convertValueToByteArray(value);
@@ -113,7 +113,7 @@ public class TinyMemoryBlockJUnitTest {
 
     boolean isSerialized = false;
 
-    AddressableStoredObject createdObject = createChunk(valueInByteArray, isSerialized, isCompressed);
+    StoredObject createdObject = createChunk(valueInByteArray, isSerialized, isCompressed);
     return createdObject;
   }
 
@@ -132,12 +132,12 @@ public class TinyMemoryBlockJUnitTest {
   @Test
   public void getMemoryAddressReturnsAddressBlockWasContructedFrom() {
     MemoryBlock mb = new TestableFreeListManager.TinyMemoryBlock(slabs[0].getMemoryAddress(), 0);
-    softly.assertThat(mb.getMemoryAddress()).isEqualTo(slabs[0].getMemoryAddress());
+    softly.assertThat(mb.getAddress()).isEqualTo(slabs[0].getMemoryAddress());
   }
 
   @Test
   public void getBlockSizeReturnsReturnsSizeOfUnderlyingChunk() {
-    MemoryBlock mb = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[0].getMemoryAddress(), slabs[0].getSize()).getMemoryAddress(), 0);
+    MemoryBlock mb = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[0].getMemoryAddress(), slabs[0].getSize()).getAddress(), 0);
     softly.assertThat(mb.getBlockSize()).isEqualTo(slabs[0].getSize());
   }
 
@@ -145,7 +145,7 @@ public class TinyMemoryBlockJUnitTest {
   public void getNextBlockThrowsUnsupportedOperationException() {
     expectedException.expect(UnsupportedOperationException.class);
 
-    MemoryBlock mb = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[0].getMemoryAddress(), slabs[0].getSize()).getMemoryAddress(), 0);
+    MemoryBlock mb = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[0].getMemoryAddress(), slabs[0].getSize()).getAddress(), 0);
     mb.getNextBlock();
     fail("getNextBlock failed to throw UnsupportedOperationException");
   }
@@ -154,23 +154,23 @@ public class TinyMemoryBlockJUnitTest {
   public void getSlabIdThrowsUnsupportedOperationException() {
     expectedException.expect(UnsupportedOperationException.class);
 
-    MemoryBlock mb = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[0].getMemoryAddress(), slabs[0].getSize()).getMemoryAddress(), 0);
+    MemoryBlock mb = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[0].getMemoryAddress(), slabs[0].getSize()).getAddress(), 0);
     mb.getSlabId();
     fail("getSlabId failed to throw UnsupportedOperationException");
   }
 
   @Test
   public void getFreeListIdReturnsIdBlockWasConstructedWith() {
-    MemoryBlock mb0 = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[0].getMemoryAddress(), slabs[0].getSize()).getMemoryAddress(), 0);
-    MemoryBlock mb1 = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[1].getMemoryAddress(), slabs[1].getSize()).getMemoryAddress(), 1);
+    MemoryBlock mb0 = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[0].getMemoryAddress(), slabs[0].getSize()).getAddress(), 0);
+    MemoryBlock mb1 = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[1].getMemoryAddress(), slabs[1].getSize()).getAddress(), 1);
     softly.assertThat(mb0.getFreeListId()).isEqualTo(0);
     softly.assertThat(mb1.getFreeListId()).isEqualTo(1);
   }
 
   @Test
   public void getRefCountReturnsZero() {
-    MemoryBlock mb0 = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[0].getMemoryAddress(), slabs[0].getSize()).getMemoryAddress(), 0);
-    MemoryBlock mb1 = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[1].getMemoryAddress(), slabs[1].getSize()).getMemoryAddress(), 1);
+    MemoryBlock mb0 = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[0].getMemoryAddress(), slabs[0].getSize()).getAddress(), 0);
+    MemoryBlock mb1 = new TestableFreeListManager.TinyMemoryBlock(new ObjectStoredInMemory(slabs[1].getMemoryAddress(), slabs[1].getSize()).getAddress(), 1);
     softly.assertThat(mb0.getRefCount()).isEqualTo(0);
     softly.assertThat(mb1.getRefCount()).isEqualTo(0);
   }
@@ -180,8 +180,8 @@ public class TinyMemoryBlockJUnitTest {
     Object obj = getValue();
     boolean compressed = false;
 
-    AddressableStoredObject storedObject0 = createValueAsSerializedStoredObject(obj, compressed);
-    MemoryBlock mb = new TestableFreeListManager.TinyMemoryBlock(((MemoryBlock)storedObject0).getMemoryAddress(), 0);
+    StoredObject storedObject0 = createValueAsSerializedStoredObject(obj, compressed);
+    MemoryBlock mb = new TestableFreeListManager.TinyMemoryBlock(((MemoryBlock)storedObject0).getAddress(), 0);
     softly.assertThat(mb.getDataType()).isEqualTo("N/A");
   }
 
@@ -190,8 +190,8 @@ public class TinyMemoryBlockJUnitTest {
     Object obj = getValue();
     boolean compressed = false;
 
-    AddressableStoredObject storedObject0 = createValueAsSerializedStoredObject(obj, compressed);
-    MemoryBlock mb = new TestableFreeListManager.TinyMemoryBlock(((MemoryBlock)storedObject0).getMemoryAddress(), 0);
+    StoredObject storedObject0 = createValueAsSerializedStoredObject(obj, compressed);
+    MemoryBlock mb = new TestableFreeListManager.TinyMemoryBlock(((MemoryBlock)storedObject0).getAddress(), 0);
     softly.assertThat(mb.getDataValue()).isNull();
   }
 
@@ -200,10 +200,10 @@ public class TinyMemoryBlockJUnitTest {
     Object obj = getValue();
     boolean compressed = false;
 
-    AddressableStoredObject storedObject0 = createValueAsSerializedStoredObject(obj, compressed);
-    AddressableStoredObject storedObject1 = createValueAsUnserializedStoredObject(obj, compressed);
-    MemoryBlock mb0 = new TestableFreeListManager.TinyMemoryBlock(((MemoryBlock)storedObject0).getMemoryAddress(), 0);
-    MemoryBlock mb1 = new TestableFreeListManager.TinyMemoryBlock(((MemoryBlock)storedObject1).getMemoryAddress(), 0);
+    StoredObject storedObject0 = createValueAsSerializedStoredObject(obj, compressed);
+    StoredObject storedObject1 = createValueAsUnserializedStoredObject(obj, compressed);
+    MemoryBlock mb0 = new TestableFreeListManager.TinyMemoryBlock(((MemoryBlock)storedObject0).getAddress(), 0);
+    MemoryBlock mb1 = new TestableFreeListManager.TinyMemoryBlock(((MemoryBlock)storedObject1).getAddress(), 0);
     softly.assertThat(mb0.isSerialized()).isFalse();
     softly.assertThat(mb1.isSerialized()).isFalse();
   }
@@ -212,10 +212,10 @@ public class TinyMemoryBlockJUnitTest {
   public void isCompressedReturnsFalse() {
     Object obj = getValue();
     boolean compressed = false;
-    AddressableStoredObject storedObject0 = createValueAsUnserializedStoredObject(obj, compressed);
-    AddressableStoredObject storedObject1 = createValueAsUnserializedStoredObject(obj, compressed = true);
-    MemoryBlock mb0 = new TestableFreeListManager.TinyMemoryBlock(((MemoryBlock)storedObject0).getMemoryAddress(), 0);
-    MemoryBlock mb1 = new TestableFreeListManager.TinyMemoryBlock(((MemoryBlock)storedObject1).getMemoryAddress(), 0);
+    StoredObject storedObject0 = createValueAsUnserializedStoredObject(obj, compressed);
+    StoredObject storedObject1 = createValueAsUnserializedStoredObject(obj, compressed = true);
+    MemoryBlock mb0 = new TestableFreeListManager.TinyMemoryBlock(((MemoryBlock)storedObject0).getAddress(), 0);
+    MemoryBlock mb1 = new TestableFreeListManager.TinyMemoryBlock(((MemoryBlock)storedObject1).getAddress(), 0);
     softly.assertThat(mb0.isCompressed()).isFalse();
     softly.assertThat(mb1.isCompressed()).isFalse();
   }

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1a49aa43/geode-core/src/test/java/com/gemstone/gemfire/pdx/OffHeapByteSourceJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/com/gemstone/gemfire/pdx/OffHeapByteSourceJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/pdx/OffHeapByteSourceJUnitTest.java
index e82124e..33fe1d9 100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/pdx/OffHeapByteSourceJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/pdx/OffHeapByteSourceJUnitTest.java
@@ -54,7 +54,7 @@ public class OffHeapByteSourceJUnitTest extends ByteSourceJUnitTest {
     StoredObject so = SimpleMemoryAllocatorImpl.getAllocator().allocateAndInitialize(bytes, false, false);
     if (so instanceof ObjectStoredInMemory) {
       // bypass the factory to make sure that OffHeapByteSource is tested
-      return new OffHeapByteSource((ObjectStoredInMemory)so);
+      return new OffHeapByteSource(so);
     } else {
       // bytes are so small they can be encoded in a long (see DataAsAddress).
       // So for this test just wrap the original bytes.


Mime
View raw message