Spring/spring-data-geode
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Implements SGF-88 - Region Shortcuts; Implements SGF-257 - Strict types in the SDG XSD for Region data-policy and shortcut attributes; Fixes SGF-258 - missing data-policy attribute for Partitioned Regions; Fixes SGF-263 - ineffective application of disk-synchronous attribute setting on Region bean definitions defined with SDG XML namespace.

Browse Source
This commit is contained in:
John Blum
2014-03-21 00:32:45 -07:00
parent 942c5ca7be
commit 1594c5f062
30 changed files with 2747 additions and 402 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
src/test/java/org/springframework/data/gemfire/InvalidRegionDataPolicyShortcutsTest.java Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2010-2013 the original author or authors.
*
* Licensed 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.springframework.data.gemfire;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.parsing.BeanDefinitionParsingException;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* The InvalidRegionDataPolicyShortcutsIntegrationTest class is a test suite of test cases testing and setting up
* some invalid, or illegal uses of the Region data-policy and/or shortcut XML namespace attributes.
* <p/>
* @author John Blum
* @see org.junit.Test
* @since 1.4.0
*/
public class InvalidRegionDataPolicyShortcutsTest {
@Test(expected = BeanCreationException.class)
public void testInvalidRegionShortcutWithPersistentAttribute() {
try {
new ClassPathXmlApplicationContext(
"/org/springframework/data/gemfire/invalid-region-shortcut-with-persistent-attribute.xml");
}
catch (BeanCreationException expected) {
//expected.printStackTrace(System.err);
assertTrue(expected.getMessage().contains("Error creating bean with name 'InvalidReplicate'"));
throw expected;
}
}
@Test(expected = BeanDefinitionParsingException.class)
public void testInvalidUseOfRegionDataPolicyAndShortcut() {
try {
new ClassPathXmlApplicationContext(
"/org/springframework/data/gemfire/invalid-use-of-region-datapolicy-and-shortcut.xml");
}
catch (BeanDefinitionParsingException expected) {
//expected.printStackTrace(System.err);
assertTrue(expected.getMessage().contains(
"Only one of [data-policy, shortcut] may be specified with element 'gfe:partitioned-region'"));
throw expected;
}
}
}

147
src/test/java/org/springframework/data/gemfire/LocalRegionFactoryBeanTest.java
View File

@@ -13,6 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire;
import static org.junit.Assert.assertEquals;
@@ -28,11 +29,13 @@ import org.springframework.data.gemfire.support.AbstractRegionFactoryBeanTest;
import com.gemstone.gemfire.cache.DataPolicy;
import com.gemstone.gemfire.cache.Region;
import com.gemstone.gemfire.cache.RegionFactory;
import com.gemstone.gemfire.cache.RegionShortcut;
/**
* The PartitionedRegionFactoryBeanTest class is a test suite of test cases testing the component functionality
* and correct behavior of the PartitionedRegionFactoryBean class.
* <p/>
*
* @author David Turanski
* @author John Blum
* @see org.mockito.Mockito
@@ -49,31 +52,31 @@ public class LocalRegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
private RegionFactoryBeanConfig defaultConfig() {
return new RegionFactoryBeanConfig(new LocalRegionFactoryBean(), "default") {
@Override
public void configureRegionFactoryBean() {
}
@Override
public void verify() {
Region region = regionFactoryBean.getRegion();
assertNotNull(region);
assertEquals(DataPolicy.DEFAULT, region.getAttributes().getDataPolicy());
}
@Override
public void configureRegionFactoryBean() {
}
};
}
@SuppressWarnings("rawtypes")
@SuppressWarnings({ "deprecation", "rawtypes" })
private RegionFactoryBeanConfig invalidConfig() {
return new RegionFactoryBeanConfig(new LocalRegionFactoryBean(), "local-replicate") {
@Override
public void verify() {
assertNotNull(this.exception);
public void configureRegionFactoryBean() {
regionFactoryBean.setDataPolicy("replicate");
}
@Override
public void configureRegionFactoryBean() {
regionFactoryBean.setDataPolicy("replicate");
public void verify() {
assertNotNull(this.exception);
}
};
}
@@ -88,6 +91,67 @@ public class LocalRegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
return mock(RegionFactory.class);
}
@Test
public void testResolveDataPolicyWhenPersistentUnspecifiedAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, (String) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.NORMAL));
}
@Test
public void testResolveDataPolicyWhenNotPersistentAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, (String) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.NORMAL));
}
@Test
public void testResolveDataPolicyWhenPersistentAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, (String) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithBlankDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.resolveDataPolicy(mockRegionFactory, null, " ");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy ' ' is invalid.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.NORMAL));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PRELOADED));
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithEmptyDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.resolveDataPolicy(mockRegionFactory, null, "");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy '' is invalid.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.NORMAL));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PRELOADED));
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithInvalidDataPolicyName() {
RegionFactory mockRegionFactory = createMockRegionFactory();
@@ -108,14 +172,14 @@ public class LocalRegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithInvalidDataPolicyRegionType() {
public void testResolveDataPolicyWithInvalidDataPolicyType() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.resolveDataPolicy(mockRegionFactory, null, "PARTITION");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy 'PARTITION' is not supported in Local Regions.", e.getMessage());
assertEquals("Data Policy 'PARTITION' is not supported for Local Regions.", e.getMessage());
throw e;
}
finally {
@@ -127,14 +191,7 @@ public class LocalRegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
}
@Test
public void testResolveDataPolicyWithPersistentUnspecifiedAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.NORMAL));
}
@Test
public void testResolveDataPolicyWithPersistentUnspecifiedAndNormalDataPolicy() {
public void testResolveDataPolicyWhenPersistentUnspecifiedAndNormalDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, "Normal");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.NORMAL));
@@ -157,7 +214,7 @@ public class LocalRegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
}
@Test
public void testResolveDataPolicyWithPersistentUnspecifiedAndPreloadedDataPolicy() {
public void testResolveDataPolicyWhenPersistentUnspecifiedAndPreloadedDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, "preloaded");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PRELOADED));
@@ -179,4 +236,54 @@ public class LocalRegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenShortcutIsNullAndPersistentReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setShortcut(null);
factoryBean.resolveDataPolicy(mockRegionFactory, null, DataPolicy.PERSISTENT_REPLICATE);
}
catch (IllegalArgumentException expected) {
assertEquals("Data Policy 'PERSISTENT_REPLICATE' is not supported for Local Regions.",
expected.getMessage());
throw expected;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(DataPolicy.NORMAL);
verify(mockRegionFactory, never()).setDataPolicy(DataPolicy.PRELOADED);
verify(mockRegionFactory, never()).setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenShortcutNotPersistentAndPersistentReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setShortcut(RegionShortcut.LOCAL_OVERFLOW);
factoryBean.resolveDataPolicy(mockRegionFactory, true, DataPolicy.PERSISTENT_REPLICATE);
}
catch (IllegalArgumentException expected) {
assertEquals("Data Policy 'PERSISTENT_REPLICATE' is not supported for Local Regions.",
expected.getMessage());
throw expected;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(DataPolicy.NORMAL);
verify(mockRegionFactory, never()).setDataPolicy(DataPolicy.PRELOADED);
verify(mockRegionFactory, never()).setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
}
}
@Test
public void testResolveDataPolicyWhenPersistentPersistentReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setShortcut(RegionShortcut.LOCAL_PERSISTENT_OVERFLOW);
factoryBean.resolveDataPolicy(mockRegionFactory, false, DataPolicy.PERSISTENT_REPLICATE);
verify(mockRegionFactory).setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
}
}

155
src/test/java/org/springframework/data/gemfire/PartitionedRegionFactoryBeanTest.java
View File

@@ -32,9 +32,11 @@ import com.gemstone.gemfire.cache.RegionFactory;
* and correct behavior of the PartitionedRegionFactoryBean class.
* <p/>
* @author John Blum
* @see org.mockito.Mockito
* @see org.junit.Test
* @see org.mockito.Mockito
* @see org.springframework.data.gemfire.PartitionedRegionFactoryBean
* @see com.gemstone.gemfire.cache.DataPolicy
* @see com.gemstone.gemfire.cache.RegionFactory
* @since 1.3.3
*/
@SuppressWarnings("unchecked")
@@ -46,6 +48,67 @@ public class PartitionedRegionFactoryBeanTest {
return mock(RegionFactory.class);
}
@Test
public void testResolveDataPolicyWithPersistentUnspecifiedAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, (String) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PARTITION));
}
@Test
public void testResolveDataPolicyWhenNotPersistentAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, (String) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PARTITION));
}
@Test
public void testResolveDataPolicyWhenPersistentAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, (String) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_PARTITION));
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithBlankDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.resolveDataPolicy(mockRegionFactory, null, " ");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy ' ' is invalid.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.NORMAL));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PRELOADED));
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithEmptyDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.resolveDataPolicy(mockRegionFactory, null, "");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy '' is invalid.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.NORMAL));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PRELOADED));
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithInvalidDataPolicyName() {
RegionFactory mockRegionFactory = createMockRegionFactory();
@@ -59,11 +122,13 @@ public class PartitionedRegionFactoryBeanTest {
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PARTITION));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_PARTITION));
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithInvalidDataPolicyRegionType() {
public void testResolveDataPolicyWithInvalidDataPolicyType() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
@@ -74,49 +139,22 @@ public class PartitionedRegionFactoryBeanTest {
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.REPLICATE));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PARTITION));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_PARTITION));
}
}
@Test
public void testResolveDataPolicyWithPersistentUnspecifiedAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PARTITION));
}
@Test
public void testResolveDataPolicyWithPersistentUnspecifiedAndPartitionedDataPolicy() {
public void testResolveDataPolicyWhenPersistentUnspecifiedAndPartitionDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, "PARTITION");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PARTITION));
}
@Test
public void testResolveDataPolicyWithPersistentUnspecifiedAndPersistentPartitionedDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, "PERSISTENT_PARTITION");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_PARTITION));
}
@Test
public void testResolveDataPolicyWithPersistentFalseAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PARTITION));
}
@Test
public void testResolveDataPolicyWithPersistentTrueAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_PARTITION));
}
@Test
public void testResolveDataPolicyWithPersistentFalseAndPartitionedDataPolicy() {
public void testResolveDataPolicyWhenNotPersistentAndPartitionDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, "PARTITION");
@@ -124,24 +162,7 @@ public class PartitionedRegionFactoryBeanTest {
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithPersistentFalseAndPersistentPartitionedDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, "PERSISTENT_PARTITION");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy 'PERSISTENT_PARTITION' is invalid when persistent is false.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_PARTITION));
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithPersistentTrueAndPartitionedDataPolicy() {
public void testResolveDataPolicyWhenPersistentAndPartitionDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
@@ -153,12 +174,40 @@ public class PartitionedRegionFactoryBeanTest {
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PARTITION));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_PARTITION));
}
}
@Test
public void testResolveDataPolicyWithPersistentTrueAndPersistentPartitionedDataPolicy() {
public void testResolveDataPolicyWhenPersistentUnspecifiedAndPersistentPartitionDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, "PERSISTENT_PARTITION");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_PARTITION));
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenNotPersistentAndPersistentPartitionedDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, "PERSISTENT_PARTITION");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy 'PERSISTENT_PARTITION' is invalid when persistent is false.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PARTITION));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_PARTITION));
}
}
@Test
public void testResolveDataPolicyWhenPersistentAndPersistentPartitionedDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, "PERSISTENT_PARTITION");

