Example usage for java.lang Integer TYPE

List of usage examples for java.lang Integer TYPE

  1. HOME
  2. Java
  3. java
  4. java.lang.*
  5. Integer
  6. TYPE

Introduction

In this page you can find the example usage for java.lang Integer TYPE.

Prototype

Class TYPE

To view the source code for java.lang Integer TYPE.

Click Source Link

Document

The Class instance representing the primitive type int .

Usage

From source file:com.aliyun.fs.oss.utils.OSSClientAgent.java

@SuppressWarnings("unchecked")
private Object initializeOSSClientConfig(Configuration conf, Class ClientConfigurationClz)
        throws IOException, ServiceException, ClientException {
    try {// w  w  w . j  a  v  a  2  s.  c om
        Constructor cons = ClientConfigurationClz.getConstructor();
        Object clientConfiguration = cons.newInstance();
        Method method0 = ClientConfigurationClz.getMethod("setConnectionTimeout", Integer.TYPE);
        method0.invoke(clientConfiguration, conf.getInt("fs.oss.client.connection.timeout",
                ClientConfiguration.DEFAULT_CONNECTION_TIMEOUT));
        Method method1 = ClientConfigurationClz.getMethod("setSocketTimeout", Integer.TYPE);
        method1.invoke(clientConfiguration,
                conf.getInt("fs.oss.client.socket.timeout", ClientConfiguration.DEFAULT_SOCKET_TIMEOUT));
        Method method2 = ClientConfigurationClz.getMethod("setConnectionTTL", Long.TYPE);
        method2.invoke(clientConfiguration,
                conf.getLong("fs.oss.client.connection.ttl", ClientConfiguration.DEFAULT_CONNECTION_TTL));
        Method method3 = ClientConfigurationClz.getMethod("setMaxConnections", Integer.TYPE);
        method3.invoke(clientConfiguration,
                conf.getInt("fs.oss.connection.max", ClientConfiguration.DEFAULT_MAX_CONNECTIONS));

        return clientConfiguration;
    } catch (Exception e) {
        handleException(e);
        return null;
    }
}

From source file:org.apache.tez.runtime.LogicalIOProcessorRuntimeTask.java

private LogicalInput createInput(InputSpec inputSpec, InputContext inputContext) throws TezException {
    InputDescriptor inputDesc = inputSpec.getInputDescriptor();
    Input input = ReflectionUtils.createClazzInstance(inputDesc.getClassName(),
            new Class[] { InputContext.class, Integer.TYPE },
            new Object[] { inputContext, inputSpec.getPhysicalEdgeCount() });
    if (!(input instanceof LogicalInput)) {
        throw new TezUncheckedException(inputDesc.getClass().getName() + " is not a sub-type of LogicalInput."
                + " Only LogicalInput sub-types supported by LogicalIOProcessor.");
    }//w  ww .  j  ava2 s. c o  m
    return (LogicalInput) input;
}

From source file:ResultSetIterator.java

/**
 * Convert a <code>ResultSet</code> column into an object.  Simple 
 * implementations could just call <code>rs.getObject(index)</code> while
 * more complex implementations could perform type manipulation to match 
 * the column's type to the bean property type.
 * //w  w  w .  j  a va  2s .c  o m
 * <p>
 * This implementation calls the appropriate <code>ResultSet</code> getter 
 * method for the given property type to perform the type conversion.  If 
 * the property type doesn't match one of the supported 
 * <code>ResultSet</code> types, <code>getObject</code> is called.
 * </p>
 * 
 * @param rs The <code>ResultSet</code> currently being processed.  It is
 * positioned on a valid row before being passed into this method.
 * 
 * @param index The current column index being processed.
 * 
 * @param propType The bean property type that this column needs to be
 * converted into.
 * 
 * @throws SQLException if a database access error occurs
 * 
 * @return The object from the <code>ResultSet</code> at the given column
 * index after optional type processing or <code>null</code> if the column
 * value was SQL NULL.
 */
