SGF-289 - Enumeration restrictions (xsd:enumeration) should be avoided in the XML schema.

Removed the XSD enumeration restriction on the 'eviction-type' attribute of the 'subscription-config' sub-element of the 'cache-server' element inside the SDG XML namespace (XSD) allowing the use of property placeholders to specify the Eviction Policy for Client Subscription to GemFire Cache Servers.

src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java

@@ -38,6 +38,8 @@ import org.springframework.core.io.Resource;
 import org.springframework.dao.DataAccessException;
 import org.springframework.dao.support.PersistenceExceptionTranslator;
 import org.springframework.data.gemfire.client.InterestResultPolicyConverter;
+import org.springframework.data.gemfire.server.SubscriptionEvictionPolicy;
+import org.springframework.data.gemfire.server.SubscriptionEvictionPolicyConverter;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.CollectionUtils;
@@ -927,6 +929,7 @@ public class CacheFactoryBean implements BeanClassLoaderAware, BeanFactoryAware,
 			beanFactory.registerCustomEditor(IndexType.class, IndexTypeConverter.class);
 			beanFactory.registerCustomEditor(InterestPolicy.class, InterestPolicyConverter.class);
 			beanFactory.registerCustomEditor(InterestResultPolicy.class, InterestResultPolicyConverter.class);
+			beanFactory.registerCustomEditor(SubscriptionEvictionPolicy.class, SubscriptionEvictionPolicyConverter.class);
 		}
 	}
 

src/main/java/org/springframework/data/gemfire/config/CacheServerParser.java

@@ -32,6 +32,11 @@ import org.w3c.dom.Element;
  *
  * @author Costin Leau
  * @author John Blum