183
src/test/java/org/springframework/data/gemfire/RegionDataPolicyShortcutsIntegrationTest.java Normal file
View File

@@ -0,0 +1,183 @@
/*
* Copyright 2010-2013 the original author or authors.
*
* Licensed 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.springframework.data.gemfire;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.gemstone.gemfire.cache.DataPolicy;
import com.gemstone.gemfire.cache.EvictionAction;
import com.gemstone.gemfire.cache.EvictionAlgorithm;
import com.gemstone.gemfire.cache.Region;
/**
* The RegionShortcutsIntegrationTest class is a test suite of test cases testing the use of RegionShortcuts in the
* Spring Data GemFire XML Namespace!
* <p/>
* @author John Blum
* @see org.junit.Test
* @see org.junit.runner.RunWith
* @see org.springframework.test.context.ContextConfiguration
* @see org.springframework.test.context.junit4.SpringJUnit4ClassRunner
* @see com.gemstone.gemfire.cache.Region
* @since 1.4.0
*/
@ContextConfiguration("region-datapolicy-shortcuts.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class RegionDataPolicyShortcutsIntegrationTest {
@Resource(name = "LocalWithDataPolicy")
private Region localWithDataPolicy;
@Resource(name = "LocalWithShortcut")
private Region localWithShortcut;
@Resource(name = "PartitionWithDataPolicy")
private Region partitionWithDataPolicy;
@Resource(name = "PartitionWithShortcut")
private Region partitionWithShortcut;
@Resource(name = "ReplicateWithDataPolicy")
private Region replicateWithDataPolicy;
@Resource(name = "ReplicateWithShortcut")
private Region replicateWithShortcut;
@Resource(name = "ShortcutDefaults")
private Region shortcutDefaults;
@Resource(name = "ShortcutOverrides")
private Region shortcutOverrides;
@Test
public void testLocalRegionWithDataPolicy() {
assertNotNull("A reference to the 'LocalWithDataPolicy' Region was not property configured!", localWithDataPolicy);
assertEquals("LocalWithDataPolicy", localWithDataPolicy.getName());
assertEquals("/LocalWithDataPolicy", localWithDataPolicy.getFullPath());
assertNotNull(localWithDataPolicy.getAttributes());
assertEquals(DataPolicy.NORMAL, localWithDataPolicy.getAttributes().getDataPolicy());
}
@Test
public void testLocalRegionWithShortcut() {
assertNotNull("A reference to the 'LocalWithShortcut' Region was not property configured!", localWithShortcut);
assertEquals("LocalWithShortcut", localWithShortcut.getName());
assertEquals("/LocalWithShortcut", localWithShortcut.getFullPath());
assertNotNull(localWithShortcut.getAttributes());
assertEquals(DataPolicy.PERSISTENT_REPLICATE, localWithShortcut.getAttributes().getDataPolicy());
}
@Test
public void testPartitionRegionWithDataPolicy() {
assertNotNull("A reference to the 'PartitionWithDataPolicy' Region was not property configured!", partitionWithDataPolicy);
assertEquals("PartitionWithDataPolicy", partitionWithDataPolicy.getName());
assertEquals("/PartitionWithDataPolicy", partitionWithDataPolicy.getFullPath());
assertNotNull(partitionWithDataPolicy.getAttributes());
assertEquals(DataPolicy.PARTITION, partitionWithDataPolicy.getAttributes().getDataPolicy());
}
@Test
public void testPartitionRegionWithShortcut() {
assertNotNull("A reference to the 'PartitionWithShortcut' Region was not property configured!", partitionWithShortcut);
assertEquals("PartitionWithShortcut", partitionWithShortcut.getName());
assertEquals("/PartitionWithShortcut", partitionWithShortcut.getFullPath());
assertNotNull(partitionWithShortcut.getAttributes());
assertEquals(DataPolicy.PERSISTENT_PARTITION, partitionWithShortcut.getAttributes().getDataPolicy());
}
@Test
public void testReplicateRegionWithDataPolicy() {
assertNotNull("A reference to the 'ReplicateWithDataPolicy' Region was not property configured!", replicateWithDataPolicy);
assertEquals("ReplicateWithDataPolicy", replicateWithDataPolicy.getName());
assertEquals("/ReplicateWithDataPolicy", replicateWithDataPolicy.getFullPath());
assertNotNull(replicateWithDataPolicy.getAttributes());
assertEquals(DataPolicy.REPLICATE, replicateWithDataPolicy.getAttributes().getDataPolicy());
}
@Test
public void testReplicateRegionWithShortcut() {
assertNotNull("A reference to the 'ReplicateWithShortcut' Region was not property configured!", replicateWithShortcut);
assertEquals("ReplicateWithShortcut", replicateWithShortcut.getName());
assertEquals("/ReplicateWithShortcut", replicateWithShortcut.getFullPath());
assertNotNull(replicateWithShortcut.getAttributes());
assertEquals(DataPolicy.PERSISTENT_REPLICATE, replicateWithShortcut.getAttributes().getDataPolicy());
}
@Test
public void testShortcutDefaultsRegion() {
assertNotNull("A reference to the 'ShortcutDefaults' Region was not properly configured!", shortcutDefaults);
assertEquals("ShortcutDefaults", shortcutDefaults.getName());
assertEquals("/ShortcutDefaults", shortcutDefaults.getFullPath());
assertNotNull(shortcutDefaults.getAttributes());
assertFalse(shortcutDefaults.getAttributes().getCloningEnabled());
assertTrue(shortcutDefaults.getAttributes().getConcurrencyChecksEnabled());
assertEquals(DataPolicy.PERSISTENT_PARTITION, shortcutDefaults.getAttributes().getDataPolicy());
assertFalse(shortcutDefaults.getAttributes().isDiskSynchronous());
assertTrue(shortcutDefaults.getAttributes().getIgnoreJTA());
assertEquals(101, shortcutDefaults.getAttributes().getInitialCapacity());
assertEquals(new Float(0.85f), new Float(shortcutDefaults.getAttributes().getLoadFactor()));
assertEquals(Long.class, shortcutDefaults.getAttributes().getKeyConstraint());
assertEquals(String.class, shortcutDefaults.getAttributes().getValueConstraint());
assertNotNull(shortcutDefaults.getAttributes().getEvictionAttributes());
assertEquals(EvictionAction.OVERFLOW_TO_DISK, shortcutDefaults.getAttributes().getEvictionAttributes().getAction());
assertEquals(EvictionAlgorithm.LRU_HEAP, shortcutDefaults.getAttributes().getEvictionAttributes().getAlgorithm());
assertNotNull(shortcutDefaults.getAttributes().getPartitionAttributes());
assertEquals(1, shortcutDefaults.getAttributes().getPartitionAttributes().getRedundantCopies());
assertEquals(177, shortcutDefaults.getAttributes().getPartitionAttributes().getTotalNumBuckets());
}
@Test
public void testShortcutOverridesRegion() {
assertNotNull("A reference to the 'ShortcutOverrides' Region was not properly configured!", shortcutOverrides);
assertEquals("ShortcutOverrides", shortcutOverrides.getName());
assertEquals("/ShortcutOverrides", shortcutOverrides.getFullPath());
assertNotNull(shortcutOverrides.getAttributes());
assertTrue(shortcutOverrides.getAttributes().getCloningEnabled());
assertFalse(shortcutOverrides.getAttributes().getConcurrencyChecksEnabled());
assertEquals(DataPolicy.PARTITION, shortcutOverrides.getAttributes().getDataPolicy());
assertTrue(shortcutOverrides.getAttributes().isDiskSynchronous());
assertFalse(shortcutOverrides.getAttributes().getIgnoreJTA());
assertEquals(51, shortcutOverrides.getAttributes().getInitialCapacity());
assertEquals(new Float(0.72f), new Float(shortcutOverrides.getAttributes().getLoadFactor()));
assertEquals(String.class, shortcutOverrides.getAttributes().getKeyConstraint());
assertEquals(Object.class, shortcutOverrides.getAttributes().getValueConstraint());
assertNotNull(shortcutOverrides.getAttributes().getEvictionAttributes());
assertEquals(EvictionAction.LOCAL_DESTROY, shortcutOverrides.getAttributes().getEvictionAttributes().getAction());
assertEquals(8192, shortcutOverrides.getAttributes().getEvictionAttributes().getMaximum());
assertEquals(EvictionAlgorithm.LRU_ENTRY, shortcutOverrides.getAttributes().getEvictionAttributes().getAlgorithm());
assertNotNull(shortcutOverrides.getAttributes().getPartitionAttributes());
assertEquals(3, shortcutOverrides.getAttributes().getPartitionAttributes().getRedundantCopies());
assertEquals(111, shortcutOverrides.getAttributes().getPartitionAttributes().getTotalNumBuckets());
}
}

796
src/test/java/org/springframework/data/gemfire/RegionFactoryBeanTest.java
View File

