QPID-1447 : Complete SCDPolicyConfiguration Testing

git-svn-id: https://svn.apache.org/repos/asf/qpid/trunk/qpid@947176 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 118 insertions, 16 deletions

diff --git a/java/broker/src/test/java/org/apache/qpid/server/configuration/plugins/ConfigurationPluginTest.java b/java/broker/src/test/java/org/apache/qpid/server/configuration/plugins/ConfigurationPluginTest.java
index b9c8e39d1f..2f2a47cd14 100644
--- a/java/broker/src/test/java/org/apache/qpid/server/configuration/plugins/ConfigurationPluginTest.java
+++ b/java/broker/src/test/java/org/apache/qpid/server/configuration/plugins/ConfigurationPluginTest.java
@@ -22,73 +22,175 @@ package org.apache.qpid.server.configuration.plugins;
 
 import junit.framework.TestCase;
 import org.apache.commons.configuration.CompositeConfiguration;
-import org.apache.commons.configuration.Configuration;
 import org.apache.commons.configuration.ConfigurationException;
 import org.apache.commons.configuration.XMLConfiguration;
 
+import java.util.List;
+
 /**
  * Test that verifies that given a configuration the
  * Plugin manager
  */
 public class ConfigurationPluginTest extends TestCase
 {
+    private static final double DOUBLE = 3.14;
+    private static final long POSITIVE_LONG = 1000;
+    private static final long NEGATIVE_LONG = -1000;
+    private static final int LIST_SIZE = 3;
 
     class ConfigPlugin extends ConfigurationPlugin
     {
         @Override
         public String[] getElementsProcessed()
         {
-                return new String[]{"[@property]", "name"};
+            return new String[]{"[@property]", "name",
+                                "positiveLong", "negativeLong",
+                                "true", "list", "double"};
         }
 
         public String getName()
         {
-            return _configuration.getString("name");
+            return getStringValue("name");
         }
 
         public String getProperty()
         {
-            return _configuration.getString("[@property]");
+            return getStringValue("[@property]");
         }
 
-
     }
 
-    Configuration _configuration;
+    ConfigPlugin _plugin;
 
     public void setUp()
     {
         XMLConfiguration xmlconfig = new XMLConfiguration();
-        xmlconfig.addProperty("base.element[@property]","property");
-        xmlconfig.addProperty("base.element.name","name");
+        xmlconfig.addProperty("base.element[@property]", "property");
+        xmlconfig.addProperty("base.element.name", "name");
+        // We make these strings as that is how they will be read from the file.
+        xmlconfig.addProperty("base.element.positiveLong", String.valueOf(POSITIVE_LONG));
+        xmlconfig.addProperty("base.element.negativeLong", String.valueOf(NEGATIVE_LONG));
+        xmlconfig.addProperty("base.element.boolean", String.valueOf(true));
+        xmlconfig.addProperty("base.element.double", String.valueOf(DOUBLE));
+        for (int i = 0; i < LIST_SIZE; i++)
+        {
+            xmlconfig.addProperty("base.element.list", i);
+        }
 
         //Use a composite configuration as this is what our broker code uses.
-        CompositeConfiguration composite  = new CompositeConfiguration();
+        CompositeConfiguration composite = new CompositeConfiguration();
         composite.addConfiguration(xmlconfig);
 
-        _configuration = composite;
+        _plugin = new ConfigPlugin();
+
+        try
+        {
+            _plugin.setConfiguration("base.element", composite.subset("base.element"));
+        }
+        catch (ConfigurationException e)
+        {
+            e.printStackTrace();
+            fail(e.toString());
+        }
+
     }
 
+    public void testHasConfiguration()
+    {
+        assertTrue("Plugin has no configuration ", _plugin.hasConfiguration());
+        _plugin = new ConfigPlugin();
+        assertFalse("Plugins has configuration", _plugin.hasConfiguration());
+    }
 
     public void testValuesRetreived()
     {
-       ConfigPlugin plugin = new ConfigPlugin();
+        assertEquals("Name not correct", "name", _plugin.getName());
+        assertEquals("Property not correct", "property", _plugin.getProperty());
+    }
+
+    public void testContainsPositiveLong()
+    {
+        assertTrue("positiveLong is not positive", _plugin.containsPositiveLong("positiveLong"));
+        assertFalse("NonExistentValue was found", _plugin.containsPositiveLong("NonExistentValue"));
 
         try
         {
-            plugin.setConfiguration("base.element", _configuration.subset("base.element"));
+            _plugin.validatePositiveLong("positiveLong");
         }
         catch (ConfigurationException e)
         {
-            e.printStackTrace();
-            fail(e.toString());
+            fail(e.getMessage());
+        }
+
+        try
+        {
+            _plugin.validatePositiveLong("negativeLong");
+            fail("negativeLong should not be positive");
+        }
+        catch (ConfigurationException e)
+        {
+            assertEquals("negativeLong should not be reported as positive",
+                         "ConfigPlugin: unable to configure invalid negativeLong:" + NEGATIVE_LONG, e.getMessage());
         }
 
-        assertEquals("Name not correct","name",plugin.getName());
-        assertEquals("Property not correct","property",plugin.getProperty());
     }
 
+    public void testDouble()
+    {
+        assertEquals("Double value not returned", DOUBLE, _plugin.getDoubleValue("double"));
+        assertEquals("default Double value not returned", 0.0, _plugin.getDoubleValue("NonExistent"));
+        assertEquals("set default Double value not returned", DOUBLE, _plugin.getDoubleValue("NonExistent", DOUBLE));
+    }
+
+    public void testLong()
+    {
+        assertTrue("Long value not returned", _plugin.containsLong("positiveLong"));
+        assertFalse("Long value returned", _plugin.containsLong("NonExistent"));
+        assertEquals("Long value not returned", POSITIVE_LONG, _plugin.getLongValue("positiveLong"));
+        assertEquals("default Long value not returned", 0, _plugin.getLongValue("NonExistent"));
+        assertEquals("set default Long value not returned", NEGATIVE_LONG, _plugin.getLongValue("NonExistent", NEGATIVE_LONG));
+    }
 
+    public void testInt()
+    {
+        assertTrue("Int value not returned", _plugin.containsInt("positiveLong"));
+        assertFalse("Int value returned", _plugin.containsInt("NonExistent"));
+        assertEquals("Int value not returned", (int) POSITIVE_LONG, _plugin.getIntValue("positiveLong"));
+        assertEquals("default Int value not returned", 0, _plugin.getIntValue("NonExistent"));
+        assertEquals("set default Int value not returned", (int) NEGATIVE_LONG, _plugin.getIntValue("NonExistent", (int) NEGATIVE_LONG));
+    }
 
+    public void testString()
+    {
+        assertEquals("String value not returned", "name", _plugin.getStringValue("name"));
+        assertNull("Null default String value not returned", _plugin.getStringValue("NonExistent", null));
+        assertNull("default String value not returned", _plugin.getStringValue("NonExistent"));
+        assertEquals("default String value not returned", "Default", _plugin.getStringValue("NonExistent", "Default"));
+    }
+
+    public void testBoolean()
+    {
+        assertTrue("Boolean value not returned", _plugin.getBooleanValue("boolean"));
+        assertFalse("default String value not returned", _plugin.getBooleanValue("NonExistent"));
+        assertTrue("set default String value not returned", _plugin.getBooleanValue("NonExistent", true));
+    }
+
+    public void testList()
+    {
+        assertTrue("list not found in plugin", _plugin.contains("list"));
+        List list = _plugin.getListValue("list");
+        assertNotNull("Returned list should not be null", list);
+        assertEquals("List should not be empty", LIST_SIZE, list.size());
+
+        list = _plugin.getListValue("NonExistent");
+        assertNotNull("Returned list should not be null", list);
+        assertEquals("List is not empty", 0, list.size());
+    }
+
+    public void testContains()
+    {
+        assertTrue("list not found in plugin", _plugin.contains("list"));
+        assertFalse("NonExistent found in plugin", _plugin.contains("NonExistent"));
+    }
 
 }