Add bean configurator

Refactored PropertyConfiguration, but left the original class alone
until references to it have been removed from other policy repos.
Split the Property annotation out into its own file.  Cloned the
remaining code into BeanConfigurator, modifying its behavior so that,
instead of operating on its own subclass, it operates on a provided bean.
Also added an ability to copy the bean's fields to a Properties object.

Updated license dates.

Removed unneeded argument from functional interface.
Added comment about always checking default values.
Updated a few comments.

Change-Id: Iff36fd0524032d7630f9ee08f0eef7b05de100d1
Issue-ID: POLICY-1444
Signed-off-by: Jim Hahn <jrh3@att.com>

1 files changed, 1424 insertions, 0 deletions

diff --git a/utils/src/test/java/org/onap/policy/common/utils/properties/BeanConfiguratorTest.java b/utils/src/test/java/org/onap/policy/common/utils/properties/BeanConfiguratorTest.java
new file mode 100644
index 00000000..beca88f0
--- /dev/null
+++ b/utils/src/test/java/org/onap/policy/common/utils/properties/BeanConfiguratorTest.java
@@ -0,0 +1,1424 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP - Common Modules
+ * ================================================================================
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.common.utils.properties;
+
+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 java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Properties;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.policy.common.utils.properties.exception.PropertyAccessException;
+import org.onap.policy.common.utils.properties.exception.PropertyException;
+import org.onap.policy.common.utils.properties.exception.PropertyInvalidException;
+import org.onap.policy.common.utils.properties.exception.PropertyMissingException;
+
+/**
+ * Test class for PropertyConfiguration.
+ */
+public class BeanConfiguratorTest {
+
+    /**
+     * Property used for most of the simple configuration subclasses.
+     */
+    private static final String THE_VALUE = "the.value";
+
+    /**
+     * String property value.
+     */
+    private static final String STRING_VALUE = "a string";
+
+    /**
+     * Default value for string property.
+     */
+    private static final String STRING_VALUE_DEFAULT = "another string";
+
+    /**
+     * Value that cannot be coerced into any other type.
+     */
+    private static final String INVALID_VALUE = "invalid";
+
+    /**
+     * Properties used when invoking constructors.
+     */
+    private Properties props;
+
+    private BeanConfigurator beancfg;
+
+    @Before
+    public void setUp() {
+        props = new Properties();
+        beancfg = new BeanConfigurator();
+    }
+
+    @Test
+    public void testConfigureFromProperties() throws PropertyException {
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        PlainStringConfig cfg = new PlainStringConfig();
+
+        assertSame(cfg, beancfg.configureFromProperties(cfg, props));
+
+        assertEquals(STRING_VALUE, cfg.value);
+    }
+
+    @Test
+    public void testSetAllFields() throws Exception {
+
+        /*
+         * Implements an extra interface, just to see that it doesn't cause issues.
+         */
+        class GrandParentConfig implements DoesNothing {
+
+            @Property(name = "grandparent.value")
+            protected boolean grandparentValue;
+
+            @SuppressWarnings("unused")
+            public void setGrandparentValue(boolean grandparentValue) {
+                this.grandparentValue = grandparentValue;
+            }
+        }
+
+        /*
+         * Implements the extra interface, too.
+         */
+        class ParentConfig extends GrandParentConfig implements DoesNothing {
+
+            @Property(name = "parent.value")
+            protected long parentValue;
+
+            @SuppressWarnings("unused")
+            public void setParentValue(long parentValue) {
+                this.parentValue = parentValue;
+            }
+        }
+
+        class Config extends ParentConfig {
+
+            @Property(name = THE_VALUE)
+            private String value;
+
+            @SuppressWarnings("unused")
+            public void setValue(String value) {
+                this.value = value;
+            }
+        }
+
+
+        final Config cfg = new Config();
+
+        // try one set of values
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        props.setProperty("parent.value", "50000");
+        props.setProperty("grandparent.value", "true");
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(STRING_VALUE, cfg.value);
+        assertEquals(50000L, cfg.parentValue);
+        assertEquals(true, cfg.grandparentValue);
+
+        // now a different set of values
+        props.setProperty(THE_VALUE, STRING_VALUE + "x");
+        props.setProperty("parent.value", "50001");
+        props.setProperty("grandparent.value", "false");
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(STRING_VALUE + "x", cfg.value);
+        assertEquals(50001L, cfg.parentValue);
+        assertEquals(false, cfg.grandparentValue);
+    }
+
+    @Test
+    public void testSetAllFields_NoProperties() throws Exception {
+
+        class Config {
+
+            private String value;
+
+            @SuppressWarnings("unused")
+            public void setValue(String value) {
+                this.value = value;
+            }
+        }
+
+
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(null, cfg.value);
+    }
+
+    @Test
+    public void testSetValueObjectFieldProperties_FieldSet() throws PropertyException {
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        PlainStringConfig cfg = new PlainStringConfig();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(STRING_VALUE, cfg.value);
+    }
+
+    @Test
+    public void testSetValueObjectFieldProperties_NoAnnotation() throws PropertyException {
+        class Config {
+
+            private String value;
+
+            @SuppressWarnings("unused")
+            public void setValue(String value) {
+                this.value = value;
+            }
+        }
+
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertNull(cfg.value);
+    }
+
+    @Test(expected = PropertyAccessException.class)
+    public void testSetValueObjectFieldProperties_WrongFieldType() throws PropertyException {
+        class Config {
+
+            // Cannot set a property into an "Exception" field
+            @Property(name = THE_VALUE)
+            private Exception value;
+
+            @SuppressWarnings("unused")
+            public void setValue(Exception value) {
+                this.value = value;
+            }
+        }
+
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test(expected = PropertyAccessException.class)
+    public void testGetSetter_NoSetter() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE)
+            private String value;
+        }
+
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test(expected = PropertyMissingException.class)
+    public void testSetValueObjectMethodFieldPropertiesProperty_NoProperty_NoDefault() throws PropertyException {
+        beancfg.configureFromProperties(new PlainStringConfig(), props);
+    }
+
+    @Test(expected = PropertyInvalidException.class)
+    public void testSetValueObjectMethodFieldPropertiesProperty_IllegalArgEx() throws PropertyException {
+        props.setProperty(THE_VALUE, STRING_VALUE);
+
+        beancfg = new BeanConfigurator() {
+            @Override
+            protected Object getValue(Field field, Properties props, Property prop) {
+                throw new IllegalArgumentException("expected exception");
+            }
+        };
+
+        beancfg.configureFromProperties(new PlainStringConfig(), props);
+    }
+
+    @Test(expected = PropertyAccessException.class)
+    public void testSetValueObjectMethodFieldPropertiesProperty_MethodEx() throws PropertyException {
+        class Config extends PlainStringConfig {
+
+            @Override
+            public void setValue(String value) {
+                throw new IllegalArgumentException("expected exception");
+            }
+        }
+
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test
+    public void testGetValue() throws PropertyException {
+        // this class contains all of the supported field types
+        class Config {
+
+            @Property(name = "string")
+            private String stringValue;
+
+            @Property(name = "boolean.true")
+            private Boolean boolTrueValue;
+
+            @Property(name = "boolean.false")
+            private Boolean boolFalseValue;
+
+            @Property(name = "primitive.boolean.true")
+            private boolean primBoolTrueValue;
+
+            @Property(name = "primitive.boolean.false")
+            private boolean primBoolFalseValue;
+
+            @Property(name = "integer")
+            private Integer intValue;
+
+            @Property(name = "primitive.integer")
+            private int primIntValue;
+
+            @Property(name = "long")
+            private Long longValue;
+
+            @Property(name = "primitive.long")
+            private long primLongValue;
+
+            @SuppressWarnings("unused")
+            public String getStringValue() {
+                return stringValue;
+            }
+
+            @SuppressWarnings("unused")
+            public void setStringValue(String stringValue) {
+                this.stringValue = stringValue;
+            }
+
+            @SuppressWarnings("unused")
+            public Boolean getBoolTrueValue() {
+                return boolTrueValue;
+            }
+
+            @SuppressWarnings("unused")
+            public void setBoolTrueValue(Boolean boolTrueValue) {
+                this.boolTrueValue = boolTrueValue;
+            }
+
+            @SuppressWarnings("unused")
+            public Boolean getBoolFalseValue() {
+                return boolFalseValue;
+            }
+
+            @SuppressWarnings("unused")
+            public void setBoolFalseValue(Boolean boolFalseValue) {
+                this.boolFalseValue = boolFalseValue;
+            }
+
+            @SuppressWarnings("unused")
+            public boolean isPrimBoolTrueValue() {
+                return primBoolTrueValue;
+            }
+
+            @SuppressWarnings("unused")
+            public void setPrimBoolTrueValue(boolean primBoolTrueValue) {
+                this.primBoolTrueValue = primBoolTrueValue;
+            }
+
+            @SuppressWarnings("unused")
+            public boolean isPrimBoolFalseValue() {
+                return primBoolFalseValue;
+            }
+
+            @SuppressWarnings("unused")
+            public void setPrimBoolFalseValue(boolean primBoolFalseValue) {
+                this.primBoolFalseValue = primBoolFalseValue;
+            }
+
+            @SuppressWarnings("unused")
+            public Integer getIntValue() {
+                return intValue;
+            }
+
+            @SuppressWarnings("unused")
+            public void setIntValue(Integer intValue) {
+                this.intValue = intValue;
+            }
+
+            @SuppressWarnings("unused")
+            public int getPrimIntValue() {
+                return primIntValue;
+            }
+
+            @SuppressWarnings("unused")
+            public void setPrimIntValue(int primIntValue) {
+                this.primIntValue = primIntValue;
+            }
+
+            @SuppressWarnings("unused")
+            public Long getLongValue() {
+                return longValue;
+            }
+
+            @SuppressWarnings("unused")
+            public void setLongValue(Long longValue) {
+                this.longValue = longValue;
+            }
+
+            @SuppressWarnings("unused")
+            public long getPrimLongValue() {
+                return primLongValue;
+            }
+
+            @SuppressWarnings("unused")
+            public void setPrimLongValue(long primLongValue) {
+                this.primLongValue = primLongValue;
+            }
+        }
+
+        props.setProperty("string", "a string");
+        props.setProperty("boolean.true", "true");
+        props.setProperty("boolean.false", "false");
+        props.setProperty("primitive.boolean.true", "true");
+        props.setProperty("primitive.boolean.false", "false");
+        props.setProperty("integer", "100");
+        props.setProperty("primitive.integer", "101");
+        props.setProperty("long", "10000");
+        props.setProperty("primitive.long", "10001");
+
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals("a string", cfg.stringValue);
+        assertEquals(true, cfg.boolTrueValue);
+        assertEquals(false, cfg.boolFalseValue);
+        assertEquals(true, cfg.primBoolTrueValue);
+        assertEquals(false, cfg.primBoolFalseValue);
+        assertEquals(100, cfg.intValue.intValue());
+        assertEquals(101, cfg.primIntValue);
+        assertEquals(10000, cfg.longValue.longValue());
+        assertEquals(10001, cfg.primLongValue);
+    }
+
+    @Test(expected = PropertyAccessException.class)
+    public void testGetValue_UnsupportedType() throws PropertyException {
+        class Config {
+
+            // Cannot set a property into an "Exception" field
+            @Property(name = THE_VALUE)
+            private Exception value;
+
+            @SuppressWarnings("unused")
+            public void setValue(Exception value) {
+                this.value = value;
+            }
+        }
+
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test
+    public void testCheckModifiable_OtherModifiers() throws PropertyException {
+        // this class contains all of the supported field types
+        class Config {
+
+            @Property(name = "public")
+            public String publicString;
+
+            @Property(name = "private")
+            private String privateString;
+
+            @Property(name = "protected")
+            protected String protectedString;
+
+            @SuppressWarnings("unused")
+            public void setPublicString(String publicString) {
+                this.publicString = publicString;
+            }
+
+            @SuppressWarnings("unused")
+            public void setPrivateString(String privateString) {
+                this.privateString = privateString;
+            }
+
+            @SuppressWarnings("unused")
+            public void setProtectedString(String protectedString) {
+                this.protectedString = protectedString;
+            }
+        }
+
+        props.setProperty("public", "a public string");
+        props.setProperty("private", "a private string");
+        props.setProperty("protected", "a protected string");
+
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals("a public string", cfg.publicString);
+        assertEquals("a private string", cfg.privateString);
+        assertEquals("a protected string", cfg.protectedString);
+    }
+
+    @Test(expected = PropertyAccessException.class)
+    public void testCheckModifiable_Static() throws PropertyException {
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        beancfg.configureFromProperties(new StaticPropConfig(), props);
+    }
+
+    @Test(expected = PropertyAccessException.class)
+    public void testCheckModifiable_Final() throws PropertyException {
+        class Config {
+
+            // Cannot set a property into an "final" field
+            @Property(name = THE_VALUE)
+            private final String value = "";
+        }
+
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test(expected = PropertyAccessException.class)
+    public void testCheckMethod_Static() throws PropertyException {
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        beancfg.configureFromProperties(new StaticMethodConfig(), props);
+    }
+
+    @Test
+    public void testGetStringValue() throws PropertyException {
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        PlainStringConfig cfg = new PlainStringConfig();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(STRING_VALUE, cfg.value);
+    }
+
+    @Test
+    public void testGetBooleanValue_NoDefault() throws PropertyException {
+        props.setProperty(THE_VALUE, "true");
+        PlainBooleanConfig cfg = new PlainBooleanConfig();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(true, cfg.value);
+    }
+
+    @Test(expected = PropertyInvalidException.class)
+    public void testGetBooleanValue_InvalidDefault() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = INVALID_VALUE)
+            private Boolean value;
+
+            @SuppressWarnings("unused")
+            public void setValue(Boolean value) {
+                this.value = value;
+            }
+        }
+
+        props.setProperty(THE_VALUE, "true");
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test
+    public void testGetBooleanValue_ValidDefault_True() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = "true")
+            private Boolean value;
+
+            @SuppressWarnings("unused")
+            public void setValue(Boolean value) {
+                this.value = value;
+            }
+        }
+
+        // property not defined
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals(true, cfg.value);
+
+        // try again, with the property defined as true
+        props.setProperty(THE_VALUE, "true");
+        cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals(true, cfg.value);
+
+        // try again, with the property defined as false
+        props.setProperty(THE_VALUE, "false");
+        cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals(false, cfg.value);
+    }
+
+    @Test
+    public void testGetBooleanValue_ValidDefault_False() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = "false")
+            private Boolean value;
+
+            @SuppressWarnings("unused")
+            public void setValue(Boolean value) {
+                this.value = value;
+            }
+        }
+
+        // property not defined
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals(false, cfg.value);
+
+        // try again, with the property defined as true
+        props.setProperty(THE_VALUE, "true");
+        cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals(true, cfg.value);
+
+        // try again, with the property defined as false
+        props.setProperty(THE_VALUE, "false");
+        cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals(false, cfg.value);
+    }
+
+    @Test
+    public void testGetIntegerValue_NoDefault() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE)
+            private Integer value;
+
+            @SuppressWarnings("unused")
+            public void setValue(Integer value) {
+                this.value = value;
+            }
+        }
+
+        props.setProperty(THE_VALUE, "200");
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(200, cfg.value.intValue());
+    }
+
+    @Test(expected = PropertyInvalidException.class)
+    public void testGetIntegerValue_InvalidDefault() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = INVALID_VALUE)
+            private Integer value;
+
+            @SuppressWarnings("unused")
+            public void setValue(Integer value) {
+                this.value = value;
+            }
+        }
+
+        props.setProperty(THE_VALUE, "200");
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test
+    public void testGetIntegerValue_ValidDefault() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = "201")
+            private Integer value;
+
+            @SuppressWarnings("unused")
+            public void setValue(Integer value) {
+                this.value = value;
+            }
+        }
+
+        // property not defined
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals(201, cfg.value.intValue());
+
+        // try again, with the property defined
+        props.setProperty(THE_VALUE, "200");
+        cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals(200, cfg.value.intValue());
+    }
+
+    @Test
+    public void testGetLongValue_NoDefault() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE)
+            private Long value;
+
+            @SuppressWarnings("unused")
+            public void setValue(Long value) {
+                this.value = value;
+            }
+        }
+
+        props.setProperty(THE_VALUE, "20000");
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(20000L, cfg.value.longValue());
+    }
+
+    @Test(expected = PropertyInvalidException.class)
+    public void testGetLongValue_InvalidDefault() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = INVALID_VALUE)
+            private Long value;
+
+            @SuppressWarnings("unused")
+            public void setValue(Long value) {
+                this.value = value;
+            }
+        }
+
+        props.setProperty(THE_VALUE, "20000");
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test
+    public void testGetLongValue_ValidDefault() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = "20001")
+            private Long value;
+
+            @SuppressWarnings("unused")
+            public void setValue(Long value) {
+                this.value = value;
+            }
+        }
+
+        // property not defined
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals(20001L, cfg.value.longValue());
+
+        // try again, with the property defined
+        props.setProperty(THE_VALUE, "20000");
+        cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals(20000L, cfg.value.longValue());
+    }
+
+    @Test
+    public void testGetPropValue_Prop_NoDefault() throws PropertyException {
+        props.setProperty(THE_VALUE, STRING_VALUE);
+
+        PlainStringConfig cfg = new PlainStringConfig();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(STRING_VALUE, cfg.value);
+    }
+
+    @Test
+    public void testGetPropValue_Prop_Default() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = STRING_VALUE_DEFAULT)
+            private String value;
+
+            @SuppressWarnings("unused")
+            public void setValue(String value) {
+                this.value = value;
+            }
+        }
+
+        props.setProperty(THE_VALUE, STRING_VALUE);
+
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(STRING_VALUE, cfg.value);
+    }
+
+    @Test
+    public void testGetPropValue_EmptyProp_EmptyOk() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, accept = "empty")
+            private String value;
+
+            @SuppressWarnings("unused")
+            public void setValue(String value) {
+                this.value = value;
+            }
+        }
+
+        props.setProperty(THE_VALUE, "");
+
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals("", cfg.value);
+    }
+
+    @Test
+    public void testGetPropValue_NullProp_EmptyOk() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, accept = "empty")
+            private String value;
+
+            @SuppressWarnings("unused")
+            public void setValue(String value) {
+                this.value = value;
+            }
+        }
+
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals("", cfg.value);
+    }
+
+    @Test
+    public void testGetPropValue_EmptyDefault_EmptyOk() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = "", accept = "empty")
+            private String value;
+
+            @SuppressWarnings("unused")
+            public void setValue(String value) {
+                this.value = value;
+            }
+        }
+
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals("", cfg.value);
+    }
+
+    @Test
+    public void testGetPropValue_Default_EmptyOk() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = STRING_VALUE, accept = "empty")
+            private String value;
+
+            @SuppressWarnings("unused")
+            public void setValue(String value) {
+                this.value = value;
+            }
+        }
+
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(STRING_VALUE, cfg.value);
+    }
+
+    @Test(expected = PropertyMissingException.class)
+    public void testGetPropValue_EmptyDefault_EmptyNotOk() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = "")
+            private String value;
+
+            @SuppressWarnings("unused")
+            public void setValue(String value) {
+                this.value = value;
+            }
+        }
+
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test
+    public void testGetPropValue_Default_EmptyNotOk() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = STRING_VALUE, accept = "")
+            private String value;
+
+            @SuppressWarnings("unused")
+            public void setValue(String value) {
+                this.value = value;
+            }
+        }
+
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(STRING_VALUE, cfg.value);
+    }
+
+    @Test
+    public void testMakeBoolean_True() throws PropertyException {
+        props.setProperty(THE_VALUE, "true");
+        PlainBooleanConfig cfg = new PlainBooleanConfig();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(true, cfg.value);
+    }
+
+    @Test
+    public void testMakeBoolean_False() throws PropertyException {
+        props.setProperty(THE_VALUE, "false");
+        PlainBooleanConfig cfg = new PlainBooleanConfig();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(false, cfg.value);
+    }
+
+    @Test(expected = PropertyInvalidException.class)
+    public void testMakeBoolean_Invalid() throws PropertyException {
+        props.setProperty(THE_VALUE, INVALID_VALUE);
+        beancfg.configureFromProperties(new PlainBooleanConfig(), props);
+    }
+
+    @Test
+    public void testMakeInteger_Valid() throws PropertyException {
+        props.setProperty(THE_VALUE, "300");
+        PlainPrimIntConfig cfg = new PlainPrimIntConfig();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(300, cfg.value);
+    }
+
+    @Test(expected = PropertyInvalidException.class)
+    public void testMakeInteger_Invalid() throws PropertyException {
+        props.setProperty(THE_VALUE, INVALID_VALUE);
+        beancfg.configureFromProperties(new PlainPrimIntConfig(), props);
+    }
+
+    @Test(expected = PropertyInvalidException.class)
+    public void testMakeInteger_TooBig() throws PropertyException {
+        props.setProperty(THE_VALUE, String.valueOf(Integer.MAX_VALUE + 10L));
+        beancfg.configureFromProperties(new PlainPrimIntConfig(), props);
+    }
+
+    @Test
+    public void testMakeLong_Valid() throws PropertyException {
+        props.setProperty(THE_VALUE, "30000");
+        PlainPrimLongConfig cfg = new PlainPrimLongConfig();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(30000L, cfg.value);
+    }
+
+    @Test(expected = PropertyInvalidException.class)
+    public void testMakeLong_Invalid() throws PropertyException {
+        props.setProperty(THE_VALUE, INVALID_VALUE);
+        beancfg.configureFromProperties(new PlainPrimLongConfig(), props);
+    }
+
+    @Test
+    public void testCheckDefaultValue_NotEmpty_Valid() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = "700")
+            private long value;
+
+            @SuppressWarnings("unused")
+            public void setValue(long value) {
+                this.value = value;
+            }
+        }
+
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals(700L, cfg.value);
+    }
+
+    @Test(expected = PropertyInvalidException.class)
+    public void testCheckDefaultValue_NotEmpty_Invalid() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = INVALID_VALUE)
+            private long value;
+
+            @SuppressWarnings("unused")
+            public void setValue(long value) {
+                this.value = value;
+            }
+        }
+
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test(expected = PropertyInvalidException.class)
+    public void testCheckDefaultValue_Empty_EmptyOk_Invalid() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = "", accept = "empty")
+            private long value;
+
+            @SuppressWarnings("unused")
+            public void setValue(long value) {
+                this.value = value;
+            }
+        }
+
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test
+    public void testIsEmptyOkPropertyString_True() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = "", accept = "empty")
+            private String value;
+
+            @SuppressWarnings("unused")
+            public void setValue(String value) {
+                this.value = value;
+            }
+        }
+
+        // missing property - should default to ""
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals("", cfg.value);
+
+        // add an empty property - should take the property's value
+        props.setProperty(THE_VALUE, "");
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals("", cfg.value);
+
+        // add the property - should take the property's value
+        props.setProperty(THE_VALUE, STRING_VALUE);
+        beancfg.configureFromProperties(cfg, props);
+        assertEquals(STRING_VALUE, cfg.value);
+    }
+
+    @Test(expected = PropertyMissingException.class)
+    public void testIsEmptyOkPropertyString_False() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = "", accept = "")
+            private long value;
+
+            @SuppressWarnings("unused")
+            public void setValue(long value) {
+                this.value = value;
+            }
+        }
+
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test
+    public void testIsEmptyOkProperty_True() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = "", accept = "empty")
+            private String value;
+
+            @SuppressWarnings("unused")
+            public void setValue(String value) {
+                this.value = value;
+            }
+        }
+
+        Config cfg = new Config();
+        beancfg.configureFromProperties(cfg, props);
+
+        assertEquals("", cfg.value);
+    }
+
+    @Test(expected = PropertyMissingException.class)
+    public void testIsEmptyOkProperty_False() throws PropertyException {
+        class Config {
+
+            @Property(name = THE_VALUE, defaultValue = "", accept = "")
+            private long value;
+
+            @SuppressWarnings("unused")
+            public void setValue(long value) {
+                this.value = value;
+            }
+        }
+
+        beancfg.configureFromProperties(new Config(), props);
+    }
+
+    @Test
+    public void testPutToProperties() throws Exception {
+
+        /*
+         * Implements the extra interface, too.
+         */
+        class ParentConfig implements DoesNothing {
+
+            @Property(name = "the.parent.value")
+            protected long parentValue;
+
+            @SuppressWarnings("unused")
+            public long getParentValue() {
+                return parentValue;
+            }
+        }
+
+        class Config extends ParentConfig {
+
+            @Property(name = THE_VALUE)
+            private String value;
+
+            @Property(name = "the.other.value")
+            private String other;
+
+            @SuppressWarnings("unused")
+            public String getValue() {
+                return value;
+            }
+
+            @SuppressWarnings("unused")
+            public String getOther() {
+                return other;
+            }
+        }
+
+
+        final Config cfg = new Config();
+
+        cfg.parentValue = 1010;
+        cfg.value = STRING_VALUE;
+        cfg.other = "other";
+
+        beancfg.addToProperties(cfg, props, "the", "a");
+
+        assertEquals("1010", props.getProperty("a.parent.value"));
+        assertEquals(STRING_VALUE, props.getProperty("a.value"));
+        assertEquals("other", props.getProperty("a.other.value"));
+
+        // original prefix is empty
+        beancfg.addToProperties(cfg, props, "", "not");
+        assertEquals(STRING_VALUE, props.getProperty("not.the.value"));
+
+        // original prefix is ends with "."
+        beancfg.addToProperties(cfg, props, "the.", "a");
+        assertEquals(STRING_VALUE, props.getProperty("a.value"));
+
+        // new prefix is empty
+        beancfg.addToProperties(cfg, props, "", "");
+        assertEquals(STRING_VALUE, props.getProperty(THE_VALUE));
+
+        // new prefix is ends with "."
+        beancfg.addToProperties(cfg, props, "the", "xxx.");
+        assertEquals(STRING_VALUE, props.getProperty("xxx.value"));
+    }
+
+    @Test
+    public void testPutProperty() throws Exception {
+
+        class Config {
+            // no annotation - should not be copied
+            private String noAnnotation;
+
+            @Property(name = THE_VALUE)
+            private String value;
+
+            // null value - should not be copied
+            @Property(name = "the.null.value")
+            private String nullValue;
+
+            // should be copied, but retain its prefix
+            @Property(name = "some.other.prefix")
+            private String other;
+
+            @SuppressWarnings("unused")
+            public String getNoAnnotation() {
+                return noAnnotation;
+            }
+
+            @SuppressWarnings("unused")
+            public String getValue() {
+                return value;
+            }
+
+            @SuppressWarnings("unused")
+            public String getNullValue() {
+                return nullValue;
+            }
+
+            @SuppressWarnings("unused")
+            public String getOther() {
+                return other;
+            }
+        }
+
+        Config cfg = new Config();
+        cfg.noAnnotation = "no annotation";
+        cfg.value = STRING_VALUE;
+        cfg.nullValue = null;
+        cfg.other = "some other value";
+        beancfg.addToProperties(cfg, props, "the", "a");
+
+        assertFalse(props.contains("noAnnotation"));
+        assertEquals(STRING_VALUE, props.getProperty("a.value"));
+        assertFalse(props.contains("a.null.value"));
+        assertEquals("some other value", props.getProperty("some.other.prefix"));
+    }
+
+    @Test
+    public void testGetGetter() throws Exception {
+
+        class Config {
+            // getter method starts with "is" for these
+            @Property(name = "plain.bool")
+            private Boolean plainBool;
+
+            @Property(name = "prim.bool")
+            private boolean primBool;
+
+            // getter method starts with "get" for these
+            @Property(name = "plain.bool.get")
+            private Boolean plainBoolGet;
+
+            @Property(name = "prim.bool.get")
+            private boolean primBoolGet;
+
+            @Property(name = "int")
+            private int intValue;
+
+            @Property(name = "string")
+            private String stringValue;
+
+            @SuppressWarnings("unused")
+            public Boolean isPlainBool() {
+                return plainBool;
+            }
+
+            @SuppressWarnings("unused")
+            public boolean isPrimBool() {
+                return primBool;
+            }
+
+            @SuppressWarnings("unused")
+            public Boolean getPlainBoolGet() {
+                return plainBoolGet;
+            }
+
+            @SuppressWarnings("unused")
+            public boolean getPrimBoolGet() {
+                return primBoolGet;
+            }
+
+            @SuppressWarnings("unused")
+            public int getIntValue() {
+                return intValue;
+            }
+
+            @SuppressWarnings("unused")
+            public String getStringValue() {
+                return stringValue;
+            }
+        }
+
+        Config cfg = new Config();
+        cfg.plainBool = true;
+        cfg.primBool = false;
+        cfg.plainBoolGet = false;
+        cfg.primBoolGet = true;
+        cfg.intValue = 1100;
+        cfg.stringValue = STRING_VALUE;
+        beancfg.addToProperties(cfg, props, "", "");
+
+        assertEquals("true", props.getProperty("plain.bool"));
+        assertEquals("false", props.getProperty("prim.bool"));
+        assertEquals("false", props.getProperty("plain.bool.get"));
+        assertEquals("true", props.getProperty("prim.bool.get"));
+        assertEquals("1100", props.getProperty("int"));
+        assertEquals(STRING_VALUE, props.getProperty("string"));
+    }
+
+    @Test(expected = PropertyAccessException.class)
+    public void testGetGetter_NoGetter() throws Exception {
+
+        class Config {
+            @Property(name = THE_VALUE)
+            private String value;
+        }
+
+        Config cfg = new Config();
+        cfg.value = STRING_VALUE;
+        beancfg.addToProperties(cfg, props, "", "");
+    }
+
+    @Test(expected = PropertyAccessException.class)
+    public void testGetGetter_NoGetterForBoolean() throws Exception {
+
+        class Config {
+            @Property(name = THE_VALUE)
+            private boolean value;
+        }
+
+        Config cfg = new Config();
+        cfg.value = true;
+        beancfg.addToProperties(cfg, props, "", "");
+    }
+
+    @Test(expected = PropertyAccessException.class)
+    public void testGetGetter_PrivateGetter() throws Exception {
+
+        class Config {
+            @Property(name = THE_VALUE)
+            private String value;
+
+            @SuppressWarnings("unused")
+            private String getValue() {
+                return value;
+            }
+        }
+
+        Config cfg = new Config();
+        cfg.value = STRING_VALUE;
+        beancfg.addToProperties(cfg, props, "", "");
+    }
+
+    @Test(expected = PropertyAccessException.class)
+    public void testGetGetter_SecurityEx() throws Exception {
+
+        class Config {
+            @Property(name = THE_VALUE)
+            private String value;
+
+            @SuppressWarnings("unused")
+            private String getValue() {
+                return value;
+            }
+        }
+
+        Config cfg = new Config();
+        cfg.value = STRING_VALUE;
+
+        beancfg = new BeanConfigurator() {
+            @Override
+            protected Method getGetter(Field field, String methodName) throws SecurityException {
+                throw new SecurityException("expected exception");
+            }
+        };
+
+        beancfg.addToProperties(cfg, props, "", "");
+    }
+
+    @Test(expected = PropertyAccessException.class)
+    public void testGetBeanValue_Ex() throws Exception {
+
+        class Config {
+
+            @Property(name = THE_VALUE)
+            private String value;
+
+            @SuppressWarnings("unused")
+            public String getValue() {
+                throw new RuntimeException("expected exception");
+            }
+        }
+
+
+        final Config cfg = new Config();
+        cfg.value = STRING_VALUE;
+
+        beancfg.addToProperties(cfg, props, "the", "a");
+
+    }
+
+    /**
+     * Config with a String value having no qualifiers.
+     */
+    public class PlainStringConfig {
+
+        @Property(name = THE_VALUE)
+        private String value;
+
+        public String getValue() {
+            return value;
+        }
+
+        public void setValue(String value) {
+            this.value = value;
+        }
+    }
+
+    /**
+     * Config with a Boolean value having no qualifiers.
+     */
+    public class PlainBooleanConfig {
+
+        @Property(name = THE_VALUE)
+        private Boolean value;
+
+        public void setValue(Boolean value) {
+            this.value = value;
+        }
+    }
+
+    /**
+     * Config with an int value having no qualifiers.
+     */
+    public class PlainPrimIntConfig {
+
+        @Property(name = THE_VALUE)
+        private int value;
+
+        public void setValue(int value) {
+            this.value = value;
+        }
+    }
+
+    /**
+     * Config with a long value having no qualifiers.
+     */
+    public class PlainPrimLongConfig {
+
+        @Property(name = THE_VALUE)
+        private long value;
+
+        public void setValue(long value) {
+            this.value = value;
+        }
+    }
+
+    /**
+     * A config whose field is "static".
+     */
+    public static class StaticPropConfig {
+
+        // "static" field cannot be set
+        @Property(name = THE_VALUE)
+        private static String value;
+
+        public static void setValue(String value) {
+            StaticPropConfig.value = value;
+        }
+    }
+
+    /**
+     * A config whose method is "static".
+     */
+    public static class StaticMethodConfig {
+
+        // "static" field cannot be set
+        @Property(name = THE_VALUE)
+        private String value;
+
+        public static void setValue(String value) {
+
+        }
+    }
+
+    /**
+     * This is just used as a mix-in to ensure that the configuration ignores interfaces.
+     */
+    public static interface DoesNothing {
+
+    }
+}