@@ -16,28 +16,68 @@
package org.springframework.data.gemfire;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.same;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.After;
import org.junit.Test;
import org.springframework.data.gemfire.support.AbstractRegionFactoryBeanTest;
import com.gemstone.gemfire.cache.Cache;
import com.gemstone.gemfire.cache.CustomExpiry;
import com.gemstone.gemfire.cache.DataPolicy;
import com.gemstone.gemfire.cache.EvictionAttributes;
import com.gemstone.gemfire.cache.ExpirationAction;
import com.gemstone.gemfire.cache.ExpirationAttributes;
import com.gemstone.gemfire.cache.MembershipAttributes;
import com.gemstone.gemfire.cache.PartitionAttributes;
import com.gemstone.gemfire.cache.Region;
import com.gemstone.gemfire.cache.RegionAttributes;
import com.gemstone.gemfire.cache.RegionFactory;
import com.gemstone.gemfire.cache.RegionShortcut;
import com.gemstone.gemfire.cache.SubscriptionAttributes;
import com.gemstone.gemfire.internal.cache.GemFireCacheImpl;
/**
* The RegionFactoryBeanTest class is a test suite of test cases testing the contract and functionality of the
* RegionFactoryBean class.
* <p/>
* @author David Turanski
* @author John Blum
* @see org.springframework.data.gemfire.RegionFactoryBean
* @see com.gemstone.gemfire.cache.Cache
* @see com.gemstone.gemfire.cache.DataPolicy
* @see com.gemstone.gemfire.cache.PartitionAttributes
* @see com.gemstone.gemfire.cache.Region
* @see com.gemstone.gemfire.cache.RegionAttributes
* @see com.gemstone.gemfire.cache.RegionFactory
* @see com.gemstone.gemfire.cache.RegionShortcut
*/
@SuppressWarnings("unchecked")
public class RegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
private final RegionFactoryBean factoryBean = new RegionFactoryBean();
@After
public void tearDown() {
factoryBean.setDataPolicy((DataPolicy) null);
factoryBean.setShortcut(null);
}
@SuppressWarnings("rawtypes")
private RegionFactoryBeanConfig defaultConfig() {
return new RegionFactoryBeanConfig(new RegionFactoryBean(), "default") {
@@ -50,14 +90,13 @@ public class RegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
@Override
public void configureRegionFactoryBean() {
// TODO Auto-generated method stub
}
};
}
@SuppressWarnings("rawtypes")
private RegionFactoryBeanConfig persistent() {
private RegionFactoryBeanConfig persistentConfig() {
return new RegionFactoryBeanConfig(new RegionFactoryBean(), "persistent") {
@Override
@@ -73,8 +112,8 @@ public class RegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
};
}
@SuppressWarnings("rawtypes")
private RegionFactoryBeanConfig invalidPersistence() {
@SuppressWarnings({ "deprecation", "rawtypes" })
private RegionFactoryBeanConfig invalidPersistentConfig() {
return new RegionFactoryBeanConfig(new RegionFactoryBean(), "invalid-persistence") {
@Override
@@ -95,18 +134,561 @@ public class RegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
@Override
protected void createRegionFactoryBeanConfigs() {
addRFBConfig(defaultConfig());
addRFBConfig(persistent());
addRFBConfig(invalidPersistence());
addRFBConfig(persistentConfig());
addRFBConfig(invalidPersistentConfig());
}
protected PartitionAttributes createPartitionAttributes(final String colocatedWith, final int localMaxMemory,
final long recoveryDelay, final int redundantCopies, final long startupRecoveryDelay,
final long totalMaxMemory, final int totalNumberOfBuckets) throws Exception {
PartitionAttributesFactoryBean partitionAttributesFactoryBean = new PartitionAttributesFactoryBean();
partitionAttributesFactoryBean.setColocatedWith(colocatedWith);
partitionAttributesFactoryBean.setLocalMaxMemory(localMaxMemory);
partitionAttributesFactoryBean.setRecoveryDelay(recoveryDelay);
partitionAttributesFactoryBean.setRedundantCopies(redundantCopies);
partitionAttributesFactoryBean.setStartupRecoveryDelay(startupRecoveryDelay);
partitionAttributesFactoryBean.setTotalMaxMemory(totalMaxMemory);
partitionAttributesFactoryBean.setTotalNumBuckets(totalNumberOfBuckets);
partitionAttributesFactoryBean.afterPropertiesSet();
return partitionAttributesFactoryBean.getObject();
}
protected RegionFactory<?, ?> createMockRegionFactory() {
return mock(RegionFactory.class);
}
protected RegionFactory<?, ?> createTestRegionFactory() {
return new TestRegionFactory();
}
@Test
public void testResolveDataPolicyWithPersistentUnspecifiedAndDataPolicyUnspecified() {
public void testAssertDataPolicyAndPersistentAttributesAreCompatible() {
RegionFactoryBean<?, ?> factoryBean = new RegionFactoryBean<Object, Object>();
factoryBean.setPersistent(null);
factoryBean.assertDataPolicyAndPersistentAttributesAreCompatible(DataPolicy.PARTITION);
factoryBean.assertDataPolicyAndPersistentAttributesAreCompatible(DataPolicy.REPLICATE);
factoryBean.assertDataPolicyAndPersistentAttributesAreCompatible(DataPolicy.PERSISTENT_PARTITION);
factoryBean.assertDataPolicyAndPersistentAttributesAreCompatible(DataPolicy.PERSISTENT_REPLICATE);
factoryBean.setPersistent(false);
factoryBean.assertDataPolicyAndPersistentAttributesAreCompatible(DataPolicy.PARTITION);
factoryBean.assertDataPolicyAndPersistentAttributesAreCompatible(DataPolicy.REPLICATE);
factoryBean.setPersistent(true);
factoryBean.assertDataPolicyAndPersistentAttributesAreCompatible(DataPolicy.PERSISTENT_PARTITION);
factoryBean.assertDataPolicyAndPersistentAttributesAreCompatible(DataPolicy.PERSISTENT_REPLICATE);
}
@Test(expected = IllegalArgumentException.class)
public void testAssertNonPersistentDataPolicyWithPersistentAttribute() {
try {
RegionFactoryBean<?, ?> factoryBean = new RegionFactoryBean<Object, Object>();
factoryBean.setPersistent(true);
factoryBean.assertDataPolicyAndPersistentAttributesAreCompatible(DataPolicy.REPLICATE);
}
catch (IllegalArgumentException expected) {
assertEquals("Data Policy 'REPLICATE' is invalid when persistent is true.", expected.getMessage());
throw expected;
}
}
@Test(expected = IllegalArgumentException.class)
public void testAssertPersistentDataPolicyWithNotPersistentAttribute() {
try {
RegionFactoryBean<?, ?> factoryBean = new RegionFactoryBean<Object, Object>();
factoryBean.setPersistent(false);
factoryBean.assertDataPolicyAndPersistentAttributesAreCompatible(DataPolicy.PERSISTENT_PARTITION);
}
catch (IllegalArgumentException expected) {
assertEquals("Data Policy 'PERSISTENT_PARTITION' is invalid when persistent is false.",
expected.getMessage());
throw expected;
}
}
@Test
public void testIsPersistentUnspecified() {
RegionFactoryBean<?, ?> factoryBean = new RegionFactoryBean<Object, Object>();
assertTrue(factoryBean.isPersistentUnspecified());
factoryBean.setPersistent(false);
assertFalse(factoryBean.isPersistentUnspecified());
factoryBean.setPersistent(true);
assertFalse(factoryBean.isPersistentUnspecified());
}
@Test
public void testIsPersistent() {
RegionFactoryBean<?, ?> factoryBean = new RegionFactoryBean<Object, Object>();
assertFalse(factoryBean.isPersistent());
factoryBean.setPersistent(false);
assertFalse(factoryBean.isPersistent());
factoryBean.setPersistent(true);
assertTrue(factoryBean.isPersistent());
}
@Test
public void testIsNotPersistent() {
RegionFactoryBean<?, ?> factoryBean = new RegionFactoryBean<Object, Object>();
assertFalse(factoryBean.isNotPersistent());
factoryBean.setPersistent(true);
assertFalse(factoryBean.isNotPersistent());
factoryBean.setPersistent(false);
assertTrue(factoryBean.isNotPersistent());
}
@Test
public void testCreateRegionFactoryWithShortcut() {
Cache mockCache = mock(Cache.class);
RegionAttributes mockRegionAttributes = mock(RegionAttributes.class);
final RegionFactory mockRegionFactory = createMockRegionFactory();
when(mockCache.createRegionFactory(eq(RegionShortcut.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW)))
.thenReturn(mockRegionFactory);
final AtomicBoolean setDataPolicyCalled = new AtomicBoolean(false);
RegionFactoryBean factoryBean = new RegionFactoryBean() {
@Override
DataPolicy getDataPolicy(final RegionFactory regionFactory) {
return DataPolicy.PERSISTENT_PARTITION;
}
@Override
public void setDataPolicy(final DataPolicy dataPolicy) {
assertEquals(DataPolicy.PERSISTENT_PARTITION, dataPolicy);
super.setDataPolicy(dataPolicy);
setDataPolicyCalled.set(true);
}
@Override
protected RegionFactory mergeRegionAttributes(RegionFactory regionFactory, RegionAttributes regionAttributes) {
return mockRegionFactory;
}
};
factoryBean.setAttributes(mockRegionAttributes);
factoryBean.setShortcut(RegionShortcut.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW);
assertSame(mockRegionFactory, factoryBean.createRegionFactory(mockCache));
assertTrue(setDataPolicyCalled.get());
verify(mockCache).createRegionFactory(eq(RegionShortcut.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW));
}
@Test
public void testCreateRegionFactoryWithAttributes() {
Cache mockCache = mock(Cache.class);
RegionAttributes mockRegionAttributes = mock(RegionAttributes.class);
final RegionFactory mockRegionFactory = createMockRegionFactory();
when(mockCache.createRegionFactory(eq(mockRegionAttributes))).thenReturn(mockRegionFactory);
RegionFactoryBean factoryBean = new RegionFactoryBean() {
@Override
protected RegionFactory mergeRegionAttributes(RegionFactory regionFactory, RegionAttributes regionAttributes) {
return mockRegionFactory;
}
};
factoryBean.setAttributes(mockRegionAttributes);
factoryBean.setShortcut(null);
assertSame(mockRegionFactory, factoryBean.createRegionFactory(mockCache));
verify(mockCache).createRegionFactory(eq(mockRegionAttributes));
}
@Test
public void testCreateRegionFactory() {
Cache mockCache = mock(Cache.class);
final RegionFactory mockRegionFactory = createMockRegionFactory();
when(mockCache.createRegionFactory()).thenReturn(mockRegionFactory);
RegionFactoryBean factoryBean = new RegionFactoryBean() {
@Override
protected RegionFactory mergeRegionAttributes(RegionFactory regionFactory, RegionAttributes regionAttributes) {
return mockRegionFactory;
}
};
factoryBean.setAttributes(null);
factoryBean.setShortcut(null);
assertSame(mockRegionFactory, factoryBean.createRegionFactory(mockCache));
verify(mockCache).createRegionFactory();
}
@Test
public void testMergeRegionAttributes() throws Exception {
EvictionAttributes testEvictionAttributes = EvictionAttributes.createLRUEntryAttributes();
ExpirationAttributes testExpirationAttributes = new ExpirationAttributes(120, ExpirationAction.LOCAL_DESTROY);
MembershipAttributes testMembershipAttributes = new MembershipAttributes();
PartitionAttributes testPartitionAttributes = createPartitionAttributes("TestRegion", 1024000, 15000l, 0,
45000l, 2048000000l, 97);
SubscriptionAttributes testSubscriptionAttributes = new SubscriptionAttributes();
RegionAttributes mockRegionAttributes = mock(RegionAttributes.class);
RegionFactory<Long, String> mockRegionFactory = (RegionFactory<Long, String>) createMockRegionFactory();
when(mockRegionAttributes.getCloningEnabled()).thenReturn(false);
when(mockRegionAttributes.getConcurrencyChecksEnabled()).thenReturn(true);
when(mockRegionAttributes.getConcurrencyLevel()).thenReturn(51);
when(mockRegionAttributes.getCustomEntryIdleTimeout()).thenReturn(null);
when(mockRegionAttributes.getCustomEntryTimeToLive()).thenReturn(null);
when(mockRegionAttributes.isDiskSynchronous()).thenReturn(true);
when(mockRegionAttributes.getEnableAsyncConflation()).thenReturn(false);
when(mockRegionAttributes.getEnableSubscriptionConflation()).thenReturn(false);
when(mockRegionAttributes.getEntryIdleTimeout()).thenReturn(testExpirationAttributes);
when(mockRegionAttributes.getEntryTimeToLive()).thenReturn(testExpirationAttributes);
when(mockRegionAttributes.getEvictionAttributes()).thenReturn(testEvictionAttributes);
when(mockRegionAttributes.getIgnoreJTA()).thenReturn(false);
when(mockRegionAttributes.getIndexMaintenanceSynchronous()).thenReturn(false);
when(mockRegionAttributes.getInitialCapacity()).thenReturn(1024);
when(mockRegionAttributes.getKeyConstraint()).thenReturn(Long.class);
when(mockRegionAttributes.getLoadFactor()).thenReturn(0.90f);
when(mockRegionAttributes.isLockGrantor()).thenReturn(true);
when(mockRegionAttributes.getMembershipAttributes()).thenReturn(testMembershipAttributes);
when(mockRegionAttributes.getMulticastEnabled()).thenReturn(false);
when(mockRegionAttributes.getPartitionAttributes()).thenReturn(testPartitionAttributes);
when(mockRegionAttributes.getPoolName()).thenReturn("swimming");
when(mockRegionAttributes.getRegionIdleTimeout()).thenReturn(testExpirationAttributes);
when(mockRegionAttributes.getRegionTimeToLive()).thenReturn(testExpirationAttributes);
when(mockRegionAttributes.getStatisticsEnabled()).thenReturn(true);
when(mockRegionAttributes.getSubscriptionAttributes()).thenReturn(testSubscriptionAttributes);
RegionFactoryBean factoryBean = new RegionFactoryBean() {
@Override boolean hasUserSpecifiedEvictionAttributes(final RegionAttributes regionAttributes) {
return true;
}
@Override void validateRegionAttributes(final RegionAttributes regionAttributes) {
// no-op!
}
};
factoryBean.mergeRegionAttributes(mockRegionFactory, mockRegionAttributes);
verify(mockRegionFactory).setCloningEnabled(eq(false));
verify(mockRegionFactory).setConcurrencyChecksEnabled(eq(true));
verify(mockRegionFactory).setConcurrencyLevel(eq(51));
verify(mockRegionFactory).setCustomEntryIdleTimeout(null);
verify(mockRegionFactory).setCustomEntryTimeToLive(null);
verify(mockRegionFactory).setDiskSynchronous(eq(true));
verify(mockRegionFactory).setEnableAsyncConflation(eq(false));
verify(mockRegionFactory).setEnableSubscriptionConflation(eq(false));
verify(mockRegionFactory).setEntryIdleTimeout(same(testExpirationAttributes));
verify(mockRegionFactory).setEntryTimeToLive(same(testExpirationAttributes));
verify(mockRegionFactory).setEvictionAttributes(same(testEvictionAttributes));
verify(mockRegionFactory).setIgnoreJTA(eq(false));
verify(mockRegionFactory).setIndexMaintenanceSynchronous(eq(false));
verify(mockRegionFactory).setInitialCapacity(eq(1024));
verify(mockRegionFactory).setKeyConstraint(Long.class);
verify(mockRegionFactory).setLoadFactor(eq(0.90f));
verify(mockRegionFactory).setLockGrantor(eq(true));
verify(mockRegionFactory).setMembershipAttributes(same(testMembershipAttributes));
verify(mockRegionFactory).setMulticastEnabled(eq(false));
verify(mockRegionFactory).setPartitionAttributes(eq(testPartitionAttributes));
verify(mockRegionFactory).setPoolName(eq("swimming"));
verify(mockRegionFactory).setRegionIdleTimeout(same(testExpirationAttributes));
verify(mockRegionFactory).setRegionTimeToLive(same(testExpirationAttributes));
verify(mockRegionFactory).setStatisticsEnabled(eq(true));
verify(mockRegionFactory).setSubscriptionAttributes(same(testSubscriptionAttributes));
}
@Test
public void testMergeRegionAttributesWithNull() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, null);
factoryBean.mergeRegionAttributes(mockRegionFactory, null);
verify(mockRegionFactory, never()).setCloningEnabled(false);
verify(mockRegionFactory, never()).setConcurrencyChecksEnabled(true);
verify(mockRegionFactory, never()).setConcurrencyLevel(2);
verify(mockRegionFactory, never()).setCustomEntryIdleTimeout(any(CustomExpiry.class));
verify(mockRegionFactory, never()).setCustomEntryTimeToLive(any(CustomExpiry.class));
verify(mockRegionFactory, never()).setDiskSynchronous(true);
verify(mockRegionFactory, never()).setEnableAsyncConflation(true);
verify(mockRegionFactory, never()).setEnableSubscriptionConflation(false);
verify(mockRegionFactory, never()).setEntryIdleTimeout(any(ExpirationAttributes.class));
verify(mockRegionFactory, never()).setEntryTimeToLive(any(ExpirationAttributes.class));
verify(mockRegionFactory, never()).setEvictionAttributes(any(EvictionAttributes.class));
verify(mockRegionFactory, never()).setIgnoreJTA(false);
verify(mockRegionFactory, never()).setIndexMaintenanceSynchronous(false);
verify(mockRegionFactory, never()).setInitialCapacity(51);
verify(mockRegionFactory, never()).setKeyConstraint(any(Class.class));
verify(mockRegionFactory, never()).setLoadFactor(0.75f);
verify(mockRegionFactory, never()).setLockGrantor(true);
verify(mockRegionFactory, never()).setMembershipAttributes(any(MembershipAttributes.class));
verify(mockRegionFactory, never()).setMulticastEnabled(false);
verify(mockRegionFactory, never()).setPartitionAttributes(any(PartitionAttributes.class));
verify(mockRegionFactory, never()).setPoolName(any(String.class));
verify(mockRegionFactory, never()).setRegionIdleTimeout(any(ExpirationAttributes.class));
verify(mockRegionFactory, never()).setRegionTimeToLive(any(ExpirationAttributes.class));
verify(mockRegionFactory, never()).setStatisticsEnabled(true);
verify(mockRegionFactory, never()).setSubscriptionAttributes(any(SubscriptionAttributes.class));
verify(mockRegionFactory, never()).setValueConstraint(any(Class.class));
}
@Test
public void testPartialMergeRegionAttributes() {
ExpirationAttributes testExpirationAttributes = new ExpirationAttributes(300, ExpirationAction.LOCAL_INVALIDATE);
RegionAttributes mockRegionAttributes = mock(RegionAttributes.class);
RegionFactory<Long, String> mockRegionFactory = (RegionFactory<Long, String>) createMockRegionFactory();
when(mockRegionAttributes.getCloningEnabled()).thenReturn(true);
when(mockRegionAttributes.getConcurrencyChecksEnabled()).thenReturn(false);
when(mockRegionAttributes.getConcurrencyLevel()).thenReturn(8);
when(mockRegionAttributes.getCustomEntryIdleTimeout()).thenReturn(null);
when(mockRegionAttributes.getCustomEntryTimeToLive()).thenReturn(null);
when(mockRegionAttributes.isDiskSynchronous()).thenReturn(false);
when(mockRegionAttributes.getEnableAsyncConflation()).thenReturn(true);
when(mockRegionAttributes.getEnableSubscriptionConflation()).thenReturn(true);
when(mockRegionAttributes.getEntryIdleTimeout()).thenReturn(testExpirationAttributes);
when(mockRegionAttributes.getEntryTimeToLive()).thenReturn(testExpirationAttributes);
when(mockRegionAttributes.getEvictionAttributes()).thenReturn(null);
when(mockRegionAttributes.getIgnoreJTA()).thenReturn(true);
when(mockRegionAttributes.getIndexMaintenanceSynchronous()).thenReturn(true);
when(mockRegionAttributes.getInitialCapacity()).thenReturn(512);
when(mockRegionAttributes.getKeyConstraint()).thenReturn(Long.class);
when(mockRegionAttributes.getLoadFactor()).thenReturn(0.60f);
when(mockRegionAttributes.isLockGrantor()).thenReturn(false);
when(mockRegionAttributes.getMembershipAttributes()).thenReturn(null);
when(mockRegionAttributes.getMulticastEnabled()).thenReturn(true);
when(mockRegionAttributes.getPartitionAttributes()).thenReturn(null);
when(mockRegionAttributes.getPoolName()).thenReturn("swimming");
when(mockRegionAttributes.getRegionIdleTimeout()).thenReturn(testExpirationAttributes);
when(mockRegionAttributes.getRegionTimeToLive()).thenReturn(testExpirationAttributes);
when(mockRegionAttributes.getStatisticsEnabled()).thenReturn(true);
when(mockRegionAttributes.getSubscriptionAttributes()).thenReturn(null);
RegionFactoryBean factoryBean = new RegionFactoryBean() {
@Override boolean hasUserSpecifiedEvictionAttributes(final RegionAttributes regionAttributes) {
return false;
}
@Override void validateRegionAttributes(final RegionAttributes regionAttributes) {
// no-op!
}
};
factoryBean.mergeRegionAttributes(mockRegionFactory, mockRegionAttributes);
verify(mockRegionFactory).setCloningEnabled(eq(true));
verify(mockRegionFactory).setConcurrencyChecksEnabled(eq(false));
verify(mockRegionFactory).setConcurrencyLevel(eq(8));
verify(mockRegionFactory).setCustomEntryIdleTimeout(null);
verify(mockRegionFactory).setCustomEntryTimeToLive(null);
verify(mockRegionFactory).setDiskSynchronous(eq(false));
verify(mockRegionFactory).setEnableAsyncConflation(eq(true));
verify(mockRegionFactory).setEnableSubscriptionConflation(eq(true));
verify(mockRegionFactory).setEntryIdleTimeout(same(testExpirationAttributes));
verify(mockRegionFactory).setEntryTimeToLive(same(testExpirationAttributes));
verify(mockRegionFactory, never()).setEvictionAttributes(any(EvictionAttributes.class));
verify(mockRegionFactory).setIgnoreJTA(eq(true));
verify(mockRegionFactory).setIndexMaintenanceSynchronous(eq(true));
verify(mockRegionFactory).setInitialCapacity(eq(512));
verify(mockRegionFactory).setKeyConstraint(Long.class);
verify(mockRegionFactory).setLoadFactor(eq(0.60f));
verify(mockRegionFactory).setLockGrantor(eq(false));
verify(mockRegionFactory).setMembershipAttributes(null);
verify(mockRegionFactory).setMulticastEnabled(eq(true));
verify(mockRegionFactory, never()).setPartitionAttributes(any(PartitionAttributes.class));
verify(mockRegionFactory).setPoolName(eq("swimming"));
verify(mockRegionFactory).setRegionIdleTimeout(same(testExpirationAttributes));
verify(mockRegionFactory).setRegionTimeToLive(same(testExpirationAttributes));
verify(mockRegionFactory).setStatisticsEnabled(eq(true));
verify(mockRegionFactory).setSubscriptionAttributes(null);
}
@Test
public void testMergePartitionAttributesWithPartitionRedundantProxy() throws Exception {
PartitionAttributes testPartitionAttributes = createPartitionAttributes("TestRegion", 512000, 15000l, 0,
30000l, 1024000l, 51);
RegionAttributes mockRegionAttributes = mock(RegionAttributes.class);
RegionFactory mockRegionFactory = createTestRegionFactory();
when(mockRegionAttributes.getPartitionAttributes()).thenReturn(testPartitionAttributes);
factoryBean.setShortcut(RegionShortcut.PARTITION_PROXY_REDUNDANT);
factoryBean.mergePartitionAttributes(mockRegionFactory, mockRegionAttributes);
RegionAttributes regionAttributes = TestUtils.readField("regionAttributes",
TestUtils.readField("attrsFactory", mockRegionFactory));
PartitionAttributes actualPartitionAttributes = regionAttributes.getPartitionAttributes();
assertNotNull(actualPartitionAttributes);
assertNotSame(testPartitionAttributes, actualPartitionAttributes);
assertEquals("TestRegion", actualPartitionAttributes.getColocatedWith());
assertEquals(0, actualPartitionAttributes.getLocalMaxMemory());
assertEquals(15000l, actualPartitionAttributes.getRecoveryDelay());
assertEquals(1, actualPartitionAttributes.getRedundantCopies());
assertEquals(30000l, actualPartitionAttributes.getStartupRecoveryDelay());
assertEquals(1024000l, actualPartitionAttributes.getTotalMaxMemory());
assertEquals(51, actualPartitionAttributes.getTotalNumBuckets());
verify(mockRegionAttributes, times(2)).getPartitionAttributes();
}
@Test
public void testMergePartitionAttributesWithPartitionRedundant() throws Exception {
PartitionAttributes testPartitionAttributes = createPartitionAttributes("TestRegion", 512000, 15000l, 0,
30000l, 1024000l, 51);
RegionAttributes mockRegionAttributes = mock(RegionAttributes.class);
RegionFactory mockRegionFactory = createTestRegionFactory();
when(mockRegionAttributes.getPartitionAttributes()).thenReturn(testPartitionAttributes);
factoryBean.setShortcut(RegionShortcut.PARTITION_REDUNDANT);
factoryBean.mergePartitionAttributes(mockRegionFactory, mockRegionAttributes);
RegionAttributes regionAttributes = TestUtils.readField("regionAttributes",
TestUtils.readField("attrsFactory", mockRegionFactory));
PartitionAttributes actualPartitionAttributes = regionAttributes.getPartitionAttributes();
assertNotNull(actualPartitionAttributes);
assertNotSame(testPartitionAttributes, actualPartitionAttributes);
assertEquals("TestRegion", actualPartitionAttributes.getColocatedWith());
assertEquals(512000, actualPartitionAttributes.getLocalMaxMemory());
assertEquals(15000l, actualPartitionAttributes.getRecoveryDelay());
assertEquals(1, actualPartitionAttributes.getRedundantCopies());
assertEquals(30000l, actualPartitionAttributes.getStartupRecoveryDelay());
assertEquals(1024000l, actualPartitionAttributes.getTotalMaxMemory());
assertEquals(51, actualPartitionAttributes.getTotalNumBuckets());
verify(mockRegionAttributes, times(2)).getPartitionAttributes();
}
@Test
public void testMergePartitionAttributesWithPartitionRedundantPersistentOverflow() throws Exception {
PartitionAttributes testPartitionAttributes = createPartitionAttributes("TestRegion", 512000, 15000l, 3,
30000l, 1024000l, 51);
RegionAttributes mockRegionAttributes = mock(RegionAttributes.class);
RegionFactory mockRegionFactory = createTestRegionFactory();
when(mockRegionAttributes.getPartitionAttributes()).thenReturn(testPartitionAttributes);
factoryBean.setShortcut(RegionShortcut.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW);
factoryBean.mergePartitionAttributes(mockRegionFactory, mockRegionAttributes);
RegionAttributes regionAttributes = TestUtils.readField("regionAttributes",
TestUtils.readField("attrsFactory", mockRegionFactory));
PartitionAttributes actualPartitionAttributes = regionAttributes.getPartitionAttributes();
assertNotNull(actualPartitionAttributes);
assertNotSame(testPartitionAttributes, actualPartitionAttributes);
assertEquals("TestRegion", actualPartitionAttributes.getColocatedWith());
assertEquals(512000, actualPartitionAttributes.getLocalMaxMemory());
assertEquals(15000l, actualPartitionAttributes.getRecoveryDelay());
assertEquals(3, actualPartitionAttributes.getRedundantCopies());
assertEquals(30000l, actualPartitionAttributes.getStartupRecoveryDelay());
assertEquals(1024000l, actualPartitionAttributes.getTotalMaxMemory());
assertEquals(51, actualPartitionAttributes.getTotalNumBuckets());
verify(mockRegionAttributes, times(2)).getPartitionAttributes();
}
@Test
public void testMergePartitionAttributesWithPartitionProxy() throws Exception {
PartitionAttributes testPartitionAttributes = createPartitionAttributes("TestRegion", 512000, 15000l, 0,
30000l, 1024000l, 51);
RegionAttributes mockRegionAttributes = mock(RegionAttributes.class);
RegionFactory mockRegionFactory = createTestRegionFactory();
when(mockRegionAttributes.getPartitionAttributes()).thenReturn(testPartitionAttributes);
factoryBean.setShortcut(RegionShortcut.PARTITION_PROXY);
factoryBean.mergePartitionAttributes(mockRegionFactory, mockRegionAttributes);
RegionAttributes regionAttributes = TestUtils.readField("regionAttributes",
TestUtils.readField("attrsFactory", mockRegionFactory));
PartitionAttributes actualPartitionAttributes = regionAttributes.getPartitionAttributes();
assertNotNull(actualPartitionAttributes);
assertNotSame(testPartitionAttributes, actualPartitionAttributes);
assertEquals("TestRegion", actualPartitionAttributes.getColocatedWith());
assertEquals(0, actualPartitionAttributes.getLocalMaxMemory());
assertEquals(15000l, actualPartitionAttributes.getRecoveryDelay());
assertEquals(0, actualPartitionAttributes.getRedundantCopies());
assertEquals(30000l, actualPartitionAttributes.getStartupRecoveryDelay());
assertEquals(1024000l, actualPartitionAttributes.getTotalMaxMemory());
assertEquals(51, actualPartitionAttributes.getTotalNumBuckets());
verify(mockRegionAttributes, times(2)).getPartitionAttributes();
}
@Test
public void testMergePartitionAttributesWithPartition() throws Exception {
PartitionAttributes testPartitionAttributes = createPartitionAttributes("TestRegion", 512000, 15000l, 0,
30000l, 1024000l, 51);
RegionAttributes mockRegionAttributes = mock(RegionAttributes.class);
RegionFactory mockRegionFactory = createTestRegionFactory();
when(mockRegionAttributes.getPartitionAttributes()).thenReturn(testPartitionAttributes);
factoryBean.setShortcut(RegionShortcut.PARTITION);
factoryBean.mergePartitionAttributes(mockRegionFactory, mockRegionAttributes);
RegionAttributes regionAttributes = TestUtils.readField("regionAttributes",
TestUtils.readField("attrsFactory", mockRegionFactory));
PartitionAttributes actualPartitionAttributes = regionAttributes.getPartitionAttributes();
assertNotNull(actualPartitionAttributes);
assertNotSame(testPartitionAttributes, actualPartitionAttributes);
assertEquals("TestRegion", actualPartitionAttributes.getColocatedWith());
assertEquals(512000, actualPartitionAttributes.getLocalMaxMemory());
assertEquals(15000l, actualPartitionAttributes.getRecoveryDelay());
assertEquals(0, actualPartitionAttributes.getRedundantCopies());
assertEquals(30000l, actualPartitionAttributes.getStartupRecoveryDelay());
assertEquals(1024000l, actualPartitionAttributes.getTotalMaxMemory());
assertEquals(51, actualPartitionAttributes.getTotalNumBuckets());
verify(mockRegionAttributes, times(2)).getPartitionAttributes();
}
@Test
public void testMergePartitionAttributes() {
RegionAttributes mockRegionAttributes = mock(RegionAttributes.class);
RegionFactory mockRegionFactory = createMockRegionFactory();
when(mockRegionAttributes.getPartitionAttributes()).thenReturn(null);
factoryBean.setShortcut(null);
factoryBean.mergePartitionAttributes(mockRegionFactory, mockRegionAttributes);
verify(mockRegionAttributes, times(1)).getPartitionAttributes();
verify(mockRegionFactory, never()).setPartitionAttributes(any(PartitionAttributes.class));
}
@Test
public void testResolveDataPolicyWhenPersistentUnspecifiedAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, (String) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.DEFAULT));
}
@@ -114,7 +696,7 @@ public class RegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
public void testResolveDataPolicyWhenNotPersistentAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, null);
factoryBean.resolveDataPolicy(mockRegionFactory, false, (String) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.DEFAULT));
}
@@ -122,13 +704,52 @@ public class RegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
public void testResolveDataPolicyWhenPersistentAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, null);
factoryBean.resolveDataPolicy(mockRegionFactory, true, (String) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithBlankDataPolicyName() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, " ");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy ' ' is invalid.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.DEFAULT));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithEmptyDataPolicyName() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, "");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy '' is invalid.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.DEFAULT));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithInvalidDataPolicyName() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, "CSV");
@@ -145,14 +766,14 @@ public class RegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
}
@Test
public void testResolveDataPolicyWithPersistentUnspecifiedAndNormalDataPolicy() {
public void testResolveDataPolicyWhenPersistentUnspecifiedAndNormalDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, "NORMAL");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.NORMAL));
}
@Test
public void testResolveDataPolicyWhenNotPersistentUnspecifiedAndPreloadedDataPolicy() {
public void testResolveDataPolicyWhenNotPersistentAndPreloadedDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, "PRELOADED");
@@ -160,8 +781,9 @@ public class RegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenPersistentAndPersistentEmptyDataPolicy() {
public void testResolveDataPolicyWhenPersistentAndEmptyDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, "EMPTY");
@@ -179,18 +801,27 @@ public class RegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
}
@Test
public void testResolveDataPolicyWithPersistentUnspecifiedAndPersistentPartitionedDataPolicy() {
public void testResolveDataPolicyWhenPersistentUnspecifiedAndPartitionDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, "PARTITION");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PARTITION));
}
@Test
public void testResolveDataPolicyWhenPersistentUnspecifiedAndPersistentPartitionDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, "PERSISTENT_PARTITION");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_PARTITION));
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenNotPersistentAndPersistentPartitionedDataPolicy() {
public void testResolveDataPolicyWhenNotPersistentAndPersistentPartitionDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, "PERSISTENT_PARTITION");
fail("Setting the 'persistent' attribute to FALSE and 'Data Policy' to PERSISTENT_PARTITION should have thrown an IllegalArgumentException!");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy 'PERSISTENT_PARTITION' is invalid when persistent is false.", e.getMessage());
@@ -204,12 +835,145 @@ public class RegionFactoryBeanTest extends AbstractRegionFactoryBeanTest {
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenPersistentAndPartitionDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, "PARTITION");
fail("Setting the 'persistent' attribute to TRUE and 'Data Policy' to PARTITION should have thrown an IllegalArgumentException!");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy 'PARTITION' is invalid when persistent is true.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.DEFAULT));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PARTITION));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_PARTITION));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
}
@Test
public void testResolveDataPolicyWhenPersistentAndPersistentPartitionedDataPolicy() {
public void testResolveDataPolicyWhenNotPersistentAndPartitionDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, "PARTITION");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PARTITION));
}
@Test
public void testResolveDataPolicyWhenPersistentAndPersistentPartitionDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, "PERSISTENT_PARTITION");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_PARTITION));
}
@Test
public void testResolveDataPolicyWhenPersistentUnspecifiedAndUnspecifiedDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(null);
factoryBean.resolveDataPolicy(mockRegionFactory, null, (DataPolicy) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.DEFAULT));
}
@Test
public void testResolveDataPolicyWhenNotPersistentAndUnspecifiedDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, (DataPolicy) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.DEFAULT));
}
@Test
public void testResolveDataPolicyWhenPersistentAndUnspecifiedDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, (DataPolicy) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
@Test
public void testResolveDataPolicyWhenPersistentUnspecifiedAndReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, DataPolicy.REPLICATE);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.REPLICATE));
}
@Test
public void testResolveDataPolicyWhenPersistentUnspecifiedAndPersistentReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, DataPolicy.PERSISTENT_REPLICATE);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenNotPersistentAndPersistentReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, DataPolicy.PERSISTENT_REPLICATE);
fail("Setting the 'persistent' attribute to FALSE and 'Data Policy' to PERSISTENT_REPLICATE should have thrown an IllegalArgumentException!");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy 'PERSISTENT_REPLICATE' is invalid when persistent is false.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.DEFAULT));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.REPLICATE));
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenPersistentAndReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, "REPLICATE");
fail("Setting the 'persistent' attribute to TRUE and 'Data Policy' to REPLICATE should have thrown an IllegalArgumentException!");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy 'REPLICATE' is invalid when persistent is true.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.DEFAULT));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.REPLICATE));
}
}
@Test
public void testResolveDataPolicyWhenNotPersistentAndReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, DataPolicy.REPLICATE);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.REPLICATE));
}
@Test
public void testResolveDataPolicyWhenPersistentAndPersistentReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, DataPolicy.PERSISTENT_REPLICATE);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
protected static class TestRegionFactory extends RegionFactory {
protected TestRegionFactory() {
super((GemFireCacheImpl) null);
}
}
}

