How to use

valueOf

method

in

org.springframework.core.convert.TypeDescriptor

@Override
public boolean canConvert(@Nullable Class<?> sourceType, Class<?> targetType) {
  Assert.notNull(targetType, "Target type to convert to cannot be null");
  return canConvert((sourceType != null ? TypeDescriptor.valueOf(sourceType) : null),
      TypeDescriptor.valueOf(targetType));
}

/**
 * Returns the websocket message type. By default the type is resolved using
 * the generic arguments of the class.
 */
protected TypeDescriptor getMessageType() {
  return TypeDescriptor.valueOf(resolveTypeArguments()[1]);
}

@Override
@Nullable
public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType, @Nullable Field field)
    throws TypeMismatchException {
  return convertIfNecessary(value, requiredType,
      (field != null ? new TypeDescriptor(field) : TypeDescriptor.valueOf(requiredType)));
}

@Override
@Nullable
public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
  if (source == null) {
    return null;
  }
  Method finder = getFinder(targetType.getType());
  Assert.state(finder != null, "No finder method");
  Object id = this.conversionService.convert(
      source, sourceType, TypeDescriptor.valueOf(finder.getParameterTypes()[0]));
  return ReflectionUtils.invokeMethod(finder, source, id);
}

@Override
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
  Method finder = getFinder(targetType.getType());
  return (finder != null &&
      this.conversionService.canConvert(sourceType, TypeDescriptor.valueOf(finder.getParameterTypes()[0])));
}

@Test
public void dateToStringWithoutGlobalFormat() {
  Date date = new Date();
  Object actual = this.conversionService.convert(date, TypeDescriptor.valueOf(Date.class), TypeDescriptor.valueOf(String.class));
  String expected = date.toString();
  assertEquals(expected, actual);
}

@Test
public void elementTypeForCollectionSubclass() throws Exception {
  @SuppressWarnings("serial")
  class CustomSet extends HashSet<String> {
  }
  assertEquals(TypeDescriptor.valueOf(CustomSet.class).getElementTypeDescriptor(), TypeDescriptor.valueOf(String.class));
  assertEquals(TypeDescriptor.forObject(new CustomSet()).getElementTypeDescriptor(), TypeDescriptor.valueOf(String.class));
}

@Test
public void convertArrayToCollectionGenericTypeConversion() throws Exception {
  @SuppressWarnings("unchecked")
  List<Integer> result = (List<Integer>) conversionService.convert(new String[] {"1", "2", "3"}, TypeDescriptor
      .valueOf(String[].class), new TypeDescriptor(getClass().getDeclaredField("genericList")));
  assertEquals(Integer.valueOf(1), result.get(0));
  assertEquals(Integer.valueOf(2), result.get(1));
  assertEquals(Integer.valueOf(3), result.get(2));
}

@Test(expected = ConversionFailedException.class)
public void parseParserReturnsNull() throws ParseException {
  formattingService.addFormatterForFieldType(Integer.class, new NullReturningFormatter());
  assertNull(formattingService.convert("1", TypeDescriptor.valueOf(String.class), TypeDescriptor.valueOf(Integer.class)));
}

@Test
public void convertCollectionToCollectionNull() throws Exception {
  @SuppressWarnings("unchecked")
  List<Integer> bar = (List<Integer>) conversionService.convert(null,
      TypeDescriptor.valueOf(LinkedHashSet.class), new TypeDescriptor(getClass().getField("genericList")));
  assertNull(bar);
}

@Test
public void parseEmptyString() throws ParseException {
  formattingService.addFormatterForFieldType(Number.class, new NumberStyleFormatter());
  assertNull(formattingService.convert("", TypeDescriptor.valueOf(String.class), TypeDescriptor.valueOf(Integer.class)));
}

@Test
public void parseBlankString() throws ParseException {
  formattingService.addFormatterForFieldType(Number.class, new NumberStyleFormatter());
  assertNull(formattingService.convert("     ", TypeDescriptor.valueOf(String.class), TypeDescriptor.valueOf(Integer.class)));
}

