MixedRegionViewTest (GemFire XD Java API Documentation)

java.lang.Object
- parReg.tx.MixedRegionViewTest

```
public class MixedRegionViewTest
extends Object
```
Serial execution test with client1 executing TX across Partition and Replicated Regions. Tx thread and non-tx threads verify their view of the cache before and after commit. Event counters (for both Cache and Tx Writers and Listeners are also verified).

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`checkEventCounters`
`protected static String`	`createCallbackPrefix`
`protected static String`	`destroyCallbackPrefix`
`protected boolean`	`initializeTxInfo`
`protected static String`	`invalidateCallbackPrefix`
`protected boolean`	`isProxy`
`protected boolean`	`isSerialExecution`
`protected int`	`maxKeys`
`protected static String`	`memberIdString`
`int`	`modValInitializer`
`protected Integer`	`myVmPid`
`static int`	`NO_REPLICATION_RESTRICTION`
`RandomValues`	`randomValues`
`protected static String`	`regionDestroyCallbackPrefix`
`protected static String`	`regionInvalidateCallbackPrefix`
`protected GsRandom`	`rng`
`static MixedRegionViewTest`	`testInstance`
`protected com.gemstone.gemfire.internal.cache.TXStateInterface`	`txContext`
`protected boolean`	`txInProgress`
`protected HydraThreadLocal`	`txState`
`protected static String`	`updateCallbackPrefix`
`static int`	`USE_PARTITIONED_REGION`
`static int`	`USE_REPLICATED_REGION`
`protected boolean`	`useFunctionExecution`

Constructor Summary

Constructors
Constructor and Description

MixedRegionViewTest()