110
src/test/java/org/springframework/data/gemfire/ReplicatedRegionFactoryBeanTest.java
View File

@@ -32,9 +32,11 @@ import com.gemstone.gemfire.cache.RegionFactory;
* and correct behavior of the ReplicatedRegionFactoryBean class.
* <p/>
* @author John Blum
* @see org.mockito.Mockito
* @see org.junit.Test
* @see org.mockito.Mockito
* @see org.springframework.data.gemfire.ReplicatedRegionFactoryBean
* @see com.gemstone.gemfire.cache.DataPolicy
* @see com.gemstone.gemfire.cache.RegionFactory
* @since 1.3.3
*/
@SuppressWarnings("unchecked")
@@ -49,7 +51,7 @@ public class ReplicatedRegionFactoryBeanTest {
@Test
public void testResolveDataPolicyWithPersistentUnspecifiedAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, null);
factoryBean.resolveDataPolicy(mockRegionFactory, null, (String) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.REPLICATE));
}
@@ -57,7 +59,7 @@ public class ReplicatedRegionFactoryBeanTest {
public void testResolveDataPolicyWhenNotPersistentAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, null);
factoryBean.resolveDataPolicy(mockRegionFactory, false, (String) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.REPLICATE));
}
@@ -65,43 +67,50 @@ public class ReplicatedRegionFactoryBeanTest {
public void testResolveDataPolicyWhenPersistentAndDataPolicyUnspecified() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, null);
factoryBean.resolveDataPolicy(mockRegionFactory, true, (String) null);
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
@Test
public void testResolveDataPolicyWithPersistentUnspecifiedAndEmptyDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, "EMPTY");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.EMPTY));
}
@Test
public void testResolveDataPolicyWhenNotPersistentAndEmptyDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, "empty");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.EMPTY));
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenPersistentAndEmptyDataPolicy() {
public void testResolveDataPolicyWithBlankDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, "empty");
factoryBean.resolveDataPolicy(mockRegionFactory, null, " ");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy 'EMPTY' is invalid when persistent is true.", e.getMessage());
assertEquals("Data Policy ' ' is invalid.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.EMPTY));
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.NORMAL));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PRELOADED));
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithPersistentUnspecifiedAndInvalidDataPolicyName() {
public void testResolveDataPolicyWithEmptyDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.resolveDataPolicy(mockRegionFactory, null, "");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy '' is invalid.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.NORMAL));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PRELOADED));
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenPersistentUnspecifiedAndInvalidDataPolicyName() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
@@ -113,13 +122,14 @@ public class ReplicatedRegionFactoryBeanTest {
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.EMPTY));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.REPLICATE));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWithPersistentUnspecifiedAndInvalidDataPolicyRegionType() {
public void testResolveDataPolicyWhenPersistentUnspecifiedAndInvalidDataPolicyType() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
@@ -136,14 +146,48 @@ public class ReplicatedRegionFactoryBeanTest {
}
@Test
public void testResolveDataPolicyWhenPersistentUnspecifiedAndReplicatedDataPolicy() {
public void testResolveDataPolicyWhenPersistentUnspecifiedAndEmptyDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, "EMPTY");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.EMPTY));
}
@Test
public void testResolveDataPolicyWhenNotPersistentAndEmptyDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, "empty");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.EMPTY));
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenPersistentAndEmptyDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, "empty");
}
catch (IllegalArgumentException e) {
assertEquals("Data Policy 'EMPTY' is invalid when persistent is true.", e.getMessage());
throw e;
}
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.EMPTY));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
}
@Test
public void testResolveDataPolicyWhenPersistentUnspecifiedAndReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, "REPLICATE");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.REPLICATE));
}
@Test
public void testResolveDataPolicyWhenNotPersistentAndReplicatedDataPolicy() {
public void testResolveDataPolicyWhenNotPersistentAndReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(false);
factoryBean.resolveDataPolicy(mockRegionFactory, false, "REPLICATE");
@@ -151,7 +195,7 @@ public class ReplicatedRegionFactoryBeanTest {
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenPersistentAndReplicatedDataPolicy() {
public void testResolveDataPolicyWhenPersistentAndReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
@@ -165,18 +209,19 @@ public class ReplicatedRegionFactoryBeanTest {
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.REPLICATE));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
}
@Test
public void testResolveDataPolicyWhenPersistentUnspecifiedAndPersistentReplicatedDataPolicy() {
public void testResolveDataPolicyWhenPersistentUnspecifiedAndPersistentReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.resolveDataPolicy(mockRegionFactory, null, "PERSISTENT_REPLICATE");
verify(mockRegionFactory).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
@Test(expected = IllegalArgumentException.class)
public void testResolveDataPolicyWhenNotPersistentAndPersistentReplicatedDataPolicy() {
public void testResolveDataPolicyWhenNotPersistentAndPersistentReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
try {
@@ -190,11 +235,12 @@ public class ReplicatedRegionFactoryBeanTest {
finally {
verify(mockRegionFactory, never()).setDataPolicy(null);
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.REPLICATE));
verify(mockRegionFactory, never()).setDataPolicy(eq(DataPolicy.PERSISTENT_REPLICATE));
}
}
@Test
public void testResolveDataPolicyWhenPersistentAndPersistentReplicatedDataPolicy() {
public void testResolveDataPolicyWhenPersistentAndPersistentReplicateDataPolicy() {
RegionFactory mockRegionFactory = createMockRegionFactory();
factoryBean.setPersistent(true);
factoryBean.resolveDataPolicy(mockRegionFactory, true, "PERSISTENT_REPLICATE");

62
src/test/java/org/springframework/data/gemfire/config/AbstractRegionParserTest.java
View File

@@ -18,12 +18,17 @@ package org.springframework.data.gemfire.config;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.matches;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.junit.Test;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.beans.factory.xml.XmlReaderContext;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
@@ -74,6 +79,63 @@ public class AbstractRegionParserTest {
assertFalse(regionParser.isSubRegion(mockElement));
}
@Test
public void testValidateDataPolicyShortcutAttributesMutualExclusion() {
Element mockElement = mock(Element.class);
when(mockElement.hasAttribute(matches("data-policy"))).thenReturn(false);
when(mockElement.hasAttribute(matches("shortcut"))).thenReturn(false);
new TestRegionParser().validateDataPolicyShortcutAttributesMutualExclusion(mockElement, null);
verify(mockElement).hasAttribute(eq("data-policy"));
verify(mockElement, never()).hasAttribute(eq("shortcut"));
}
@Test
public void testValidateDataPolicyShortcutAttributesMutualExclusionWithDataPolicy() {
Element mockElement = mock(Element.class);
when(mockElement.hasAttribute(matches("data-policy"))).thenReturn(true);
when(mockElement.hasAttribute(matches("shortcut"))).thenReturn(false);
new TestRegionParser().validateDataPolicyShortcutAttributesMutualExclusion(mockElement, null);
verify(mockElement).hasAttribute(eq("data-policy"));
verify(mockElement).hasAttribute(eq("shortcut"));
}
@Test
public void testValidateDataPolicyShortcutAttributesMutualExclusionWithShortcut() {
Element mockElement = mock(Element.class);
when(mockElement.hasAttribute(matches("data-policy"))).thenReturn(false);
when(mockElement.hasAttribute(matches("shortcut"))).thenReturn(true);
new TestRegionParser().validateDataPolicyShortcutAttributesMutualExclusion(mockElement, null);
verify(mockElement).hasAttribute(eq("data-policy"));
verify(mockElement, never()).hasAttribute(eq("shortcut"));
}
@Test
public void testValidateDataPolicyShortcutAttributesMutualExclusionWithDataPolicyAndShortcut() {
Element mockElement = mock(Element.class);
XmlReaderContext mockReaderContext = mock(XmlReaderContext.class);
ParserContext mockParserContext = new ParserContext(mockReaderContext, null);
when(mockElement.hasAttribute(matches("data-policy"))).thenReturn(true);
when(mockElement.hasAttribute(matches("shortcut"))).thenReturn(true);
when(mockElement.getTagName()).thenReturn("local-region");
new TestRegionParser().validateDataPolicyShortcutAttributesMutualExclusion(mockElement, mockParserContext);
verify(mockReaderContext).error(
eq("Only one of [data-policy, shortcut] may be specified with element 'local-region'."),
eq(mockElement));
}
protected static class TestRegionParser extends AbstractRegionParser {
@Override

12
src/test/java/org/springframework/data/gemfire/config/SubRegionWithInvalidDataPolicyTest.java
View File

@@ -21,7 +21,9 @@ import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.xml.XmlBeanDefinitionStoreException;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.xml.sax.SAXParseException;
/**
* The SubRegionWithInvalidDataPolicyTest class is a test suite of test cases testing the data-policy and persistent
@@ -35,17 +37,15 @@ import org.springframework.context.support.ClassPathXmlApplicationContext;
*/
public class SubRegionWithInvalidDataPolicyTest {
@Test(expected = BeanCreationException.class)
@Test(expected = XmlBeanDefinitionStoreException.class)
public void testSubRegionBeanDefinitionWithInconsistentDataPolicy() {
try {
new ClassPathXmlApplicationContext("/org/springframework/data/gemfire/config/subregion-with-invalid-datapolicy.xml");
}
catch (BeanCreationException expected) {
catch (XmlBeanDefinitionStoreException expected) {
//expected.printStackTrace(System.err);
assertTrue(expected.getMessage().contains("Error creating bean with name '/Parent/Child'"));
assertTrue(expected.getCause() instanceof IllegalArgumentException);
assertEquals("Data Policy 'PERSISTENT_PARTITION' is not supported in Replicated Regions.",
expected.getCause().getMessage());
assertTrue(expected.getCause() instanceof SAXParseException);
assertTrue(expected.getCause().getMessage().contains("PERSISTENT_PARTITION"));
throw expected;
}
}

152
src/test/java/org/springframework/data/gemfire/support/ClientRegionShortcutWrapperTest.java Normal file
View File

@@ -0,0 +1,152 @@
/*
* Copyright 2010-2013 the original author or authors.
*
* Licensed 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.springframework.data.gemfire.support;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import com.gemstone.gemfire.cache.client.ClientRegionShortcut;
/**
* The ClientRegionShortcutWrapperTest class is a test suite of test cases testing the contract and functionality of the
* ClientRegionShortcutWrapper enum class type.
* <p/>
* @author John Blum
* @see org.junit.Test
* @see org.springframework.data.gemfire.support.ClientRegionShortcutWrapper
* @see com.gemstone.gemfire.cache.client.ClientRegionShortcut
* @since 1.4.0
*/
public class ClientRegionShortcutWrapperTest {
@Test
public void testOneToOneMapping() {
for (ClientRegionShortcut shortcut : ClientRegionShortcut.values()) {
assertNotNull(ClientRegionShortcutWrapper.valueOf(shortcut.name()));
assertFalse(ClientRegionShortcutWrapper.UNSPECIFIED.equals(ClientRegionShortcutWrapper.valueOf(shortcut)));
}
}
@Test
public void testClientRegionShortcutUnspecified() {
assertEquals(ClientRegionShortcutWrapper.UNSPECIFIED, ClientRegionShortcutWrapper.valueOf(
(ClientRegionShortcut) null));
}
@Test
public void testIsCaching() {
assertTrue(ClientRegionShortcutWrapper.CACHING_PROXY.isCaching());
assertTrue(ClientRegionShortcutWrapper.CACHING_PROXY_HEAP_LRU.isCaching());
assertTrue(ClientRegionShortcutWrapper.CACHING_PROXY_OVERFLOW.isCaching());
assertFalse(ClientRegionShortcutWrapper.LOCAL.isCaching());
assertFalse(ClientRegionShortcutWrapper.LOCAL_HEAP_LRU.isCaching());
assertFalse(ClientRegionShortcutWrapper.LOCAL_OVERFLOW.isCaching());
assertFalse(ClientRegionShortcutWrapper.LOCAL_PERSISTENT.isCaching());
assertFalse(ClientRegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isCaching());
assertFalse(ClientRegionShortcutWrapper.PROXY.isCaching());
assertFalse(ClientRegionShortcutWrapper.UNSPECIFIED.isCaching());
}
@Test
public void testIsHeapLru() {
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY.isHeapLru());
assertTrue(ClientRegionShortcutWrapper.CACHING_PROXY_HEAP_LRU.isHeapLru());
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY_OVERFLOW.isHeapLru());
assertFalse(ClientRegionShortcutWrapper.LOCAL.isHeapLru());
assertTrue(ClientRegionShortcutWrapper.LOCAL_HEAP_LRU.isHeapLru());
assertFalse(ClientRegionShortcutWrapper.LOCAL_OVERFLOW.isHeapLru());
assertFalse(ClientRegionShortcutWrapper.LOCAL_PERSISTENT.isHeapLru());
assertFalse(ClientRegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isHeapLru());
assertFalse(ClientRegionShortcutWrapper.PROXY.isHeapLru());
assertFalse(ClientRegionShortcutWrapper.UNSPECIFIED.isHeapLru());
}
@Test
public void testIsLocal() {
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY.isLocal());
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY_HEAP_LRU.isLocal());
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY_OVERFLOW.isLocal());
assertTrue(ClientRegionShortcutWrapper.LOCAL.isLocal());
assertTrue(ClientRegionShortcutWrapper.LOCAL_HEAP_LRU.isLocal());
assertTrue(ClientRegionShortcutWrapper.LOCAL_OVERFLOW.isLocal());
assertTrue(ClientRegionShortcutWrapper.LOCAL_PERSISTENT.isLocal());
assertTrue(ClientRegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isLocal());
assertFalse(ClientRegionShortcutWrapper.PROXY.isLocal());
assertFalse(ClientRegionShortcutWrapper.UNSPECIFIED.isLocal());
}
@Test
public void testIsOverflow() {
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY.isOverflow());
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY_HEAP_LRU.isOverflow());
assertTrue(ClientRegionShortcutWrapper.CACHING_PROXY_OVERFLOW.isOverflow());
assertFalse(ClientRegionShortcutWrapper.LOCAL.isOverflow());
assertFalse(ClientRegionShortcutWrapper.LOCAL_HEAP_LRU.isOverflow());
assertTrue(ClientRegionShortcutWrapper.LOCAL_OVERFLOW.isOverflow());
assertFalse(ClientRegionShortcutWrapper.LOCAL_PERSISTENT.isOverflow());
assertTrue(ClientRegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isOverflow());
assertFalse(ClientRegionShortcutWrapper.PROXY.isOverflow());
assertFalse(ClientRegionShortcutWrapper.UNSPECIFIED.isOverflow());
}
@Test
public void testIsPersistent() {
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY.isPersistent());
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY_HEAP_LRU.isPersistent());
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY_OVERFLOW.isPersistent());
assertFalse(ClientRegionShortcutWrapper.LOCAL.isPersistent());
assertFalse(ClientRegionShortcutWrapper.LOCAL_HEAP_LRU.isPersistent());
assertFalse(ClientRegionShortcutWrapper.LOCAL_OVERFLOW.isPersistent());
assertTrue(ClientRegionShortcutWrapper.LOCAL_PERSISTENT.isPersistent());
assertTrue(ClientRegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isPersistent());
assertFalse(ClientRegionShortcutWrapper.PROXY.isPersistent());
assertFalse(ClientRegionShortcutWrapper.UNSPECIFIED.isPersistent());
}
@Test
public void testIsPersistentOverflow() {
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY.isPersistentOverflow());
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY_HEAP_LRU.isPersistentOverflow());
assertFalse(ClientRegionShortcutWrapper.CACHING_PROXY_OVERFLOW.isPersistentOverflow());
assertFalse(ClientRegionShortcutWrapper.LOCAL.isPersistentOverflow());
assertFalse(ClientRegionShortcutWrapper.LOCAL_HEAP_LRU.isPersistentOverflow());
assertFalse(ClientRegionShortcutWrapper.LOCAL_OVERFLOW.isPersistentOverflow());
assertFalse(ClientRegionShortcutWrapper.LOCAL_PERSISTENT.isPersistentOverflow());
assertTrue(ClientRegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isPersistentOverflow());
assertFalse(ClientRegionShortcutWrapper.PROXY.isPersistentOverflow());
assertFalse(ClientRegionShortcutWrapper.UNSPECIFIED.isPersistentOverflow());
}
@Test
public void testIsProxy() {
assertTrue(ClientRegionShortcutWrapper.CACHING_PROXY.isProxy());
assertTrue(ClientRegionShortcutWrapper.CACHING_PROXY_HEAP_LRU.isProxy());
assertTrue(ClientRegionShortcutWrapper.CACHING_PROXY_OVERFLOW.isProxy());
assertFalse(ClientRegionShortcutWrapper.LOCAL.isProxy());
assertFalse(ClientRegionShortcutWrapper.LOCAL_HEAP_LRU.isProxy());
assertFalse(ClientRegionShortcutWrapper.LOCAL_OVERFLOW.isProxy());
assertFalse(ClientRegionShortcutWrapper.LOCAL_PERSISTENT.isProxy());
assertFalse(ClientRegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isProxy());
assertTrue(ClientRegionShortcutWrapper.PROXY.isProxy());
assertFalse(ClientRegionShortcutWrapper.UNSPECIFIED.isProxy());
}
}

