InitImageTest (GemFire XD Java API Documentation)

java.lang.Object
- getInitialImage.InitImageTest

Direct Known Subclasses:

AsyncMsgInitImageTest, InterestPolicyTest, KnownKeysTest
```
public class InitImageTest
extends Object
```

Field Summary

Fields
Modifier and Type	Field and Description
`protected static int`	`ADD_NEW_KEY`
`com.gemstone.gemfire.cache.Region`	`aRegion`
`protected long`	`createRegionDurationMS`
`protected static int`	`DESTROY`
`protected static int`	`FIRST_OP`
`protected static int`	`GET`
`protected long`	`giiDurationMS`
`protected static int`	`INVALIDATE`
`KeyIntervals`	`keyIntervals`
`protected static int`	`LAST_OP`
`protected static int`	`LOCAL_DESTROY`
`protected static int`	`LOCAL_INVALIDATE`
`protected long`	`LOG_INTERVAL_MILLIS`
`protected int`	`numNewKeys`
`protected static int[]`	`operations`
`protected static int`	`PUTALL_NEW_KEY`
`protected RandomValues`	`randomValues`
`protected static String`	`REGION_NAME`
`protected SharedCounters`	`sc`
`protected int`	`sleepMSAfterOps`
`protected boolean`	`supportsConcurrentMap`
`protected static InitImageTest`	`testInstance`
`protected int`	`totalNumKeys`
`protected static int`	`UPDATE_EXISTING_KEY`

Constructor Summary

Constructors
Constructor and Description

InitImageTest()

