You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by oh...@apache.org on 2013/11/26 21:35:00 UTC
svn commit: r1545825 - in /commons/proper/configuration/trunk/src:
main/java/org/apache/commons/configuration/builder/fluent/Parameters.java
test/java/org/apache/commons/configuration/builder/fluent/TestParameters.java
Author: oheger
Date: Tue Nov 26 20:35:00 2013
New Revision: 1545825
URL: http://svn.apache.org/r1545825
Log:
Parameters now uses a DefaultParametersManager.
The handling of default values for newly created parameters objects is now
delegated to a DefaultParametersManager instance which can either be passed to
the constructor or is dynamically created.
Modified:
commons/proper/configuration/trunk/src/main/java/org/apache/commons/configuration/builder/fluent/Parameters.java
commons/proper/configuration/trunk/src/test/java/org/apache/commons/configuration/builder/fluent/TestParameters.java
Modified: commons/proper/configuration/trunk/src/main/java/org/apache/commons/configuration/builder/fluent/Parameters.java
URL: http://svn.apache.org/viewvc/commons/proper/configuration/trunk/src/main/java/org/apache/commons/configuration/builder/fluent/Parameters.java?rev=1545825&r1=1545824&r2=1545825&view=diff
==============================================================================
--- commons/proper/configuration/trunk/src/main/java/org/apache/commons/configuration/builder/fluent/Parameters.java (original)
+++ commons/proper/configuration/trunk/src/main/java/org/apache/commons/configuration/builder/fluent/Parameters.java Tue Nov 26 20:35:00 2013
@@ -19,14 +19,12 @@ package org.apache.commons.configuration
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.concurrent.CopyOnWriteArrayList;
import org.apache.commons.configuration.builder.BasicBuilderParameters;
import org.apache.commons.configuration.builder.BuilderParameters;
import org.apache.commons.configuration.builder.DatabaseBuilderParametersImpl;
import org.apache.commons.configuration.builder.DefaultParametersHandler;
+import org.apache.commons.configuration.builder.DefaultParametersManager;
import org.apache.commons.configuration.builder.FileBasedBuilderParametersImpl;
import org.apache.commons.configuration.builder.HierarchicalBuilderParametersImpl;
import org.apache.commons.configuration.builder.JndiBuilderParametersImpl;
@@ -69,13 +67,13 @@ import org.apache.commons.configuration.
* <p>
* Using this class it is not only possible to create new parameters objects but
* also to initialize the newly created objects with default values. This is
- * achieved by registering objects implementing the
- * {@link DefaultParametersHandler} interface with the
- * {@code registerDefaultsHandler()} method. The handler object is then called
- * whenever a parameters object of the supported class (or one of its
- * subclasses) is created. This makes it easy to define default settings that
- * are applied for all parameters object created by this {@code Parameters}
- * instance.
+ * via the associated {@link DefaultParametersManager} object. Such an object
+ * can be passed to the constructor, or a new (uninitialized) instance is
+ * created. There are convenience methods for interacting with the associated
+ * {@code DefaultParametersManager}, namely to register or remove
+ * {@link DefaultParametersHandler} objects. On all newly created parameters
+ * objects the handlers registered at the associated {@code DefaultParametersHandler}
+ * are automatically applied.
* </p>
* <p>
* Implementation note: This class is thread-safe.
@@ -86,27 +84,48 @@ import org.apache.commons.configuration.
*/
public final class Parameters
{
- /** A collection with the registered default handlers. */
- private final Collection<DefaultHandlerData> defaultHandlers;
+ /** The manager for default handlers. */
+ private final DefaultParametersManager defaultParametersManager;
/**
- * Creates a new instance of {@code Parameters}.
+ * Creates a new instance of {@code Parameters}. A new, uninitialized
+ * {@link DefaultParametersManager} is created.
*/
public Parameters()
{
- defaultHandlers = new CopyOnWriteArrayList<DefaultHandlerData>();
+ this(null);
+ }
+
+ /**
+ * Creates a new instance of {@code Parameters} and initializes it with the
+ * given {@code DefaultParametersManager}. Because
+ * {@code DefaultParametersManager} is thread-safe, it makes sense to share
+ * a single instance between multiple {@code Parameters} objects; that way
+ * the same initialization is performed on newly created parameters objects.
+ *
+ * @param manager the {@code DefaultParametersHandler} (may be <b>null</b>,
+ * then a new default instance is created)
+ */
+ public Parameters(DefaultParametersManager manager)
+ {
+ defaultParametersManager =
+ (manager != null) ? manager : new DefaultParametersManager();
+ }
+
+ /**
+ * Returns the {@code DefaultParametersManager} associated with this object.
+ *
+ * @return the {@code DefaultParametersManager}
+ */
+ public DefaultParametersManager getDefaultParametersManager()
+ {
+ return defaultParametersManager;
}
/**
* Registers the specified {@code DefaultParametersHandler} object for the
- * given parameters class. This means that this handler object is invoked
- * every time a new parameters object of the specified class or one of its
- * subclasses is created. The handler can set arbitrary default values for
- * the properties supported by this parameters object. If there are multiple
- * handlers registered supporting a specific parameters class, they are
- * invoked in the order in which they were registered. So handlers
- * registered later may override the values set by handlers registered
- * earlier.
+ * given parameters class. This is a convenience method which just delegates
+ * to the associated {@code DefaultParametersManager}.
*
* @param <T> the type of the parameters supported by this handler
* @param paramsClass the parameters class supported by this handler (must
@@ -114,43 +133,19 @@ public final class Parameters
* @param handler the {@code DefaultParametersHandler} to be registered
* (must not be <b>null</b>)
* @throws IllegalArgumentException if a required parameter is missing
+ * @see DefaultParametersManager
*/
public <T> void registerDefaultsHandler(Class<T> paramsClass,
DefaultParametersHandler<? super T> handler)
{
- registerDefaultsHandler(paramsClass, handler, null);
+ getDefaultParametersManager().registerDefaultsHandler(paramsClass, handler);
}
/**
* Registers the specified {@code DefaultParametersHandler} object for the
* given parameters class and start class in the inheritance hierarchy. This
- * method works like
- * {@link #registerDefaultsHandler(Class, DefaultParametersHandler)}, but
- * the defaults handler is only executed on parameter objects that are
- * instances of the specified start class. Parameter classes do not stand in
- * a real inheritance hierarchy; however, there is a logic hierarchy defined
- * by the methods supported by the different parameter objects. A properties
- * parameter object for instance supports all methods defined for a
- * file-based parameter object. So one can argue that
- * {@link FileBasedBuilderParameters} is a base interface of
- * {@link PropertiesBuilderParameters} (although, for technical reasons,
- * this relation is not reflected in the Java classes). A
- * {@link DefaultParametersHandler} object defined for a base interface can
- * also deal with parameter objects "derived" from this base interface (i.e.
- * supporting a super set of the methods defined by the base interface). Now
- * there may be the use case that there is an implementation of
- * {@code DefaultParametersHandler} for a base interface (e.g.
- * {@code FileBasedBuilderParameters}), but it should only process specific
- * derived interfaces (say {@code PropertiesBuilderParameters}, but not
- * {@link XMLBuilderParameters}). This can be achieved by passing in
- * {@code PropertiesBuilderParameters} as start class. In this case,
- * {@code Parameters} ensures that the handler is only called on parameter
- * objects having both the start class and the actual type supported by the
- * handler as base interfaces. The passed in start class can be <b>null</b>;
- * then the parameter class supported by the handler is used (which is the
- * default behavior of the
- * {@link #registerDefaultsHandler(Class, DefaultParametersHandler)}
- * method).
+ * is a convenience method which just delegates to the associated
+ * {@code DefaultParametersManager}.
*
* @param <T> the type of the parameters supported by this handler
* @param paramsClass the parameters class supported by this handler (must
@@ -164,57 +159,8 @@ public final class Parameters
public <T> void registerDefaultsHandler(Class<T> paramsClass,
DefaultParametersHandler<? super T> handler, Class<?> startClass)
{
- if (paramsClass == null)
- {
- throw new IllegalArgumentException(
- "Parameters class must not be null!");
- }
- if (handler == null)
- {
- throw new IllegalArgumentException(
- "DefaultParametersHandler must not be null!");
- }
- defaultHandlers.add(new DefaultHandlerData(handler, paramsClass,
- startClass));
- }
-
- /**
- * Removes the specified {@code DefaultParametersHandler} from this
- * instance. If this handler has been registered multiple times for
- * different start classes, all occurrences are removed.
- *
- * @param handler the {@code DefaultParametersHandler} to be removed
- */
- public void unregisterDefaultsHandler(DefaultParametersHandler<?> handler)
- {
- unregisterDefaultsHandler(handler, null);
- }
-
- /**
- * Removes the specified {@code DefaultParametersHandler} from this instance
- * if it is in combination with the given start class. If this handler has
- * been registered multiple times for different start classes, only
- * occurrences for the given start class are removed. The {@code startClass}
- * parameter can be <b>null</b>, then all occurrences of the handler are
- * removed.
- *
- * @param handler the {@code DefaultParametersHandler} to be removed
- * @param startClass the start class for which this handler is to be removed
- */
- public void unregisterDefaultsHandler(DefaultParametersHandler<?> handler,
- Class<?> startClass)
- {
- Collection<DefaultHandlerData> toRemove =
- new LinkedList<DefaultHandlerData>();
- for (DefaultHandlerData dhd : defaultHandlers)
- {
- if (dhd.isOccurrence(handler, startClass))
- {
- toRemove.add(dhd);
- }
- }
-
- defaultHandlers.removeAll(toRemove);
+ getDefaultParametersManager().registerDefaultsHandler(paramsClass,
+ handler, startClass);
}
/**
@@ -326,31 +272,6 @@ public final class Parameters
}
/**
- * Initializes the passed in {@code BuilderParameters} object by applying
- * all matching {@link DefaultParametersHandler} objects registered at this
- * instance. Using this method the passed in parameters object can be
- * populated with default values. It is not necessary to call this method
- * for parameter objects that have been created by this {@code Parameters}
- * instance - in this case, it is called automatically. However, if a
- * parameters object was created by another source, this method can be used
- * to apply the {@code DefaultParametersHandler} objects which have been
- * registered here.
- *
- * @param params the parameters object to be initialized (may be
- * <b>null</b>, then this method has no effect)
- */
- public void initializeParameters(BuilderParameters params)
- {
- if (params != null)
- {
- for (DefaultHandlerData dhd : defaultHandlers)
- {
- dhd.applyHandlerIfMatching(params);
- }
- }
- }
-
- /**
* Creates a proxy object for a given parameters interface based on the
* given implementation object. The newly created object is initialized
* with default values if there are matching {@link DefaultParametersHandler}
@@ -372,7 +293,8 @@ public final class Parameters
Object obj =
Proxy.newProxyInstance(Parameters.class.getClassLoader(),
ifcClasses, new ParametersIfcInvocationHandler(target));
- initializeParameters((BuilderParameters) obj);
+ getDefaultParametersManager().initializeParameters(
+ (BuilderParameters) obj);
return ifcClass.cast(obj);
}
@@ -429,71 +351,4 @@ public final class Parameters
&& !declaringClass.equals(BuilderParameters.class);
}
}
-
- /**
- * A data class storing information about {@code DefaultParametersHandler}
- * objects added to a {@code Parameters} object. Using this class it is
- * possible to find out which default handlers apply for a given parameters
- * object and to invoke them.
- */
- private static class DefaultHandlerData
- {
- /** The handler object.*/
- private final DefaultParametersHandler<?> handler;
-
- /** The class supported by this handler.*/
- private final Class<?> parameterClass;
-
- /** The start class for applying this handler.*/
- private final Class<?> startClass;
-
- /**
- *
- * Creates a new instance of {@code DefaultHandlerData}.
- * @param h the {@code DefaultParametersHandler}
- * @param cls the handler's data class
- * @param startCls the start class
- */
- public DefaultHandlerData(DefaultParametersHandler<?> h, Class<?> cls, Class<?> startCls)
- {
- handler = h;
- parameterClass = cls;
- startClass = startCls;
- }
-
- /**
- * Checks whether the managed {@code DefaultParametersHandler} can be
- * applied to the given parameters object. If this is the case, it is
- * executed on this object and can initialize it with default values.
- * @param obj the parameters object to be initialized
- */
- @SuppressWarnings("unchecked")
- // There are explicit isInstance() checks, so there won't be
- // ClassCastExceptions
- public void applyHandlerIfMatching(BuilderParameters obj)
- {
- if(parameterClass.isInstance(obj) && (startClass == null || startClass.isInstance(obj)))
- {
- @SuppressWarnings("rawtypes")
- DefaultParametersHandler handlerUntyped = handler;
- handlerUntyped.initializeDefaults(obj);
- }
- }
-
- /**
- * Tests whether this instance refers to the specified occurrence of a
- * {@code DefaultParametersHandler}.
- *
- * @param h the handler to be checked
- * @param startCls the start class
- * @return <b>true</b> if this instance refers to this occurrence,
- * <b>false</b> otherwise
- */
- public boolean isOccurrence(DefaultParametersHandler<?> h,
- Class<?> startCls)
- {
- return h == handler
- && (startCls == null || startCls.equals(startClass));
- }
- }
}
Modified: commons/proper/configuration/trunk/src/test/java/org/apache/commons/configuration/builder/fluent/TestParameters.java
URL: http://svn.apache.org/viewvc/commons/proper/configuration/trunk/src/test/java/org/apache/commons/configuration/builder/fluent/TestParameters.java?rev=1545825&r1=1545824&r2=1545825&view=diff
==============================================================================
--- commons/proper/configuration/trunk/src/test/java/org/apache/commons/configuration/builder/fluent/TestParameters.java (original)
+++ commons/proper/configuration/trunk/src/test/java/org/apache/commons/configuration/builder/fluent/TestParameters.java Tue Nov 26 20:35:00 2013
@@ -17,12 +17,12 @@
package org.apache.commons.configuration.builder.fluent;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
+import java.util.ArrayList;
+import java.util.List;
import java.util.Map;
import org.apache.commons.configuration.PropertiesConfiguration;
@@ -30,13 +30,14 @@ import org.apache.commons.configuration.
import org.apache.commons.configuration.builder.BasicBuilderProperties;
import org.apache.commons.configuration.builder.BuilderParameters;
import org.apache.commons.configuration.builder.DefaultParametersHandler;
+import org.apache.commons.configuration.builder.DefaultParametersManager;
import org.apache.commons.configuration.builder.FileBasedBuilderParametersImpl;
import org.apache.commons.configuration.builder.combined.CombinedBuilderParametersImpl;
import org.apache.commons.configuration.builder.combined.MultiFileBuilderParametersImpl;
import org.apache.commons.configuration.convert.ListDelimiterHandler;
import org.apache.commons.configuration.tree.ExpressionEngine;
import org.easymock.EasyMock;
-import org.junit.Before;
+import org.easymock.IAnswer;
import org.junit.BeforeClass;
import org.junit.Test;
@@ -53,19 +54,22 @@ public class TestParameters
/** A test list delimiter handler. */
private static ListDelimiterHandler listHandler;
- /** The parameters object to be tested. */
- private Parameters parameters;
-
@BeforeClass
public static void setUpBeforeClass() throws Exception
{
listHandler = EasyMock.createMock(ListDelimiterHandler.class);
}
- @Before
- public void setUp() throws Exception
+ /**
+ * Tests whether an uninitialized default parameters manager is created at
+ * construction time.
+ */
+ @Test
+ public void testDefaultParametersManager()
{
- parameters = new Parameters();
+ Parameters parameters = new Parameters();
+ assertNotNull("No default manager",
+ parameters.getDefaultParametersManager());
}
/**
@@ -74,7 +78,7 @@ public class TestParameters
@Test
public void testBasic()
{
- BasicBuilderParameters basic = parameters.basic();
+ BasicBuilderParameters basic = new Parameters().basic();
assertNotNull("No result object", basic);
}
@@ -99,7 +103,7 @@ public class TestParameters
public void testFileBased()
{
Map<String, Object> map =
- parameters.fileBased().setThrowExceptionOnMissing(true)
+ new Parameters().fileBased().setThrowExceptionOnMissing(true)
.setEncoding(DEF_ENCODING).setListDelimiterHandler(listHandler)
.setFileName("test.xml").getParameters();
FileBasedBuilderParametersImpl fbparams =
@@ -145,7 +149,7 @@ public class TestParameters
@Test
public void testFileBasedInheritance()
{
- checkInheritance(parameters.fileBased());
+ checkInheritance(new Parameters().fileBased());
}
/**
@@ -155,7 +159,7 @@ public class TestParameters
@Test
public void testProxyObjectMethods()
{
- FileBasedBuilderParameters params = parameters.fileBased();
+ FileBasedBuilderParameters params = new Parameters().fileBased();
String s = params.toString();
assertTrue(
"Wrong string: " + s,
@@ -170,7 +174,7 @@ public class TestParameters
public void testCombined()
{
Map<String, Object> map =
- parameters.combined().setThrowExceptionOnMissing(true)
+ new Parameters().combined().setThrowExceptionOnMissing(true)
.setBasePath("test").setListDelimiterHandler(listHandler)
.getParameters();
CombinedBuilderParametersImpl cparams =
@@ -186,7 +190,7 @@ public class TestParameters
public void testJndi()
{
Map<String, Object> map =
- parameters.jndi().setThrowExceptionOnMissing(true)
+ new Parameters().jndi().setThrowExceptionOnMissing(true)
.setPrefix("test").setListDelimiterHandler(listHandler)
.getParameters();
assertEquals("Wrong prefix", "test", map.get("prefix"));
@@ -202,7 +206,7 @@ public class TestParameters
{
ExpressionEngine engine = EasyMock.createMock(ExpressionEngine.class);
Map<String, Object> map =
- parameters.hierarchical().setThrowExceptionOnMissing(true)
+ new Parameters().hierarchical().setThrowExceptionOnMissing(true)
.setExpressionEngine(engine).setFileName("test.xml")
.setListDelimiterHandler(listHandler).getParameters();
checkBasicProperties(map);
@@ -220,7 +224,7 @@ public class TestParameters
@Test
public void testHierarchicalInheritance()
{
- checkInheritance(parameters.hierarchical(),
+ checkInheritance(new Parameters().hierarchical(),
FileBasedBuilderParameters.class);
}
@@ -233,7 +237,7 @@ public class TestParameters
{
ExpressionEngine engine = EasyMock.createMock(ExpressionEngine.class);
Map<String, Object> map =
- parameters.xml().setThrowExceptionOnMissing(true)
+ new Parameters().xml().setThrowExceptionOnMissing(true)
.setFileName("test.xml").setValidating(true)
.setExpressionEngine(engine).setListDelimiterHandler(listHandler)
.setSchemaValidation(true).getParameters();
@@ -256,7 +260,7 @@ public class TestParameters
@Test
public void testXmlInheritance()
{
- checkInheritance(parameters.xml(), HierarchicalBuilderParameters.class,
+ checkInheritance(new Parameters().xml(), HierarchicalBuilderParameters.class,
FileBasedBuilderParameters.class);
}
@@ -270,7 +274,7 @@ public class TestParameters
PropertiesConfiguration.IOFactory factory =
EasyMock.createMock(PropertiesConfiguration.IOFactory.class);
Map<String, Object> map =
- parameters.properties().setThrowExceptionOnMissing(true)
+ new Parameters().properties().setThrowExceptionOnMissing(true)
.setFileName("test.properties").setIOFactory(factory)
.setListDelimiterHandler(listHandler).setIncludesAllowed(false)
.getParameters();
@@ -290,7 +294,7 @@ public class TestParameters
@Test
public void testPropertiesInheritance()
{
- checkInheritance(parameters.properties(),
+ checkInheritance(new Parameters().properties(),
FileBasedBuilderParameters.class);
}
@@ -303,7 +307,7 @@ public class TestParameters
BuilderParameters bp = EasyMock.createMock(BuilderParameters.class);
String pattern = "a pattern";
Map<String, Object> map =
- parameters.multiFile().setThrowExceptionOnMissing(true)
+ new Parameters().multiFile().setThrowExceptionOnMissing(true)
.setFilePattern(pattern).setListDelimiterHandler(listHandler)
.setManagedBuilderParameters(bp).getParameters();
checkBasicProperties(map);
@@ -322,7 +326,7 @@ public class TestParameters
public void testDatabase()
{
Map<String, Object> map =
- parameters.database().setThrowExceptionOnMissing(true)
+ new Parameters().database().setThrowExceptionOnMissing(true)
.setAutoCommit(true).setTable("table")
.setListDelimiterHandler(listHandler).setKeyColumn("keyColumn")
.getParameters();
@@ -341,7 +345,7 @@ public class TestParameters
@Test
public void testInheritance()
{
- Object params = parameters.xml();
+ Object params = new Parameters().xml();
assertTrue("No instance of base interface",
params instanceof FileBasedBuilderParameters);
assertTrue("No instance of base interface (dynamic)",
@@ -358,196 +362,84 @@ public class TestParameters
}
/**
- * Tries to register a default handler without a class.
- */
- @Test(expected = IllegalArgumentException.class)
- public void testRegisterDefaultsHandlerNoClass()
- {
- parameters
- .registerDefaultsHandler(null, new FileBasedDefaultsHandler());
- }
-
- /**
- * Tries to register a null default handler.
- */
- @Test(expected = IllegalArgumentException.class)
- public void testRegisterDefaultsHandlerNoHandler()
- {
- parameters.registerDefaultsHandler(BasicBuilderProperties.class, null);
- }
-
- /**
- * Checks whether the expected default values have been set on a parameters
- * object.
- *
- * @param map the map with parameters
- */
- private static void checkDefaultValues(Map<String, Object> map)
- {
- checkBasicProperties(map);
- FileBasedBuilderParametersImpl fbparams =
- FileBasedBuilderParametersImpl.fromParameters(map);
- assertEquals("Wrong encoding", DEF_ENCODING, fbparams.getFileHandler()
- .getEncoding());
- }
-
- /**
- * Checks that no default values have been set on a parameters object.
- *
- * @param map the map with parameters
- */
- private static void checkNoDefaultValues(Map<String, Object> map)
- {
- assertFalse("Got base properties",
- map.containsKey("throwExceptionOnMissing"));
- FileBasedBuilderParametersImpl fbParams =
- FileBasedBuilderParametersImpl.fromParameters(map, true);
- assertNull("Got an encoding", fbParams.getFileHandler().getEncoding());
- }
-
- /**
* Tests whether default values are set for newly created parameters
* objects.
*/
@Test
public void testApplyDefaults()
{
- parameters.registerDefaultsHandler(FileBasedBuilderParameters.class,
- new FileBasedDefaultsHandler());
- Map<String, Object> map = parameters.fileBased().getParameters();
- checkDefaultValues(map);
- }
-
- /**
- * Tests whether default values are also applied when a sub parameters class
- * is created.
- */
- @Test
- public void testApplyDefaultsOnSubClass()
- {
- parameters.registerDefaultsHandler(FileBasedBuilderParameters.class,
- new FileBasedDefaultsHandler());
- Map<String, Object> map = parameters.xml().getParameters();
- checkDefaultValues(map);
- }
-
- /**
- * Tests that default values are only applied if the start class provided at
- * registration time matches.
- */
- @Test
- public void testApplyDefaultsStartClass()
- {
- parameters.registerDefaultsHandler(FileBasedBuilderParameters.class,
- new FileBasedDefaultsHandler(), XMLBuilderParameters.class);
- Map<String, Object> map = parameters.xml().getParameters();
- checkDefaultValues(map);
- map = parameters.properties().getParameters();
- checkNoDefaultValues(map);
- }
-
- /**
- * Tests whether multiple handlers can be registered for the same classes
- * and whether they are called in the correct order.
- */
- @Test
- public void testApplyDefaultsMultipleHandlers()
- {
- final ExpressionEngine engine =
- EasyMock.createMock(ExpressionEngine.class);
- parameters.registerDefaultsHandler(XMLBuilderParameters.class,
- new DefaultParametersHandler<XMLBuilderParameters>()
- {
- public void initializeDefaults(
- XMLBuilderParameters parameters)
- {
- parameters
- .setThrowExceptionOnMissing(false)
- .setListDelimiterHandler(
- EasyMock.createMock(ListDelimiterHandler.class))
- .setExpressionEngine(engine);
- }
- });
- parameters.registerDefaultsHandler(FileBasedBuilderParameters.class,
- new FileBasedDefaultsHandler());
- Map<String, Object> map = parameters.xml().getParameters();
- checkDefaultValues(map);
- assertSame("Expression engine not set", engine,
- map.get("expressionEngine"));
+ DefaultParametersManager manager =
+ EasyMock.createMock(DefaultParametersManager.class);
+ final List<Object> initializedParams = new ArrayList<Object>(1);
+ manager.initializeParameters(EasyMock
+ .anyObject(BuilderParameters.class));
+ EasyMock.expectLastCall().andAnswer(new IAnswer<Object>()
+ {
+ public Object answer() throws Throwable
+ {
+ initializedParams.add(EasyMock.getCurrentArguments()[0]);
+ return null;
+ }
+ });
+ EasyMock.replay(manager);
+
+ Parameters params = new Parameters(manager);
+ XMLBuilderParameters xmlParams = params.xml();
+ assertEquals("Wrong number of initializations", 1,
+ initializedParams.size());
+ assertSame("Wrong initialized object", xmlParams,
+ initializedParams.get(0));
}
/**
- * Tests whether initializeParameters() ignores null input. (We can only
- * test that no exception is thrown.)
+ * Creates a mock for a defaults parameter handler.
+ *
+ * @return the mock object
*/
- @Test
- public void testInitializeParametersNull()
+ private static DefaultParametersHandler<XMLBuilderParameters> createHandlerMock()
{
- parameters.registerDefaultsHandler(FileBasedBuilderParameters.class,
- new FileBasedDefaultsHandler());
- parameters.initializeParameters(null);
+ @SuppressWarnings("unchecked")
+ DefaultParametersHandler<XMLBuilderParameters> handler =
+ EasyMock.createMock(DefaultParametersHandler.class);
+ return handler;
}
/**
- * Tests whether a parameters object created externally can be initialized.
+ * Tests whether a default handler with a start class can be registered.
*/
@Test
- public void testInitializeParameters()
+ public void testRegisterDefaultsHandlerWithStartClass()
{
- parameters.registerDefaultsHandler(FileBasedBuilderParameters.class,
- new FileBasedDefaultsHandler());
- XMLBuilderParameters params = new Parameters().xml();
- parameters.initializeParameters(params);
- checkDefaultValues(params.getParameters());
- }
+ DefaultParametersManager manager =
+ EasyMock.createMock(DefaultParametersManager.class);
+ DefaultParametersHandler<XMLBuilderParameters> handler =
+ createHandlerMock();
+ manager.registerDefaultsHandler(XMLBuilderParameters.class, handler,
+ FileBasedBuilderParameters.class);
+ EasyMock.replay(manager, handler);
- /**
- * Tests whether all occurrences of a given defaults handler can be removed.
- */
- @Test
- public void testUnregisterDefaultsHandlerAll()
- {
- FileBasedDefaultsHandler handler = new FileBasedDefaultsHandler();
- parameters.registerDefaultsHandler(FileBasedBuilderParameters.class,
- handler, XMLBuilderParameters.class);
- parameters.registerDefaultsHandler(FileBasedBuilderParameters.class,
- handler, PropertiesBuilderParameters.class);
- parameters.unregisterDefaultsHandler(handler);
- checkNoDefaultValues(parameters.fileBased().getParameters());
- checkNoDefaultValues(parameters.xml().getParameters());
- checkNoDefaultValues(parameters.properties().getParameters());
+ Parameters params = new Parameters(manager);
+ params.registerDefaultsHandler(XMLBuilderParameters.class, handler,
+ FileBasedBuilderParameters.class);
+ EasyMock.verify(manager);
}
/**
- * Tests whether a specific occurrence of a defaults handler can be removed.
+ * Tests the registration of a defaults handler if no start class is
+ * provided.
*/
@Test
- public void testUnregisterDefaultsHandlerSpecific()
+ public void testRegisterDefaultsHandlerNoStartClass()
{
- FileBasedDefaultsHandler handler = new FileBasedDefaultsHandler();
- parameters.registerDefaultsHandler(FileBasedBuilderParameters.class,
- handler, XMLBuilderParameters.class);
- parameters.registerDefaultsHandler(FileBasedBuilderParameters.class,
- handler, PropertiesBuilderParameters.class);
- parameters.unregisterDefaultsHandler(handler,
- PropertiesBuilderParameters.class);
- checkDefaultValues(parameters.xml().getParameters());
- checkNoDefaultValues(parameters.properties().getParameters());
- }
+ DefaultParametersManager manager =
+ EasyMock.createMock(DefaultParametersManager.class);
+ DefaultParametersHandler<XMLBuilderParameters> handler =
+ createHandlerMock();
+ manager.registerDefaultsHandler(XMLBuilderParameters.class, handler);
+ EasyMock.replay(manager, handler);
- /**
- * A test defaults handler implementation for testing the initialization of
- * parameters objects with default values. This class sets some hard-coded
- * default values.
- */
- private static class FileBasedDefaultsHandler implements
- DefaultParametersHandler<FileBasedBuilderParameters>
- {
- public void initializeDefaults(FileBasedBuilderParameters parameters)
- {
- parameters.setThrowExceptionOnMissing(true)
- .setEncoding(DEF_ENCODING)
- .setListDelimiterHandler(listHandler);
- }
+ Parameters params = new Parameters(manager);
+ params.registerDefaultsHandler(XMLBuilderParameters.class, handler);
+ EasyMock.verify(manager);
}
}