protected Object processColumn(ResultSet rs, int index, Class propType) throws SQLException {

    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 new Integer(rs.getInt(index));

    } else if (propType.equals(Boolean.TYPE) || propType.equals(Boolean.class)) {
        return new Boolean(rs.getBoolean(index));

    } else if (propType.equals(Long.TYPE) || propType.equals(Long.class)) {
        return new Long(rs.getLong(index));

    } else if (propType.equals(Double.TYPE) || propType.equals(Double.class)) {
        return new Double(rs.getDouble(index));

    } else if (propType.equals(Float.TYPE) || propType.equals(Float.class)) {
        return new Float(rs.getFloat(index));

    } else if (propType.equals(Short.TYPE) || propType.equals(Short.class)) {
        return new Short(rs.getShort(index));

    } else if (propType.equals(Byte.TYPE) || propType.equals(Byte.class)) {
        return new Byte(rs.getByte(index));

    } else if (propType.equals(Timestamp.class)) {
        return rs.getTimestamp(index);

    } else {
        return rs.getObject(index);
    }

}

From source file:javadz.beanutils.ConvertUtilsBean.java

/**
 * Register array converters.// w  w w.  j a v  a  2  s  .  co  m
 *
 * @param throwException <code>true</code> if the converters should
 * throw an exception when a conversion error occurs, otherwise <code>
 * <code>false</code> if a default value should be used.
 * @param defaultArraySize The size of the default array value for array converters
 * (N.B. This values is ignored if <code>throwException</code> is <code>true</code>).
 * Specifying a value less than zero causes a <code>null<code> value to be used for
 * the default.
 */
private void registerArrays(boolean throwException, int defaultArraySize) {

    // Primitives
    registerArrayConverter(Boolean.TYPE, new BooleanConverter(), throwException, defaultArraySize);
    registerArrayConverter(Byte.TYPE, new ByteConverter(), throwException, defaultArraySize);
    registerArrayConverter(Character.TYPE, new CharacterConverter(), throwException, defaultArraySize);
    registerArrayConverter(Double.TYPE, new DoubleConverter(), throwException, defaultArraySize);
    registerArrayConverter(Float.TYPE, new FloatConverter(), throwException, defaultArraySize);
    registerArrayConverter(Integer.TYPE, new IntegerConverter(), throwException, defaultArraySize);
    registerArrayConverter(Long.TYPE, new LongConverter(), throwException, defaultArraySize);
    registerArrayConverter(Short.TYPE, new ShortConverter(), throwException, defaultArraySize);

    // Standard
    registerArrayConverter(BigDecimal.class, new BigDecimalConverter(), throwException, defaultArraySize);
    registerArrayConverter(BigInteger.class, new BigIntegerConverter(), throwException, defaultArraySize);
    registerArrayConverter(Boolean.class, new BooleanConverter(), throwException, defaultArraySize);
    registerArrayConverter(Byte.class, new ByteConverter(), throwException, defaultArraySize);
    registerArrayConverter(Character.class, new CharacterConverter(), throwException, defaultArraySize);
    registerArrayConverter(Double.class, new DoubleConverter(), throwException, defaultArraySize);
    registerArrayConverter(Float.class, new FloatConverter(), throwException, defaultArraySize);
    registerArrayConverter(Integer.class, new IntegerConverter(), throwException, defaultArraySize);
    registerArrayConverter(Long.class, new LongConverter(), throwException, defaultArraySize);
    registerArrayConverter(Short.class, new ShortConverter(), throwException, defaultArraySize);
    registerArrayConverter(String.class, new StringConverter(), throwException, defaultArraySize);

    // Other
    registerArrayConverter(Class.class, new ClassConverter(), throwException, defaultArraySize);
    registerArrayConverter(java.util.Date.class, new DateConverter(), throwException, defaultArraySize);
    registerArrayConverter(Calendar.class, new DateConverter(), throwException, defaultArraySize);
    registerArrayConverter(File.class, new FileConverter(), throwException, defaultArraySize);
    registerArrayConverter(java.sql.Date.class, new SqlDateConverter(), throwException, defaultArraySize);
    registerArrayConverter(java.sql.Time.class, new SqlTimeConverter(), throwException, defaultArraySize);
    registerArrayConverter(Timestamp.class, new SqlTimestampConverter(), throwException, defaultArraySize);
    registerArrayConverter(URL.class, new URLConverter(), throwException, defaultArraySize);

}

From source file:com.sun.faces.config.ManagedBeanFactory.java