Constructors
Constructor and Description
`InitImageTest()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected boolean`	`addNewKey()` Add a new key to REGION_NAME.
`protected void`	`blockedGetRegion()` Wait for another thread in this VM to begin a getInitialImage, then get the region REGION_NAME, which should block while somebody else has a getInitialImage in progress.
`protected void`	`checkContainsKey(Object key, boolean expected, String logStr)` Check that containsKey() called on the tests' region has the expected result.
`protected void`	`checkContainsValueForKey(Object key, boolean expected, String logStr)` Check that containsValueForKey() called on the tests' region has the expected result.
`protected void`	`checkUpdatedValue(Object key, Object value)` Check that the value of the given key is expected as an updated value.
`protected void`	`checkValue(Object key, Object value)` Check that the value of the given key is expected for this test.
`protected BaseValueHolder`	`createObject(Object key)`
`protected BaseValueHolder`	`createObject(Object key, RandomValues values)`
`protected boolean`	`destroy()` Destroy a key in region REGION_NAME.
`protected void`	`doGetInitImage(boolean withMonitor)` Get the region REGION_NAME, which should do a getInitialImage.
`protected void`	`doNewKeyGets()` Do gets with keys that do not exist in the system.
`void`	`doOps(BitSet availableOps)` Do operations on the REGION_NAME's keys using keyIntervals to specify which keys get which operations.
`protected void`	`doOpsPlusPuts()` Do keyInterval operations during the gii, then wait for the gii to complete.
`protected boolean`	`get()` Do a get on a key in region REGION_NAME.
`protected com.gemstone.gemfire.cache.CacheLoader`	`getCacheLoader()` Return a cache loader to install into a region, or null of none InitImagePrms.useCacheLoader is used to determine if a cache loader should be installed.
`protected com.gemstone.gemfire.cache.CacheWriter`	`getCacheWriter()` Return a cache writer to install into a region, or null if none InitImagePrms.useCacheWriter is used to determine if a cache writer should be installed.
`protected int`	`getOp(BitSet bs, int bsSize)` Get a random operation to perform.
`protected Set`	`getRegionKeySet(com.gemstone.gemfire.cache.Region aRegion)`
`protected Object`	`getValueToAdd(Object key)` Return a value to add to a region for the given key
`protected static boolean`	`hasLocalGiiCompleted()` Test whether the local GII has completed.
`static void`	`HydraTask_blockedGetRegion()` Hydra task to wait until another thread does a getInitialImage, then this get region should block.
`static void`	`HydraTask_doCacheWriterTest()` Hydra task to do operations that will cause a CacheWriter to be invoked in the VM doing a getInitialImage.
`static void`	`HydraTask_doGetInitImage()` Hydra task to do a get region, which does a getInitialImage.
`static void`	`HydraTask_doGetInitImageWithoutMonitor()` Hydra task to do a get region, which does a getInitialImage.
`static void`	`HydraTask_doNewKeyGets()` Hydra task to do gets with new keys (ie not anywhere in the system)
`static void`	`HydraTask_doOps()` Hydra task to perform operations according to keyIntervals on an previously initialized region.
`static void`	`HydraTask_doPutAllNewKey()` Hydra task to perform local destroy operations, according to keyIntervals on a previously initialized region.
`static void`	`HydraTask_initCache()` Hydra task to initialize the cache
`static void`	`HydraTask_loadRegion()` Hydra task to initialize a region and load it according to hydra param settings.
`static void`	`HydraTask_loadRegionWithGets()` Hydra task to initialize a region and load it by getting values from another distributed system using gets.
`static void`	`HydraTask_verifyCacheWriterTest()` Hydra task to verify that a CacheWriters are not invoked during a GII.
`static void`	`HydraTask_verifyEventCounters()` Hydra task to verify event counters.
`static void`	`HydraTask_verifyGII()`
`static void`	`HydraTask_verifyNonBlocking()` Hydra task to verify that operations concurrent to getInitialImage are non-blocking.
`static void`	`HydraTask_verifyRegionContents()` Hydra task to verify the keys and values in a region using keyIntervals.
`protected static void`	`initializeInstance()` Initialize the single instance of this test class but not a region.
`protected static void`	`initializeRegion(com.gemstone.gemfire.cache.DataPolicy dataPolicy)` Initialize the single instance of this test class and a region.
`void`	`initInstance()` Initialize fields for this instance
`protected void`	`initRegion(com.gemstone.gemfire.cache.DataPolicy dataPolicy)` Initialize a region with the desired attributes.
`protected boolean`	`invalidate()` Invalidate a key in region REGION_NAME.
`protected static boolean`	`isAnyGiiInProgress()` Test whether any GII is in progress.
`protected static boolean`	`isLocalGiiInProgress()` Test whether a local GII is in progress.
`protected static boolean`	`isLocalGiiInProgress(com.gemstone.gemfire.cache.Region aRegion)` Test whether a local GII is in progress.
`void`	`loadRegion()` Load a region with keys and values.
`void`	`loadRegionWithGets()` Loads a region with keys and values by getting the value from another distributed system.
`protected boolean`	`localDestroy()` Locally destroy a key in region REGION_NAME.
`protected boolean`	`localInvalidate()` Locally invalidate a key in region REGION_NAME.
`protected boolean`	`putAllNewKey()` Add a group of new keys via putAll to REGION_NAME.
`static void`	`StartTask_initialize()` Hydra start task to initialize key intervals, which are ranges of keys which are to have an operation done on them (invalidate, destroy, etc)
`protected boolean`	`updateExistingKey()` Update an existing key in region REGION_NAME.
`protected void`	`verifyCacheWriterTest()` Verify counters to show that the cache writer installed in the VM doing the getInitialImage was not invoked while GII was in progress, but gets invoked when GII is not in progress.
`protected void`	`verifyEventCounters()`
`void`	`verifyNonBlocking()` Verify that the region operations that occurred did not block.
`void`	`verifyRegionContents()` Verify the contents of the region, taking into account the keys that were destroyed, invalidted, etc (as specified in keyIntervals) Throw an error of any problems are detected.
`protected static void`	`waitForAllGiiToComplete()` Wait for getInitialImage in ALL vms to complete.
`static void`	`waitForAnyGiiToBegin()` Wait for a getInitialImage in ANY vm to be in progress.
`protected static void`	`waitForLocalGiiCompleted()` Wait for stats to indicate that a getInitialImage has completed.
`protected static void`	`waitForLocalGiiToBegin()` Wait for stats to indicate that a getInitialImage is in progress.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - testInstance
```
protected static InitImageTest testInstance
```
  - REGION_NAME
