Repository: wicket Updated Branches: refs/heads/WICKET-6318-configurable-property-expression-resolver [created] 3a6db1bf7
http://git-wip-us.apache.org/repos/asf/wicket/blob/3a6db1bf/wicket-core/src/main/java/org/apache/wicket/core/util/reflection/MethodGetAndSet.java ---------------------------------------------------------------------- diff --git a/wicket-core/src/main/java/org/apache/wicket/core/util/reflection/MethodGetAndSet.java b/wicket-core/src/main/java/org/apache/wicket/core/util/reflection/MethodGetAndSet.java new file mode 100644 index 0000000..6765dbf --- /dev/null +++ b/wicket-core/src/main/java/org/apache/wicket/core/util/reflection/MethodGetAndSet.java @@ -0,0 +1,243 @@ +package org.apache.wicket.core.util.reflection; + +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import org.apache.wicket.WicketRuntimeException; +import org.apache.wicket.core.util.lang.PropertyResolverConverter; +import org.apache.wicket.util.convert.ConversionException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public final class MethodGetAndSet extends AbstractGetAndSet +{ + private static final Logger log = LoggerFactory.getLogger(MethodGetAndSet.class); + public static final String GET = "get"; + public static final String IS = "is"; + public static final String SET = "set"; + + private final Method getMethod; + private final Method setMethod; + private final Field field; + + public MethodGetAndSet(Method getMethod, Method setMethod, Field field) + { + this.getMethod = getMethod; + this.getMethod.setAccessible(true); + this.field = field; + this.setMethod = setMethod; + } + + /** + * {@inheritDoc} + */ + @Override + public final Object getValue(final Object object) + { + Object ret; + try + { + ret = getMethod.invoke(object, (Object[])null); + } + catch (InvocationTargetException ex) + { + throw new WicketRuntimeException( + "Error calling method: " + getMethod + " on object: " + object, ex.getCause()); + } + catch (Exception ex) + { + throw new WicketRuntimeException( + "Error calling method: " + getMethod + " on object: " + object, ex); + } + return ret; + } + + /** + * @param object + * @param value + * @param converter + */ + @Override + public final void setValue(final Object object, final Object value, + PropertyResolverConverter converter) + { + Class<?> type = null; + if (setMethod != null) + { + // getMethod is always there and if the value will be set through a setMethod then + // the getMethod return type will be its type. Else we have to look at the + // parameters if the setter but getting the return type is quicker + type = getMethod.getReturnType(); + } + else if (field != null) + { + type = field.getType(); + } + + Object converted = null; + if (type != null) + { + converted = converter.convert(value, type); + if (converted == null) + { + if (value != null) + { + throw new ConversionException( + "Method [" + getMethod + "]. Can't convert value: " + value + " to class: " + + getMethod.getReturnType() + " for setting it on " + object); + } + else if (getMethod.getReturnType().isPrimitive()) + { + throw new ConversionException("Method [" + getMethod + + "]. Can't convert null value to a primitive class: " + + getMethod.getReturnType() + " for setting it on " + object); + } + } + } + + if (setMethod != null) + { + try + { + setMethod.invoke(object, converted); + } + catch (InvocationTargetException ex) + { + throw new WicketRuntimeException( + "Error calling method: " + setMethod + " on object: " + object, ex.getCause()); + } + catch (Exception ex) + { + throw new WicketRuntimeException( + "Error calling method: " + setMethod + " on object: " + object, ex); + } + } + else if (field != null) + { + try + { + field.set(object, converted); + } + catch (Exception ex) + { + throw new WicketRuntimeException( + "Error setting field: " + field + " on object: " + object, ex); + } + } + else + { + throw new WicketRuntimeException( + "no set method defined for value: " + value + " on object: " + object + + " while respective getMethod being " + getMethod.getName()); + } + } + + public static Method findSetter(Method getMethod, Class<?> clz) + { + String name = getMethod.getName(); + if (name.startsWith(GET)) + { + name = SET + name.substring(3); + } + else + { + name = SET + name.substring(2); + } + try + { + Method method = clz.getMethod(name, new Class[] { getMethod.getReturnType() }); + if (method != null) + { + method.setAccessible(true); + } + return method; + } + catch (NoSuchMethodException e) + { + Method[] methods = clz.getMethods(); + for (Method method : methods) + { + if (method.getName().equals(name)) + { + Class<?>[] parameterTypes = method.getParameterTypes(); + if (parameterTypes.length == 1) + { + if (parameterTypes[0].isAssignableFrom(getMethod.getReturnType())) + { + return method; + } + } + } + } + log.debug("Cannot find setter corresponding to " + getMethod); + } + catch (Exception e) + { + log.debug("Cannot find setter corresponding to " + getMethod); + } + return null; + } + + /** + * {@inheritDoc} + */ + @Override + public Object newValue(Object object) + { + if (setMethod == null) + { + log.warn("Null setMethod"); + return null; + } + + Class<?> clz = getMethod.getReturnType(); + Object value = null; + try + { + value = clz.newInstance(); + setMethod.invoke(object, value); + } + catch (Exception e) + { + log.warn("Cannot set new value " + value, e); + } + return value; + } + + /** + * {@inheritDoc} + */ + @Override + public Class<?> getTargetClass() + { + return getMethod.getReturnType(); + } + + /** + * {@inheritDoc} + */ + @Override + public Method getGetter() + { + return getMethod; + } + + /** + * {@inheritDoc} + */ + @Override + public Method getSetter() + { + return setMethod; + } + + /** + * {@inheritDoc} + */ + @Override + public Field getField() + { + return field; + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/wicket/blob/3a6db1bf/wicket-core/src/main/java/org/apache/wicket/core/util/reflection/ObjectWithGetAndSet.java ---------------------------------------------------------------------- diff --git a/wicket-core/src/main/java/org/apache/wicket/core/util/reflection/ObjectWithGetAndSet.java b/wicket-core/src/main/java/org/apache/wicket/core/util/reflection/ObjectWithGetAndSet.java new file mode 100644 index 0000000..4dec997 --- /dev/null +++ b/wicket-core/src/main/java/org/apache/wicket/core/util/reflection/ObjectWithGetAndSet.java @@ -0,0 +1,75 @@ +package org.apache.wicket.core.util.reflection; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; + +import org.apache.wicket.core.util.lang.PropertyResolverConverter; + +/** + * @author jcompagner + * + */ +public class ObjectWithGetAndSet +{ + private final IGetAndSet getAndSet; + private final Object value; + + /** + * @param getAndSet + * @param value + */ + public ObjectWithGetAndSet(IGetAndSet getAndSet, Object value) + { + this.getAndSet = getAndSet; + this.value = value; + } + + /** + * @param value + * @param converter + */ + public void setValue(Object value, PropertyResolverConverter converter) + { + getAndSet.setValue(this.value, value, converter); + } + + /** + * @return The value + */ + public Object getValue() + { + return getAndSet.getValue(value); + } + + /** + * @return class of property value + */ + public Class<?> getTargetClass() + { + return getAndSet.getTargetClass(); + } + + /** + * @return Field or null if no field exists for expression + */ + public Field getField() + { + return getAndSet.getField(); + } + + /** + * @return Getter method or null if no getter exists for expression + */ + public Method getGetter() + { + return getAndSet.getGetter(); + } + + /** + * @return Setter method or null if no setter exists for expression + */ + public Method getSetter() + { + return getAndSet.getSetter(); + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/wicket/blob/3a6db1bf/wicket-core/src/main/java/org/apache/wicket/core/util/reflection/ReflectionUtility.java ---------------------------------------------------------------------- diff --git a/wicket-core/src/main/java/org/apache/wicket/core/util/reflection/ReflectionUtility.java b/wicket-core/src/main/java/org/apache/wicket/core/util/reflection/ReflectionUtility.java new file mode 100644 index 0000000..caa0fed --- /dev/null +++ b/wicket-core/src/main/java/org/apache/wicket/core/util/reflection/ReflectionUtility.java @@ -0,0 +1,92 @@ +package org.apache.wicket.core.util.reflection; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; + +import org.apache.wicket.core.util.lang.DefaultPropertyLocator; + +public class ReflectionUtility +{ + + /** + * @param clz + * @param expression + * @return introspected field + */ + public static Field findField(final Class<?> clz, final String expression) + { + Field field = null; + try + { + field = clz.getField(expression); + } + catch (Exception e) + { + Class<?> tmp = clz; + while (tmp != null && tmp != Object.class) + { + Field[] fields = tmp.getDeclaredFields(); + for (Field aField : fields) + { + if (aField.getName().equals(expression)) + { + aField.setAccessible(true); + return aField; + } + } + tmp = tmp.getSuperclass(); + } + DefaultPropertyLocator.log.debug("Cannot find field " + clz + "." + expression); + } + return field; + } + + /** + * @param clz + * @param expression + * @return The method for the expression null if not found + */ + public static Method findGetter(final Class<?> clz, final String expression) + { + String name = Character.toUpperCase(expression.charAt(0)) + expression.substring(1); + Method method = null; + try + { + method = clz.getMethod(MethodGetAndSet.GET + name, (Class[])null); + } + catch (Exception ignored) + { + } + if (method == null) + { + try + { + method = clz.getMethod(MethodGetAndSet.IS + name, (Class[])null); + } + catch (Exception e) + { + DefaultPropertyLocator.log.debug("Cannot find getter " + clz + "." + expression); + } + } + return method; + } + + public static Method findMethod(final Class<?> clz, String expression) + { + if (expression.endsWith("()")) + { + expression = expression.substring(0, expression.length() - 2); + } + Method method = null; + try + { + method = clz.getMethod(expression, (Class[])null); + } + catch (Exception e) + { + DefaultPropertyLocator.log.debug("Cannot find method " + clz + "." + expression); + } + return method; + } + +} http://git-wip-us.apache.org/repos/asf/wicket/blob/3a6db1bf/wicket-core/src/main/java/org/apache/wicket/markup/html/form/FormComponent.java ---------------------------------------------------------------------- diff --git a/wicket-core/src/main/java/org/apache/wicket/markup/html/form/FormComponent.java b/wicket-core/src/main/java/org/apache/wicket/markup/html/form/FormComponent.java index b3d9277..6f9d0b9 100644 --- a/wicket-core/src/main/java/org/apache/wicket/markup/html/form/FormComponent.java +++ b/wicket-core/src/main/java/org/apache/wicket/markup/html/form/FormComponent.java @@ -42,7 +42,6 @@ import org.apache.wicket.core.util.lang.WicketObjects; import org.apache.wicket.markup.ComponentTag; import org.apache.wicket.markup.html.form.AutoLabelResolver.AutoLabelMarker; import org.apache.wicket.model.IModel; -import org.apache.wicket.model.IPropertyReflectionAwareModel; import org.apache.wicket.model.Model; import org.apache.wicket.util.convert.ConversionException; import org.apache.wicket.util.convert.IConverter; http://git-wip-us.apache.org/repos/asf/wicket/blob/3a6db1bf/wicket-core/src/main/java/org/apache/wicket/model/AbstractPropertyModel.java ---------------------------------------------------------------------- diff --git a/wicket-core/src/main/java/org/apache/wicket/model/AbstractPropertyModel.java b/wicket-core/src/main/java/org/apache/wicket/model/AbstractPropertyModel.java index 88ee038..4c48366 100644 --- a/wicket-core/src/main/java/org/apache/wicket/model/AbstractPropertyModel.java +++ b/wicket-core/src/main/java/org/apache/wicket/model/AbstractPropertyModel.java @@ -16,9 +16,6 @@ */ package org.apache.wicket.model; -import java.lang.reflect.Field; -import java.lang.reflect.Method; - import org.apache.wicket.Application; import org.apache.wicket.Session; import org.apache.wicket.WicketRuntimeException; @@ -45,8 +42,7 @@ import org.apache.wicket.util.string.Strings; */ public abstract class AbstractPropertyModel<T> extends ChainingModel<T> implements - IObjectClassAwareModel<T>, - IPropertyReflectionAwareModel<T> + IObjectClassAwareModel<T> { private static final long serialVersionUID = 1L; @@ -149,7 +145,7 @@ public abstract class AbstractPropertyModel<T> extends ChainingModel<T> { try { - return (Class<T>)PropertyResolver.getPropertyClass(expression, target); + return (Class<T>)PropertyResolver.getPropertyClass(expression, target, target.getClass()); } catch (Exception e) { @@ -163,7 +159,7 @@ public abstract class AbstractPropertyModel<T> extends ChainingModel<T> Class<?> targetClass = ((IObjectClassAwareModel<?>) getTarget()).getObjectClass(); if (targetClass != null) { - return PropertyResolver.getPropertyClass(expression, targetClass); + return PropertyResolver.getPropertyClass(expression, null, targetClass); } } catch (WicketRuntimeException e) @@ -175,70 +171,6 @@ public abstract class AbstractPropertyModel<T> extends ChainingModel<T> return null; } - @Override - public Field getPropertyField() - { - String expression = propertyExpression(); - if (Strings.isEmpty(expression) == false) - { - Object target = getInnermostModelOrObject(); - if (target != null) - { - try - { - return PropertyResolver.getPropertyField(expression, target); - } - catch (Exception ignore) - { - // ignore. - } - } - } - return null; - } - - @Override - public Method getPropertyGetter() - { - String expression = propertyExpression(); - if (Strings.isEmpty(expression) == false) - { - Object target = getInnermostModelOrObject(); - if (target != null) - { - try - { - return PropertyResolver.getPropertyGetter(expression, target); - } - catch (Exception ignore) - { - } - } - } - return null; - } - - @Override - public Method getPropertySetter() - { - String expression = propertyExpression(); - if (Strings.isEmpty(expression) == false) - { - Object target = getInnermostModelOrObject(); - if (target != null) - { - try - { - return PropertyResolver.getPropertySetter(expression, target); - } - catch (Exception ignore) - { - } - } - } - return null; - } - /** * @return The property expression for the component */ http://git-wip-us.apache.org/repos/asf/wicket/blob/3a6db1bf/wicket-core/src/main/java/org/apache/wicket/model/IPropertyReflectionAwareModel.java ---------------------------------------------------------------------- diff --git a/wicket-core/src/main/java/org/apache/wicket/model/IPropertyReflectionAwareModel.java b/wicket-core/src/main/java/org/apache/wicket/model/IPropertyReflectionAwareModel.java deleted file mode 100644 index 23258bb..0000000 --- a/wicket-core/src/main/java/org/apache/wicket/model/IPropertyReflectionAwareModel.java +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.wicket.model; - -import java.lang.reflect.Field; -import java.lang.reflect.Method; - -/** - * Optional interface implemented by models that are able to provide reflection information about - * object property they interact with. - * - * The model doesn't have to support all property information in this interface. It is valid to - * return null for any method. - * - * @author Matej Knopp - * @param <T> - */ -public interface IPropertyReflectionAwareModel<T> extends IModel<T> -{ - /** - * Returns the field of model property or null if the field doesn't exist. - * - * @return Field or null - */ - Field getPropertyField(); - - /** - * Returns the getter method of model property or null if the method doesn't exist. - * - * @return Method or null - */ - Method getPropertyGetter(); - - /** - * Returns the setter method of model property or null if the method doesn't exist. - * - * @return Method or null - */ - Method getPropertySetter(); -} http://git-wip-us.apache.org/repos/asf/wicket/blob/3a6db1bf/wicket-core/src/main/java/org/apache/wicket/settings/ApplicationSettings.java ---------------------------------------------------------------------- diff --git a/wicket-core/src/main/java/org/apache/wicket/settings/ApplicationSettings.java b/wicket-core/src/main/java/org/apache/wicket/settings/ApplicationSettings.java index 3dc699d..a86e4ff 100644 --- a/wicket-core/src/main/java/org/apache/wicket/settings/ApplicationSettings.java +++ b/wicket-core/src/main/java/org/apache/wicket/settings/ApplicationSettings.java @@ -21,6 +21,8 @@ import java.lang.ref.WeakReference; import org.apache.wicket.Page; import org.apache.wicket.application.DefaultClassResolver; import org.apache.wicket.application.IClassResolver; +import org.apache.wicket.core.util.lang.IPropertyExpressionResolver; +import org.apache.wicket.core.util.lang.OGNLPropertyExpressionResolver; import org.apache.wicket.feedback.DefaultCleanupFeedbackMessageFilter; import org.apache.wicket.feedback.IFeedbackMessageFilter; import org.apache.wicket.request.cycle.RequestCycle; @@ -55,6 +57,8 @@ public class ApplicationSettings private IClassResolver classResolver = new DefaultClassResolver(); + private IPropertyExpressionResolver propertyExpressionResolver = new OGNLPropertyExpressionResolver(); + private WeakReference<Class<? extends Page>> internalErrorPage; private WeakReference<Class<? extends Page>> pageExpiredErrorPage; @@ -85,6 +89,11 @@ public class ApplicationSettings return classResolver; } + public IPropertyExpressionResolver getPropertyExpressionResolver() + { + return propertyExpressionResolver; + } + /** * Gets the default maximum size for uploads. This is used by {@link org.apache.wicket.markup.html.form.Form#getMaxSize()} if no * value is explicitly set through {@link org.apache.wicket.markup.html.form.Form#setMaxSize(Bytes)}. @@ -158,6 +167,12 @@ public class ApplicationSettings return this; } + public void setPropertyExpressionResolver( + IPropertyExpressionResolver propertyExpressionResolver) + { + this.propertyExpressionResolver = propertyExpressionResolver; + } + /** * Sets the default maximum size for uploads. This is used by {@link org.apache.wicket.markup.html.form.Form#getMaxSize()} if no * value is explicitly set through {@link org.apache.wicket.markup.html.form.Form#setMaxSize(Bytes)}. http://git-wip-us.apache.org/repos/asf/wicket/blob/3a6db1bf/wicket-core/src/test/java/org/apache/wicket/model/AbstractPropertyModelObjectClassTest.java ---------------------------------------------------------------------- diff --git a/wicket-core/src/test/java/org/apache/wicket/model/AbstractPropertyModelObjectClassTest.java b/wicket-core/src/test/java/org/apache/wicket/model/AbstractPropertyModelObjectClassTest.java index 1d141fc..1d613e1 100644 --- a/wicket-core/src/test/java/org/apache/wicket/model/AbstractPropertyModelObjectClassTest.java +++ b/wicket-core/src/test/java/org/apache/wicket/model/AbstractPropertyModelObjectClassTest.java @@ -18,8 +18,7 @@ package org.apache.wicket.model; import java.io.Serializable; -import junit.framework.TestCase; -import org.junit.Assert; +import org.apache.wicket.util.tester.WicketTestCase; import org.junit.Test; /** @@ -31,7 +30,7 @@ import org.junit.Test; * @see <a href="https://issues.apache.org/jira/browse/WICKET-2937";>WICKET-2937</a> * @author Pedro Santos */ -public class AbstractPropertyModelObjectClassTest extends Assert +public class AbstractPropertyModelObjectClassTest extends WicketTestCase { /** http://git-wip-us.apache.org/repos/asf/wicket/blob/3a6db1bf/wicket-core/src/test/java/org/apache/wicket/model/PropertyModelWithListTest.java ---------------------------------------------------------------------- diff --git a/wicket-core/src/test/java/org/apache/wicket/model/PropertyModelWithListTest.java b/wicket-core/src/test/java/org/apache/wicket/model/PropertyModelWithListTest.java index c0ee2da..ea2343f 100644 --- a/wicket-core/src/test/java/org/apache/wicket/model/PropertyModelWithListTest.java +++ b/wicket-core/src/test/java/org/apache/wicket/model/PropertyModelWithListTest.java @@ -19,7 +19,7 @@ package org.apache.wicket.model; import java.util.ArrayList; import java.util.List; -import org.junit.Assert; +import org.apache.wicket.util.tester.WicketTestCase; import org.junit.Test; /** @@ -27,7 +27,7 @@ import org.junit.Test; * * @author Carl-Eric Menzel */ -public class PropertyModelWithListTest extends Assert +public class PropertyModelWithListTest extends WicketTestCase { /** */ public static class BeansContainer http://git-wip-us.apache.org/repos/asf/wicket/blob/3a6db1bf/wicket-core/src/test/java/org/apache/wicket/util/lang/OGNLPropertyExpressionResolverTest.java ---------------------------------------------------------------------- diff --git a/wicket-core/src/test/java/org/apache/wicket/util/lang/OGNLPropertyExpressionResolverTest.java b/wicket-core/src/test/java/org/apache/wicket/util/lang/OGNLPropertyExpressionResolverTest.java new file mode 100644 index 0000000..f371496 --- /dev/null +++ b/wicket-core/src/test/java/org/apache/wicket/util/lang/OGNLPropertyExpressionResolverTest.java @@ -0,0 +1,842 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.wicket.util.lang; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Vector; + +import org.apache.wicket.ConverterLocator; +import org.apache.wicket.IConverterLocator; +import org.apache.wicket.WicketRuntimeException; +import org.apache.wicket.core.util.lang.OGNLPropertyExpressionResolver; +import org.apache.wicket.core.util.lang.PropertyResolverConverter; +import org.apache.wicket.util.convert.ConversionException; +import org.apache.wicket.util.convert.IConverter; +import org.apache.wicket.util.convert.converter.AbstractConverter; +import org.apache.wicket.util.tester.WicketTestCase; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** + * @author jcompagner + * + */ +public class OGNLPropertyExpressionResolverTest extends WicketTestCase +{ + + private static final PropertyResolverConverter CONVERTER = new PropertyResolverConverter( + new ConverterLocator(), Locale.US); + OGNLPropertyExpressionResolver ognlResolver = new OGNLPropertyExpressionResolver(); + private Person person; + + /** + * @throws Exception + */ + @Before + public void before() + { + person = new Person(); + } + + /** + * @throws Exception + */ + @After + public void after() + { +// ognlResolver.destroy(tester.getApplication()); + } + + /** + * @throws Exception + */ + @Test + public void simpleExpression() throws Exception + { + String name = (String)ognlResolver.getValue("name", person); + assertNull(name); + + ognlResolver.setValue("name", person, "wicket", CONVERTER); + name = (String)ognlResolver.getValue("name", person); + assertEquals(name, "wicket"); + } + + /** + * @throws Exception + */ + @Test(expected = ConversionException.class) + public void primitiveValue() throws Exception + { + Integer integer = (Integer)ognlResolver.getValue("age", person); + assertTrue(integer == 0); + + ognlResolver.setValue("age", person, 10, CONVERTER); + integer = (Integer)ognlResolver.getValue("age", person); + assertTrue(integer == 10); + + ognlResolver.setValue("age", person, null, CONVERTER); + fail("primitive type can't be set to null"); + + } + + /** + * @throws Exception + */ + @Test + public void pathExpression() throws Exception + { + person.setAddress(new Address()); + ognlResolver.setValue("address.street", person, "wicket-street", + CONVERTER); + String street = (String)ognlResolver.getValue("address.street", person); + assertEquals(street, "wicket-street"); + + } + + /** + * @throws Exception + */ + @Test + public void testNull() throws Exception + { + String street = (String)ognlResolver.getValue("address.street", person); + assertNull(street); + } + + /** + * @throws Exception + */ + @Test + public void nullCreation() throws Exception + { + ognlResolver.setValue("address.street", person, "wicket-street", + CONVERTER); + String street = (String)ognlResolver.getValue("address.street", person); + assertEquals(street, "wicket-street"); + + try + { + ognlResolver.setValue("country.name", person, "US", CONVERTER); + fail("name can't be set on a country that doesn't have default constructor"); + } + catch (WicketRuntimeException ex) + { + } + } + + /** + * @throws Exception + */ + @Test + public void getterOnly() throws Exception + { + ognlResolver.setValue("country", person, new Country("US"), CONVERTER); + ognlResolver.getValue("country.name", person); + + try + { + ognlResolver.setValue("country.name", person, "NL", CONVERTER); + } + catch (WicketRuntimeException ex) + { + } + } + + /** + * @throws Exception + */ + @Test + public void pathExpressionWithConversion() throws Exception + { + person.setAddress(new Address()); + ognlResolver.setValue("address.number", person, "10", CONVERTER); + Integer number = (Integer)ognlResolver.getValue("address.number", person); + assertEquals(number, new Integer(10)); + + try + { + ognlResolver.setValue("address.number", person, "10a", CONVERTER); + throw new Exception("Conversion error should be thrown"); + } + catch (ConversionException ex) + { + } + + } + + /** + * @throws Exception + */ + @Test + public void mapLookup() throws Exception + { + Address address = new Address(); + ognlResolver.setValue("addressMap", person, + new HashMap<String, Address>(), CONVERTER); + ognlResolver.setValue("addressMap.address", person, address, CONVERTER); + ognlResolver.setValue("addressMap.address.street", person, + "wicket-street", CONVERTER); + String street = (String)ognlResolver.getValue("addressMap.address.street", + person); + assertEquals(street, "wicket-street"); + } + + /** + * @throws Exception + */ + @Test + public void mapWithDotLookup() throws Exception + { + Address address = new Address(); + HashMap<String, Address> hm = new HashMap<String, Address>(); + ognlResolver.setValue("addressMap", person, hm, CONVERTER); + ognlResolver.setValue("addressMap[address.test]", person, address, + CONVERTER); + assertNotNull(hm.get("address.test")); + ognlResolver.setValue("addressMap[address.test].street", person, + "wicket-street", CONVERTER); + String street = (String)ognlResolver + .getValue("addressMap[address.test].street", person); + assertEquals(street, "wicket-street"); + } + + /** + * @throws Exception + */ + @Test + public void listLookup() throws Exception + { + ognlResolver.setValue("addressList", person, new ArrayList<Address>(), + CONVERTER); + ognlResolver.setValue("addressList.0", person, new Address(), CONVERTER); + ognlResolver.setValue("addressList.10", person, new Address(), CONVERTER); + ognlResolver.setValue("addressList.1", person, new Address(), CONVERTER); + ognlResolver.setValue("addressList.1.street", person, "wicket-street", + CONVERTER); + + String street = (String)ognlResolver.getValue("addressList.0.street", + person); + assertNull(street); + street = (String)ognlResolver.getValue("addressList.1.street", person); + assertEquals(street, "wicket-street"); + } + + /** + * @throws Exception + */ + @Test + public void arrayLookup() throws Exception + { + ognlResolver.setValue("addressArray", person, + new Address[] { new Address(), null }, CONVERTER); + ognlResolver.setValue("addressArray.0.street", person, "wicket-street", + CONVERTER); + String street = (String)ognlResolver.getValue("addressArray.0.street", + person); + assertEquals(street, "wicket-street"); + + ognlResolver.setValue("addressArray.1.street", person, "wicket-street", + CONVERTER); + street = (String)ognlResolver.getValue("addressArray.1.street", person); + assertEquals(street, "wicket-street"); + } + + /** + * @throws Exception + */ + @Test + public void arrayLookupByBrackets() throws Exception + { + ognlResolver.setValue("addressArray", person, + new Address[] { new Address(), null }, CONVERTER); + ognlResolver.setValue("addressArray[0].street", person, "wicket-street", + CONVERTER); + String street = (String)ognlResolver.getValue("addressArray[0].street", + person); + assertEquals(street, "wicket-street"); + + ognlResolver.setValue("addressArray[1].street", person, "wicket-street", + CONVERTER); + street = (String)ognlResolver.getValue("addressArray[1].street", person); + assertEquals(street, "wicket-street"); + } + + /** + * @throws Exception + */ + @Test + public void propertyByIndexLookup() throws Exception + { + ognlResolver.setValue("addressAt.0", person, new Address(), CONVERTER); + ognlResolver.setValue("addressAt.0.street", person, "wicket-street", + CONVERTER); + String street = (String)ognlResolver.getValue("addressAt.0.street", + person); + assertEquals(street, "wicket-street"); + } + + /** + * @throws Exception + */ + @Test + public void getPropertyByNotExistingIndexArrayLookup() throws Exception + { + ognlResolver.setValue("addressArray", person, new Address[] { }, + CONVERTER); + String street = (String)ognlResolver.getValue("addressArray.0.street", + person); + assertNull(street); + street = (String)ognlResolver.getValue("addressArray[0].street", person); + assertNull(street); + } + + /** + * @throws Exception + */ + @Test + public void getPropertyByNotExistingIndexListLookup() throws Exception + { + ognlResolver.setValue("addressList", person, new ArrayList<Address>(), + CONVERTER); + String street = (String)ognlResolver.getValue("addressList.0.street", + person); + assertNull(street); + street = (String)ognlResolver.getValue("addressList[0].street", person); + assertNull(street); + } + + /** + * @throws Exception + */ + @Test + public void getIndexPropertyDirectly() throws Exception + { + Address address = new Address(); + Address[] addresses = new Address[] { address }; + + Address address2 = (Address)ognlResolver.getValue("[0]", addresses); + assertSame(address, address2); + } + + /** + * @throws Exception + */ + @Test + public void listSizeLookup() throws Exception + { + List<Address> addresses = new ArrayList<Address>(); + addresses.add(new Address()); + addresses.add(new Address()); + person.setAddressList(addresses); + Object size = ognlResolver.getValue("addressList.size", person); + assertEquals(size, 2); + size = ognlResolver.getValue("addressList.size()", person); + assertEquals(size, 2); + } + + + /** + * @throws Exception + */ + @Test + public void mapSizeLookup() throws Exception + { + Map<String, Address> addresses = new HashMap<String, Address>(); + Address address = new Address(); + addresses.put("size", address); + addresses.put("test", new Address()); + person.setAddressMap(addresses); + Object addressFromMap = ognlResolver.getValue("addressMap.size", person); + assertEquals(addressFromMap, address); + Object size = ognlResolver.getValue("addressMap.size()", person); + assertEquals(size, 2); + } + + /** + * @throws Exception + */ + @Test + public void arraySizeLookup() throws Exception + { + person.setAddressArray(new Address[] { new Address(), new Address() }); + Object size = ognlResolver.getValue("addressArray.length", person); + assertEquals(size, 2); + size = ognlResolver.getValue("addressArray.size", person); + assertEquals(size, 2); + } + + /** + * @throws Exception + */ + @Test + public void methodLookup() throws Exception + { + Address[] addresses = new Address[] { new Address(), new Address() }; + person.setAddressArray(addresses); + Object value = ognlResolver.getValue("getAddressArray()", person); + assertEquals(value, addresses); + } + + /** + * @throws Exception + */ + @Test + public void field() throws Exception + { + Address address = new Address(); + ognlResolver.setValue("address2", person, address, CONVERTER); + Address address2 = (Address)ognlResolver.getValue("address2", person); + assertEquals(address, address2); + + try + { + ognlResolver.setValue("address3", person, address, CONVERTER); + fail("Shoudln't come here"); + } + catch (RuntimeException ex) + { + + } + } + + /** + * @throws Exception + */ + @Test + public void testPrivateField() throws Exception + { + Address address = new Address(); + ognlResolver.setValue("privateAddress", person, address, CONVERTER); + Address address2 = (Address)ognlResolver.getValue("privateAddress", + person); + assertEquals(address, address2); + } + + /** + * @throws Exception + */ + @Test + public void privateFieldOfSuperClass() throws Exception + { + Person2 person2 = new Person2(); + Address address = new Address(); + ognlResolver.setValue("privateAddress", person2, address, CONVERTER); + Address address2 = (Address)ognlResolver.getValue("privateAddress", + person2); + assertEquals(address, address2); + } + + /** + * + */ + @Test + public void getTargetClass() + { + Address address = new Address(); + + Class<?> clazz = ognlResolver.getPropertyClass("number", address, address.getClass()); + assertEquals(int.class, clazz); + + Person person = new Person(); + person.setAddress(new Address()); + + clazz = ognlResolver.getPropertyClass("address.number", person, person.getClass()); + assertEquals(int.class, clazz); + + person.setAddressArray(new Address[] { new Address(), new Address() }); + clazz = ognlResolver.getPropertyClass("addressArray[0]", person, person.getClass()); + assertEquals(Address.class, clazz); + + clazz = ognlResolver.getPropertyClass("addressArray[0].number", person, person.getClass()); + assertEquals(int.class, clazz); + } + + /** + * + */ + @Test + public void getTargetField() + { + Address address = new Address(); + + Field field = ognlResolver.getPropertyField("number", address); + assertEquals(field.getName(), "number"); + assertEquals(field.getType(), int.class); + + Person person = new Person(); + person.setAddress(new Address()); + + field = ognlResolver.getPropertyField("address.number", person); + assertEquals(field.getName(), "number"); + assertEquals(field.getType(), int.class); + + person.setAddressArray(new Address[] { new Address(), new Address() }); + field = ognlResolver.getPropertyField("addressArray[0].number", person); + assertEquals(field.getName(), "number"); + assertEquals(field.getType(), int.class); + } + + /** + * + */ + @Test + public void getTargetGetter() + { + Address address = new Address(); + + Method method = ognlResolver.getPropertyGetter("number", address); + assertEquals(method.getName(), "getNumber"); + assertEquals(method.getReturnType(), int.class); + + Person person = new Person(); + person.setAddress(new Address()); + + method = ognlResolver.getPropertyGetter("address.number", person); + assertEquals(method.getName(), "getNumber"); + assertEquals(method.getReturnType(), int.class); + + person.setAddressArray(new Address[] { new Address(), new Address() }); + method = ognlResolver.getPropertyGetter("addressArray[0].number", person); + assertEquals(method.getName(), "getNumber"); + assertEquals(method.getReturnType(), int.class); + } + + /** + * @throws Exception + */ + @Test + public void onlyPrimitiveGetter() throws Exception + { + Person person = new Person(); + + ognlResolver.setValue("onlyGetterPrimitive", person, 1, CONVERTER); + + assertEquals(person.getOnlyGetterPrimitive(), 1); + assertEquals(ognlResolver.getValue("onlyGetterPrimitive", person), 1); + + } + + /** + * @throws Exception + */ + @Test + public void onlyStringGetter() throws Exception + { + Person person = new Person(); + + ognlResolver.setValue("onlyGetterString", person, "onlygetter", + CONVERTER); + + assertEquals(person.getOnlyGetterString(), "onlygetter"); + assertEquals(ognlResolver.getValue("onlyGetterString", person), + "onlygetter"); + + } + + /** + * + */ + @Test + public void getTargetSetter() + { + Address address = new Address(); + + Method method = ognlResolver.getPropertySetter("number", address); + assertEquals(method.getName(), "setNumber"); + + Person person = new Person(); + person.setAddress(new Address()); + + method = ognlResolver.getPropertySetter("address.number", person); + assertEquals(method.getName(), "setNumber"); + + person.setAddressArray(new Address[] { new Address(), new Address() }); + method = ognlResolver.getPropertySetter("addressArray[0].number", person); + assertEquals(method.getName(), "setNumber"); + } + + /** + * @throws Exception + */ + @Test + public void overriddenGetter() throws Exception + { + Person2 person = new Person2(); + person.setName("foo"); + + String name = (String)ognlResolver.getValue("name", person); + assertEquals("foo", name); + + ognlResolver.setValue("name", person, "bar", CONVERTER); + + name = (String)ognlResolver.getValue("name", person); + assertEquals("bar", name); + + } + + /** + * @throws Exception + */ + @Test + public void propertyClassWithSubType() throws Exception + { + Person person = new Person(); + assertEquals(String.class, + ognlResolver.getPropertyClass("country.name", person, person.getClass())); + try + { + ognlResolver.getPropertyClass("country.subCountry.name", person, person.getClass()); + fail("country.subCountry shouldnt be found"); + } + catch (Exception e) + { + + } + person.setCountry(new Country2("test", new Country("test"))); + ognlResolver.getPropertyClass("country.subCountry.name", person, person.getClass()); + } + + /** + * Used for models in testing. + */ + private static class InnerVectorPOJO extends Vector<Void> + { + private static final long serialVersionUID = 1L; + + /** + */ + @SuppressWarnings("unused") + public String testValue = "vector"; + } + + /** + * Tests the PropertyModel with vector. + */ + @Test + public void propertyModel() + { + String value = (String)ognlResolver.getValue("testValue", + new InnerVectorPOJO()); + assertEquals("vector", value); + } + + /** + * + */ + @Test + public void directFieldSetWithDifferentTypeThanGetter() + { + final DirectFieldSetWithDifferentTypeThanGetter obj = new DirectFieldSetWithDifferentTypeThanGetter(); + ognlResolver.setValue("value", obj, 1, null); + assertEquals(1, obj.value); + } + + private static class DirectFieldSetWithDifferentTypeThanGetter + { + private int value; + + @SuppressWarnings("unused") + public String getValue() + { + return String.valueOf(value); + } + } + + /** + * @see <a href="https://issues.apache.org/jira/browse/WICKET-1802";>WICKET-1802</a> + */ + @Test + public void conversionExceptionMessageContainsTheObjectPropertyBeingSet() + { + try + { + PropertyResolverConverter convertToNull = new PropertyResolverConverter(null, null) + { + private static final long serialVersionUID = 1L; + + @Override + public <T> T convert(Object object, java.lang.Class<T> clz) + { + return null; + } + }; + ognlResolver.setValue("name", person, "", convertToNull); + fail("Should have thrown an ConversionException"); + } + catch (ConversionException e) + { + assertTrue(e.getMessage().toLowerCase().contains("name")); + } + } + + /** + * WICKET-3441 + */ + @Test + public void dateToStringConverting() + { + IConverterLocator converterLocator = new ConverterLocator(); + Locale locale = Locale.GERMAN; + PropertyResolverConverter converter = new PropertyResolverConverter(converterLocator, + locale); + + Calendar calDate = Calendar.getInstance(); + calDate.clear(); + calDate.set(2011, Calendar.APRIL, 17); + Date date = calDate.getTime(); + + Object actual = converter.convert(date, String.class); + String expected = converterLocator.getConverter(Date.class).convertToString(date, locale); + assertEquals(expected, actual); + } + + /** + * WICKET-3441 + */ + @Test + public void dateToLongConverting() + { + ConverterLocator converterLocator = new ConverterLocator(); + final IConverter<Date> dateConverter = converterLocator.get(Date.class); + IConverter<Long> customLongConverter = new AbstractConverter<Long>() + { + private static final long serialVersionUID = 1L; + + @Override + public Long convertToObject(String value, Locale locale) + { + Date date = dateConverter.convertToObject(value, locale); + return date != null ? date.getTime() : null; + } + + @Override + public String convertToString(Long value, Locale locale) + { + Date date; + if (value != null) + { + date = new Date(); + date.setTime(value); + } + else + { + date = null; + } + + return dateConverter.convertToString(date, locale); + } + + @Override + protected Class<Long> getTargetType() + { + return Long.class; + } + }; + converterLocator.set(Long.class, customLongConverter); + converterLocator.set(Long.TYPE, customLongConverter); + + PropertyResolverConverter converter = new PropertyResolverConverter(converterLocator, + Locale.ENGLISH); + + Calendar calDate = Calendar.getInstance(); + calDate.clear(); + calDate.set(2011, Calendar.APRIL, 17); + Date date = calDate.getTime(); + + Object actual = converter.convert(date, Long.class); + assertEquals(date.getTime(), actual); + } + +// /** +// * WICKET-5623 custom properties +// */ +// @Test +// public void custom() +// { +// Document document = new Document(); +// document.setType("type"); +// document.setProperty("string", "string"); +// +// Document nestedCustom = new Document(); +// nestedCustom.setProperty("string", "string2"); +// document.setProperty("nested", nestedCustom); +// +// ognlResolver.setLocator(tester.getApplication(), +// new CachingPropertyLocator(new CustomGetAndSetLocator())); +// +// assertEquals("type", ognlResolver.getValue("type", document)); +// assertEquals("string", ognlResolver.getValue("string", document)); +// assertEquals("string2", ognlResolver.getValue("nested.string", document)); +// } + +// class CustomGetAndSetLocator implements IPropertyLocator +// { +// +// private IPropertyLocator locator = new DefaultPropertyLocator(); +// +// @Override +// public IGetAndSet get(Class<?> clz, String exp) +// { +// // first try default properties +// IGetAndSet getAndSet = locator.get(clz, exp); +// if (getAndSet == null && Document.class.isAssignableFrom(clz)) +// { +// // fall back to document properties +// getAndSet = new DocumentPropertyGetAndSet(exp); +// } +// return getAndSet; +// } +// +// public class DocumentPropertyGetAndSet extends AbstractGetAndSet +// { +// +// private String name; +// +// public DocumentPropertyGetAndSet(String name) +// { +// this.name = name; +// } +// +// @Override +// public Object getValue(Object object) +// { +// return ((Document)object).getProperty(name); +// } +// +// @Override +// public Object newValue(Object object) +// { +// return new Document(); +// } +// +// @Override +// public void setValue(Object object, Object value, PropertyResolverConverter converter) +// { +// ((Document)object).setProperty(name, value); +// } +// } +// } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/wicket/blob/3a6db1bf/wicket-core/src/test/java/org/apache/wicket/util/lang/PropertyResolverTest.java ---------------------------------------------------------------------- diff --git a/wicket-core/src/test/java/org/apache/wicket/util/lang/PropertyResolverTest.java b/wicket-core/src/test/java/org/apache/wicket/util/lang/PropertyResolverTest.java deleted file mode 100644 index 1a3278d..0000000 --- a/wicket-core/src/test/java/org/apache/wicket/util/lang/PropertyResolverTest.java +++ /dev/null @@ -1,809 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.wicket.util.lang; - -import java.lang.reflect.Field; -import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.Calendar; -import java.util.Date; -import java.util.HashMap; -import java.util.List; -import java.util.Locale; -import java.util.Map; -import java.util.Vector; - -import org.apache.wicket.ConverterLocator; -import org.apache.wicket.IConverterLocator; -import org.apache.wicket.WicketRuntimeException; -import org.apache.wicket.core.util.lang.PropertyResolver; -import org.apache.wicket.core.util.lang.PropertyResolver.AbstractGetAndSet; -import org.apache.wicket.core.util.lang.PropertyResolver.CachingPropertyLocator; -import org.apache.wicket.core.util.lang.PropertyResolver.DefaultPropertyLocator; -import org.apache.wicket.core.util.lang.PropertyResolver.IGetAndSet; -import org.apache.wicket.core.util.lang.PropertyResolver.IPropertyLocator; -import org.apache.wicket.core.util.lang.PropertyResolverConverter; -import org.apache.wicket.util.convert.ConversionException; -import org.apache.wicket.util.convert.IConverter; -import org.apache.wicket.util.convert.converter.AbstractConverter; -import org.apache.wicket.util.tester.WicketTestCase; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; - -/** - * @author jcompagner - * - */ -public class PropertyResolverTest extends WicketTestCase -{ - - private static final PropertyResolverConverter CONVERTER = new PropertyResolverConverter( - new ConverterLocator(), Locale.US); - - private Person person; - - /** - * @throws Exception - */ - @Before - public void before() - { - person = new Person(); - } - - /** - * @throws Exception - */ - @After - public void after() - { - PropertyResolver.destroy(tester.getApplication()); - } - - /** - * @throws Exception - */ - @Test - public void simpleExpression() throws Exception - { - String name = (String) PropertyResolver.getValue("name", person); - assertNull(name); - - PropertyResolver.setValue("name", person, "wicket", CONVERTER); - name = (String)PropertyResolver.getValue("name", person); - assertEquals(name, "wicket"); - } - - /** - * @throws Exception - */ - @Test(expected = ConversionException.class) - public void primitiveValue() throws Exception - { - Integer integer = (Integer)PropertyResolver.getValue("age", person); - assertTrue(integer == 0); - - PropertyResolver.setValue("age", person, 10, CONVERTER); - integer = (Integer)PropertyResolver.getValue("age", person); - assertTrue(integer == 10); - - PropertyResolver.setValue("age", person, null, CONVERTER); - fail("primitive type can't be set to null"); - - } - - /** - * @throws Exception - */ - @Test - public void pathExpression() throws Exception - { - person.setAddress(new Address()); - PropertyResolver.setValue("address.street", person, "wicket-street", CONVERTER); - String street = (String)PropertyResolver.getValue("address.street", person); - assertEquals(street, "wicket-street"); - - } - - /** - * @throws Exception - */ - @Test - public void testNull() throws Exception - { - String street = (String)PropertyResolver.getValue("address.street", person); - assertNull(street); - } - - /** - * @throws Exception - */ - @Test - public void nullCreation() throws Exception - { - PropertyResolver.setValue("address.street", person, "wicket-street", CONVERTER); - String street = (String)PropertyResolver.getValue("address.street", person); - assertEquals(street, "wicket-street"); - - try - { - PropertyResolver.setValue("country.name", person, "US", CONVERTER); - fail("name can't be set on a country that doesn't have default constructor"); - } - catch (WicketRuntimeException ex) - { - } - } - - /** - * @throws Exception - */ - @Test - public void getterOnly() throws Exception - { - PropertyResolver.setValue("country", person, new Country("US"), CONVERTER); - PropertyResolver.getValue("country.name", person); - - try - { - PropertyResolver.setValue("country.name", person, "NL", CONVERTER); - } - catch (WicketRuntimeException ex) - { - } - } - - /** - * @throws Exception - */ - @Test - public void pathExpressionWithConversion() throws Exception - { - person.setAddress(new Address()); - PropertyResolver.setValue("address.number", person, "10", CONVERTER); - Integer number = (Integer)PropertyResolver.getValue("address.number", person); - assertEquals(number, new Integer(10)); - - try - { - PropertyResolver.setValue("address.number", person, "10a", CONVERTER); - throw new Exception("Conversion error should be thrown"); - } - catch (ConversionException ex) - { - } - - } - - /** - * @throws Exception - */ - @Test - public void mapLookup() throws Exception - { - Address address = new Address(); - PropertyResolver.setValue("addressMap", person, new HashMap<String, Address>(), CONVERTER); - PropertyResolver.setValue("addressMap.address", person, address, CONVERTER); - PropertyResolver.setValue("addressMap.address.street", person, "wicket-street", CONVERTER); - String street = (String)PropertyResolver.getValue("addressMap.address.street", person); - assertEquals(street, "wicket-street"); - } - - /** - * @throws Exception - */ - @Test - public void mapWithDotLookup() throws Exception - { - Address address = new Address(); - HashMap<String, Address> hm = new HashMap<String, Address>(); - PropertyResolver.setValue("addressMap", person, hm, CONVERTER); - PropertyResolver.setValue("addressMap[address.test]", person, address, CONVERTER); - assertNotNull(hm.get("address.test")); - PropertyResolver.setValue("addressMap[address.test].street", person, "wicket-street", - CONVERTER); - String street = (String)PropertyResolver.getValue("addressMap[address.test].street", person); - assertEquals(street, "wicket-street"); - } - - /** - * @throws Exception - */ - @Test - public void listLookup() throws Exception - { - PropertyResolver.setValue("addressList", person, new ArrayList<Address>(), CONVERTER); - PropertyResolver.setValue("addressList.0", person, new Address(), CONVERTER); - PropertyResolver.setValue("addressList.10", person, new Address(), CONVERTER); - PropertyResolver.setValue("addressList.1", person, new Address(), CONVERTER); - PropertyResolver.setValue("addressList.1.street", person, "wicket-street", CONVERTER); - - String street = (String)PropertyResolver.getValue("addressList.0.street", person); - assertNull(street); - street = (String)PropertyResolver.getValue("addressList.1.street", person); - assertEquals(street, "wicket-street"); - } - - /** - * @throws Exception - */ - @Test - public void arrayLookup() throws Exception - { - PropertyResolver.setValue("addressArray", person, new Address[] { new Address(), null }, - CONVERTER); - PropertyResolver.setValue("addressArray.0.street", person, "wicket-street", CONVERTER); - String street = (String)PropertyResolver.getValue("addressArray.0.street", person); - assertEquals(street, "wicket-street"); - - PropertyResolver.setValue("addressArray.1.street", person, "wicket-street", CONVERTER); - street = (String)PropertyResolver.getValue("addressArray.1.street", person); - assertEquals(street, "wicket-street"); - } - - /** - * @throws Exception - */ - @Test - public void arrayLookupByBrackets() throws Exception - { - PropertyResolver.setValue("addressArray", person, new Address[] { new Address(), null }, - CONVERTER); - PropertyResolver.setValue("addressArray[0].street", person, "wicket-street", CONVERTER); - String street = (String)PropertyResolver.getValue("addressArray[0].street", person); - assertEquals(street, "wicket-street"); - - PropertyResolver.setValue("addressArray[1].street", person, "wicket-street", CONVERTER); - street = (String)PropertyResolver.getValue("addressArray[1].street", person); - assertEquals(street, "wicket-street"); - } - - /** - * @throws Exception - */ - @Test - public void propertyByIndexLookup() throws Exception - { - PropertyResolver.setValue("addressAt.0", person, new Address(), CONVERTER); - PropertyResolver.setValue("addressAt.0.street", person, "wicket-street", CONVERTER); - String street = (String)PropertyResolver.getValue("addressAt.0.street", person); - assertEquals(street, "wicket-street"); - } - - /** - * @throws Exception - */ - @Test - public void getPropertyByNotExistingIndexArrayLookup() throws Exception - { - PropertyResolver.setValue("addressArray", person, new Address[] { }, CONVERTER); - String street = (String)PropertyResolver.getValue("addressArray.0.street", person); - assertNull(street); - street = (String)PropertyResolver.getValue("addressArray[0].street", person); - assertNull(street); - } - - /** - * @throws Exception - */ - @Test - public void getPropertyByNotExistingIndexListLookup() throws Exception - { - PropertyResolver.setValue("addressList", person, new ArrayList<Address>(), CONVERTER); - String street = (String)PropertyResolver.getValue("addressList.0.street", person); - assertNull(street); - street = (String)PropertyResolver.getValue("addressList[0].street", person); - assertNull(street); - } - - /** - * @throws Exception - */ - @Test - public void getIndexPropertyDirectly() throws Exception - { - Address address = new Address(); - Address[] addresses = new Address[] { address }; - - Address address2 = (Address)PropertyResolver.getValue("[0]", addresses); - assertSame(address, address2); - } - - /** - * @throws Exception - */ - @Test - public void listSizeLookup() throws Exception - { - List<Address> addresses = new ArrayList<Address>(); - addresses.add(new Address()); - addresses.add(new Address()); - person.setAddressList(addresses); - Object size = PropertyResolver.getValue("addressList.size", person); - assertEquals(size, 2); - size = PropertyResolver.getValue("addressList.size()", person); - assertEquals(size, 2); - } - - - /** - * @throws Exception - */ - @Test - public void mapSizeLookup() throws Exception - { - Map<String, Address> addresses = new HashMap<String, Address>(); - Address address = new Address(); - addresses.put("size", address); - addresses.put("test", new Address()); - person.setAddressMap(addresses); - Object addressFromMap = PropertyResolver.getValue("addressMap.size", person); - assertEquals(addressFromMap, address); - Object size = PropertyResolver.getValue("addressMap.size()", person); - assertEquals(size, 2); - } - - /** - * @throws Exception - */ - @Test - public void arraySizeLookup() throws Exception - { - person.setAddressArray(new Address[] { new Address(), new Address() }); - Object size = PropertyResolver.getValue("addressArray.length", person); - assertEquals(size, 2); - size = PropertyResolver.getValue("addressArray.size", person); - assertEquals(size, 2); - } - - /** - * @throws Exception - */ - @Test - public void methodLookup() throws Exception - { - Address[] addresses = new Address[] { new Address(), new Address() }; - person.setAddressArray(addresses); - Object value = PropertyResolver.getValue("getAddressArray()", person); - assertEquals(value, addresses); - } - - /** - * @throws Exception - */ - @Test - public void field() throws Exception - { - Address address = new Address(); - PropertyResolver.setValue("address2", person, address, CONVERTER); - Address address2 = (Address)PropertyResolver.getValue("address2", person); - assertEquals(address, address2); - - try - { - PropertyResolver.setValue("address3", person, address, CONVERTER); - fail("Shoudln't come here"); - } - catch (RuntimeException ex) - { - - } - } - - /** - * @throws Exception - */ - @Test - public void testPrivateField() throws Exception - { - Address address = new Address(); - PropertyResolver.setValue("privateAddress", person, address, CONVERTER); - Address address2 = (Address)PropertyResolver.getValue("privateAddress", person); - assertEquals(address, address2); - } - - /** - * @throws Exception - */ - @Test - public void privateFieldOfSuperClass() throws Exception - { - Person2 person2 = new Person2(); - Address address = new Address(); - PropertyResolver.setValue("privateAddress", person2, address, CONVERTER); - Address address2 = (Address)PropertyResolver.getValue("privateAddress", person2); - assertEquals(address, address2); - } - - /** - * - */ - @Test - public void getTargetClass() - { - Address address = new Address(); - - Class<?> clazz = PropertyResolver.getPropertyClass("number", address); - assertEquals(int.class, clazz); - - Person person = new Person(); - person.setAddress(new Address()); - - clazz = PropertyResolver.getPropertyClass("address.number", person); - assertEquals(int.class, clazz); - - person.setAddressArray(new Address[] { new Address(), new Address() }); - clazz = PropertyResolver.getPropertyClass("addressArray[0]", person); - assertEquals(Address.class, clazz); - - clazz = PropertyResolver.getPropertyClass("addressArray[0].number", person); - assertEquals(int.class, clazz); - } - - /** - * - */ - @Test - public void getTargetField() - { - Address address = new Address(); - - Field field = PropertyResolver.getPropertyField("number", address); - assertEquals(field.getName(), "number"); - assertEquals(field.getType(), int.class); - - Person person = new Person(); - person.setAddress(new Address()); - - field = PropertyResolver.getPropertyField("address.number", person); - assertEquals(field.getName(), "number"); - assertEquals(field.getType(), int.class); - - person.setAddressArray(new Address[] { new Address(), new Address() }); - field = PropertyResolver.getPropertyField("addressArray[0].number", person); - assertEquals(field.getName(), "number"); - assertEquals(field.getType(), int.class); - } - - /** - * - */ - @Test - public void getTargetGetter() - { - Address address = new Address(); - - Method method = PropertyResolver.getPropertyGetter("number", address); - assertEquals(method.getName(), "getNumber"); - assertEquals(method.getReturnType(), int.class); - - Person person = new Person(); - person.setAddress(new Address()); - - method = PropertyResolver.getPropertyGetter("address.number", person); - assertEquals(method.getName(), "getNumber"); - assertEquals(method.getReturnType(), int.class); - - person.setAddressArray(new Address[] { new Address(), new Address() }); - method = PropertyResolver.getPropertyGetter("addressArray[0].number", person); - assertEquals(method.getName(), "getNumber"); - assertEquals(method.getReturnType(), int.class); - } - - /** - * @throws Exception - */ - @Test - public void onlyPrimitiveGetter() throws Exception - { - Person person = new Person(); - - PropertyResolver.setValue("onlyGetterPrimitive", person, 1, CONVERTER); - - assertEquals(person.getOnlyGetterPrimitive(), 1); - assertEquals(PropertyResolver.getValue("onlyGetterPrimitive", person), 1); - - } - - /** - * @throws Exception - */ - @Test - public void onlyStringGetter() throws Exception - { - Person person = new Person(); - - PropertyResolver.setValue("onlyGetterString", person, "onlygetter", CONVERTER); - - assertEquals(person.getOnlyGetterString(), "onlygetter"); - assertEquals(PropertyResolver.getValue("onlyGetterString", person), "onlygetter"); - - } - - /** - * - */ - @Test - public void getTargetSetter() - { - Address address = new Address(); - - Method method = PropertyResolver.getPropertySetter("number", address); - assertEquals(method.getName(), "setNumber"); - - Person person = new Person(); - person.setAddress(new Address()); - - method = PropertyResolver.getPropertySetter("address.number", person); - assertEquals(method.getName(), "setNumber"); - - person.setAddressArray(new Address[] { new Address(), new Address() }); - method = PropertyResolver.getPropertySetter("addressArray[0].number", person); - assertEquals(method.getName(), "setNumber"); - } - - /** - * @throws Exception - */ - @Test - public void overriddenGetter() throws Exception - { - Person2 person = new Person2(); - person.setName("foo"); - - String name = (String)PropertyResolver.getValue("name", person); - assertEquals("foo", name); - - PropertyResolver.setValue("name", person, "bar", CONVERTER); - - name = (String)PropertyResolver.getValue("name", person); - assertEquals("bar", name); - - } - - /** - * @throws Exception - */ - @Test - public void propertyClassWithSubType() throws Exception - { - Person person = new Person(); - assertEquals(String.class, PropertyResolver.getPropertyClass("country.name", person)); - try - { - PropertyResolver.getPropertyClass("country.subCountry.name", person); - fail("country.subCountry shouldnt be found"); - } - catch (Exception e) - { - - } - person.setCountry(new Country2("test", new Country("test"))); - PropertyResolver.getPropertyClass("country.subCountry.name", person); - } - - /** - * Used for models in testing. - */ - private static class InnerVectorPOJO extends Vector<Void> - { - private static final long serialVersionUID = 1L; - - /** - */ - @SuppressWarnings("unused") - public String testValue = "vector"; - } - - /** - * Tests the PropertyModel with vector. - */ - @Test - public void propertyModel() - { - String value = (String)PropertyResolver.getValue("testValue", new InnerVectorPOJO()); - assertEquals("vector", value); - } - - /** - * - */ - @Test - public void directFieldSetWithDifferentTypeThanGetter() - { - final DirectFieldSetWithDifferentTypeThanGetter obj = new DirectFieldSetWithDifferentTypeThanGetter(); - PropertyResolver.setValue("value", obj, 1, null); - assertEquals(1, obj.value); - } - - private static class DirectFieldSetWithDifferentTypeThanGetter - { - private int value; - - @SuppressWarnings("unused") - public String getValue() - { - return String.valueOf(value); - } - } - - /** - * @see <a href="https://issues.apache.org/jira/browse/WICKET-1802";>WICKET-1802</a> - */ - @Test - public void conversionExceptionMessageContainsTheObjectPropertyBeingSet() - { - try - { - PropertyResolverConverter convertToNull = new PropertyResolverConverter(null, null) - { - private static final long serialVersionUID = 1L; - - @Override - public <T> T convert(Object object, java.lang.Class<T> clz) - { - return null; - } - }; - PropertyResolver.setValue("name", person, "", convertToNull); - fail("Should have thrown an ConversionException"); - } - catch (ConversionException e) - { - assertTrue(e.getMessage().toLowerCase().contains("name")); - } - } - - /** - * WICKET-3441 - */ - @Test - public void dateToStringConverting() - { - IConverterLocator converterLocator = new ConverterLocator(); - Locale locale = Locale.GERMAN; - PropertyResolverConverter converter = new PropertyResolverConverter(converterLocator, - locale); - - Calendar calDate = Calendar.getInstance(); - calDate.clear(); - calDate.set(2011, Calendar.APRIL, 17); - Date date = calDate.getTime(); - - Object actual = converter.convert(date, String.class); - String expected = converterLocator.getConverter(Date.class).convertToString(date, locale); - assertEquals(expected, actual); - } - - /** - * WICKET-3441 - */ - @Test - public void dateToLongConverting() - { - ConverterLocator converterLocator = new ConverterLocator(); - final IConverter<Date> dateConverter = converterLocator.get(Date.class); - IConverter<Long> customLongConverter = new AbstractConverter<Long>() - { - private static final long serialVersionUID = 1L; - - @Override - public Long convertToObject(String value, Locale locale) - { - Date date = dateConverter.convertToObject(value, locale); - return date != null ? date.getTime() : null; - } - - @Override - public String convertToString(Long value, Locale locale) - { - Date date; - if (value != null) - { - date = new Date(); - date.setTime(value); - } - else - { - date = null; - } - - return dateConverter.convertToString(date, locale); - } - - @Override - protected Class<Long> getTargetType() - { - return Long.class; - } - }; - converterLocator.set(Long.class, customLongConverter); - converterLocator.set(Long.TYPE, customLongConverter); - - PropertyResolverConverter converter = new PropertyResolverConverter(converterLocator, - Locale.ENGLISH); - - Calendar calDate = Calendar.getInstance(); - calDate.clear(); - calDate.set(2011, Calendar.APRIL, 17); - Date date = calDate.getTime(); - - Object actual = converter.convert(date, Long.class); - assertEquals(date.getTime(), actual); - } - - /** - * WICKET-5623 custom properties - */ - @Test - public void custom() { - Document document = new Document(); - document.setType("type"); - document.setProperty("string", "string"); - - Document nestedCustom = new Document(); - nestedCustom.setProperty("string", "string2"); - document.setProperty("nested", nestedCustom); - - PropertyResolver.setLocator(tester.getApplication(), new CachingPropertyLocator(new CustomGetAndSetLocator())); - - assertEquals("type", PropertyResolver.getValue("type", document)); - assertEquals("string", PropertyResolver.getValue("string", document)); - assertEquals("string2", PropertyResolver.getValue("nested.string", document)); - } - - class CustomGetAndSetLocator implements IPropertyLocator { - - private IPropertyLocator locator = new DefaultPropertyLocator(); - - @Override - public IGetAndSet get(Class<?> clz, String exp) { - // first try default properties - IGetAndSet getAndSet = locator.get(clz, exp); - if (getAndSet == null && Document.class.isAssignableFrom(clz)) { - // fall back to document properties - getAndSet = new DocumentPropertyGetAndSet(exp); - } - return getAndSet; - } - - public class DocumentPropertyGetAndSet extends AbstractGetAndSet { - - private String name; - - public DocumentPropertyGetAndSet(String name) { - this.name = name; - } - - @Override - public Object getValue(Object object) { - return ((Document) object).getProperty(name); - } - - @Override - public Object newValue(Object object) { - return new Document(); - } - - @Override - public void setValue(Object object, Object value, PropertyResolverConverter converter) { - ((Document) object).setProperty(name, value); - } - } - } -} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/wicket/blob/3a6db1bf/wicket-core/src/test/java/org/apache/wicket/util/string/interpolator/PropertyVariableInterpolatorTest.java ---------------------------------------------------------------------- diff --git a/wicket-core/src/test/java/org/apache/wicket/util/string/interpolator/PropertyVariableInterpolatorTest.java b/wicket-core/src/test/java/org/apache/wicket/util/string/interpolator/PropertyVariableInterpolatorTest.java index 8438f81..eed1c6e 100644 --- a/wicket-core/src/test/java/org/apache/wicket/util/string/interpolator/PropertyVariableInterpolatorTest.java +++ b/wicket-core/src/test/java/org/apache/wicket/util/string/interpolator/PropertyVariableInterpolatorTest.java @@ -17,7 +17,7 @@ package org.apache.wicket.util.string.interpolator; import org.apache.wicket.core.util.string.interpolator.PropertyVariableInterpolator; -import org.junit.Assert; +import org.apache.wicket.util.tester.WicketTestCase; import org.junit.Test; /** @@ -25,7 +25,7 @@ import org.junit.Test; * * @author Gerolf Seitz */ -public class PropertyVariableInterpolatorTest extends Assert +public class PropertyVariableInterpolatorTest extends WicketTestCase { /** *
