org.apache.geode.internal.cache.OplogJUnitTest.java Source code

Java tutorial

Introduction

Here is the source code for org.apache.geode.internal.cache.OplogJUnitTest.java

Source

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
 * agreements. See the NOTICE file distributed with this work for additional information regarding
 * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the License. You may obtain a
 * copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package org.apache.geode.internal.cache;

import static org.junit.Assert.*;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.IntStream;

import com.jayway.awaitility.Awaitility;
import org.apache.commons.io.FileUtils;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.experimental.categories.Category;

import org.apache.geode.StatisticsFactory;
import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.CacheWriterException;
import org.apache.geode.cache.CommitConflictException;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.DiskAccessException;
import org.apache.geode.cache.DiskStore;
import org.apache.geode.cache.DiskStoreFactory;
import org.apache.geode.cache.EntryEvent;
import org.apache.geode.cache.EntryNotFoundException;
import org.apache.geode.cache.Scope;
import org.apache.geode.cache.util.CacheWriterAdapter;
import org.apache.geode.internal.InternalDataSerializer;
import org.apache.geode.internal.cache.Oplog.OPLOG_TYPE;
import org.apache.geode.test.dunit.ThreadUtils;
import org.apache.geode.test.dunit.Wait;
import org.apache.geode.test.dunit.WaitCriterion;
import org.apache.geode.test.junit.categories.FlakyTest;
import org.apache.geode.test.junit.categories.IntegrationTest;

/**
 * Testing Oplog API's
 */
@Category(IntegrationTest.class)
public class OplogJUnitTest extends DiskRegionTestingBase {

    boolean proceed = false;

    private final DiskRegionProperties diskProps = new DiskRegionProperties();

    static final int OP_CREATE = 1;

    static final int OP_MODIFY = 2;

    static final int OP_DEL = 3;

    protected volatile static Random random = new Random();

    protected long expectedOplogSize = Oplog.OPLOG_NEW_ENTRY_BASE_REC_SIZE;

    volatile int totalSuccessfulOperations = 0;

    protected int numCreate = 0;

    protected int numModify = 0;

    protected int numDel = 0;

    protected long delta;

    protected boolean flushOccuredAtleastOnce = false;

    volatile protected boolean assertDone = false;

    boolean failure = false;

    /** The key for entry */
    static final String KEY = "KEY1";

    /** The initial value for key */
    static final String OLD_VALUE = "VAL1";

    /** The updated value for key */
    static final String NEW_VALUE = "VAL2";

    /** The value read from cache using LocalRegion.getValueOnDiskOrBuffer API */
    static volatile String valueRead = null;

    /** Boolean to indicate test to proceed for validation */
    static volatile boolean proceedForValidation = false;

    protected volatile Thread rollerThread = null;

    @Override
    protected final void postSetUp() throws Exception {
        diskProps.setDiskDirs(dirs);
        DiskStoreImpl.SET_IGNORE_PREALLOCATE = true;
    }

    @Override
    protected final void postTearDown() throws Exception {
        DiskStoreImpl.SET_IGNORE_PREALLOCATE = false;
    }

    /**
     * Test method for 'org.apache.geode.internal.cache.Oplog.isBackup()'
     */
    @Test
    public void testIsBackup() {

        region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps);
        if (!((LocalRegion) region).getDiskRegion().isBackup()) {
            fail("Test persist backup not being correctly set for overflow and persist");
        }
        closeDown();