```
protected static final String REGION_NAME
```
    See Also:
    
    Constant Field Values
  - randomValues
```
protected RandomValues randomValues
```
  - numNewKeys
```
protected int numNewKeys
```
  - keyIntervals
```
public KeyIntervals keyIntervals
```
  - totalNumKeys
```
protected int totalNumKeys
```
  - aRegion
```
public com.gemstone.gemfire.cache.Region aRegion
```
  - createRegionDurationMS
```
protected long createRegionDurationMS
```
  - giiDurationMS
```
protected long giiDurationMS
```
  - sc
```
protected SharedCounters sc
```
  - sleepMSAfterOps
```
protected int sleepMSAfterOps
```
  - supportsConcurrentMap
```
protected boolean supportsConcurrentMap
```
  - INVALIDATE
```
protected static final int INVALIDATE
```
    See Also:
    
    Constant Field Values
  - LOCAL_INVALIDATE
```
protected static final int LOCAL_INVALIDATE
```
    See Also:
    
    Constant Field Values
  - DESTROY
```
protected static final int DESTROY
```
    See Also:
    
    Constant Field Values
  - LOCAL_DESTROY
```
protected static final int LOCAL_DESTROY
```
    See Also:
    
    Constant Field Values
  - UPDATE_EXISTING_KEY
```
protected static final int UPDATE_EXISTING_KEY
```
    See Also:
    
    Constant Field Values
  - GET
```
protected static final int GET
```
    See Also:
    
    Constant Field Values
  - ADD_NEW_KEY
```
protected static final int ADD_NEW_KEY
```
    See Also:
    
    Constant Field Values
  - PUTALL_NEW_KEY
```
protected static final int PUTALL_NEW_KEY
```
    See Also:
    
    Constant Field Values
  - FIRST_OP
```
protected static final int FIRST_OP
```
    See Also:
    
    Constant Field Values
  - LAST_OP
```
protected static final int LAST_OP
```
    See Also:
    
    Constant Field Values
  - operations
```
protected static final int[] operations
```
  - LOG_INTERVAL_MILLIS