+ * @see org.springframework.beans.factory.support.AbstractBeanDefinition
+ * @see org.springframework.beans.factory.support.BeanDefinitionBuilder
+ * @see org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser
+ * @see org.springframework.data.gemfire.server.CacheServerFactoryBean
+ * @since 1.1.0
  */
 class CacheServerParser extends AbstractSimpleBeanDefinitionParser {
 
@@ -42,18 +47,15 @@ class CacheServerParser extends AbstractSimpleBeanDefinitionParser {
 
 	@Override
 	protected String resolveId(Element element, AbstractBeanDefinition definition, ParserContext parserContext)
-		throws BeanDefinitionStoreException {
+			throws BeanDefinitionStoreException {
 		String name = super.resolveId(element, definition, parserContext);
-		if (!StringUtils.hasText(name)) {
-			name = "gemfireServer";
-		}
-		return name;
+		return (StringUtils.hasText(name) ? name : "gemfireServer");
 	}
 
 	@Override
 	protected boolean isEligibleAttribute(Attr attribute, ParserContext parserContext) {
-		return super.isEligibleAttribute(attribute, parserContext) && !"groups".equals(attribute.getName())
-			&& !"cache-ref".equals(attribute.getName());
+		return (super.isEligibleAttribute(attribute, parserContext) && !"groups".equals(attribute.getName())
+			&& !"cache-ref".equals(attribute.getName()));
 	}
 
 	@Override
@@ -69,10 +71,10 @@ class CacheServerParser extends AbstractSimpleBeanDefinitionParser {
 			builder.addPropertyValue("serverGroups", StringUtils.commaDelimitedListToStringArray(groupsAttribute));
 		}
 
-		parseSubscription(builder, element);
+		parseSubscription(element, builder);
 	}
 
-	private void parseSubscription(BeanDefinitionBuilder builder, Element element) {
+	private void parseSubscription(Element element, BeanDefinitionBuilder builder) {
 		Element subscriptionConfigElement = DomUtils.getChildElementByTagName(element, "subscription-config");
 
 		if (subscriptionConfigElement != null) {
@@ -82,7 +84,7 @@ class CacheServerParser extends AbstractSimpleBeanDefinitionParser {
 			String evictionTypeAttribute = subscriptionConfigElement.getAttribute("eviction-type");
 
 			if (StringUtils.hasText(evictionTypeAttribute)) {
-				builder.addPropertyValue("subscriptionEvictionPolicy", evictionTypeAttribute.toUpperCase());
+				builder.addPropertyValue("subscriptionEvictionPolicy", evictionTypeAttribute);
 			}
 		}
 	}

src/main/java/org/springframework/data/gemfire/server/CacheServerFactoryBean.java

@@ -71,8 +71,7 @@ public class CacheServerFactoryBean implements FactoryBean<CacheServer>, Initial
 
 	private String[] serverGroups = {};
 
-	private SubscriptionEvictionPolicy subscriptionEvictionPolicy = SubscriptionEvictionPolicy.valueOf(
-		ClientSubscriptionConfig.DEFAULT_EVICTION_POLICY.toUpperCase());
+	private SubscriptionEvictionPolicy subscriptionEvictionPolicy = SubscriptionEvictionPolicy.DEFAULT;
 
 	public CacheServer getObject() {
 		return cacheServer;
@@ -112,42 +111,43 @@ public class CacheServerFactoryBean implements FactoryBean<CacheServer>, Initial
 		ClientSubscriptionConfig config = cacheServer.getClientSubscriptionConfig();
 
 		config.setCapacity(subscriptionCapacity);
-		config.setEvictionPolicy(subscriptionEvictionPolicy.name().toLowerCase());
+		getSubscriptionEvictionPolicy().setEvictionPolicy(config);
 
 		if (StringUtils.hasText(subscriptionDiskStore)) {
 			config.setDiskStoreName(subscriptionDiskStore);
 		}
 	}
 
+	public boolean isAutoStartup() {
+		return autoStartup;
+	}
+
+	public boolean isRunning() {
+		return (cacheServer != null && cacheServer.isRunning());
+	}
+
+	public int getPhase() {
+		// start at the latest possible moment
+		return Integer.MAX_VALUE;
+	}
+
 	public void destroy() {
 		stop();
 		cacheServer = null;
 	}
 
-	public boolean isAutoStartup() {
-		return autoStartup;
-	}
-
-	public void stop(Runnable callback) {
-		stop();
-		callback.run();
-	}
-
-	public int getPhase() {
-		// start the latest
-		return Integer.MAX_VALUE;
-	}
-
-	public boolean isRunning() {
-		return (cacheServer != null && cacheServer.isRunning());
-	}
-
 	public void start() {
 		try {
 			cacheServer.start();
-		} catch (IOException ex) {
-			throw new BeanInitializationException("Cannot start cache server", ex);
 		}
+		catch (IOException e) {
+			throw new BeanInitializationException("Cannot start cache server", e);
+		}
+	}
+
+	public void stop(final Runnable callback) {
+		stop();
+		callback.run();
 	}
 
 	public void stop() {
@@ -160,54 +160,22 @@ public class CacheServerFactoryBean implements FactoryBean<CacheServer>, Initial
 		this.autoStartup = autoStartup;
 	}
 
-	public void setPort(int port) {
-		this.port = port;
-	}
-
-	public void setMaxConnections(int maxConnections) {
-		this.maxConnections = maxConnections;
-	}
-
-	public void setMaxThreads(int maxThreads) {
-		this.maxThreads = maxThreads;
-	}
-
-	public void setNotifyBySubscription(boolean notifyBySubscription) {
-		this.notifyBySubscription = notifyBySubscription;
-	}
-
-	public void setSocketBufferSize(int socketBufferSize) {
-		this.socketBufferSize = socketBufferSize;
-	}
-
-	public void setMaxTimeBetweenPings(int maxTimeBetweenPings) {
-		this.maxTimeBetweenPings = maxTimeBetweenPings;
-	}
-
-	public void setMaxMessageCount(int maxMessageCount) {
-		this.maxMessageCount = maxMessageCount;
-	}
-
-	public void setMessageTimeToLive(int messageTimeToLive) {
-		this.messageTimeToLive = messageTimeToLive;
-	}
-
-	public void setServerGroups(String[] serverGroups) {
-		this.serverGroups = serverGroups;
-	}
-
-	public void setServerLoadProbe(ServerLoadProbe serverLoadProbe) {
-		this.serverLoadProbe = serverLoadProbe;
-	}
-
-	public void setLoadPollInterval(long loadPollInterval) {
-		this.loadPollInterval = loadPollInterval;
-	}
-
 	public void setBindAddress(String bindAddress) {
 		this.bindAddress = bindAddress;
 	}
 
+	public void setCache(final Cache cache) {
+		this.cache = cache;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * For testing purposes only!
+	 */
+	void setCacheServer(final CacheServer cacheServer) {
+		this.cacheServer = cacheServer;
+	}
+
 	public void setHostNameForClients(String hostNameForClients) {
 		this.hostNameForClients = hostNameForClients;
 	}
@@ -216,20 +184,50 @@ public class CacheServerFactoryBean implements FactoryBean<CacheServer>, Initial
 		this.listeners = listeners;
 	}
 
-	public void setCache(Cache cache) {
-		this.cache = cache;
+	public void setLoadPollInterval(long loadPollInterval) {
+		this.loadPollInterval = loadPollInterval;
 	}
 
-	/**
-	 * @param evictionPolicy the subscriptionEvictionPolicy to set
-	 */
-	public void setSubscriptionEvictionPolicy(SubscriptionEvictionPolicy evictionPolicy) {
-		this.subscriptionEvictionPolicy = evictionPolicy;
+	public void setMaxConnections(int maxConnections) {
+		this.maxConnections = maxConnections;
+	}
+
+	public void setMaxMessageCount(int maxMessageCount) {
+		this.maxMessageCount = maxMessageCount;
+	}
+
+	public void setMaxThreads(int maxThreads) {
+		this.maxThreads = maxThreads;
+	}
+
+	public void setMaxTimeBetweenPings(int maxTimeBetweenPings) {
+		this.maxTimeBetweenPings = maxTimeBetweenPings;
+	}
+
+	public void setMessageTimeToLive(int messageTimeToLive) {
+		this.messageTimeToLive = messageTimeToLive;
+	}
+
+	public void setNotifyBySubscription(boolean notifyBySubscription) {
+		this.notifyBySubscription = notifyBySubscription;
+	}
+
+	public void setPort(int port) {
+		this.port = port;
+	}
+
+	public void setServerGroups(String[] serverGroups) {
+		this.serverGroups = serverGroups;
+	}
+
+	public void setServerLoadProbe(ServerLoadProbe serverLoadProbe) {
+		this.serverLoadProbe = serverLoadProbe;
+	}
+
+	public void setSocketBufferSize(int socketBufferSize) {
+		this.socketBufferSize = socketBufferSize;
 	}
 
-	/**
-	 * @param subscriptionCapacity the subscriptionCapacity to set
-	 */
 	public void setSubscriptionCapacity(int subscriptionCapacity) {
 		this.subscriptionCapacity = subscriptionCapacity;
 	}
@@ -238,4 +236,12 @@ public class CacheServerFactoryBean implements FactoryBean<CacheServer>, Initial
 		this.subscriptionDiskStore = diskStoreName;
 	}
 
+	SubscriptionEvictionPolicy getSubscriptionEvictionPolicy() {
+		return (subscriptionEvictionPolicy != null ? subscriptionEvictionPolicy : SubscriptionEvictionPolicy.DEFAULT);
+	}
+
+	public void setSubscriptionEvictionPolicy(SubscriptionEvictionPolicy evictionPolicy) {
+		this.subscriptionEvictionPolicy = evictionPolicy;
+	}
+
 }

src/main/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicy.java

@@ -17,12 +17,59 @@
 package org.springframework.data.gemfire.server;
 
 import com.gemstone.gemfire.cache.server.CacheServer;
+import com.gemstone.gemfire.cache.server.ClientSubscriptionConfig;
 
 /**
  * Enumeration of the various client subscription policies for {@link CacheServer}.
  * 
  * @author Costin Leau
+ * @author John Blum
+ * @since 1.1.0
  */
 public enum SubscriptionEvictionPolicy {
-	NONE, MEM, ENTRY
+	ENTRY,
+	MEM,
+	NONE;
+
+	public static final SubscriptionEvictionPolicy DEFAULT = SubscriptionEvictionPolicy.valueOfIgnoreCase(
+		ClientSubscriptionConfig.DEFAULT_EVICTION_POLICY);
+
+	/**
+	 * Returns the value of the given String name as a SubscriptionEvictionPolicy enum using a case-insensitive,
+	 * equality comparison.
+	 *
+	 * @param name the String name of a SubscriptionEvictionPolicy enumerated value.
+	 * @return a SubscriptionEvictionPolicy enumerated value given a String name or null if no enum value
+	 * with name was found.
+	 * @see org.springframework.data.gemfire.server.SubscriptionEvictionPolicy
+	 * @see java.lang.String#equalsIgnoreCase(String)
+	 * @see #values()
+	 * @see #name()
+	 */
+	public static SubscriptionEvictionPolicy valueOfIgnoreCase(final String name) {
+		for (SubscriptionEvictionPolicy subscriptionEvictionPolicy : values()) {
+			if (subscriptionEvictionPolicy.name().equalsIgnoreCase(name)) {
+				return subscriptionEvictionPolicy;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Null-safe utility method for setting the client's subscription eviction policy on the configuration meta-data.
+	 *
+	 * @param config a GemFire ClientSubscriptionConfig object holding the configuration setting and meta-data
+	 * about the client's subscription configuration.
+	 * @return the ClientSubscriptionConfig object.
+	 * @see com.gemstone.gemfire.cache.server.ClientSubscriptionConfig#setEvictionPolicy(String)
+	 */
+	public ClientSubscriptionConfig setEvictionPolicy(final ClientSubscriptionConfig config) {
+		if (config != null) {
+			config.setEvictionPolicy(name().toLowerCase());
+		}
+
+		return config;
+	}
+
 }

src/main/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyConverter.java

@@ -0,0 +1,49 @@
+/*
+ * 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.server;
+
+import org.springframework.data.gemfire.support.AbstractPropertyEditorConverterSupport;
+
+/**
+ * The SubscriptionEvictionPolicyConverter class is a Spring Converter and JavaBeans PropertyEditor for converting
+ * Strings into a SubscriptionEvictionPolicy enumerated value.
+ *
+ * @author John Blum
+ * @see org.springframework.data.gemfire.server.SubscriptionEvictionPolicy
+ * @see org.springframework.data.gemfire.support.AbstractPropertyEditorConverterSupport
+ * @since 1.6.0
+ */
+@SuppressWarnings("unused")
+public class SubscriptionEvictionPolicyConverter extends AbstractPropertyEditorConverterSupport<SubscriptionEvictionPolicy> {
+
+	/**
+	 * Converts the given String into a SubscriptionEvictionPolicy enumerated value.
+	 *
+	 * @param source the String to convert into a SubscriptionEvictionPolicy enum.
+	 * @return a SubscriptionEvictionPolicy enumerated value for the given String.
+	 * @throws java.lang.IllegalArgumentException if the String is a valid SubscriptionEvictionPolicy
+	 * enumerated value.
+	 * @see org.springframework.data.gemfire.server.SubscriptionEvictionPolicy#valueOfIgnoreCase(String)
+	 * @see #assertConverted(String, Object, Class)
+	 */
+	@Override
+	public SubscriptionEvictionPolicy convert(final String source) {
+		return assertConverted(source, SubscriptionEvictionPolicy.valueOfIgnoreCase(source),
+			SubscriptionEvictionPolicy.class);
+	}
+
+}

src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.6.xsd

@@ -2122,17 +2122,8 @@ The client subscription configuration that is used to control a clients use of s
 				]]></xsd:documentation>
 					</xsd:annotation>
 					<xsd:complexType>
-						<xsd:attribute name="eviction-type" use="optional" default="NONE">
-							<xsd:simpleType>
-								<xsd:restriction base="xsd:string">
-									<xsd:enumeration value="NONE" />
-									<xsd:enumeration value="MEM" />
-									<xsd:enumeration value="ENTRY" />
-								</xsd:restriction>
-							</xsd:simpleType>
-						</xsd:attribute>
-						<xsd:attribute name="capacity" type="xsd:string"
-									   use="optional" default="1" />
+						<xsd:attribute name="eviction-type" type="xsd:string" use="optional" default="NONE"/>
+						<xsd:attribute name="capacity" type="xsd:string" use="optional" default="1"/>
 						<xsd:attribute name="disk-store" type="xsd:string" use="optional"/>
 					</xsd:complexType>
 				</xsd:element>

src/test/java/org/springframework/data/gemfire/server/CacheServerFactoryBeanTest.java

@@ -0,0 +1,233 @@
+/*
+ * 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.server;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Matchers.same;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.junit.Test;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import com.gemstone.gemfire.cache.Cache;
+import com.gemstone.gemfire.cache.InterestRegistrationListener;
+import com.gemstone.gemfire.cache.server.CacheServer;
+import com.gemstone.gemfire.cache.server.ClientSubscriptionConfig;
+import com.gemstone.gemfire.cache.server.ServerLoadProbe;
+
+/**
+ * The CacheServerFactoryBeanTest class is a test suite of test cases testing the contract and functionality
+ * of the CacheServerFactoryBean class.
+ *
+ * @author John Blum
+ * @see org.junit.Test
+ * @see org.springframework.data.gemfire.server.CacheServerFactoryBean
+ * @since 1.6.0
+ */
+public class CacheServerFactoryBeanTest {
+
+	@Test
+	public void testGetObjectUninitialized() {
+		assertNull(new CacheServerFactoryBean().getObject());
+	}
+
+	@Test
+	public void testGetObjectType() {
+		assertEquals(CacheServer.class, new CacheServerFactoryBean().getObjectType());
+	}
+
+	@Test
+	public void testIsSingleton() {
+		assertTrue(new CacheServerFactoryBean().isSingleton());
+	}
+
+	@Test
+	@SuppressWarnings("deprecation")
+	public void testAfterPropertiesSet() throws IOException {
+		Cache mockCache = mock(Cache.class, "testAfterPropertiesSet.MockCache");
+
+		CacheServer mockCacheServer = mock(CacheServer.class, "testAfterPropertiesSet.MockCacheServer");
+
+		ClientSubscriptionConfig mockClientSubscriptionConfig = mock(ClientSubscriptionConfig.class,
+			"testAfterPropertiesSet.MockClientSubscriptionConfig");
+
+		InterestRegistrationListener mockInterestRegistrationListenerOne = mock(InterestRegistrationListener.class,
+			"testAfterPropertiesSet.MockInterestRegistrationListener.One");
+
+		InterestRegistrationListener mockInterestRegistrationListenerTwo = mock(InterestRegistrationListener.class,
+			"testAfterPropertiesSet.MockInterestRegistrationListener.Two");
+
+		ServerLoadProbe mockServerLoadProbe = mock(ServerLoadProbe.class, "testAfterPropertiesSet.MockServerLoadProbe");
+
+		when(mockCache.addCacheServer()).thenReturn(mockCacheServer);
+		when(mockCacheServer.getClientSubscriptionConfig()).thenReturn(mockClientSubscriptionConfig);
+
+		CacheServerFactoryBean factoryBean = new CacheServerFactoryBean();
+
+		factoryBean.setCache(mockCache);
+		factoryBean.setBindAddress("10.124.62.5");
+		factoryBean.setHostNameForClients("skullbox");
+		factoryBean.setListeners(new HashSet<InterestRegistrationListener>(Arrays.asList(
+			mockInterestRegistrationListenerOne, mockInterestRegistrationListenerTwo)));
+		factoryBean.setLoadPollInterval(500l);
+		factoryBean.setMaxConnections(200);
+		factoryBean.setMaxMessageCount(1024);
+		factoryBean.setMaxTimeBetweenPings(2000);
+		factoryBean.setMaxThreads(50);
+		factoryBean.setMessageTimeToLive(8192);
+		factoryBean.setNotifyBySubscription(true);
+		factoryBean.setPort(54321);
+		factoryBean.setServerGroups(new String[] { "testGroup" });
+		factoryBean.setServerLoadProbe(mockServerLoadProbe);
+		factoryBean.setSocketBufferSize(4096);
+		factoryBean.setSubscriptionCapacity(8196);
+		factoryBean.setSubscriptionEvictionPolicy(SubscriptionEvictionPolicy.ENTRY);
+		factoryBean.setSubscriptionDiskStore("toTheVoid");
+		factoryBean.afterPropertiesSet();
+
+		assertSame(mockCacheServer, factoryBean.getObject());
+		assertEquals(mockCacheServer.getClass(), factoryBean.getObjectType());
+
+		verify(mockCache, times(1)).addCacheServer();
+		verify(mockCacheServer, times(1)).setBindAddress(eq("10.124.62.5"));
+		verify(mockCacheServer, times(1)).setGroups(eq(new String[] { "testGroup" }));
+		verify(mockCacheServer, times(1)).setHostnameForClients(eq("skullbox"));
+		verify(mockCacheServer, times(1)).setLoadPollInterval(eq(500l));
+		verify(mockCacheServer, times(1)).setLoadProbe(same(mockServerLoadProbe));
+		verify(mockCacheServer, times(1)).setMaxConnections(eq(200));
+		verify(mockCacheServer, times(1)).setMaximumMessageCount(eq(1024));
+		verify(mockCacheServer, times(1)).setMaximumTimeBetweenPings(eq(2000));
+		verify(mockCacheServer, times(1)).setMaxThreads(eq(50));
+		verify(mockCacheServer, times(1)).setMessageTimeToLive(eq(8192));
+		verify(mockCacheServer, times(1)).setNotifyBySubscription(eq(true));
+		verify(mockCacheServer, times(1)).setPort(eq(54321));
+		verify(mockCacheServer, times(1)).setSocketBufferSize(eq(4096));
+		verify(mockCacheServer, times(1)).registerInterestRegistrationListener(
+			same(mockInterestRegistrationListenerOne));
+		verify(mockCacheServer, times(1)).registerInterestRegistrationListener(
+			same(mockInterestRegistrationListenerTwo));
+		verify(mockCacheServer, times(1)).getClientSubscriptionConfig();
+		verify(mockClientSubscriptionConfig, times(1)).setCapacity(eq(8196));
+		verify(mockClientSubscriptionConfig, times(1)).setDiskStoreName(eq("toTheVoid"));
+		verify(mockClientSubscriptionConfig, times(1)).setEvictionPolicy("entry");
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testAfterPropertiesSetWithNullCache() throws IOException {
+		try {
+			new CacheServerFactoryBean().afterPropertiesSet();
+		}
+		catch (IllegalArgumentException expected) {
+			assertEquals("A GemFire Cache is required.", expected.getMessage());
+			throw expected;
+		}
+	}
+
+	@Test
+	public void testSetAndGetAutoStartup() {
+		CacheServerFactoryBean factoryBean = new CacheServerFactoryBean();
+
+		assertTrue(factoryBean.isAutoStartup());
+
+		factoryBean.setAutoStartup(false);
+
+		assertFalse(factoryBean.isAutoStartup());
+	}
+
+	@Test
+	public void testSetAndGetSubscriptionEvictionPolicy() {
+		CacheServerFactoryBean factoryBean = new CacheServerFactoryBean();
+
+		assertEquals(SubscriptionEvictionPolicy.DEFAULT, factoryBean.getSubscriptionEvictionPolicy());
+
+		factoryBean.setSubscriptionEvictionPolicy(SubscriptionEvictionPolicy.MEM);
+
+		assertEquals(SubscriptionEvictionPolicy.MEM, factoryBean.getSubscriptionEvictionPolicy());
+
+		factoryBean.setSubscriptionEvictionPolicy(null);
+
+		assertEquals(SubscriptionEvictionPolicy.DEFAULT, factoryBean.getSubscriptionEvictionPolicy());
+	}
+
+	@Test
+	public void testCacheServerLifecycle() throws Exception {
+		CacheServer mockCacheServer = mock(CacheServer.class, "testCacheServerLifecycle.MockCacheServer");
+
+		final AtomicBoolean running = new AtomicBoolean(false);
+		final AtomicBoolean called = new AtomicBoolean(false);
+
+		doAnswer(new Answer() {
+			@Override
+			public Object answer(final InvocationOnMock invocationOnMock) throws Throwable {
+				running.compareAndSet(false, true);
+				return null;
+			}
+		}).when(mockCacheServer).start();
+
+		doAnswer(new Answer() {
+			@Override
+			public Object answer(final InvocationOnMock invocationOnMock) throws Throwable {
+				running.compareAndSet(true, false);
+				return null;
+			}
+		}).when(mockCacheServer).stop();
+
+		when(mockCacheServer.isRunning()).then(new Answer<Boolean>() {
+			@Override
+			public Boolean answer(final InvocationOnMock invocationOnMock) throws Throwable {
+				return running.get();
+			}
+		});
+
+		CacheServerFactoryBean factoryBean = new CacheServerFactoryBean();
+
+		factoryBean.setCacheServer(mockCacheServer);
+
+		assertSame(mockCacheServer, factoryBean.getObject());
+		assertFalse(factoryBean.isRunning());
+
+		factoryBean.start();
+
+		assertTrue(factoryBean.isRunning());
+		assertFalse(called.get());
+
+		factoryBean.stop(new Runnable() {
+			@Override public void run() {
+				called.set(true);
+			}
+		});
+
+		assertFalse(factoryBean.isRunning());
+		assertTrue(called.get());
+	}
+
+}

src/test/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyConverterTest.java

@@ -0,0 +1,87 @@
+/*
+ * 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.server;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import org.junit.After;
+import org.junit.Test;
+
+/**
+ * The SubscriptionEvictionPolicyConverterTest class is a test suite of test cases testing the contract
+ * and functionality of the SubscriptionEvictionPolicyConverter class.
+ *
+ * @author John Blum
+ * @see org.junit.Test
+ * @see org.springframework.data.gemfire.server.SubscriptionEvictionPolicy
+ * @see org.springframework.data.gemfire.server.SubscriptionEvictionPolicyConverter
+ * @since 1.6.0
+ */
+public class SubscriptionEvictionPolicyConverterTest {
+
+	private final SubscriptionEvictionPolicyConverter converter = new SubscriptionEvictionPolicyConverter();
+
+	@After
+	public void tearDown() {
+		converter.setValue(null);
+	}
+
+	@Test
+	public void testConvert() {
+		assertEquals(SubscriptionEvictionPolicy.ENTRY, converter.convert("EnTry"));
+		assertEquals(SubscriptionEvictionPolicy.MEM, converter.convert("MEM"));
+		assertEquals(SubscriptionEvictionPolicy.NONE, converter.convert("nONE"));
+		assertEquals(SubscriptionEvictionPolicy.NONE, converter.convert("NOne"));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testConvertIllegalValue() {
+		try {
+			converter.setAsText("memory");
+		}
+		catch (IllegalArgumentException expected) {
+			assertEquals("(memory) is not a valid SubscriptionEvictionPolicy!", expected.getMessage());
+			throw expected;
+		}
+	}
+
+	@Test
+	public void testSetAsText() {
+		assertNull(converter.getValue());
+		converter.setAsText("enTRY");
+		assertEquals(SubscriptionEvictionPolicy.ENTRY, converter.getValue());
+		converter.setAsText("MEm");
+		assertEquals(SubscriptionEvictionPolicy.MEM, converter.getValue());
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testSetAsTextWithIllegalValue() {
+		try {
+			assertNull(converter.getValue());
+			converter.setAsText("KEYS");
+		}
+		catch (IllegalArgumentException expected) {
+			assertEquals("(KEYS) is not a valid SubscriptionEvictionPolicy!", expected.getMessage());
+			throw expected;
+		}
+		finally {
+			assertNull(converter.getValue());
+		}
+	}
+
+}

src/test/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyTest.java

@@ -0,0 +1,87 @@
+/*
+ * 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.server;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import org.junit.Test;
+
+import com.gemstone.gemfire.cache.server.ClientSubscriptionConfig;
+
+/**
+ * The SubscriptionEvictionPolicyTest class is a test suite of test cases testing the contract and functionality
+ * of the SubscriptionEvictionPolicy enum.
+ *
+ * @author John Blum
+ * @see org.junit.Test
+ * @see org.springframework.data.gemfire.server.SubscriptionEvictionPolicy
+ * @since 1.6.0
+ */
+public class SubscriptionEvictionPolicyTest {
+
+	@Test
+	public void testDefault() {
+		assertEquals(ClientSubscriptionConfig.DEFAULT_EVICTION_POLICY.toLowerCase(),
+			SubscriptionEvictionPolicy.DEFAULT.name().toLowerCase());
+		assertSame(SubscriptionEvictionPolicy.NONE, SubscriptionEvictionPolicy.DEFAULT);
+	}
+
+	@Test
+	public void testValueOfIgnoreCase() {
+		assertEquals(SubscriptionEvictionPolicy.ENTRY, SubscriptionEvictionPolicy.valueOfIgnoreCase("entry"));
+		assertEquals(SubscriptionEvictionPolicy.MEM, SubscriptionEvictionPolicy.valueOfIgnoreCase("Mem"));
+		assertEquals(SubscriptionEvictionPolicy.NONE, SubscriptionEvictionPolicy.valueOfIgnoreCase("NOne"));
+		assertEquals(SubscriptionEvictionPolicy.NONE, SubscriptionEvictionPolicy.valueOfIgnoreCase("nONE"));
+		assertEquals(SubscriptionEvictionPolicy.NONE, SubscriptionEvictionPolicy.valueOfIgnoreCase("NONE"));
+	}
+
+	@Test
+	public void testValueOfIgnoreCaseWithIllegalValue() {
+		assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase("KEYS"));
+		assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase("Memory"));
+		assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase("all"));
+		assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase("no"));
+		assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase("one"));
+		assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase("  "));
+		assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase(""));
+		assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase(null));
+	}
+
+	@Test
+	public void testSetEvictionPolicy() {
+		ClientSubscriptionConfig mockConfig = mock(ClientSubscriptionConfig.class,
+			"testSetEvictionPolicy.ClientSubscriptionConfig");
+
+		ClientSubscriptionConfig returnedConfig = SubscriptionEvictionPolicy.MEM.setEvictionPolicy(mockConfig);
+
+		assertSame(mockConfig, returnedConfig);
+
+		verify(mockConfig, times(1)).setEvictionPolicy(eq("mem"));
+	}
+
+	@Test
+	public void testSetEvictionPolicyWithNull() {
+		assertNull(SubscriptionEvictionPolicy.ENTRY.setEvictionPolicy(null));
+	}
+
+}