Constructors
Constructor and Description
`MixedRegionViewTest()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`beginTx()`
`protected void`	`checkCommittedState()`
`protected void`	`checkEventCounters()` Check CacheListener Event Counters
`protected void`	`checkTxEventCounters()` Check TxListener Event Counters
`protected void`	`checkTxWriterCounters()` Check TxWriter Event Counters
`protected void`	`checkWriterCounters()` Check CacheWriter Event Counters
`Operation`	`createEntry(com.gemstone.gemfire.cache.Region aRegion)` Does a creates for a key.
`void`	`createPartitionedRegions()`
`void`	`createRegionHierarchy(String regionConfig)` Create a forest of regions based on numRootRegions, numSubRegions, regionDepth
`Operation`	`destroyEntry(com.gemstone.gemfire.cache.Region aRegion, Object key)` Destroys an entry in aRegion.
`static OpList`	`doOperations()` Do random operations on random regions using the hydra parameter TxPrms.operations as the list of available operations and TxPrms.numOps as the number of operations to do.
`static OpList`	`doOperations(boolean allowGetOperations)` Do random operations on random regions using the hydra parameter TxPrms.operations as the list of available operations and TxPrms.numOps as the number of operations to do.
`OpList`	`doOperations(Vector operations, int numOperationsToDo)` Do random operations on random regions.
`OpList`	`doOperations(Vector operations, int numOperationsToDo, boolean allowGetOperations)` Do random operations on random regions.
`protected void`	`dumpLocalKeys()`
`protected Object`	`executeOp(com.gemstone.gemfire.cache.Region aRegion, String opName, Object key, Object value, String callback)` Execute the specified operation with (key, value) provided on the given region.
`protected void`	`executeTx()`
`protected void`	`finishTx()`
`Operation`	`getEntryWithNewKey(com.gemstone.gemfire.cache.Region aRegion)` Gets a value in aRegion with a the next new (never-before_used) key.
`Operation`	`getEntryWithPreviousKey(com.gemstone.gemfire.cache.Region aRegion)` Gets a value in aRegion with a random key that was previously used in the test.
`protected KeySetResult`	`getKeySet(com.gemstone.gemfire.cache.Region aRegion, com.gemstone.gemfire.distributed.DistributedMember targetDM)`
`Object`	`getNewKey(com.gemstone.gemfire.cache.Region aRegion)` Gets a new (never before seen) key
`Object`	`getNewKeyForPartitionedRegion(com.gemstone.gemfire.cache.Region aRegion)` Gets a new (never before seen) key.
`Object`	`getNewValue(Object key)`
`Object`	`getRandomKey(com.gemstone.gemfire.cache.Region aRegion)` Get a random key from the given region.
`Object`	`getRandomKey(com.gemstone.gemfire.cache.Region aRegion, Object excludeKey)` Get a random key from the given region, excluding the key specified by excludeKey.
`com.gemstone.gemfire.cache.Region`	`getRandomRegion(boolean allowRootRegion)` Return a currently existing random region.
`com.gemstone.gemfire.cache.Region`	`getRandomRegion(boolean allowRootRegion, int restriction)` Return a currently existing random region.
`com.gemstone.gemfire.cache.Region`	`getRandomRegion(boolean allowRootRegion, com.gemstone.gemfire.cache.Region excludeRegion, int restriction)` Return a currently existing random region.
`static long`	`getRoundRobinNumber()` Return the current roundRobin number.
`Set`	`getSubregions(com.gemstone.gemfire.cache.Region aRegion, boolean recursive)` Return a Set of subregions of the given region, while handling regionDestroyedExceptions.
`static MixedRegionViewTest`	`getTestInstance()`
`Object`	`getValueInVM(com.gemstone.gemfire.cache.Region aRegion, Object key)` Call getValueInVM on the given region and key using suspend and resume.
`Operation`	`getWithExistingKey(com.gemstone.gemfire.cache.Region aRegion)` Gets a value in aRegion with a key existing in aRegion.
`static void`	`HydraTask_checkCommittedState()`
`static void`	`HydraTask_createPartitionedRegions()` Create the cache and Partitioned Regions.
`static void`	`HydraTask_createReplicatedRegions()` Hydra task to create a forest of replicated regions.
`static void`	`HydraTask_dumpLocalKeys()` Debug method to see what keys are on each VM at start of test
`static void`	`HydraTask_executeTx()`
`static void`	`HydraTask_populateRegions()`
`void`	`incrementEventCounters(OpList txOpList, int counterType)`
`void`	`initialize()`
`void`	`initialize(String regionConfig)`
`protected void`	`initializeKeySet(boolean useLocalKeySet)` Initialize remote keySet.
`static boolean`	`inTxThreadWithTxInProgress()`
`static boolean`	`inTxVm()`
`Operation`	`invalEntry(com.gemstone.gemfire.cache.Region aRegion, Object key)` Invalidates an entry in aRegion.
`boolean`	`isHierReplicated(com.gemstone.gemfire.cache.Region aRegion)` Return true if the region or any of its subregions is replicated, return false otherwise.
`static void`	`logExecutionNumber()` Log the number of tasks that have been executed in this test.
`static boolean`	`logRoundRobinNumber()` Log the "round" number for this test.
`protected void`	`populateRegions()`
`Operation`	`putEntry(com.gemstone.gemfire.cache.Region aRegion, Object key, BaseValueHolder value, String opName)` Puts a new key/value in the given region.
`protected void`	`registerFunctions()`
`Operation`	`updateEntry(com.gemstone.gemfire.cache.Region aRegion, Object key)` Updates an existing entry in aRegion.
`protected void`	`updateKeySet(Operation op)` Update (per region) keySet Region specific keySets are maintained through each invocation of doOperations().
`protected void`	`validateAllStates(boolean isTxVisible)`
`protected void`	`validateCombinedOpsAfterCommit()`
`protected void`	`validateCombinedOpsAfterRollback()`
`protected void`	`validateCommittedState(boolean txCommitted)`
`protected boolean`	`validateNonTxOps()`
`protected void`	`validateState(OpList opList, boolean isVisible)`
`protected void`	`validateState(OpList opList, boolean isVisible, String txAction)`
`protected boolean`	`validateTxOps(boolean isTxVisible)`
`protected boolean`	`validateTxOps(boolean isTxVisible, String txAction)`

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

- Field Detail
  - testInstance
```
public static MixedRegionViewTest testInstance
```
  - rng
```
protected GsRandom rng
```
  - txInProgress
```
protected boolean txInProgress
```
  - isProxy
```
protected boolean isProxy
```
  - myVmPid
```
protected Integer myVmPid
```
  - initializeTxInfo
```
protected boolean initializeTxInfo
```
  - checkEventCounters
```
protected boolean checkEventCounters
```
  - useFunctionExecution
```
protected boolean useFunctionExecution
```
  - txContext
```
protected com.gemstone.gemfire.internal.cache.TXStateInterface txContext
```
  - randomValues
```
public RandomValues randomValues
```
  - maxKeys
```
protected int maxKeys
```
  - modValInitializer
```
public int modValInitializer
```
  - isSerialExecution
```
protected boolean isSerialExecution
```
  - txState
```
protected HydraThreadLocal txState
```
  - NO_REPLICATION_RESTRICTION
```
public static final int NO_REPLICATION_RESTRICTION
```
    See Also:
    
    Constant Field Values
  - USE_REPLICATED_REGION
```
public static final int USE_REPLICATED_REGION
```
    See Also:
    
    Constant Field Values
  - USE_PARTITIONED_REGION
```
public static final int USE_PARTITIONED_REGION
```
    See Also:
    
    Constant Field Values
  - createCallbackPrefix
```
protected static final String createCallbackPrefix
```
    See Also:
    
    Constant Field Values
  - updateCallbackPrefix
```
protected static final String updateCallbackPrefix
```
    See Also:
    
    Constant Field Values
  - invalidateCallbackPrefix
```
protected static final String invalidateCallbackPrefix
```
    See Also:
    
    Constant Field Values
  - destroyCallbackPrefix
```
protected static final String destroyCallbackPrefix
```
    See Also:
    
    Constant Field Values
  - regionInvalidateCallbackPrefix
```
protected static final String regionInvalidateCallbackPrefix
```
    See Also:
    
    Constant Field Values
  - regionDestroyCallbackPrefix
```
protected static final String regionDestroyCallbackPrefix
```
    See Also:
    
    Constant Field Values
  - memberIdString
```
protected static final String memberIdString
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - MixedRegionViewTest
```
public MixedRegionViewTest()
```
- Method Detail
  - initialize