@Test
public void narrow() {
  TypeDescriptor desc = TypeDescriptor.valueOf(Number.class);
  Integer value = Integer.valueOf(3);
  desc = desc.narrow(value);
  assertEquals(Integer.class, desc.getType());
}

@Test
public void testCollectionsEmptyList() throws Exception {
  CollectionToCollectionConverter converter = new CollectionToCollectionConverter(new GenericConversionService());
  TypeDescriptor type = new TypeDescriptor(getClass().getField("list"));
  converter.convert(list, type, TypeDescriptor.valueOf(Class.forName("java.util.Collections$EmptyList")));
}

@Test
public void dateToStringWithFormat() {
  JodaTimeFormatterRegistrar registrar = new JodaTimeFormatterRegistrar();
  registrar.setDateTimeFormatter(org.joda.time.format.DateTimeFormat.shortDateTime());
  setup(registrar);
  Date date = new Date();
  Object actual = this.conversionService.convert(date, TypeDescriptor.valueOf(Date.class), TypeDescriptor.valueOf(String.class));
  String expected = JodaTimeContextHolder.getFormatter(org.joda.time.format.DateTimeFormat.shortDateTime(), Locale.US).print(new DateTime(date));
  assertEquals(expected, actual);
}

@Test
@SuppressWarnings("unchecked")
public void convertObjectToOptional() {
  Method method = ClassUtils.getMethod(TestEntity.class, "handleOptionalValue", Optional.class);
  MethodParameter parameter = new MethodParameter(method, 0);
  TypeDescriptor descriptor = new TypeDescriptor(parameter);
  Object actual = conversionService.convert("1,2,3", TypeDescriptor.valueOf(String.class), descriptor);
  assertEquals(Optional.class, actual.getClass());
  assertEquals(Arrays.asList(1, 2, 3), ((Optional<List<Integer>>) actual).get());
}

@Test
public void dateToStringWithGlobalFormat() {
  DateFormatterRegistrar registrar = new DateFormatterRegistrar();
  registrar.setFormatter(new DateFormatter());
  setup(registrar);
  Date date = new Date();
  Object actual = this.conversionService.convert(date, TypeDescriptor.valueOf(Date.class), TypeDescriptor.valueOf(String.class));
  String expected = new DateFormatter().print(date, Locale.US);
  assertEquals(expected, actual);
}

@Test
public void stringToCollectionCanConvert() throws Exception {
  conversionService.addConverter(new StringToCollectionConverter(conversionService));
  assertTrue(conversionService.canConvert(String.class, Collection.class));
  TypeDescriptor targetType = new TypeDescriptor(getClass().getField("integerCollection"));
  assertFalse(conversionService.canConvert(TypeDescriptor.valueOf(String.class), targetType));
  conversionService.addConverterFactory(new StringToNumberConverterFactory());
  assertTrue(conversionService.canConvert(TypeDescriptor.valueOf(String.class), targetType));
}

@Test
public void emptyListToObject() {
  conversionService.addConverter(new CollectionToObjectConverter(conversionService));
  conversionService.addConverterFactory(new StringToNumberConverterFactory());
  List<String> list = new ArrayList<>();
  TypeDescriptor sourceType = TypeDescriptor.forObject(list);
  TypeDescriptor targetType = TypeDescriptor.valueOf(Integer.class);
  assertTrue(conversionService.canConvert(sourceType, targetType));
  assertNull(conversionService.convert(list, sourceType, targetType));
}

@Test
public void valueOfArray() throws Exception {
  TypeDescriptor typeDescriptor = TypeDescriptor.valueOf(int[].class);
  assertTrue(typeDescriptor.isArray());
  assertFalse(typeDescriptor.isCollection());
  assertFalse(typeDescriptor.isMap());
  assertEquals(Integer.TYPE, typeDescriptor.getElementTypeDescriptor().getType());
}