src/test/resources/org/springframework/data/gemfire/config/server-ns.xml

@@ -11,23 +11,28 @@
 		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
 ">
 
+	<util:properties id="cacheServerConfiguration">
+		<prop key="server.port">40406</prop>
+		<prop key="subscription.eviction.policy">ENTRY</prop>
+	</util:properties>
+
+	<context:property-placeholder properties-ref="cacheServerConfiguration"/>
+
 	<util:properties id="gemfireProperties">
-		<prop key="name">ServerNamespaceConfig</prop>
+		<prop key="name">CacheServerNamespaceTest</prop>
 		<prop key="mcast-port">0</prop>
 		<prop key="log-level">warning</prop>
 	</util:properties>
 
 	<gfe:cache properties-ref="gemfireProperties"/>
 
-	<context:property-placeholder location="classpath:port.properties"/>
-
 	<bean id="bean1" class="org.springframework.data.gemfire.Init"/>
 
 	<!-- Advanced example depicting various cache server configuration options -->
-	<gfe:cache-server id="advanced-config" auto-startup="true" bind-address="localhost" port="${gfe.port.6}"
+	<gfe:cache-server id="advanced-config" auto-startup="true" bind-address="localhost" port="${server.port}"
 					  host-name-for-clients="localhost" groups="test-server" load-poll-interval="2000"
 					  max-connections="22" max-threads="16" max-message-count="1000" max-time-between-pings="30000">
-		<gfe:subscription-config eviction-type="ENTRY" capacity="1000"/>
+		<gfe:subscription-config eviction-type="${subscription.eviction.policy}" capacity="1000"/>
 	</gfe:cache-server>
 
 	<bean id="bean2" class="org.springframework.data.gemfire.Init"/>