```
public void initialize()
```
  - initialize
```
public void initialize(String regionConfig)
```
  - getTestInstance
```
public static MixedRegionViewTest getTestInstance()
```
  - HydraTask_createReplicatedRegions
```
public static void HydraTask_createReplicatedRegions()
```
    Hydra task to create a forest of replicated regions. The HydraTask_createPartitionedRegions must be invoked prior to this method.
  - createRegionHierarchy
```
public void createRegionHierarchy(String regionConfig)
```
    Create a forest of regions based on numRootRegions, numSubRegions, regionDepth
  - HydraTask_createPartitionedRegions
```
public static void HydraTask_createPartitionedRegions()
```
    Create the cache and Partitioned Regions.
  - createPartitionedRegions
```
public void createPartitionedRegions()
```
  - HydraTask_populateRegions
```
public static void HydraTask_populateRegions()
```
  - populateRegions
```
protected void populateRegions()
```
  - HydraTask_dumpLocalKeys
```
public static void HydraTask_dumpLocalKeys()
```
    Debug method to see what keys are on each VM at start of test
  - dumpLocalKeys
```
protected void dumpLocalKeys()
```
  - registerFunctions
```
protected void registerFunctions()
```
  - HydraTask_executeTx
```
public static void HydraTask_executeTx()
```
  - executeTx
```
protected void executeTx()
```
  - beginTx
```
protected void beginTx()
```
  - finishTx
```
protected void finishTx()
```
  - validateCommittedState
```
protected void validateCommittedState(boolean txCommitted)
```
  - validateCombinedOpsAfterCommit
```
protected void validateCombinedOpsAfterCommit()
```
  - validateCombinedOpsAfterRollback
```
protected void validateCombinedOpsAfterRollback()
```
  - HydraTask_checkCommittedState
