isBoolean -> "false"
                isUnit -> "Unit"
                isString -> "\"\""
                isUInt -> "0.toUInt()"
                isULong -> "0.toULong()"
                isUShort -> "0.toUShort()"
                isUByte -> "0.toUByte()"
                else -> null
            }
        }
}

public typealias KtTypeInfoProviderMixIn = KaTypeInfoProviderMixIn

            type.isShort -> KaConstantValue.KaShortConstantValue((value as Number).toShort(), expression)
            type.isUShort -> KaConstantValue.KaUnsignedShortConstantValue((value as Number).toShort().toUShort(), expression)
            type.isInt -> KaConstantValue.KaIntConstantValue((value as Number).toInt(), expression)

            ConstantValueKind.Long -> (value as Number).toLong()
            ConstantValueKind.Short -> (value as Number).toShort()
            ConstantValueKind.UnsignedByte -> (value as Number).toLong().toUByte()
            ConstantValueKind.UnsignedShort -> (value as Number).toLong().toUShort()
            ConstantValueKind.UnsignedInt -> (value as Number).toLong().toUInt()

                        println "prop theLong      : $p.theLong :"
                        println "prop thelong      : $p.thelong :"
                        println "prop theshort     : $p.theshort :"
                        println "prop theShort     : $p.theShort :"
                        println "prop theString    : $p.theString :"
                        println "prop theThing     : $p.theThing :"
                    }
                }

 *
 */
public class ShortConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToShort() throws Exception {
        assertEquals(new Short("1000"), ShortConversionUtil.toShort("1,000"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveShort() throws Exception {
        assertEquals(1000, ShortConversionUtil.toPrimitiveShort("1,000"));
    }

     * @return 変換された{@link Short}
     */
    public static Short toShort(final Object o) {
        return toShort(o, null);
    }

    /**
     * {@link Short}に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @param pattern
     *            パターン文字列
     * @return 変換された{@link Short}
     */
    public static Short toShort(final Object o, final String pattern) {
        if (o == null) {

func main() {
	s := ""
	_ = s
	C.malloc(s) // ERROR HERE

	x := (*C.bar_t)(nil)
	C.foop = x // ERROR HERE

	// issue 13129: used to output error about C.unsignedshort with CC=clang
	var x1 C.ushort
	x1 = int(0) // ERROR HERE: C\.ushort

	// issue 13423
	_ = C.fopen() // ERROR HERE

	// issue 13467
	var x2 rune = '✈'
	var _ rune = C.transform(x2) // ERROR HERE: C\.int

	struct  timeval ifi_lastchange;
};

// This structure is a duplicate of if_msghdr on FreeBSD 8-STABLE.
// See /usr/include/net/if.h.
struct if_msghdr8 {
	u_short ifm_msglen;
	u_char  ifm_version;
	u_char  ifm_type;
	int     ifm_addrs;
	int     ifm_flags;
	u_short ifm_index;
	struct  if_data8 ifm_data;
};
*/
import "C"

// Machine characteristics; for internal use.

const (

        is UByte -> KaConstantValue.KaUnsignedByteConstantValue(value, expression)
        is Short -> KaConstantValue.KaShortConstantValue(value, expression)
        is UShort -> KaConstantValue.KaUnsignedShortConstantValue(value, expression)
        is Int -> KaConstantValue.KaIntConstantValue(value, expression)
        is UInt -> KaConstantValue.KaUnsignedIntConstantValue(value, expression)

            return LongConversionUtil.toLong(o);
        } else if (type == Float.class) {
            return FloatConversionUtil.toFloat(o);
        } else if (type == Short.class) {
            return ShortConversionUtil.toShort(o);
        } else if (type == BigInteger.class) {
            return BigIntegerConversionUtil.toBigInteger(o);
        } else if (type == Byte.class) {
            return ByteConversionUtil.toByte(o);
        }