/** * Create a new {@link ConvertingComparator} that compares {@link java.util.Map.Entry * map entries} based on their {@link java.util.Map.Entry#getValue() values}. * @param comparator the underlying comparator used to compare values * @return a new {@link ConvertingComparator} instance */ public static <K, V> ConvertingComparator<Map.Entry<K, V>, V> mapEntryValues(Comparator<V> comparator) { return new ConvertingComparator<>(comparator, Map.Entry::getValue); }
@Test public void shouldGetMapEntryValues() throws Exception { ArrayList<Entry<String, Integer>> list = createReverseOrderMapEntryList(); Comparator<Map.Entry<String, Integer>> comparator = ConvertingComparator.mapEntryValues(new ComparableComparator<Integer>()); Collections.sort(list, comparator); assertThat(list.get(0).getValue(), is(1)); }
@Test public void shouldGetMapEntryKeys() throws Exception { ArrayList<Entry<String, Integer>> list = createReverseOrderMapEntryList(); Comparator<Map.Entry<String, Integer>> comparator = ConvertingComparator.mapEntryKeys(new ComparableComparator<String>()); Collections.sort(list, comparator); assertThat(list.get(0).getKey(), is("a")); }
/** * Create a new {@link ConvertingComparator} that compares {@link java.util.Map.Entry * map * entries} based on their {@link java.util.Map.Entry#getKey() keys}. * @param comparator the underlying comparator used to compare keys * @return a new {@link ConvertingComparator} instance */ public static <K, V> ConvertingComparator<Map.Entry<K, V>, K> mapEntryKeys(Comparator<K> comparator) { return new ConvertingComparator<>(comparator, Map.Entry::getKey); }
/** * Create a new {@link ConvertingComparator} that compares {@link java.util.Map.Entry * map * entries} based on their {@link java.util.Map.Entry#getKey() keys}. * @param comparator the underlying comparator used to compare keys * @return a new {@link ConvertingComparator} instance */ public static <K, V> ConvertingComparator<Map.Entry<K, V>, K> mapEntryKeys(Comparator<K> comparator) { return new ConvertingComparator<>(comparator, Map.Entry::getKey); }
/** * Create a new {@link ConvertingComparator} that compares {@link java.util.Map.Entry * map entries} based on their {@link java.util.Map.Entry#getValue() values}. * @param comparator the underlying comparator used to compare values * @return a new {@link ConvertingComparator} instance */ public static <K, V> ConvertingComparator<Map.Entry<K, V>, V> mapEntryValues(Comparator<V> comparator) { return new ConvertingComparator<>(comparator, Map.Entry::getValue); }
@Test(expected = IllegalArgumentException.class) public void shouldThrowOnNullComparator() throws Exception { new ConvertingComparator<>(null, this.converter); }
@Test(expected = IllegalArgumentException.class) public void shouldThrowOnNullConverter() throws Exception { new ConvertingComparator<String, Integer>(this.comparator, null); }
@Test(expected = IllegalArgumentException.class) public void shouldThrowOnNullType() throws Exception { new ConvertingComparator<String, Integer>(this.comparator, this.conversionService, null); }
@Test(expected = IllegalArgumentException.class) public void shouldThrowOnNullConversionService() throws Exception { new ConvertingComparator<String, Integer>(this.comparator, null, Integer.class); }
@Test public void shouldUseConverterOnCompare() throws Exception { ConvertingComparator<String, Integer> convertingComparator = new ConvertingComparator<>( this.comparator, this.converter); testConversion(convertingComparator); }
@Test public void shouldUseConversionServiceOnCompare() throws Exception { ConvertingComparator<String, Integer> convertingComparator = new ConvertingComparator<>( comparator, conversionService, Integer.class); testConversion(convertingComparator); }
@Test public void shouldGetForConverter() throws Exception { testConversion(new ConvertingComparator<>(comparator, converter)); }
/** * Create a new {@link ConvertingComparator} that compares {@link java.util.Map.Entry * map * entries} based on their {@link java.util.Map.Entry#getKey() keys}. * @param comparator the underlying comparator used to compare keys * @return a new {@link ConvertingComparator} instance */ public static <K, V> ConvertingComparator<Map.Entry<K, V>, K> mapEntryKeys(Comparator<K> comparator) { return new ConvertingComparator<>(comparator, Map.Entry::getKey); }
/** * Create a new {@link ConvertingComparator} that compares {@link java.util.Map.Entry * map entries} based on their {@link java.util.Map.Entry#getValue() values}. * @param comparator the underlying comparator used to compare values * @return a new {@link ConvertingComparator} instance */ public static <K, V> ConvertingComparator<Map.Entry<K, V>, V> mapEntryValues(Comparator<V> comparator) { return new ConvertingComparator<>(comparator, Map.Entry::getValue); }
/** * Create a new {@link ConvertingComparator} that compares {@link java.util.Map.Entry * map * entries} based on their {@link java.util.Map.Entry#getKey() keys}. * @param comparator the underlying comparator used to compare keys * @return a new {@link ConvertingComparator} instance */ public static <K, V> ConvertingComparator<Map.Entry<K, V>, K> mapEntryKeys(Comparator<K> comparator) { return new ConvertingComparator<>(comparator, Map.Entry::getKey); }
/** * Create a new {@link ConvertingComparator} that compares {@link java.util.Map.Entry * map entries} based on their {@link java.util.Map.Entry#getValue() values}. * @param comparator the underlying comparator used to compare values * @return a new {@link ConvertingComparator} instance */ public static <K, V> ConvertingComparator<Map.Entry<K, V>, V> mapEntryValues(Comparator<V> comparator) { return new ConvertingComparator<>(comparator, Map.Entry::getValue); }
comparator.addComparator(new ConvertingComparator<Method, Annotation>( new InstanceComparator<Annotation>( Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class), comparator.addComparator(new ConvertingComparator<Method, String>( new Converter<Method, String>() { @Override