```
protected final long LOG_INTERVAL_MILLIS
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - InitImageTest
```
public InitImageTest()
```
- Method Detail
  - initializeRegion
```
protected static void initializeRegion(com.gemstone.gemfire.cache.DataPolicy dataPolicy)
```
    Initialize the single instance of this test class and a region. If this VM has already initialized its instance, then skip reinitializing.
  - initializeInstance
```
protected static void initializeInstance()
```
    Initialize the single instance of this test class but not a region. If this VM has already initialized its instance, then skip reinitializing.
  - initRegion
```
protected void initRegion(com.gemstone.gemfire.cache.DataPolicy dataPolicy)
```
    Initialize a region with the desired attributes. Initialize instance fields for this instance.
  - initInstance
```
public void initInstance()
```
    Initialize fields for this instance
  - StartTask_initialize
```
public static void StartTask_initialize()
```
    Hydra start task to initialize key intervals, which are ranges of keys which are to have an operation done on them (invalidate, destroy, etc)
  - HydraTask_loadRegion
```
public static void HydraTask_loadRegion()
```
    Hydra task to initialize a region and load it according to hydra param settings.
  - HydraTask_loadRegionWithGets
```
public static void HydraTask_loadRegionWithGets()
```
    Hydra task to initialize a region and load it by getting values from another distributed system using gets.
  - HydraTask_doOps
```
public static void HydraTask_doOps()
```
    Hydra task to perform operations according to keyIntervals on an previously initialized region.
  - HydraTask_doPutAllNewKey
```
public static void HydraTask_doPutAllNewKey()
```
    Hydra task to perform local destroy operations, according to keyIntervals on a previously initialized region.
  - HydraTask_doGetInitImage
```
public static void HydraTask_doGetInitImage()
```
    Hydra task to do a get region, which does a getInitialImage.
  - HydraTask_doGetInitImageWithoutMonitor
```
public static void HydraTask_doGetInitImageWithoutMonitor()
```
    Hydra task to do a get region, which does a getInitialImage.
  - HydraTask_blockedGetRegion
```
public static void HydraTask_blockedGetRegion()
```
    Hydra task to wait until another thread does a getInitialImage, then this get region should block.
  - HydraTask_verifyRegionContents
```
public static void HydraTask_verifyRegionContents()
```
    Hydra task to verify the keys and values in a region using keyIntervals.
  - HydraTask_verifyEventCounters
```
public static void HydraTask_verifyEventCounters()
```
    Hydra task to verify event counters.
  - HydraTask_initCache
```
public static void HydraTask_initCache()
```
    Hydra task to initialize the cache
  - HydraTask_verifyNonBlocking
```
public static void HydraTask_verifyNonBlocking()
```
    Hydra task to verify that operations concurrent to getInitialImage are non-blocking.
  - HydraTask_doNewKeyGets
```
public static void HydraTask_doNewKeyGets()
```
    Hydra task to do gets with new keys (ie not anywhere in the system)
  - HydraTask_doCacheWriterTest
```
public static void HydraTask_doCacheWriterTest()
```
    Hydra task to do operations that will cause a CacheWriter to be invoked in the VM doing a getInitialImage.
  - HydraTask_verifyCacheWriterTest
```
public static void HydraTask_verifyCacheWriterTest()
```
    Hydra task to verify that a CacheWriters are not invoked during a GII.
  - doGetInitImage
```
protected void doGetInitImage(boolean withMonitor)
```
    Get the region REGION_NAME, which should do a getInitialImage. Verify that the getInitialImage occurred by checking the stat for completion of getInitialImage. Save the number of millis taken for the getRegion in the createRegionDurationMS instance field.
  - blockedGetRegion
```
protected void blockedGetRegion()
```
    Wait for another thread in this VM to begin a getInitialImage, then get the region REGION_NAME, which should block while somebody else has a getInitialImage in progress. When finished, compare time to createRegionDurationMS (the time taken by the thread that did the getInitialImage) to verify that this blocked. Also, check stats to make sure this thread did not do another getInitialImage.
  - loadRegion
```
public void loadRegion()
```
    Load a region with keys and values. The number of keys and values is specified by the total number of keys in keyIntervals. This can be invoked by several threads to accomplish the work.
  - loadRegionWithGets
```
public void loadRegionWithGets()
```
    Loads a region with keys and values by getting the value from another distributed system. The number of keys and values loaded are specified by the number of keys in keyIntervals. Can be invoked by several threads to accomplish the work.
  - doOps
```
public void doOps(BitSet availableOps)
```
    Do operations on the REGION_NAME's keys using keyIntervals to specify which keys get which operations. This will return when all operations in all intervals have completed.
    
    Parameters:
    
    availableOps - - Bits which are true correspond to the operations that should be executed.
  - addNewKey
```
protected boolean addNewKey()
```
    Add a new key to REGION_NAME.
    
    Returns:
    
    true if all new keys have been added (specified by InitImagePrms.numNewKeys)
  - putAllNewKey
```
protected boolean putAllNewKey()
```
    Add a group of new keys via putAll to REGION_NAME.
    
    Returns:
    
    true if all new keys have been added (specified by InitImagePrms.numNewKeys)
  - updateExistingKey
```
protected boolean updateExistingKey()
```
    Update an existing key in region REGION_NAME. The keys to update are specified in keyIntervals.
    
    Returns:
    
    true if all keys to be updated have been completed.
  - localInvalidate
```
protected boolean localInvalidate()
```
    Locally invalidate a key in region REGION_NAME. The keys to locally invalidate are specified in keyIntervals.
    
    Returns:
    
    true if all keys to be locally invalidated have been completed.
  - invalidate
```
protected boolean invalidate()
```
    Invalidate a key in region REGION_NAME. The keys to invalidate are specified in keyIntervals.
    
    Returns:
    
    true if all keys to be invalidated have been completed.
  - localDestroy
```
protected boolean localDestroy()
```
    Locally destroy a key in region REGION_NAME. The keys to locally destroy are specified in keyIntervals.
    
    Returns:
    
    true if all keys to be locally destroyed have been completed.
  - destroy
```
protected boolean destroy()
```
    Destroy a key in region REGION_NAME. The keys to destroy are specified in keyIntervals.
    
    Returns:
    
    true if all keys to be destroyed have been completed.
  - get
```
protected boolean get()
```
    Do a get on a key in region REGION_NAME. Keys to get are specified in keyIntervals.
    
    Returns:
    
    true if all keys to have get performaed have been completed.
  - doNewKeyGets
```
protected void doNewKeyGets()
```
    Do gets with keys that do not exist in the system. Do this until a getInitialImage has completed.
  - doOpsPlusPuts
```
protected void doOpsPlusPuts()
```
    Do keyInterval operations during the gii, then wait for the gii to complete. After it has completed, do more puts with new keys.
  - verifyRegionContents
```
public void verifyRegionContents()
```
    Verify the contents of the region, taking into account the keys that were destroyed, invalidted, etc (as specified in keyIntervals) Throw an error of any problems are detected.
  - verifyNonBlocking
```
public void verifyNonBlocking()
```
    Verify that the region operations that occurred did not block. Do this by looking at the number of operations that occurred while creating the region that did getInitialImage.
  - verifyEventCounters
```
protected void verifyEventCounters()
```
  - verifyCacheWriterTest
```
protected void verifyCacheWriterTest()
```
    Verify counters to show that the cache writer installed in the VM doing the getInitialImage was not invoked while GII was in progress, but gets invoked when GII is not in progress.
  - checkContainsKey
```
protected void checkContainsKey(Object key,
                                boolean expected,
                                String logStr)