```
public static void HydraTask_checkCommittedState()
```
  - checkCommittedState
```
protected void checkCommittedState()
```
  - validateAllStates
```
protected void validateAllStates(boolean isTxVisible)
```
  - validateNonTxOps
```
protected boolean validateNonTxOps()
```
  - validateTxOps
```
protected boolean validateTxOps(boolean isTxVisible)
```
  - validateTxOps
```
protected boolean validateTxOps(boolean isTxVisible,
                                String txAction)
```
  - validateState
```
protected void validateState(OpList opList,
                             boolean isVisible)
```
  - validateState
```
protected void validateState(OpList opList,
                             boolean isVisible,
                             String txAction)
```
  - checkWriterCounters
```
protected void checkWriterCounters()
```
    Check CacheWriter Event Counters
  - checkTxWriterCounters
```
protected void checkTxWriterCounters()
```
    Check TxWriter Event Counters
  - checkEventCounters
```
protected void checkEventCounters()
```
    Check CacheListener Event Counters
  - checkTxEventCounters
```
protected void checkTxEventCounters()
```
    Check TxListener Event Counters
  - incrementEventCounters
```
public void incrementEventCounters(OpList txOpList,
                                   int counterType)
```
  - logExecutionNumber
```
public static void logExecutionNumber()
```
    Log the number of tasks that have been executed in this test. Useful for debugging/analyzing serial execution tests.
  - logRoundRobinNumber
```
public static boolean logRoundRobinNumber()
```
    Log the "round" number for this test. This is called for serial execution tests that use round-robin scheduling. Each task can call this method and it will remember the first thread in the round, then increment and log a counter each time a new round begins.
  - getRoundRobinNumber
```
public static long getRoundRobinNumber()
```
    Return the current roundRobin number.
  - getRandomRegion
```
public com.gemstone.gemfire.cache.Region getRandomRegion(boolean allowRootRegion)
```
    Return a currently existing random region.
    
    Parameters:
    
    allowRootRegion - true if this call can return the root region, false otherwise.
    
    Returns:
    
    A random region, or null if none available.
  - getRandomRegion
```
public com.gemstone.gemfire.cache.Region getRandomRegion(boolean allowRootRegion,
                                                         int restriction)
```
    Return a currently existing random region.
    
    Parameters:
    
    allowRootRegion - true if this call can return the root region, false otherwise.
    
    restriction - (forces selection of Partitioned vs. Replicated Regions)
    
    Returns:
    
    A random region, or null of none available.
  - getRandomRegion
```
public com.gemstone.gemfire.cache.Region getRandomRegion(boolean allowRootRegion,
                                                         com.gemstone.gemfire.cache.Region excludeRegion,
                                                         int restriction)
```
    Return a currently existing random region.
    
    Parameters:
    
    allowRootRegion - true if this call can return the root region, false otherwise.
    
    excludeRegion - Return a region other than this region, or null if none to exclude.
    
    restriction - Restriction on what region can be returned, for example NO_REPLICATION_RESTRICTION, NO_REPLICATION
    
    Returns:
    
    A random region, or null of none available.
  - doOperations
```
public static OpList doOperations()
```
    Do random operations on random regions using the hydra parameter TxPrms.operations as the list of available operations and TxPrms.numOps as the number of operations to do.
  - doOperations
```
public static OpList doOperations(boolean allowGetOperations)
```
    Do random operations on random regions using the hydra parameter TxPrms.operations as the list of available operations and TxPrms.numOps as the number of operations to do.
    
    Parameters:
    
    allowGetOperations - - to prevent proxy clients from attempting gets (since they have no storage this always invokes the loader and oldValue is always reported as null).
  - doOperations
```
public OpList doOperations(Vector operations,
                           int numOperationsToDo)
```
    Do random operations on random regions.
    
    Parameters:
    
    operations - - a Vector of operations to choose from.
    
    numOperationsToDo - - the number of operations to execute.
  - doOperations
