Merge "Add bean configurator"

3 files changed, 2050 insertions, 0 deletions

diff --git a/utils/src/main/java/org/onap/policy/common/utils/properties/BeanConfigurator.java b/utils/src/main/java/org/onap/policy/common/utils/properties/BeanConfigurator.java
new file mode 100644
index 00000000..9d02819a
--- /dev/null
+++ b/utils/src/main/java/org/onap/policy/common/utils/properties/BeanConfigurator.java
@@ -0,0 +1,567 @@
+/*
+ * ============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 java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Properties;
+import org.apache.commons.lang3.StringUtils;
+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;
+
+/**
+ * Configurator for beans whose fields are initialized by reading from a set of
+ * {@link Properties}, as directed by the {@link Property} annotations that appear on
+ * fields within the bean. The values of the fields are set via <i>setXxx()</i> methods.
+ * As a result, if a field is annotated and there is no corresponding <i>setXxx()</i>
+ * method, then an exception will be thrown.
+ *
+ * <p>It is possible that an invalid <i>defaultValue</i> is specified via the
+ * {@link Property} annotation. This could remain undetected until an optional property is
+ * left out of the {@link Properties}. Consequently, this class will always validate a
+ * {@link Property}'s default value, if the <i>defaultValue</i> is not empty or if
+ * <i>accept</i> includes the "empty" option.
+ */
+public class BeanConfigurator {
+
+    /**
+     * The "empty" option that may appear within the {@link Property}'s <i>accept</i>
+     * attribute.
+     */
+    public static final String ACCEPT_EMPTY = "empty";
+
+    /**
+     * Walks the class hierarchy of the bean, populating fields defined in each class,
+     * using values extracted from the given property set.
+     *
+     * @param bean bean whose fields are to be configured from the properties
+     * @param props properties from which to extract the values
+     * @throws PropertyException if an error occurs
+     */
+    public <T> T configureFromProperties(T bean, Properties props) throws PropertyException {
+        Class<?> clazz = bean.getClass();
+
+        while (clazz != Object.class) {
+            for (Field field : clazz.getDeclaredFields()) {
+                setValue(bean, field, props);
+            }
+
+            clazz = clazz.getSuperclass();
+        }
+
+        return bean;
+    }
+
+    /**
+     * Sets a field's value, within an object, based on what's in the properties.
+     *
+     * @param bean bean whose fields are to be configured from the properties
+     * @param field field whose value is to be set
+     * @param props properties from which to get the value
+     * @return {@code true} if the property's value was set, {@code false} otherwise
+     * @throws PropertyException if an error occurs
+     */
+    protected boolean setValue(Object bean, Field field, Properties props) throws PropertyException {
+        Property prop = field.getAnnotation(Property.class);
+        if (prop == null) {
+            return false;
+        }
+
+        checkModifiable(field, prop);
+
+        Method setter = getSetter(field, prop);
+        checkMethod(setter, prop);
+
+        if (setValue(bean, setter, field, props, prop)) {
+            return true;
+        }
+
+        throw new PropertyAccessException(prop.name(), field.getName(), "unsupported field type");
+    }
+
+    /**
+     * Sets a field's value from a particular property.
+     *
+     * @param bean bean whose fields are to be configured from the properties
+     * @param setter method to be used to set the field's value
+     * @param field field whose value is to be set
+     * @param props properties from which to get the value
+     * @param prop property of interest
+     * @return {@code true} if the property's value was set, {@code false} otherwise
+     * @throws PropertyException if an error occurs
+     */
+    protected boolean setValue(Object bean, Method setter, Field field, Properties props, Property prop)
+                    throws PropertyException {
+
+        try {
+            Object val = getValue(field, props, prop);
+            if (val == null) {
+                return false;
+
+            } else {
+                setter.invoke(bean, val);
+                return true;
+            }
+
+        } catch (IllegalArgumentException e) {
+            throw new PropertyInvalidException(prop.name(), field.getName(), e);
+
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            throw new PropertyAccessException(prop.name(), setter.getName(), e);
+        }
+    }
+
+    /**
+     * Get the setter.
+     *
+     * @param field field whose value is to be set
+     * @param prop property of interest
+     * @return the method to be used to set the field's value
+     * @throws PropertyAccessException if a "set" method cannot be identified
+     */
+    private Method getSetter(Field field, Property prop) throws PropertyAccessException {
+        String nm = "set" + StringUtils.capitalize(field.getName());
+
+        try {
+            return field.getDeclaringClass().getMethod(nm, field.getType());
+
+        } catch (NoSuchMethodException | SecurityException e) {
+            throw new PropertyAccessException(prop.name(), nm, e);
+        }
+    }
+
+    /**
+     * Gets a property value, coercing it to the field's type.
+     *
+     * @param field field whose value is to be set
+     * @param props properties from which to get the value
+     * @param prop property of interest
+     * @return the value extracted from the property, or {@code null} if the field type is
+     *         not supported
+     * @throws PropertyException if an error occurs
+     */
+    protected Object getValue(Field field, Properties props, Property prop) throws PropertyException {
+
+        Class<?> clazz = field.getType();
+        String fieldName = field.getName();
+
+        // can still add support for short, float, double, enum
+
+        if (clazz == String.class) {
+            return getStringValue(fieldName, props, prop);
+
+        } else if (clazz == Boolean.class || clazz == boolean.class) {
+            return getBooleanValue(fieldName, props, prop);
+
+        } else if (clazz == Integer.class || clazz == int.class) {
+            return getIntegerValue(fieldName, props, prop);
+
+        } else if (clazz == Long.class || clazz == long.class) {
+            return getLongValue(fieldName, props, prop);
+
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Verifies that the field can be modified, i.e., it's neither <i>static</i>, nor
+     * <i>final</i>.
+     *
+     * @param field field whose value is to be set
+     * @param prop property of interest
+     * @throws PropertyAccessException if the field is not modifiable
+     */
+    protected void checkModifiable(Field field, Property prop) throws PropertyAccessException {
+        int mod = field.getModifiers();
+
+        if (Modifier.isStatic(mod)) {
+            throw new PropertyAccessException(prop.name(), field.getName(), "'static' variable cannot be modified");
+        }
+
+        if (Modifier.isFinal(mod)) {
+            throw new PropertyAccessException(prop.name(), field.getName(), "'final' variable cannot be modified");
+        }
+    }
+
+    /**
+     * Verifies that the method is not <i>static</i>.
+     *
+     * @param method method to be checked
+     * @param prop property of interest
+     * @throws PropertyAccessException if the method is static
+     */
+    private void checkMethod(Method method, Property prop) throws PropertyAccessException {
+        int mod = method.getModifiers();
+
+        if (Modifier.isStatic(mod)) {
+            throw new PropertyAccessException(prop.name(), method.getName(), "method is 'static'");
+        }
+    }
+
+    /**
+     * Gets a property value, coercing it to a String.
+     *
+     * @param fieldName field whose value is to be set
+     * @param props properties from which to get the value
+     * @param prop property of interest
+     * @return the value extracted from the property
+     * @throws PropertyException if an error occurs
+     */
+    protected String getStringValue(String fieldName, Properties props, Property prop) throws PropertyException {
+
+        /*
+         * Note: the default value for a String type is always valid, thus no need to
+         * check it.
+         */
+
+        return getPropValue(fieldName, props, prop);
+    }
+
+    /**
+     * Gets a property value, coercing it to a Boolean.
+     *
+     * @param fieldName field whose value is to be set
+     * @param props properties from which to get the value
+     * @param prop property of interest
+     * @return the value extracted from the property
+     * @throws PropertyException if an error occurs
+     */
+    protected Boolean getBooleanValue(String fieldName, Properties props, Property prop) throws PropertyException {
+        // validate the default value
+        checkDefaultValue(fieldName, prop, () -> makeBoolean(fieldName, prop, prop.defaultValue()));
+
+        return makeBoolean(fieldName, prop, getPropValue(fieldName, props, prop));
+    }
+
+    /**
+     * Gets a property value, coercing it to an Integer.
+     *
+     * @param fieldName field whose value is to be set
+     * @param props properties from which to get the value
+     * @param prop property of interest
+     * @return the value extracted from the property
+     * @throws PropertyException if an error occurs
+     */
+    protected Integer getIntegerValue(String fieldName, Properties props, Property prop) throws PropertyException {
+        // validate the default value
+        checkDefaultValue(fieldName, prop, () -> makeInteger(fieldName, prop, prop.defaultValue()));
+
+        return makeInteger(fieldName, prop, getPropValue(fieldName, props, prop));
+    }
+
+    /**
+     * Gets a property value, coercing it to a Long.
+     *
+     * @param fieldName field whose value is to be set
+     * @param props properties from which to get the value
+     * @param prop property of interest
+     * @return the value extracted from the property
+     * @throws PropertyException if an error occurs
+     */
+    protected Long getLongValue(String fieldName, Properties props, Property prop) throws PropertyException {
+        // validate the default value
+        checkDefaultValue(fieldName, prop, () -> makeLong(fieldName, prop, prop.defaultValue()));
+
+        return makeLong(fieldName, prop, getPropValue(fieldName, props, prop));
+    }
+
+    /**
+     * Gets a value from the property set.
+     *
+     * @param fieldName field whose value is to be set
+     * @param props properties from which to get the value
+     * @param prop property of interest
+     * @return the value extracted from the property, or the <i>defaultValue</i> if the
+     *         value does not exist
+     * @throws PropertyMissingException if the property does not exist and the
+     *         <i>defaultValue</i> is empty and <i>emptyOk</i> is {@code false}
+     */
+    protected String getPropValue(String fieldName, Properties props, Property prop) throws PropertyMissingException {
+        String propnm = prop.name();
+
+        String val = props.getProperty(propnm);
+        if (val != null && isEmptyOk(prop, val)) {
+            return val;
+        }
+
+        val = prop.defaultValue();
+        if (val != null && isEmptyOk(prop, val)) {
+            return val;
+        }
+
+        throw new PropertyMissingException(prop.name(), fieldName);
+    }
+
+    /**
+     * Coerces a String value into a Boolean.
+     *
+     * @param fieldName field whose value is to be set
+     * @param prop property of interest
+     * @param value value to be coerced
+     * @return the Boolean value represented by the String value
+     * @throws PropertyInvalidException if the value does not represent a valid Boolean
+     */
+    private Boolean makeBoolean(String fieldName, Property prop, String value) throws PropertyInvalidException {
+        if ("true".equalsIgnoreCase(value)) {
+            return Boolean.TRUE;
+
+        } else if ("false".equalsIgnoreCase(value)) {
+            return Boolean.FALSE;
+
+        } else {
+            throw new PropertyInvalidException(prop.name(), fieldName, "expecting 'true' or 'false'");
+        }
+    }
+
+    /**
+     * Coerces a String value into an Integer.
+     *
+     * @param fieldName field whose value is to be set
+     * @param prop property of interest
+     * @param value value to be coerced
+     * @return the Integer value represented by the String value
+     * @throws PropertyInvalidException if the value does not represent a valid Integer
+     */
+    private Integer makeInteger(String fieldName, Property prop, String value) throws PropertyInvalidException {
+        try {
+            return Integer.valueOf(value);
+
+        } catch (NumberFormatException e) {
+            throw new PropertyInvalidException(prop.name(), fieldName, e);
+        }
+    }
+
+    /**
+     * Coerces a String value into a Long.
+     *
+     * @param fieldName field whose value is to be set
+     * @param prop property of interest
+     * @param value value to be coerced
+     * @return the Long value represented by the String value
+     * @throws PropertyInvalidException if the value does not represent a valid Long
+     */
+    private Long makeLong(String fieldName, Property prop, String value) throws PropertyInvalidException {
+        try {
+            return Long.valueOf(value);
+
+        } catch (NumberFormatException e) {
+            throw new PropertyInvalidException(prop.name(), fieldName, e);
+        }
+    }
+
+    /**
+     * Applies a function to check a property's default value. If the function throws an
+     * exception about an invalid property, then it's re-thrown as an exception about an
+     * invalid <i>defaultValue</i>.
+     *
+     * @param fieldName name of the field being checked
+     * @param prop property of interest
+     * @param func function to invoke to check the default value
+     */
+    private void checkDefaultValue(String fieldName, Property prop, CheckDefaultValueFunction func)
+                    throws PropertyInvalidException {
+
+        if (isEmptyOk(prop, prop.defaultValue())) {
+            try {
+                func.apply();
+
+            } catch (PropertyInvalidException ex) {
+                throw new PropertyInvalidException(ex.getPropertyName(), fieldName, "defaultValue is invalid", ex);
+            }
+        }
+    }
+
+    /**
+     * Determines if a value is OK, even if it's empty.
+     *
+     * @param prop property specifying what's acceptable
+     * @param value value to be checked
+     * @return {@code true} if the value is not empty or empty is allowed, {@code false}
+     *         otherwise
+     */
+    protected boolean isEmptyOk(Property prop, String value) {
+        return !value.isEmpty() || isEmptyOk(prop);
+    }
+
+    /**
+     * Determines if a {@link Property}'s <i>accept</i> attribute includes the "empty"
+     * option.
+     *
+     * @param prop property whose <i>accept</i> attribute is to be examined
+     * @return {@code true} if the <i>accept</i> attribute includes "empty"
+     */
+    protected boolean isEmptyOk(Property prop) {
+        for (String option : prop.accept().split(",")) {
+            if (ACCEPT_EMPTY.equals(option)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Copies the field values to a set of properties.
+     *
+     * @param bean bean whose fields are to be exported to the properties
+     * @param props properties into which the values should be added
+     * @param origPrefix prefix of the property names as they appear within the Property
+     *        annotations
+     * @param finalPrefix prefix to use instead, when adding to the set of properties
+     * @throws PropertyException if an error occurs
+     */
+    public void addToProperties(Object bean, Properties props, String origPrefix, String finalPrefix)
+                    throws PropertyException {
+
+        Class<?> clazz = bean.getClass();
+
+        String dottedOrig = (origPrefix.isEmpty() || origPrefix.endsWith(".") ? origPrefix : origPrefix + ".");
+        String dottedFinal = (finalPrefix.isEmpty() || finalPrefix.endsWith(".") ? finalPrefix : finalPrefix + ".");
+
+        while (clazz != Object.class) {
+            for (Field field : clazz.getDeclaredFields()) {
+                putProperty(bean, field, props, dottedOrig, dottedFinal);
+            }
+
+            clazz = clazz.getSuperclass();
+        }
+    }
+
+    /**
+     * Copies the field values to a set of properties.
+     *
+     * @param bean bean whose fields are to be exported to the properties
+     * @param field field whose value is to be copied
+     * @param props properties into which the values should be added
+     * @param origPrefix prefix of the property names as they appear within the Property
+     *        annotations. Includes a trailing "." (if non-empty)
+     * @param finalPrefix prefix to use instead, when adding to the set of properties.
+     *        Includes a trailing "." (if non-empty)
+     * @throws PropertyAccessException if an error occurs
+     */
+    private void putProperty(Object bean, Field field, Properties props, String origPrefix, String finalPrefix)
+                    throws PropertyAccessException {
+
+        Property prop = field.getAnnotation(Property.class);
+        if (prop == null) {
+            return;
+        }
+
+        Method getter = getGetter(field, prop);
+        checkMethod(getter, prop);
+
+        Object value = getBeanValue(bean, field, getter, prop);
+        if (value == null) {
+            return;
+        }
+
+        String name = prop.name();
+        if (name.startsWith(origPrefix)) {
+            name = finalPrefix + name.substring(origPrefix.length());
+        }
+
+        props.setProperty(name, value.toString());
+    }
+
+    /**
+     * Get the getter.
+     *
+     * @param field field whose value is to be gotten
+     * @param prop property of interest
+     * @return the method to be used to get the field's value
+     * @throws PropertyAccessException if a "get" method cannot be identified
+     */
+    private Method getGetter(Field field, Property prop) throws PropertyAccessException {
+        String capnm = StringUtils.capitalize(field.getName());
+
+        try {
+            return getGetter(field, "get" + capnm);
+
+        } catch (NoSuchMethodException e) {
+            if (field.getType() == Boolean.class || field.getType() == boolean.class) {
+                // boolean - check for "isXxx" method, too
+                try {
+                    return getGetter(field, "is" + capnm);
+
+                } catch (NoSuchMethodException | SecurityException e2) {
+                    throw new PropertyAccessException(prop.name(), "is" + capnm, e2);
+                }
+            }
+
+            throw new PropertyAccessException(prop.name(), "get" + capnm, e);
+
+        } catch (SecurityException e) {
+            // problem with "get" method
+            throw new PropertyAccessException(prop.name(), "get" + capnm, e);
+        }
+    }
+
+    /**
+     * Get the getter.  This may be overridden by junit tests.
+     *
+     * @param field field whose value is to be gotten
+     * @param methodName name of the method to return
+     * @return the method to be used to get the field's value
+     * @throws NoSuchMethodException if the method does not exist
+     * @throws SecurityException if the method cannot be accessed
+     */
+    protected Method getGetter(Field field, String methodName) throws NoSuchMethodException, SecurityException {
+        return field.getDeclaringClass().getMethod(methodName);
+    }
+
+    /**
+     * Gets a field's value for a particular property.
+     *
+     * @param bean bean whose fields are to be configured from the properties
+     * @param getter method to be used to get the field's value
+     * @param field field whose value is to be gotten
+     * @param prop property of interest
+     * @throws PropertyAccessException if an error occurs
+     */
+    private Object getBeanValue(Object bean, Field field, Method getter, Property prop)
+                    throws PropertyAccessException {
+        try {
+            return getter.invoke(bean);
+
+        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+            throw new PropertyAccessException(prop.name(), field.getName(), e);
+        }
+    }
+
+    /**
+     * Functions to check a default value.
+     */
+    @FunctionalInterface
+    private static interface CheckDefaultValueFunction {
+
+        /**
+         * Checks the default value.
+         *
+         * @throws PropertyInvalidException if an error occurs
+         */
+        public void apply() throws PropertyInvalidException;
+    }
+}
diff --git a/utils/src/main/java/org/onap/policy/common/utils/properties/Property.java b/utils/src/main/java/org/onap/policy/common/utils/properties/Property.java
new file mode 100644
index 00000000..bacedef9
--- /dev/null
+++ b/utils/src/main/java/org/onap/policy/common/utils/properties/Property.java
@@ -0,0 +1,59 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * 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 java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.Properties;
+
+
+/**
+ * Annotation that declares a variable to be configured via {@link Properties}.
+ */
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+
+public @interface Property {
+
+    /**
+     * Name of the property.
+     *
+     * @return the property name
+     */
+    public String name();
+
+    /**
+     * Default value, used when the property does not exist.
+     *
+     * @return the default value
+     */
+    public String defaultValue() default "";
+
+    /**
+     * Comma-separated options identifying what's acceptable. The word, "empty",
+     * indicates that an empty string, "", is an acceptable value.
+     *
+     * @return options identifying what's acceptable
+     */
+    public String accept() default "";
+}
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 {
+
+    }
+}