private Object getConvertedValueConsideringPrimitives(Object value, Class valueType) throws FacesException {
    if (null != value && null != valueType) {
        if (valueType == Boolean.TYPE || valueType == java.lang.Boolean.class) {
            value = Boolean.valueOf(value.toString().toLowerCase());
        } else if (valueType == Byte.TYPE || valueType == java.lang.Byte.class) {
            value = new Byte(value.toString());
        } else if (valueType == Double.TYPE || valueType == java.lang.Double.class) {
            value = new Double(value.toString());
        } else if (valueType == Float.TYPE || valueType == java.lang.Float.class) {
            value = new Float(value.toString());
        } else if (valueType == Integer.TYPE || valueType == java.lang.Integer.class) {
            value = new Integer(value.toString());
        } else if (valueType == Character.TYPE || valueType == java.lang.Character.class) {
            value = new Character(value.toString().charAt(0));
        } else if (valueType == Short.TYPE || valueType == java.lang.Short.class) {
            value = new Short(value.toString());
        } else if (valueType == Long.TYPE || valueType == java.lang.Long.class) {
            value = new Long(value.toString());
        } else if (valueType == String.class) {
        } else if (!valueType.isAssignableFrom(value.getClass())) {
            throw new FacesException(
                    Util.getExceptionMessageString(Util.MANAGED_BEAN_TYPE_CONVERSION_ERROR_ID, new Object[] {
                            value.toString(), value.getClass(), valueType, managedBean.getManagedBeanName() }));

        }//from w  w w  .  j  ava 2 s .  co m
    }
    return value;
}

From source file:alice.tuprolog.lib.OOLibrary.java

/**
 * get the value of the field//  ww w  .  j ava  2s  . com
 */
private boolean java_get(PTerm objId, PTerm fieldTerm, PTerm what) {
    if (!fieldTerm.isAtom()) {
        return false;
    }
    String fieldName = ((Struct) fieldTerm).getName();
    Object obj = null;
    try {
        Class<?> cl = null;
        if (objId.isCompound() && ((Struct) objId).getName().equals("class")) {
            String clName = null;
            if (((Struct) objId).getArity() == 1)
                clName = alice.util.Tools.removeApices(((Struct) objId).getArg(0).toString());
            if (clName != null) {
                try {
                    cl = Class.forName(clName, true, dynamicLoader);
                } catch (ClassNotFoundException ex) {
                    getEngine().logger.warn("Java class not found: " + clName);
                    return false;
                } catch (Exception ex) {
                    getEngine().logger.warn("Static field " + fieldName + " not found in class "
                            + alice.util.Tools.removeApices(((Struct) objId).getArg(0).toString()));
                    return false;
                }
            }
        } else {
            String objName = alice.util.Tools.removeApices(objId.toString());
            obj = currentObjects.get(objName);
            if (obj == null) {
                return false;
            }
            cl = obj.getClass();
        }

        Field field = cl.getField(fieldName);
        Class<?> fc = field.getType();
        field.setAccessible(true);
        if (fc.equals(Integer.TYPE) || fc.equals(Byte.TYPE)) {
            int value = field.getInt(obj);
            return unify(what, new alice.tuprolog.Int(value));
        } else if (fc.equals(java.lang.Long.TYPE)) {
            long value = field.getLong(obj);
            return unify(what, new alice.tuprolog.Long(value));
        } else if (fc.equals(java.lang.Float.TYPE)) {
            float value = field.getFloat(obj);
            return unify(what, new alice.tuprolog.Float(value));
        } else if (fc.equals(java.lang.Double.TYPE)) {
            double value = field.getDouble(obj);
            return unify(what, new alice.tuprolog.Double(value));
        } else {
            // the field value is an object
            Object res = field.get(obj);
            return bindDynamicObject(what, res);
        }

    } catch (NoSuchFieldException ex) {
        getEngine().logger.warn("Field " + fieldName + " not found in class " + objId);
        return false;
    } catch (Exception ex) {
        getEngine().logger.warn("Generic error in accessing the field");
        return false;
    }
}

From source file:org.apache.tez.runtime.LogicalIOProcessorRuntimeTask.java

private LogicalOutput createOutput(OutputSpec outputSpec, OutputContext outputContext) throws TezException {
    OutputDescriptor outputDesc = outputSpec.getOutputDescriptor();
    Output output = ReflectionUtils.createClazzInstance(outputDesc.getClassName(),
            new Class[] { OutputContext.class, Integer.TYPE },
            new Object[] { outputContext, outputSpec.getPhysicalEdgeCount() });

    if (!(output instanceof LogicalOutput)) {
        throw new TezUncheckedException(output.getClass().getName() + " is not a sub-type of LogicalOutput."
                + " Only LogicalOutput sub-types supported by LogicalIOProcessor.");
    }//www. j  a  va 2  s.  c  om
    return (LogicalOutput) output;
}

