diff options
Diffstat (limited to 'src/test/java/com/fasterxml/jackson/databind/util/ClassUtilTest.java')
| -rw-r--r-- | src/test/java/com/fasterxml/jackson/databind/util/ClassUtilTest.java | 221 |
1 files changed, 221 insertions, 0 deletions
diff --git a/src/test/java/com/fasterxml/jackson/databind/util/ClassUtilTest.java b/src/test/java/com/fasterxml/jackson/databind/util/ClassUtilTest.java new file mode 100644 index 000000000..8572635bc --- /dev/null +++ b/src/test/java/com/fasterxml/jackson/databind/util/ClassUtilTest.java @@ -0,0 +1,221 @@ +package com.fasterxml.jackson.databind.util; + +import java.util.*; + +import com.fasterxml.jackson.databind.BaseMapTest; +import com.fasterxml.jackson.databind.util.ClassUtil; + +public class ClassUtilTest extends BaseMapTest +{ + /* + /********************************************************** + /* Test classes, enums + /********************************************************** + */ + + /* Test classes and interfaces needed for testing class util + * methods + */ + static abstract class BaseClass implements Comparable<BaseClass>, + BaseInt + { + BaseClass(String str) { } + } + + interface BaseInt { } + + interface SubInt extends BaseInt { } + + enum TestEnum { A; } + + abstract class InnerNonStatic { } + + static class Inner { + protected Inner() { + throw new IllegalStateException("test"); + } + } + + static abstract class SubClass + extends BaseClass + implements SubInt { + SubClass() { super("x"); } + } + + static abstract class ConcreteAndAbstract { + public abstract void a(); + + public void c() { } + } + + /* + /********************************************************** + /* Test methods + /********************************************************** + */ + + public void testIsConcrete() throws Exception + { + assertTrue(ClassUtil.isConcrete(getClass())); + assertFalse(ClassUtil.isConcrete(BaseClass.class)); + assertFalse(ClassUtil.isConcrete(BaseInt.class)); + + assertFalse(ClassUtil.isConcrete(ConcreteAndAbstract.class.getDeclaredMethod("a"))); + assertTrue(ClassUtil.isConcrete(ConcreteAndAbstract.class.getDeclaredMethod("c"))); + } + + public void testCanBeABeanType() + { + assertEquals("annotation", ClassUtil.canBeABeanType(java.lang.annotation.Retention.class)); + assertEquals("array", ClassUtil.canBeABeanType(String[].class)); + assertEquals("enum", ClassUtil.canBeABeanType(TestEnum.class)); + assertEquals("primitive", ClassUtil.canBeABeanType(Integer.TYPE)); + assertNull(ClassUtil.canBeABeanType(Integer.class)); + + assertEquals("non-static member class", ClassUtil.isLocalType(InnerNonStatic.class, false)); + assertNull(ClassUtil.isLocalType(Integer.class, false)); + } + + public void testExceptionHelpers() + { + RuntimeException e = new RuntimeException("test"); + RuntimeException wrapper = new RuntimeException(e); + + assertSame(e, ClassUtil.getRootCause(wrapper)); + + try { + ClassUtil.throwAsIAE(e); + fail("Shouldn't get this far"); + } catch (RuntimeException e2) { + assertSame(e, e2); + } + + try { + ClassUtil.throwRootCause(e); + fail("Shouldn't get this far"); + } catch (Exception eAct) { + assertSame(e, eAct); + } + + Error err = new Error(); + try { + ClassUtil.throwAsIAE(err); + fail("Shouldn't get this far"); + } catch (Error errAct) { + assertSame(err, errAct); + } + + try { + ClassUtil.unwrapAndThrowAsIAE(wrapper); + fail("Shouldn't get this far"); + } catch (RuntimeException e2) { + assertSame(e, e2); + } + } + + public void testFailedCreateInstance() + { + try { + ClassUtil.createInstance(BaseClass.class, true); + } catch (IllegalArgumentException e) { + verifyException(e, "has no default"); + } + + try { + // false means ctor would need to be public + ClassUtil.createInstance(Inner.class, false); + } catch (IllegalArgumentException e) { + verifyException(e, "is not accessible"); + } + + // and finally, check that we'll get expected exception... + try { + ClassUtil.createInstance(Inner.class, true); + } catch (IllegalStateException e) { + verifyException(e, "test"); + } + } + + public void testPrimitiveDefaultValue() + { + assertEquals(Integer.valueOf(0), ClassUtil.defaultValue(Integer.TYPE)); + assertEquals(Long.valueOf(0L), ClassUtil.defaultValue(Long.TYPE)); + assertEquals(Character.valueOf('\0'), ClassUtil.defaultValue(Character.TYPE)); + assertEquals(Short.valueOf((short) 0), ClassUtil.defaultValue(Short.TYPE)); + assertEquals(Byte.valueOf((byte) 0), ClassUtil.defaultValue(Byte.TYPE)); + + assertEquals(Double.valueOf(0.0), ClassUtil.defaultValue(Double.TYPE)); + assertEquals(Float.valueOf(0.0f), ClassUtil.defaultValue(Float.TYPE)); + + assertEquals(Boolean.FALSE, ClassUtil.defaultValue(Boolean.TYPE)); + + try { + ClassUtil.defaultValue(String.class); + } catch (IllegalArgumentException e) { + verifyException(e, "String is not a primitive type"); + } + } + + public void testPrimitiveWrapperType() + { + assertEquals(Byte.class, ClassUtil.wrapperType(Byte.TYPE)); + assertEquals(Short.class, ClassUtil.wrapperType(Short.TYPE)); + assertEquals(Character.class, ClassUtil.wrapperType(Character.TYPE)); + assertEquals(Integer.class, ClassUtil.wrapperType(Integer.TYPE)); + assertEquals(Long.class, ClassUtil.wrapperType(Long.TYPE)); + + assertEquals(Double.class, ClassUtil.wrapperType(Double.TYPE)); + assertEquals(Float.class, ClassUtil.wrapperType(Float.TYPE)); + + assertEquals(Boolean.class, ClassUtil.wrapperType(Boolean.TYPE)); + + try { + ClassUtil.wrapperType(String.class); + fail("Should not pass"); + } catch (IllegalArgumentException e) { + verifyException(e, "String is not a primitive type"); + } + } + + public void testWrapperToPrimitiveType() + { + assertEquals(Integer.TYPE, ClassUtil.primitiveType(Integer.class)); + assertEquals(Long.TYPE, ClassUtil.primitiveType(Long.class)); + assertEquals(Character.TYPE, ClassUtil.primitiveType(Character.class)); + assertEquals(Short.TYPE, ClassUtil.primitiveType(Short.class)); + assertEquals(Byte.TYPE, ClassUtil.primitiveType(Byte.class)); + assertEquals(Float.TYPE, ClassUtil.primitiveType(Float.class)); + assertEquals(Double.TYPE, ClassUtil.primitiveType(Double.class)); + assertEquals(Boolean.TYPE, ClassUtil.primitiveType(Boolean.class)); + + assertNull(ClassUtil.primitiveType(String.class)); + } + + public void testFindEnumType() + { + assertEquals(TestEnum.class, ClassUtil.findEnumType(TestEnum.A)); + assertEquals(TestEnum.class, ClassUtil.findEnumType(EnumSet.allOf(TestEnum.class))); + assertEquals(TestEnum.class, ClassUtil.findEnumType(new EnumMap<TestEnum,Integer>(TestEnum.class))); + } + + public void testDescs() + { + final String exp = String.class.getName(); + assertEquals(exp, ClassUtil.getClassDescription("foo")); + assertEquals(exp, ClassUtil.getClassDescription(String.class)); + } + + @SuppressWarnings("deprecation") + public void testFindClass() throws Exception + { + assertEquals(Integer.TYPE, ClassUtil.findClass("int")); + assertEquals(Long.TYPE, ClassUtil.findClass("long")); + assertEquals(Byte.TYPE, ClassUtil.findClass("byte")); + assertEquals(Short.TYPE, ClassUtil.findClass("short")); + assertEquals(Character.TYPE, ClassUtil.findClass("char")); + assertEquals(Float.TYPE, ClassUtil.findClass("float")); + assertEquals(Double.TYPE, ClassUtil.findClass("double")); + assertEquals(Boolean.TYPE, ClassUtil.findClass("boolean")); + assertEquals(Void.TYPE, ClassUtil.findClass("void")); + } +} |