public void testHandleToSuperClass() throws SQLException {

        ResultSetHandler h = new BeanHandler(SubTestBean.class);

        TestBean results = h.handle(this.rs);

        assertNotNull(results);

        assertEquals("1", results.getOne());

        assertEquals("2", results.getTwo());

        assertEquals(TestBean.Ordinal.THREE, results.getThree());

        assertEquals("not set", results.getDoNotSet());

    }

    private static final ProxyFactory instance = new ProxyFactory();

        return instance;

        super();

    }

        return type.cast(Proxy.newProxyInstance(handler.getClass().getClassLoader(), new Class[] {type}, handler));

        return newProxyInstance(ResultSet.class, handler);

        return newProxyInstance(ResultSetMetaData.class, handler);

        this(type, ArrayHandler.ROW_PROCESSOR);

    }

        this.type = type;

        this.convert = convert;

    }

        return rs.next() ? this.convert.toBean(rs, this.type) : null;

    private static final BeanProcessor defaultConvert = new BeanProcessor();

    private static final BasicRowProcessor instance = new BasicRowProcessor();

        this(defaultConvert);

    }

        super();

        this.convert = convert;

    }

        return this.convert.toBean(rs, type);

    static final RowProcessor ROW_PROCESSOR = new BasicRowProcessor();

    private static final Object[] EMPTY_ARRAY = new Object[0];

    private static final Map, Object> primitiveDefaults = new HashMap, Object>();

        primitiveDefaults.put(Integer.TYPE, Integer.valueOf(0));

        primitiveDefaults.put(Short.TYPE, Short.valueOf((short) 0));

        primitiveDefaults.put(Byte.TYPE, Byte.valueOf((byte) 0));

        primitiveDefaults.put(Float.TYPE, Float.valueOf(0f));

        primitiveDefaults.put(Double.TYPE, Double.valueOf(0d));

        primitiveDefaults.put(Long.TYPE, Long.valueOf(0L));

        primitiveDefaults.put(Boolean.TYPE, Boolean.FALSE);

        primitiveDefaults.put(Character.TYPE, Character.valueOf((char) 0));

    }

        this(new HashMap());

    }

        super();

        if (columnToPropertyOverrides == null) {

        this.columnToPropertyOverrides = columnToPropertyOverrides;

    }

        PropertyDescriptor[] props = this.propertyDescriptors(type);

        ResultSetMetaData rsmd = rs.getMetaData();

        int[] columnToProperty = this.mapColumnsToProperties(rsmd, props);

        return this.createBean(rs, type, props, columnToProperty);

        T bean = this.newInstance(type);

        for (int i = 1; i < columnToProperty.length; i++) {

            if (columnToProperty[i] == PROPERTY_NOT_FOUND) {

                continue;

            PropertyDescriptor prop = props[columnToProperty[i]];

            Class propType = prop.getPropertyType();

            Object value = null;

            if(propType != null) {

                value = this.processColumn(rs, i, propType);

                if (value == null && propType.isPrimitive()) {

            this.callSetter(bean, prop, value);

        return bean;

        if (setter == null) {

        Class[] params = setter.getParameterTypes();

            if (value instanceof java.util.Date) {

            if (value instanceof String && params[0].isEnum()) {

                value = Enum.valueOf(params[0].asSubclass(Enum.class), (String) value);

            if (this.isCompatibleType(value, params[0])) {

                setter.invoke(target, new Object[]{value});

        }

    }

        if (value == null || type.isInstance(value)) {

            return true;

        } else if (type.equals(Integer.TYPE) && value instanceof Integer) {

            return true;

        } else if (type.equals(Long.TYPE) && value instanceof Long) {

        } else if (type.equals(Double.TYPE) && value instanceof Double) {

            return true;

            return c.newInstance();

        BeanInfo beanInfo = null;

            beanInfo = Introspector.getBeanInfo(c);

        }

        return beanInfo.getPropertyDescriptors();

        int cols = rsmd.getColumnCount();

        int[] columnToProperty = new int[cols + 1];

        Arrays.fill(columnToProperty, PROPERTY_NOT_FOUND);

        for (int col = 1; col <= cols; col++) {

            String columnName = rsmd.getColumnLabel(col);

            if (null == columnName || 0 == columnName.length()) {

              columnName = rsmd.getColumnName(col);

            String propertyName = columnToPropertyOverrides.get(columnName);

            if (propertyName == null) {

                propertyName = columnName;

            for (int i = 0; i < props.length; i++) {

                if (propertyName.equalsIgnoreCase(props[i].getName())) {

                    columnToProperty[col] = i;

                    break;

        return columnToProperty;

        if ( !propType.isPrimitive() && rs.getObject(index) == null ) {

            return null;

        if (propType.equals(String.class)) {

            return rs.getString(index);

        } else if (

            propType.equals(Integer.TYPE) || propType.equals(Integer.class)) {

            return Integer.valueOf(rs.getInt(index));

        } else if (

            propType.equals(Boolean.TYPE) || propType.equals(Boolean.class)) {

        } else if (propType.equals(Long.TYPE) || propType.equals(Long.class)) {

        } else if (

            propType.equals(Double.TYPE) || propType.equals(Double.class)) {

            return Double.valueOf(rs.getDouble(index));

        } else if (

            propType.equals(Float.TYPE) || propType.equals(Float.class)) {

        } else if (

            propType.equals(Short.TYPE) || propType.equals(Short.class)) {

        } else if (propType.equals(Byte.TYPE) || propType.equals(Byte.class)) {

        } else if (propType.equals(Timestamp.class)) {

        } else if (propType.equals(SQLXML.class)) {

            return rs.getObject(index);