From source file:org.eclipse.jubula.rc.swt.utils.SwtUtils.java

/**
 * GTK-specific method for getting the bounds of a component. This method
 * is only for GTK.//  w  ww.j ava  2s .  c  o m
 * @param handle    The handle of the component to get the bounds for.
 * @param bounds    The bounds will be written to this rectangle since there
 *                  is no return value.
 */
static void gtkgetBounds(int handle, Rectangle bounds) throws Exception {

    Class clazz = Class.forName("org.eclipse.swt.internal.gtk.OS"); //$NON-NLS-1$
    Class[] params = new Class[] { Integer.TYPE };
    Object[] args = new Object[] { new Integer(handle) };
    try {
        Method method = clazz.getMethod("gtkWIDGET_X", params); //$NON-NLS-1$
        bounds.x = ((Integer) method.invoke(clazz, args)).intValue();
        method = clazz.getMethod("gtkWIDGET_Y", params); //$NON-NLS-1$
        bounds.y = ((Integer) method.invoke(clazz, args)).intValue();
        method = clazz.getMethod("gtkWIDGET_WIDTH", params); //$NON-NLS-1$
        bounds.width = ((Integer) method.invoke(clazz, args)).intValue();
        method = clazz.getMethod("gtkWIDGET_HEIGHT", params); //$NON-NLS-1$
        bounds.height = ((Integer) method.invoke(clazz, args)).intValue();
    } catch (NoSuchMethodException nsme) {
        Method method = clazz.getMethod("GTK_WIDGET_X", params); //$NON-NLS-1$
        bounds.x = ((Integer) method.invoke(clazz, args)).intValue();
        method = clazz.getMethod("GTK_WIDGET_Y", params); //$NON-NLS-1$
        bounds.y = ((Integer) method.invoke(clazz, args)).intValue();
        method = clazz.getMethod("GTK_WIDGET_WIDTH", params); //$NON-NLS-1$
        bounds.width = ((Integer) method.invoke(clazz, args)).intValue();
        method = clazz.getMethod("GTK_WIDGET_HEIGHT", params); //$NON-NLS-1$
        bounds.height = ((Integer) method.invoke(clazz, args)).intValue();

    }
}

From source file:javadz.beanutils.LazyDynaBean.java

/**
 * Is an object of the source class assignable to the destination class?
 *
 * @param dest Destination class/*  w ww .  java 2s . com*/
 * @param source Source class
 * @return <code>true<code> if the source class is assignable to the
 * destination class, otherwise <code>false</code>
 */
protected boolean isAssignable(Class dest, Class source) {

    if (dest.isAssignableFrom(source) || ((dest == Boolean.TYPE) && (source == Boolean.class))
            || ((dest == Byte.TYPE) && (source == Byte.class))
            || ((dest == Character.TYPE) && (source == Character.class))
            || ((dest == Double.TYPE) && (source == Double.class))
            || ((dest == Float.TYPE) && (source == Float.class))
            || ((dest == Integer.TYPE) && (source == Integer.class))
            || ((dest == Long.TYPE) && (source == Long.class))
            || ((dest == Short.TYPE) && (source == Short.class))) {
        return (true);
    } else {
        return (false);
    }

}

From source file:org.evosuite.testcase.statements.FunctionalMockStatement.java

