http://git-wip-us.apache.org/repos/asf/struts/blob/82cb1286/core/src/test/java/com/opensymphony/xwork2/conversion/impl/AnnotationXWorkConverterTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/com/opensymphony/xwork2/conversion/impl/AnnotationXWorkConverterTest.java b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/AnnotationXWorkConverterTest.java new file mode 100644 index 0000000..7302359 --- /dev/null +++ b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/AnnotationXWorkConverterTest.java @@ -0,0 +1,469 @@ +/* + * Copyright 2002-2006,2009 The Apache Software Foundation. + * + * 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. + */ +package com.opensymphony.xwork2.conversion.impl; + +import com.opensymphony.xwork2.*; +import com.opensymphony.xwork2.test.AnnotationUser; +import com.opensymphony.xwork2.test.ModelDrivenAnnotationAction2; +import com.opensymphony.xwork2.util.Bar; +import com.opensymphony.xwork2.util.ValueStack; +import com.opensymphony.xwork2.util.reflection.ReflectionContextState; +import ognl.OgnlException; +import ognl.OgnlRuntime; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.text.DateFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.*; + + +/** + * @author $Author$ + * @author Rainer Hermanns + * @version $Revision$ + */ +public class AnnotationXWorkConverterTest extends XWorkTestCase { + + ActionContext ac; + Map<String, Object> context; + XWorkConverter converter; + +// public void testConversionToSetKeepsOriginalSetAndReplacesContents() { +// ValueStack stack = ValueStackFactory.getFactory().createValueStack(); +// +// Map stackContext = stack.getContext(); +// stackContext.put(InstantiatingNullHandler.CREATE_NULL_OBJECTS, Boolean.TRUE); +// stackContext.put(XWorkMethodAccessor.DENY_METHOD_EXECUTION, Boolean.TRUE); +// stackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); +// +// String[] param = new String[] {"abc", "def", "ghi"}; +// List paramList = Arrays.asList(param); +// +// List originalList = new ArrayList(); +// originalList.add("jkl"); +// originalList.add("mno"); +// +// AnnotationUser user = new AnnotationUser(); +// user.setList(originalList); +// stack.push(user); +// +// stack.setValue("list", param); +// +// List userList = user.getList(); +// assertEquals(3,userList.size()); +// assertEquals(paramList,userList); +// assertSame(originalList,userList); +// } + + public void testArrayToNumberConversion() { + String[] value = new String[]{"12345"}; + assertEquals(new Integer(12345), converter.convertValue(context, null, null, null, value, Integer.class)); + assertEquals(new Long(12345), converter.convertValue(context, null, null, null, value, Long.class)); + value[0] = "123.45"; + assertEquals(new Float(123.45), converter.convertValue(context, null, null, null, value, Float.class)); + assertEquals(new Double(123.45), converter.convertValue(context, null, null, null, value, Double.class)); + value[0] = "1234567890123456789012345678901234567890"; + assertEquals(new BigInteger(value[0]), converter.convertValue(context, null, null, null, value, BigInteger.class)); + value[0] = "1234567890123456789.012345678901234567890"; + assertEquals(new BigDecimal(value[0]), converter.convertValue(context, null, null, null, value, BigDecimal.class)); + } + + public void testDateConversion() throws ParseException { + java.sql.Date sqlDate = new java.sql.Date(System.currentTimeMillis()); + assertEquals(sqlDate, converter.convertValue(context, null, null, null, sqlDate, Date.class)); + + SimpleDateFormat format = new SimpleDateFormat("mm/dd/yyyy hh:mm:ss"); + Date date = format.parse("01/10/2001 00:00:00"); + String dateStr = (String) converter.convertValue(context, null, null, null, date, String.class); + Date date2 = (Date) converter.convertValue(context, null, null, null, dateStr, Date.class); + assertEquals(date, date2); + } + + public void testFieldErrorMessageAddedForComplexProperty() { + SimpleAnnotationAction action = new SimpleAnnotationAction(); + action.setBean(new AnnotatedTestBean()); + + ValueStack stack = ActionContext.getContext().getValueStack(); + stack.push(action); + + Map<String, Object> ognlStackContext = stack.getContext(); + ognlStackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); + ognlStackContext.put(XWorkConverter.CONVERSION_PROPERTY_FULLNAME, "bean.birth"); + + String[] value = new String[]{"invalid date"}; + assertEquals("Conversion should have failed.", OgnlRuntime.NoConversionPossible, converter.convertValue(ognlStackContext, action.getBean(), null, "birth", value, Date.class)); + stack.pop(); + + Map conversionErrors = (Map) stack.getContext().get(ActionContext.CONVERSION_ERRORS); + assertNotNull(conversionErrors); + assertTrue(conversionErrors.size() == 1); + assertEquals(value, conversionErrors.get("bean.birth")); + } + + public void testFieldErrorMessageAddedWhenConversionFails() { + SimpleAnnotationAction action = new SimpleAnnotationAction(); + action.setDate(null); + + ValueStack stack = ActionContext.getContext().getValueStack(); + stack.push(action); + + Map<String, Object> ognlStackContext = stack.getContext(); + ognlStackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); + + String[] value = new String[]{"invalid date"}; + assertEquals("Conversion should have failed.", OgnlRuntime.NoConversionPossible, converter.convertValue(ognlStackContext, action, null, "date", value, Date.class)); + stack.pop(); + + Map conversionErrors = (Map) ognlStackContext.get(ActionContext.CONVERSION_ERRORS); + assertNotNull(conversionErrors); + assertEquals(1, conversionErrors.size()); + assertNotNull(conversionErrors.get("date")); + assertEquals(value, conversionErrors.get("date")); + } + + public void testFieldErrorMessageAddedWhenConversionFailsOnModelDriven() { + ModelDrivenAnnotationAction action = new ModelDrivenAnnotationAction(); + ValueStack stack = ActionContext.getContext().getValueStack(); + stack.push(action); + stack.push(action.getModel()); + + Map<String, Object> ognlStackContext = stack.getContext(); + ognlStackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); + + String[] value = new String[]{"invalid date"}; + assertEquals("Conversion should have failed.", OgnlRuntime.NoConversionPossible, converter.convertValue(ognlStackContext, action, null, "birth", value, Date.class)); + stack.pop(); + stack.pop(); + + Map conversionErrors = (Map) ognlStackContext.get(ActionContext.CONVERSION_ERRORS); + assertNotNull(conversionErrors); + assertEquals(1, conversionErrors.size()); + assertNotNull(conversionErrors.get("birth")); + assertEquals(value, conversionErrors.get("birth")); + } + + public void testFindConversionErrorMessage() { + ModelDrivenAnnotationAction action = new ModelDrivenAnnotationAction(); + ValueStack stack = ActionContext.getContext().getValueStack(); + stack.push(action); + stack.push(action.getModel()); + + String message = XWorkConverter.getConversionErrorMessage("birth", stack); + assertNotNull(message); + assertEquals("Invalid date for birth.", message); + + message = XWorkConverter.getConversionErrorMessage("foo", stack); + assertNotNull(message); + assertEquals("Invalid field value for field \"foo\".", message); + } + + public void testFindConversionMappingForInterface() { + ModelDrivenAnnotationAction2 action = new ModelDrivenAnnotationAction2(); + ValueStack stack = ActionContext.getContext().getValueStack(); + stack.push(action); + stack.push(action.getModel()); + + Map<String, Object> ognlStackContext = stack.getContext(); + ognlStackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); + + String value = "asdf:123"; + Object o = converter.convertValue(ognlStackContext, action.getModel(), null, "barObj", value, Bar.class); + assertNotNull(o); + assertTrue("class is: " + o.getClass(), o instanceof Bar); + + Bar b = (Bar) o; + assertEquals(value, b.getTitle() + ":" + b.getSomethingElse()); + } + + public void testLocalizedDateConversion() throws Exception { + Date date = new Date(System.currentTimeMillis()); + Locale locale = Locale.GERMANY; + DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT, locale); + String dateString = df.format(date); + context.put(ActionContext.LOCALE, locale); + assertEquals(dateString, converter.convertValue(context, null, null, null, date, String.class)); + } + + public void testStringArrayToCollection() { + List<String> list = new ArrayList<>(); + list.add("foo"); + list.add("bar"); + list.add("baz"); + assertEquals(list, converter.convertValue(context, null, null, null, new String[]{ + "foo", "bar", "baz" + }, Collection.class)); + } + + public void testStringArrayToList() { + List<String> list = new ArrayList<String>(); + list.add("foo"); + list.add("bar"); + list.add("baz"); + assertEquals(list, converter.convertValue(context, null, null, null, new String[]{ + "foo", "bar", "baz" + }, List.class)); + } + + public void testStringArrayToPrimitiveWrappers() { + Long[] longs = (Long[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, Long[].class); + assertNotNull(longs); + assertTrue(Arrays.equals(new Long[]{123L, 456L}, longs)); + + Integer[] ints = (Integer[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, Integer[].class); + assertNotNull(ints); + assertTrue(Arrays.equals(new Integer[]{123, 456}, ints)); + + Double[] doubles = (Double[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, Double[].class); + assertNotNull(doubles); + assertTrue(Arrays.equals(new Double[]{123D, 456D}, doubles)); + + Float[] floats = (Float[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, Float[].class); + assertNotNull(floats); + assertTrue(Arrays.equals(new Float[]{123F, 456F}, floats)); + + Boolean[] booleans = (Boolean[]) converter.convertValue(context, null, null, null, new String[]{ + "true", "false" + }, Boolean[].class); + assertNotNull(booleans); + assertTrue(Arrays.equals(new Boolean[]{Boolean.TRUE, Boolean.FALSE}, booleans)); + } + + public void testStringArrayToPrimitives() throws OgnlException { + long[] longs = (long[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, long[].class); + assertNotNull(longs); + assertTrue(Arrays.equals(new long[]{123, 456}, longs)); + + int[] ints = (int[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, int[].class); + assertNotNull(ints); + assertTrue(Arrays.equals(new int[]{123, 456}, ints)); + + double[] doubles = (double[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, double[].class); + assertNotNull(doubles); + assertTrue(Arrays.equals(new double[]{123, 456}, doubles)); + + float[] floats = (float[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, float[].class); + assertNotNull(floats); + assertTrue(Arrays.equals(new float[]{123, 456}, floats)); + + boolean[] booleans = (boolean[]) converter.convertValue(context, null, null, null, new String[]{ + "true", "false" + }, boolean[].class); + assertNotNull(booleans); + assertTrue(Arrays.equals(new boolean[]{true, false}, booleans)); + } + + public void testStringArrayToSet() { + Set<String> list = new HashSet<>(); + list.add("foo"); + list.add("bar"); + list.add("baz"); + assertEquals(list, converter.convertValue(context, null, null, null, new String[]{ + "foo", "bar", "bar", "baz" + }, Set.class)); + } + + // TODO: Fixme... This test does not work with GenericsObjectDeterminer! + public void testStringToCollectionConversion() { + ValueStack stack = ActionContext.getContext().getValueStack(); + Map<String, Object> stackContext = stack.getContext(); + stackContext.put(ReflectionContextState.CREATE_NULL_OBJECTS, Boolean.TRUE); + stackContext.put(ReflectionContextState.DENY_METHOD_EXECUTION, Boolean.TRUE); + stackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); + + AnnotationUser user = new AnnotationUser(); + stack.push(user); + + stack.setValue("list", "asdf"); + assertNotNull(user.getList()); + assertEquals(1, user.getList().size()); + assertEquals(String.class, user.getList().get(0).getClass()); + assertEquals("asdf", user.getList().get(0)); + } + + public void testStringToCustomTypeUsingCustomConverter() { + // the converter needs to be registered as the Bar.class converter + // it won't be detected from the Foo-conversion.properties + // because the Foo-conversion.properties file is only used when converting a property of Foo + converter.registerConverter(Bar.class.getName(), new FooBarConverter()); + + Bar bar = (Bar) converter.convertValue(null, null, null, null, "blah:123", Bar.class); + assertNotNull("conversion failed", bar); + assertEquals(123, bar.getSomethingElse()); + assertEquals("blah", bar.getTitle()); + } + + public void testStringToPrimitiveWrappers() { + assertEquals(new Long(123), converter.convertValue(context, null, null, null, "123", Long.class)); + assertEquals(new Integer(123), converter.convertValue(context, null, null, null, "123", Integer.class)); + assertEquals(new Double(123.5), converter.convertValue(context, null, null, null, "123.5", Double.class)); + assertEquals(new Float(123.5), converter.convertValue(context, null, null, null, "123.5", float.class)); + assertEquals(false, converter.convertValue(context, null, null, null, "false", Boolean.class)); + assertEquals(true, converter.convertValue(context, null, null, null, "true", Boolean.class)); + } + + public void testStringToPrimitives() { + assertEquals(new Long(123), converter.convertValue(context, null, null, null, "123", long.class)); + assertEquals(new Integer(123), converter.convertValue(context, null, null, null, "123", int.class)); + assertEquals(new Double(123.5), converter.convertValue(context, null, null, null, "123.5", double.class)); + assertEquals(new Float(123.5), converter.convertValue(context, null, null, null, "123.5", float.class)); + assertEquals(false, converter.convertValue(context, null, null, null, "false", boolean.class)); + assertEquals(true, converter.convertValue(context, null, null, null, "true", boolean.class)); + assertEquals(new BigDecimal(123.5), converter.convertValue(context, null, null, null, "123.5", BigDecimal.class)); + assertEquals(new BigInteger("123"), converter.convertValue(context, null, null, null, "123", BigInteger.class)); + } + + public void testValueStackWithTypeParameter() { + ValueStack stack = ActionContext.getContext().getValueStack(); + stack.push(new Foo1()); + Bar1 bar = (Bar1) stack.findValue("bar", Bar1.class); + assertNotNull(bar); + } + + public void testGenericProperties() { + GenericsBean gb = new GenericsBean(); + ValueStack stack = ac.getValueStack(); + stack.push(gb); + + String[] value = new String[] {"123.12", "123.45"}; + stack.setValue("doubles", value); + assertEquals(2, gb.getDoubles().size()); + assertEquals(Double.class, gb.getDoubles().get(0).getClass()); + assertEquals(new Double(123.12), gb.getDoubles().get(0)); + assertEquals(new Double(123.45), gb.getDoubles().get(1)); + } + + public void testGenericPropertiesFromField() { + GenericsBean gb = new GenericsBean(); + ValueStack stack = ac.getValueStack(); + stack.push(gb); + + stack.setValue("genericMap[123.12]", "66"); + stack.setValue("genericMap[456.12]", "42"); + + assertEquals(2, gb.getGenericMap().size()); + assertEquals("66", stack.findValue("genericMap.get(123.12).toString()")); + assertEquals("42", stack.findValue("genericMap.get(456.12).toString()")); + assertEquals(66, stack.findValue("genericMap.get(123.12)")); + assertEquals(42, stack.findValue("genericMap.get(456.12)")); + assertEquals(true, stack.findValue("genericMap.containsValue(66)")); + assertEquals(true, stack.findValue("genericMap.containsValue(42)")); + assertEquals(true, stack.findValue("genericMap.containsKey(123.12)")); + assertEquals(true, stack.findValue("genericMap.containsKey(456.12)")); + } + + public void testGenericPropertiesFromSetter() { + GenericsBean gb = new GenericsBean(); + ValueStack stack = ac.getValueStack(); + stack.push(gb); + + stack.setValue("genericMap[123.12]", "66"); + stack.setValue("genericMap[456.12]", "42"); + + assertEquals(2, gb.getGenericMap().size()); + assertEquals("66", stack.findValue("genericMap.get(123.12).toString()")); + assertEquals("42", stack.findValue("genericMap.get(456.12).toString()")); + assertEquals(66, stack.findValue("genericMap.get(123.12)")); + assertEquals(42, stack.findValue("genericMap.get(456.12)")); + assertEquals(true, stack.findValue("genericMap.containsValue(66)")); + assertEquals(true, stack.findValue("genericMap.containsValue(42)")); + assertEquals(true, stack.findValue("genericMap.containsKey(123.12)")); + assertEquals(true, stack.findValue("genericMap.containsKey(456.12)")); + } + + public void testGenericPropertiesFromGetter() { + GenericsBean gb = new GenericsBean(); + ValueStack stack = ac.getValueStack(); + stack.push(gb); + + assertEquals(1, gb.getGetterList().size()); + assertEquals("42.42", stack.findValue("getterList.get(0).toString()")); + assertEquals(new Double(42.42), stack.findValue("getterList.get(0)")); + assertEquals(new Double(42.42), gb.getGetterList().get(0)); + + } + + + // FIXME: Implement nested Generics such as: List of Generics List, Map of Generic keys/values, etc... + public void no_testGenericPropertiesWithNestedGenerics() { + GenericsBean gb = new GenericsBean(); + ValueStack stack = ac.getValueStack(); + stack.push(gb); + + stack.setValue("extendedMap[123.12]", new String[] {"1", "2", "3", "4"}); + stack.setValue("extendedMap[456.12]", new String[] {"5", "6", "7", "8", "9"}); + + System.out.println("gb.getExtendedMap(): " + gb.getExtendedMap()); + + assertEquals(2, gb.getExtendedMap().size()); + System.out.println(stack.findValue("extendedMap")); + assertEquals(4, stack.findValue("extendedMap.get(123.12).size")); + assertEquals(5, stack.findValue("extendedMap.get(456.12).size")); + + assertEquals("1", stack.findValue("extendedMap.get(123.12).get(0)")); + assertEquals("5", stack.findValue("extendedMap.get(456.12).get(0)")); + assertEquals(Integer.class, stack.findValue("extendedMap.get(123.12).get(0).class")); + assertEquals(Integer.class, stack.findValue("extendedMap.get(456.12).get(0).class")); + + assertEquals(List.class, stack.findValue("extendedMap.get(123.12).class")); + assertEquals(List.class, stack.findValue("extendedMap.get(456.12).class")); + + } + + public static class Foo1 { + public Bar1 getBar() { + return new Bar1Impl(); + } + } + + public interface Bar1 { + } + + public static class Bar1Impl implements Bar1 { + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + converter = container.getInstance(XWorkConverter.class); + + ac = ActionContext.getContext(); + ac.setLocale(Locale.US); + context = ac.getContextMap(); + } + + @Override + protected void tearDown() throws Exception { + ActionContext.setContext(null); + } +}
http://git-wip-us.apache.org/repos/asf/struts/blob/82cb1286/core/src/test/java/com/opensymphony/xwork2/conversion/impl/FooBarConverter.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/com/opensymphony/xwork2/conversion/impl/FooBarConverter.java b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/FooBarConverter.java new file mode 100644 index 0000000..6d7ec50 --- /dev/null +++ b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/FooBarConverter.java @@ -0,0 +1,72 @@ +/* + * Copyright 2002-2003,2009 The Apache Software Foundation. + * + * 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. + */ +package com.opensymphony.xwork2.conversion.impl; + +import com.opensymphony.xwork2.util.AnnotatedCat; +import com.opensymphony.xwork2.util.Bar; +import com.opensymphony.xwork2.util.Cat; + +import java.lang.reflect.Member; +import java.util.Map; + + +/** + * @author <a href="mailto:[email protected]";>Pat Lightbody</a> + * @author $Author$ + * @version $Revision$ + */ +public class FooBarConverter extends DefaultTypeConverter { + + @Override + public Object convertValue(Map<String, Object> context, Object value, Class toType) { + if (toType == String.class) { + Bar bar = (Bar) value; + + return bar.getTitle() + ":" + bar.getSomethingElse(); + } else if (toType == Bar.class) { + String valueStr = (String) value; + int loc = valueStr.indexOf(":"); + String title = valueStr.substring(0, loc); + String rest = valueStr.substring(loc + 1); + + Bar bar = new Bar(); + bar.setTitle(title); + bar.setSomethingElse(Integer.parseInt(rest)); + + return bar; + } else if (toType == Cat.class) { + Cat cat = new Cat(); + cat.setName((String) value); + + return cat; + } else if (toType == AnnotatedCat.class) { + AnnotatedCat cat = new AnnotatedCat(); + cat.setName((String) value); + + return cat; + } else { + System.out.println("Don't know how to convert between " + value.getClass().getName() + + " and " + toType.getName()); + } + + return null; + } + + @Override + public Object convertValue(Map<String, Object> context, Object source, Member member, String property, Object value, Class toClass) { + return convertValue(context, value, toClass); + } +} http://git-wip-us.apache.org/repos/asf/struts/blob/82cb1286/core/src/test/java/com/opensymphony/xwork2/conversion/impl/FooNumberConverter.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/com/opensymphony/xwork2/conversion/impl/FooNumberConverter.java b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/FooNumberConverter.java new file mode 100644 index 0000000..86ba9e9 --- /dev/null +++ b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/FooNumberConverter.java @@ -0,0 +1,18 @@ +package com.opensymphony.xwork2.conversion.impl; + +import java.util.Map; + +public class FooNumberConverter extends DefaultTypeConverter { + @Override + public Object convertValue(Map<String, Object> map, Object object, Class aClass) { + String s = (String) object; + + int length = s.length(); + StringBuilder r = new StringBuilder(); + for (int i = length; i > 0; i--) { + r.append(s.charAt(i - 1)); + } + + return super.convertValue(map, r.toString(), aClass); + } +} http://git-wip-us.apache.org/repos/asf/struts/blob/82cb1286/core/src/test/java/com/opensymphony/xwork2/conversion/impl/InstantiatingNullHandlerTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/com/opensymphony/xwork2/conversion/impl/InstantiatingNullHandlerTest.java b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/InstantiatingNullHandlerTest.java new file mode 100644 index 0000000..ac92719 --- /dev/null +++ b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/InstantiatingNullHandlerTest.java @@ -0,0 +1,54 @@ +/* + * Copyright 2002-2003,2009 The Apache Software Foundation. + * + * 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. + */ +package com.opensymphony.xwork2.conversion.impl; + +import junit.framework.TestCase; + + +/** + * DOCUMENT ME! + * + * @author $author$ + * @version $Revision$ + */ +public class InstantiatingNullHandlerTest extends TestCase { + + public void testBlank() { + + } + /*public void testInheritance() { + Tiger t = new Tiger(); + CompoundRoot root = new CompoundRoot(); + root.add(t); + + Map context = new OgnlContext(); + context.put(InstantiatingNullHandler.CREATE_NULL_OBJECTS, Boolean.TRUE); + + InstantiatingNullHandler nh = new InstantiatingNullHandler(); + + Object dogList = nh.nullPropertyValue(context, root, "dogs"); + Class clazz = nh.getCollectionType(Tiger.class, "dogs"); + assertEquals(Dog.class, clazz); + assertNotNull(dogList); + assertTrue(dogList instanceof List); + + Object kittenList = nh.nullPropertyValue(context, root, "kittens"); + clazz = nh.getCollectionType(Tiger.class, "kittens"); + assertEquals(Cat.class, clazz); + assertNotNull(kittenList); + assertTrue(kittenList instanceof List); + }*/ +} http://git-wip-us.apache.org/repos/asf/struts/blob/82cb1286/core/src/test/java/com/opensymphony/xwork2/conversion/impl/NumberConverterTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/com/opensymphony/xwork2/conversion/impl/NumberConverterTest.java b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/NumberConverterTest.java new file mode 100644 index 0000000..76be6e1 --- /dev/null +++ b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/NumberConverterTest.java @@ -0,0 +1,42 @@ +package com.opensymphony.xwork2.conversion.impl; + +import com.opensymphony.xwork2.ActionContext; +import com.opensymphony.xwork2.SimpleFooAction; +import com.opensymphony.xwork2.XWorkTestCase; + +import java.util.HashMap; +import java.util.Locale; +import java.util.Map; + +public class NumberConverterTest extends XWorkTestCase { + + public void testStringToNumberConversionPL() throws Exception { + // given + NumberConverter converter = new NumberConverter(); + Map<String, Object> context = new HashMap<>(); + context.put(ActionContext.LOCALE, new Locale("pl", "PL")); + + SimpleFooAction foo = new SimpleFooAction(); + + // when + Object value = converter.convertValue(context, foo, null, "id", "1234", Integer.class); + + // then + assertEquals(1234, value); + } + + public void testStringToNumberConversionUS() throws Exception { + // given + NumberConverter converter = new NumberConverter(); + Map<String, Object> context = new HashMap<>(); + context.put(ActionContext.LOCALE, new Locale("en", "US")); + + SimpleFooAction foo = new SimpleFooAction(); + + // when + Object value = converter.convertValue(context, foo, null, "id", ",1234", Integer.class); + + // then + assertEquals(1234, value); + } +} http://git-wip-us.apache.org/repos/asf/struts/blob/82cb1286/core/src/test/java/com/opensymphony/xwork2/conversion/impl/ParentClass.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/com/opensymphony/xwork2/conversion/impl/ParentClass.java b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/ParentClass.java new file mode 100644 index 0000000..a8fc59e --- /dev/null +++ b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/ParentClass.java @@ -0,0 +1,27 @@ +package com.opensymphony.xwork2.conversion.impl; + +/** + * <code>ParentClass</code> + * + * @author <a href="mailto:[email protected]";>Rainer Hermanns</a> + * @version $Id$ + */ +public class ParentClass { + + public enum NestedEnum { + TEST, + TEST2, + TEST3 + } + + + private NestedEnum value; + + public void setValue(NestedEnum value) { + this.value = value; + } + + public NestedEnum getValue() { + return value; + } +} http://git-wip-us.apache.org/repos/asf/struts/blob/82cb1286/core/src/test/java/com/opensymphony/xwork2/conversion/impl/XWorkBasicConverterTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/com/opensymphony/xwork2/conversion/impl/XWorkBasicConverterTest.java b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/XWorkBasicConverterTest.java new file mode 100644 index 0000000..7bd4906 --- /dev/null +++ b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/XWorkBasicConverterTest.java @@ -0,0 +1,260 @@ +/* + * Copyright 2002-2007,2009 The Apache Software Foundation. + * + * 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. + */ +package com.opensymphony.xwork2.conversion.impl; + +import com.opensymphony.xwork2.ActionContext; +import com.opensymphony.xwork2.XWorkException; +import com.opensymphony.xwork2.XWorkTestCase; +import com.opensymphony.xwork2.test.annotations.Person; + +import java.text.DateFormat; +import java.util.*; + +/** + * Test case for XWorkBasicConverter + * + * @author tm_jee + * @version $Date$ $Id$ + */ +public class XWorkBasicConverterTest extends XWorkTestCase { + + private XWorkBasicConverter basicConverter; + + // TODO: test for every possible conversion + // take into account of empty string + // primitive -> conversion error when empty string is passed + // object -> return null when empty string is passed + + public void testDateConversionWithEmptyValue() { + Object convertedObject = basicConverter.convertValue(new HashMap<String, Object>(), null, null, null, "", Date.class); + // we must not get XWorkException as that will caused a conversion error + assertNull(convertedObject); + } + + public void testDateConversionWithInvalidValue() throws Exception { + try { + Object convertedObject = basicConverter.convertValue(new HashMap<String, Object>(), null, null, null, "asdsd", Date.class); + fail("XWorkException expected - conversion error occurred"); + } catch (XWorkException e) { + // we MUST get this exception as this is a conversion error + } + } + + public void testDateWithLocalePoland() throws Exception { + + Map<String, Object> map = new HashMap<>(); + Locale locale = new Locale("pl", "PL"); + map.put(ActionContext.LOCALE, locale); + + String reference = "2009-01-09"; + Object convertedObject = basicConverter.convertValue(map, null, null, null, reference, Date.class); + + assertNotNull(convertedObject); + + compareDates(locale, convertedObject); + } + + public void testDateWithLocaleFrance() throws Exception { + + Map<String, Object> map = new HashMap<>(); + Locale locale = new Locale("fr", "FR"); + map.put(ActionContext.LOCALE, locale); + + String reference = "09/01/2009"; + Object convertedObject = basicConverter.convertValue(map, null, null, null, reference, Date.class); + + assertNotNull(convertedObject); + + compareDates(locale, convertedObject); + } + + public void testDateWithLocaleUK() throws Exception { + + Map<String, Object> map = new HashMap<>(); + Locale locale = new Locale("en", "US"); + map.put(ActionContext.LOCALE, locale); + + String reference = "01/09/2009"; + Object convertedObject = basicConverter.convertValue(map, null, null, null, reference, Date.class); + + assertNotNull(convertedObject); + + compareDates(locale, convertedObject); + } + + private void compareDates(Locale locale, Object convertedObject) { + Calendar cal = Calendar.getInstance(locale); + cal.set(Calendar.YEAR, 2009); + cal.set(Calendar.MONTH, Calendar.JANUARY); + cal.set(Calendar.DATE, 9); + + Calendar cal1 = Calendar.getInstance(locale); + cal1.setTime((Date) convertedObject); + + assertEquals(cal.get(Calendar.YEAR), cal1.get(Calendar.YEAR)); + assertEquals(cal.get(Calendar.MONTH), cal1.get(Calendar.MONTH)); + assertEquals(cal.get(Calendar.DATE), cal1.get(Calendar.DATE)); + + DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT, locale); + assertEquals(df.format(cal.getTime()), df.format(convertedObject)); + } + + public void testEmptyArrayConversion() throws Exception { + Object convertedObject = basicConverter.convertValue(new HashMap<String, Object>(), null, null, null, new Object[]{}, Object[].class); + // we must not get XWorkException as that will caused a conversion error + assertEquals(Object[].class, convertedObject.getClass()); + Object[] obj = (Object[]) convertedObject; + assertEquals(0, obj.length); + } + + public void testNullArrayConversion() throws Exception { + Object convertedObject = basicConverter.convertValue(new HashMap<String, Object>(), null, null, null, null, Object[].class); + // we must not get XWorkException as that will caused a conversion error + assertNull(convertedObject); + } + + /* the code below has been disabled as it causes sideffects in Strtus2 (XW-512) + public void testXW490ConvertStringToDouble() throws Exception { + Locale locale = new Locale("DA"); // let's use a not common locale such as Denmark + + Map ctx = new HashMap(); + ctx.put(ActionContext.LOCALE, locale); + + XWorkBasicConverter conv = new XWorkBasicConverter(); + // decimal seperator is , in Denmark so we should write 123,99 as input + Double value = (Double) conv.convertValue(ctx, null, null, null, "123,99", Double.class); + assertNotNull(value); + + // output is as expected a real double value converted using Denmark as locale + assertEquals(123.99d, value.doubleValue(), 0.001d); + } + + public void testXW49ConvertDoubleToString() throws Exception { + Locale locale = new Locale("DA"); // let's use a not common locale such as Denmark + + Map ctx = new HashMap(); + ctx.put(ActionContext.LOCALE, locale); + + XWorkBasicConverter conv = new XWorkBasicConverter(); + // decimal seperator is , in Denmark so we should write 123,99 as input + String value = (String) conv.convertValue(ctx, null, null, null, new Double("123.99"), String.class); + assertNotNull(value); + + // output should be formatted according to Danish locale using , as decimal seperator + assertEquals("123,99", value); + } + */ + + public void testDoubleValues() { + NumberConverter numberConverter = new NumberConverter(); + + assertTrue(numberConverter.isInRange(-1.2, "-1.2", Double.class)); + assertTrue(numberConverter.isInRange(1.5, "1.5", Double.class)); + + Object value = basicConverter.convertValue("-1.3", double.class); + assertNotNull(value); + assertEquals(-1.3, value); + + value = basicConverter.convertValue("1.8", double.class); + assertNotNull(value); + assertEquals(1.8, value); + + value = basicConverter.convertValue("-1.9", double.class); + assertNotNull(value); + assertEquals(-1.9, value); + + value = basicConverter.convertValue("1.7", Double.class); + assertNotNull(value); + assertEquals(1.7, value); + + value = basicConverter.convertValue("0.0", Double.class); + assertNotNull(value); + assertEquals(0.0, value); + + value = basicConverter.convertValue("0.0", double.class); + assertNotNull(value); + assertEquals(0.0, value); + } + + public void testFloatValues() { + NumberConverter numberConverter = new NumberConverter(); + + assertTrue(numberConverter.isInRange(-1.65, "-1.65", Float.class)); + assertTrue(numberConverter.isInRange(1.9876, "1.9876", float.class)); + + Float value = (Float) basicConverter.convertValue("-1.444401", Float.class); + assertNotNull(value); + assertEquals(Float.valueOf("-1.444401"), value); + + value = (Float) basicConverter.convertValue("1.46464989", Float.class); + assertNotNull(value); + assertEquals(Float.valueOf(1.46464989f), value); + } + + public void testNegativeFloatValue() throws Exception { + Object convertedObject = basicConverter.convertValue("-94.1231233", Float.class); + assertTrue(convertedObject instanceof Float); + assertEquals(-94.1231233f, ((Float) convertedObject).floatValue(), 0.0001); + } + + public void testPositiveFloatValue() throws Exception { + Object convertedObject = basicConverter.convertValue("94.1231233", Float.class); + assertTrue(convertedObject instanceof Float); + assertEquals(94.1231233f, ((Float) convertedObject).floatValue(), 0.0001); + } + + + public void testNegativeDoubleValue() throws Exception { + Object convertedObject = basicConverter.convertValue("-94.1231233", Double.class); + assertTrue(convertedObject instanceof Double); + assertEquals(-94.1231233d, ((Double) convertedObject).doubleValue(), 0.0001); + } + + public void testPositiveDoubleValue() throws Exception { + Object convertedObject = basicConverter.convertValue("94.1231233", Double.class); + assertTrue(convertedObject instanceof Double); + assertEquals(94.1231233d, ((Double) convertedObject).doubleValue(), 0.0001); + } + + public void testNestedEnumValue() throws Exception { + Object convertedObject = basicConverter.convertValue(ParentClass.NestedEnum.TEST.name(), ParentClass.NestedEnum.class); + assertTrue(convertedObject instanceof ParentClass.NestedEnum); + assertEquals(ParentClass.NestedEnum.TEST, convertedObject); + } + + + public void testConvert() { + Map<String, Object> context = new HashMap<>(); + Person o = new Person(); + String s = "names"; + Object value = new Person[0]; + Class toType = String.class; + basicConverter.convertValue(context, value, null, s, value, toType); + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + basicConverter = container.getInstance(XWorkBasicConverter.class); + } + + @Override + protected void tearDown() throws Exception { + ActionContext.setContext(null); + } + + +} http://git-wip-us.apache.org/repos/asf/struts/blob/82cb1286/core/src/test/java/com/opensymphony/xwork2/conversion/impl/XWorkConverterTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/com/opensymphony/xwork2/conversion/impl/XWorkConverterTest.java b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/XWorkConverterTest.java new file mode 100644 index 0000000..3d7fc49 --- /dev/null +++ b/core/src/test/java/com/opensymphony/xwork2/conversion/impl/XWorkConverterTest.java @@ -0,0 +1,715 @@ +/* + * Copyright 2002-2003,2009 The Apache Software Foundation. + * + * 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. + */ +package com.opensymphony.xwork2.conversion.impl; + +import com.opensymphony.xwork2.*; +import com.opensymphony.xwork2.ognl.OgnlValueStack; +import com.opensymphony.xwork2.test.ModelDrivenAction2; +import com.opensymphony.xwork2.test.User; +import com.opensymphony.xwork2.util.Bar; +import com.opensymphony.xwork2.util.Cat; +import com.opensymphony.xwork2.util.Foo; +import com.opensymphony.xwork2.util.FurColor; +import com.opensymphony.xwork2.util.reflection.ReflectionContextState; +import ognl.OgnlException; +import ognl.OgnlRuntime; + +import java.io.IOException; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.net.URL; +import java.sql.Timestamp; +import java.text.DateFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.*; + + +/** + * @author $Author$ + * @version $Revision$ + */ +public class XWorkConverterTest extends XWorkTestCase { + + Map<String, Object> context; + XWorkConverter converter; + OgnlValueStack stack; + +// public void testConversionToSetKeepsOriginalSetAndReplacesContents() { +// ValueStack stack = ValueStackFactory.getFactory().createValueStack(); +// +// Map stackContext = stack.getContext(); +// stackContext.put(InstantiatingNullHandler.CREATE_NULL_OBJECTS, Boolean.TRUE); +// stackContext.put(XWorkMethodAccessor.DENY_METHOD_EXECUTION, Boolean.TRUE); +// stackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); +// +// String[] param = new String[] {"abc", "def", "ghi"}; +// List paramList = Arrays.asList(param); +// +// List originalList = new ArrayList(); +// originalList.add("jkl"); +// originalList.add("mno"); +// +// User user = new User(); +// user.setList(originalList); +// stack.push(user); +// +// stack.setValue("list", param); +// +// List userList = user.getList(); +// assertEquals(3,userList.size()); +// assertEquals(paramList,userList); +// assertSame(originalList,userList); +// } + + public void testArrayToNumberConversion() { + String[] value = new String[]{"12345"}; + assertEquals(new Integer(12345), converter.convertValue(context, null, null, null, value, Integer.class)); + assertEquals(new Long(12345), converter.convertValue(context, null, null, null, value, Long.class)); + value[0] = "123.45"; + assertEquals(new Float(123.45), converter.convertValue(context, null, null, null, value, Float.class)); + assertEquals(new Double(123.45), converter.convertValue(context, null, null, null, value, Double.class)); + value[0] = "1234567890123456789012345678901234567890"; + assertEquals(new BigInteger(value[0]), converter.convertValue(context, null, null, null, value, BigInteger.class)); + value[0] = "1234567890123456789.012345678901234567890"; + assertEquals(new BigDecimal(value[0]), converter.convertValue(context, null, null, null, value, BigDecimal.class)); + } + + public void testDateConversion() throws ParseException { + java.sql.Date sqlDate = new java.sql.Date(System.currentTimeMillis()); + assertEquals(sqlDate, converter.convertValue(context, null, null, null, sqlDate, Date.class)); + + SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy hh:mm:ss"); + Date date = format.parse("01/10/2001 00:00:00"); + + SimpleDateFormat formatt = new SimpleDateFormat("hh:mm:ss"); + java.sql.Time datet = new java.sql.Time(formatt.parse("10:11:12").getTime()); + + String dateStr = (String) converter.convertValue(context, null, null, null, date, String.class); + String datetStr = (String) converter.convertValue(context, null, null, null, datet, String.class); + + Date date2 = (Date) converter.convertValue(context, null, null, null, dateStr, Date.class); + assertEquals(date, date2); + java.sql.Date date3 = (java.sql.Date) converter.convertValue(context, null, null, null, dateStr, java.sql.Date.class); + assertEquals(date, date3); + java.sql.Timestamp ts = (java.sql.Timestamp) converter.convertValue(context, null, null, null, dateStr, java.sql.Timestamp.class); + assertEquals(date, ts); + java.sql.Time time1 = (java.sql.Time) converter.convertValue(context, null, null, null, datetStr, java.sql.Time.class); + assertEquals(datet, time1); + } + + public void testFieldErrorMessageAddedForComplexProperty() { + SimpleAction action = new SimpleAction(); + action.setBean(new TestBean()); + + stack.push(action); + + Map<String, Object> ognlStackContext = stack.getContext(); + ognlStackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); + ognlStackContext.put(XWorkConverter.CONVERSION_PROPERTY_FULLNAME, "bean.birth"); + + String[] value = new String[]{"invalid date"}; + assertEquals("Conversion should have failed.", OgnlRuntime.NoConversionPossible, converter.convertValue(ognlStackContext, action.getBean(), null, "birth", value, Date.class)); + stack.pop(); + + Map conversionErrors = (Map) stack.getContext().get(ActionContext.CONVERSION_ERRORS); + assertNotNull(conversionErrors); + assertTrue(conversionErrors.size() == 1); + assertEquals(value, conversionErrors.get("bean.birth")); + } + + public void testFieldErrorMessageAddedWhenConversionFails() { + SimpleAction action = new SimpleAction(); + action.setDate(null); + + stack.push(action); + + Map<String, Object> ognlStackContext = stack.getContext(); + ognlStackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); + + String[] value = new String[]{"invalid date"}; + assertEquals("Conversion should have failed.", OgnlRuntime.NoConversionPossible, converter.convertValue(ognlStackContext, action, null, "date", value, Date.class)); + stack.pop(); + + Map conversionErrors = (Map) ognlStackContext.get(ActionContext.CONVERSION_ERRORS); + assertNotNull(conversionErrors); + assertEquals(1, conversionErrors.size()); + assertNotNull(conversionErrors.get("date")); + assertEquals(value, conversionErrors.get("date")); + } + + public void testFieldErrorMessageAddedWhenConversionFailsOnModelDriven() { + ModelDrivenAction action = new ModelDrivenAction(); + stack.push(action); + stack.push(action.getModel()); + + Map<String, Object> ognlStackContext = stack.getContext(); + ognlStackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); + + String[] value = new String[]{"invalid date"}; + assertEquals("Conversion should have failed.", OgnlRuntime.NoConversionPossible, converter.convertValue(ognlStackContext, action, null, "birth", value, Date.class)); + stack.pop(); + stack.pop(); + + Map conversionErrors = (Map) ognlStackContext.get(ActionContext.CONVERSION_ERRORS); + assertNotNull(conversionErrors); + assertEquals(1, conversionErrors.size()); + assertNotNull(conversionErrors.get("birth")); + assertEquals(value, conversionErrors.get("birth")); + } + + public void testDateStrictConversion() throws Exception { + // see XW-341 + String dateStr = "13/01/2005"; // us date format is used in context + Object res = converter.convertValue(context, null, null, null, dateStr, Date.class); + assertEquals(res, OgnlRuntime.NoConversionPossible); + + dateStr = "02/30/2005"; // us date format is used in context + res = converter.convertValue(context, null, null, null, dateStr, Date.class); + assertEquals(res, OgnlRuntime.NoConversionPossible); + + // and test a date that is passable + SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy"); + dateStr = "12/31/2005"; // us date format + res = converter.convertValue(context, null, null, null, dateStr, Date.class); + Date date = format.parse(dateStr); + assertNotSame(res, OgnlRuntime.NoConversionPossible); + assertEquals(date, res); + } + + + public void testFindConversionErrorMessage() { + ModelDrivenAction action = new ModelDrivenAction(); + stack.push(action); + stack.push(action.getModel()); + + String message = XWorkConverter.getConversionErrorMessage("birth", stack); + assertNotNull(message); + assertEquals("Invalid date for birth.", message); + + message = XWorkConverter.getConversionErrorMessage("foo", stack); + assertNotNull(message); + assertEquals("Invalid field value for field \"foo\".", message); + } + + public void testFindConversionMappingForInterface() { + ModelDrivenAction2 action = new ModelDrivenAction2(); + stack.push(action); + stack.push(action.getModel()); + + Map<String, Object> ognlStackContext = stack.getContext(); + ognlStackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); + + String value = "asdf:123"; + Object o = converter.convertValue(ognlStackContext, action.getModel(), null, "barObj", value, Bar.class); + assertNotNull(o); + assertTrue(o instanceof Bar); + + Bar b = (Bar) o; + assertEquals(value, b.getTitle() + ":" + b.getSomethingElse()); + } + + public void testLocalizedDateConversion() throws Exception { + Date date = new Date(System.currentTimeMillis()); + Locale locale = Locale.GERMANY; + DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT, locale); + String dateString = df.format(date); + context.put(ActionContext.LOCALE, locale); + assertEquals(dateString, converter.convertValue(context, null, null, null, date, String.class)); + } + + public void testStringToIntConversions() { + SimpleAction action = new SimpleAction(); + action.setBean(new TestBean()); + + stack.push(action); + + Map<String, Object> ognlStackContext = stack.getContext(); + ognlStackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); + + assertEquals("Conversion should have failed.", OgnlRuntime.NoConversionPossible, converter.convertValue(ognlStackContext, action.getBean(), null, "count", "111.1", int.class)); + stack.pop(); + + Map conversionErrors = (Map) stack.getContext().get(ActionContext.CONVERSION_ERRORS); + assertNotNull(conversionErrors); + assertTrue(conversionErrors.size() == 1); + } + + public void testStringArrayToCollection() { + List<String> list = new ArrayList<>(); + list.add("foo"); + list.add("bar"); + list.add("baz"); + assertEquals(list, converter.convertValue(context, null, null, null, new String[]{ + "foo", "bar", "baz" + }, Collection.class)); + } + + public void testStringArrayToList() { + List<String> list = new ArrayList<>(); + list.add("foo"); + list.add("bar"); + list.add("baz"); + assertEquals(list, converter.convertValue(context, null, null, null, new String[]{ + "foo", "bar", "baz" + }, List.class)); + } + + public void testStringArrayToPrimitiveWrappers() { + Long[] longs = (Long[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, Long[].class); + assertNotNull(longs); + assertTrue(Arrays.equals(new Long[]{123L, 456L}, longs)); + + Integer[] ints = (Integer[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, Integer[].class); + assertNotNull(ints); + assertTrue(Arrays.equals(new Integer[]{123, 456}, ints)); + + Double[] doubles = (Double[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, Double[].class); + assertNotNull(doubles); + assertTrue(Arrays.equals(new Double[]{123D, 456D}, doubles)); + + Float[] floats = (Float[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, Float[].class); + assertNotNull(floats); + assertTrue(Arrays.equals(new Float[]{123F, 456F}, floats)); + + Boolean[] booleans = (Boolean[]) converter.convertValue(context, null, null, null, new String[]{ + "true", "false" + }, Boolean[].class); + assertNotNull(booleans); + assertTrue(Arrays.equals(new Boolean[]{Boolean.TRUE, Boolean.FALSE}, booleans)); + } + + public void testStringArrayToPrimitives() throws OgnlException { + long[] longs = (long[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, long[].class); + assertNotNull(longs); + assertTrue(Arrays.equals(new long[]{123, 456}, longs)); + + int[] ints = (int[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, int[].class); + assertNotNull(ints); + assertTrue(Arrays.equals(new int[]{123, 456}, ints)); + + double[] doubles = (double[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, double[].class); + assertNotNull(doubles); + assertTrue(Arrays.equals(new double[]{123, 456}, doubles)); + + float[] floats = (float[]) converter.convertValue(context, null, null, null, new String[]{ + "123", "456" + }, float[].class); + assertNotNull(floats); + assertTrue(Arrays.equals(new float[]{123, 456}, floats)); + + boolean[] booleans = (boolean[]) converter.convertValue(context, null, null, null, new String[]{ + "true", "false" + }, boolean[].class); + assertNotNull(booleans); + assertTrue(Arrays.equals(new boolean[]{true, false}, booleans)); + } + + public void testStringArrayToSet() { + Set<String> list = new HashSet<>(); + list.add("foo"); + list.add("bar"); + list.add("baz"); + assertEquals(list, converter.convertValue(context, null, null, null, new String[]{ + "foo", "bar", "bar", "baz" + }, Set.class)); + } + + public void testStringToCollectionConversion() { + Map<String, Object> stackContext = stack.getContext(); + stackContext.put(ReflectionContextState.CREATE_NULL_OBJECTS, Boolean.TRUE); + stackContext.put(ReflectionContextState.DENY_METHOD_EXECUTION, Boolean.TRUE); + stackContext.put(XWorkConverter.REPORT_CONVERSION_ERRORS, Boolean.TRUE); + + User user = new User(); + stack.push(user); + + stack.setValue("list", "asdf"); + assertNotNull(user.getList()); + assertEquals(1, user.getList().size()); + assertEquals(String.class, user.getList().get(0).getClass()); + assertEquals("asdf", user.getList().get(0)); + } + + public void testStringToCustomTypeUsingCustomConverter() { + // the converter needs to be registered as the Bar.class converter + // it won't be detected from the Foo-conversion.properties + // because the Foo-conversion.properties file is only used when converting a property of Foo + converter.registerConverter(Bar.class.getName(), new FooBarConverter()); + + Bar bar = (Bar) converter.convertValue(null, null, null, null, "blah:123", Bar.class); + assertNotNull("conversion failed", bar); + assertEquals(123, bar.getSomethingElse()); + assertEquals("blah", bar.getTitle()); + } + + public void testStringToCustomTypeUsingCustomConverterFromProperties() throws Exception { + + ClassLoader cl = Thread.currentThread().getContextClassLoader(); + try { + Thread.currentThread().setContextClassLoader(new ClassLoader(cl) { + @Override + public Enumeration<URL> getResources(String name) throws IOException { + if ("xwork-conversion.properties".equals(name)) { + return new Enumeration<URL>() { + boolean done = false; + public boolean hasMoreElements() { + return !done; + } + + public URL nextElement() { + if (done) { + throw new RuntimeException("Conversion configuration loading " + + "failed because it asked the enumeration for the next URL " + + "too many times"); + } + + done = true; + return getClass().getResource("/com/opensymphony/xwork2/conversion/impl/test-xwork-conversion.properties"); + } + }; + } else { + return super.getResources(name); + } + } + }); + setUp(); + } finally { + Thread.currentThread().setContextClassLoader(cl); + } + Bar bar = (Bar) converter.convertValue(null, null, null, null, "blah:123", Bar.class); + assertNotNull("conversion failed", bar); + assertEquals(123, bar.getSomethingElse()); + assertEquals("blah", bar.getTitle()); + } + + public void testStringToPrimitiveWrappers() { + assertEquals(new Long(123), converter.convertValue(context, null, null, null, "123", Long.class)); + assertEquals(new Integer(123), converter.convertValue(context, null, null, null, "123", Integer.class)); + assertEquals(new Double(123.5), converter.convertValue(context, null, null, null, "123.5", Double.class)); + assertEquals(new Float(123.5), converter.convertValue(context, null, null, null, "123.5", float.class)); + assertEquals(false, converter.convertValue(context, null, null, null, "false", Boolean.class)); + assertEquals(true, converter.convertValue(context, null, null, null, "true", Boolean.class)); + } + + public void testStringToPrimitives() { + assertEquals(new Long(123), converter.convertValue(context, null, null, null, "123", long.class)); + assertEquals(new Double(123.5), converter.convertValue(context, null, null, null, "123.5", double.class)); + assertEquals(new Float(123.5), converter.convertValue(context, null, null, null, "123.5", float.class)); + assertEquals(false, converter.convertValue(context, null, null, null, "false", boolean.class)); + assertEquals(true, converter.convertValue(context, null, null, null, "true", boolean.class)); + assertEquals(new BigDecimal(123.5), converter.convertValue(context, null, null, null, "123.5", BigDecimal.class)); + assertEquals(new BigInteger("123"), converter.convertValue(context, null, null, null, "123", BigInteger.class)); + } + + public void testOverflows() { + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Double.MAX_VALUE + "1", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Double.MIN_VALUE + "-1", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Double.MAX_VALUE + "1", Double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Double.MIN_VALUE + "-1", Double.class)); + + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Float.MAX_VALUE + "1", float.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Float.MIN_VALUE + "-1", float.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Float.MAX_VALUE + "1", Float.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Float.MIN_VALUE + "-1", Float.class)); + + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Integer.MAX_VALUE + "1", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Integer.MIN_VALUE + "-1", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Integer.MAX_VALUE + "1", Integer.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Integer.MIN_VALUE + "-1", Integer.class)); + + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Byte.MAX_VALUE + "1", byte.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Byte.MIN_VALUE + "-1", byte.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Byte.MAX_VALUE + "1", Byte.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Byte.MIN_VALUE + "-1", Byte.class)); + + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Short.MAX_VALUE + "1", short.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Short.MIN_VALUE + "-1", short.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Short.MAX_VALUE + "1", Short.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Short.MIN_VALUE + "-1", Short.class)); + + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Long.MAX_VALUE + "1", long.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Long.MIN_VALUE + "-1", long.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Long.MAX_VALUE + "1", Long.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, Long.MIN_VALUE + "-1", Long.class)); + } + + public void testStringToInt() { + assertEquals(new Integer(123), converter.convertValue(context, null, null, null, "123", int.class)); + context.put(ActionContext.LOCALE, Locale.US); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "123.12", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "123aa", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "aa123", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,234", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,23", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,234.12", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1.234", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1.234,12", int.class)); + context.put(ActionContext.LOCALE, Locale.GERMANY); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "123.12", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "123aa", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "aa123", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,234", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,23", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,234.12", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1.234", int.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1.234,12", int.class)); + } + + + public void testStringToInteger() { + assertEquals(new Integer(123), converter.convertValue(context, null, null, null, "123", Integer.class)); + context.put(ActionContext.LOCALE, Locale.US); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "123.12", Integer.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "123aa", Integer.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "aa123", Integer.class)); + assertEquals(new Integer(1234), converter.convertValue(context, null, null, null, "1,234", Integer.class)); + // WRONG: locale separator is wrongly placed + assertEquals(new Integer(123), converter.convertValue(context, null, null, null, "1,23", Integer.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,234.12", Integer.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1.234", Integer.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1.234,12", Integer.class)); + + context.put(ActionContext.LOCALE, Locale.GERMANY); + // WRONG: locale separator is wrongly placed + assertEquals(new Integer(12312), converter.convertValue(context, null, null, null, "123.12", Integer.class)); + assertEquals(new Integer(1234), converter.convertValue(context, null, null, null, "1.234", Integer.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "123aa", Integer.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "aa123", Integer.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,234", Integer.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,234.12", Integer.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,23", Integer.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1.234,12", Integer.class)); + } + + public void testStringToPrimitiveDouble() { + assertEquals(new Double(123), converter.convertValue(context, null, null, null, "123", double.class)); + context.put(ActionContext.LOCALE, Locale.US); + assertEquals(new Double(123.12), converter.convertValue(context, null, null, null, "123.12", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "123aa", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "aa123", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,234", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,234.12", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,23", double.class)); + assertEquals(new Double(1.234), converter.convertValue(context, null, null, null, "1.234", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1.234,12", double.class)); + + context.put(ActionContext.LOCALE, Locale.GERMANY); + assertEquals(new Double(123.12), converter.convertValue(context, null, null, null, "123.12", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "123aa", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "aa123", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,234", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,234.12", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,23", double.class)); + assertEquals(new Double(1.234), converter.convertValue(context, null, null, null, "1.234", double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1.234,12", double.class)); + } + + public void testStringToDouble() { + assertEquals(new Double(123), converter.convertValue(context, null, null, null, "123", Double.class)); + context.put(ActionContext.LOCALE, Locale.US); + assertEquals(new Double(123.12), converter.convertValue(context, null, null, null, "123.12", Double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "123aa", Double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "aa123", Double.class)); + assertEquals(new Double(1234), converter.convertValue(context, null, null, null, "1,234", Double.class)); + assertEquals(new Double(1234.12), converter.convertValue(context, null, null, null, "1,234.12", Double.class)); + // WRONG: locale separator is wrongly placed + assertEquals(new Double(123), converter.convertValue(context, null, null, null, "1,23", Double.class)); + assertEquals(new Double(1.234), converter.convertValue(context, null, null, null, "1.234", Double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1.234,12", Double.class)); + + context.put(ActionContext.LOCALE, Locale.GERMANY); + // WRONG: locale separator is wrongly placed + assertEquals(new Double(12312), converter.convertValue(context, null, null, null, "123.12", Double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "123aa", Double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "aa123", Double.class)); + assertEquals(new Double(1.234), converter.convertValue(context, null, null, null, "1,234", Double.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "1,234.12", Double.class)); + assertEquals(new Double(1.23), converter.convertValue(context, null, null, null, "1,23", Double.class)); + assertEquals(new Double(1234), converter.convertValue(context, null, null, null, "1.234", Double.class)); + assertEquals(new Double(1234.12), converter.convertValue(context, null, null, null, "1.234,12", Double.class)); + + } + + public void testStringToEnum() { + assertEquals(FurColor.BLACK, converter.convertValue(context, null, null, null, "BLACK", FurColor.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "black", FurColor.class)); + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, null, null, null, "red", FurColor.class)); + } + + // Testing for null result on non-primitive Number types supplied as empty String or + public void testNotPrimitiveDefaultsToNull() { + assertEquals(null, converter.convertValue(context, null, null, null, null, Double.class)); + assertEquals(null, converter.convertValue(context, null, null, null, "", Double.class)); + + assertEquals(null, converter.convertValue(context, null, null, null, null, Integer.class)); + assertEquals(null, converter.convertValue(context, null, null, null, "", Integer.class)); + + assertEquals(null, converter.convertValue(context, null, null, null, null, Float.class)); + assertEquals(null, converter.convertValue(context, null, null, null, "", Float.class)); + + assertEquals(null, converter.convertValue(context, null, null, null, null, Character.class)); + assertEquals(null, converter.convertValue(context, null, null, null, "", Character.class)); + + assertEquals(null, converter.convertValue(context, null, null, null, null, Long.class)); + assertEquals(null, converter.convertValue(context, null, null, null, "", Long.class)); + + assertEquals(null, converter.convertValue(context, null, null, null, null, Short.class)); + assertEquals(null, converter.convertValue(context, null, null, null, "", Short.class)); + + } + + public void testConvertChar() { + assertEquals(new Character('A'), converter.convertValue(context, "A", char.class)); + assertEquals(new Character('Z'), converter.convertValue(context, "Z", char.class)); + assertEquals(new Character('A'), converter.convertValue(context, "A", Character.class)); + assertEquals(new Character('Z'), converter.convertValue(context, "Z", Character.class)); + + assertEquals(new Character('A'), converter.convertValue(context, new Character('A'), char.class)); + assertEquals(new Character('Z'), converter.convertValue(context, new Character('Z'), char.class)); + assertEquals(new Character('A'), converter.convertValue(context, new Character('A'), Character.class)); + assertEquals(new Character('Z'), converter.convertValue(context, new Character('Z'), Character.class)); + + assertEquals(new Character('D'), converter.convertValue(context, "DEF", char.class)); + assertEquals(new Character('X'), converter.convertValue(context, "XYZ", Character.class)); + assertEquals(new Character(' '), converter.convertValue(context, " ", Character.class)); + assertEquals(new Character(' '), converter.convertValue(context, " ", char.class)); + + assertEquals(null, converter.convertValue(context, "", char.class)); + } + + public void testConvertClass() { + Class clazz = (Class) converter.convertValue(context, "java.util.Date", Class.class); + assertEquals(Date.class.getName(), clazz.getName()); + + Class clazz2 = (Class) converter.convertValue(context, "com.opensymphony.xwork2.util.Bar", Class.class); + assertEquals(Bar.class.getName(), clazz2.getName()); + + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, "com.opensymphony.xwork2.util.IDoNotExist", Class.class)); + + assertEquals(OgnlRuntime.NoConversionPossible, converter.convertValue(context, new Bar(), Class.class)); // only supports string values + } + + public void testConvertBoolean() { + assertEquals(Boolean.TRUE, converter.convertValue(context, "true", Boolean.class)); + assertEquals(Boolean.FALSE, converter.convertValue(context, "false", Boolean.class)); + + assertEquals(Boolean.TRUE, converter.convertValue(context, Boolean.TRUE, Boolean.class)); + assertEquals(Boolean.FALSE, converter.convertValue(context, Boolean.FALSE, Boolean.class)); + + assertEquals(null, converter.convertValue(context, null, Boolean.class)); + assertEquals(Boolean.TRUE, converter.convertValue(context, new Bar(), Boolean.class)); // Ognl converter will default to true + } + + public void testConvertPrimitiveArraysToString() { + assertEquals("2, 3, 1", converter.convertValue(context, new int[]{2, 3, 1}, String.class)); + assertEquals("100, 200, 300", converter.convertValue(context, new long[]{100, 200, 300}, String.class)); + assertEquals("1.5, 2.5, 3.5", converter.convertValue(context, new double[]{1.5, 2.5, 3.5}, String.class)); + assertEquals("true, false, true", converter.convertValue(context, new boolean[]{true, false, true}, String.class)); + } + + public void testConvertSameCollectionToCollection() { + Collection<String> names = new ArrayList<>(); + names.add("XWork"); + names.add("Struts"); + + Collection col = (Collection) converter.convertValue(context, names, Collection.class); + assertSame(names, col); + } + + public void testConvertSqlTimestamp() { + assertNotNull(converter.convertValue(context, new Timestamp(new Date().getTime()), String.class)); + assertNotNull(converter.convertValue(null, new Timestamp(new Date().getTime()), String.class)); + } + + public void testValueStackWithTypeParameter() { + stack.push(new Foo1()); + Bar1 bar = (Bar1) stack.findValue("bar", Bar1.class); + assertNotNull(bar); + } + + public void testNestedConverters() { + Cat cat = new Cat(); + cat.setFoo(new Foo()); + stack.push(cat); + stack.setValue("foo.number", "123"); + assertEquals(321, cat.getFoo().getNumber()); + } + + public void testCollectionConversion() throws Exception { + // given + String[] col1 = new String[]{"1", "2", "ble", "3"}; + + // when + Object converted = converter.convertValue(context, new ListAction(), null, "ints", col1, List.class); + + // then + assertEquals(converted, Arrays.asList(1, 2, 3)); + } + + public static class Foo1 { + public Bar1 getBar() { + return new Bar1Impl(); + } + } + + public interface Bar1 { + } + + public static class Bar1Impl implements Bar1 { + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + + converter = container.getInstance(XWorkConverter.class); + + ActionContext ac = ActionContext.getContext(); + ac.setLocale(Locale.US); + context = ac.getContextMap(); + stack = (OgnlValueStack) ac.getValueStack(); + } + +} + +class ListAction { + + private List<Integer> ints = new ArrayList<>(); + + public List<Integer> getInts() { + return ints; + } + + public void setInts(List<Integer> ints) { + this.ints = ints; + } + +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/struts/blob/82cb1286/core/src/test/java/com/opensymphony/xwork2/interceptor/annotations/AllowingByDefaultAction.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/com/opensymphony/xwork2/interceptor/annotations/AllowingByDefaultAction.java b/core/src/test/java/com/opensymphony/xwork2/interceptor/annotations/AllowingByDefaultAction.java new file mode 100644 index 0000000..d97c59a --- /dev/null +++ b/core/src/test/java/com/opensymphony/xwork2/interceptor/annotations/AllowingByDefaultAction.java @@ -0,0 +1,23 @@ +package com.opensymphony.xwork2.interceptor.annotations; + +import com.opensymphony.xwork2.ActionSupport; + +/** + * @author martin.gilday + * + */ +public class AllowingByDefaultAction extends ActionSupport { + + @Blocked + private String name; + private String job; + + public void setName(String name) { + this.name = name; + } + + public void setJob(String job) { + this.job = job; + } + +} http://git-wip-us.apache.org/repos/asf/struts/blob/82cb1286/core/src/test/java/com/opensymphony/xwork2/interceptor/annotations/AllowingByDefaultModel.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/com/opensymphony/xwork2/interceptor/annotations/AllowingByDefaultModel.java b/core/src/test/java/com/opensymphony/xwork2/interceptor/annotations/AllowingByDefaultModel.java new file mode 100644 index 0000000..e315577 --- /dev/null +++ b/core/src/test/java/com/opensymphony/xwork2/interceptor/annotations/AllowingByDefaultModel.java @@ -0,0 +1,22 @@ +package com.opensymphony.xwork2.interceptor.annotations; + + +/** + * @author jafl + * + */ +public class AllowingByDefaultModel { + + @Blocked + private String m1; + private String m2; + + public void setM1(String s) { + m1 = s; + } + + public void setM2(String s) { + m2 = s; + } + +} http://git-wip-us.apache.org/repos/asf/struts/blob/82cb1286/core/src/test/java/com/opensymphony/xwork2/interceptor/annotations/AnnotatedAction.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/com/opensymphony/xwork2/interceptor/annotations/AnnotatedAction.java b/core/src/test/java/com/opensymphony/xwork2/interceptor/annotations/AnnotatedAction.java new file mode 100644 index 0000000..6698088 --- /dev/null +++ b/core/src/test/java/com/opensymphony/xwork2/interceptor/annotations/AnnotatedAction.java @@ -0,0 +1,46 @@ +/* + * Copyright 2002-2006,2009 The Apache Software Foundation. + * + * 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. + */ +package com.opensymphony.xwork2.interceptor.annotations; + +import com.opensymphony.xwork2.Action; + +/** + * @author Zsolt Szasz, zsolt at lorecraft dot com + * @author Rainer Hermanns + */ +public class AnnotatedAction extends BaseAnnotatedAction { + + @Before(priority=5) + public String before() { + log = log + "before"; + return null; + } + + public String execute() { + log = log + "-execute"; + return Action.SUCCESS; + } + + @BeforeResult + public void beforeResult() throws Exception { + log = log +"-beforeResult"; + } + + @After(priority=5) + public void after() { + log = log + "-after"; + } +}