```
public OpList doOperations(Vector operations,
                           int numOperationsToDo,
                           boolean allowGetOperations)
```
    Do random operations on random regions.
    
    Parameters:
    
    operations - - a Vector of operations to choose from.
    
    numOperationsToDo - - the number of operations to execute.
    
    allowGetOperations - - if false, replace entry-get ops with entry-create
  - createEntry
```
public Operation createEntry(com.gemstone.gemfire.cache.Region aRegion)
```
    Does a creates for a key.
    
    Parameters:
    
    aRegion - The region to create the new key in.
    
    Returns:
    
    An instance of Operation describing the create operation.
  - updateEntry
```
public Operation updateEntry(com.gemstone.gemfire.cache.Region aRegion,
                             Object key)
```
    Updates an existing entry in aRegion. The value in the key is increment by 1.
    
    Parameters:
    
    aRegion - The region to modify a key in.
    
    key - The key to modify.
    
    Returns:
    
    An instance of Operation describing the update operation.
  - destroyEntry
```
public Operation destroyEntry(com.gemstone.gemfire.cache.Region aRegion,
                              Object key)
```
    Destroys an entry in aRegion.
    
    Parameters:
    
    aRegion - The region to destroy the entry in.
    
    key - The key to destroy.
    
    Returns:
    
    An instance of Operation describing the destroy operation.
  - invalEntry
```
public Operation invalEntry(com.gemstone.gemfire.cache.Region aRegion,
                            Object key)
```
    Invalidates an entry in aRegion.
    
    Parameters:
    
    aRegion - The region to invalidate the entry in.
    
    key - The key to invalidate.
    
    Returns:
    
    An instance of Operation describing the invalidate operation.
  - getWithExistingKey
```
public Operation getWithExistingKey(com.gemstone.gemfire.cache.Region aRegion)
```
    Gets a value in aRegion with a key existing in aRegion.
    
    Parameters:
    
    aRegion - The region to get from.
    
    Returns:
    
    An instance of Operation describing the get operation.
  - getEntryWithPreviousKey
```
public Operation getEntryWithPreviousKey(com.gemstone.gemfire.cache.Region aRegion)
```
    Gets a value in aRegion with a random key that was previously used in the test.
    
    Parameters:
    
    aRegion - The region to get from.
    
    Returns:
    
    An instance of Operation describing the get operation.
  - getNewKey
```
public Object getNewKey(com.gemstone.gemfire.cache.Region aRegion)
```
    Gets a new (never before seen) key
    
    Returns:
    
    the next key from NameFactory
  - getNewKeyForPartitionedRegion
```
public Object getNewKeyForPartitionedRegion(com.gemstone.gemfire.cache.Region aRegion)
```
    Gets a new (never before seen) key. Invoked by createEntry and getEntryWithNewKey (TxUtil)
    
    Returns:
    
    the next key (with hashCode) for the target VM
  - getEntryWithNewKey
```
public Operation getEntryWithNewKey(com.gemstone.gemfire.cache.Region aRegion)
```
    Gets a value in aRegion with a the next new (never-before_used) key.
    
    Parameters:
    
    aRegion - The region to get from.
    
    Returns:
    
    An instance of Operation describing the get operation.
  - putEntry
```
public Operation putEntry(com.gemstone.gemfire.cache.Region aRegion,
                          Object key,
                          BaseValueHolder value,
                          String opName)
```
    Puts a new key/value in the given region.
    
    Parameters:
    
    aRegion - The region to create the new key in.
    
    key - The key to use for the put.
    
    value - The value to put.
    
    opName - The operation to use for the returned Operation instance.
    
    Returns:
    
    An instance of Operation describing the put operation.
  - getRandomKey
```
public Object getRandomKey(com.gemstone.gemfire.cache.Region aRegion)
```
    Get a random key from the given region. If no keys are present in the region, return null.
    
    Parameters:
    
    aRegion - - The region to get the key from.
  - getRandomKey
```
public Object getRandomKey(com.gemstone.gemfire.cache.Region aRegion,
                           Object excludeKey)
```
    Get a random key from the given region, excluding the key specified by excludeKey. If no keys qualify in the region, return null.
    
    Parameters:
    
    aRegion - - The region to get the key from.
    
    excludeKey - - The region to get the key from.
  - getNewValue
