diff --git a/src/java.base/share/classes/java/lang/invoke/TypeConvertingMethodAdapter.java b/src/java.base/share/classes/java/lang/invoke/TypeConvertingMethodAdapter.java
index e35271dc8b42c..7a1419f03b109 100644
--- a/src/java.base/share/classes/java/lang/invoke/TypeConvertingMethodAdapter.java
+++ b/src/java.base/share/classes/java/lang/invoke/TypeConvertingMethodAdapter.java
@@ -69,14 +69,14 @@ private static MethodRefEntry unbox(ClassDesc owner, String methodName, ClassDes
     }
 
     private static TypeKind primitiveTypeKindFromClass(Class<?> type) {
-        if (type == int.class)     return TypeKind.IntType;
-        if (type == long.class)    return TypeKind.LongType;
-        if (type == boolean.class) return TypeKind.BooleanType;
-        if (type == short.class)   return TypeKind.ShortType;
-        if (type == byte.class)    return TypeKind.ByteType;
-        if (type == char.class)    return TypeKind.CharType;
-        if (type == float.class)   return TypeKind.FloatType;
-        if (type == double.class)  return TypeKind.DoubleType;
+        if (type == Integer.class)   return TypeKind.IntType;
+        if (type == Long.class)      return TypeKind.LongType;
+        if (type == Boolean.class)   return TypeKind.BooleanType;
+        if (type == Short.class)     return TypeKind.ShortType;
+        if (type == Byte.class)      return TypeKind.ByteType;
+        if (type == Character.class) return TypeKind.CharType;
+        if (type == Float.class)     return TypeKind.FloatType;
+        if (type == Double.class)    return TypeKind.DoubleType;
         return null;
     }
 
