public PrimitiveTypeDescription(ResolvedPrimitiveType resolvedPrimitiveType){
    type = resolvedPrimitiveType.describe();
    switch (resolvedPrimitiveType){
        case BYTE:
            value = (byte) 0;
            break;
        case SHORT:
            value = (short) 0;
            break;
        case INT:
            value = 0;
            break;
        case LONG:
            value = 0L;
            break;
        case FLOAT:
            value = 0f;
            break;
        case DOUBLE:
            value = 0d;
            break;
        case CHAR:
            value = (char)0;
            break;
        case BOOLEAN:
            value = false;
            break;
    }
}
 

private boolean isNumberType(ResolvedType type) {
    if (type.isPrimitive()) {
        ResolvedPrimitiveType resolvedPrimitiveType = type.asPrimitive();
        return resolvedPrimitiveType != ResolvedPrimitiveType.BOOLEAN
                && resolvedPrimitiveType != ResolvedPrimitiveType.CHAR;
    } else {
        return isTypeOf(type, Number.class);
    }
}
 

private boolean isBooleanType(ResolvedType type) {
    if (type.isPrimitive()) {
        return type.asPrimitive() == ResolvedPrimitiveType.BOOLEAN;
    } else {
        return isTypeOf(type, Boolean.class);
    }
}
 

private boolean isStringType(ResolvedType type) {
    if (type.isPrimitive()) {
        return type.asPrimitive() == ResolvedPrimitiveType.CHAR;
    } else {
        return isTypeOf(type, String.class, Character.class);
    }
}
 

@Test
public void should_ReturnNotNullableNumberSchema_When_GivenTypeIsAPrimitiveInt() {
    ResolvedType numberType = mockPrimitiveTypeOf(
            ResolvedPrimitiveType.INT);

    Schema schema = schemaResolver.parseResolvedTypeToSchema(numberType);
    Assert.assertTrue(schema instanceof NumberSchema);
    Assert.assertNull(schema.getNullable());
    Assert.assertTrue(schemaResolver.getFoundTypes().isEmpty());
}
 

@Test
public void should_ReturnNotNullableBoolean_When_GivenTypeIsAPrimitiveBoolean() {
    ResolvedType resolvedType = mockPrimitiveTypeOf(
            ResolvedPrimitiveType.BOOLEAN);

    Schema schema = schemaResolver.parseResolvedTypeToSchema(resolvedType);

    Assert.assertTrue(schema instanceof BooleanSchema);
    Assert.assertNull(schema.getNullable());
    Assert.assertTrue(schemaResolver.getFoundTypes().isEmpty());
}
 

private ResolvedType mockPrimitiveTypeOf(
        ResolvedPrimitiveType primitiveType) {
    ResolvedType numberType = mock(ResolvedType.class);

    when(numberType.isPrimitive()).thenReturn(true);
    when(numberType.asPrimitive()).thenReturn(primitiveType);
    return numberType;
}