@Override
@SuppressWarnings({"rawtypes", "unchecked"})
public Options convertValue(String value, Type type)
{
    Type listOfOption = new TypeLiteral<List<Option>>() { }.getType();
    Set options = new HashSet<>(fluentEnumListConverter.convertValue(value, listOfOption));
    if (options.isEmpty())
    {
        return Options.empty();
    }
    Iterator<Option> iterator = options.iterator();
    Options jsonComparisonOptions = new Options(iterator.next());
    while (iterator.hasNext())
    {
        jsonComparisonOptions = jsonComparisonOptions.with(iterator.next());
    }
    return jsonComparisonOptions;
}
 

@Test
@SuppressWarnings("rawtypes")
void testConvertValue()
{
    FluentEnumListConverter fluentEnumListConverter = new FluentEnumListConverter(new FluentTrimmedEnumConverter());
    Type type = new TypeLiteral<List<Option>>() { }.getType();

    assertTrue(fluentEnumListConverter.accept(type));
    List list = fluentEnumListConverter.convertValue("ignoring extra fields, ignoring values", type);
    assertIterableEquals(Arrays.asList(Option.IGNORING_EXTRA_FIELDS, Option.IGNORING_VALUES), list);
}
 

@Test
void shouldConvertToEmptyList()
{
    String value = "  ";
    List<Integer> convertedValue = List.of();
    Type type = new TypeLiteral<List<Integer>>() { }.value;
    when(expressionAdaptor.process(value)).thenReturn(value);
    when(parameterAdaptor.convert(value)).thenReturn(value);
    List<Integer> actual = (List<Integer>) parameterConverters.convert(value, type);
    assertEquals(convertedValue, actual);
    verifyNoInteractions(stepMonitor);
}
 

@Test
void shouldConvertToEmptyOptional()
{
    String value = " ";
    Optional<Integer> convertedValue = Optional.empty();
    Type type = new TypeLiteral<Optional<Integer>>() { }.value;
    when(expressionAdaptor.process(value)).thenReturn(value);
    when(parameterAdaptor.convert(value)).thenReturn(value);
    Optional<Integer> actual = (Optional<Integer>) parameterConverters.convert(value, type);
    assertEquals(convertedValue, actual);
    verifyNoInteractions(stepMonitor);
}
 

@Test
void shouldConvertToNonEmptyOptional()
{
    Integer baseConvertedValue = Integer.valueOf(VALUE);
    Optional<Integer> convertedValue = Optional.of(baseConvertedValue);
    Type type = new TypeLiteral<Optional<Integer>>() { }.value;
    when(expressionAdaptor.process(VALUE)).thenReturn(VALUE);
    when(parameterAdaptor.convert(VALUE)).thenReturn(VALUE);
    Optional<Integer> actual = (Optional<Integer>) parameterConverters.convert(VALUE, type);
    assertEquals(convertedValue, actual);
    verify(stepMonitor).convertedValueOfType(VALUE, Integer.class, baseConvertedValue,
            new LinkedList<>(List.of(NumberConverter.class)));
}
 

@Test
void shouldReturnValueAsIsIfAdaptedValueTypeAssignableFromRequestedType()
{
    Type type = new TypeLiteral<List<Map<String, Object>>>() { }.value;
    List<Map<Object, Object>> adaptedValue = List.of(Map.of());
    when(parameterAdaptor.convert(VALUE)).thenReturn(adaptedValue);
    assertEquals(adaptedValue, parameterConverters.convert(VALUE, type));
    verifyNoInteractions(expressionAdaptor);
}
 

@Test
public void testListSerializer() {
    roundTrip(new TypeLiteral<List<List<String>>>() { }, asList(asList("a", "b"), asList("c", "d")));
    roundTrip(new TypeLiteral<List<List<String>>>() { }, emptyList());
}
 

@Test
public void testWildcardSerializer() {
    roundTrip(new TypeLiteral<List<? extends List<String>>>() { }, asList(emptyList(), asList("", "foo & <bar></bar>")));
    roundTrip(new TypeLiteral<List<? extends List<String>>>() { }, emptyList());
}
 

@Test
public void testNullValue() {
    roundTrip(String.class, null);
    roundTrip(new TypeLiteral<List<? extends List<String>>>() { }, null);
    roundTrip(new TypeLiteral<List<? extends List<String>>>() { }, asList(null, asList(null, "")));
}
 

@Test
public void testListSerializerRegistrarOverride() {

    testRegistrar.register(nullSerializer(), new TypeLiteral<List<List<String>>>() { });

    Serializer<List<List<String>>> serializer =
        testRegistrar.getSerializer(new TypeLiteral<List<List<String>>>() { });

    Element element = serializer.toXml(
        asList(asList("a", "b"), asList("c", "d")),
        dummyElementFactory()
    );

    assertNull(serializer.fromXml(element));

}