```
public Object getNewValue(Object key)
```
  - inTxThreadWithTxInProgress
```
public static boolean inTxThreadWithTxInProgress()
```
  - inTxVm
```
public static boolean inTxVm()
```
  - isHierReplicated
```
public boolean isHierReplicated(com.gemstone.gemfire.cache.Region aRegion)
```
    Return true if the region or any of its subregions is replicated, return false otherwise.
    
    Parameters:
    
    aRegion - The region parent to test for replication.
  - getSubregions
```
public Set getSubregions(com.gemstone.gemfire.cache.Region aRegion,
                         boolean recursive)
```
    Return a Set of subregions of the given region, while handling regionDestroyedExceptions.
    
    Parameters:
    
    aRegion - - The region to get subregions of.
    
    recursive - - If true, return all subregions, otherwise only aRegion's subregions.
  - getValueInVM
```
public Object getValueInVM(com.gemstone.gemfire.cache.Region aRegion,
                           Object key)
```
    Call getValueInVM on the given region and key using suspend and resume.
    
    Parameters:
    
    aRegion - - The region to use for the call.
    
    key - - The key to use for the call.
  - initializeKeySet
```
protected void initializeKeySet(boolean useLocalKeySet)
```
    Initialize remote keySet. Writes a KeySetResult (with DistributedMember and keySet) to PrTxBB. getRandomKey() relies upon this (to select colocated entries on a single remote VM). getNewKey() also relies on this (so it can determine the correct hashCode required for a new entry on the remote VM).
  - getKeySet
```
protected KeySetResult getKeySet(com.gemstone.gemfire.cache.Region aRegion,
                                 com.gemstone.gemfire.distributed.DistributedMember targetDM)
```
  - updateKeySet
```
protected void updateKeySet(Operation op)
```
    Update (per region) keySet Region specific keySets are maintained through each invocation of doOperations(). They are initialized at the beginning, but keys need to be removed on entryDestroy and added on entryCreate. We don't have a test hook to look at the TxState (vs. committed state). This does nothing if the region is replicated (vs. partitioned).
  - executeOp
```
protected Object executeOp(com.gemstone.gemfire.cache.Region aRegion,
                           String opName,
                           Object key,
                           Object value,
                           String callback)
```
    Execute the specified operation with (key, value) provided on the given region.

Class MixedRegionViewTest

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

testInstance

rng

txInProgress

isProxy

myVmPid

initializeTxInfo

checkEventCounters

useFunctionExecution

txContext

randomValues

maxKeys

modValInitializer

isSerialExecution

txState

NO_REPLICATION_RESTRICTION

USE_REPLICATED_REGION

USE_PARTITIONED_REGION

createCallbackPrefix

updateCallbackPrefix

invalidateCallbackPrefix

destroyCallbackPrefix

regionInvalidateCallbackPrefix

regionDestroyCallbackPrefix

memberIdString

Constructor Detail

MixedRegionViewTest

Method Detail

initialize

initialize

getTestInstance

HydraTask_createReplicatedRegions

createRegionHierarchy

HydraTask_createPartitionedRegions

createPartitionedRegions

HydraTask_populateRegions

populateRegions

HydraTask_dumpLocalKeys

dumpLocalKeys

registerFunctions

HydraTask_executeTx

executeTx

beginTx

finishTx

validateCommittedState

validateCombinedOpsAfterCommit

validateCombinedOpsAfterRollback

HydraTask_checkCommittedState

checkCommittedState

validateAllStates

validateNonTxOps

validateTxOps

validateTxOps

validateState

validateState

checkWriterCounters

checkTxWriterCounters

checkEventCounters

checkTxEventCounters

incrementEventCounters

logExecutionNumber

logRoundRobinNumber

getRoundRobinNumber

getRandomRegion

getRandomRegion

getRandomRegion

doOperations

doOperations

doOperations

doOperations

createEntry

updateEntry

destroyEntry

invalEntry

getWithExistingKey