@Override
public Throwable execute(Scope scope, PrintStream out) throws InvocationTargetException,
        IllegalArgumentException, IllegalAccessException, InstantiationException {

    Throwable exceptionThrown = null;

    try {//from   w  ww.  ja v a  2 s . c  om
        return super.exceptionHandler(new Executer() {

            @Override
            public void execute() throws InvocationTargetException, IllegalArgumentException,
                    IllegalAccessException, InstantiationException, CodeUnderTestException {

                // First create the listener
                listener = new EvoInvocationListener(retval.getType());

                //then create the mock
                Object ret;
                try {
                    logger.debug("Mockito: create mock for {}", targetClass);

                    ret = mock(targetClass, withSettings().invocationListeners(listener));
                    //ret = mockCreator.invoke(null,targetClass,withSettings().invocationListeners(listener));

                    //execute all "when" statements
                    int index = 0;

                    logger.debug("Mockito: going to mock {} different methods", mockedMethods.size());
                    for (MethodDescriptor md : mockedMethods) {

                        if (!md.shouldBeMocked()) {
                            //no need to mock a method that returns void
                            logger.debug("Mockito: method {} cannot be mocked", md.getMethodName());
                            continue;
                        }

                        Method method = md.getMethod(); //target method, eg foo.aMethod(...)

                        // this is needed if method is protected: it couldn't be called here, although fine in
                        // the generated JUnit tests
                        method.setAccessible(true);

                        //target inputs
                        Object[] targetInputs = new Object[md.getNumberOfInputParameters()];
                        for (int i = 0; i < targetInputs.length; i++) {
                            logger.debug("Mockito: executing matcher {}/{}", (1 + i), targetInputs.length);
                            targetInputs[i] = md.executeMatcher(i);
                        }

                        logger.debug("Mockito: going to invoke method {} with {} matchers", method.getName(),
                                targetInputs.length);

                        if (!method.getDeclaringClass().isAssignableFrom(ret.getClass())) {

                            String msg = "Mismatch between callee's class " + ret.getClass()
                                    + " and method's class " + method.getDeclaringClass();
                            msg += "\nTarget class classloader " + targetClass.getClassLoader()
                                    + " vs method's classloader " + method.getDeclaringClass().getClassLoader();
                            throw new EvosuiteError(msg);
                        }

                        //actual call foo.aMethod(...)
                        Object targetMethodResult;

                        try {
                            if (targetInputs.length == 0) {
                                targetMethodResult = method.invoke(ret);
                            } else {
                                targetMethodResult = method.invoke(ret, targetInputs);
                            }
                        } catch (InvocationTargetException e) {
                            logger.error(
                                    "Invocation of mocked {}.{}() threw an exception. "
                                            + "This means the method was not mocked",
                                    targetClass.getName(), method.getName());
                            throw e;
                        } catch (IllegalArgumentException e) {
                            logger.error("IAE on <" + method + "> when called with "
                                    + Arrays.toString(targetInputs));
                            throw e;
                        }

                        //when(...)
                        logger.debug("Mockito: call 'when'");
                        OngoingStubbing<Object> retForThen = Mockito.when(targetMethodResult);

                        //thenReturn(...)
                        Object[] thenReturnInputs = null;
                        try {
                            int size = Math.min(md.getCounter(), Properties.FUNCTIONAL_MOCKING_INPUT_LIMIT);

                            thenReturnInputs = new Object[size];

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

                                int k = i + index; //the position in flat parameter list
                                if (k >= parameters.size()) {
                                    throw new RuntimeException(
                                            "EvoSuite ERROR: index " + k + " out of " + parameters.size());
                                }

                                VariableReference parameterVar = parameters.get(i + index);
                                thenReturnInputs[i] = parameterVar.getObject(scope);

                                CodeUnderTestException codeUnderTestException = null;

                                if (thenReturnInputs[i] == null && method.getReturnType().isPrimitive()) {
                                    codeUnderTestException = new CodeUnderTestException(
                                            new NullPointerException());

                                } else if (thenReturnInputs[i] != null && !TypeUtils
                                        .isAssignable(thenReturnInputs[i].getClass(), method.getReturnType())) {
                                    codeUnderTestException = new CodeUnderTestException(
                                            new UncompilableCodeException(
                                                    "Cannot assign " + parameterVar.getVariableClass().getName()
                                                            + " to " + method.getReturnType()));
                                }

                                if (codeUnderTestException != null) {
                                    throw codeUnderTestException;
                                }

                                thenReturnInputs[i] = fixBoxing(thenReturnInputs[i], method.getReturnType());
                            }
                        } catch (Exception e) {
                            //be sure "then" is always called after a "when", otherwise Mockito might end up in
                            //a inconsistent state
                            retForThen
                                    .thenThrow(new RuntimeException("Failed to setup mock: " + e.getMessage()));
                            throw e;
                        }

                        //final call when(...).thenReturn(...)
                        logger.debug("Mockito: executing 'thenReturn'");
                        if (thenReturnInputs == null || thenReturnInputs.length == 0) {
                            retForThen.thenThrow(new RuntimeException("No valid return value"));
                        } else if (thenReturnInputs.length == 1) {
                            retForThen.thenReturn(thenReturnInputs[0]);
                        } else {
                            Object[] values = Arrays.copyOfRange(thenReturnInputs, 1, thenReturnInputs.length);
                            retForThen.thenReturn(thenReturnInputs[0], values);
                        }

                        index += thenReturnInputs == null ? 0 : thenReturnInputs.length;
                    }

                } catch (CodeUnderTestException e) {
                    throw e;
                } catch (java.lang.NoClassDefFoundError e) {
                    AtMostOnceLogger.error(logger, "Cannot use Mockito on " + targetClass
                            + " due to failed class initialization: " + e.getMessage());
                    return; //or should throw an exception?
                } catch (Throwable t) {
                    AtMostOnceLogger.error(logger,
                            "Failed to use Mockito on " + targetClass + ": " + t.getMessage());
                    throw new EvosuiteError(t);
                }

                //finally, activate the listener
                listener.activate();

                try {
                    retval.setObject(scope, ret);
                } catch (CodeUnderTestException e) {
                    throw e;
                } catch (Throwable e) {
                    throw new EvosuiteError(e);
                }
            }

            /**
             * a "char" can be used for a "int". But problem is that Mockito takes as input
             * Object, and so those get boxed. However, a Character cannot be used for a "int",
             * so we need to be sure to convert it here
             *
             * @param value
             * @param expectedType
             * @return
             */
            private Object fixBoxing(Object value, Class<?> expectedType) {

                if (!expectedType.isPrimitive()) {
                    return value;
                }

                Class<?> valuesClass = value.getClass();
                assert !valuesClass.isPrimitive();

                if (expectedType.equals(Integer.TYPE)) {
                    if (valuesClass.equals(Character.class)) {
                        value = (int) ((Character) value).charValue();
                    } else if (valuesClass.equals(Byte.class)) {
                        value = (int) ((Byte) value).intValue();
                    } else if (valuesClass.equals(Short.class)) {
                        value = (int) ((Short) value).intValue();
                    }
                }

                if (expectedType.equals(Double.TYPE)) {
                    if (valuesClass.equals(Integer.class)) {
                        value = (double) ((Integer) value).intValue();
                    } else if (valuesClass.equals(Byte.class)) {
                        value = (double) ((Byte) value).intValue();
                    } else if (valuesClass.equals(Character.class)) {
                        value = (double) ((Character) value).charValue();
                    } else if (valuesClass.equals(Short.class)) {
                        value = (double) ((Short) value).intValue();
                    } else if (valuesClass.equals(Long.class)) {
                        value = (double) ((Long) value).longValue();
                    } else if (valuesClass.equals(Float.class)) {
                        value = (double) ((Float) value).floatValue();
                    }
                }

                if (expectedType.equals(Float.TYPE)) {
                    if (valuesClass.equals(Integer.class)) {
                        value = (float) ((Integer) value).intValue();
                    } else if (valuesClass.equals(Byte.class)) {
                        value = (float) ((Byte) value).intValue();
                    } else if (valuesClass.equals(Character.class)) {
                        value = (float) ((Character) value).charValue();
                    } else if (valuesClass.equals(Short.class)) {
                        value = (float) ((Short) value).intValue();
                    } else if (valuesClass.equals(Long.class)) {
                        value = (float) ((Long) value).longValue();
                    }
                }

                if (expectedType.equals(Long.TYPE)) {
                    if (valuesClass.equals(Integer.class)) {
                        value = (long) ((Integer) value).intValue();
                    } else if (valuesClass.equals(Byte.class)) {
                        value = (long) ((Byte) value).intValue();
                    } else if (valuesClass.equals(Character.class)) {
                        value = (long) ((Character) value).charValue();
                    } else if (valuesClass.equals(Short.class)) {
                        value = (long) ((Short) value).intValue();
                    }
                }

                return value;
            }

            @Override
            public Set<Class<? extends Throwable>> throwableExceptions() {
                Set<Class<? extends Throwable>> t = new LinkedHashSet<>();
                t.add(InvocationTargetException.class);
                return t;
            }
        });

    } catch (InvocationTargetException e) {
        exceptionThrown = e.getCause();
    }
    return exceptionThrown;
}