303
src/test/java/org/springframework/data/gemfire/support/RegionShortcutWrapperTest.java Normal file
View File

@@ -0,0 +1,303 @@
/*
* Copyright 2010-2013 the original author or authors.
*
* Licensed 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.springframework.data.gemfire.support;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import com.gemstone.gemfire.cache.RegionShortcut;
/**
* The RegionShortcutWrapperTest class is a test suite of test cases testing the contract and functionality of the
* RegionShortcutWrapper enum class type.
* <p/>
* @author John Blum
* @see org.junit.Test
* @see org.springframework.data.gemfire.support.RegionShortcutWrapper
* @see com.gemstone.gemfire.cache.RegionShortcut
* @since 1.4.0
*/
public class RegionShortcutWrapperTest {
@Test
public void testOneForOneMapping() {
for (RegionShortcut shortcut : RegionShortcut.values()) {
assertNotNull(RegionShortcutWrapper.valueOf(shortcut.name()));
assertFalse(RegionShortcutWrapper.UNSPECIFIED.equals(RegionShortcutWrapper.valueOf(shortcut)));
}
}
@Test
public void testRegionShortcutUnspecified() {
assertEquals(RegionShortcutWrapper.UNSPECIFIED, RegionShortcutWrapper.valueOf((RegionShortcut) null));
}
@Test
public void testIsHeapLru() {
assertFalse(RegionShortcutWrapper.LOCAL.isHeapLru());
assertTrue(RegionShortcutWrapper.LOCAL_HEAP_LRU.isHeapLru());
assertFalse(RegionShortcutWrapper.LOCAL_OVERFLOW.isHeapLru());
assertFalse(RegionShortcutWrapper.LOCAL_PERSISTENT.isHeapLru());
assertFalse(RegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isHeapLru());
assertFalse(RegionShortcutWrapper.PARTITION.isHeapLru());
assertTrue(RegionShortcutWrapper.PARTITION_HEAP_LRU.isHeapLru());
assertFalse(RegionShortcutWrapper.PARTITION_OVERFLOW.isHeapLru());
assertFalse(RegionShortcutWrapper.PARTITION_PERSISTENT.isHeapLru());
assertFalse(RegionShortcutWrapper.PARTITION_PERSISTENT_OVERFLOW.isHeapLru());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY.isHeapLru());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY_REDUNDANT.isHeapLru());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT.isHeapLru());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_HEAP_LRU.isHeapLru());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_OVERFLOW.isHeapLru());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT.isHeapLru());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW.isHeapLru());
assertFalse(RegionShortcutWrapper.REPLICATE.isHeapLru());
assertTrue(RegionShortcutWrapper.REPLICATE_HEAP_LRU.isHeapLru());
assertFalse(RegionShortcutWrapper.REPLICATE_OVERFLOW.isHeapLru());
assertFalse(RegionShortcutWrapper.REPLICATE_PERSISTENT.isHeapLru());
assertFalse(RegionShortcutWrapper.REPLICATE_PERSISTENT_OVERFLOW.isHeapLru());
assertFalse(RegionShortcutWrapper.REPLICATE_PROXY.isHeapLru());
assertFalse(RegionShortcutWrapper.UNSPECIFIED.isHeapLru());
}
@Test
public void testIsLocal() {
assertTrue(RegionShortcutWrapper.LOCAL.isLocal());
assertTrue(RegionShortcutWrapper.LOCAL_HEAP_LRU.isLocal());
assertTrue(RegionShortcutWrapper.LOCAL_OVERFLOW.isLocal());
assertTrue(RegionShortcutWrapper.LOCAL_PERSISTENT.isLocal());
assertTrue(RegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isLocal());
assertFalse(RegionShortcutWrapper.PARTITION.isLocal());
assertFalse(RegionShortcutWrapper.PARTITION_HEAP_LRU.isLocal());
assertFalse(RegionShortcutWrapper.PARTITION_OVERFLOW.isLocal());
assertFalse(RegionShortcutWrapper.PARTITION_PERSISTENT.isLocal());
assertFalse(RegionShortcutWrapper.PARTITION_PERSISTENT_OVERFLOW.isLocal());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY.isLocal());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY_REDUNDANT.isLocal());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT.isLocal());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_HEAP_LRU.isLocal());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_OVERFLOW.isLocal());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT.isLocal());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW.isLocal());
assertFalse(RegionShortcutWrapper.REPLICATE.isLocal());
assertFalse(RegionShortcutWrapper.REPLICATE_HEAP_LRU.isLocal());
assertFalse(RegionShortcutWrapper.REPLICATE_OVERFLOW.isLocal());
assertFalse(RegionShortcutWrapper.REPLICATE_PERSISTENT.isLocal());
assertFalse(RegionShortcutWrapper.REPLICATE_PERSISTENT_OVERFLOW.isLocal());
assertFalse(RegionShortcutWrapper.REPLICATE_PROXY.isLocal());
assertFalse(RegionShortcutWrapper.UNSPECIFIED.isLocal());
}
@Test
public void testIsOverflow() {
assertFalse(RegionShortcutWrapper.LOCAL.isOverflow());
assertFalse(RegionShortcutWrapper.LOCAL_HEAP_LRU.isOverflow());
assertTrue(RegionShortcutWrapper.LOCAL_OVERFLOW.isOverflow());
assertFalse(RegionShortcutWrapper.LOCAL_PERSISTENT.isOverflow());
assertTrue(RegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isOverflow());
assertFalse(RegionShortcutWrapper.PARTITION.isOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_HEAP_LRU.isOverflow());
assertTrue(RegionShortcutWrapper.PARTITION_OVERFLOW.isOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_PERSISTENT.isOverflow());
assertTrue(RegionShortcutWrapper.PARTITION_PERSISTENT_OVERFLOW.isOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY.isOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY_REDUNDANT.isOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT.isOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_HEAP_LRU.isOverflow());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_OVERFLOW.isOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT.isOverflow());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW.isOverflow());
assertFalse(RegionShortcutWrapper.REPLICATE.isOverflow());
assertFalse(RegionShortcutWrapper.REPLICATE_HEAP_LRU.isOverflow());
assertTrue(RegionShortcutWrapper.REPLICATE_OVERFLOW.isOverflow());
assertFalse(RegionShortcutWrapper.REPLICATE_PERSISTENT.isOverflow());
assertTrue(RegionShortcutWrapper.REPLICATE_PERSISTENT_OVERFLOW.isOverflow());
assertFalse(RegionShortcutWrapper.REPLICATE_PROXY.isOverflow());
assertFalse(RegionShortcutWrapper.UNSPECIFIED.isOverflow());
}
@Test
public void testIsPartition() {
assertFalse(RegionShortcutWrapper.LOCAL.isPartition());
assertFalse(RegionShortcutWrapper.LOCAL_HEAP_LRU.isPartition());
assertFalse(RegionShortcutWrapper.LOCAL_OVERFLOW.isPartition());
assertFalse(RegionShortcutWrapper.LOCAL_PERSISTENT.isPartition());
assertFalse(RegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isPartition());
assertTrue(RegionShortcutWrapper.PARTITION.isPartition());
assertTrue(RegionShortcutWrapper.PARTITION_HEAP_LRU.isPartition());
assertTrue(RegionShortcutWrapper.PARTITION_OVERFLOW.isPartition());
assertTrue(RegionShortcutWrapper.PARTITION_PERSISTENT.isPartition());
assertTrue(RegionShortcutWrapper.PARTITION_PERSISTENT_OVERFLOW.isPartition());
assertTrue(RegionShortcutWrapper.PARTITION_PROXY.isPartition());
assertTrue(RegionShortcutWrapper.PARTITION_PROXY_REDUNDANT.isPartition());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT.isPartition());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_HEAP_LRU.isPartition());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_OVERFLOW.isPartition());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT.isPartition());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW.isPartition());
assertFalse(RegionShortcutWrapper.REPLICATE.isPartition());
assertFalse(RegionShortcutWrapper.REPLICATE_HEAP_LRU.isPartition());
assertFalse(RegionShortcutWrapper.REPLICATE_OVERFLOW.isPartition());
assertFalse(RegionShortcutWrapper.REPLICATE_PERSISTENT.isPartition());
assertFalse(RegionShortcutWrapper.REPLICATE_PERSISTENT_OVERFLOW.isPartition());
assertFalse(RegionShortcutWrapper.REPLICATE_PROXY.isPartition());
assertFalse(RegionShortcutWrapper.UNSPECIFIED.isPartition());
}
@Test
public void testIsPersistent() {
assertFalse(RegionShortcutWrapper.LOCAL.isPersistent());
assertFalse(RegionShortcutWrapper.LOCAL_HEAP_LRU.isPersistent());
assertFalse(RegionShortcutWrapper.LOCAL_OVERFLOW.isPersistent());
assertTrue(RegionShortcutWrapper.LOCAL_PERSISTENT.isPersistent());
assertTrue(RegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isPersistent());
assertFalse(RegionShortcutWrapper.PARTITION.isPersistent());
assertFalse(RegionShortcutWrapper.PARTITION_HEAP_LRU.isPersistent());
assertFalse(RegionShortcutWrapper.PARTITION_OVERFLOW.isPersistent());
assertTrue(RegionShortcutWrapper.PARTITION_PERSISTENT.isPersistent());
assertTrue(RegionShortcutWrapper.PARTITION_PERSISTENT_OVERFLOW.isPersistent());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY.isPersistent());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY_REDUNDANT.isPersistent());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT.isPersistent());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_HEAP_LRU.isPersistent());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_OVERFLOW.isPersistent());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT.isPersistent());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW.isPersistent());
assertFalse(RegionShortcutWrapper.REPLICATE.isPersistent());
assertFalse(RegionShortcutWrapper.REPLICATE_HEAP_LRU.isPersistent());
assertFalse(RegionShortcutWrapper.REPLICATE_OVERFLOW.isPersistent());
assertTrue(RegionShortcutWrapper.REPLICATE_PERSISTENT.isPersistent());
assertTrue(RegionShortcutWrapper.REPLICATE_PERSISTENT_OVERFLOW.isPersistent());
assertFalse(RegionShortcutWrapper.REPLICATE_PROXY.isPersistent());
assertFalse(RegionShortcutWrapper.UNSPECIFIED.isPersistent());
}
@Test
public void testIsPersistentOverflow() {
assertFalse(RegionShortcutWrapper.LOCAL.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.LOCAL_HEAP_LRU.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.LOCAL_OVERFLOW.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.LOCAL_PERSISTENT.isPersistentOverflow());
assertTrue(RegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.PARTITION.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_HEAP_LRU.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_OVERFLOW.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_PERSISTENT.isPersistentOverflow());
assertTrue(RegionShortcutWrapper.PARTITION_PERSISTENT_OVERFLOW.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY_REDUNDANT.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_HEAP_LRU.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_OVERFLOW.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT.isPersistentOverflow());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.REPLICATE.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.REPLICATE_HEAP_LRU.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.REPLICATE_OVERFLOW.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.REPLICATE_PERSISTENT.isPersistentOverflow());
assertTrue(RegionShortcutWrapper.REPLICATE_PERSISTENT_OVERFLOW.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.REPLICATE_PROXY.isPersistentOverflow());
assertFalse(RegionShortcutWrapper.UNSPECIFIED.isPersistentOverflow());
}
@Test
public void testIsProxy() {
assertFalse(RegionShortcutWrapper.LOCAL.isProxy());
assertFalse(RegionShortcutWrapper.LOCAL_HEAP_LRU.isProxy());
assertFalse(RegionShortcutWrapper.LOCAL_OVERFLOW.isProxy());
assertFalse(RegionShortcutWrapper.LOCAL_PERSISTENT.isProxy());
assertFalse(RegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isProxy());
assertFalse(RegionShortcutWrapper.PARTITION.isProxy());
assertFalse(RegionShortcutWrapper.PARTITION_HEAP_LRU.isProxy());
assertFalse(RegionShortcutWrapper.PARTITION_OVERFLOW.isProxy());
assertFalse(RegionShortcutWrapper.PARTITION_PERSISTENT.isProxy());
assertFalse(RegionShortcutWrapper.PARTITION_PERSISTENT_OVERFLOW.isProxy());
assertTrue(RegionShortcutWrapper.PARTITION_PROXY.isProxy());
assertTrue(RegionShortcutWrapper.PARTITION_PROXY_REDUNDANT.isProxy());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT.isProxy());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_HEAP_LRU.isProxy());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_OVERFLOW.isProxy());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT.isProxy());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW.isProxy());
assertFalse(RegionShortcutWrapper.REPLICATE.isProxy());
assertFalse(RegionShortcutWrapper.REPLICATE_HEAP_LRU.isProxy());
assertFalse(RegionShortcutWrapper.REPLICATE_OVERFLOW.isProxy());
assertFalse(RegionShortcutWrapper.REPLICATE_PERSISTENT.isProxy());
assertFalse(RegionShortcutWrapper.REPLICATE_PERSISTENT_OVERFLOW.isProxy());
assertTrue(RegionShortcutWrapper.REPLICATE_PROXY.isProxy());
assertFalse(RegionShortcutWrapper.UNSPECIFIED.isProxy());
}
@Test
public void testIsRedundant() {
assertFalse(RegionShortcutWrapper.LOCAL.isRedundant());
assertFalse(RegionShortcutWrapper.LOCAL_HEAP_LRU.isRedundant());
assertFalse(RegionShortcutWrapper.LOCAL_OVERFLOW.isRedundant());
assertFalse(RegionShortcutWrapper.LOCAL_PERSISTENT.isRedundant());
assertFalse(RegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isRedundant());
assertFalse(RegionShortcutWrapper.PARTITION.isRedundant());
assertFalse(RegionShortcutWrapper.PARTITION_HEAP_LRU.isRedundant());
assertFalse(RegionShortcutWrapper.PARTITION_OVERFLOW.isRedundant());
assertFalse(RegionShortcutWrapper.PARTITION_PERSISTENT.isRedundant());
assertFalse(RegionShortcutWrapper.PARTITION_PERSISTENT_OVERFLOW.isRedundant());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY.isRedundant());
assertTrue(RegionShortcutWrapper.PARTITION_PROXY_REDUNDANT.isRedundant());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT.isRedundant());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_HEAP_LRU.isRedundant());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_OVERFLOW.isRedundant());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT.isRedundant());
assertTrue(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW.isRedundant());
assertFalse(RegionShortcutWrapper.REPLICATE.isRedundant());
assertFalse(RegionShortcutWrapper.REPLICATE_HEAP_LRU.isRedundant());
assertFalse(RegionShortcutWrapper.REPLICATE_OVERFLOW.isRedundant());
assertFalse(RegionShortcutWrapper.REPLICATE_PERSISTENT.isRedundant());
assertFalse(RegionShortcutWrapper.REPLICATE_PERSISTENT_OVERFLOW.isRedundant());
assertFalse(RegionShortcutWrapper.REPLICATE_PROXY.isRedundant());
assertFalse(RegionShortcutWrapper.UNSPECIFIED.isRedundant());
}
@Test
public void testIsReplicate() {
assertFalse(RegionShortcutWrapper.LOCAL.isReplicate());
assertFalse(RegionShortcutWrapper.LOCAL_HEAP_LRU.isReplicate());
assertFalse(RegionShortcutWrapper.LOCAL_OVERFLOW.isReplicate());
assertFalse(RegionShortcutWrapper.LOCAL_PERSISTENT.isReplicate());
assertFalse(RegionShortcutWrapper.LOCAL_PERSISTENT_OVERFLOW.isReplicate());
assertFalse(RegionShortcutWrapper.PARTITION.isReplicate());
assertFalse(RegionShortcutWrapper.PARTITION_HEAP_LRU.isReplicate());
assertFalse(RegionShortcutWrapper.PARTITION_OVERFLOW.isReplicate());
assertFalse(RegionShortcutWrapper.PARTITION_PERSISTENT.isReplicate());
assertFalse(RegionShortcutWrapper.PARTITION_PERSISTENT_OVERFLOW.isReplicate());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY.isReplicate());
assertFalse(RegionShortcutWrapper.PARTITION_PROXY_REDUNDANT.isReplicate());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT.isReplicate());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_HEAP_LRU.isReplicate());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_OVERFLOW.isReplicate());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT.isReplicate());
assertFalse(RegionShortcutWrapper.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW.isReplicate());
assertTrue(RegionShortcutWrapper.REPLICATE.isReplicate());
assertTrue(RegionShortcutWrapper.REPLICATE_HEAP_LRU.isReplicate());
assertTrue(RegionShortcutWrapper.REPLICATE_OVERFLOW.isReplicate());
assertTrue(RegionShortcutWrapper.REPLICATE_PERSISTENT.isReplicate());
assertTrue(RegionShortcutWrapper.REPLICATE_PERSISTENT_OVERFLOW.isReplicate());
assertTrue(RegionShortcutWrapper.REPLICATE_PROXY.isReplicate());
assertFalse(RegionShortcutWrapper.UNSPECIFIED.isReplicate());
}
}