HV-2127 Use ImmutableCollections (List.of/Set.of/Map.of) instead of Collections.unmodifiableXxx

Signed-off-by: marko-bekhta <[email protected]>

Author: marko-bekhta

engine/src/main/java/org/hibernate/validator/internal/constraintvalidators/hv/UniqueElementsValidator.java

@@ -7,6 +7,7 @@
 import static java.util.stream.Collectors.toList;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -53,7 +54,10 @@ public boolean isValid(Collection collection, ConstraintValidatorContext constra
 		if ( constraintValidatorContext instanceof HibernateConstraintValidatorContext ) {
 			constraintValidatorContext.unwrap( HibernateConstraintValidatorContext.class )
 					.addMessageParameter( "duplicates", duplicates.stream().map( String::valueOf ).collect( Collectors.joining( ", " ) ) )
-					.withDynamicPayload( CollectionHelper.toImmutableList( duplicates ) );
+					// We cannot leverage the CollectionHelper.toImmutableList here as it does not allow `null` values.
+					//  User collections may have `null`s in it and those could as well be duplicates
+					//  so let's rely on the Collections.unmodifiableList here which accepts `null` values as long as the underlying collection allows it:
+					.withDynamicPayload( Collections.unmodifiableList( duplicates ) );
 		}
 
 		return false;

engine/src/main/java/org/hibernate/validator/internal/util/CollectionHelper.java

@@ -7,14 +7,12 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -95,38 +93,47 @@ public static <T> Set<T> asSet(T... ts) {
 		return new HashSet<>( Arrays.asList( ts ) );
 	}
 
+	/**
+	 * Converts the provided list to an {@code java.util.ImmutableCollections}.
+	 * <p>
+	 * <b>NOTE:</b> the resulting list does not allow {@code null} values.
+	 * Attempt to convert a list with {@code null}s will result in an exception!
+	 *
+	 * @param list the list to convert.
+	 * @return the converted list.
+	 * @param <T> the type of the list elements.
+	 */
 	public static <T> List<T> toImmutableList(List<? extends T> list) {
-		switch ( list.size() ) {
-			case 0:
-				return Collections.emptyList();
-			case 1:
-				return Collections.singletonList( list.get( 0 ) );
-			default:
-				return Collections.unmodifiableList( list );
-		}
+		return List.copyOf( list );
 	}
 
+	/**
+	 * Converts the provided set to an {@code java.util.ImmutableCollections}.
+	 * <p>
+	 * <b>NOTE:</b> the resulting set does not allow {@code null} values.
+	 * Attempt to convert a set with {@code null}s will result in an exception!
+	 *
+	 * @param set the set to convert.
+	 * @return the converted set.
+	 * @param <T> the type of the set elements.
+	 */
 	public static <T> Set<T> toImmutableSet(Set<? extends T> set) {
-		switch ( set.size() ) {
-			case 0:
-				return Collections.emptySet();
-			case 1:
-				return Collections.singleton( set.iterator().next() );
-			default:
-				return Collections.unmodifiableSet( set );
-		}
+		return Set.copyOf( set );
 	}
 
+	/**
+	 * Converts the provided map to an {@code java.util.ImmutableCollections}.
+	 * <p>
+	 * <b>NOTE:</b> the resulting map does not allow {@code null} keys and values .
+	 * Attempt to convert a map with {@code null}s (either as key or a value) will result in an exception!
+	 *
+	 * @param map the map to convert.
+	 * @param <K> the type of the map keys.
+	 * @param <V> the type of the map values.
+	 * @return the converted map.
+	 */
 	public static <K, V> Map<K, V> toImmutableMap(Map<K, V> map) {
-		switch ( map.size() ) {
-			case 0:
-				return Collections.emptyMap();
-			case 1:
-				Entry<K, V> entry = map.entrySet().iterator().next();
-				return Collections.singletonMap( entry.getKey(), entry.getValue() );
-			default:
-				return Collections.unmodifiableMap( map );
-		}
+		return Map.copyOf( map );
 	}
 
 	/**