        region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);
        if (((LocalRegion) region).getDiskRegion().isBackup()) {
            fail("Test persist backup not being correctly set for overflow only mode");
        }
        closeDown();

        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        if (!((LocalRegion) region).getDiskRegion().isBackup()) {
            fail("Test persist backup not being correctly set for persist only");
        }
        closeDown();
    }

    /*
     * Test method for 'org.apache.geode.internal.cache.Oplog.useSyncWrites()'
     */
    @Test
    public void testUseSyncWrites() {
        boolean result;
        diskProps.setSynchronous(true);
        region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps);
        result = ((LocalRegion) region).getAttributes().isDiskSynchronous();
        if (!result) {
            fail("Synchronous is false when it is supposed to be true");
        }
        closeDown();

        region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);

        result = ((LocalRegion) region).getAttributes().isDiskSynchronous();
        if (!result) {
            fail("Synchronous is false when it is supposed to be true");
        }
        closeDown();

        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);

        result = ((LocalRegion) region).getAttributes().isDiskSynchronous();
        if (!result) {
            fail("Synchronous is false when it is supposed to be true");
        }
        closeDown();

        diskProps.setSynchronous(false);
        region = DiskRegionHelperFactory.getAsyncOverFlowAndPersistRegion(cache, diskProps);

        result = ((LocalRegion) region).getAttributes().isDiskSynchronous();
        if (result) {
            fail("Synchronous is true when it is supposed to be false");
        }

        closeDown();
        region = DiskRegionHelperFactory.getAsyncOverFlowOnlyRegion(cache, diskProps);

        result = ((LocalRegion) region).getAttributes().isDiskSynchronous();
        if (result) {
            fail("Synchronous is true when it is supposed to be false");
        }
        closeDown();

        region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps);

        result = ((LocalRegion) region).getAttributes().isDiskSynchronous();
        if (result) {
            fail("Synchronous is true when it is supposed to be false");
        }
        closeDown();
    }

    // @todo port testBufferOperations
    /**
     * Asif: Tests the correct behaviour of attributes like byte-threshhold, asynch thread wait
     * time,etc. 'org.apache.geode.internal.cache.Oplog.bufferOperations()'
     */
    // @Test
    // public void testBufferOperations()
    // {
    // boolean result;

    // diskProps.setBytesThreshold(0);
    // region = DiskRegionHelperFactory.getAsyncOverFlowAndPersistRegion(cache,
    // diskProps);
    // Oplog.WriterThread writer = ((LocalRegion)region).getDiskRegion()
    // .getChild().getAsynchWriter();
    // long waitTime = writer.getAsynchThreadWaitTime();
    // long buffSize = writer.getBufferSize();
    // result = waitTime == writer.getDefaultAsynchThreadWaitTime()
    // && buffSize == 0;

    // assertTrue("buffer operations is true when it is supposed to be false",
    // result);

    // closeDown();

    // region = DiskRegionHelperFactory.getAsyncOverFlowOnlyRegion(cache,
    // diskProps);
    // writer = ((LocalRegion)region).getDiskRegion().getChild().getAsynchWriter();
    // waitTime = writer.getAsynchThreadWaitTime();
    // buffSize = writer.getBufferSize();
    // result = waitTime == writer.getDefaultAsynchThreadWaitTime()
    // && buffSize == 0;

    // assertTrue("buffer operations is true when it is supposed to be false",
    // result);
    // closeDown();

    // region = DiskRegionHelperFactory
    // .getAsyncPersistOnlyRegion(cache, diskProps);
    // writer = ((LocalRegion)region).getDiskRegion().getChild().getAsynchWriter();
    // waitTime = writer.getAsynchThreadWaitTime();
    // buffSize = writer.getBufferSize();
    // result = waitTime == writer.getDefaultAsynchThreadWaitTime()
    // && buffSize == 0;

    // assertTrue("buffer operations is true when it is supposed to be false",
    // result);

    // closeDown();

    // diskProps.setBytesThreshold(100);

    // region = DiskRegionHelperFactory.getAsyncOverFlowAndPersistRegion(cache,
    // diskProps);

    // writer = ((LocalRegion)region).getDiskRegion().getChild().getAsynchWriter();
    // waitTime = writer.getAsynchThreadWaitTime();
    // buffSize = writer.getBufferSize();
    // result = waitTime <= 0 && buffSize > 0;
    // assertTrue("bufferoperations is false when it is supposed to be true",
    // result);

    // closeDown();

    // region = DiskRegionHelperFactory.getAsyncOverFlowOnlyRegion(cache,
    // diskProps);

    // writer = ((LocalRegion)region).getDiskRegion().getChild().getAsynchWriter();
    // waitTime = writer.getAsynchThreadWaitTime();
    // buffSize = writer.getBufferSize();
    // result = waitTime <= 0 && buffSize > 0;
    // assertTrue("baufferoperations is false when it is supposed to be true",
    // result);

    // closeDown();

    // region = DiskRegionHelperFactory
    // .getAsyncPersistOnlyRegion(cache, diskProps);

    // writer = ((LocalRegion)region).getDiskRegion().getChild().getAsynchWriter();
    // waitTime = writer.getAsynchThreadWaitTime();
    // buffSize = writer.getBufferSize();
    // result = waitTime <= 0 && buffSize > 0;
    // assertTrue("baufferoperations is false when it is supposed to be true",
    // result);

    // closeDown();
    // }

    /**
     * Test method for 'org.apache.geode.internal.cache.Oplog.clear(File)'
     */
    @Test
    public void testClear() {
        region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps);
        putTillOverFlow(region);
        region.clear();
        region.close();
        region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps);
        assertTrue(" failed in get OverflowAndPersist ", region.get(new Integer(0)) == null);
        closeDown();

        region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);
        putTillOverFlow(region);
        region.clear();
        region.close();
        region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);
        assertTrue(" failed in get OverflowOnly ", region.get(new Integer(0)) == null);
        closeDown();

        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        put100Int();
        region.clear();
        region.close();
        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        assertTrue(" failed in get PersistOnly ", region.get(new Integer(0)) == null);
        closeDown();
    }

    /**
     * Test method for 'org.apache.geode.internal.cache.Oplog.close()'
     */
    @Test
    public void testClose() {
        {
            deleteFiles();
            region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps);
            DiskRegion dr = ((LocalRegion) region).getDiskRegion();
            Oplog oplog = dr.testHook_getChild();
            long id = oplog.getOplogId();
            oplog.close();
            // lk should still exist since it locks DiskStore not just one oplog
            // checkIfContainsFile(".lk");

            StatisticsFactory factory = region.getCache().getDistributedSystem();
            Oplog newOplog = new Oplog(id, dr.getOplogSet(), new DirectoryHolder(factory, dirs[0], 1000, 0));
            dr.getOplogSet().setChild(newOplog);
            closeDown();
        }
        {
            deleteFiles();
            region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);
            DiskRegion dr = ((LocalRegion) region).getDiskRegion();
            dr.testHookCloseAllOverflowOplogs();
            // lk should still exist since it locks DiskStore not just one oplog
            // checkIfContainsFile(".lk");
            checkIfContainsFile("OVERFLOW");
            closeDown();
        }
        {
            deleteFiles();
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            DiskRegion dr = ((LocalRegion) region).getDiskRegion();
            Oplog oplog = dr.testHook_getChild();
            long id = oplog.getOplogId();
            oplog.close();
            // lk should still exist since it locks DiskStore not just one oplog
            // checkIfContainsFile(".lk");
            StatisticsFactory factory = region.getCache().getDistributedSystem();
            Oplog newOplog = new Oplog(id, dr.getOplogSet(), new DirectoryHolder(factory, dirs[0], 1000, 2));
            dr.setChild(newOplog);
            closeDown();
        }

    }

    @Override
    protected void closeDown() {
        DiskRegion dr = null;
        if (region != null) {
            dr = ((LocalRegion) region).getDiskRegion();
        }
        super.closeDown();
        if (dr != null) {
            dr.getDiskStore().close();
            ((LocalRegion) region).getGemFireCache().removeDiskStore(dr.getDiskStore());
        }
    }

    void checkIfContainsFile(String fileExtension) {
        for (int i = 0; i < 4; i++) {
            File[] files = dirs[i].listFiles();
            for (int j = 0; j < files.length; j++) {
                if (files[j].getAbsolutePath().endsWith(fileExtension)) {
                    fail("file " + files[j] + " still exists after oplog.close()");
                }
            }
        }
    }

    /**
     * Test method for 'org.apache.geode.internal.cache.Oplog.destroy()'
     */
    @Test
    public void testDestroy() {
        region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps);
        put100Int();
        putTillOverFlow(region);
        try {
            region.destroy(new Integer(0));
        } catch (EntryNotFoundException e1) {
            logWriter.error("Exception occured", e1);
            fail(" Entry not found when it was expected to be there");
        }
        region.close();
        region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps);
        assertTrue(" failed in get OverflowAndPersist ", region.get(new Integer(0)) == null);
        closeDown();

        region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);
        put100Int();
        putTillOverFlow(region);
        try {
            region.destroy(new Integer(0));
        } catch (EntryNotFoundException e1) {
            logWriter.error("Exception occured", e1);
            fail(" Entry not found when it was expected to be there");
        }
        region.close();
        region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);
        assertTrue(" failed in get OverflowOnly ", region.get(new Integer(0)) == null);

        closeDown();

        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        put100Int();
        try {
            region.destroy(new Integer(0));
        } catch (EntryNotFoundException e1) {
            logWriter.error("Exception occured", e1);
            fail(" Entry not found when it was expected to be there");
        }
        region.close();
        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        assertTrue(" failed in get PersistOnly ", region.get(new Integer(0)) == null);
        closeDown();

    }

    /**
     * Test method for 'org.apache.geode.internal.cache.Oplog.remove(long)'
     */
    @Test
    public void testRemove() {
        region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps);
        putTillOverFlow(region);
        region.remove(new Integer(0));
        region.close();
        region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps);
        assertTrue(" failed in get OverflowAndPersist ", region.get(new Integer(0)) == null);
        closeDown();

        region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);
        putTillOverFlow(region);
        region.remove(new Integer(0));
        assertTrue(" failed in get OverflowOnly ", region.get(new Integer(0)) == null);
        region.close();
        region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);
        closeDown();

        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        put100Int();
        region.remove(new Integer(0));
        assertTrue(" failed in get PersistOnly ", region.get(new Integer(0)) == null);
        region.close();
        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        closeDown();

    }

    // @todo: port testByteBufferCreationForCreateModifyAndDeleteOperation
    /**
     * This tests the final ByteBuffer object that gets created for synch/Asynch operation for a
     * create / modify & Delete operation
     *
     */
    // @Test
    // public void testByteBufferCreationForCreateModifyAndDeleteOperation()
    // {
    // // Asif First create a persist only disk region which is of aysnch
    // // & switch of OplOg type
    // diskProps.setMaxOplogSize(1000);
    // diskProps.setBytesThreshold(500);
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(false);
    // diskProps.setSynchronous(false);
    // diskProps.setTimeInterval(-1);
    // diskProps.setOverflow(false);

    // region = DiskRegionHelperFactory
    // .getAsyncPersistOnlyRegion(cache, diskProps);
    // byte[] val = new byte[10];
    // for (int i = 0; i < 10; ++i) {
    // val[i] = (byte)i;
    // }
    // region.put(new Integer(1), val);
    // DiskEntry entry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(new Integer(1)));
    // long opKey = entry.getDiskId().getKeyId();
    // // The final position in the Byte Buffer created in Asynch Op should be
    // int createPos = 2 + 4 + val.length;
    // if (opKey > Integer.MAX_VALUE) {
    // createPos += 8;
    // }
    // else if (opKey > Short.MAX_VALUE) {
    // createPos += 4;
    // }
    // else {
    // createPos += 2;
    // }
    // createPos += 4;
    // createPos += EntryEventImpl.serialize(new Integer(1)).length;
    // DiskRegion dr = ((LocalRegion)region).getDiskRegion();
    // Oplog.WriterThread writer = dr.getChild().getAsynchWriter();
    // Oplog.AsyncOp asynchOp = writer
    // .getAsynchOpForEntryFromPendingFlushMap(entry.getDiskId());
    // ByteBuffer bb = asynchOp.getByteBuffer();
    // assertTrue(createPos == bb.position());
    // assertTrue(bb.limit() == bb.capacity());
    // byte val1[] = new byte[20];
    // for (int i = 0; i < 20; ++i) {
    // val1[i] = (byte)i;
    // }
    // region.put(new Integer(1), val1);
    // bb = writer.getAsynchOpForEntryFromPendingFlushMap(entry.getDiskId())
    // .getByteBuffer();
    // createPos += 10;
    // assertTrue(createPos == bb.position());
    // assertTrue(bb.limit() == bb.capacity());
    // byte val2[] = new byte[30];
    // for (int i = 0; i < 30; ++i) {
    // val2[i] = (byte)i;
    // }
    // region.put(new Integer(1), val2);
    // bb = writer.getAsynchOpForEntryFromPendingFlushMap(entry.getDiskId())
    // .getByteBuffer();
    // createPos += 10;
    // assertTrue(createPos == bb.position());
    // assertTrue(bb.limit() == bb.capacity());
    // long opSizeBeforeCreateRemove = dr.getChild().getOplogSize();
    // long pendingFlushSize = dr.getChild().getAsynchWriter()
    // .getCurrentBufferedBytesSize();
    // region.put(new Integer(2), val2);
    // DiskEntry entry2 = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(new Integer(2)));
    // bb = writer.getAsynchOpForEntryFromPendingFlushMap(entry2.getDiskId())
    // .getByteBuffer();
    // assertNotNull(bb);
    // region.remove(new Integer(2));
    // assertNull(writer
    // .getAsynchOpForEntryFromPendingFlushMap(entry2.getDiskId()));
    // assertIndexDetailsEquals(opSizeBeforeCreateRemove, dr.getChild().getOplogSize());
    // assertIndexDetailsEquals(pendingFlushSize, dr.getChild().getAsynchWriter()
    // .getCurrentBufferedBytesSize());

    // closeDown();

    // }

    /**
     * Tests whether the data is written in the right format on the disk
     *
     */
    @Test
    public void testFaultInOfValuesFromDisk() {
        try {
            // Asif First create a persist only disk region which is of aysnch
            // & switch of OplOg type
            diskProps.setMaxOplogSize(1000);

            diskProps.setPersistBackup(true);
            diskProps.setRolling(false);
            diskProps.setSynchronous(true);
            diskProps.setTimeInterval(-1);
            diskProps.setOverflow(false);

            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            byte[] val = new byte[10];
            for (int i = 0; i < 10; ++i) {
                val[i] = (byte) i;
            }
            region.put(new Integer(1), val);

            DiskEntry entry = ((DiskEntry) ((LocalRegion) region).basicGetEntry(new Integer(1)));
            DiskRegion dr = ((LocalRegion) region).getDiskRegion();

            val = (byte[]) dr.getNoBuffer(entry.getDiskId());
            for (int i = 0; i < 10; ++i) {
                if (val[i] != (byte) i) {
                    fail("Test for fault in from disk failed");
                }
            }
            val = (byte[]) DiskStoreImpl
                    .convertBytesAndBitsIntoObject(dr.getBytesAndBitsWithoutLock(entry.getDiskId(), true, false));
            for (int i = 0; i < 10; ++i) {
                if (val[i] != (byte) i) {
                    fail("Test for fault in from disk failed");
                }
            }
            region.invalidate(new Integer(1));
            assertTrue(dr.getNoBuffer(entry.getDiskId()) == Token.INVALID);

        } catch (Exception e) {
            logWriter.error("Exception occured", e);
            fail(e.toString());
        }
        closeDown();
    }

    // @todo port testAsynchWriterTerminationOnSwitch
    /**
     * Tests the termination of asynch writer for an Oplog after the switch has been made
     *
     */
    // @Test
    // public void testAsynchWriterTerminationOnSwitch()
    // {
    // // & switch of OplOg type
    // diskProps.setMaxOplogSize(23);
    // diskProps.setBytesThreshold(0);
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(false);
    // diskProps.setSynchronous(false);
    // diskProps.setTimeInterval(10000);
    // diskProps.setOverflow(false);
    // // diskProps.setDiskDirs(new File[]{new File("test1"), new
    // // File("test2"),
    // // new File("test3")});

    // region = DiskRegionHelperFactory
    // .getAsyncPersistOnlyRegion(cache, diskProps);
    // DiskRegion dr = ((LocalRegion)region).getDiskRegion();
    // Oplog.WriterThread writer = dr.getChild().getAsynchWriter();
    // // Populate data just below the switch over threshhold
    // byte[] val = new byte[5];
    // for (int i = 0; i < 5; ++i) {
    // val[i] = (byte)i;
    // }

    // region.put(new Integer(1), val);

    // DiskEntry entry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(new Integer(1)));
    // long opKey = entry.getDiskId().getKeyId();
    // // The final position in the Byte Buffer created in Asynch Op should be
    // int createPos = 2 + 4 + val.length;
    // if (opKey > Integer.MAX_VALUE) {
    // createPos += 8;
    // }
    // else if (opKey > Short.MAX_VALUE) {
    // createPos += 4;
    // }
    // else {
    // createPos += 2;
    // }
    // createPos += 4;
    // createPos += EntryEventImpl.serialize(new Integer(1)).length;
    // assertTrue(createPos == 22);
    // region.put(new Integer(2), val);
    // DistributedTestCase.join(writer.getThread(), 10 * 1000, null);
    // closeDown();
    // }

    /**
     * Tests the original ByteBufferPool gets transferred to the new Oplog for synch mode
     *
     */
    @Test
    public void testByteBufferPoolTransferForSynchMode() {
        diskProps.setMaxOplogSize(1024);
        diskProps.setBytesThreshold(0);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setSynchronous(true);
        diskProps.setTimeInterval(10000);
        diskProps.setOverflow(false);
        // diskProps.setDiskDirs(new File[]{new File("test1"), new
        // File("test2"),
        // new File("test3")});

        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        DiskRegion dr = ((LocalRegion) region).getDiskRegion();
        // assertNull(dr.getChild().getAsynchWriter());
        // Populate data just below the switch over threshhold
        byte[] val = new byte[5];
        for (int i = 0; i < 5; ++i) {
            val[i] = (byte) i;
        }

        region.put(new Integer(1), val);

        ((LocalRegion) region).basicGetEntry(new Integer(1));
        Oplog old = dr.testHook_getChild();
        ByteBuffer oldWriteBuf = old.getWriteBuf();
        region.forceRolling(); // start a new oplog
        region.put(new Integer(2), val);
        Oplog switched = dr.testHook_getChild();
        assertTrue(old != switched);
        assertEquals(dr.getDiskStore().persistentOplogs.getChild(2), switched);
        assertEquals(oldWriteBuf, switched.getWriteBuf());
        assertEquals(null, old.getWriteBuf());
        closeDown();

    }

    // @todo port this test if needed. ByteBufferPool code is going to change
    /**
     * Tests the ByteBufferPool usage during asynch mode operation & ensuring that GetOperation does
     * not get corrupted data due to returing of ByetBuffer to the pool. There are 5 pre created pools
     * in Oplog . Each pool has size of 1. Out of 5 pools , only one pool is used by the test. Thus
     * there are 4 bytebuffers which will always be free. Thus if the asynch writer had initially 8
     * byte buffers only 4 will be released
     *
     */
    // @Test
    // public void testByteBufferPoolUsageForAsynchMode()
    // {
    // final int PRCREATED_POOL_NUM = 5;
    // try {
    // // Asif First create a persist only disk region which is of aysnch
    // // & switch of OplOg type
    // diskProps.setMaxOplogSize(1000);
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(false);
    // diskProps.setSynchronous(false);
    // diskProps.setTimeInterval(-1);
    // diskProps.setOverflow(false);
    // final int byte_threshold = 500;
    // diskProps.setBytesThreshold(byte_threshold);
    // byte[] val = new byte[50];
    // region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache,
    // diskProps);
    // for (int i = 0; i < 50; ++i) {
    // val[i] = (byte)i;
    // }
    // region.put(new Integer(1), val);
    // final int singleOpSize = evaluateSizeOfOperationForPersist(
    // new Integer(1), val, ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(new Integer(1))).getDiskId(), OP_CREATE);

    // final int loopCount = byte_threshold / singleOpSize + 1;
    // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;

    // final Thread th = new Thread(new Runnable() {
    // public void run()
    // {
    // takeRecursiveLockOnAllEntries(1);
    // DiskRegion dr = ((LocalRegion)region).getDiskRegion();
    // // Asif : Sleep for somemore time
    // try {
    // Thread.yield();
    // Thread.sleep(4000);
    // }
    // catch (InterruptedException ie) {
    // logWriter.error("Exception occured", ie);
    // failureCause = "No guarantee of vaildity of result hence failing. Exception = "
    // + ie;
    // testFailed = true;
    // fail("No guarantee of vaildity of result hence failing. Exception = "
    // + ie);
    // }

    // // There shoudl beatleast one Pool which has active counts
    // // as two
    // Oplog.ByteBufferPool bbp = null;
    // List pools = dr.getChild().getByteBufferPoolList();
    // Iterator itr = pools.iterator();
    // boolean found = false;
    // while (itr.hasNext()) {
    // bbp = (Oplog.ByteBufferPool)itr.next();
    // int len = bbp.getByteBufferHolderList().size();
    // if (len == (loopCount - (PRCREATED_POOL_NUM - 1))) {
    // found = true;
    // break;
    // }
    // }

    // if (!found) {
    // testFailed = true;
    // failureCause = "Test failed as the Asynch writer did not release ByetBuffer after get
    // operation";
    // fail("Test failed as the Asynch writer did not release ByetBuffer after get operation");

    // }

    // }

    // private void takeRecursiveLockOnAllEntries(int key)
    // {
    // // Get the DisKID
    // DiskRegion dr = ((LocalRegion)region).getDiskRegion();
    // if (key > loopCount) {
    // // Interrupt the writer thread so as to start releasing
    // // bytebuffer to pool
    // //dr.getChild().getAsynchWriter().interrupt();
    // // Sleep for a while & check the active ByteBuffer
    // // count.
    // // It should be two
    // try {
    // Thread.yield();
    // Thread.sleep(5000);
    // }
    // catch (InterruptedException ie) {
    // logWriter.error("Exception occured", ie);
    // failureCause = "No guarantee of vaildity of result hence failing. Exception = "
    // + ie;
    // testFailed = true;
    // fail("No guarantee of vaildity of result hence failing. Exception = "
    // + ie);
    // }
    // // Check the number of ByteBuffers in the pool.
    // List pools = dr.getChild().getByteBufferPoolList();
    // // There shoudl beatleast one Pool which has active
    // // counts as two
    // Oplog.ByteBufferPool bbp = null;
    // Iterator itr = pools.iterator();
    // boolean found = true;
    // int len = -1;
    // while (itr.hasNext()) {
    // bbp = (Oplog.ByteBufferPool)itr.next();
    // len = bbp.getByteBufferHolderList().size();
    // if (len > 1) {
    // found = false;
    // break;
    // }
    // }
    // if (!found) {
    // failureCause = "Test failed as the Asynch writer released ByteBuffer before get operation. The
    // length of byte buffer pool is found to be greater than 0. the length is"
    // + len;
    // testFailed = true;
    // fail("Test failed as the Asynch writer released ByteBuffer before get operation");
    // }
    // }
    // else {
    // DiskEntry entry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(new Integer(key)));
    // DiskId id = entry.getDiskId();

    // synchronized (id) {
    // takeRecursiveLockOnAllEntries(++key);

    // }
    // }
    // }

    // });

    // CacheObserver old = CacheObserverHolder
    // .setInstance(new CacheObserverAdapter() {
    // public void afterWritingBytes()
    // {
    // // Asif Start a Thread & do a get in the thread without
    // // releasing the
    // // lock on dik ID
    // th.start();
    // synchronized (OplogJUnitTest.this) {
    // OplogJUnitTest.this.proceed = true;
    // OplogJUnitTest.this.notify();
    // }
    // try {
    // th.join(30 * 1000); // Yes, really use Thread#join here
    // fail("never interrupted");
    // }
    // catch (InterruptedException ie) {
    // // OK. Expected the interrupted Exception
    // if (debug)
    // System.out.println("Got the right exception");
    // }

    // }
    // });

    // int totalOpSize = singleOpSize;
    // for (int j = 1; j < loopCount; ++j) {
    // region.put(new Integer(j + 1), val);
    // totalOpSize += evaluateSizeOfOperationForPersist(new Integer(j + 1),
    // val, ((DiskEntry)((LocalRegion)region).basicGetEntry(new Integer(
    // j + 1))).getDiskId(), OP_CREATE);
    // }
    // assertTrue(totalOpSize - byte_threshold <= singleOpSize);

    // if (!proceed) {
    // synchronized (this) {
    // if (!proceed) {
    // this.wait(25000);
    // if (!proceed) {
    // fail("Test failed as no callback recieved from asynch writer");
    // }
    // }
    // }
    // }
    // DistributedTestCase.join(th, 30 * 1000, null);
    // CacheObserverHolder.setInstance(old);
    // }
    // catch (Exception e) {
    // logWriter.error("Exception occured", e);
    // fail(e.toString());
    // }
    // assertFalse(failureCause, testFailed);
    // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
    // closeDown();
    // }

    // give the new oplog record format it is too hard for the test to calculate
    // the expected size
    // /**
    // */
    // @Test
    // public void testSynchModeConcurrentOperations()
    // {
    // final Map map = new HashMap();
    // diskProps.setMaxOplogSize(1024 * 1024 * 20);
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(false);
    // diskProps.setSynchronous(true);
    // diskProps.setOverflow(false);
    // final int THREAD_COUNT = 90;

    // final byte[] val = new byte[50];
    // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps);
    // for (int i = 1; i < 101; ++i) {
    // map.put(new Integer(i), new Integer(i));
    // }
    // Thread[] threads = new Thread[THREAD_COUNT];
    // for (int i = 0; i < THREAD_COUNT; ++i) {
    // threads[i] = new Thread(new Runnable() {

    // public void run()
    // {
    // int sizeOfOp = 0;
    // DiskId id = null;
    // for (int j = 0; j < 50; ++j) {
    // int keyNum = random.nextInt(10) + 1;
    // Integer key = new Integer(keyNum);
    // Integer intgr = (Integer)map.get(key);
    // try {
    // synchronized (intgr) {

    // region.create(key, val);
    // DiskEntry entry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(key));
    // id = entry.getDiskId();

    // }
    // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(key,
    // val, id, OP_CREATE);
    // synchronized (OplogJUnitTest.this) {
    // OplogJUnitTest.this.expectedOplogSize += sizeOfOp;
    // ++OplogJUnitTest.this.totalSuccessfulOperations;
    // ++OplogJUnitTest.this.numCreate;
    // }
    // }
    // catch (EntryExistsException eee) {
    // if (OplogJUnitTest.this.logWriter.finerEnabled()) {
    // OplogJUnitTest.this.logWriter
    // .finer("The entry already exists so this operation will not increase the size of oplog");
    // }
    // }
    // try {
    // boolean isUpdate = false;
    // synchronized (intgr) {
    // isUpdate = region.containsKey(key);
    // region.put(key, val);
    // DiskEntry entry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(key));
    // id = entry.getDiskId();
    // }
    // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(key,
    // val, id, (isUpdate ? OP_MODIFY : OP_CREATE));
    // synchronized (OplogJUnitTest.this) {
    // OplogJUnitTest.this.expectedOplogSize += sizeOfOp;
    // ++OplogJUnitTest.this.totalSuccessfulOperations;
    // if (!isUpdate) {
    // ++OplogJUnitTest.this.numCreate;
    // }
    // else {
    // ++OplogJUnitTest.this.numModify;
    // }
    // }
    // }
    // catch (EntryDestroyedException ede) {
    // if (OplogJUnitTest.this.logWriter.finerEnabled()) {
    // OplogJUnitTest.this.logWriter
    // .finer("The entry already exists so this operation will not increase the size of oplog");
    // }
    // }

    // boolean deleted = false;
    // synchronized (intgr) {
    // if (region.containsKey(key)) {
    // DiskEntry entry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(key));
    // id = entry.getDiskId();
    // region.remove(key);
    // deleted = true;
    // }

    // }
    // if (deleted) {
    // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(key,
    // null, id, OP_DEL);
    // synchronized (OplogJUnitTest.this) {
    // OplogJUnitTest.this.expectedOplogSize += sizeOfOp;
    // ++OplogJUnitTest.this.totalSuccessfulOperations;
    // ++OplogJUnitTest.this.numDel;

    // }
    // }

    // }

    // }

    // });
    // threads[i].start();
    // }

    // for (int i = 0; i < THREAD_COUNT; ++i) {
    // DistributedTestCase.join(threads[i], 30 * 1000, null);
    // }
    // long inMemOplogSize = 0;
    // File opFile = null;
    // try {
    // opFile = ((LocalRegion)region).getDiskRegion().getChild().getOplogFile();
    // }
    // catch (Exception e) {
    // logWriter
    // .error(
    // "Exception in synching data present in the buffers of RandomAccessFile of Oplog, to the disk",
    // e);
    // fail("Test failed because synching of data present in buffer of RandomAccesFile ");
    // }
    // synchronized (opFile) {
    // inMemOplogSize = ((LocalRegion)region).getDiskRegion().getChild().getOplogSize();
    // }

    // long actFileSize = 0;
    // try {

    // actFileSize = ((LocalRegion)region).getDiskRegion().getChild().testGetOplogFileLength();
    // }
    // catch (IOException e) {

    // fail("exception not expected" + e);
    // fail("The test failed as the oplog could not eb synched to disk");
    // }
    // assertIndexDetailsEquals((this.numCreate + this.numDel + this.numModify),
    // this.totalSuccessfulOperations);
    // assertTrue(" The expected oplog size =" + inMemOplogSize
    // + " Actual Oplog file size =" + actFileSize,
    // inMemOplogSize == actFileSize);
    // assertTrue(" The expected oplog size =" + this.expectedOplogSize
    // + " In memeory Oplog size =" + inMemOplogSize,
    // this.expectedOplogSize == inMemOplogSize);
    // closeDown();

    // }

    static int evaluateSizeOfOperationForPersist(Object key, byte[] val, DiskId id, int OperationType) {
        int size = 1;
        long opKey = id.getKeyId();
        switch (OperationType) {
        case OP_CREATE:
            size += 4 + EntryEventImpl.serialize(key).length + 1 + 4 + val.length;
            break;

        case OP_MODIFY:
            // @todo how do a know if the key needed to be serialized?
            size += 1 + 4 + val.length + Oplog.bytesNeeded(Oplog.abs(opKey));
            break;
        case OP_DEL:
            size += Oplog.bytesNeeded(Oplog.abs(opKey));
            break;
        }
        return size;

    }

    // give the new oplog record format it is too hard for the test to calculate
    // the expected size
    // /**
    // * Tests whether the switching of Oplog happens correctly without size
    // * violation in case of concurrent region operations for synch mode.
    // */
    // @Test
    // public void testSwitchingForConcurrentSynchedOperations()
    // {
    // final Map map = new HashMap();
    // final int MAX_OPLOG_SIZE = 500;
    // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(false);
    // diskProps.setSynchronous(true);
    // diskProps.setOverflow(false);
    // final int THREAD_COUNT = 5;
    // final byte[] val = new byte[50];
    // final byte[] uval = new byte[1];
    // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps);
    // for (int i = 1; i < 101; ++i) {
    // map.put(new Integer(i), new Integer(i));
    // }
    // final AI uniqueCtr = CFactory.createAI();
    // Thread[] threads = new Thread[THREAD_COUNT];
    // for (int i = 0; i < THREAD_COUNT; ++i) {
    // threads[i] = new Thread(new Runnable() {
    // public void run()
    // {
    // int sizeOfOp = 0;
    // DiskId id = null;
    // for (int j = 0; j < 50; ++j) {
    // int keyNum = random.nextInt(10) + 1;
    // Integer key = new Integer(keyNum);
    // Integer intgr = (Integer)map.get(key);
    // try {
    // String uniqueKey = "UK" + uniqueCtr.incrementAndGet();
    // // since the files for "empty" oplogs now get cleaned up early
    // // create a unique key to keep this oplog alive.
    // region.create(uniqueKey, uval);
    // DiskEntry uentry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(uniqueKey));
    // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(uniqueKey, uval,
    // uentry.getDiskId(), OP_CREATE);
    // synchronized (OplogJUnitTest.this) {
    // OplogJUnitTest.this.expectedOplogSize += sizeOfOp;
    // ++OplogJUnitTest.this.totalSuccessfulOperations;
    // ++OplogJUnitTest.this.numCreate;
    // }

    // synchronized (intgr) {

    // region.create(key, val);
    // DiskEntry entry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(key));
    // id = entry.getDiskId();

    // }
    // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(key,
    // val, id, OP_CREATE);

    // synchronized (OplogJUnitTest.this) {
    // OplogJUnitTest.this.expectedOplogSize += sizeOfOp;
    // ++OplogJUnitTest.this.totalSuccessfulOperations;
    // ++OplogJUnitTest.this.numCreate;
    // }
    // }
    // catch (EntryExistsException eee) {
    // if (logWriter.finerEnabled()) {
    // logWriter
    // .finer("The entry already exists so this operation will not increase the size of oplog");
    // }
    // }
    // try {
    // boolean isUpdate = false;
    // synchronized (intgr) {
    // isUpdate = region.containsKey(key) && region.get(key) != null
    // && region.get(key) != Token.DESTROYED;
    // region.put(key, val);
    // DiskEntry entry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(key));
    // id = entry.getDiskId();
    // }
    // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(key,
    // val, id, (isUpdate ? OP_MODIFY : OP_CREATE));
    // synchronized (OplogJUnitTest.this) {
    // OplogJUnitTest.this.expectedOplogSize += sizeOfOp;
    // ++OplogJUnitTest.this.totalSuccessfulOperations;
    // if (!isUpdate) {
    // ++OplogJUnitTest.this.numCreate;
    // }
    // else {
    // ++OplogJUnitTest.this.numModify;
    // }
    // }
    // }
    // catch (EntryDestroyedException ede) {
    // if (logWriter.finerEnabled()) {
    // logWriter
    // .finer("The entry already exists so this operation will not increase the size of oplog");
    // }
    // }

    // boolean deleted = false;
    // synchronized (intgr) {

    // if (region.containsKey(key) && region.get(key) != null
    // && region.get(key) != Token.DESTROYED) {
    // DiskEntry entry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(key));
    // id = entry.getDiskId();
    // region.remove(key);
    // deleted = true;
    // }

    // }
    // if (deleted) {
    // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(key,
    // null, id, OP_DEL);
    // synchronized (OplogJUnitTest.this) {
    // OplogJUnitTest.this.expectedOplogSize += sizeOfOp;
    // ++OplogJUnitTest.this.totalSuccessfulOperations;
    // ++OplogJUnitTest.this.numDel;

    // }
    // }

    // }

    // }

    // });
    // threads[i].start();
    // }

    // for (int i = 0; i < THREAD_COUNT; ++i) {
    // DistributedTestCase.join(threads[i], 30 * 1000, null);
    // }

    // long currentOplogID = ((LocalRegion)region).getDiskRegion().getChild()
    // .getOplogId();
    // assertTrue(
    // " Switching did not happen, increase the iterations to insert more data ",
    // currentOplogID > 1);
    // long inMemOplogSize = 0;

    // for (int j = 1; j <= currentOplogID; ++j) {

    // Oplog oplog = ((LocalRegion)region).getDiskRegion().getChild(j);
    // // if (j < currentOplogID) {
    // // // oplogs are now closed to save memory and file descriptors
    // // // once they are no longer needed
    // // assertIndexDetailsEquals(null, oplog);
    // // } else {
    // inMemOplogSize += oplog.getOplogSize();
    // logWriter.info(" Oplog size="+ oplog.getOplogSize() + " Max Oplog size
    // acceptable="+MAX_OPLOG_SIZE );
    // assertTrue(
    // " The max Oplog Size limit is violated when taken the inmemory oplog size",
    // oplog.getOplogSize() <= MAX_OPLOG_SIZE);

    // // File opFile = null;
    // try {
    // oplog.getOplogFile();
    // }
    // catch (Exception e) {
    // logWriter
    // .error(
    // "Exception in synching data present in the buffers of RandomAccessFile of Oplog, to the disk",
    // e);
    // fail("Test failed because synching of data present in buffer of RandomAccesFile ");
    // }

    // assertTrue(
    // " The max Oplog Size limit is violated when taken the actual file size",
    // oplog.getActualFileLength() <= MAX_OPLOG_SIZE);
    // assertIndexDetailsEquals(oplog.getOplogSize(), oplog.getActualFileLength());
    // // }
    // }

    // inMemOplogSize +=
    // ((LocalRegion)region).getDiskRegion().getDiskStore().undeletedOplogSize.get();

    // assertTrue(" The sum of all oplogs size as expected ="
    // + this.expectedOplogSize + " Actual sizes of all oplogs ="
    // + inMemOplogSize, this.expectedOplogSize == inMemOplogSize);

    // assertIndexDetailsEquals((this.numCreate + this.numDel + this.numModify),
    // this.totalSuccessfulOperations);
    // closeDown();

    // }

    // give the new oplog record format it is too hard for the test to calculate
    // the expected size
    // /**
    // * Tests whether the switching of Oplog happens correctly without size
    // * violation in case of concurrent region operations for asynch mode.
    // *
    // */
    // @Test
    // public void testSwitchingForConcurrentASynchedOperations()
    // {
    // final int MAX_OPLOG_SIZE = 500;
    // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(false);
    // diskProps.setSynchronous(false);
    // diskProps.setOverflow(false);
    // diskProps.setBytesThreshold(100);
    // final int THREAD_COUNT = 40;
    // final byte[] val = new byte[50];
    // region = DiskRegionHelperFactory
    // .getAsyncPersistOnlyRegion(cache, diskProps);

    // Thread[] threads = new Thread[THREAD_COUNT];
    // for (int i = 0; i < THREAD_COUNT; ++i) {
    // final int threadNum = (i + 1);
    // threads[i] = new Thread(new Runnable() {
    // public void run()
    // {
    // int sizeOfOp = 0;
    // DiskId id = null;
    // try {
    // region.create(new Integer(threadNum), val);
    // }

    // catch (EntryExistsException e) {
    // e.printStackTrace();
    // testFailed = true;
    // failureCause = "Entry existed with key =" + threadNum;
    // fail("Entry existed with key =" + threadNum);
    // }
    // DiskEntry entry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(new Integer(threadNum)));
    // id = entry.getDiskId();

    // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(
    // new Integer(threadNum), val, id, OP_CREATE);
    // synchronized (OplogJUnitTest.this) {
    // OplogJUnitTest.this.expectedOplogSize += sizeOfOp;
    // ++OplogJUnitTest.this.totalSuccessfulOperations;
    // ++OplogJUnitTest.this.numCreate;
    // }

    // }

    // });

    // threads[i].start();
    // }

    // for (int i = 0; i < THREAD_COUNT; ++i) {
    // DistributedTestCase.join(threads[i], 30 * 1000, null);
    // }

    // long currentOplogID = ((LocalRegion)region).getDiskRegion().getChild()
    // .getOplogId();
    // assertTrue(
    // " Switching did not happen, increase the iterations to insert more data ",
    // currentOplogID > 1);
    // if (debug)
    // System.out.print("Total number of oplogs created = " + currentOplogID);
    // long inMemOplogSize = 0;

    // for (int j = 1; j <= currentOplogID; ++j) {
    // Oplog oplog = ((LocalRegion)region).getDiskRegion().getChild(j);
    // // if (j < currentOplogID) {
    // // // oplogs are now closed to save memory and file descriptors
    // // // once they are no longer needed
    // // assertIndexDetailsEquals(null, oplog);
    // // } else {
    // inMemOplogSize += oplog.getOplogSize();
    // //oplog.forceFlush();
    // assertTrue(
    // " The max Oplog Size limit is violated when taken the inmemory oplog size",
    // oplog.getOplogSize() <= MAX_OPLOG_SIZE);
    // // File opFile = null;
    // try {
    // oplog.getOplogFile();
    // }
    // catch (Exception e) {
    // logWriter
    // .error(
    // "Exception in synching data present in the buffers of RandomAccessFile of Oplog, to the disk",
    // e);
    // fail("Test failed because synching of data present in buffer of RandomAccesFile ");
    // }
    // assertTrue(
    // " The max Oplog Size limit is violated when taken the actual file size",
    // oplog.getActualFileLength() <= MAX_OPLOG_SIZE);
    // assertIndexDetailsEquals(oplog.getOplogSize(), oplog.getActualFileLength());
    // // }
    // }

    // inMemOplogSize +=
    // ((LocalRegion)region).getDiskRegion().getDiskStore().undeletedOplogSize.get();

    // assertTrue(" The sum of all oplogs size as expected ="
    // + this.expectedOplogSize + " Actual sizes of all oplogs ="
    // + inMemOplogSize, this.expectedOplogSize == inMemOplogSize);
    // assertIndexDetailsEquals((this.numCreate + this.numDel + this.numModify),
    // this.totalSuccessfulOperations);
    // assertFalse(failureCause, testFailed);
    // closeDown();

    // }

    // /**
    // */
    // @Test
    // public void testAsyncWriterTerminationAfterSwitch()
    // {
    // final int MAX_OPLOG_SIZE = 500;
    // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(false);
    // diskProps.setSynchronous(false);
    // diskProps.setOverflow(false);
    // diskProps.setBytesThreshold(100);
    // final int THREAD_COUNT = 40;
    // final byte[] val = new byte[50];
    // region = DiskRegionHelperFactory
    // .getAsyncPersistOnlyRegion(cache, diskProps);

    // Thread[] threads = new Thread[THREAD_COUNT];
    // for (int i = 0; i < THREAD_COUNT; ++i) {
    // final int threadNum = (i + 1);
    // threads[i] = new Thread(new Runnable() {
    // public void run()
    // {
    // int sizeOfOp = 0;
    // DiskId id = null;
    // try {
    // region.create(new Integer(threadNum), val);
    // }

    // catch (EntryExistsException e) {
    // testFailed = true;
    // failureCause = "Entry existed with key =" + threadNum;
    // fail("Entry existed with key =" + threadNum);
    // }
    // DiskEntry entry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(new Integer(threadNum)));
    // id = entry.getDiskId();

    // sizeOfOp = OplogJUnitTest.evaluateSizeOfOperationForPersist(
    // new Integer(threadNum), val, id, OP_CREATE);
    // synchronized (OplogJUnitTest.this) {
    // OplogJUnitTest.this.expectedOplogSize += sizeOfOp;
    // ++OplogJUnitTest.this.totalSuccessfulOperations;
    // ++OplogJUnitTest.this.numCreate;
    // }

    // }

    // });

    // threads[i].start();
    // }

    // for (int i = 0; i < THREAD_COUNT; ++i) {
    // DistributedTestCase.join(threads[i], 30 * 1000, null);
    // }

    // long currentOplogID = ((LocalRegion)region).getDiskRegion().getChild()
    // .getOplogId();
    // assertTrue(
    // " Switching did not happen, increase the iterations to insert more data ",
    // currentOplogID > 1);

    // for (int j = 1; j < currentOplogID; ++j) {
    // Oplog oplog = ((LocalRegion)region).getDiskRegion().getChild(j);
    // // if (oplog != null) {
    // // DistributedTestCase.join(oplog.getAsynchWriter().getThread(), 10 * 1000, null);
    // // }
    // }
    // assertFalse(failureCause, testFailed);
    // closeDown();

    // }

    // /**
    // */
    // @Test
    // public void testMultipleByteBuffersASynchOperations()
    // {
    // final int MAX_OPLOG_SIZE = 100000;
    // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(false);
    // diskProps.setSynchronous(false);
    // diskProps.setOverflow(false);
    // diskProps.setBytesThreshold(1000);
    // Oplog.testSetMaxByteBufferSize(100);
    // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
    // final int OP_COUNT = 40;
    // final byte[] val = new byte[50];
    // region = DiskRegionHelperFactory
    // .getAsyncPersistOnlyRegion(cache, diskProps);
    // CacheObserver old = CacheObserverHolder
    // .setInstance(new CacheObserverAdapter() {
    // public void afterWritingBytes()
    // {

    // synchronized (OplogJUnitTest.this) {
    // flushOccuredAtleastOnce = true;
    // OplogJUnitTest.this.notify();
    // }

    // }
    // });

    // int sizeOfOp = 0;
    // DiskId id = null;
    // for (int i = 0; i < OP_COUNT; ++i) {
    // try {
    // region.create(new Integer(i), val);
    // DiskEntry entry = ((DiskEntry)((LocalRegion)region)
    // .basicGetEntry(new Integer(i)));
    // id = entry.getDiskId();
    // sizeOfOp += evaluateSizeOfOperationForPersist(new Integer(i), val, id,
    // OP_CREATE);

    // }

    // catch (EntryExistsException e) {
    // fail("Entry existed with key =" + i);
    // }
    // }
    // Oplog currOplog = ((LocalRegion)region).getDiskRegion().getChild();
    // long currentOplogID = currOplog.getOplogId();
    // long expectedSize = currOplog.getOplogSize();
    // // Ensure that now switching has happned during the operations
    // assertIndexDetailsEquals(1, currentOplogID);
    // assertTrue(
    // "The number of operations did not cause asynch writer to run atleast once , the expected file
    // size = "
    // + expectedSize, expectedSize > 1000);
    // if (!flushOccuredAtleastOnce) {
    // synchronized (this) {
    // if (!flushOccuredAtleastOnce) {
    // try {
    // this.wait(20000);
    // }
    // catch (InterruptedException e) {
    // fail("No guarantee as flushed occure deven once.Exception=" + e);
    // }
    // }
    // }
    // }
    // if (!flushOccuredAtleastOnce) {
    // fail("In the wait duration , flush did not occur even once. Try increasing the wait time");
    // }
    // long actualFileSize = 0L;

    // try {
    // actualFileSize = currOplog.getFileChannel().position();
    // }
    // catch (IOException e) {
    // fail(e.toString());
    // }

    // assertTrue(
    // "The number of operations did not cause asynch writer to run atleast once as the actual file
    // size = "
    // + actualFileSize, actualFileSize >= 1000);
    // //currOplog.forceFlush();
    // // File opFile = null;
    // try {
    // currOplog.getOplogFile();
    // }
    // catch (Exception e) {
    // logWriter
    // .error(
    // "Exception in synching data present in the buffers of RandomAccessFile of Oplog, to the disk",
    // e);
    // fail("Test failed because synching of data present in buffer of RandomAccesFile ");
    // }
    // actualFileSize = currOplog.getActualFileLength();
    // assertTrue(
    // " The expected Oplog Size not equal to the actual file size. Expected size="
    // + expectedSize + " actual size = " + actualFileSize,
    // expectedSize == actualFileSize);
    // Oplog.testSetMaxByteBufferSize(Integer.MAX_VALUE);
    // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
    // CacheObserverHolder.setInstance(old);
    // closeDown();

    // }

    /**
     * Tests the bug which arises in case of asynch mode during oplog switching caused by conflation
     * of create/destroy operation.The bug occurs if a create operation is followed by destroy but
     * before destroy proceeds some other operation causes oplog switching
     *
     */
    @Test
    public void testBug34615() {
        final int MAX_OPLOG_SIZE = 100;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setSynchronous(false);
        diskProps.setOverflow(false);
        diskProps.setBytesThreshold(150);

        LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
        final byte[] val = new byte[50];
        region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps);
        final CacheObserver old = CacheObserverHolder.setInstance(new CacheObserverAdapter() {
            @Override
            public void afterConflation(ByteBuffer orig, ByteBuffer conflated) {
                Thread th = new Thread(new Runnable() {
                    public void run() {
                        region.put("2", new byte[75]);
                    }
                });
                assertNull(conflated);
                th.start();
                ThreadUtils.join(th, 30 * 1000);
                LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;

            }
        });

        region.put("1", val);
        region.remove("1");
        assertFalse(failureCause, testFailed);
        CacheObserverHolder.setInstance(old);
        closeDown();

    }

    /**
     */
    @Test
    public void testConflation() throws Exception {

        final int MAX_OPLOG_SIZE = 1000;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setSynchronous(false);
        diskProps.setOverflow(false);
        diskProps.setBytesThreshold(1500);

        final byte[] val = new byte[50];
        final byte[][] bb = new byte[2][];
        bb[0] = new byte[5];
        region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps);
        try {
            region.put("1", val);
            region.put("1", new byte[10]);
            region.put("2", val);
            region.put("2", new byte[100]);
            region.create("3", null);
            region.put("3", new byte[10]);
            region.create("4", null);
            region.put("4", new byte[0]);

            // tests for byte[][]
            region.create("5", bb);
            region.put("6", val);
            region.put("6", bb);
            region.create("7", null);
            region.put("7", bb);

            region.create("8", new byte[9]);
            region.invalidate("8");
            region.create("9", new byte[0]);
            region.invalidate("9");

            region.create("10", new byte[9]);
            region.localInvalidate("10");
            region.create("11", new byte[0]);
            region.localInvalidate("11");

            DiskRegion dr = ((LocalRegion) region).getDiskRegion();
            dr.flushForTesting();
            byte[] val_1 = ((byte[]) ((LocalRegion) region).getValueOnDisk("1"));
            assertEquals(val_1.length, 10);
            byte[] val_2 = ((byte[]) ((LocalRegion) region).getValueOnDisk("2"));
            assertEquals(val_2.length, 100);
            byte[] val_3 = ((byte[]) ((LocalRegion) region).getValueOnDisk("3"));
            assertEquals(val_3.length, 10);
            byte[] val_4 = ((byte[]) ((LocalRegion) region).getValueOnDisk("4"));
            assertEquals(val_4.length, 0);
            byte[][] val_5 = (byte[][]) ((LocalRegion) region).getValueOnDisk("5");
            assertEquals(val_5.length, 2);
            assertEquals(val_5[0].length, 5);
            assertNull(val_5[1]);
            byte[][] val_6 = (byte[][]) ((LocalRegion) region).getValueOnDisk("6");
            assertEquals(val_6.length, 2);
            assertEquals(val_6[0].length, 5);
            assertNull(val_6[1]);
            byte[][] val_7 = (byte[][]) ((LocalRegion) region).getValueOnDisk("7");
            assertEquals(val_7.length, 2);
            assertEquals(val_7[0].length, 5);
            assertNull(val_7[1]);
            Object val_8 = ((LocalRegion) region).getValueOnDisk("8");
            assertEquals(val_8, Token.INVALID);
            Object val_9 = ((LocalRegion) region).getValueOnDisk("9");
            assertEquals(val_9, Token.INVALID);
            Object val_10 = ((LocalRegion) region).getValueOnDisk("10");
            assertEquals(val_10, Token.LOCAL_INVALID);
            Object val_11 = ((LocalRegion) region).getValueOnDisk("11");
            assertEquals(val_11, Token.LOCAL_INVALID);

        } catch (Exception e) {
            logWriter.error("Exception occured", e);
            // fail("The test failed due to exception = " + e);
            throw e;
        } finally {
            closeDown();
        }
    }

    /**
     * This tests the retrieval of empty byte array when present in asynch buffers
     *
     */
    @Test
    public void testGetEmptyByteArrayInAsynchBuffer() {
        final int MAX_OPLOG_SIZE = 1000;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setSynchronous(false);
        diskProps.setOverflow(false);
        diskProps.setBytesThreshold(1500);

        final byte[] val = new byte[50];
        region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps);
        try {
            region.put("1", val);
            region.put("1", new byte[0]);
            byte[] val_1 = ((byte[]) ((LocalRegion) region).getValueOnDiskOrBuffer("1"));
            assertEquals(val_1.length, 0);
        } catch (Exception e) {
            logWriter.error("Exception occured", e);
            fail("The test failed due to exception = " + e);
        }
        closeDown();
    }

    /**
     * This tests the retrieval of empty byte array in synch mode
     *
     */
    @Test
    public void testGetEmptyByteArrayInSynchMode() {
        final int MAX_OPLOG_SIZE = 1000;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setSynchronous(true);
        diskProps.setOverflow(false);
        diskProps.setBytesThreshold(1500);

        final byte[] val = new byte[50];
        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        try {
            region.put("1", val);
            region.put("1", new byte[0]);
            byte[] val_1 = ((byte[]) ((LocalRegion) region).getValueOnDiskOrBuffer("1"));
            assertEquals(val_1.length, 0);
        } catch (Exception e) {
            logWriter.error("Exception occured", e);
            fail("The test failed due to exception = " + e);
        }
        closeDown();
    }

    /**
     * This tests the bug which caused the oplogRoller to attempt to roll a removed entry whose value
     * is Token.Removed This bug can occur if a remove operation causes oplog switching & hence roller
     * thread gets notified, & the roller thread obtains the iterator of the concurrent region map
     * before the remove
     *
     */
    @Test
    public void testBug34702() {
        final int MAX_OPLOG_SIZE = 500 * 2;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(true);
        diskProps.setSynchronous(true);
        diskProps.setOverflow(false);
        final byte[] val = new byte[200];
        proceed = false;

        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        region.put("key1", val);
        region.put("key2", val);
        LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
        final CacheObserver old = CacheObserverHolder.setInstance(new CacheObserverAdapter() {

            @Override
            public void afterSettingOplogOffSet(long offset) {
                ((LocalRegion) region).getDiskRegion().forceRolling();
                // Let the operation thread yield to the Roller so that
                // it is able to obtain the iterator of the concurrrent region map
                // & thus get the reference to the entry which will contain
                // value as Token.Removed as the entry though removed from
                // concurrent
                // map still will be available to the roller
                Thread.yield();
                // Sleep for some time
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    testFailed = true;
                    failureCause = "No guarantee that test is succesful";
                    fail("No guarantee that test is succesful");
                }
            }

            @Override
            public void afterHavingCompacted() {
                proceed = true;
                synchronized (OplogJUnitTest.this) {
                    OplogJUnitTest.this.notify();
                }
            }
        });
        try {
            region.destroy("key1");
            region.destroy("key2");
        } catch (Exception e1) {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
            CacheObserverHolder.setInstance(old);
            fail("Test failed as entry deletion threw exception. Exception = " + e1);
        }
        // Wait for some time & check if the after having rolled callabck
        // is issued sucessfully or not.
        if (!proceed) {
            synchronized (this) {
                if (!proceed) {
                    try {
                        this.wait(20000);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        // The test will automatically fail due to proceed flag
                    }
                }
            }
        }
        assertFalse(failureCause, testFailed);
        LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
        CacheObserverHolder.setInstance(old);

        if (!proceed) {
            fail("Test failed as afterHavingCompacted callabck not issued even after sufficient wait");
        }
        closeDown();

    }

    /**
     * tests a potential deadlock situation if the operation causing a swithcing of Oplog is waiting
     * for roller to free space. The problem can arise if the operation causing Oplog switching is
     * going on an Entry , which already has its oplog ID referring to the Oplog being switched. In
     * such case, when the roller will try to roll the entries referencing the current oplog , it will
     * not be able to acquire the lock on the entry as the switching thread has already taken a lock
     * on it.
     *
     */
    @Test
    public void testRollingDeadlockSituation() {
        final int MAX_OPLOG_SIZE = 2000;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(true);
        diskProps.setSynchronous(true);
        diskProps.setOverflow(false);
        diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 1400 });
        final byte[] val = new byte[500];
        proceed = false;
        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        region.put("key1", val);
        region.put("key1", val);
        try {
            region.put("key1", val);
        } catch (DiskAccessException dae) {
            logWriter.error("Exception occured", dae);
            fail("Test failed as DiskAccessException was encountered where as the operation should ideally have proceeded without issue . exception = "
                    + dae);
        }
    }

    /**
     * This tests whether an empty byte array is correctly writtem to the disk as a zero value length
     * operation & hence the 4 bytes field for recording the value length is absent & also since the
     * value length is zero no byte for it should also get added. Similary during recover from HTree
     * as well as Oplog , the empty byte array should be read correctly
     *
     */
    @Test
    public void testEmptyByteArrayPutAndRecovery() {
        CacheObserver old = CacheObserverHolder.setInstance(new CacheObserverAdapter() {
            @Override
            public void afterConflation(ByteBuffer origBB, ByteBuffer conflatedBB) {
                if ((2 + 4 + 1 + EntryEventImpl.serialize("key1").length) != origBB.capacity()) {
                    failureCause = "For a backup region, addition of an empty array should result in an offset of 6 bytes where as actual offset is ="
                            + origBB.capacity();
                    testFailed = true;
                }
                Assert.assertTrue(
                        "For a backup region, addition of an empty array should result in an offset of 6 bytes where as actual offset is ="
                                + origBB.capacity(),
                        (2 + 4 + 1 + EntryEventImpl.serialize("key1").length) == origBB.capacity());

            }
        });
        try {
            final int MAX_OPLOG_SIZE = 2000;
            diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
            diskProps.setPersistBackup(true);
            // diskProps.setRolling(true);
            diskProps.setSynchronous(true);
            diskProps.setOverflow(false);
            diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 1400 });
            final byte[] val = new byte[0];
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;

            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            region.put("key1", val);
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
            region.close();
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            byte[] _val = (byte[]) region.get("key1");
            assertTrue(
                    "value of key1 after restarting the region is not an empty byte array. This may indicate problem in reading from Oplog",
                    _val.length == 0);
            if (this.logWriter.infoEnabled()) {
                this.logWriter.info(
                        "After first region close & opening again no problems encountered & hence Oplog has been read successfully.");
                this.logWriter.info(
                        "Closing the region again without any operation done, would indicate that next time data will be loaded from HTree .");
            }
            region.close();
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            _val = (byte[]) region.get("key1");
            assertTrue(
                    "value of key1 after restarting the region is not an empty byte array. This may indicate problem in reading from HTRee",
                    _val.length == 0);
            assertFalse(failureCause, testFailed);
            // region.close();

        } finally {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
            CacheObserverHolder.setInstance(old);

        }
    }

    /**
     * This is used to test bug 35012 where a remove operation on a key gets unrecorded due to
     * switching of Oplog if it happens just after the remove operation has destroyed the in memory
     * entry & is about to acquire the readlock in DiskRegion to record the same. If the Oplog has
     * switched during that duration , the bug would appear
     *
     */

    @Test
    public void testBug35012() {
        final int MAX_OPLOG_SIZE = 500;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setSynchronous(true);
        diskProps.setOverflow(false);
        final byte[] val = new byte[200];
        try {

            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);

            region.put("key1", val);
            region.put("key2", val);
            region.put("key3", val);
            final Thread th = new Thread(new Runnable() {
                public void run() {
                    region.remove("key1");
                }
            });
            // main thread acquires the write lock
            ((LocalRegion) region).getDiskRegion().acquireWriteLock();
            try {
                th.start();
                Thread.yield();
                DiskRegion dr = ((LocalRegion) region).getDiskRegion();
                dr.testHook_getChild().forceRolling(dr);
            } finally {
                ((LocalRegion) region).getDiskRegion().releaseWriteLock();
            }
            ThreadUtils.join(th, 30 * 1000);
            region.close();
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            assertEquals(region.size(), 2);
        } catch (Exception e) {
            this.logWriter.error("Exception occurred ", e);
            fail("The test could not be completed because of exception .Exception=" + e);
        }
        closeDown();

    }

    /**
     * Tests the various configurable parameters used by the ByteBufferPool . The behaviour of
     * parameters is based on the mode of DiskRegion ( synch or asynch) . Pls refer to the class
     * documentation ( Oplog.ByteBufferPool) for the exact behaviour of the class
     *
     */
    // @Test
    // public void testByteBufferPoolParameters()
    // {
    // // If the mode is asynch , the ByteBuffer obtained should e non direct else
    // // direct
    // final int MAX_OPLOG_SIZE = 500;
    // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(false);
    // diskProps.setSynchronous(true);
    // diskProps.setOverflow(false);
    // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps);
    // List bbPools = ((LocalRegion)region).getDiskRegion().getChild()
    // .getByteBufferPoolList();
    // ByteBuffer bb = ((Oplog.ByteBufferPool)bbPools.get(1)).getBufferFromPool();
    // assertTrue(" ByteBuffer is not of type direct", bb.isDirect());
    // region.destroyRegion();
    // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(false);
    // diskProps.setSynchronous(false);
    // diskProps.setOverflow(false);
    // region = DiskRegionHelperFactory
    // .getAsyncPersistOnlyRegion(cache, diskProps);
    // bbPools = ((LocalRegion)region).getDiskRegion().getChild()
    // .getByteBufferPoolList();
    // bb = ((Oplog.ByteBufferPool)bbPools.get(1)).getBufferFromPool();
    // assertTrue(" ByteBuffer is not of type direct", bb.isDirect());
    // region.close();
    // // Test max pool limit & wait time ( valid only in synch mode).
    // diskProps.setSynchronous(true);
    // diskProps.setRegionName("testRegion");
    // System.setProperty("/testRegion_MAX_POOL_SIZE", "1");

    // System.setProperty("/testRegion_WAIT_TIME", "4000");
    // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps);
    // bbPools = ((LocalRegion)region).getDiskRegion().getChild()
    // .getByteBufferPoolList();
    // bb = ((Oplog.ByteBufferPool)bbPools.get(1)).getBufferFromPool();
    // assertTrue("Since the Pool has one Entry , it should be direct", bb
    // .isDirect());

    // long t1 = System.currentTimeMillis();
    // bb = ((Oplog.ByteBufferPool)bbPools.get(1)).getBufferFromPool();
    // long t2 = System.currentTimeMillis();
    // assertTrue(
    // "Since the Pool should have been exhausted hence non direct byte buffer should have been
    // returned",
    // !bb.isDirect());
    // assertTrue("The wait time for ByteBuffer pool was not respected ",
    // (t2 - t1) > 3000);
    // region.close();
    // // // In case of asynch mode , the upper limit should not have been imposed
    // // System.setProperty("/testRegion_MAX_POOL_SIZE", "1");
    // // System.setProperty("/testRegion_WAIT_TIME", "5000");
    // // diskProps.setSynchronous(false);
    // // diskProps.setRegionName("testRegion");
    // // region = DiskRegionHelperFactory
    // // .getAsyncPersistOnlyRegion(cache, diskProps);
    // // bbPools = ((LocalRegion)region).getDiskRegion().getChild()
    // // .getByteBufferPoolList();
    // // bb = ((Oplog.ByteBufferPool)bbPools.get(1)).getBufferFromPool();
    // // t1 = System.currentTimeMillis();
    // // bb = ((Oplog.ByteBufferPool)bbPools.get(1)).getBufferFromPool();
    // // t2 = System.currentTimeMillis();
    // // assertTrue(
    // // "There should not have been any wait time " + (t2-t1) + " for ByteBuffer pool ",
    // // (t2 - t1) / 1000 < 3);
    // // region.close();
    // System.setProperty("/testRegion_MAX_POOL_SIZE", "2");
    // System.setProperty("/testRegion_WAIT_TIME", "5000");
    // diskProps.setSynchronous(true);
    // diskProps.setRegionName("testRegion");
    // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps);
    // bbPools = ((LocalRegion)region).getDiskRegion().getChild()
    // .getByteBufferPoolList();
    // Oplog.ByteBufferPool pool = (Oplog.ByteBufferPool)bbPools.get(1);
    // ByteBuffer bb1 = pool.getBufferFromPool();
    // ByteBuffer bb2 = pool.getBufferFromPool();
    // assertIndexDetailsEquals(2, pool.getTotalBuffers());
    // assertIndexDetailsEquals(2, pool.getBuffersInUse());
    // ((LocalRegion)region).getDiskRegion().getChild().releaseBuffer(bb1);
    // ((LocalRegion)region).getDiskRegion().getChild().releaseBuffer(bb2);
    // assertIndexDetailsEquals(0, pool.getBuffersInUse());
    // region.close();

    // System.setProperty("/testRegion_MAX_POOL_SIZE", "1");
    // System.setProperty("/testRegion_WAIT_TIME", "1000");
    // diskProps.setSynchronous(true);
    // diskProps.setRegionName("testRegion");
    // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps);
    // bbPools = ((LocalRegion)region).getDiskRegion().getChild()
    // .getByteBufferPoolList();
    // pool = (Oplog.ByteBufferPool)bbPools.get(1);
    // bb1 = pool.getBufferFromPool();
    // bb2 = pool.getBufferFromPool();
    // assertIndexDetailsEquals(1, pool.getTotalBuffers());
    // assertIndexDetailsEquals(1, pool.getBuffersInUse());
    // ((LocalRegion)region).getDiskRegion().getChild().releaseBuffer(bb1);
    // ((LocalRegion)region).getDiskRegion().getChild().releaseBuffer(bb2);
    // assertIndexDetailsEquals(0, pool.getBuffersInUse());
    // closeDown();

    // }

    /**
     * Tests the ByteBuffer Pool operations for release of ByteBuffers in case the objects being put
     * vary in size & hence use ByteBuffer Pools present at different indexes
     *
     */
    // @Test
    // public void testByteBufferPoolReleaseBugTest()
    // {

    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(false);
    // diskProps.setSynchronous(true);
    // diskProps.setOverflow(false);
    // System.setProperty("/testRegion_UNIT_BUFF_SIZE", "100");
    // System.setProperty("/testRegion_UNIT_BUFF_SIZE", "100");
    // System.setProperty("gemfire.log-level", getGemFireLogLevel());
    // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps);
    // region.put("key1", new byte[900]);
    // region.put("key1", new byte[700]);
    // closeDown();

    // }

    /**
     * Tests if buffer size & time are not set , the asynch writer gets awakened on time basis of
     * default 1 second
     *
     */
    @Test
    public void testAsynchWriterAttribBehaviour1() {
        DiskStoreFactory dsf = cache.createDiskStoreFactory();
        ((DiskStoreFactoryImpl) dsf).setMaxOplogSizeInBytes(10000);
        File dir = new File("testingDirectoryDefault");
        dir.mkdir();
        dir.deleteOnExit();
        File[] dirs = { dir };
        dsf.setDiskDirs(dirs);
        AttributesFactory factory = new AttributesFactory();
        final long t1 = System.currentTimeMillis();
        DiskStore ds = dsf.create("test");
        factory.setDiskSynchronous(false);
        factory.setDiskStoreName(ds.getName());
        factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
        factory.setScope(Scope.LOCAL);
        try {
            region = cache.createVMRegion("test", factory.createRegionAttributes());
        } catch (Exception e1) {
            logWriter.error("Test failed due to exception", e1);
            fail("Test failed due to exception " + e1);

        }

        LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
        CacheObserver old = CacheObserverHolder.setInstance(

                new CacheObserverAdapter() {
                    private long t2;

                    @Override
                    public void goingToFlush() {
                        t2 = System.currentTimeMillis();
                        delta = t2 - t1;
                        LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
                        synchronized (OplogJUnitTest.this) {
                            OplogJUnitTest.this.notify();
                        }
                    }
                });

        region.put("key1", "111111111111");
        synchronized (this) {
            if (LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER) {
                try {
                    this.wait(10000);
                } catch (InterruptedException e) {
                    logWriter.error("Test failed due to exception", e);
                    fail("Test failed due to exception " + e);

                }
                assertFalse(LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER);
            }
        }
        CacheObserverHolder.setInstance(old);
        // Windows clock has an accuracy of 15 ms. Accounting for the same.
        assertTrue("delta is in miilliseconds=" + delta, delta >= 985);
        closeDown();
    }

    /**
     * Tests if buffer size is set but time is not set , the asynch writer gets awakened on buffer
     * size basis
     */
    @Ignore("TODO:DARREL_DISABLE: test is disabled")
    @Test
    public void testAsynchWriterAttribBehaviour2() {
        DiskStoreFactory dsf = cache.createDiskStoreFactory();
        ((DiskStoreFactoryImpl) dsf).setMaxOplogSizeInBytes(10000);
        dsf.setQueueSize(2);
        File dir = new File("testingDirectoryDefault");
        dir.mkdir();
        dir.deleteOnExit();
        File[] dirs = { dir };
        dsf.setDiskDirs(dirs);
        AttributesFactory factory = new AttributesFactory();
        DiskStore ds = dsf.create("test");
        factory.setDiskSynchronous(false);
        factory.setDiskStoreName(ds.getName());
        factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
        factory.setScope(Scope.LOCAL);
        try {
            region = cache.createVMRegion("test", factory.createRegionAttributes());
        } catch (Exception e1) {
            logWriter.error("Test failed due to exception", e1);
            fail("Test failed due to exception " + e1);

        }

        LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
        CacheObserver old = CacheObserverHolder.setInstance(

                new CacheObserverAdapter() {

                    @Override
                    public void goingToFlush() {
                        synchronized (OplogJUnitTest.this) {
                            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
                            OplogJUnitTest.this.notify();
                        }
                    }
                });

        region.put("key1", new byte[25]);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            logWriter.error("Test failed due to exception", e);
            fail("Test failed due to exception " + e);
        }
        assertTrue(LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER);
        region.put("key2", new byte[25]);
        synchronized (this) {
            if (LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER) {
                try {
                    OplogJUnitTest.this.wait(10000);
                    assertFalse(LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER);
                } catch (InterruptedException e2) {
                    logWriter.error("Test failed due to exception", e2);
                    fail("Test failed due to exception " + e2);
                }
            }
        }
        CacheObserverHolder.setInstance(old);
        closeDown();
    }

    /**
     * Tests if buffer size & time interval are explicitly set to zero then the flush will occur due
     * to asynchForceFlush or due to switching of Oplog
     *
     */
    @Test
    public void testAsynchWriterAttribBehaviour3() {
        DiskStoreFactory dsf = cache.createDiskStoreFactory();
        ((DiskStoreFactoryImpl) dsf).setMaxOplogSizeInBytes(500);
        dsf.setQueueSize(0);
        dsf.setTimeInterval(0);
        File dir = new File("testingDirectoryDefault");
        dir.mkdir();
        dir.deleteOnExit();
        File[] dirs = { dir };
        dsf.setDiskDirs(dirs);
        AttributesFactory factory = new AttributesFactory();
        DiskStore ds = dsf.create("test");
        factory.setDiskSynchronous(false);
        factory.setDiskStoreName(ds.getName());
        factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
        factory.setScope(Scope.LOCAL);
        try {
            region = cache.createVMRegion("test", factory.createRegionAttributes());
        } catch (Exception e1) {
            logWriter.error("Test failed due to exception", e1);
            fail("Test failed due to exception " + e1);

        }

        LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
        CacheObserver old = CacheObserverHolder.setInstance(

                new CacheObserverAdapter() {

                    @Override
                    public void goingToFlush() {
                        LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
                        synchronized (OplogJUnitTest.this) {
                            OplogJUnitTest.this.notify();
                        }
                    }
                });
        try {
            region.put("key1", new byte[100]);
            region.put("key2", new byte[100]);
            region.put("key3", new byte[100]);
            region.put("key4", new byte[100]);
            region.put("key5", new byte[100]);
            Thread.sleep(1000);
            assertTrue(LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER);
        } catch (Exception e) {
            logWriter.error("Test failed due to exception", e);
            fail("Test failed due to exception " + e);
        }
        region.forceRolling();
        synchronized (this) {
            if (LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER) {
                try {
                    OplogJUnitTest.this.wait(10000);
                } catch (InterruptedException e2) {
                    logWriter.error("Test failed due to exception", e2);
                    fail("Test failed due to exception " + e2);
                }
            }
        }
        assertFalse(LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER);
        CacheObserverHolder.setInstance(old);
        closeDown();
    }

    /**
     * Tests if the preblowing of a file with size greater than the disk space available so that
     * preblowing results in IOException , is able to recover without problem
     *
     */
    // Now we preallocate spaces for if files and also crfs and drfs. So the below test is not valid
    // any more. See revision: r42359 and r42320. So disabling this test.
    @Ignore("TODO: test is disabled")
    @Test
    public void testPreblowErrorCondition() {
        DiskStoreFactory dsf = cache.createDiskStoreFactory();
        ((DiskStoreFactoryImpl) dsf).setMaxOplogSizeInBytes(100000000L * 1024L * 1024L * 1024L);
        dsf.setAutoCompact(false);
        File dir = new File("testingDirectoryDefault");
        dir.mkdir();
        dir.deleteOnExit();
        File[] dirs = { dir };
        int size[] = new int[] { Integer.MAX_VALUE };
        dsf.setDiskDirsAndSizes(dirs, size);
        AttributesFactory factory = new AttributesFactory();
        logWriter.info("<ExpectedException action=add>" + "Could not pregrow" + "</ExpectedException>");
        try {
            DiskStore ds = dsf.create("test");
            factory.setDiskStoreName(ds.getName());
            factory.setDiskSynchronous(true);
            factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
            factory.setScope(Scope.LOCAL);
            try {
                region = cache.createVMRegion("test", factory.createRegionAttributes());
            } catch (Exception e1) {
                logWriter.error("Test failed due to exception", e1);
                fail("Test failed due to exception " + e1);

            }
            region.put("key1", new byte[900]);
            byte[] val = null;
            try {
                val = (byte[]) ((LocalRegion) region).getValueOnDisk("key1");
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                fail(e.toString());
            }
            assertTrue(val.length == 900);
        } finally {
            logWriter.info("<ExpectedException action=remove>" + "Could not pregrow" + "</ExpectedException>");
        }
        closeDown();
    }

    /**
     * Tests if the byte buffer pool in asynch mode tries to contain the pool size
     *
     */
    @Test
    public void testByteBufferPoolContainment() {

        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setMaxOplogSize(1024 * 1024);
        diskProps.setSynchronous(false);
        diskProps.setOverflow(false);
        diskProps.setBytesThreshold(10); // this is now item count
        diskProps.setTimeInterval(0);
        region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps);
        final byte[] val = new byte[1000];
        LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;

        CacheObserverHolder.setInstance(new CacheObserverAdapter() {

            @Override
            public void goingToFlush() { // Delay flushing

                assertEquals(10, region.size());
                for (int i = 10; i < 20; ++i) {
                    region.put("" + i, val);
                }
                synchronized (OplogJUnitTest.this) {
                    OplogJUnitTest.this.notify();
                    LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
                }

            }
        });
        for (int i = 0; i < 10; ++i) {
            region.put("" + i, val);
        }
        try {
            synchronized (OplogJUnitTest.this) {
                if (LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER) {
                    OplogJUnitTest.this.wait(9000);
                    assertEquals(false, LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER);
                }
            }

        } catch (InterruptedException ie) {
            fail("interrupted");
        }
        // ((LocalRegion)region).getDiskRegion().getChild().forceFlush();
        // int x = ((LocalRegion)region).getDiskRegion().getChild().getAsynchWriter()
        // .getApproxFreeBuffers();
        // assertIndexDetailsEquals(10, x);
    }

    // we no longer have a pendingFlushMap
    // /**
    // * This test does the following: <br>
    // * 1)Create a diskRegion with async mode and byte-threshold as 25 bytes. <br>
    // * 2)Put an entry into the region such that the async-buffer is just over 25
    // * bytes and the writer-thread is invoked. <br>
    // * 3)Using CacheObserver.afterSwitchingWriteAndFlushMaps callback, perform a
    // * put on the same key just after the async writer thread swaps the
    // * pendingFlushMap and pendingWriteMap for flushing. <br>
    // * 4)Using CacheObserver.afterWritingBytes, read the value for key
    // * (LocalRegion.getValueOnDiskOrBuffer) just after the async writer thread has
    // * flushed to the disk. <br>
    // * 5) Verify that the value read in step3 is same as the latest value. This
    // * will ensure that the flushBufferToggle flag is functioning as expected ( It
    // * prevents the writer thread from setting the oplog-offset in diskId if that
    // * particular entry has been updated by a put-thread while the
    // * async-writer-thread is flushing that entry.)
    // *
    // * @throws Exception
    // */
    // @Test
    // public void testFlushBufferToggleFlag() throws Exception
    // {
    // final int MAX_OPLOG_SIZE = 100000;
    // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(false);
    // diskProps.setSynchronous(false);
    // diskProps.setOverflow(false);
    // diskProps.setBytesThreshold(25);
    // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;

    // region = DiskRegionHelperFactory
    // .getAsyncPersistOnlyRegion(cache, diskProps);
    // CacheObserver old = CacheObserverHolder
    // .setInstance(new CacheObserverAdapter() {
    // public void afterWritingBytes()
    // {
    // LocalRegion localregion = (LocalRegion)region;
    // try {
    // valueRead = (String)localregion.getValueOnDiskOrBuffer(KEY);
    // synchronized (OplogJUnitTest.class) {
    // proceedForValidation = true;
    // OplogJUnitTest.class.notify();
    // }
    // }
    // catch (EntryNotFoundException e) {
    // e.printStackTrace();
    // }
    // }

    // public void afterSwitchingWriteAndFlushMaps()
    // {
    // region.put(KEY, NEW_VALUE);
    // }

    // });

    // region.put(KEY, OLD_VALUE);

    // if (!proceedForValidation) {
    // synchronized (OplogJUnitTest.class) {
    // if (!proceedForValidation) {
    // try {
    // OplogJUnitTest.class.wait(9000);
    // assertIndexDetailsEquals(true, proceedForValidation);
    // }
    // catch (InterruptedException e) {
    // fail("interrupted");
    // }
    // }
    // }
    // }

    // cache.getLogger().info("valueRead : " + valueRead);
    // assertIndexDetailsEquals("valueRead is stale, doesnt match with latest PUT", NEW_VALUE,
    // valueRead);
    // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
    // CacheObserverHolder.setInstance(old);
    // closeDown();
    // }

    /**
     * tests async stats are correctly updated
     */
    @Test
    public void testAsyncStats() throws InterruptedException {
        diskProps.setBytesThreshold(101);
        diskProps.setTimeInterval(1000000);
        region = DiskRegionHelperFactory.getAsyncOverFlowAndPersistRegion(cache, diskProps);
        final DiskStoreStats dss = ((LocalRegion) region).getDiskRegion().getDiskStore().getStats();

        assertEquals(0, dss.getQueueSize());
        put100Int();
        Awaitility.await().pollInterval(10, TimeUnit.MILLISECONDS).pollDelay(10, TimeUnit.MILLISECONDS)
                .timeout(10, TimeUnit.SECONDS).until(() -> assertEquals(100, dss.getQueueSize()));

        assertEquals(0, dss.getFlushes());
        region.writeToDisk();
        Awaitility.await().pollInterval(10, TimeUnit.MILLISECONDS).pollDelay(10, TimeUnit.MILLISECONDS)
                .timeout(10, TimeUnit.SECONDS).until(() -> assertEquals(0, dss.getQueueSize()));
        Awaitility.await().pollInterval(10, TimeUnit.MILLISECONDS).pollDelay(10, TimeUnit.MILLISECONDS)
                .timeout(10, TimeUnit.SECONDS).until(() -> assertEquals(100, dss.getFlushes()));
        put100Int();
        Awaitility.await().pollInterval(10, TimeUnit.MILLISECONDS).pollDelay(10, TimeUnit.MILLISECONDS)
                .timeout(10, TimeUnit.SECONDS).until(() -> assertEquals(100, dss.getQueueSize()));
        region.writeToDisk();
        Awaitility.await().pollInterval(10, TimeUnit.MILLISECONDS).pollDelay(10, TimeUnit.MILLISECONDS)
                .timeout(10, TimeUnit.SECONDS).until(() -> assertEquals(0, dss.getQueueSize()));
        Awaitility.await().pollInterval(10, TimeUnit.MILLISECONDS).pollDelay(10, TimeUnit.MILLISECONDS)
                .timeout(10, TimeUnit.SECONDS).until(() -> assertEquals(200, dss.getFlushes()));
        closeDown();
    }

    /**
     * Tests delayed creation of DiskID in overflow only mode
     *
     */
    @Test
    public void testDelayedDiskIdCreationInOverflowOnlyMode() {
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setMaxOplogSize(1024 * 1024);
        diskProps.setSynchronous(false);
        diskProps.setOverflow(true);
        diskProps.setBytesThreshold(10000);
        diskProps.setTimeInterval(0);
        diskProps.setOverFlowCapacity(1);
        region = DiskRegionHelperFactory.getAsyncOverFlowOnlyRegion(cache, diskProps);
        final byte[] val = new byte[1000];
        region.put("1", val);
        DiskEntry entry = (DiskEntry) ((LocalRegion) region).basicGetEntry("1");
        assertTrue(entry instanceof AbstractDiskLRURegionEntry);
        assertNull(entry.getDiskId());
        region.put("2", val);
        assertNotNull(entry.getDiskId());
        entry = (DiskEntry) ((LocalRegion) region).basicGetEntry("2");
        assertTrue(entry instanceof AbstractDiskLRURegionEntry);
        assertNull(entry.getDiskId());
    }

    /**
     * Tests immediate creation of DiskID in overflow With Persistence mode
     *
     */
    @Test
    public void testImmediateDiskIdCreationInOverflowWithPersistMode() {
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setMaxOplogSize(1024 * 1024);
        diskProps.setSynchronous(false);
        diskProps.setOverflow(true);
        diskProps.setBytesThreshold(10000);
        diskProps.setTimeInterval(0);
        diskProps.setOverFlowCapacity(1);
        region = DiskRegionHelperFactory.getAsyncOverFlowAndPersistRegion(cache, diskProps);
        final byte[] val = new byte[1000];
        region.put("1", val);
        DiskEntry entry = (DiskEntry) ((LocalRegion) region).basicGetEntry("1");
        assertTrue(entry instanceof AbstractDiskLRURegionEntry);
        assertNotNull(entry.getDiskId());
        region.put("2", val);
        assertNotNull(entry.getDiskId());
        entry = (DiskEntry) ((LocalRegion) region).basicGetEntry("2");
        assertTrue(entry instanceof AbstractDiskLRURegionEntry);
        assertNotNull(entry.getDiskId());
    }

    /**
     * An entry which is evicted to disk will have the flag already written to disk, appropriately set
     *
     */
    @Test
    public void testEntryAlreadyWrittenIsCorrectlyUnmarkedForOverflowOnly() throws Exception {
        try {
            diskProps.setPersistBackup(false);
            diskProps.setRolling(false);
            diskProps.setMaxOplogSize(1024 * 1024);
            diskProps.setSynchronous(true);
            diskProps.setOverflow(true);
            diskProps.setBytesThreshold(10000);
            diskProps.setTimeInterval(0);
            diskProps.setOverFlowCapacity(1);
            region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);
            final byte[] val = new byte[1000];
            region.put("1", val);
            region.put("2", val);
            // "1" should now be on disk
            region.get("1");
            // "2" should now be on disk
            DiskEntry entry1 = (DiskEntry) ((LocalRegion) region).basicGetEntry("1");
            DiskId did1 = entry1.getDiskId();
            DiskId.isInstanceofOverflowIntOplogOffsetDiskId(did1);
            assertTrue(!did1.needsToBeWritten());
            region.put("1", "3");
            assertTrue(did1.needsToBeWritten());
            region.put("2", val);
            DiskEntry entry2 = (DiskEntry) ((LocalRegion) region).basicGetEntry("2");
            DiskId did2 = entry2.getDiskId();
            assertTrue(!did2.needsToBeWritten() || !did1.needsToBeWritten());
            tearDown();
            setUp();
            diskProps.setPersistBackup(false);
            diskProps.setRolling(false);
            long opsize = Integer.MAX_VALUE;
            opsize += 100L;
            diskProps.setMaxOplogSize(opsize);
            diskProps.setSynchronous(true);
            diskProps.setOverflow(true);
            diskProps.setBytesThreshold(10000);
            diskProps.setTimeInterval(0);
            diskProps.setOverFlowCapacity(1);
            region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);
            region.put("1", val);
            region.put("2", val);
            region.get("1");
            entry1 = (DiskEntry) ((LocalRegion) region).basicGetEntry("1");
            did1 = entry1.getDiskId();
            DiskId.isInstanceofOverflowOnlyWithLongOffset(did1);
            assertTrue(!did1.needsToBeWritten());
            region.put("1", "3");
            assertTrue(did1.needsToBeWritten());
            region.put("2", "3");
            did2 = entry2.getDiskId();
            assertTrue(!did2.needsToBeWritten() || !did1.needsToBeWritten());
        } catch (Exception e) {
            e.printStackTrace();
            fail(e.toString());
        }
    }

    /**
     * An persistent or overflow with persistence entry which is evicted to disk, will have the flag
     * already written to disk, appropriately set
     *
     */
    @Test
    public void testEntryAlreadyWrittenIsCorrectlyUnmarkedForOverflowWithPersistence() {
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setMaxOplogSize(1024 * 1024);
        diskProps.setSynchronous(true);
        diskProps.setOverflow(true);
        diskProps.setBytesThreshold(10000);
        diskProps.setTimeInterval(0);
        diskProps.setOverFlowCapacity(1);
        region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps);
        final byte[] val = new byte[1000];
        region.put("1", val);
        DiskEntry entry1 = (DiskEntry) ((LocalRegion) region).basicGetEntry("1");
        DiskId did1 = entry1.getDiskId();
        DiskId.isInstanceofPersistIntOplogOffsetDiskId(did1);
        assertTrue(!did1.needsToBeWritten());
        region.put("2", val);
        assertTrue(!did1.needsToBeWritten());
    }

    /**
     * Tests the various DiskEntry.Helper APIs for correctness as there is now delayed creation of
     * DiskId and accessing OplogkeyId will throw UnsupportedException
     */
    @Test
    public void testHelperAPIsForOverflowOnlyRegion() {
        diskProps.setPersistBackup(false);
        diskProps.setRolling(false);
        diskProps.setMaxOplogSize(1024 * 1024);
        diskProps.setSynchronous(true);
        diskProps.setOverflow(true);
        diskProps.setBytesThreshold(10000);
        diskProps.setTimeInterval(0);
        diskProps.setOverFlowCapacity(2);
        region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);
        final byte[] val = new byte[1000];
        DiskRegion dr = ((LocalRegion) region).getDiskRegion();
        region.put("1", val);
        // region.get("1");
        region.put("2", val);
        // region.get("2");
        region.put("3", val);
        // region.get("3");
        DiskEntry entry1 = (DiskEntry) ((LocalRegion) region).basicGetEntry("1");
        // DiskId did1 = entry1.getDiskId();
        DiskEntry entry2 = (DiskEntry) ((LocalRegion) region).basicGetEntry("2");
        // DiskId did2 = entry2.getDiskId();
        DiskEntry entry3 = (DiskEntry) ((LocalRegion) region).basicGetEntry("3");
        // DiskId did3 = entry3.getDiskId();
        assertNull(entry2.getDiskId());
        assertNull(entry3.getDiskId());
        assertNotNull(entry1.getDiskId());
        assertNull(DiskEntry.Helper.getValueOnDisk(entry3, dr));
        assertNull(DiskEntry.Helper.getValueOnDisk(entry2, dr));
        assertNotNull(DiskEntry.Helper.getValueOnDisk(entry1, dr));
        assertNull(DiskEntry.Helper.getValueOnDisk(entry3, dr));
        assertNull(DiskEntry.Helper.getValueOnDisk(entry2, dr));

        assertNull(entry2.getDiskId());
        assertNull(entry3.getDiskId());
        assertNotNull(entry1.getDiskId());
        assertNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry3, dr, (LocalRegion) region));
        assertNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry2, dr, (LocalRegion) region));
        assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry1, dr, (LocalRegion) region));
        assertNull(DiskEntry.Helper.getValueOnDisk(entry3, dr));
        assertNull(DiskEntry.Helper.getValueOnDisk(entry2, dr));
    }

    /**
     * Tests the various DiskEntry.Helper APIs for correctness as there is now delayed creation of
     * DiskId and accessing OplogkeyId will throw UnsupportedException
     */
    @Test
    public void testHelperAPIsForOverflowWithPersistenceRegion() {
        helperAPIsForPersistenceWithOrWithoutOverflowRegion(true /* should overflow */);
    }

    /**
     * Tests the various DiskEntry.Helper APIs for correctness as there is now delayed creation of
     * DiskId and accessing OplogkeyId will throw UnsupportedException
     */
    @Test
    public void testHelperAPIsForPersistenceRegion() {
        helperAPIsForPersistenceWithOrWithoutOverflowRegion(false /* should overflow */);
    }

    /**
     * Tests the various DiskEntry.Helper APIs for correctness as there is now delayed creation of
     * DiskId and accessing OplogkeyId will throw UnsupportedException
     */
    private void helperAPIsForPersistenceWithOrWithoutOverflowRegion(boolean overflow) {
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setMaxOplogSize(1024 * 1024);
        diskProps.setSynchronous(true);
        diskProps.setOverflow(overflow);
        diskProps.setBytesThreshold(10000);
        diskProps.setTimeInterval(0);
        diskProps.setOverFlowCapacity(2);
        region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps);
        final byte[] val = new byte[1000];
        DiskRegion dr = ((LocalRegion) region).getDiskRegion();
        region.put("1", val);
        // region.get("1");
        region.put("2", val);
        // region.get("2");
        region.put("3", val);
        // region.get("3");
        DiskEntry entry1 = (DiskEntry) ((LocalRegion) region).basicGetEntry("1");
        // DiskId did1 = entry1.getDiskId();
        DiskEntry entry2 = (DiskEntry) ((LocalRegion) region).basicGetEntry("2");
        // DiskId did2 = entry2.getDiskId();
        DiskEntry entry3 = (DiskEntry) ((LocalRegion) region).basicGetEntry("3");
        // DiskId did3 = entry3.getDiskId();
        assertNotNull(entry2.getDiskId());
        assertNotNull(entry3.getDiskId());
        assertNotNull(entry1.getDiskId());
        assertNotNull(DiskEntry.Helper.getValueOnDisk(entry3, dr));
        assertNotNull(DiskEntry.Helper.getValueOnDisk(entry2, dr));
        assertNotNull(DiskEntry.Helper.getValueOnDisk(entry1, dr));

        assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry3, dr, (LocalRegion) region));
        assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry2, dr, (LocalRegion) region));
        assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry1, dr, (LocalRegion) region));

        region.close();
        region = DiskRegionHelperFactory.getSyncOverFlowAndPersistRegion(cache, diskProps);
        dr = ((LocalRegion) region).getDiskRegion();
        entry1 = (DiskEntry) ((LocalRegion) region).basicGetEntry("1");
        // did1 = entry1.getDiskId();
        entry2 = (DiskEntry) ((LocalRegion) region).basicGetEntry("2");
        // did2 = entry2.getDiskId();
        entry3 = (DiskEntry) ((LocalRegion) region).basicGetEntry("3");
        // did3 = entry3.getDiskId();

        assertNotNull(entry2.getDiskId());
        assertNotNull(entry3.getDiskId());
        assertNotNull(entry1.getDiskId());

        assertNotNull(DiskEntry.Helper.getValueOnDisk(entry3, dr));
        assertNotNull(DiskEntry.Helper.getValueOnDisk(entry2, dr));
        assertNotNull(DiskEntry.Helper.getValueOnDisk(entry1, dr));

        assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry3, dr, (LocalRegion) region));
        assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry2, dr, (LocalRegion) region));
        assertNotNull(DiskEntry.Helper.getValueOnDiskOrBuffer(entry1, dr, (LocalRegion) region));

    }

    // @todo this test is failing for some reason. Does it need to be fixed?
    /**
     * Bug test to reproduce the bug 37261. The scenario which this test depicts is not actually the
     * cause of Bug 37261. This test validates the case where a synch persist only entry1 is created
     * in Oplog1. A put operation on entry2 causes the switch , but before Oplog1 is rolled , the
     * entry1 is modified so that it references Oplog2. Thus in effect roller will skip rolling entry1
     * when rolling Oplog1.Now entry1 is deleted in Oplog2 and then a rolling happens. There should
     * not be any error
     */
    // @Test
    // public void testBug37261_1()
    // {
    // CacheObserver old = CacheObserverHolder.getInstance();
    // try {
    // // Create a persist only region with rolling true
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(true);
    // diskProps.setCompactionThreshold(100);
    // diskProps.setMaxOplogSize(1024);
    // diskProps.setSynchronous(true);
    // this.proceed = false;
    // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache,
    // diskProps);
    // // create an entry 1 in oplog1,
    // region.put("key1", new byte[800]);

    // // Asif the second put will cause a switch to oplog 2 & also cause the
    // // oplog1
    // // to be submitted to the roller
    // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
    // CacheObserverHolder.setInstance(new CacheObserverAdapter() {
    // public void beforeGoingToCompact()
    // {
    // // modify entry 1 so that it points to the new switched oplog
    // Thread th = new Thread(new Runnable() {
    // public void run()
    // {
    // region.put("key1", new byte[400]);
    // }
    // });
    // th.start();
    // try {
    // DistributedTestCase.join(th, 30 * 1000, null);
    // }
    // catch (Exception e) {
    // e.printStackTrace();
    // failureCause = e.toString();
    // failure = true;
    // }
    // }

    // public void afterHavingCompacted()
    // {
    // synchronized (OplogJUnitTest.this) {
    // rollerThread = Thread.currentThread();
    // OplogJUnitTest.this.notify();
    // OplogJUnitTest.this.proceed = true;
    // }
    // }
    // });
    // region.put("key2", new byte[300]);
    // synchronized (this) {
    // if (!this.proceed) {
    // this.wait(15000);
    // assertTrue(this.proceed);
    // }
    // }
    // this.proceed = false;
    // // Asif Delete the 1st entry
    // region.destroy("key1");

    // CacheObserverHolder.setInstance(new CacheObserverAdapter() {
    // public void afterHavingCompacted()
    // {
    // synchronized (OplogJUnitTest.this) {
    // OplogJUnitTest.this.notify();
    // OplogJUnitTest.this.proceed = true;
    // }
    // }
    // });
    // // Coz another switch and wait till rolling done
    // region.put("key2", new byte[900]);

    // synchronized (this) {
    // if (!this.proceed) {
    // this.wait(15000);
    // assertFalse(this.proceed);
    // }
    // }
    // // Check if the roller is stil alive
    // assertTrue(rollerThread.isAlive());
    // }
    // catch (Exception e) {
    // e.printStackTrace();
    // fail("Test failed du toe xception" + e);
    // }
    // finally {
    // CacheObserverHolder.setInstance(old);
    // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
    // }

    // }

    /**
     * Tests the condition when a 'put' is in progress and concurrent 'clear' and 'put'(on the same
     * key) occur. Thus if after Htree ref was set (in 'put'), the region got cleared (and same key
     * re-'put'), the entry will get recorded in the new Oplog without a corresponding create (
     * because the Oplogs containing create have already been deleted due to the clear operation).
     * This put should not proceed. Also, Region creation after closing should not give an exception.
     */
    @Test
    public void testPutClearPut() {
        try {
            // Create a persist only region with rolling true
            diskProps.setPersistBackup(true);
            diskProps.setRolling(true);
            diskProps.setMaxOplogSize(1024);
            diskProps.setSynchronous(true);
            this.proceed = false;
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            final Thread clearOp = new Thread(new Runnable() {
                public void run() {
                    try {
                        LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
                        region.clear();
                        region.put("key1", "value3");
                    } catch (Exception e) {
                        testFailed = true;
                        failureCause = "Encountered Exception=" + e;
                    }
                }
            });
            region.getAttributesMutator().setCacheWriter(new CacheWriterAdapter() {
                @Override
                public void beforeUpdate(EntryEvent event) throws CacheWriterException {
                    clearOp.start();
                }
            });
            try {
                ThreadUtils.join(clearOp, 30 * 1000);
            } catch (Exception e) {
                testFailed = true;
                failureCause = "Encountered Exception=" + e;
                e.printStackTrace();
            }
            region.create("key1", "value1");
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
            region.put("key1", "value2");
            if (!testFailed) {
                region.close();
                region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            } else {
                fail(failureCause);
            }
        } catch (Exception e) {
            e.printStackTrace();
            fail("Test failed due to exception" + e);
        } finally {
            testFailed = false;
            proceed = false;
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
        }
    }

    /**
     * Tests the condition when a 'put' on an alreay created entry and concurrent 'clear' are
     * happening. Thus if after HTree ref was set (in 'put'), the region got cleared (and same key
     * re-'put'), the entry will actually become a create in the VM The new Oplog should record it as
     * a create even though the Htree ref in ThreadLocal will not match with the current Htree Ref.
     * But the operation is valid & should get recorded in Oplog
     *
     */
    @Test
    public void testPutClearCreate() {
        failure = false;
        try {
            // Create a persist only region with rolling true
            diskProps.setPersistBackup(true);
            diskProps.setRolling(true);
            diskProps.setMaxOplogSize(1024);
            diskProps.setSynchronous(true);

            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);

            region.create("key1", "value1");
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
            CacheObserverHolder.setInstance(new CacheObserverAdapter() {
                @Override
                public void afterSettingDiskRef() {
                    Thread clearTh = new Thread(new Runnable() {
                        public void run() {
                            region.clear();
                        }
                    });
                    clearTh.start();
                    try {
                        ThreadUtils.join(clearTh, 120 * 1000);
                        failure = clearTh.isAlive();
                        failureCause = "Clear Thread still running !";
                    } catch (Exception e) {
                        failure = true;
                        failureCause = e.toString();
                    }
                }
            });
            region.put("key1", "value2");
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
            assertFalse(failureCause, failure);
            assertEquals(1, region.size());
            region.close();
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            assertEquals(1, region.size());
            assertEquals("value2", (String) region.get("key1"));
        } catch (Exception e) {
            e.printStackTrace();
            fail("Test failed due to exception" + e);
        } finally {
            testFailed = false;
            proceed = false;
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
            CacheObserverHolder.setInstance(new CacheObserverAdapter());
            failure = false;
        }
    }

    /**
     * Tests if 'destroy' transaction is working correctly for sync-overflow-only disk region entry
     */
    @Test
    public void testOverFlowOnlySyncDestroyTx() {
        diskProps.setMaxOplogSize(20480);
        diskProps.setOverFlowCapacity(1);
        diskProps.setDiskDirs(dirs);
        region = DiskRegionHelperFactory.getSyncOverFlowOnlyRegion(cache, diskProps);
        assertNotNull(region);
        region.put("key", "createValue");
        region.put("key1", "createValue1");
        try {
            cache.getCacheTransactionManager().begin();
            region.destroy("key");
            cache.getCacheTransactionManager().commit();
            assertNull("The deleted entry should have been null", ((LocalRegion) region).entries.getEntry("key"));
        } catch (CommitConflictException e) {
            testFailed = true;
            fail("CommitConflitException encountered");
        } catch (Exception e) {
            e.printStackTrace();
            fail("Test failed due to exception" + e);
        }
    }

    /**
     * Test to force a recovery to follow the path of switchOutFilesForRecovery and ensuring that
     * IOExceptions do not come as a result. This is also a bug test for bug 37682
     * 
     * @throws Exception
     */
    @Test
    public void testSwitchFilesForRecovery() throws Exception {
        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, null, Scope.LOCAL);
        put100Int();
        region.forceRolling();
        Thread.sleep(2000);
        put100Int();
        int sizeOfRegion = region.size();
        region.close();
        // this variable will set to false in the src code itself
        // NewLBHTreeDiskRegion.setJdbmexceptionOccuredToTrueForTesting = true;
        try {
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, null, Scope.LOCAL);
        } catch (Exception e) {
            fail("failed in recreating region due to" + e);
        } finally {
            // NewLBHTreeDiskRegion.setJdbmexceptionOccuredToTrueForTesting = false;
        }
        if (sizeOfRegion != region.size()) {
            fail(" Expected region size to be " + sizeOfRegion + " after recovery but it is " + region.size());
        }
    }

    /**
     * tests directory stats are correctly updated in case of single directory (for bug 37531)
     */
    @Test
    public void testPersist1DirStats() {
        final AtomicBoolean freezeRoller = new AtomicBoolean();
        CacheObserver old = CacheObserverHolder.setInstance(new CacheObserverAdapter() {
            private volatile boolean didBeforeCall = false;

            @Override
            public void beforeGoingToCompact() {
                this.didBeforeCall = true;
                synchronized (freezeRoller) {
                    if (!assertDone) {
                        try {
                            // Here, we are not allowing the Roller thread to roll the old oplog into htree
                            while (!freezeRoller.get()) {
                                freezeRoller.wait();
                            }
                            freezeRoller.set(false);
                        } catch (InterruptedException e) {
                            fail("interrupted");
                        }
                    }
                }
            }

            @Override
            public void afterHavingCompacted() {
                if (this.didBeforeCall) {
                    this.didBeforeCall = false;
                    LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
                    // assertTrue("Assert failure for DSpaceUsage in afterHavingCompacted ",
                    // diskSpaceUsageStats() == calculatedDiskSpaceUsageStats());
                    // what is the point of this assert?
                    checkDiskStats();
                }
            }
        });
        try {
            final int MAX_OPLOG_SIZE = 500;
            diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
            diskProps.setPersistBackup(true);
            diskProps.setRolling(true);
            diskProps.setSynchronous(true);
            diskProps.setOverflow(false);
            diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 4000 });
            final byte[] val = new byte[200];
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
            region.put("key1", val);
            // Disk space should have changed due to 1 put
            // assertTrue("stats did not increase after put 1 ", diskSpaceUsageStats() ==
            // calculatedDiskSpaceUsageStats());
            checkDiskStats();
            region.put("key2", val);
            // assertTrue("stats did not increase after put 2", diskSpaceUsageStats() ==
            // calculatedDiskSpaceUsageStats());
            checkDiskStats();
            // This put will cause a switch as max-oplog size (500) will be exceeded (600)
            region.put("key3", val);
            synchronized (freezeRoller) {
                // assertTrue("current disk space usage with Roller thread in wait and put key3 done is
                // incorrect " + diskSpaceUsageStats() + " " + calculatedDiskSpaceUsageStats(),
                // diskSpaceUsageStats()== calculatedDiskSpaceUsageStats());
                checkDiskStats();
                assertDone = true;
                freezeRoller.set(true);
                freezeRoller.notifyAll();
            }

            region.close();
            closeDown();
            // Stop rolling to get accurate estimates:
            diskProps.setRolling(false);

            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);

            // On recreating the region after closing, old Oplog file gets rolled into htree
            // "Disk space usage zero when region recreated"
            checkDiskStats();
            region.put("key4", val);
            // assertTrue("stats did not increase after put 4", diskSpaceUsageStats() ==
            // calculatedDiskSpaceUsageStats());
            checkDiskStats();
            region.put("key5", val);
            // assertTrue("stats did not increase after put 5", diskSpaceUsageStats() ==
            // calculatedDiskSpaceUsageStats());
            checkDiskStats();
            assertDone = false;
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
            region.put("key6", val);
            // again we expect a switch in oplog here
            synchronized (freezeRoller) {
                // assertTrue("current disk space usage with Roller thread in wait and put key6 done is
                // incorrect", diskSpaceUsageStats()== calculatedDiskSpaceUsageStats());
                checkDiskStats();
                assertDone = true;
                freezeRoller.set(true);
                freezeRoller.notifyAll();
            }
            region.close();
        } catch (Exception e) {
            e.printStackTrace();
            fail("Test failed due to exception" + e);
        } finally {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
            CacheObserverHolder.setInstance(old);
            synchronized (freezeRoller) {
                assertDone = true;
                freezeRoller.set(true);
                freezeRoller.notifyAll();
            }
        }
    }

    /**
     * Tests reduction in size of disk stats when the oplog is rolled.
     */
    @Category(FlakyTest.class) // GEODE-527: jvm sizing sensitive, non-thread-safe test hooks, time
                               // sensitive
    @Test
    public void testStatsSizeReductionOnRolling() throws Exception {
        final int MAX_OPLOG_SIZE = 500 * 2;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(true);
        diskProps.setCompactionThreshold(100);
        diskProps.setSynchronous(true);
        diskProps.setOverflow(false);
        diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 4000 });
        final byte[] val = new byte[333];
        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        final DiskRegion dr = ((LocalRegion) region).getDiskRegion();
        final Object lock = new Object();
        final boolean[] exceptionOccured = new boolean[] { true };
        final boolean[] okToExit = new boolean[] { false };
        final boolean[] switchExpected = new boolean[] { false };

        // calculate sizes
        final int extra_byte_num_per_entry = InternalDataSerializer
                .calculateBytesForTSandDSID(getDSID((LocalRegion) region));
        final int key3_size = DiskOfflineCompactionJUnitTest.getSize4Create(extra_byte_num_per_entry, "key3", val);
        final int tombstone_key1 = DiskOfflineCompactionJUnitTest.getSize4TombstoneWithKey(extra_byte_num_per_entry,
                "key1");
        final int tombstone_key2 = DiskOfflineCompactionJUnitTest.getSize4TombstoneWithKey(extra_byte_num_per_entry,
                "key2");

        // TODO: move static methods from DiskOfflineCompactionJUnitTest to shared util class

        CacheObserver old = CacheObserverHolder.setInstance(new CacheObserverAdapter() {
            private long before = -1;
            private DirectoryHolder dh = null;
            private long oplogsSize = 0;

            @Override
            public void beforeSwitchingOplog() {
                cache.getLogger().info("beforeSwitchingOplog");
                if (!switchExpected[0]) {
                    fail("unexpected oplog switch");
                }
                if (before == -1) {
                    // only want to call this once; before the 1st oplog destroy
                    this.dh = dr.getNextDir();
                    this.before = this.dh.getDirStatsDiskSpaceUsage();
                }
            }

            @Override
            public void beforeDeletingCompactedOplog(Oplog oplog) {
                cache.getLogger().info("beforeDeletingCompactedOplog");
                oplogsSize += oplog.getOplogSize();
            }

            @Override
            public void afterHavingCompacted() {
                cache.getLogger().info("afterHavingCompacted");
                if (before > -1) {
                    synchronized (lock) {
                        okToExit[0] = true;
                        long after = this.dh.getDirStatsDiskSpaceUsage();
                        // after compaction, in _2.crf, key3 is an create-entry,
                        // key1 and key2 are tombstones.
                        // _2.drf contained a rvvgc with drMap.size()==1
                        int expected_drf_size = Oplog.OPLOG_DISK_STORE_REC_SIZE + Oplog.OPLOG_MAGIC_SEQ_REC_SIZE
                                + Oplog.OPLOG_GEMFIRE_VERSION_REC_SIZE
                                + DiskOfflineCompactionJUnitTest.getRVVSize(1, new int[] { 0 }, true);
                        int expected_crf_size = Oplog.OPLOG_DISK_STORE_REC_SIZE + Oplog.OPLOG_MAGIC_SEQ_REC_SIZE
                                + Oplog.OPLOG_GEMFIRE_VERSION_REC_SIZE
                                + DiskOfflineCompactionJUnitTest.getRVVSize(1, new int[] { 1 }, false)
                                + Oplog.OPLOG_NEW_ENTRY_BASE_REC_SIZE + key3_size + tombstone_key1 + tombstone_key2;
                        int oplog_2_size = expected_drf_size + expected_crf_size;
                        if (after != oplog_2_size) {
                            cache.getLogger().info("test failed before=" + before + " after=" + after
                                    + " oplogsSize=" + oplogsSize);
                            exceptionOccured[0] = true;
                        } else {
                            exceptionOccured[0] = false;
                        }
                        LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
                        lock.notify();
                    }
                }
            }
        });
        try {

            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
            cache.getLogger().info("putting key1");
            region.put("key1", val);
            // Disk space should have changed due to 1 put
            // assertTrue("stats did not increase after put 1 ", diskSpaceUsageStats() ==
            // calculatedDiskSpaceUsageStats());
            checkDiskStats();
            cache.getLogger().info("putting key2");
            region.put("key2", val);
            // assertTrue("stats did not increase after put 2", diskSpaceUsageStats() ==
            // calculatedDiskSpaceUsageStats());
            checkDiskStats();

            cache.getLogger().info("removing key1");
            region.remove("key1");
            cache.getLogger().info("removing key2");
            region.remove("key2");

            // This put will cause a switch as max-oplog size (900) will be exceeded (999)
            switchExpected[0] = true;
            cache.getLogger().info("putting key3");
            region.put("key3", val);
            cache.getLogger().info("waiting for compaction");
            synchronized (lock) {
                if (!okToExit[0]) {
                    lock.wait(9000);
                    assertTrue(okToExit[0]);
                }
                assertFalse(exceptionOccured[0]);
            }

            region.close();
        } finally {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
            CacheObserverHolder.setInstance(old);
        }
    }

    // @todo this test is broken; size1 can keep changing since the roller will
    // keep copying forward forever. Need to change it so copy forward oplogs
    // will not be compacted so that size1 reaches a steady state
    /**
     * Tests stats verification with rolling enabled
     */
    // @Test
    // public void testSizeStatsAfterRecreationWithRollingEnabled() throws Exception
    // {
    // final int MAX_OPLOG_SIZE = 500;
    // diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
    // diskProps.setPersistBackup(true);
    // diskProps.setRolling(true);
    // diskProps.setCompactionThreshold(100);
    // diskProps.setSynchronous(true);
    // diskProps.setOverflow(false);
    // diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 4000 });
    // final byte[] val = new byte[200];
    // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache,
    // diskProps);
    // final DiskRegion dr = ((LocalRegion)region).getDiskRegion();
    // final Object lock = new Object();
    // final boolean [] exceptionOccured = new boolean[] {true};
    // final boolean [] okToExit = new boolean[] {false};

    // CacheObserver old = CacheObserverHolder
    // .setInstance(new CacheObserverAdapter() {
    // private long before = -1;
    // public void beforeDeletingCompactedOplog(Oplog rolledOplog)
    // {
    // if (before == -1) {
    // // only want to call this once; before the 1st oplog destroy
    // before = dr.getNextDir().getDirStatsDiskSpaceUsage();
    // }
    // }
    // public void afterHavingCompacted() {
    // if(before > -1) {
    // synchronized(lock) {
    // okToExit[0] = true;
    // long after = dr.getNextDir().getDirStatsDiskSpaceUsage();;
    // exceptionOccured[0] = false;
    // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
    // lock.notify();
    // }
    // }
    // }
    // });
    // try {

    // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
    // region.put("key1", val);
    // region.put("key2", val);
    // // This put will cause a switch as max-oplog size (500) will be exceeded (600)
    // region.put("key3", val);
    // synchronized(lock) {
    // if (!okToExit[0]) {
    // lock.wait(9000);
    // assertTrue(okToExit[0]);
    // }
    // assertFalse(exceptionOccured[0]);
    // }
    // while (region.forceCompaction() != null) {
    // // wait until no more oplogs to compact
    // Thread.sleep(50);
    // }
    // long size1 =0;
    // for(DirectoryHolder dh:dr.getDirectories()) {
    // cache.getLogger().info(" dir=" + dh.getDir()
    // + " size1=" + dh.getDirStatsDiskSpaceUsage());
    // size1 += dh.getDirStatsDiskSpaceUsage();
    // }
    // System.out.println("Size before closing= "+ size1);
    // region.close();
    // diskProps.setRolling(false);
    // region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache,
    // diskProps);

    // long size2 =0;
    // for(DirectoryHolder dh:((LocalRegion)region).getDiskRegion().getDirectories()) {
    // cache.getLogger().info(" dir=" + dh.getDir()
    // + " size2=" + dh.getDirStatsDiskSpaceUsage());
    // size2 += dh.getDirStatsDiskSpaceUsage();
    // }
    // System.out.println("Size after recreation= "+ size2);
    // assertIndexDetailsEquals(size1, size2);
    // region.close();

    // }
    // finally {
    // LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
    // CacheObserverHolder.setInstance(old);
    // }
    // }

    // This test is not valid. When listenForDataSerializeChanges is called
    // it ALWAYS does vrecman writes and a commit. Look at saveInstantiators
    // and saveDataSerializers to see these commit calls.
    // These calls can cause the size of the files to change.
    /**
     * Tests if without rolling the region size before close is same as after recreation
     */
    @Test
    public void testSizeStatsAfterRecreation() throws Exception {
        final int MAX_OPLOG_SIZE = 500;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setSynchronous(true);
        diskProps.setOverflow(false);
        diskProps.setDiskDirsAndSizes(new File[] { dirs[0], dirs[1] }, new int[] { 4000, 4000 });
        final byte[] val = new byte[200];
        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
        DiskRegion dr = ((LocalRegion) region).getDiskRegion();

        try {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
            for (int i = 0; i < 8; ++i) {
                region.put("key" + i, val);
            }
            long size1 = 0;
            for (DirectoryHolder dh : dr.getDirectories()) {
                size1 += dh.getDirStatsDiskSpaceUsage();
            }
            System.out.println("Size before close = " + size1);
            region.close();
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            dr = ((LocalRegion) region).getDiskRegion();
            long size2 = 0;
            for (DirectoryHolder dh : dr.getDirectories()) {
                size2 += dh.getDirStatsDiskSpaceUsage();
            }
            System.out.println("Size after recreation= " + size2);
            assertEquals(size1, size2);
            region.close();
        } finally {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
        }
    }

    @Test
    public void testUnPreblowOnRegionCreate() throws Exception {
        final int MAX_OPLOG_SIZE = 20000;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(true);
        diskProps.setSynchronous(true);
        diskProps.setOverflow(false);
        diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 40000 });
        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);

        try {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
            for (int i = 0; i < 10; ++i) {
                region.put("key-" + i, "value-");
            }

            assertEquals(18000, getOplogFileSizeSum(dirs[0], ".crf"));
            assertEquals(2000, getOplogFileSizeSum(dirs[0], ".drf"));

            // make a copy of inflated crf. use this to replace compacted crf to
            // simulate incomplete diskStore close
            File[] files = dirs[0].listFiles();
            for (File file : files) {
                if (file.getName().endsWith(".crf") || file.getName().endsWith(".drf")) {
                    File inflated = new File(file.getAbsolutePath() + "_inflated");
                    FileUtils.copyFile(file, inflated);
                }
            }

            cache.close();
            assertTrue(500 > getOplogFileSizeSum(dirs[0], ".crf"));
            assertTrue(100 > getOplogFileSizeSum(dirs[0], ".drf"));

            // replace compacted crf with inflated crf and remove krf
            files = dirs[0].listFiles();
            for (File file : files) {
                String name = file.getName();
                if (name.endsWith(".krf") || name.endsWith(".crf") || name.endsWith(".drf")) {
                    file.delete();
                }
            }
            for (File file : files) {
                String name = file.getName();
                if (name.endsWith("_inflated")) {
                    assertTrue(file.renameTo(new File(file.getAbsolutePath().replace("_inflated", ""))));
                }
            }
            assertEquals(18000, getOplogFileSizeSum(dirs[0], ".crf"));
            assertEquals(2000, getOplogFileSizeSum(dirs[0], ".drf"));

            createCache();
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            for (int i = 10; i < 20; ++i) {
                region.put("key-" + i, "value-");
            }

            int sizeCrf = getOplogFileSizeSum(dirs[0], ".crf");
            assertTrue("crf too big:" + sizeCrf, sizeCrf < 18000 + 500);
            assertTrue("crf too small:" + sizeCrf, sizeCrf > 18000);
            int sizeDrf = getOplogFileSizeSum(dirs[0], ".drf");
            assertTrue("drf too big:" + sizeDrf, sizeDrf < 2000 + 100);
            assertTrue("drf too small:" + sizeDrf, sizeDrf > 2000);

            // test that region recovery does not cause unpreblow
            region.close();
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);

            assertEquals(sizeCrf, getOplogFileSizeSum(dirs[0], ".crf"));
            assertEquals(sizeDrf, getOplogFileSizeSum(dirs[0], ".drf"));
        } finally {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
        }
    }

    private int getOplogFileSizeSum(File dir, String type) {
        int sum = 0;
        File[] files = dir.listFiles();
        for (File file : files) {
            String name = file.getName();
            if (name.endsWith(type)) {
                sum += file.length();
            }
        }
        return sum;
    }

    @Test
    public void testMagicSeqPresence() throws Exception {
        final int MAX_OPLOG_SIZE = 200;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(true);
        diskProps.setSynchronous(true);
        diskProps.setOverflow(false);
        diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 4000 });
        region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);

        // 3 types of oplog files will be verified
        verifyOplogHeader(dirs[0], ".if", ".crf", ".drf");

        try {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
            IntStream.range(0, 20).forEach(i -> region.put("key-" + i, "value-" + i));
            // krf is created, so 4 types of oplog files will be verified
            verifyOplogHeader(dirs[0], ".if", ".crf", ".drf", ".krf");

            region.close();
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);

            verifyOplogHeader(dirs[0], ".if", ".crf", ".drf", ".krf");
            region.close();
        } finally {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
        }
    }

    private void verifyOplogHeader(File dir, String... oplogTypes) throws IOException {

        Awaitility.await().atMost(5, TimeUnit.SECONDS).until(() -> {
            List<String> types = new ArrayList<>(Arrays.asList(oplogTypes));
            Arrays.stream(dir.listFiles()).map(File::getName).map(f -> f.substring(f.indexOf(".")))
                    .forEach(types::remove);
            return types.isEmpty();
        });

        File[] files = dir.listFiles();
        HashSet<String> verified = new HashSet<String>();
        for (File file : files) {
            String name = file.getName();
            byte[] expect = new byte[Oplog.OPLOG_MAGIC_SEQ_REC_SIZE];
            if (name.endsWith(".crf")) {
                expect[0] = Oplog.OPLOG_MAGIC_SEQ_ID;
                System.arraycopy(OPLOG_TYPE.CRF.getBytes(), 0, expect, 1, OPLOG_TYPE.getLen());
                verified.add(".crf");
            } else if (name.endsWith(".drf")) {
                expect[0] = Oplog.OPLOG_MAGIC_SEQ_ID;
                System.arraycopy(OPLOG_TYPE.DRF.getBytes(), 0, expect, 1, OPLOG_TYPE.getLen());
                verified.add(".drf");
            } else if (name.endsWith(".krf")) {
                expect[0] = Oplog.OPLOG_MAGIC_SEQ_ID;
                System.arraycopy(OPLOG_TYPE.KRF.getBytes(), 0, expect, 1, OPLOG_TYPE.getLen());
                verified.add(".krf");
            } else if (name.endsWith(".if")) {
                expect[0] = DiskInitFile.OPLOG_MAGIC_SEQ_ID;
                System.arraycopy(OPLOG_TYPE.IF.getBytes(), 0, expect, 1, OPLOG_TYPE.getLen());
                verified.add(".if");
            } else {
                System.out.println("Ignored: " + file);
                continue;
            }
            expect[expect.length - 1] = 21; // EndOfRecord

            byte[] buf = new byte[Oplog.OPLOG_MAGIC_SEQ_REC_SIZE];

            FileInputStream fis = new FileInputStream(file);
            int count = fis.read(buf, 0, 8);
            fis.close();

            System.out.println("Verifying: " + file);
            assertEquals("expected a read to return 8 but it returned " + count + " for file " + file, 8, count);
            assertTrue(Arrays.equals(expect, buf));
        }

        assertEquals(oplogTypes.length, verified.size());
    }

    /**
     * Tests if without rolling the region size before close is same as after recreation
     */
    @Test
    public void testSizeStatsAfterRecreationInAsynchMode() throws Exception {
        final int MAX_OPLOG_SIZE = 1000;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setSynchronous(false);
        diskProps.setBytesThreshold(800);
        diskProps.setOverflow(false);
        diskProps.setDiskDirsAndSizes(new File[] { dirs[0], dirs[1] }, new int[] { 4000, 4000 });
        final byte[] val = new byte[25];
        region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps);
        DiskRegion dr = ((LocalRegion) region).getDiskRegion();

        try {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
            for (int i = 0; i < 42; ++i) {
                region.put("key" + i, val);
            }
            // need to wait for writes to happen before getting size
            dr.flushForTesting();
            long size1 = 0;
            for (DirectoryHolder dh : dr.getDirectories()) {
                size1 += dh.getDirStatsDiskSpaceUsage();
            }
            System.out.println("Size before close = " + size1);
            region.close();
            diskProps.setSynchronous(true);
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            dr = ((LocalRegion) region).getDiskRegion();
            long size2 = 0;
            for (DirectoryHolder dh : dr.getDirectories()) {
                size2 += dh.getDirStatsDiskSpaceUsage();
            }
            System.out.println("Size after recreation= " + size2);
            assertEquals(size1, size2);
            region.close();
        } finally {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
        }
    }

    @Test
    public void testAsynchModeStatsBehaviour() throws Exception {
        final int MAX_OPLOG_SIZE = 1000;
        diskProps.setMaxOplogSize(MAX_OPLOG_SIZE);
        diskProps.setPersistBackup(true);
        diskProps.setRolling(false);
        diskProps.setSynchronous(false);
        diskProps.setBytesThreshold(800);
        diskProps.setTimeInterval(Long.MAX_VALUE);
        diskProps.setOverflow(false);
        diskProps.setDiskDirsAndSizes(new File[] { dirs[0] }, new int[] { 4000 });
        final byte[] val = new byte[25];
        region = DiskRegionHelperFactory.getAsyncPersistOnlyRegion(cache, diskProps);
        DiskRegion dr = ((LocalRegion) region).getDiskRegion();

        try {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = true;
            for (int i = 0; i < 4; ++i) {
                region.put("key" + i, val);
            }
            // This test now has a race condition in it since
            // async puts no longer increment disk space.
            // It is not until a everything is flushed that we will know the disk size.
            dr.flushForTesting();

            checkDiskStats();
            long size1 = 0;
            for (DirectoryHolder dh : dr.getDirectories()) {
                size1 += dh.getDirStatsDiskSpaceUsage();
            }
            System.out.println("Size before close = " + size1);
            region.close();
            diskProps.setSynchronous(true);
            region = DiskRegionHelperFactory.getSyncPersistOnlyRegion(cache, diskProps, Scope.LOCAL);
            dr = ((LocalRegion) region).getDiskRegion();
            long size2 = 0;
            for (DirectoryHolder dh : dr.getDirectories()) {
                size2 += dh.getDirStatsDiskSpaceUsage();
            }
            System.out.println("Size after recreation= " + size2);
            assertEquals(size1, size2);
            region.close();
        } finally {
            LocalRegion.ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
        }
    }

    protected long diskSpaceUsageStats() {
        return ((LocalRegion) region).getDiskRegion().getInfoFileDir().getDirStatsDiskSpaceUsage();
    }

    protected long calculatedDiskSpaceUsageStats() {
        long oplogSize = oplogSize();
        // cache.getLogger().info(" oplogSize=" + oplogSize
        // + " statSize=" + diskSpaceUsageStats());
        return oplogSize;
    }

    private void checkDiskStats() {
        long actualDiskStats = diskSpaceUsageStats();
        long computedDiskStats = calculatedDiskSpaceUsageStats();
        int tries = 0;
        while (actualDiskStats != computedDiskStats && tries++ <= 100) {
            // race conditions exist in which the stats change
            try {
                Thread.sleep(100);
            } catch (InterruptedException ignore) {
            }
            actualDiskStats = diskSpaceUsageStats();
            computedDiskStats = calculatedDiskSpaceUsageStats();
        }
        assertEquals(computedDiskStats, actualDiskStats);
    }

    private long oplogSize() {
        long size = ((LocalRegion) region).getDiskRegion().getDiskStore().undeletedOplogSize.get();
        // cache.getLogger().info("undeletedOplogSize=" + size);
        Oplog[] opArray = ((LocalRegion) region).getDiskRegion().getDiskStore().persistentOplogs.getAllOplogs();
        if ((opArray != null) && (opArray.length != 0)) {
            for (int j = 0; j < opArray.length; ++j) {
                size += opArray[j].getOplogSize();
                // cache.getLogger().info("oplog#" + opArray[j].getOplogId()
                // + ".size=" + opArray[j].getOplogSize());
            }
        }
        return size;
    }

    private int getDSID(LocalRegion lr) {
        return lr.getDistributionManager().getDistributedSystemId();
    }
}