```
    Check that containsKey() called on the tests' region has the expected result. Throw an error if any problems.
    
    Parameters:
    
    key - The key to check.
    
    expected - The expected result of containsKey
    
    logStr - Used if throwing an error due to an unexpected value.
  - checkContainsValueForKey
```
protected void checkContainsValueForKey(Object key,
                                        boolean expected,
                                        String logStr)
```
    Check that containsValueForKey() called on the tests' region has the expected result. Throw an error if any problems.
    
    Parameters:
    
    key - The key to check.
    
    expected - The expected result of containsValueForKey
    
    logStr - Used if throwing an error due to an unexpected value.
  - checkValue
```
protected void checkValue(Object key,
                          Object value)
```
    Check that the value of the given key is expected for this test. Throw an error if any problems.
    
    Parameters:
    
    key - The key to check.
    
    value - The value for the key.
    
    logStr - Used if throwing an error due to an unexpected value.
  - checkUpdatedValue
```
protected void checkUpdatedValue(Object key,
                                 Object value)
```
    Check that the value of the given key is expected as an updated value. Throw an error if any problems.
    
    Parameters:
    
    key - The key to check.
    
    value - The value for the key.
    
    logStr - Used if throwing an error due to an unexpected value.
  - getOp
```
protected int getOp(BitSet bs,
                    int bsSize)
```
    Get a random operation to perform. The set of operations available are in the BitSet. These bits correspond to the operations defined in this class.
    
    Parameters:
    
    bs - True bits correspond to operations available to be chosen.
    
    bsSize - The number of bits to consider.
    
    Returns:
    
    An operation as defined in this class.
  - getCacheLoader
```
protected com.gemstone.gemfire.cache.CacheLoader getCacheLoader()
```
    Return a cache loader to install into a region, or null of none InitImagePrms.useCacheLoader is used to determine if a cache loader should be installed.
  - getCacheWriter
```
protected com.gemstone.gemfire.cache.CacheWriter getCacheWriter()
```
    Return a cache writer to install into a region, or null if none InitImagePrms.useCacheWriter is used to determine if a cache writer should be installed.
  - getValueToAdd
```
protected Object getValueToAdd(Object key)
```
    Return a value to add to a region for the given key
  - createObject
```
protected BaseValueHolder createObject(Object key)
```
  - createObject
```
protected BaseValueHolder createObject(Object key,
                                       RandomValues values)