diff --git a/test/jdk/java/lang/invoke/TypeConvertingTest.java b/test/jdk/java/lang/invoke/TypeConvertingTest.java
new file mode 100644
index 0000000000000..1df6e007880d1
--- /dev/null
+++ b/test/jdk/java/lang/invoke/TypeConvertingTest.java
@@ -0,0 +1,798 @@
+/*
+ * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+/* @test
+ * @bug 8335060
+ * @summary unit tests of TypeConvertingMethodAdapter
+ * @run junit TypeConvertingTest
+ */
+public class TypeConvertingTest {
+
+    static void smallBooleanC(boolean b) {
+        assertTrue(b);
+    }
+
+    static void bigBooleanC(Boolean b) {
+        assertTrue(b);
+    }
+
+    static void smallByteC(byte b) {
+        assertEquals(1, b);
+    }
+
+    static void bigByteC(Byte b) {
+        assertEquals((byte)1, b);
+    }
+
+    static void smallShortC(short s) {
+        assertEquals(1, s);
+    }
+
+    static void bigShortC(Short s) {
+        assertEquals((short)1, s);
+    }
+
+    static void smallCharC(char c) {
+        assertEquals(1, c);
+    }
+
+    static void bigCharC(Character c) {
+        assertEquals((char)1, c);
+    }
+
+    static void smallIntC(int i) {
+        assertEquals(1, i);
+    }
+
+    static void bigIntC(Integer i) {
+        assertEquals(1, i);
+    }
+
+    static void smallLongC(long l) {
+        assertEquals(1, l);
+    }
+
+    static void bigLongC(Long l) {
+        assertEquals(1, l);
+    }
+
+    static void smallFloatC(float f) {
+        assertEquals(1.0f, f);
+    }
+
+    static void bigFloatC(Float f) {
+        assertEquals(1.0f, f);
+    }
+
+    static void smallDoubleC(double d) {
+        assertEquals(1.0, d);
+    }
+
+    static void bigDoubleC(Double d) {
+        assertEquals(1.0, d);
+    }
+
+    static void numberC(Number n) {
+        assertEquals(1, n.intValue());
+    }
+
+
+    static boolean smallBooleanS() {return true;}
+
+    static Boolean bigBooleanS() {return true;}
+
+    static byte smallByteS() {return 1;}
+
+    static Byte bigByteS() {return 1;}
+
+    static short smallShortS() {return 1;}
+
+    static Short bigShortS() {return 1;}
+
+    static char smallCharS() {return 1;}
+
+    static Character bigCharS() {return 1;}
+
+    static int smallIntS() {return 1;}
+
+    static Integer bigIntS() {return 1;}
+
+    static long smallLongS() {return 1;}
+
+    static Long bigLongS() {return 1l;}
+
+    static float smallFloatS() {return 1;}
+
+    static Float bigFloatS() {return 1f;}
+
+    static double smallDoubleS() {return 1;}
+
+    static Double bigDoubleS() {return 1d;}
+
+    static Number numberS() {return 1;}
+
+
+    interface GenericC<T> {
+        void m(T t);
+    }
+
+    interface SmallBooleanC {
+        void m(boolean b);
+    }
+
+    interface BigBooleanC {
+        void m(Boolean b);
+    }
+
+    interface SmallByteC {
+        void m(byte b);
+    }
+
+    interface BigByteC {
+        void m(Byte b);
+    }
+
+    interface SmallShortC {
+        void m(short s);
+    }
+
+    interface BigShortC {
+        void m(Short s);
+    }
+
+    interface SmallCharC {
+        void m(char c);
+    }
+
+    interface BigCharC {
+        void m(Character c);
+    }
+
+    interface SmallIntC {
+        void m(int i);
+    }
+
+    interface BigIntC {
+        void m(Integer i);
+    }
+
+    interface SmallLongC {
+        void m(long l);
+    }
+
+    interface BigLongC {
+        void m(Long l);
+    }
+
+    interface SmallFloatC {
+        void m(float f);
+    }
+
+    interface BigFloatC {
+        void m(Float f);
+    }
+
+    interface SmallDoubleC {
+        void m(double d);
+    }
+
+    interface BigDoubleC {
+        void m(Double d);
+    }
+
+    interface BigNumberC {
+        void m(Number n);
+    }
+
+
+    interface GenericS<T> {
+        T m();
+    }
+
+    interface SmallBooleanS {
+        boolean m();
+    }
+
+    interface BigBooleanS {
+        Boolean m();
+    }
+
+    interface SmallByteS {
+        byte m();
+    }
+
+    interface BigByteS {
+        Byte m();
+    }
+
+    interface SmallShortS {
+        short m();
+    }
+
+    interface BigShortS {
+        Short m();
+    }
+
+    interface SmallCharS {
+        char m();
+    }
+
+    interface BigCharS {
+        Character m();
+    }
+
+    interface SmallIntS {
+        int m();
+    }
+
+    interface BigIntS {
+        Integer m();
+    }
+
+    interface SmallLongS {
+        long m();
+    }
+
+    interface BigLongS {
+        Long m();
+    }
+
+    interface SmallFloatS {
+        float m();
+    }
+
+    interface BigFloatS {
+        Float m();
+    }
+
+    interface SmallDoubleS {
+        double m();
+    }
+
+    interface BigDoubleS {
+        Double m();
+    }
+
+    interface BigNumberS {
+        Number m();
+    }
+
+
+    static void testGenericBoolean(GenericC<Boolean> t) {
+        t.m(true);
+    }
+
+    static void testGenericByte(GenericC<Byte> t) {
+        t.m((byte)1);
+    }
+
+    static void testGenericShort(GenericC<Short> t) {
+        t.m((short)1);
+    }
+
+    static void testGenericChar(GenericC<Character> t) {
+        t.m((char)1);
+    }
+
+    static void testGenericInt(GenericC<Integer> t) {
+        t.m(1);
+    }
+
+    static void testGenericLong(GenericC<Long> t) {
+        t.m(1l);
+    }
+
+    static void testGenericFloat(GenericC<Float> t) {
+        t.m(1.0f);
+    }
+
+    static void testGenericDouble(GenericC<Double> t) {
+        t.m(1.0d);
+    }
+
+    static void testGenericNumber(GenericC<Number> t) {
+        t.m(1);
+    }
+
+    static void testSmallBoolean(SmallBooleanC t) {
+        t.m(true);
+    }
+
+    static void testSmallByte(SmallByteC t) {
+        t.m((byte)1);
+    }
+
+    static void testSmallShort(SmallShortC t) {
+        t.m((short)1);
+    }
+
+    static void testSmallChar(SmallCharC t) {
+        t.m((char)1);
+    }
+
+    static void testSmallInt(SmallIntC t) {
+        t.m(1);
+    }
+
+    static void testSmallLong(SmallLongC t) {
+        t.m(1l);
+    }
+
+    static void testSmallFloat(SmallFloatC t) {
+        t.m(1.0f);
+    }
+
+    static void testSmallDouble(SmallDoubleC t) {
+        t.m(1.0d);
+    }
+
+    static void testBigBoolean(BigBooleanC t) {
+        t.m(true);
+    }
+
+    static void testBigByte(BigByteC t) {
+        t.m((byte)1);
+    }
+
+    static void testBigShort(BigShortC t) {
+        t.m((short)1);
+    }
+
+    static void testBigChar(BigCharC t) {
+        t.m((char)1);
+    }
+
+    static void testBigInt(BigIntC t) {
+        t.m(1);
+    }
+
+    static void testBigLong(BigLongC t) {
+        t.m(1l);
+    }
+
+    static void testBigFloat(BigFloatC t) {
+        t.m(1.0f);
+    }
+
+    static void testBigDouble(BigDoubleC t) {
+        t.m(1.0d);
+    }
+
+    static void testBigNumber(BigNumberC t) {
+        t.m(1);
+    }
+
+
+    static void testGenericBoolean(GenericS<Boolean> t) {
+        assertEquals(true, t.m());
+    }
+
+    static void testGenericByte(GenericS<Byte> t) {
+        assertEquals((byte)1, t.m());
+    }
+
+    static void testGenericShort(GenericS<Short> t) {
+        assertEquals((short)1, t.m());
+    }
+
+    static void testGenericChar(GenericS<Character> t) {
+        assertEquals((char)1, t.m());
+    }
+
+    static void testGenericInt(GenericS<Integer> t) {
+        assertEquals(1, t.m());
+    }
+
+    static void testGenericLong(GenericS<Long> t) {
+        assertEquals(1, t.m());
+    }
+
+    static void testGenericFloat(GenericS<Float> t) {
+        assertEquals(1.0f, t.m());
+    }
+
+    static void testGenericDouble(GenericS<Double> t) {
+        assertEquals(1.0d, t.m());
+    }
+
+    static void testGenericNumber(GenericS<Number> t) {
+        assertEquals(1, t.m().intValue());
+    }
+
+    static void testSmallBoolean(SmallBooleanS t) {
+        assertEquals(true, t.m());
+    }
+
+    static void testSmallByte(SmallByteS t) {
+        assertEquals(1, t.m());
+    }
+
+    static void testSmallShort(SmallShortS t) {
+        assertEquals(1, t.m());
+    }
+
+    static void testSmallChar(SmallCharS t) {
+        assertEquals(1, t.m());
+    }
+
+    static void testSmallInt(SmallIntS t) {
+        assertEquals(1, t.m());
+    }
+
+    static void testSmallLong(SmallLongS t) {
+        assertEquals(1, t.m());
+    }
+
+    static void testSmallFloat(SmallFloatS t) {
+        assertEquals(1.0f, t.m());
+    }
+
+    static void testSmallDouble(SmallDoubleS t) {
+        assertEquals(1.0d, t.m());
+    }
+
+    static void testBigBoolean(BigBooleanS t) {
+        assertEquals(true, t.m());
+    }
+
+    static void testBigByte(BigByteS t) {
+        assertEquals((byte)1, t.m());
+    }
+
+    static void testBigShort(BigShortS t) {
+        assertEquals((short)1, t.m());
+    }
+
+    static void testBigChar(BigCharS t) {
+        assertEquals((char)1, t.m());
+    }
+
+    static void testBigInt(BigIntS t) {
+        assertEquals(1, t.m());
+    }
+
+    static void testBigLong(BigLongS t) {
+        assertEquals(1, t.m());
+    }
+
+    static void testBigFloat(BigFloatS t) {
+        assertEquals(1.0f, t.m());
+    }
+
+    static void testBigDouble(BigDoubleS t) {
+        assertEquals(1.0f, t.m());
+    }
+
+    static void testBigNumber(BigNumberS t) {
+        assertEquals(1, t.m().intValue());
+    }
+
+
+    @Test
+    void testGenericBoolean() {
+        testGenericBoolean(TypeConvertingTest::smallBooleanC);
+        testGenericBoolean(TypeConvertingTest::bigBooleanC);
+
+        testGenericBoolean(TypeConvertingTest::smallBooleanS);
+        testGenericBoolean(TypeConvertingTest::bigBooleanS);
+    }
+
+    @Test
+    void testGenericByte() {
+        testGenericByte(TypeConvertingTest::smallByteC);
+        testGenericByte(TypeConvertingTest::bigByteC);
+        testGenericByte(TypeConvertingTest::smallShortC);
+        testGenericByte(TypeConvertingTest::smallIntC);
+        testGenericByte(TypeConvertingTest::smallLongC);
+        testGenericByte(TypeConvertingTest::smallFloatC);
+        testGenericByte(TypeConvertingTest::smallDoubleC);
+        testGenericByte(TypeConvertingTest::numberC);
+
+        testGenericByte(TypeConvertingTest::smallByteS);
+        testGenericByte(TypeConvertingTest::bigByteS);
+    }
+
+    @Test
+    void testGenericShort() {
+        testGenericShort(TypeConvertingTest::smallShortC);
+        testGenericShort(TypeConvertingTest::bigShortC);
+        testGenericShort(TypeConvertingTest::smallIntC);
+        testGenericShort(TypeConvertingTest::smallLongC);
+        testGenericShort(TypeConvertingTest::smallFloatC);
+        testGenericShort(TypeConvertingTest::smallDoubleC);
+        testGenericShort(TypeConvertingTest::numberC);
+
+        testGenericShort(TypeConvertingTest::smallShortS);
+        testGenericShort(TypeConvertingTest::bigShortS);
+    }
+
+    @Test
+    void testGenericChar() {
+        testGenericChar(TypeConvertingTest::smallCharC);
+        testGenericChar(TypeConvertingTest::bigCharC);
+        testGenericChar(TypeConvertingTest::smallIntC);
+        testGenericChar(TypeConvertingTest::smallLongC);
+        testGenericChar(TypeConvertingTest::smallFloatC);
+        testGenericChar(TypeConvertingTest::smallDoubleC);
+
+        testGenericChar(TypeConvertingTest::smallCharS);
+        testGenericChar(TypeConvertingTest::bigCharS);
+    }
+
+    @Test
+    void testGenericInt() {
+        testGenericInt(TypeConvertingTest::smallIntC);
+        testGenericInt(TypeConvertingTest::bigIntC);
+        testGenericInt(TypeConvertingTest::smallLongC);
+        testGenericInt(TypeConvertingTest::smallFloatC);
+        testGenericInt(TypeConvertingTest::smallDoubleC);
+        testGenericInt(TypeConvertingTest::numberC);
+
+        testGenericInt(TypeConvertingTest::smallIntS);
+        testGenericInt(TypeConvertingTest::bigIntS);
+    }
+
+    @Test
+    void testGenericLong() {
+        testGenericLong(TypeConvertingTest::smallLongC);
+        testGenericLong(TypeConvertingTest::bigLongC);
+        testGenericLong(TypeConvertingTest::smallFloatC);
+        testGenericLong(TypeConvertingTest::smallDoubleC);
+        testGenericLong(TypeConvertingTest::numberC);
+
+        testGenericLong(TypeConvertingTest::smallLongS);
+        testGenericLong(TypeConvertingTest::bigLongS);
+    }
+
+    @Test
+    void testGenericFloat() {
+        testGenericFloat(TypeConvertingTest::smallFloatC);
+        testGenericFloat(TypeConvertingTest::bigFloatC);
+        testGenericFloat(TypeConvertingTest::smallDoubleC);
+        testGenericFloat(TypeConvertingTest::numberC);
+
+        testGenericFloat(TypeConvertingTest::smallFloatS);
+        testGenericFloat(TypeConvertingTest::bigFloatS);
+    }
+
+    @Test
+    void testGenericDouble() {
+        testGenericDouble(TypeConvertingTest::smallDoubleC);
+        testGenericDouble(TypeConvertingTest::bigDoubleC);
+        testGenericDouble(TypeConvertingTest::numberC);
+
+        testGenericDouble(TypeConvertingTest::smallDoubleS);
+        testGenericDouble(TypeConvertingTest::bigDoubleS);
+    }
+
+    @Test
+    void testGenericNumber() {
+        testGenericNumber(TypeConvertingTest::numberC);
+
+        testGenericNumber(TypeConvertingTest::numberS);
+    }
+
+    @Test
+    void testSmallBoolean() {
+        testSmallBoolean(TypeConvertingTest::smallBooleanC);
+        testSmallBoolean(TypeConvertingTest::bigBooleanC);
+
+        testSmallBoolean(TypeConvertingTest::smallBooleanS);
+        testSmallBoolean(TypeConvertingTest::bigBooleanS);
+    }
+
+    @Test
+    void testSmallByte() {
+        testSmallByte(TypeConvertingTest::smallByteC);
+        testSmallByte(TypeConvertingTest::bigByteC);
+        testSmallByte(TypeConvertingTest::smallShortC);
+        testSmallByte(TypeConvertingTest::smallIntC);
+        testSmallByte(TypeConvertingTest::smallLongC);
+        testSmallByte(TypeConvertingTest::smallFloatC);
+        testSmallByte(TypeConvertingTest::smallDoubleC);
+        testSmallByte(TypeConvertingTest::numberC);
+
+        testSmallByte(TypeConvertingTest::smallByteS);
+        testSmallByte(TypeConvertingTest::bigByteS);
+    }
+
+    @Test
+    void testSmallShort() {
+        testSmallShort(TypeConvertingTest::smallShortC);
+        testSmallShort(TypeConvertingTest::bigShortC);
+        testSmallShort(TypeConvertingTest::smallIntC);
+        testSmallShort(TypeConvertingTest::smallLongC);
+        testSmallShort(TypeConvertingTest::smallFloatC);
+        testSmallShort(TypeConvertingTest::smallDoubleC);
+        testSmallShort(TypeConvertingTest::numberC);
+
+        testSmallShort(TypeConvertingTest::smallShortS);
+        testSmallShort(TypeConvertingTest::bigShortS);
+    }
+
+    @Test
+    void testSmallChar() {
+        testSmallChar(TypeConvertingTest::smallCharC);
+        testSmallChar(TypeConvertingTest::bigCharC);
+        testSmallChar(TypeConvertingTest::smallIntC);
+        testSmallChar(TypeConvertingTest::smallLongC);
+        testSmallChar(TypeConvertingTest::smallFloatC);
+        testSmallChar(TypeConvertingTest::smallDoubleC);
+
+        testSmallChar(TypeConvertingTest::smallCharS);
+        testSmallChar(TypeConvertingTest::bigCharS);
+    }
+
+    @Test
+    void testSmallInt() {
+        testSmallInt(TypeConvertingTest::smallIntC);
+        testSmallInt(TypeConvertingTest::bigIntC);
+        testSmallInt(TypeConvertingTest::smallLongC);
+        testSmallInt(TypeConvertingTest::smallFloatC);
+        testSmallInt(TypeConvertingTest::smallDoubleC);
+        testSmallInt(TypeConvertingTest::numberC);
+
+        testSmallInt(TypeConvertingTest::smallIntS);
+        testSmallInt(TypeConvertingTest::bigIntS);
+    }
+
+    @Test
+    void testSmallLong() {
+        testSmallLong(TypeConvertingTest::smallLongC);
+        testSmallLong(TypeConvertingTest::bigLongC);
+        testSmallLong(TypeConvertingTest::smallFloatC);
+        testSmallLong(TypeConvertingTest::smallDoubleC);
+        testSmallLong(TypeConvertingTest::numberC);
+
+        testSmallLong(TypeConvertingTest::smallLongS);
+        testSmallLong(TypeConvertingTest::bigLongS);
+    }
+
+    @Test
+    void testSmallFloat() {
+        testSmallFloat(TypeConvertingTest::smallFloatC);
+        testSmallFloat(TypeConvertingTest::bigFloatC);
+        testSmallFloat(TypeConvertingTest::smallDoubleC);
+        testSmallFloat(TypeConvertingTest::numberC);
+
+        testSmallFloat(TypeConvertingTest::smallFloatS);
+        testSmallFloat(TypeConvertingTest::bigFloatS);
+    }
+
+    @Test
+    void testSmallDouble() {
+        testSmallDouble(TypeConvertingTest::smallDoubleC);
+        testSmallDouble(TypeConvertingTest::bigDoubleC);
+        testSmallDouble(TypeConvertingTest::numberC);
+
+        testSmallDouble(TypeConvertingTest::smallDoubleS);
+        testSmallDouble(TypeConvertingTest::bigDoubleS);
+    }
+
+    @Test
+    void testBigBoolean() {
+        testBigBoolean(TypeConvertingTest::smallBooleanC);
+        testBigBoolean(TypeConvertingTest::bigBooleanC);
+
+        testBigBoolean(TypeConvertingTest::smallBooleanS);
+        testBigBoolean(TypeConvertingTest::bigBooleanS);
+    }
+
+    @Test
+    void testBigByte() {
+        testBigByte(TypeConvertingTest::smallByteC);
+        testBigByte(TypeConvertingTest::bigByteC);
+        testBigByte(TypeConvertingTest::smallShortC);
+        testBigByte(TypeConvertingTest::smallIntC);
+        testBigByte(TypeConvertingTest::smallLongC);
+        testBigByte(TypeConvertingTest::smallFloatC);
+        testBigByte(TypeConvertingTest::smallDoubleC);
+        testBigByte(TypeConvertingTest::numberC);
+
+        testBigByte(TypeConvertingTest::smallByteS);
+        testBigByte(TypeConvertingTest::bigByteS);
+    }
+
+    @Test
+    void testBigShort() {
+        testBigShort(TypeConvertingTest::smallShortC);
+        testBigShort(TypeConvertingTest::bigShortC);
+        testBigShort(TypeConvertingTest::smallIntC);
+        testBigShort(TypeConvertingTest::smallLongC);
+        testBigShort(TypeConvertingTest::smallFloatC);
+        testBigShort(TypeConvertingTest::smallDoubleC);
+        testBigShort(TypeConvertingTest::numberC);
+
+        testBigShort(TypeConvertingTest::smallShortS);
+        testBigShort(TypeConvertingTest::bigShortS);
+    }
+
+    @Test
+    void testBigChar() {
+        testBigChar(TypeConvertingTest::smallCharC);
+        testBigChar(TypeConvertingTest::bigCharC);
+        testBigChar(TypeConvertingTest::smallIntC);
+        testBigChar(TypeConvertingTest::smallLongC);
+        testBigChar(TypeConvertingTest::smallFloatC);
+        testBigChar(TypeConvertingTest::smallDoubleC);
+
+        testBigChar(TypeConvertingTest::smallCharS);
+        testBigChar(TypeConvertingTest::bigCharS);
+    }
+
+    @Test
+    void testBigInt() {
+        testBigInt(TypeConvertingTest::smallIntC);
+        testBigInt(TypeConvertingTest::bigIntC);
+        testBigInt(TypeConvertingTest::smallLongC);
+        testBigInt(TypeConvertingTest::smallFloatC);
+        testBigInt(TypeConvertingTest::smallDoubleC);
+        testBigInt(TypeConvertingTest::numberC);
+
+        testBigInt(TypeConvertingTest::smallIntS);
+        testBigInt(TypeConvertingTest::bigIntS);
+    }
+
+    @Test
+    void testBigLong() {
+        testBigLong(TypeConvertingTest::smallLongC);
+        testBigLong(TypeConvertingTest::bigLongC);
+        testBigLong(TypeConvertingTest::smallFloatC);
+        testBigLong(TypeConvertingTest::smallDoubleC);
+        testBigLong(TypeConvertingTest::numberC);
+
+        testBigLong(TypeConvertingTest::smallLongS);
+        testBigLong(TypeConvertingTest::bigLongS);
+    }
+
+    @Test
+    void testBigFloat() {
+        testBigFloat(TypeConvertingTest::smallFloatC);
+        testBigFloat(TypeConvertingTest::bigFloatC);
+        testBigFloat(TypeConvertingTest::smallDoubleC);
+        testBigFloat(TypeConvertingTest::numberC);
+
+        testBigFloat(TypeConvertingTest::smallFloatS);
+        testBigFloat(TypeConvertingTest::bigFloatS);
+    }
+
+    @Test
+    void testBigDouble() {
+        testBigDouble(TypeConvertingTest::smallDoubleC);
+        testBigDouble(TypeConvertingTest::bigDoubleC);
+        testBigDouble(TypeConvertingTest::numberC);
+
+        testBigDouble(TypeConvertingTest::smallDoubleS);
+        testBigDouble(TypeConvertingTest::bigDoubleS);
+    }
+
+    @Test
+    void testBigNumber() {
+        testBigNumber(TypeConvertingTest::numberC);
+
+        testBigNumber(TypeConvertingTest::numberS);
+    }
+}