```
  - getRegionKeySet
```
protected Set getRegionKeySet(com.gemstone.gemfire.cache.Region aRegion)
```
  - isLocalGiiInProgress
```
protected static boolean isLocalGiiInProgress()
```
    Test whether a local GII is in progress. Not as accurate as isLocalGiiInProgress(Region), but works if you don't have a region available.
  - isLocalGiiInProgress
```
protected static boolean isLocalGiiInProgress(com.gemstone.gemfire.cache.Region aRegion)
```
    Test whether a local GII is in progress. Is more accurate than isLocalGiiInProgress().
    
    Parameters:
    
    The - region that may be in a getInitialImage
  - hasLocalGiiCompleted
```
protected static boolean hasLocalGiiCompleted()
```
    Test whether the local GII has completed.
  - isAnyGiiInProgress
```
protected static boolean isAnyGiiInProgress()
```
    Test whether any GII is in progress.
  - waitForAnyGiiToBegin
```
public static void waitForAnyGiiToBegin()
```
    Wait for a getInitialImage in ANY vm to be in progress.
  - waitForAllGiiToComplete
```
protected static void waitForAllGiiToComplete()
```
    Wait for getInitialImage in ALL vms to complete.
  - waitForLocalGiiToBegin
```
protected static void waitForLocalGiiToBegin()
```
    Wait for stats to indicate that a getInitialImage is in progress. Note that this will wait for stats for this VM only.
  - waitForLocalGiiCompleted
```
protected static void waitForLocalGiiCompleted()
```
    Wait for stats to indicate that a getInitialImage has completed. Note that this will wait for stats for this VM only.
  - HydraTask_verifyGII
```
public static void HydraTask_verifyGII()
```

Class InitImageTest

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

testInstance

REGION_NAME

randomValues

numNewKeys

keyIntervals

totalNumKeys

aRegion

createRegionDurationMS

giiDurationMS

sc

sleepMSAfterOps

supportsConcurrentMap

INVALIDATE

LOCAL_INVALIDATE

DESTROY

LOCAL_DESTROY

UPDATE_EXISTING_KEY

GET

ADD_NEW_KEY

PUTALL_NEW_KEY

FIRST_OP

LAST_OP

operations

LOG_INTERVAL_MILLIS

Constructor Detail

InitImageTest

Method Detail

initializeRegion

initializeInstance

initRegion

initInstance

StartTask_initialize

HydraTask_loadRegion

HydraTask_loadRegionWithGets

HydraTask_doOps

HydraTask_doPutAllNewKey

HydraTask_doGetInitImage

HydraTask_doGetInitImageWithoutMonitor

HydraTask_blockedGetRegion

HydraTask_verifyRegionContents

HydraTask_verifyEventCounters

HydraTask_initCache

HydraTask_verifyNonBlocking

HydraTask_doNewKeyGets

HydraTask_doCacheWriterTest

HydraTask_verifyCacheWriterTest

doGetInitImage

blockedGetRegion

loadRegion

loadRegionWithGets

doOps

addNewKey

putAllNewKey

updateExistingKey

localInvalidate

invalidate

localDestroy

destroy

get

doNewKeyGets

doOpsPlusPuts

verifyRegionContents

verifyNonBlocking

verifyEventCounters

verifyCacheWriterTest

checkContainsKey

checkContainsValueForKey

checkValue

checkUpdatedValue

getOp

getCacheLoader

getCacheWriter

getValueToAdd

createObject