From 27383970b629775bf6368bf10e58122b3b709522 Mon Sep 17 00:00:00 2001 From: Sanskar Jhajharia Date: Thu, 10 Jul 2025 22:05:41 +0530 Subject: [PATCH] MINOR: Cleanup Connect Module (1/n) (#19869) Now that Kafka support Java 17, this PR makes some changes in connect module. The changes in this PR are limited to only some files. A future PR(s) shall follow. The changes mostly include: - Collections.emptyList(), Collections.singletonList() and Arrays.asList() are replaced with List.of() - Collections.emptyMap() and Collections.singletonMap() are replaced with Map.of() - Collections.singleton() is replaced with Set.of() Sub modules targeted: api, basic-auth-extensions, file, json, mirror, mirror-client Reviewers: Ken Huang , TengYao Chi , Chia-Ping Tsai --- .../kafka/connect/data/ConnectSchema.java | 75 +++++++++-------- .../org/apache/kafka/connect/data/Schema.java | 17 +--- .../kafka/connect/data/SchemaProjector.java | 57 ++++--------- .../org/apache/kafka/connect/data/Values.java | 69 ++++++---------- .../kafka/connect/storage/ConverterType.java | 16 +--- .../ConnectorReconfigurationTest.java | 9 +-- .../kafka/connect/data/ConnectSchemaTest.java | 81 ++++++++++--------- .../kafka/connect/data/DecimalTest.java | 4 +- .../kafka/connect/data/SchemaBuilderTest.java | 26 +++--- .../connect/data/SchemaProjectorTest.java | 60 +++++++------- .../apache/kafka/connect/data/StructTest.java | 22 +++-- .../apache/kafka/connect/data/ValuesTest.java | 39 +++++---- .../connect/header/ConnectHeadersTest.java | 7 +- .../connect/source/SourceRecordTest.java | 5 +- .../connect/storage/StringConverterTest.java | 6 +- .../connect/util/ConnectorUtilsTest.java | 38 +++++---- .../BasicAuthSecurityRestExtensionTest.java | 4 +- .../extension/JaasBasicAuthFilterTest.java | 5 +- .../connect/file/FileStreamSourceTask.java | 2 +- .../connect/file/FileStreamSinkTaskTest.java | 11 ++- .../file/FileStreamSourceConnectorTest.java | 40 ++++----- .../file/FileStreamSourceTaskTest.java | 25 +++--- ...eStreamSourceConnectorIntegrationTest.java | 5 +- .../kafka/connect/json/JsonConverter.java | 12 ++- .../kafka/connect/json/JsonDeserializer.java | 3 +- .../kafka/connect/json/JsonSerializer.java | 3 +- .../connect/json/JsonConverterConfigTest.java | 2 +- .../kafka/connect/json/JsonConverterTest.java | 47 ++++++----- .../kafka/connect/mirror/MirrorClient.java | 3 +- .../connect/mirror/MirrorClientTest.java | 28 +++---- .../connect/mirror/ReplicationPolicyTest.java | 3 +- .../kafka/connect/mirror/CheckpointStore.java | 3 +- .../mirror/MirrorCheckpointConnector.java | 7 +- .../connect/mirror/MirrorCheckpointTask.java | 7 +- .../mirror/MirrorCheckpointTaskConfig.java | 3 +- .../mirror/MirrorHeartbeatConnector.java | 5 +- .../connect/mirror/MirrorHeartbeatTask.java | 3 +- .../kafka/connect/mirror/MirrorMaker.java | 3 +- .../connect/mirror/MirrorMakerConfig.java | 15 +--- .../connect/mirror/MirrorSourceConnector.java | 7 +- .../mirror/MirrorSourceTaskConfig.java | 3 +- .../kafka/connect/mirror/MirrorUtils.java | 11 +-- .../connect/mirror/rest/MirrorRestServer.java | 9 +-- .../connect/mirror/CheckpointStoreTest.java | 3 +- .../mirror/MirrorCheckpointConfigTest.java | 6 +- .../mirror/MirrorCheckpointConnectorTest.java | 37 +++++---- .../mirror/MirrorCheckpointTaskTest.java | 40 ++++----- .../mirror/MirrorHeartBeatConnectorTest.java | 23 +++--- .../mirror/MirrorHeartbeatTaskTest.java | 4 +- .../connect/mirror/MirrorMakerConfigTest.java | 16 ++-- .../mirror/MirrorSourceConfigTest.java | 3 +- .../mirror/MirrorSourceConnectorTest.java | 76 +++++++++-------- .../kafka/connect/mirror/MirrorUtilsTest.java | 15 ++-- .../connect/mirror/OffsetSyncWriterTest.java | 8 +- .../DedicatedMirrorIntegrationTest.java | 11 +-- .../MirrorConnectorsIntegrationBaseTest.java | 74 +++++++++-------- ...rConnectorsIntegrationExactlyOnceTest.java | 4 +- ...hCustomForwardingAdminIntegrationTest.java | 18 ++--- 58 files changed, 506 insertions(+), 632 deletions(-) diff --git a/connect/api/src/main/java/org/apache/kafka/connect/data/ConnectSchema.java b/connect/api/src/main/java/org/apache/kafka/connect/data/ConnectSchema.java index cf5f01502c8..b8e10c3dbde 100644 --- a/connect/api/src/main/java/org/apache/kafka/connect/data/ConnectSchema.java +++ b/connect/api/src/main/java/org/apache/kafka/connect/data/ConnectSchema.java @@ -20,59 +20,55 @@ import org.apache.kafka.connect.errors.DataException; import java.math.BigDecimal; import java.nio.ByteBuffer; -import java.util.Arrays; import java.util.Collections; import java.util.EnumMap; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.stream.Collectors; public class ConnectSchema implements Schema { /** * Maps {@link Schema.Type}s to a list of Java classes that can be used to represent them. */ - private static final Map>> SCHEMA_TYPE_CLASSES = new EnumMap<>(Type.class); + private static final Map>> SCHEMA_TYPE_CLASSES = Collections.unmodifiableMap(new EnumMap<>(Map.ofEntries( + Map.entry(Type.INT8, List.of(Byte.class)), + Map.entry(Type.INT16, List.of(Short.class)), + Map.entry(Type.INT32, List.of(Integer.class)), + Map.entry(Type.INT64, List.of(Long.class)), + Map.entry(Type.FLOAT32, List.of(Float.class)), + Map.entry(Type.FLOAT64, List.of(Double.class)), + Map.entry(Type.BOOLEAN, List.of(Boolean.class)), + Map.entry(Type.STRING, List.of(String.class)), + // Bytes are special and have 2 representations. byte[] causes problems because it doesn't handle equals() and + // hashCode() like we want objects to, so we support both byte[] and ByteBuffer. Using plain byte[] can cause + // those methods to fail, so ByteBuffers are recommended + Map.entry(Type.BYTES, List.of(byte[].class, ByteBuffer.class)), + Map.entry(Type.ARRAY, List.of(List.class)), + Map.entry(Type.MAP, List.of(Map.class)), + Map.entry(Type.STRUCT, List.of(Struct.class)) + ))); /** * Maps known logical types to a list of Java classes that can be used to represent them. */ - private static final Map>> LOGICAL_TYPE_CLASSES = new HashMap<>(); + // We don't need to put these into JAVA_CLASS_SCHEMA_TYPES since that's only used to determine schemas for + // schemaless data and logical types will have ambiguous schemas (e.g. many of them use the same Java class) so + // they should not be used without schemas. + private static final Map>> LOGICAL_TYPE_CLASSES = Map.of( + Decimal.LOGICAL_NAME, List.of(BigDecimal.class), + Date.LOGICAL_NAME, List.of(java.util.Date.class), + Time.LOGICAL_NAME, List.of(java.util.Date.class), + Timestamp.LOGICAL_NAME, List.of(java.util.Date.class) + ); /** * Maps the Java classes to the corresponding {@link Schema.Type}. */ - private static final Map, Type> JAVA_CLASS_SCHEMA_TYPES = new HashMap<>(); - - static { - SCHEMA_TYPE_CLASSES.put(Type.INT8, Collections.singletonList(Byte.class)); - SCHEMA_TYPE_CLASSES.put(Type.INT16, Collections.singletonList(Short.class)); - SCHEMA_TYPE_CLASSES.put(Type.INT32, Collections.singletonList(Integer.class)); - SCHEMA_TYPE_CLASSES.put(Type.INT64, Collections.singletonList(Long.class)); - SCHEMA_TYPE_CLASSES.put(Type.FLOAT32, Collections.singletonList(Float.class)); - SCHEMA_TYPE_CLASSES.put(Type.FLOAT64, Collections.singletonList(Double.class)); - SCHEMA_TYPE_CLASSES.put(Type.BOOLEAN, Collections.singletonList(Boolean.class)); - SCHEMA_TYPE_CLASSES.put(Type.STRING, Collections.singletonList(String.class)); - // Bytes are special and have 2 representations. byte[] causes problems because it doesn't handle equals() and - // hashCode() like we want objects to, so we support both byte[] and ByteBuffer. Using plain byte[] can cause - // those methods to fail, so ByteBuffers are recommended - SCHEMA_TYPE_CLASSES.put(Type.BYTES, Arrays.asList(byte[].class, ByteBuffer.class)); - SCHEMA_TYPE_CLASSES.put(Type.ARRAY, Collections.singletonList(List.class)); - SCHEMA_TYPE_CLASSES.put(Type.MAP, Collections.singletonList(Map.class)); - SCHEMA_TYPE_CLASSES.put(Type.STRUCT, Collections.singletonList(Struct.class)); - - for (Map.Entry>> schemaClasses : SCHEMA_TYPE_CLASSES.entrySet()) { - for (Class schemaClass : schemaClasses.getValue()) - JAVA_CLASS_SCHEMA_TYPES.put(schemaClass, schemaClasses.getKey()); - } - - LOGICAL_TYPE_CLASSES.put(Decimal.LOGICAL_NAME, Collections.singletonList(BigDecimal.class)); - LOGICAL_TYPE_CLASSES.put(Date.LOGICAL_NAME, Collections.singletonList(java.util.Date.class)); - LOGICAL_TYPE_CLASSES.put(Time.LOGICAL_NAME, Collections.singletonList(java.util.Date.class)); - LOGICAL_TYPE_CLASSES.put(Timestamp.LOGICAL_NAME, Collections.singletonList(java.util.Date.class)); - // We don't need to put these into JAVA_CLASS_SCHEMA_TYPES since that's only used to determine schemas for - // schemaless data and logical types will have ambiguous schemas (e.g. many of them use the same Java class) so - // they should not be used without schemas. - } + private static final Map, Type> JAVA_CLASS_SCHEMA_TYPES = SCHEMA_TYPE_CLASSES.entrySet() + .stream() + .flatMap(entry -> entry.getValue().stream().map(klass -> Map.entry(klass, entry.getKey()))) + .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); // The type of the field private final Type type; @@ -110,7 +106,7 @@ public class ConnectSchema implements Schema { this.parameters = parameters; if (this.type == Type.STRUCT) { - this.fields = fields == null ? Collections.emptyList() : fields; + this.fields = fields == null ? List.of() : fields; this.fieldsByName = new HashMap<>(this.fields.size()); for (Field field : this.fields) fieldsByName.put(field.name(), field); @@ -283,9 +279,12 @@ public class ConnectSchema implements Schema { } private static List> expectedClassesFor(Schema schema) { - List> expectedClasses = LOGICAL_TYPE_CLASSES.get(schema.name()); + List> expectedClasses = null; + if (schema.name() != null) { + expectedClasses = LOGICAL_TYPE_CLASSES.get(schema.name()); + } if (expectedClasses == null) - expectedClasses = SCHEMA_TYPE_CLASSES.getOrDefault(schema.type(), Collections.emptyList()); + expectedClasses = SCHEMA_TYPE_CLASSES.getOrDefault(schema.type(), List.of()); return expectedClasses; } diff --git a/connect/api/src/main/java/org/apache/kafka/connect/data/Schema.java b/connect/api/src/main/java/org/apache/kafka/connect/data/Schema.java index 4a57663f4c5..4f25e3611a0 100644 --- a/connect/api/src/main/java/org/apache/kafka/connect/data/Schema.java +++ b/connect/api/src/main/java/org/apache/kafka/connect/data/Schema.java @@ -117,19 +117,10 @@ public interface Schema { } public boolean isPrimitive() { - switch (this) { - case INT8: - case INT16: - case INT32: - case INT64: - case FLOAT32: - case FLOAT64: - case BOOLEAN: - case STRING: - case BYTES: - return true; - } - return false; + return switch (this) { + case INT8, INT16, INT32, INT64, FLOAT32, FLOAT64, BOOLEAN, STRING, BYTES -> true; + default -> false; + }; } } diff --git a/connect/api/src/main/java/org/apache/kafka/connect/data/SchemaProjector.java b/connect/api/src/main/java/org/apache/kafka/connect/data/SchemaProjector.java index 6a9dd56aeb3..ed096504e09 100644 --- a/connect/api/src/main/java/org/apache/kafka/connect/data/SchemaProjector.java +++ b/connect/api/src/main/java/org/apache/kafka/connect/data/SchemaProjector.java @@ -78,25 +78,13 @@ public class SchemaProjector { } private static Object projectRequiredSchema(Schema source, Object record, Schema target) throws SchemaProjectorException { - switch (target.type()) { - case INT8: - case INT16: - case INT32: - case INT64: - case FLOAT32: - case FLOAT64: - case BOOLEAN: - case BYTES: - case STRING: - return projectPrimitive(source, record, target); - case STRUCT: - return projectStruct(source, (Struct) record, target); - case ARRAY: - return projectArray(source, record, target); - case MAP: - return projectMap(source, record, target); - } - return null; + return switch (target.type()) { + case INT8, INT16, INT32, INT64, FLOAT32, FLOAT64, BOOLEAN, BYTES, STRING -> + projectPrimitive(source, record, target); + case STRUCT -> projectStruct(source, (Struct) record, target); + case ARRAY -> projectArray(source, record, target); + case MAP -> projectMap(source, record, target); + }; } private static Object projectStruct(Schema source, Struct sourceStruct, Schema target) throws SchemaProjectorException { @@ -161,28 +149,15 @@ public class SchemaProjector { assert target.type().isPrimitive(); Object result; if (isPromotable(source.type(), target.type()) && record instanceof Number numberRecord) { - switch (target.type()) { - case INT8: - result = numberRecord.byteValue(); - break; - case INT16: - result = numberRecord.shortValue(); - break; - case INT32: - result = numberRecord.intValue(); - break; - case INT64: - result = numberRecord.longValue(); - break; - case FLOAT32: - result = numberRecord.floatValue(); - break; - case FLOAT64: - result = numberRecord.doubleValue(); - break; - default: - throw new SchemaProjectorException("Not promotable type."); - } + result = switch (target.type()) { + case INT8 -> numberRecord.byteValue(); + case INT16 -> numberRecord.shortValue(); + case INT32 -> numberRecord.intValue(); + case INT64 -> numberRecord.longValue(); + case FLOAT32 -> numberRecord.floatValue(); + case FLOAT64 -> numberRecord.doubleValue(); + default -> throw new SchemaProjectorException("Not promotable type."); + }; } else { result = record; } diff --git a/connect/api/src/main/java/org/apache/kafka/connect/data/Values.java b/connect/api/src/main/java/org/apache/kafka/connect/data/Values.java index f23f1f88a75..266d31534a8 100644 --- a/connect/api/src/main/java/org/apache/kafka/connect/data/Values.java +++ b/connect/api/src/main/java/org/apache/kafka/connect/data/Values.java @@ -430,33 +430,20 @@ public class Values { } throw new DataException("Unable to convert a null value to a schema that requires a value"); } - switch (toSchema.type()) { - case BYTES: - return convertMaybeLogicalBytes(toSchema, value); - case STRING: - return convertToString(fromSchema, value); - case BOOLEAN: - return convertToBoolean(fromSchema, value); - case INT8: - return convertToByte(fromSchema, value); - case INT16: - return convertToShort(fromSchema, value); - case INT32: - return convertMaybeLogicalInteger(toSchema, fromSchema, value); - case INT64: - return convertMaybeLogicalLong(toSchema, fromSchema, value); - case FLOAT32: - return convertToFloat(fromSchema, value); - case FLOAT64: - return convertToDouble(fromSchema, value); - case ARRAY: - return convertToArray(toSchema, value); - case MAP: - return convertToMapInternal(toSchema, value); - case STRUCT: - return convertToStructInternal(toSchema, value); - } - throw new DataException("Unable to convert " + value + " (" + value.getClass() + ") to " + toSchema); + return switch (toSchema.type()) { + case BYTES -> convertMaybeLogicalBytes(toSchema, value); + case STRING -> convertToString(fromSchema, value); + case BOOLEAN -> convertToBoolean(fromSchema, value); + case INT8 -> convertToByte(fromSchema, value); + case INT16 -> convertToShort(fromSchema, value); + case INT32 -> convertMaybeLogicalInteger(toSchema, fromSchema, value); + case INT64 -> convertMaybeLogicalLong(toSchema, fromSchema, value); + case FLOAT32 -> convertToFloat(fromSchema, value); + case FLOAT64 -> convertToDouble(fromSchema, value); + case ARRAY -> convertToArray(toSchema, value); + case MAP -> convertToMapInternal(toSchema, value); + case STRUCT -> convertToStructInternal(toSchema, value); + }; } private static Serializable convertMaybeLogicalBytes(Schema toSchema, Object value) { @@ -1144,21 +1131,15 @@ public class Values { Type previousType = previous.type(); Type newType = newSchema.type(); if (previousType != newType) { - switch (previous.type()) { - case INT8: - return commonSchemaForInt8(newSchema, newType); - case INT16: - return commonSchemaForInt16(previous, newSchema, newType); - case INT32: - return commonSchemaForInt32(previous, newSchema, newType); - case INT64: - return commonSchemaForInt64(previous, newSchema, newType); - case FLOAT32: - return commonSchemaForFloat32(previous, newSchema, newType); - case FLOAT64: - return commonSchemaForFloat64(previous, newType); - } - return null; + return switch (previous.type()) { + case INT8 -> commonSchemaForInt8(newSchema, newType); + case INT16 -> commonSchemaForInt16(previous, newSchema, newType); + case INT32 -> commonSchemaForInt32(previous, newSchema, newType); + case INT64 -> commonSchemaForInt64(previous, newSchema, newType); + case FLOAT32 -> commonSchemaForFloat32(previous, newSchema, newType); + case FLOAT64 -> commonSchemaForFloat64(previous, newType); + default -> null; + }; } if (previous.isOptional() == newSchema.isOptional()) { // Use the optional one @@ -1273,10 +1254,8 @@ public class Values { } if (knownType == null) { knownType = schema.type(); - } else if (knownType != schema.type()) { - return false; } - return true; + return knownType == schema.type(); } public Schema schema() { diff --git a/connect/api/src/main/java/org/apache/kafka/connect/storage/ConverterType.java b/connect/api/src/main/java/org/apache/kafka/connect/storage/ConverterType.java index ecd7b2e755a..2da2bd8d07e 100644 --- a/connect/api/src/main/java/org/apache/kafka/connect/storage/ConverterType.java +++ b/connect/api/src/main/java/org/apache/kafka/connect/storage/ConverterType.java @@ -16,10 +16,10 @@ */ package org.apache.kafka.connect.storage; -import java.util.Collections; -import java.util.HashMap; +import java.util.Arrays; import java.util.Locale; import java.util.Map; +import java.util.stream.Collectors; /** * The type of {@link Converter} and {@link HeaderConverter}. @@ -29,16 +29,8 @@ public enum ConverterType { VALUE, HEADER; - private static final Map NAME_TO_TYPE; - - static { - ConverterType[] types = ConverterType.values(); - Map nameToType = new HashMap<>(types.length); - for (ConverterType type : types) { - nameToType.put(type.name, type); - } - NAME_TO_TYPE = Collections.unmodifiableMap(nameToType); - } + private static final Map NAME_TO_TYPE = Arrays.stream(ConverterType.values()) + .collect(Collectors.toUnmodifiableMap(ConverterType::getName, t -> t)); /** * Find the ConverterType with the given name, using a case-insensitive match. diff --git a/connect/api/src/test/java/org/apache/kafka/connect/connector/ConnectorReconfigurationTest.java b/connect/api/src/test/java/org/apache/kafka/connect/connector/ConnectorReconfigurationTest.java index efa56aca469..8b9c16bfe64 100644 --- a/connect/api/src/test/java/org/apache/kafka/connect/connector/ConnectorReconfigurationTest.java +++ b/connect/api/src/test/java/org/apache/kafka/connect/connector/ConnectorReconfigurationTest.java @@ -21,7 +21,6 @@ import org.apache.kafka.connect.errors.ConnectException; import org.junit.jupiter.api.Test; -import java.util.Collections; import java.util.List; import java.util.Map; @@ -33,15 +32,15 @@ public class ConnectorReconfigurationTest { @Test public void testDefaultReconfigure() { TestConnector conn = new TestConnector(false); - conn.reconfigure(Collections.emptyMap()); - assertEquals(conn.stopOrder, 0); - assertEquals(conn.configureOrder, 1); + conn.reconfigure(Map.of()); + assertEquals(0, conn.stopOrder); + assertEquals(1, conn.configureOrder); } @Test public void testReconfigureStopException() { TestConnector conn = new TestConnector(true); - assertThrows(ConnectException.class, () -> conn.reconfigure(Collections.emptyMap())); + assertThrows(ConnectException.class, () -> conn.reconfigure(Map.of())); } private static class TestConnector extends Connector { diff --git a/connect/api/src/test/java/org/apache/kafka/connect/data/ConnectSchemaTest.java b/connect/api/src/test/java/org/apache/kafka/connect/data/ConnectSchemaTest.java index b4e9f81ce81..95cc36edb1b 100644 --- a/connect/api/src/test/java/org/apache/kafka/connect/data/ConnectSchemaTest.java +++ b/connect/api/src/test/java/org/apache/kafka/connect/data/ConnectSchemaTest.java @@ -27,6 +27,7 @@ import java.nio.CharBuffer; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; +import java.util.List; import java.util.Map; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -86,17 +87,17 @@ public class ConnectSchemaTest { ConnectSchema.validateValue(Schema.STRING_SCHEMA, "a string"); ConnectSchema.validateValue(Schema.BYTES_SCHEMA, "a byte array".getBytes()); ConnectSchema.validateValue(Schema.BYTES_SCHEMA, ByteBuffer.wrap("a byte array".getBytes())); - ConnectSchema.validateValue(SchemaBuilder.array(Schema.INT32_SCHEMA).build(), Arrays.asList(1, 2, 3)); + ConnectSchema.validateValue(SchemaBuilder.array(Schema.INT32_SCHEMA).build(), List.of(1, 2, 3)); ConnectSchema.validateValue( SchemaBuilder.map(Schema.INT32_SCHEMA, Schema.STRING_SCHEMA).build(), - Collections.singletonMap(1, "value") + Map.of(1, "value") ); // Struct tests the basic struct layout + complex field types + nested structs Struct structValue = new Struct(STRUCT_SCHEMA) .put("first", 1) .put("second", "foo") - .put("array", Arrays.asList(1, 2, 3)) - .put("map", Collections.singletonMap(1, "value")) + .put("array", List.of(1, 2, 3)) + .put("map", Map.of(1, "value")) .put("nested", new Struct(FLAT_STRUCT_SCHEMA).put("field", 12)); ConnectSchema.validateValue(STRUCT_SCHEMA, structValue); } @@ -171,7 +172,7 @@ public class ConnectSchemaTest { @Test public void testValidateValueMismatchArray() { assertThrows(DataException.class, - () -> ConnectSchema.validateValue(SchemaBuilder.array(Schema.INT32_SCHEMA).build(), Arrays.asList("a", "b", "c"))); + () -> ConnectSchema.validateValue(SchemaBuilder.array(Schema.INT32_SCHEMA).build(), List.of("a", "b", "c"))); } @Test @@ -179,19 +180,19 @@ public class ConnectSchemaTest { // Even if some match the right type, this should fail if any mismatch. In this case, type erasure loses // the fact that the list is actually List, but we couldn't tell if only checking the first element assertThrows(DataException.class, - () -> ConnectSchema.validateValue(SchemaBuilder.array(Schema.INT32_SCHEMA).build(), Arrays.asList(1, 2, "c"))); + () -> ConnectSchema.validateValue(SchemaBuilder.array(Schema.INT32_SCHEMA).build(), List.of(1, 2, "c"))); } @Test public void testValidateValueMismatchMapKey() { assertThrows(DataException.class, - () -> ConnectSchema.validateValue(MAP_INT_STRING_SCHEMA, Collections.singletonMap("wrong key type", "value"))); + () -> ConnectSchema.validateValue(MAP_INT_STRING_SCHEMA, Map.of("wrong key type", "value"))); } @Test public void testValidateValueMismatchMapValue() { assertThrows(DataException.class, - () -> ConnectSchema.validateValue(MAP_INT_STRING_SCHEMA, Collections.singletonMap(1, 2))); + () -> ConnectSchema.validateValue(MAP_INT_STRING_SCHEMA, Map.of(1, 2))); } @Test @@ -259,7 +260,7 @@ public class ConnectSchemaTest { ConnectSchema differentName = new ConnectSchema(Schema.Type.INT8, false, null, "otherName", 2, "doc"); ConnectSchema differentVersion = new ConnectSchema(Schema.Type.INT8, false, null, "name", 4, "doc"); ConnectSchema differentDoc = new ConnectSchema(Schema.Type.INT8, false, null, "name", 2, "other doc"); - ConnectSchema differentParameters = new ConnectSchema(Schema.Type.INT8, false, null, "name", 2, "doc", Collections.singletonMap("param", "value"), null, null, null); + ConnectSchema differentParameters = new ConnectSchema(Schema.Type.INT8, false, null, "name", 2, "doc", Map.of("param", "value"), null, null, null); assertEquals(s1, s2); assertNotEquals(s1, differentType); @@ -311,13 +312,13 @@ public class ConnectSchemaTest { // Same as testArrayEquality, but checks differences in fields. Only does a simple check, relying on tests of // Field's equals() method to validate all variations in the list of fields will be checked ConnectSchema s1 = new ConnectSchema(Schema.Type.STRUCT, false, null, null, null, null, null, - Arrays.asList(new Field("field", 0, SchemaBuilder.int8().build()), + List.of(new Field("field", 0, SchemaBuilder.int8().build()), new Field("field2", 1, SchemaBuilder.int16().build())), null, null); ConnectSchema s2 = new ConnectSchema(Schema.Type.STRUCT, false, null, null, null, null, null, - Arrays.asList(new Field("field", 0, SchemaBuilder.int8().build()), + List.of(new Field("field", 0, SchemaBuilder.int8().build()), new Field("field2", 1, SchemaBuilder.int16().build())), null, null); ConnectSchema differentField = new ConnectSchema(Schema.Type.STRUCT, false, null, null, null, null, null, - Arrays.asList(new Field("field", 0, SchemaBuilder.int8().build()), + List.of(new Field("field", 0, SchemaBuilder.int8().build()), new Field("different field name", 1, SchemaBuilder.int16().build())), null, null); assertEquals(s1, s2); @@ -365,44 +366,44 @@ public class ConnectSchemaTest { // Optional element schema Schema optionalStrings = SchemaBuilder.array(Schema.OPTIONAL_STRING_SCHEMA); - ConnectSchema.validateValue(fieldName, optionalStrings, Collections.emptyList()); - ConnectSchema.validateValue(fieldName, optionalStrings, Collections.singletonList("hello")); + ConnectSchema.validateValue(fieldName, optionalStrings, List.of()); + ConnectSchema.validateValue(fieldName, optionalStrings, List.of("hello")); ConnectSchema.validateValue(fieldName, optionalStrings, Collections.singletonList(null)); - ConnectSchema.validateValue(fieldName, optionalStrings, Arrays.asList("hello", "world")); + ConnectSchema.validateValue(fieldName, optionalStrings, List.of("hello", "world")); ConnectSchema.validateValue(fieldName, optionalStrings, Arrays.asList("hello", null)); ConnectSchema.validateValue(fieldName, optionalStrings, Arrays.asList(null, "world")); - assertInvalidValueForSchema(fieldName, optionalStrings, Collections.singletonList(true), + assertInvalidValueForSchema(fieldName, optionalStrings, List.of(true), "Invalid Java object for schema with type STRING: class java.lang.Boolean for element of array field: \"field\""); // Required element schema Schema requiredStrings = SchemaBuilder.array(Schema.STRING_SCHEMA); - ConnectSchema.validateValue(fieldName, requiredStrings, Collections.emptyList()); - ConnectSchema.validateValue(fieldName, requiredStrings, Collections.singletonList("hello")); + ConnectSchema.validateValue(fieldName, requiredStrings, List.of()); + ConnectSchema.validateValue(fieldName, requiredStrings, List.of("hello")); assertInvalidValueForSchema(fieldName, requiredStrings, Collections.singletonList(null), "Invalid value: null used for required element of array field: \"field\", schema type: STRING"); - ConnectSchema.validateValue(fieldName, requiredStrings, Arrays.asList("hello", "world")); + ConnectSchema.validateValue(fieldName, requiredStrings, List.of("hello", "world")); assertInvalidValueForSchema(fieldName, requiredStrings, Arrays.asList("hello", null), "Invalid value: null used for required element of array field: \"field\", schema type: STRING"); assertInvalidValueForSchema(fieldName, requiredStrings, Arrays.asList(null, "world"), "Invalid value: null used for required element of array field: \"field\", schema type: STRING"); - assertInvalidValueForSchema(fieldName, optionalStrings, Collections.singletonList(true), + assertInvalidValueForSchema(fieldName, optionalStrings, List.of(true), "Invalid Java object for schema with type STRING: class java.lang.Boolean for element of array field: \"field\""); // Null element schema Schema nullElements = SchemaBuilder.type(Schema.Type.ARRAY); - assertInvalidValueForSchema(fieldName, nullElements, Collections.emptyList(), + assertInvalidValueForSchema(fieldName, nullElements, List.of(), "No schema defined for element of array field: \"field\""); - assertInvalidValueForSchema(fieldName, nullElements, Collections.singletonList("hello"), + assertInvalidValueForSchema(fieldName, nullElements, List.of("hello"), "No schema defined for element of array field: \"field\""); assertInvalidValueForSchema(fieldName, nullElements, Collections.singletonList(null), "No schema defined for element of array field: \"field\""); - assertInvalidValueForSchema(fieldName, nullElements, Arrays.asList("hello", "world"), + assertInvalidValueForSchema(fieldName, nullElements, List.of("hello", "world"), "No schema defined for element of array field: \"field\""); assertInvalidValueForSchema(fieldName, nullElements, Arrays.asList("hello", null), "No schema defined for element of array field: \"field\""); assertInvalidValueForSchema(fieldName, nullElements, Arrays.asList(null, "world"), "No schema defined for element of array field: \"field\""); - assertInvalidValueForSchema(fieldName, nullElements, Collections.singletonList(true), + assertInvalidValueForSchema(fieldName, nullElements, List.of(true), "No schema defined for element of array field: \"field\""); } @@ -412,36 +413,36 @@ public class ConnectSchemaTest { // Optional element schema Schema optionalStrings = SchemaBuilder.map(Schema.OPTIONAL_STRING_SCHEMA, Schema.OPTIONAL_STRING_SCHEMA); - ConnectSchema.validateValue(fieldName, optionalStrings, Collections.emptyMap()); - ConnectSchema.validateValue(fieldName, optionalStrings, Collections.singletonMap("key", "value")); + ConnectSchema.validateValue(fieldName, optionalStrings, Map.of()); + ConnectSchema.validateValue(fieldName, optionalStrings, Map.of("key", "value")); ConnectSchema.validateValue(fieldName, optionalStrings, Collections.singletonMap("key", null)); ConnectSchema.validateValue(fieldName, optionalStrings, Collections.singletonMap(null, "value")); ConnectSchema.validateValue(fieldName, optionalStrings, Collections.singletonMap(null, null)); - assertInvalidValueForSchema(fieldName, optionalStrings, Collections.singletonMap("key", true), + assertInvalidValueForSchema(fieldName, optionalStrings, Map.of("key", true), "Invalid Java object for schema with type STRING: class java.lang.Boolean for value of map field: \"field\""); - assertInvalidValueForSchema(fieldName, optionalStrings, Collections.singletonMap(true, "value"), + assertInvalidValueForSchema(fieldName, optionalStrings, Map.of(true, "value"), "Invalid Java object for schema with type STRING: class java.lang.Boolean for key of map field: \"field\""); // Required element schema Schema requiredStrings = SchemaBuilder.map(Schema.STRING_SCHEMA, Schema.STRING_SCHEMA); - ConnectSchema.validateValue(fieldName, requiredStrings, Collections.emptyMap()); - ConnectSchema.validateValue(fieldName, requiredStrings, Collections.singletonMap("key", "value")); + ConnectSchema.validateValue(fieldName, requiredStrings, Map.of()); + ConnectSchema.validateValue(fieldName, requiredStrings, Map.of("key", "value")); assertInvalidValueForSchema(fieldName, requiredStrings, Collections.singletonMap("key", null), "Invalid value: null used for required value of map field: \"field\", schema type: STRING"); assertInvalidValueForSchema(fieldName, requiredStrings, Collections.singletonMap(null, "value"), "Invalid value: null used for required key of map field: \"field\", schema type: STRING"); assertInvalidValueForSchema(fieldName, requiredStrings, Collections.singletonMap(null, null), "Invalid value: null used for required key of map field: \"field\", schema type: STRING"); - assertInvalidValueForSchema(fieldName, requiredStrings, Collections.singletonMap("key", true), + assertInvalidValueForSchema(fieldName, requiredStrings, Map.of("key", true), "Invalid Java object for schema with type STRING: class java.lang.Boolean for value of map field: \"field\""); - assertInvalidValueForSchema(fieldName, requiredStrings, Collections.singletonMap(true, "value"), + assertInvalidValueForSchema(fieldName, requiredStrings, Map.of(true, "value"), "Invalid Java object for schema with type STRING: class java.lang.Boolean for key of map field: \"field\""); // Null key schema Schema nullKeys = SchemaBuilder.type(Schema.Type.MAP); - assertInvalidValueForSchema(fieldName, nullKeys, Collections.emptyMap(), + assertInvalidValueForSchema(fieldName, nullKeys, Map.of(), "No schema defined for key of map field: \"field\""); - assertInvalidValueForSchema(fieldName, nullKeys, Collections.singletonMap("key", "value"), + assertInvalidValueForSchema(fieldName, nullKeys, Map.of("key", "value"), "No schema defined for key of map field: \"field\""); assertInvalidValueForSchema(fieldName, nullKeys, Collections.singletonMap("key", null), "No schema defined for key of map field: \"field\""); @@ -449,16 +450,16 @@ public class ConnectSchemaTest { "No schema defined for key of map field: \"field\""); assertInvalidValueForSchema(fieldName, nullKeys, Collections.singletonMap(null, null), "No schema defined for key of map field: \"field\""); - assertInvalidValueForSchema(fieldName, nullKeys, Collections.singletonMap("key", true), + assertInvalidValueForSchema(fieldName, nullKeys, Map.of("key", true), "No schema defined for key of map field: \"field\""); - assertInvalidValueForSchema(fieldName, nullKeys, Collections.singletonMap(true, "value"), + assertInvalidValueForSchema(fieldName, nullKeys, Map.of(true, "value"), "No schema defined for key of map field: \"field\""); // Null value schema Schema nullValues = SchemaBuilder.mapWithNullValues(Schema.OPTIONAL_STRING_SCHEMA); - assertInvalidValueForSchema(fieldName, nullValues, Collections.emptyMap(), + assertInvalidValueForSchema(fieldName, nullValues, Map.of(), "No schema defined for value of map field: \"field\""); - assertInvalidValueForSchema(fieldName, nullValues, Collections.singletonMap("key", "value"), + assertInvalidValueForSchema(fieldName, nullValues, Map.of("key", "value"), "No schema defined for value of map field: \"field\""); assertInvalidValueForSchema(fieldName, nullValues, Collections.singletonMap("key", null), "No schema defined for value of map field: \"field\""); @@ -466,9 +467,9 @@ public class ConnectSchemaTest { "No schema defined for value of map field: \"field\""); assertInvalidValueForSchema(fieldName, nullValues, Collections.singletonMap(null, null), "No schema defined for value of map field: \"field\""); - assertInvalidValueForSchema(fieldName, nullValues, Collections.singletonMap("key", true), + assertInvalidValueForSchema(fieldName, nullValues, Map.of("key", true), "No schema defined for value of map field: \"field\""); - assertInvalidValueForSchema(fieldName, nullValues, Collections.singletonMap(true, "value"), + assertInvalidValueForSchema(fieldName, nullValues, Map.of(true, "value"), "No schema defined for value of map field: \"field\""); } } diff --git a/connect/api/src/test/java/org/apache/kafka/connect/data/DecimalTest.java b/connect/api/src/test/java/org/apache/kafka/connect/data/DecimalTest.java index 9592fb918e7..efb4a75ed29 100644 --- a/connect/api/src/test/java/org/apache/kafka/connect/data/DecimalTest.java +++ b/connect/api/src/test/java/org/apache/kafka/connect/data/DecimalTest.java @@ -20,7 +20,7 @@ import org.junit.jupiter.api.Test; import java.math.BigDecimal; import java.math.BigInteger; -import java.util.Collections; +import java.util.Map; import static org.junit.jupiter.api.Assertions.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -36,7 +36,7 @@ public class DecimalTest { public void testBuilder() { Schema plain = Decimal.builder(2).build(); assertEquals(Decimal.LOGICAL_NAME, plain.name()); - assertEquals(Collections.singletonMap(Decimal.SCALE_FIELD, "2"), plain.parameters()); + assertEquals(Map.of(Decimal.SCALE_FIELD, "2"), plain.parameters()); assertEquals(1, (Object) plain.version()); } diff --git a/connect/api/src/test/java/org/apache/kafka/connect/data/SchemaBuilderTest.java b/connect/api/src/test/java/org/apache/kafka/connect/data/SchemaBuilderTest.java index c789541ae53..23a96f92c15 100644 --- a/connect/api/src/test/java/org/apache/kafka/connect/data/SchemaBuilderTest.java +++ b/connect/api/src/test/java/org/apache/kafka/connect/data/SchemaBuilderTest.java @@ -21,8 +21,6 @@ import org.apache.kafka.connect.errors.SchemaBuilderException; import org.junit.jupiter.api.Test; import java.nio.ByteBuffer; -import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -234,14 +232,14 @@ public class SchemaBuilderTest { public void testArrayBuilder() { Schema schema = SchemaBuilder.array(Schema.INT8_SCHEMA).build(); assertTypeAndDefault(schema, Schema.Type.ARRAY, false, null); - assertEquals(schema.valueSchema(), Schema.INT8_SCHEMA); + assertEquals(Schema.INT8_SCHEMA, schema.valueSchema()); assertNoMetadata(schema); // Default value - List defArray = Arrays.asList((byte) 1, (byte) 2); + List defArray = List.of((byte) 1, (byte) 2); schema = SchemaBuilder.array(Schema.INT8_SCHEMA).defaultValue(defArray).build(); assertTypeAndDefault(schema, Schema.Type.ARRAY, false, defArray); - assertEquals(schema.valueSchema(), Schema.INT8_SCHEMA); + assertEquals(Schema.INT8_SCHEMA, schema.valueSchema()); assertNoMetadata(schema); } @@ -249,7 +247,7 @@ public class SchemaBuilderTest { public void testArrayBuilderInvalidDefault() { // Array, but wrong embedded type assertThrows(SchemaBuilderException.class, - () -> SchemaBuilder.array(Schema.INT8_SCHEMA).defaultValue(Collections.singletonList("string")).build()); + () -> SchemaBuilder.array(Schema.INT8_SCHEMA).defaultValue(List.of("string")).build()); } @Test @@ -257,30 +255,30 @@ public class SchemaBuilderTest { // SchemaBuilder should also pass the check Schema schema = SchemaBuilder.map(Schema.INT8_SCHEMA, Schema.INT8_SCHEMA); assertTypeAndDefault(schema, Schema.Type.MAP, false, null); - assertEquals(schema.keySchema(), Schema.INT8_SCHEMA); - assertEquals(schema.valueSchema(), Schema.INT8_SCHEMA); + assertEquals(Schema.INT8_SCHEMA, schema.keySchema()); + assertEquals(Schema.INT8_SCHEMA, schema.valueSchema()); assertNoMetadata(schema); schema = SchemaBuilder.map(Schema.INT8_SCHEMA, Schema.INT8_SCHEMA).build(); assertTypeAndDefault(schema, Schema.Type.MAP, false, null); - assertEquals(schema.keySchema(), Schema.INT8_SCHEMA); - assertEquals(schema.valueSchema(), Schema.INT8_SCHEMA); + assertEquals(Schema.INT8_SCHEMA, schema.keySchema()); + assertEquals(Schema.INT8_SCHEMA, schema.valueSchema()); assertNoMetadata(schema); // Default value - Map defMap = Collections.singletonMap((byte) 5, (byte) 10); + Map defMap = Map.of((byte) 5, (byte) 10); schema = SchemaBuilder.map(Schema.INT8_SCHEMA, Schema.INT8_SCHEMA) .defaultValue(defMap).build(); assertTypeAndDefault(schema, Schema.Type.MAP, false, defMap); - assertEquals(schema.keySchema(), Schema.INT8_SCHEMA); - assertEquals(schema.valueSchema(), Schema.INT8_SCHEMA); + assertEquals(Schema.INT8_SCHEMA, schema.keySchema()); + assertEquals(Schema.INT8_SCHEMA, schema.valueSchema()); assertNoMetadata(schema); } @Test public void testMapBuilderInvalidDefault() { // Map, but wrong embedded type - Map defMap = Collections.singletonMap((byte) 5, "foo"); + Map defMap = Map.of((byte) 5, "foo"); assertThrows(SchemaBuilderException.class, () -> SchemaBuilder.map(Schema.INT8_SCHEMA, Schema.INT8_SCHEMA) .defaultValue(defMap).build()); } diff --git a/connect/api/src/test/java/org/apache/kafka/connect/data/SchemaProjectorTest.java b/connect/api/src/test/java/org/apache/kafka/connect/data/SchemaProjectorTest.java index 4ec35d369ad..0f438c0e0ff 100644 --- a/connect/api/src/test/java/org/apache/kafka/connect/data/SchemaProjectorTest.java +++ b/connect/api/src/test/java/org/apache/kafka/connect/data/SchemaProjectorTest.java @@ -24,8 +24,6 @@ import org.junit.jupiter.api.Test; import java.math.BigDecimal; import java.math.BigInteger; -import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -78,12 +76,12 @@ public class SchemaProjectorTest { Object[] values = {(byte) 127, (short) 255, 32767, 327890L, 1.2F, 1.2345}; Map> expectedProjected = new HashMap<>(); - expectedProjected.put(values[0], Arrays.asList((byte) 127, (short) 127, 127, 127L, 127.F, 127.)); - expectedProjected.put(values[1], Arrays.asList((short) 255, 255, 255L, 255.F, 255.)); - expectedProjected.put(values[2], Arrays.asList(32767, 32767L, 32767.F, 32767.)); - expectedProjected.put(values[3], Arrays.asList(327890L, 327890.F, 327890.)); - expectedProjected.put(values[4], Arrays.asList(1.2F, 1.2)); - expectedProjected.put(values[5], Collections.singletonList(1.2345)); + expectedProjected.put(values[0], List.of((byte) 127, (short) 127, 127, 127L, 127.F, 127.)); + expectedProjected.put(values[1], List.of((short) 255, 255, 255L, 255.F, 255.)); + expectedProjected.put(values[2], List.of(32767, 32767L, 32767.F, 32767.)); + expectedProjected.put(values[3], List.of(327890L, 327890.F, 327890.)); + expectedProjected.put(values[4], List.of(1.2F, 1.2)); + expectedProjected.put(values[5], List.of(1.2345)); Object promoted; for (int i = 0; i < promotableSchemas.length; ++i) { @@ -298,16 +296,16 @@ public class SchemaProjectorTest { Struct sourceNestedStruct = new Struct(sourceNestedSchema); sourceNestedStruct.put("first", 1); sourceNestedStruct.put("second", "abc"); - sourceNestedStruct.put("array", Arrays.asList(1, 2)); - sourceNestedStruct.put("map", Collections.singletonMap(5, "def")); + sourceNestedStruct.put("array", List.of(1, 2)); + sourceNestedStruct.put("map", Map.of(5, "def")); sourceNestedStruct.put("nested", sourceFlatStruct); Struct targetNestedStruct = (Struct) SchemaProjector.project(sourceNestedSchema, sourceNestedStruct, targetNestedSchema); assertEquals(1, targetNestedStruct.get("first")); assertEquals("abc", targetNestedStruct.get("second")); - assertEquals(Arrays.asList(1, 2), targetNestedStruct.get("array")); - assertEquals(Collections.singletonMap(5, "def"), targetNestedStruct.get("map")); + assertEquals(List.of(1, 2), targetNestedStruct.get("array")); + assertEquals(Map.of(5, "def"), targetNestedStruct.get("map")); Struct projectedStruct = (Struct) targetNestedStruct.get("nested"); assertEquals(113, projectedStruct.get("field")); @@ -360,22 +358,22 @@ public class SchemaProjectorTest { public void testArrayProjection() { Schema source = SchemaBuilder.array(Schema.INT32_SCHEMA).build(); - Object projected = SchemaProjector.project(source, Arrays.asList(1, 2, 3), source); - assertEquals(Arrays.asList(1, 2, 3), projected); + Object projected = SchemaProjector.project(source, List.of(1, 2, 3), source); + assertEquals(List.of(1, 2, 3), projected); Schema optionalSource = SchemaBuilder.array(Schema.INT32_SCHEMA).optional().build(); - Schema target = SchemaBuilder.array(Schema.INT32_SCHEMA).defaultValue(Arrays.asList(1, 2, 3)).build(); - projected = SchemaProjector.project(optionalSource, Arrays.asList(4, 5), target); - assertEquals(Arrays.asList(4, 5), projected); + Schema target = SchemaBuilder.array(Schema.INT32_SCHEMA).defaultValue(List.of(1, 2, 3)).build(); + projected = SchemaProjector.project(optionalSource, List.of(4, 5), target); + assertEquals(List.of(4, 5), projected); projected = SchemaProjector.project(optionalSource, null, target); - assertEquals(Arrays.asList(1, 2, 3), projected); + assertEquals(List.of(1, 2, 3), projected); - Schema promotedTarget = SchemaBuilder.array(Schema.INT64_SCHEMA).defaultValue(Arrays.asList(1L, 2L, 3L)).build(); - projected = SchemaProjector.project(optionalSource, Arrays.asList(4, 5), promotedTarget); - List expectedProjected = Arrays.asList(4L, 5L); + Schema promotedTarget = SchemaBuilder.array(Schema.INT64_SCHEMA).defaultValue(List.of(1L, 2L, 3L)).build(); + projected = SchemaProjector.project(optionalSource, List.of(4, 5), promotedTarget); + List expectedProjected = List.of(4L, 5L); assertEquals(expectedProjected, projected); projected = SchemaProjector.project(optionalSource, null, promotedTarget); - assertEquals(Arrays.asList(1L, 2L, 3L), projected); + assertEquals(List.of(1L, 2L, 3L), projected); Schema noDefaultValueTarget = SchemaBuilder.array(Schema.INT32_SCHEMA).build(); assertThrows(SchemaProjectorException.class, () -> SchemaProjector.project(optionalSource, null, @@ -391,18 +389,18 @@ public class SchemaProjectorTest { public void testMapProjection() { Schema source = SchemaBuilder.map(Schema.INT32_SCHEMA, Schema.INT32_SCHEMA).optional().build(); - Schema target = SchemaBuilder.map(Schema.INT32_SCHEMA, Schema.INT32_SCHEMA).defaultValue(Collections.singletonMap(1, 2)).build(); - Object projected = SchemaProjector.project(source, Collections.singletonMap(3, 4), target); - assertEquals(Collections.singletonMap(3, 4), projected); + Schema target = SchemaBuilder.map(Schema.INT32_SCHEMA, Schema.INT32_SCHEMA).defaultValue(Map.of(1, 2)).build(); + Object projected = SchemaProjector.project(source, Map.of(3, 4), target); + assertEquals(Map.of(3, 4), projected); projected = SchemaProjector.project(source, null, target); - assertEquals(Collections.singletonMap(1, 2), projected); + assertEquals(Map.of(1, 2), projected); Schema promotedTarget = SchemaBuilder.map(Schema.INT64_SCHEMA, Schema.FLOAT32_SCHEMA).defaultValue( - Collections.singletonMap(3L, 4.5F)).build(); - projected = SchemaProjector.project(source, Collections.singletonMap(3, 4), promotedTarget); - assertEquals(Collections.singletonMap(3L, 4.F), projected); + Map.of(3L, 4.5F)).build(); + projected = SchemaProjector.project(source, Map.of(3, 4), promotedTarget); + assertEquals(Map.of(3L, 4.F), projected); projected = SchemaProjector.project(source, null, promotedTarget); - assertEquals(Collections.singletonMap(3L, 4.5F), projected); + assertEquals(Map.of(3L, 4.5F), projected); Schema noDefaultValueTarget = SchemaBuilder.map(Schema.INT32_SCHEMA, Schema.INT32_SCHEMA).build(); assertThrows(SchemaProjectorException.class, @@ -424,7 +422,7 @@ public class SchemaProjectorTest { () -> SchemaProjector.project(source, 12, target), "Source name and target name mismatch."); - Schema targetWithParameters = SchemaBuilder.int32().parameters(Collections.singletonMap("key", "value")); + Schema targetWithParameters = SchemaBuilder.int32().parameters(Map.of("key", "value")); assertThrows(SchemaProjectorException.class, () -> SchemaProjector.project(source, 34, targetWithParameters), "Source parameters and target parameters mismatch."); diff --git a/connect/api/src/test/java/org/apache/kafka/connect/data/StructTest.java b/connect/api/src/test/java/org/apache/kafka/connect/data/StructTest.java index 6dee26ca83a..bfdec2fcb9b 100644 --- a/connect/api/src/test/java/org/apache/kafka/connect/data/StructTest.java +++ b/connect/api/src/test/java/org/apache/kafka/connect/data/StructTest.java @@ -21,8 +21,6 @@ import org.apache.kafka.connect.errors.DataException; import org.junit.jupiter.api.Test; import java.nio.ByteBuffer; -import java.util.Arrays; -import java.util.Collections; import java.util.List; import java.util.Map; @@ -93,8 +91,8 @@ public class StructTest { @Test public void testComplexStruct() { - List array = Arrays.asList((byte) 1, (byte) 2); - Map map = Collections.singletonMap(1, "string"); + List array = List.of((byte) 1, (byte) 2); + Map map = Map.of(1, "string"); Struct struct = new Struct(NESTED_SCHEMA) .put("array", array) .put("map", map) @@ -124,13 +122,13 @@ public class StructTest { @Test public void testInvalidArrayFieldElements() { assertThrows(DataException.class, - () -> new Struct(NESTED_SCHEMA).put("array", Collections.singletonList("should fail since elements should be int8s"))); + () -> new Struct(NESTED_SCHEMA).put("array", List.of("should fail since elements should be int8s"))); } @Test public void testInvalidMapKeyElements() { assertThrows(DataException.class, - () -> new Struct(NESTED_SCHEMA).put("map", Collections.singletonMap("should fail because keys should be int8s", (byte) 12))); + () -> new Struct(NESTED_SCHEMA).put("map", Map.of("should fail because keys should be int8s", (byte) 12))); } @Test @@ -219,20 +217,20 @@ public class StructTest { assertEquals(struct1, struct2); assertNotEquals(struct1, struct3); - List array = Arrays.asList((byte) 1, (byte) 2); - Map map = Collections.singletonMap(1, "string"); + List array = List.of((byte) 1, (byte) 2); + Map map = Map.of(1, "string"); struct1 = new Struct(NESTED_SCHEMA) .put("array", array) .put("map", map) .put("nested", new Struct(NESTED_CHILD_SCHEMA).put("int8", (byte) 12)); - List array2 = Arrays.asList((byte) 1, (byte) 2); - Map map2 = Collections.singletonMap(1, "string"); + List array2 = List.of((byte) 1, (byte) 2); + Map map2 = Map.of(1, "string"); struct2 = new Struct(NESTED_SCHEMA) .put("array", array2) .put("map", map2) .put("nested", new Struct(NESTED_CHILD_SCHEMA).put("int8", (byte) 12)); - List array3 = Arrays.asList((byte) 1, (byte) 2, (byte) 3); - Map map3 = Collections.singletonMap(2, "string"); + List array3 = List.of((byte) 1, (byte) 2, (byte) 3); + Map map3 = Map.of(2, "string"); struct3 = new Struct(NESTED_SCHEMA) .put("array", array3) .put("map", map3) diff --git a/connect/api/src/test/java/org/apache/kafka/connect/data/ValuesTest.java b/connect/api/src/test/java/org/apache/kafka/connect/data/ValuesTest.java index ac6eef6fa68..6be0b4a3772 100644 --- a/connect/api/src/test/java/org/apache/kafka/connect/data/ValuesTest.java +++ b/connect/api/src/test/java/org/apache/kafka/connect/data/ValuesTest.java @@ -38,7 +38,6 @@ import java.time.ZoneOffset; import java.time.format.DateTimeFormatter; import java.time.temporal.ChronoUnit; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashMap; @@ -184,7 +183,7 @@ public class ValuesTest { SchemaAndValue schemaAndValue = Values.parseString("[true, false]"); assertEquals(Type.ARRAY, schemaAndValue.schema().type()); assertEquals(Type.BOOLEAN, schemaAndValue.schema().valueSchema().type()); - assertEquals(Arrays.asList(true, false), schemaAndValue.value()); + assertEquals(List.of(true, false), schemaAndValue.value()); } @Test @@ -217,14 +216,14 @@ public class ValuesTest { public void shouldParseEmptyMap() { SchemaAndValue schemaAndValue = Values.parseString("{}"); assertEquals(Type.MAP, schemaAndValue.schema().type()); - assertEquals(Collections.emptyMap(), schemaAndValue.value()); + assertEquals(Map.of(), schemaAndValue.value()); } @Test public void shouldParseEmptyArray() { SchemaAndValue schemaAndValue = Values.parseString("[]"); assertEquals(Type.ARRAY, schemaAndValue.schema().type()); - assertEquals(Collections.emptyList(), schemaAndValue.value()); + assertEquals(List.of(), schemaAndValue.value()); } @Test @@ -468,16 +467,16 @@ public class ValuesTest { @Test public void shouldParseStringListWithMultipleElementTypes() { assertParseStringArrayWithNoSchema( - Arrays.asList((byte) 1, (byte) 2, (short) 300, "four"), + List.of((byte) 1, (byte) 2, (short) 300, "four"), "[1, 2, 300, \"four\"]"); assertParseStringArrayWithNoSchema( - Arrays.asList((byte) 2, (short) 300, "four", (byte) 1), + List.of((byte) 2, (short) 300, "four", (byte) 1), "[2, 300, \"four\", 1]"); assertParseStringArrayWithNoSchema( - Arrays.asList((short) 300, "four", (byte) 1, (byte) 2), + List.of((short) 300, "four", (byte) 1, (byte) 2), "[300, \"four\", 1, 2]"); assertParseStringArrayWithNoSchema( - Arrays.asList("four", (byte) 1, (byte) 2, (short) 300), + List.of("four", (byte) 1, (byte) 2, (short) 300), "[\"four\", 1, 2, 300]"); } @@ -648,7 +647,7 @@ public class ValuesTest { assertEquals(Type.INT32, elementSchema.type()); assertEquals(Date.LOGICAL_NAME, elementSchema.name()); java.util.Date expected = new SimpleDateFormat(Values.ISO_8601_DATE_FORMAT_PATTERN).parse(dateStr); - assertEquals(Collections.singletonList(expected), result.value()); + assertEquals(List.of(expected), result.value()); } @Test @@ -661,7 +660,7 @@ public class ValuesTest { assertEquals(Type.INT32, elementSchema.type()); assertEquals(Time.LOGICAL_NAME, elementSchema.name()); java.util.Date expected = new SimpleDateFormat(Values.ISO_8601_TIME_FORMAT_PATTERN).parse(timeStr); - assertEquals(Collections.singletonList(expected), result.value()); + assertEquals(List.of(expected), result.value()); } @Test @@ -674,7 +673,7 @@ public class ValuesTest { assertEquals(Type.INT64, elementSchema.type()); assertEquals(Timestamp.LOGICAL_NAME, elementSchema.name()); java.util.Date expected = new SimpleDateFormat(Values.ISO_8601_TIMESTAMP_FORMAT_PATTERN).parse(tsStr); - assertEquals(Collections.singletonList(expected), result.value()); + assertEquals(List.of(expected), result.value()); } @Test @@ -691,7 +690,7 @@ public class ValuesTest { java.util.Date expected1 = new SimpleDateFormat(Values.ISO_8601_TIMESTAMP_FORMAT_PATTERN).parse(tsStr1); java.util.Date expected2 = new SimpleDateFormat(Values.ISO_8601_TIMESTAMP_FORMAT_PATTERN).parse(tsStr2); java.util.Date expected3 = new SimpleDateFormat(Values.ISO_8601_TIMESTAMP_FORMAT_PATTERN).parse(tsStr3); - assertEquals(Arrays.asList(expected1, expected2, expected3), result.value()); + assertEquals(List.of(expected1, expected2, expected3), result.value()); } @Test @@ -707,7 +706,7 @@ public class ValuesTest { assertEquals(Type.INT32, valueSchema.type()); assertEquals(Time.LOGICAL_NAME, valueSchema.name()); java.util.Date expected = new SimpleDateFormat(Values.ISO_8601_TIME_FORMAT_PATTERN).parse(timeStr); - assertEquals(Collections.singletonMap(keyStr, expected), result.value()); + assertEquals(Map.of(keyStr, expected), result.value()); } @Test @@ -723,7 +722,7 @@ public class ValuesTest { assertEquals(Type.INT32, valueSchema.type()); assertEquals(Time.LOGICAL_NAME, valueSchema.name()); java.util.Date expected = new SimpleDateFormat(Values.ISO_8601_TIME_FORMAT_PATTERN).parse(timeStr); - assertEquals(Collections.singletonMap(keyStr, expected), result.value()); + assertEquals(Map.of(keyStr, expected), result.value()); } @Test @@ -991,25 +990,25 @@ public class ValuesTest { @Test public void shouldInferNoSchemaForEmptyList() { - Schema listSchema = Values.inferSchema(Collections.emptyList()); + Schema listSchema = Values.inferSchema(List.of()); assertNull(listSchema); } @Test public void shouldInferNoSchemaForListContainingObject() { - Schema listSchema = Values.inferSchema(Collections.singletonList(new Object())); + Schema listSchema = Values.inferSchema(List.of(new Object())); assertNull(listSchema); } @Test public void shouldInferNoSchemaForEmptyMap() { - Schema listSchema = Values.inferSchema(Collections.emptyMap()); + Schema listSchema = Values.inferSchema(Map.of()); assertNull(listSchema); } @Test public void shouldInferNoSchemaForMapContainingObject() { - Schema listSchema = Values.inferSchema(Collections.singletonMap(new Object(), new Object())); + Schema listSchema = Values.inferSchema(Map.of(new Object(), new Object())); assertNull(listSchema); } @@ -1019,7 +1018,7 @@ public class ValuesTest { */ @Test public void shouldNotConvertArrayValuesToDecimal() { - List decimals = Arrays.asList("\"1.0\"", BigDecimal.valueOf(Long.MAX_VALUE).add(BigDecimal.ONE), + List decimals = List.of("\"1.0\"", BigDecimal.valueOf(Long.MAX_VALUE).add(BigDecimal.ONE), BigDecimal.valueOf(Long.MIN_VALUE).subtract(BigDecimal.ONE), (byte) 1, (byte) 1); List expected = new ArrayList<>(decimals); // most values are directly reproduced with the same type expected.set(0, "1.0"); // The quotes are parsed away, but the value remains a string @@ -1032,7 +1031,7 @@ public class ValuesTest { @Test public void shouldParseArrayOfOnlyDecimals() { - List decimals = Arrays.asList(BigDecimal.valueOf(Long.MAX_VALUE).add(BigDecimal.ONE), + List decimals = List.of(BigDecimal.valueOf(Long.MAX_VALUE).add(BigDecimal.ONE), BigDecimal.valueOf(Long.MIN_VALUE).subtract(BigDecimal.ONE)); SchemaAndValue schemaAndValue = Values.parseString(decimals.toString()); Schema schema = schemaAndValue.schema(); diff --git a/connect/api/src/test/java/org/apache/kafka/connect/header/ConnectHeadersTest.java b/connect/api/src/test/java/org/apache/kafka/connect/header/ConnectHeadersTest.java index 44073f77229..52aeff4a1a2 100644 --- a/connect/api/src/test/java/org/apache/kafka/connect/header/ConnectHeadersTest.java +++ b/connect/api/src/test/java/org/apache/kafka/connect/header/ConnectHeadersTest.java @@ -37,10 +37,11 @@ import java.math.RoundingMode; import java.util.ArrayList; import java.util.Arrays; import java.util.Calendar; -import java.util.Collections; import java.util.GregorianCalendar; import java.util.HashMap; import java.util.Iterator; +import java.util.List; +import java.util.Map; import java.util.TimeZone; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -380,9 +381,9 @@ public class ConnectHeadersTest { assertSchemaMatches(Schema.FLOAT64_SCHEMA, 1.0d); assertSchemaMatches(Schema.STRING_SCHEMA, "value"); assertSchemaMatches(SchemaBuilder.array(Schema.STRING_SCHEMA), new ArrayList()); - assertSchemaMatches(SchemaBuilder.array(Schema.STRING_SCHEMA), Collections.singletonList("value")); + assertSchemaMatches(SchemaBuilder.array(Schema.STRING_SCHEMA), List.of("value")); assertSchemaMatches(SchemaBuilder.map(Schema.STRING_SCHEMA, Schema.INT32_SCHEMA), new HashMap()); - assertSchemaMatches(SchemaBuilder.map(Schema.STRING_SCHEMA, Schema.INT32_SCHEMA), Collections.singletonMap("a", 0)); + assertSchemaMatches(SchemaBuilder.map(Schema.STRING_SCHEMA, Schema.INT32_SCHEMA), Map.of("a", 0)); Schema emptyStructSchema = SchemaBuilder.struct(); assertSchemaMatches(emptyStructSchema, new Struct(emptyStructSchema)); Schema structSchema = SchemaBuilder.struct().field("foo", Schema.OPTIONAL_BOOLEAN_SCHEMA).field("bar", Schema.STRING_SCHEMA) diff --git a/connect/api/src/test/java/org/apache/kafka/connect/source/SourceRecordTest.java b/connect/api/src/test/java/org/apache/kafka/connect/source/SourceRecordTest.java index 90bd4f897df..32716da8975 100644 --- a/connect/api/src/test/java/org/apache/kafka/connect/source/SourceRecordTest.java +++ b/connect/api/src/test/java/org/apache/kafka/connect/source/SourceRecordTest.java @@ -25,7 +25,6 @@ import org.apache.kafka.connect.header.Headers; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import java.util.Collections; import java.util.Map; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -38,8 +37,8 @@ import static org.junit.jupiter.api.Assertions.assertTrue; public class SourceRecordTest { - private static final Map SOURCE_PARTITION = Collections.singletonMap("src", "abc"); - private static final Map SOURCE_OFFSET = Collections.singletonMap("offset", "1"); + private static final Map SOURCE_PARTITION = Map.of("src", "abc"); + private static final Map SOURCE_OFFSET = Map.of("offset", "1"); private static final String TOPIC_NAME = "myTopic"; private static final Integer PARTITION_NUMBER = 0; private static final Long KAFKA_TIMESTAMP = 0L; diff --git a/connect/api/src/test/java/org/apache/kafka/connect/storage/StringConverterTest.java b/connect/api/src/test/java/org/apache/kafka/connect/storage/StringConverterTest.java index 463125e0940..119d0594a8f 100644 --- a/connect/api/src/test/java/org/apache/kafka/connect/storage/StringConverterTest.java +++ b/connect/api/src/test/java/org/apache/kafka/connect/storage/StringConverterTest.java @@ -24,7 +24,7 @@ import org.apache.kafka.connect.data.SchemaAndValue; import org.junit.jupiter.api.Test; import java.nio.charset.StandardCharsets; -import java.util.Collections; +import java.util.Map; import static org.junit.jupiter.api.Assertions.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -58,7 +58,7 @@ public class StringConverterTest { @Test public void testToBytesNonUtf8Encoding() { - converter.configure(Collections.singletonMap("converter.encoding", StandardCharsets.UTF_16.name()), true); + converter.configure(Map.of("converter.encoding", StandardCharsets.UTF_16.name()), true); assertArrayEquals(SAMPLE_STRING.getBytes(StandardCharsets.UTF_16), converter.fromConnectData(TOPIC, Schema.STRING_SCHEMA, SAMPLE_STRING)); } @@ -78,7 +78,7 @@ public class StringConverterTest { @Test public void testBytesToStringNonUtf8Encoding() { - converter.configure(Collections.singletonMap("converter.encoding", StandardCharsets.UTF_16.name()), true); + converter.configure(Map.of("converter.encoding", StandardCharsets.UTF_16.name()), true); SchemaAndValue data = converter.toConnectData(TOPIC, SAMPLE_STRING.getBytes(StandardCharsets.UTF_16)); assertEquals(Schema.OPTIONAL_STRING_SCHEMA, data.schema()); assertEquals(SAMPLE_STRING, data.value()); diff --git a/connect/api/src/test/java/org/apache/kafka/connect/util/ConnectorUtilsTest.java b/connect/api/src/test/java/org/apache/kafka/connect/util/ConnectorUtilsTest.java index 1972ff7a89d..0a72a0a181c 100644 --- a/connect/api/src/test/java/org/apache/kafka/connect/util/ConnectorUtilsTest.java +++ b/connect/api/src/test/java/org/apache/kafka/connect/util/ConnectorUtilsTest.java @@ -18,8 +18,6 @@ package org.apache.kafka.connect.util; import org.junit.jupiter.api.Test; -import java.util.Arrays; -import java.util.Collections; import java.util.List; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -27,37 +25,37 @@ import static org.junit.jupiter.api.Assertions.assertThrows; public class ConnectorUtilsTest { - private static final List FIVE_ELEMENTS = Arrays.asList(1, 2, 3, 4, 5); + private static final List FIVE_ELEMENTS = List.of(1, 2, 3, 4, 5); @Test public void testGroupPartitions() { List> grouped = ConnectorUtils.groupPartitions(FIVE_ELEMENTS, 1); - assertEquals(Collections.singletonList(FIVE_ELEMENTS), grouped); + assertEquals(List.of(FIVE_ELEMENTS), grouped); grouped = ConnectorUtils.groupPartitions(FIVE_ELEMENTS, 2); - assertEquals(Arrays.asList(Arrays.asList(1, 2, 3), Arrays.asList(4, 5)), grouped); + assertEquals(List.of(List.of(1, 2, 3), List.of(4, 5)), grouped); grouped = ConnectorUtils.groupPartitions(FIVE_ELEMENTS, 3); - assertEquals(Arrays.asList(Arrays.asList(1, 2), - Arrays.asList(3, 4), - Collections.singletonList(5)), grouped); + assertEquals(List.of(List.of(1, 2), + List.of(3, 4), + List.of(5)), grouped); grouped = ConnectorUtils.groupPartitions(FIVE_ELEMENTS, 5); - assertEquals(Arrays.asList(Collections.singletonList(1), - Collections.singletonList(2), - Collections.singletonList(3), - Collections.singletonList(4), - Collections.singletonList(5)), grouped); + assertEquals(List.of(List.of(1), + List.of(2), + List.of(3), + List.of(4), + List.of(5)), grouped); grouped = ConnectorUtils.groupPartitions(FIVE_ELEMENTS, 7); - assertEquals(Arrays.asList(Collections.singletonList(1), - Collections.singletonList(2), - Collections.singletonList(3), - Collections.singletonList(4), - Collections.singletonList(5), - Collections.emptyList(), - Collections.emptyList()), grouped); + assertEquals(List.of(List.of(1), + List.of(2), + List.of(3), + List.of(4), + List.of(5), + List.of(), + List.of()), grouped); } @Test diff --git a/connect/basic-auth-extension/src/test/java/org/apache/kafka/connect/rest/basic/auth/extension/BasicAuthSecurityRestExtensionTest.java b/connect/basic-auth-extension/src/test/java/org/apache/kafka/connect/rest/basic/auth/extension/BasicAuthSecurityRestExtensionTest.java index 81f3a7327d5..d8439309e1d 100644 --- a/connect/basic-auth-extension/src/test/java/org/apache/kafka/connect/rest/basic/auth/extension/BasicAuthSecurityRestExtensionTest.java +++ b/connect/basic-auth-extension/src/test/java/org/apache/kafka/connect/rest/basic/auth/extension/BasicAuthSecurityRestExtensionTest.java @@ -26,7 +26,7 @@ import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import java.io.IOException; -import java.util.Collections; +import java.util.Map; import java.util.concurrent.atomic.AtomicBoolean; import java.util.function.Supplier; @@ -107,7 +107,7 @@ public class BasicAuthSecurityRestExtensionTest { BasicAuthSecurityRestExtension extension = new BasicAuthSecurityRestExtension(configuration); - Exception thrownException = assertThrows(Exception.class, () -> extension.configure(Collections.emptyMap())); + Exception thrownException = assertThrows(Exception.class, () -> extension.configure(Map.of())); assertEquals(jaasConfigurationException, thrownException); thrownException = assertThrows(Exception.class, () -> extension.register(mock(ConnectRestExtensionContext.class))); diff --git a/connect/basic-auth-extension/src/test/java/org/apache/kafka/connect/rest/basic/auth/extension/JaasBasicAuthFilterTest.java b/connect/basic-auth-extension/src/test/java/org/apache/kafka/connect/rest/basic/auth/extension/JaasBasicAuthFilterTest.java index bcd6e0ab319..d168e6466db 100644 --- a/connect/basic-auth-extension/src/test/java/org/apache/kafka/connect/rest/basic/auth/extension/JaasBasicAuthFilterTest.java +++ b/connect/basic-auth-extension/src/test/java/org/apache/kafka/connect/rest/basic/auth/extension/JaasBasicAuthFilterTest.java @@ -32,7 +32,6 @@ import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.util.ArrayList; import java.util.Base64; -import java.util.Collections; import java.util.List; import java.util.Map; @@ -261,8 +260,8 @@ public class JaasBasicAuthFilterTest { private JaasBasicAuthFilter setupJaasFilter(String name, String credentialFilePath) { TestJaasConfig configuration = new TestJaasConfig(); Map moduleOptions = credentialFilePath != null - ? Collections.singletonMap("file", credentialFilePath) - : Collections.emptyMap(); + ? Map.of("file", credentialFilePath) + : Map.of(); configuration.addEntry(name, LOGIN_MODULE, moduleOptions); return new JaasBasicAuthFilter(configuration); } diff --git a/connect/file/src/main/java/org/apache/kafka/connect/file/FileStreamSourceTask.java b/connect/file/src/main/java/org/apache/kafka/connect/file/FileStreamSourceTask.java index 79478c57d1f..8a76a480a7a 100644 --- a/connect/file/src/main/java/org/apache/kafka/connect/file/FileStreamSourceTask.java +++ b/connect/file/src/main/java/org/apache/kafka/connect/file/FileStreamSourceTask.java @@ -90,7 +90,7 @@ public class FileStreamSourceTask extends SourceTask { if (stream == null) { try { stream = Files.newInputStream(Paths.get(filename)); - Map offset = context.offsetStorageReader().offset(Collections.singletonMap(FILENAME_FIELD, filename)); + Map offset = context.offsetStorageReader().offset(Map.of(FILENAME_FIELD, filename)); if (offset != null) { Object lastRecordedOffset = offset.get(POSITION_FIELD); if (lastRecordedOffset != null && !(lastRecordedOffset instanceof Long)) diff --git a/connect/file/src/test/java/org/apache/kafka/connect/file/FileStreamSinkTaskTest.java b/connect/file/src/test/java/org/apache/kafka/connect/file/FileStreamSinkTaskTest.java index dde20105e37..6a256fc9c06 100644 --- a/connect/file/src/test/java/org/apache/kafka/connect/file/FileStreamSinkTaskTest.java +++ b/connect/file/src/test/java/org/apache/kafka/connect/file/FileStreamSinkTaskTest.java @@ -32,9 +32,8 @@ import java.io.PrintStream; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; +import java.util.List; import java.util.Map; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -63,14 +62,14 @@ public class FileStreamSinkTaskTest { // We do not call task.start() since it would override the output stream - task.put(Collections.singletonList( + task.put(List.of( new SinkRecord("topic1", 0, null, null, Schema.STRING_SCHEMA, "line1", 1) )); offsets.put(new TopicPartition("topic1", 0), new OffsetAndMetadata(1L)); task.flush(offsets); assertEquals("line1" + newLine, os.toString()); - task.put(Arrays.asList( + task.put(List.of( new SinkRecord("topic1", 0, null, null, Schema.STRING_SCHEMA, "line2", 2), new SinkRecord("topic2", 0, null, null, Schema.STRING_SCHEMA, "line3", 1) )); @@ -88,7 +87,7 @@ public class FileStreamSinkTaskTest { task.start(props); HashMap offsets = new HashMap<>(); - task.put(Collections.singletonList( + task.put(List.of( new SinkRecord("topic1", 0, null, null, Schema.STRING_SCHEMA, "line0", 1) )); offsets.put(new TopicPartition("topic1", 0), new OffsetAndMetadata(1L)); @@ -99,7 +98,7 @@ public class FileStreamSinkTaskTest { int i = 0; try (BufferedReader reader = Files.newBufferedReader(Paths.get(outputFile))) { lines[i++] = reader.readLine(); - task.put(Arrays.asList( + task.put(List.of( new SinkRecord("topic1", 0, null, null, Schema.STRING_SCHEMA, "line1", 2), new SinkRecord("topic2", 0, null, null, Schema.STRING_SCHEMA, "line2", 1) )); diff --git a/connect/file/src/test/java/org/apache/kafka/connect/file/FileStreamSourceConnectorTest.java b/connect/file/src/test/java/org/apache/kafka/connect/file/FileStreamSourceConnectorTest.java index e0c14a1e6cb..94c046182f1 100644 --- a/connect/file/src/test/java/org/apache/kafka/connect/file/FileStreamSourceConnectorTest.java +++ b/connect/file/src/test/java/org/apache/kafka/connect/file/FileStreamSourceConnectorTest.java @@ -158,48 +158,48 @@ public class FileStreamSourceConnectorTest { @Test public void testAlterOffsetsStdin() { sourceProperties.remove(FileStreamSourceConnector.FILE_CONFIG); - Map, Map> offsets = Collections.singletonMap( - Collections.singletonMap(FILENAME_FIELD, FILENAME), - Collections.singletonMap(POSITION_FIELD, 0L) + Map, Map> offsets = Map.of( + Map.of(FILENAME_FIELD, FILENAME), + Map.of(POSITION_FIELD, 0L) ); assertThrows(ConnectException.class, () -> connector.alterOffsets(sourceProperties, offsets)); } @Test public void testAlterOffsetsIncorrectPartitionKey() { - assertThrows(ConnectException.class, () -> connector.alterOffsets(sourceProperties, Collections.singletonMap( - Collections.singletonMap("other_partition_key", FILENAME), - Collections.singletonMap(POSITION_FIELD, 0L) + assertThrows(ConnectException.class, () -> connector.alterOffsets(sourceProperties, Map.of( + Map.of("other_partition_key", FILENAME), + Map.of(POSITION_FIELD, 0L) ))); // null partitions are invalid assertThrows(ConnectException.class, () -> connector.alterOffsets(sourceProperties, Collections.singletonMap( null, - Collections.singletonMap(POSITION_FIELD, 0L) + Map.of(POSITION_FIELD, 0L) ))); } @Test public void testAlterOffsetsMultiplePartitions() { Map, Map> offsets = new HashMap<>(); - offsets.put(Collections.singletonMap(FILENAME_FIELD, FILENAME), Collections.singletonMap(POSITION_FIELD, 0L)); + offsets.put(Map.of(FILENAME_FIELD, FILENAME), Map.of(POSITION_FIELD, 0L)); offsets.put(Collections.singletonMap(FILENAME_FIELD, "/someotherfilename"), null); assertTrue(connector.alterOffsets(sourceProperties, offsets)); } @Test public void testAlterOffsetsIncorrectOffsetKey() { - Map, Map> offsets = Collections.singletonMap( - Collections.singletonMap(FILENAME_FIELD, FILENAME), - Collections.singletonMap("other_offset_key", 0L) + Map, Map> offsets = Map.of( + Map.of(FILENAME_FIELD, FILENAME), + Map.of("other_offset_key", 0L) ); assertThrows(ConnectException.class, () -> connector.alterOffsets(sourceProperties, offsets)); } @Test public void testAlterOffsetsOffsetPositionValues() { - Function alterOffsets = offset -> connector.alterOffsets(sourceProperties, Collections.singletonMap( - Collections.singletonMap(FILENAME_FIELD, FILENAME), + Function alterOffsets = offset -> connector.alterOffsets(sourceProperties, Map.of( + Map.of(FILENAME_FIELD, FILENAME), Collections.singletonMap(POSITION_FIELD, offset) )); @@ -217,9 +217,9 @@ public class FileStreamSourceConnectorTest { @Test public void testSuccessfulAlterOffsets() { - Map, Map> offsets = Collections.singletonMap( - Collections.singletonMap(FILENAME_FIELD, FILENAME), - Collections.singletonMap(POSITION_FIELD, 0L) + Map, Map> offsets = Map.of( + Map.of(FILENAME_FIELD, FILENAME), + Map.of(POSITION_FIELD, 0L) ); // Expect no exception to be thrown when a valid offsets map is passed. An empty offsets map is treated as valid @@ -237,9 +237,9 @@ public class FileStreamSourceConnectorTest { ); assertTrue(alterOffsets.apply(null)); - assertTrue(alterOffsets.apply(Collections.emptyMap())); - assertTrue(alterOffsets.apply(Collections.singletonMap(FILENAME_FIELD, FILENAME))); - assertTrue(alterOffsets.apply(Collections.singletonMap(FILENAME_FIELD, "/someotherfilename"))); - assertTrue(alterOffsets.apply(Collections.singletonMap("garbage_partition_key", "garbage_partition_value"))); + assertTrue(alterOffsets.apply(Map.of())); + assertTrue(alterOffsets.apply(Map.of(FILENAME_FIELD, FILENAME))); + assertTrue(alterOffsets.apply(Map.of(FILENAME_FIELD, "/someotherfilename"))); + assertTrue(alterOffsets.apply(Map.of("garbage_partition_key", "garbage_partition_value"))); } } diff --git a/connect/file/src/test/java/org/apache/kafka/connect/file/FileStreamSourceTaskTest.java b/connect/file/src/test/java/org/apache/kafka/connect/file/FileStreamSourceTaskTest.java index e0e77a8433c..c8118faf158 100644 --- a/connect/file/src/test/java/org/apache/kafka/connect/file/FileStreamSourceTaskTest.java +++ b/connect/file/src/test/java/org/apache/kafka/connect/file/FileStreamSourceTaskTest.java @@ -30,7 +30,6 @@ import java.io.IOException; import java.io.OutputStream; import java.nio.file.Files; import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -87,8 +86,8 @@ public class FileStreamSourceTaskTest { assertEquals(1, records.size()); assertEquals(TOPIC, records.get(0).topic()); assertEquals("partial line finished", records.get(0).value()); - assertEquals(Collections.singletonMap(FileStreamSourceTask.FILENAME_FIELD, tempFile.getAbsolutePath()), records.get(0).sourcePartition()); - assertEquals(Collections.singletonMap(FileStreamSourceTask.POSITION_FIELD, 22L), records.get(0).sourceOffset()); + assertEquals(Map.of(FileStreamSourceTask.FILENAME_FIELD, tempFile.getAbsolutePath()), records.get(0).sourcePartition()); + assertEquals(Map.of(FileStreamSourceTask.POSITION_FIELD, 22L), records.get(0).sourceOffset()); assertNull(task.poll()); // Different line endings, and make sure the final \r doesn't result in a line until we can @@ -98,25 +97,25 @@ public class FileStreamSourceTaskTest { records = task.poll(); assertEquals(4, records.size()); assertEquals("line1", records.get(0).value()); - assertEquals(Collections.singletonMap(FileStreamSourceTask.FILENAME_FIELD, tempFile.getAbsolutePath()), records.get(0).sourcePartition()); - assertEquals(Collections.singletonMap(FileStreamSourceTask.POSITION_FIELD, 28L), records.get(0).sourceOffset()); + assertEquals(Map.of(FileStreamSourceTask.FILENAME_FIELD, tempFile.getAbsolutePath()), records.get(0).sourcePartition()); + assertEquals(Map.of(FileStreamSourceTask.POSITION_FIELD, 28L), records.get(0).sourceOffset()); assertEquals("line2", records.get(1).value()); - assertEquals(Collections.singletonMap(FileStreamSourceTask.FILENAME_FIELD, tempFile.getAbsolutePath()), records.get(1).sourcePartition()); - assertEquals(Collections.singletonMap(FileStreamSourceTask.POSITION_FIELD, 35L), records.get(1).sourceOffset()); + assertEquals(Map.of(FileStreamSourceTask.FILENAME_FIELD, tempFile.getAbsolutePath()), records.get(1).sourcePartition()); + assertEquals(Map.of(FileStreamSourceTask.POSITION_FIELD, 35L), records.get(1).sourceOffset()); assertEquals("line3", records.get(2).value()); - assertEquals(Collections.singletonMap(FileStreamSourceTask.FILENAME_FIELD, tempFile.getAbsolutePath()), records.get(2).sourcePartition()); - assertEquals(Collections.singletonMap(FileStreamSourceTask.POSITION_FIELD, 41L), records.get(2).sourceOffset()); + assertEquals(Map.of(FileStreamSourceTask.FILENAME_FIELD, tempFile.getAbsolutePath()), records.get(2).sourcePartition()); + assertEquals(Map.of(FileStreamSourceTask.POSITION_FIELD, 41L), records.get(2).sourceOffset()); assertEquals("line4", records.get(3).value()); - assertEquals(Collections.singletonMap(FileStreamSourceTask.FILENAME_FIELD, tempFile.getAbsolutePath()), records.get(3).sourcePartition()); - assertEquals(Collections.singletonMap(FileStreamSourceTask.POSITION_FIELD, 47L), records.get(3).sourceOffset()); + assertEquals(Map.of(FileStreamSourceTask.FILENAME_FIELD, tempFile.getAbsolutePath()), records.get(3).sourcePartition()); + assertEquals(Map.of(FileStreamSourceTask.POSITION_FIELD, 47L), records.get(3).sourceOffset()); os.write("subsequent text".getBytes()); os.flush(); records = task.poll(); assertEquals(1, records.size()); assertEquals("", records.get(0).value()); - assertEquals(Collections.singletonMap(FileStreamSourceTask.FILENAME_FIELD, tempFile.getAbsolutePath()), records.get(0).sourcePartition()); - assertEquals(Collections.singletonMap(FileStreamSourceTask.POSITION_FIELD, 48L), records.get(0).sourceOffset()); + assertEquals(Map.of(FileStreamSourceTask.FILENAME_FIELD, tempFile.getAbsolutePath()), records.get(0).sourcePartition()); + assertEquals(Map.of(FileStreamSourceTask.POSITION_FIELD, 48L), records.get(0).sourceOffset()); os.close(); task.stop(); diff --git a/connect/file/src/test/java/org/apache/kafka/connect/file/integration/FileStreamSourceConnectorIntegrationTest.java b/connect/file/src/test/java/org/apache/kafka/connect/file/integration/FileStreamSourceConnectorIntegrationTest.java index 577b07bb5bd..51096d32107 100644 --- a/connect/file/src/test/java/org/apache/kafka/connect/file/integration/FileStreamSourceConnectorIntegrationTest.java +++ b/connect/file/src/test/java/org/apache/kafka/connect/file/integration/FileStreamSourceConnectorIntegrationTest.java @@ -30,7 +30,6 @@ import java.io.File; import java.io.PrintStream; import java.nio.file.Files; import java.nio.file.StandardOpenOption; -import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.Map; @@ -130,8 +129,8 @@ public class FileStreamSourceConnectorIntegrationTest { // Alter the offsets to make the connector re-process the last line in the file connect.alterSourceConnectorOffset( CONNECTOR_NAME, - Collections.singletonMap(FILENAME_FIELD, sourceFile.getAbsolutePath()), - Collections.singletonMap(POSITION_FIELD, 28L) + Map.of(FILENAME_FIELD, sourceFile.getAbsolutePath()), + Map.of(POSITION_FIELD, 28L) ); connect.resumeConnector(CONNECTOR_NAME); diff --git a/connect/json/src/main/java/org/apache/kafka/connect/json/JsonConverter.java b/connect/json/src/main/java/org/apache/kafka/connect/json/JsonConverter.java index 0e15888f70c..8b3d60133a9 100644 --- a/connect/json/src/main/java/org/apache/kafka/connect/json/JsonConverter.java +++ b/connect/json/src/main/java/org/apache/kafka/connect/json/JsonConverter.java @@ -149,14 +149,12 @@ public class JsonConverter implements Converter, HeaderConverter, Versioned { if (!(value instanceof BigDecimal decimal)) throw new DataException("Invalid type for Decimal, expected BigDecimal but was " + value.getClass()); - switch (config.decimalFormat()) { - case NUMERIC: - return JSON_NODE_FACTORY.numberNode(decimal); - case BASE64: - return JSON_NODE_FACTORY.binaryNode(Decimal.fromLogical(schema, decimal)); - default: + return switch (config.decimalFormat()) { + case NUMERIC -> JSON_NODE_FACTORY.numberNode(decimal); + case BASE64 -> JSON_NODE_FACTORY.binaryNode(Decimal.fromLogical(schema, decimal)); + default -> throw new DataException("Unexpected " + JsonConverterConfig.DECIMAL_FORMAT_CONFIG + ": " + config.decimalFormat()); - } + }; } @Override diff --git a/connect/json/src/main/java/org/apache/kafka/connect/json/JsonDeserializer.java b/connect/json/src/main/java/org/apache/kafka/connect/json/JsonDeserializer.java index 775768f37d3..f88c1d838ab 100644 --- a/connect/json/src/main/java/org/apache/kafka/connect/json/JsonDeserializer.java +++ b/connect/json/src/main/java/org/apache/kafka/connect/json/JsonDeserializer.java @@ -26,7 +26,6 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.JsonNodeFactory; import com.fasterxml.jackson.module.blackbird.BlackbirdModule; -import java.util.Collections; import java.util.Set; /** @@ -40,7 +39,7 @@ public class JsonDeserializer implements Deserializer { * Default constructor needed by Kafka */ public JsonDeserializer() { - this(Collections.emptySet(), new JsonNodeFactory(true), true); + this(Set.of(), new JsonNodeFactory(true), true); } /** diff --git a/connect/json/src/main/java/org/apache/kafka/connect/json/JsonSerializer.java b/connect/json/src/main/java/org/apache/kafka/connect/json/JsonSerializer.java index e40f530469a..8f6adfaf1ff 100644 --- a/connect/json/src/main/java/org/apache/kafka/connect/json/JsonSerializer.java +++ b/connect/json/src/main/java/org/apache/kafka/connect/json/JsonSerializer.java @@ -25,7 +25,6 @@ import com.fasterxml.jackson.databind.SerializationFeature; import com.fasterxml.jackson.databind.node.JsonNodeFactory; import com.fasterxml.jackson.module.blackbird.BlackbirdModule; -import java.util.Collections; import java.util.Set; /** @@ -39,7 +38,7 @@ public class JsonSerializer implements Serializer { * Default constructor needed by Kafka */ public JsonSerializer() { - this(Collections.emptySet(), new JsonNodeFactory(true), true); + this(Set.of(), new JsonNodeFactory(true), true); } /** diff --git a/connect/json/src/test/java/org/apache/kafka/connect/json/JsonConverterConfigTest.java b/connect/json/src/test/java/org/apache/kafka/connect/json/JsonConverterConfigTest.java index 930fb3bb4b8..6b2eabaab1e 100644 --- a/connect/json/src/test/java/org/apache/kafka/connect/json/JsonConverterConfigTest.java +++ b/connect/json/src/test/java/org/apache/kafka/connect/json/JsonConverterConfigTest.java @@ -35,7 +35,7 @@ public class JsonConverterConfigTest { configValues.put(JsonConverterConfig.DECIMAL_FORMAT_CONFIG, "NuMeRiC"); final JsonConverterConfig config = new JsonConverterConfig(configValues); - assertEquals(config.decimalFormat(), DecimalFormat.NUMERIC); + assertEquals(DecimalFormat.NUMERIC, config.decimalFormat()); } } \ No newline at end of file diff --git a/connect/json/src/test/java/org/apache/kafka/connect/json/JsonConverterTest.java b/connect/json/src/test/java/org/apache/kafka/connect/json/JsonConverterTest.java index c4a5356d59f..34010ddac05 100644 --- a/connect/json/src/test/java/org/apache/kafka/connect/json/JsonConverterTest.java +++ b/connect/json/src/test/java/org/apache/kafka/connect/json/JsonConverterTest.java @@ -44,12 +44,11 @@ import java.math.BigInteger; import java.net.URISyntaxException; import java.net.URL; import java.nio.ByteBuffer; -import java.util.Arrays; import java.util.Calendar; -import java.util.Collections; import java.util.GregorianCalendar; import java.util.HashMap; import java.util.HashSet; +import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Set; @@ -74,7 +73,7 @@ public class JsonConverterTest { @BeforeEach public void setUp() { - converter.configure(Collections.emptyMap(), false); + converter.configure(Map.of(), false); } // Schema metadata @@ -155,7 +154,7 @@ public class JsonConverterTest { @Test public void arrayToConnect() { byte[] arrayJson = "{ \"schema\": { \"type\": \"array\", \"items\": { \"type\" : \"int32\" } }, \"payload\": [1, 2, 3] }".getBytes(); - assertEquals(new SchemaAndValue(SchemaBuilder.array(Schema.INT32_SCHEMA).build(), Arrays.asList(1, 2, 3)), converter.toConnectData(TOPIC, arrayJson)); + assertEquals(new SchemaAndValue(SchemaBuilder.array(Schema.INT32_SCHEMA).build(), List.of(1, 2, 3)), converter.toConnectData(TOPIC, arrayJson)); } @Test @@ -211,7 +210,7 @@ public class JsonConverterTest { @Test public void emptyBytesToConnect() { // This characterizes the messages with empty data when Json schemas is disabled - Map props = Collections.singletonMap("schemas.enable", false); + Map props = Map.of("schemas.enable", false); converter.configure(props, true); SchemaAndValue converted = converter.toConnectData(TOPIC, "".getBytes()); assertEquals(SchemaAndValue.NULL, converted); @@ -223,7 +222,7 @@ public class JsonConverterTest { @Test public void schemalessWithEmptyFieldValueToConnect() { // This characterizes the messages with empty data when Json schemas is disabled - Map props = Collections.singletonMap("schemas.enable", false); + Map props = Map.of("schemas.enable", false); converter.configure(props, true); String input = "{ \"a\": \"\", \"b\": null}"; SchemaAndValue converted = converter.toConnectData(TOPIC, input.getBytes()); @@ -254,7 +253,7 @@ public class JsonConverterTest { assertEquals(new SchemaAndValue(null, "a string"), converted); converted = converter.toConnectData(TOPIC, "{ \"schema\": null, \"payload\": [1, \"2\", 3] }".getBytes()); - assertEquals(new SchemaAndValue(null, Arrays.asList(1L, "2", 3L)), converted); + assertEquals(new SchemaAndValue(null, List.of(1L, "2", 3L)), converted); converted = converter.toConnectData(TOPIC, "{ \"schema\": null, \"payload\": { \"field1\": 1, \"field2\": 2} }".getBytes()); Map obj = new HashMap<>(); @@ -587,7 +586,7 @@ public class JsonConverterTest { @Test public void arrayToJson() { Schema int32Array = SchemaBuilder.array(Schema.INT32_SCHEMA).build(); - JsonNode converted = parse(converter.fromConnectData(TOPIC, int32Array, Arrays.asList(1, 2, 3))); + JsonNode converted = parse(converter.fromConnectData(TOPIC, int32Array, List.of(1, 2, 3))); validateEnvelope(converted); assertEquals(parse("{ \"type\": \"array\", \"items\": { \"type\": \"int32\", \"optional\": false }, \"optional\": false }"), converted.get(JsonSchema.ENVELOPE_SCHEMA_FIELD_NAME)); @@ -675,7 +674,7 @@ public class JsonConverterTest { @Test public void decimalToNumericJson() { - converter.configure(Collections.singletonMap(JsonConverterConfig.DECIMAL_FORMAT_CONFIG, DecimalFormat.NUMERIC.name()), false); + converter.configure(Map.of(JsonConverterConfig.DECIMAL_FORMAT_CONFIG, DecimalFormat.NUMERIC.name()), false); JsonNode converted = parse(converter.fromConnectData(TOPIC, Decimal.schema(2), new BigDecimal(new BigInteger("156"), 2))); validateEnvelope(converted); assertEquals(parse("{ \"type\": \"bytes\", \"optional\": false, \"name\": \"org.apache.kafka.connect.data.Decimal\", \"version\": 1, \"parameters\": { \"scale\": \"2\" } }"), @@ -686,7 +685,7 @@ public class JsonConverterTest { @Test public void decimalWithTrailingZerosToNumericJson() { - converter.configure(Collections.singletonMap(JsonConverterConfig.DECIMAL_FORMAT_CONFIG, DecimalFormat.NUMERIC.name()), false); + converter.configure(Map.of(JsonConverterConfig.DECIMAL_FORMAT_CONFIG, DecimalFormat.NUMERIC.name()), false); JsonNode converted = parse(converter.fromConnectData(TOPIC, Decimal.schema(4), new BigDecimal(new BigInteger("15600"), 4))); validateEnvelope(converted); assertEquals(parse("{ \"type\": \"bytes\", \"optional\": false, \"name\": \"org.apache.kafka.connect.data.Decimal\", \"version\": 1, \"parameters\": { \"scale\": \"4\" } }"), @@ -766,7 +765,7 @@ public class JsonConverterTest { public void nullSchemaAndArrayToJson() { // This still needs to do conversion of data, null schema means "anything goes". Make sure we mix and match // types to verify conversion still works. - JsonNode converted = parse(converter.fromConnectData(TOPIC, null, Arrays.asList(1, "string", true))); + JsonNode converted = parse(converter.fromConnectData(TOPIC, null, List.of(1, "string", true))); validateEnvelopeNullSchema(converted); assertTrue(converted.get(JsonSchema.ENVELOPE_SCHEMA_FIELD_NAME).isNull()); assertEquals(JsonNodeFactory.instance.arrayNode().add(1).add("string").add(true), @@ -815,7 +814,7 @@ public class JsonConverterTest { @Test public void nullSchemaAndNullValueToJson() { // This characterizes the production of tombstone messages when Json schemas is enabled - Map props = Collections.singletonMap("schemas.enable", true); + Map props = Map.of("schemas.enable", true); converter.configure(props, true); byte[] converted = converter.fromConnectData(TOPIC, null, null); assertNull(converted); @@ -824,7 +823,7 @@ public class JsonConverterTest { @Test public void nullValueToJson() { // This characterizes the production of tombstone messages when Json schemas is not enabled - Map props = Collections.singletonMap("schemas.enable", false); + Map props = Map.of("schemas.enable", false); converter.configure(props, true); byte[] converted = converter.fromConnectData(TOPIC, null, null); assertNull(converted); @@ -839,14 +838,14 @@ public class JsonConverterTest { @Test public void noSchemaToConnect() { - Map props = Collections.singletonMap("schemas.enable", false); + Map props = Map.of("schemas.enable", false); converter.configure(props, true); assertEquals(new SchemaAndValue(null, true), converter.toConnectData(TOPIC, "true".getBytes())); } @Test public void noSchemaToJson() { - Map props = Collections.singletonMap("schemas.enable", false); + Map props = Map.of("schemas.enable", false); converter.configure(props, true); JsonNode converted = parse(converter.fromConnectData(TOPIC, null, true)); assertTrue(converted.isBoolean()); @@ -876,7 +875,7 @@ public class JsonConverterTest { File propFile = new File(url.toURI()); String workerPropsFile = propFile.getAbsolutePath(); Map workerProps = !workerPropsFile.isEmpty() ? - Utils.propsToStringMap(Utils.loadProps(workerPropsFile)) : Collections.emptyMap(); + Utils.propsToStringMap(Utils.loadProps(workerPropsFile)) : Map.of(); JsonConverter rc = new JsonConverter(); rc.configure(workerProps, false); @@ -901,7 +900,7 @@ public class JsonConverterTest { @Test public void serializeNullToDefault() { - converter.configure(Collections.singletonMap(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, true), false); + converter.configure(Map.of(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, true), false); Schema schema = SchemaBuilder.string().optional().defaultValue("default").build(); JsonNode converted = parse(converter.fromConnectData(TOPIC, schema, null)); JsonNode expected = parse("{\"schema\":{\"type\":\"string\",\"optional\":true,\"default\":\"default\"},\"payload\":\"default\"}"); @@ -910,7 +909,7 @@ public class JsonConverterTest { @Test public void serializeNullToNull() { - converter.configure(Collections.singletonMap(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, false), false); + converter.configure(Map.of(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, false), false); Schema schema = SchemaBuilder.string().optional().defaultValue("default").build(); JsonNode converted = parse(converter.fromConnectData(TOPIC, schema, null)); JsonNode expected = parse("{\"schema\":{\"type\":\"string\",\"optional\":true,\"default\":\"default\"},\"payload\":null}"); @@ -919,7 +918,7 @@ public class JsonConverterTest { @Test public void deserializeNullToDefault() { - converter.configure(Collections.singletonMap(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, true), false); + converter.configure(Map.of(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, true), false); String value = "{\"schema\":{\"type\":\"string\",\"optional\":true,\"default\":\"default\"},\"payload\":null}"; SchemaAndValue sav = converter.toConnectData(TOPIC, null, value.getBytes()); assertEquals("default", sav.value()); @@ -927,7 +926,7 @@ public class JsonConverterTest { @Test public void deserializeNullToNull() { - converter.configure(Collections.singletonMap(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, false), false); + converter.configure(Map.of(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, false), false); String value = "{\"schema\":{\"type\":\"string\",\"optional\":true,\"default\":\"default\"},\"payload\":null}"; SchemaAndValue sav = converter.toConnectData(TOPIC, null, value.getBytes()); assertNull(sav.value()); @@ -935,7 +934,7 @@ public class JsonConverterTest { @Test public void serializeFieldNullToDefault() { - converter.configure(Collections.singletonMap(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, true), false); + converter.configure(Map.of(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, true), false); Schema schema = SchemaBuilder.string().optional().defaultValue("default").build(); Schema structSchema = SchemaBuilder.struct().field("field1", schema).build(); JsonNode converted = parse(converter.fromConnectData(TOPIC, structSchema, new Struct(structSchema))); @@ -945,7 +944,7 @@ public class JsonConverterTest { @Test public void serializeFieldNullToNull() { - converter.configure(Collections.singletonMap(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, false), false); + converter.configure(Map.of(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, false), false); Schema schema = SchemaBuilder.string().optional().defaultValue("default").build(); Schema structSchema = SchemaBuilder.struct().field("field1", schema).build(); JsonNode converted = parse(converter.fromConnectData(TOPIC, structSchema, new Struct(structSchema))); @@ -955,7 +954,7 @@ public class JsonConverterTest { @Test public void deserializeFieldNullToDefault() { - converter.configure(Collections.singletonMap(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, true), false); + converter.configure(Map.of(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, true), false); String value = "{\"schema\":{\"type\":\"struct\",\"fields\":[{\"field\":\"field1\",\"type\":\"string\",\"optional\":true,\"default\":\"default\"}],\"optional\":false},\"payload\":{\"field1\":null}}"; SchemaAndValue sav = converter.toConnectData(TOPIC, null, value.getBytes()); Schema schema = SchemaBuilder.string().optional().defaultValue("default").build(); @@ -965,7 +964,7 @@ public class JsonConverterTest { @Test public void deserializeFieldNullToNull() { - converter.configure(Collections.singletonMap(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, false), false); + converter.configure(Map.of(JsonConverterConfig.REPLACE_NULL_WITH_DEFAULT_CONFIG, false), false); String value = "{\"schema\":{\"type\":\"struct\",\"fields\":[{\"field\":\"field1\",\"type\":\"string\",\"optional\":true,\"default\":\"default\"}],\"optional\":false},\"payload\":{\"field1\":null}}"; SchemaAndValue sav = converter.toConnectData(TOPIC, null, value.getBytes()); Schema schema = SchemaBuilder.string().optional().defaultValue("default").build(); diff --git a/connect/mirror-client/src/main/java/org/apache/kafka/connect/mirror/MirrorClient.java b/connect/mirror-client/src/main/java/org/apache/kafka/connect/mirror/MirrorClient.java index 0b74b64ebbb..06dec5b25ba 100644 --- a/connect/mirror-client/src/main/java/org/apache/kafka/connect/mirror/MirrorClient.java +++ b/connect/mirror-client/src/main/java/org/apache/kafka/connect/mirror/MirrorClient.java @@ -33,7 +33,6 @@ import org.slf4j.LoggerFactory; import java.time.Duration; import java.util.Collection; -import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -165,7 +164,7 @@ public class MirrorClient implements AutoCloseable { // to use ReplicationPolicy to create the checkpoint topic here. String checkpointTopic = replicationPolicy.checkpointsTopic(remoteClusterAlias); List checkpointAssignment = - Collections.singletonList(new TopicPartition(checkpointTopic, 0)); + List.of(new TopicPartition(checkpointTopic, 0)); consumer.assign(checkpointAssignment); consumer.seekToBeginning(checkpointAssignment); while (System.currentTimeMillis() < deadline && !endOfStream(consumer, checkpointAssignment)) { diff --git a/connect/mirror-client/src/test/java/org/apache/kafka/connect/mirror/MirrorClientTest.java b/connect/mirror-client/src/test/java/org/apache/kafka/connect/mirror/MirrorClientTest.java index f7dbac5ad97..5e99f6cd74e 100644 --- a/connect/mirror-client/src/test/java/org/apache/kafka/connect/mirror/MirrorClientTest.java +++ b/connect/mirror-client/src/test/java/org/apache/kafka/connect/mirror/MirrorClientTest.java @@ -20,10 +20,9 @@ import org.apache.kafka.common.Configurable; import org.junit.jupiter.api.Test; -import java.util.Arrays; -import java.util.Collections; import java.util.HashSet; import java.util.List; +import java.util.Map; import java.util.Set; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -46,7 +45,7 @@ public class MirrorClientTest { } FakeMirrorClient() { - this(Collections.emptyList()); + this(List.of()); } @Override @@ -94,7 +93,7 @@ public class MirrorClientTest { @Test public void heartbeatTopicsTest() throws InterruptedException { - MirrorClient client = new FakeMirrorClient(Arrays.asList("topic1", "topic2", "heartbeats", + MirrorClient client = new FakeMirrorClient(List.of("topic1", "topic2", "heartbeats", "source1.heartbeats", "source2.source1.heartbeats", "source3.heartbeats")); Set heartbeatTopics = client.heartbeatTopics(); assertEquals(heartbeatTopics, Set.of("heartbeats", "source1.heartbeats", @@ -103,7 +102,7 @@ public class MirrorClientTest { @Test public void checkpointsTopicsTest() throws InterruptedException { - MirrorClient client = new FakeMirrorClient(Arrays.asList("topic1", "topic2", "checkpoints.internal", + MirrorClient client = new FakeMirrorClient(List.of("topic1", "topic2", "checkpoints.internal", "source1.checkpoints.internal", "source2.source1.checkpoints.internal", "source3.checkpoints.internal")); Set checkpointTopics = client.checkpointTopics(); assertEquals(Set.of("source1.checkpoints.internal", @@ -112,7 +111,7 @@ public class MirrorClientTest { @Test public void replicationHopsTest() throws InterruptedException { - MirrorClient client = new FakeMirrorClient(Arrays.asList("topic1", "topic2", "heartbeats", + MirrorClient client = new FakeMirrorClient(List.of("topic1", "topic2", "heartbeats", "source1.heartbeats", "source1.source2.heartbeats", "source3.heartbeats")); assertEquals(1, client.replicationHops("source1")); assertEquals(2, client.replicationHops("source2")); @@ -122,7 +121,7 @@ public class MirrorClientTest { @Test public void upstreamClustersTest() throws InterruptedException { - MirrorClient client = new FakeMirrorClient(Arrays.asList("topic1", "topic2", "heartbeats", + MirrorClient client = new FakeMirrorClient(List.of("topic1", "topic2", "heartbeats", "source1.heartbeats", "source1.source2.heartbeats", "source3.source4.source5.heartbeats")); Set sources = client.upstreamClusters(); assertTrue(sources.contains("source1")); @@ -138,7 +137,7 @@ public class MirrorClientTest { @Test public void testIdentityReplicationUpstreamClusters() throws InterruptedException { // IdentityReplicationPolicy treats heartbeats as a special case, so these should work as usual. - MirrorClient client = new FakeMirrorClient(identityReplicationPolicy("source"), Arrays.asList("topic1", + MirrorClient client = new FakeMirrorClient(identityReplicationPolicy("source"), List.of("topic1", "topic2", "heartbeats", "source1.heartbeats", "source1.source2.heartbeats", "source3.source4.source5.heartbeats")); Set sources = client.upstreamClusters(); @@ -154,7 +153,7 @@ public class MirrorClientTest { @Test public void remoteTopicsTest() throws InterruptedException { - MirrorClient client = new FakeMirrorClient(Arrays.asList("topic1", "topic2", "topic3", + MirrorClient client = new FakeMirrorClient(List.of("topic1", "topic2", "topic3", "source1.topic4", "source1.source2.topic5", "source3.source4.source5.topic6")); Set remoteTopics = client.remoteTopics(); assertFalse(remoteTopics.contains("topic1")); @@ -168,7 +167,7 @@ public class MirrorClientTest { @Test public void testIdentityReplicationRemoteTopics() throws InterruptedException { // IdentityReplicationPolicy should consider any topic to be remote. - MirrorClient client = new FakeMirrorClient(identityReplicationPolicy("source"), Arrays.asList( + MirrorClient client = new FakeMirrorClient(identityReplicationPolicy("source"), List.of( "topic1", "topic2", "topic3", "heartbeats", "backup.heartbeats")); Set remoteTopics = client.remoteTopics(); assertTrue(remoteTopics.contains("topic1")); @@ -181,10 +180,10 @@ public class MirrorClientTest { @Test public void remoteTopicsSeparatorTest() throws InterruptedException { - MirrorClient client = new FakeMirrorClient(Arrays.asList("topic1", "topic2", "topic3", + MirrorClient client = new FakeMirrorClient(List.of("topic1", "topic2", "topic3", "source1__topic4", "source1__source2__topic5", "source3__source4__source5__topic6")); ((Configurable) client.replicationPolicy()).configure( - Collections.singletonMap("replication.policy.separator", "__")); + Map.of("replication.policy.separator", "__")); Set remoteTopics = client.remoteTopics(); assertFalse(remoteTopics.contains("topic1")); assertFalse(remoteTopics.contains("topic2")); @@ -197,7 +196,7 @@ public class MirrorClientTest { @Test public void testIdentityReplicationTopicSource() { MirrorClient client = new FakeMirrorClient( - identityReplicationPolicy("primary"), Collections.emptyList()); + identityReplicationPolicy("primary"), List.of()); assertEquals("topic1", client.replicationPolicy() .formatRemoteTopic("primary", "topic1")); assertEquals("primary", client.replicationPolicy() @@ -211,8 +210,7 @@ public class MirrorClientTest { private ReplicationPolicy identityReplicationPolicy(String source) { IdentityReplicationPolicy policy = new IdentityReplicationPolicy(); - policy.configure(Collections.singletonMap( - IdentityReplicationPolicy.SOURCE_CLUSTER_ALIAS_CONFIG, source)); + policy.configure(Map.of(IdentityReplicationPolicy.SOURCE_CLUSTER_ALIAS_CONFIG, source)); return policy; } } diff --git a/connect/mirror-client/src/test/java/org/apache/kafka/connect/mirror/ReplicationPolicyTest.java b/connect/mirror-client/src/test/java/org/apache/kafka/connect/mirror/ReplicationPolicyTest.java index 86aaf8ffd0e..e59348b05a4 100644 --- a/connect/mirror-client/src/test/java/org/apache/kafka/connect/mirror/ReplicationPolicyTest.java +++ b/connect/mirror-client/src/test/java/org/apache/kafka/connect/mirror/ReplicationPolicyTest.java @@ -20,7 +20,6 @@ package org.apache.kafka.connect.mirror; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import java.util.Collections; import java.util.HashMap; import java.util.Map; @@ -33,7 +32,7 @@ public class ReplicationPolicyTest { @BeforeEach public void setUp() { - DEFAULT_REPLICATION_POLICY.configure(Collections.emptyMap()); + DEFAULT_REPLICATION_POLICY.configure(Map.of()); } @Test diff --git a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/CheckpointStore.java b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/CheckpointStore.java index 2e88977d93c..39aea181b66 100644 --- a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/CheckpointStore.java +++ b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/CheckpointStore.java @@ -30,7 +30,6 @@ import org.apache.kafka.connect.util.TopicAdmin; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Map; @@ -97,7 +96,7 @@ public class CheckpointStore implements AutoCloseable { public Map get(String group) { Map result = checkpointsPerConsumerGroup.get(group); - return result == null ? null : Collections.unmodifiableMap(result); + return result == null ? null : Map.copyOf(result); } public Map> computeConvertedUpstreamOffset() { diff --git a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorCheckpointConnector.java b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorCheckpointConnector.java index 74b77850c86..9f8472c9c35 100644 --- a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorCheckpointConnector.java +++ b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorCheckpointConnector.java @@ -38,7 +38,6 @@ import org.slf4j.LoggerFactory; import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Map; @@ -136,7 +135,7 @@ public class MirrorCheckpointConnector extends SourceConnector { // If the replication is disabled or checkpoint emission is disabled by setting 'emit.checkpoints.enabled' to false, // the interval of checkpoint emission will be negative and no 'MirrorCheckpointTask' will be created. if (!config.enabled() || config.emitCheckpointsInterval().isNegative()) { - return Collections.emptyList(); + return List.of(); } if (knownConsumerGroups == null) { @@ -148,7 +147,7 @@ public class MirrorCheckpointConnector extends SourceConnector { // If the consumer group is empty, no 'MirrorCheckpointTask' will be created. if (knownConsumerGroups.isEmpty()) { - return Collections.emptyList(); + return List.of(); } int numTasks = Math.min(maxTasks, knownConsumerGroups.size()); @@ -199,7 +198,7 @@ public class MirrorCheckpointConnector extends SourceConnector { throws InterruptedException, ExecutionException { // If loadInitialConsumerGroups fails for any reason(e.g., timeout), knownConsumerGroups may be null. // We still want this method to recover gracefully in such cases. - Set knownConsumerGroups = this.knownConsumerGroups == null ? Collections.emptySet() : this.knownConsumerGroups; + Set knownConsumerGroups = this.knownConsumerGroups == null ? Set.of() : this.knownConsumerGroups; Set consumerGroups = findConsumerGroups(); Set newConsumerGroups = new HashSet<>(consumerGroups); newConsumerGroups.removeAll(knownConsumerGroups); diff --git a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorCheckpointTask.java b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorCheckpointTask.java index 254e2bf8ca6..ecaf6bd7bd7 100644 --- a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorCheckpointTask.java +++ b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorCheckpointTask.java @@ -35,7 +35,6 @@ import org.slf4j.LoggerFactory; import java.time.Duration; import java.util.ArrayList; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -186,7 +185,7 @@ public class MirrorCheckpointTask extends SourceTask { .collect(Collectors.toList()); } catch (ExecutionException e) { log.error("Error querying offsets for consumer group {} on cluster {}.", group, sourceClusterAlias, e); - return Collections.emptyList(); + return List.of(); } } @@ -195,7 +194,7 @@ public class MirrorCheckpointTask extends SourceTask { return upstreamGroupOffsets.entrySet().stream() .filter(x -> shouldCheckpointTopic(x.getKey().topic())) // Only perform relevant checkpoints filtered by "topic filter" .map(x -> checkpoint(group, x.getKey(), x.getValue())) - .flatMap(o -> o.stream()) // do not emit checkpoints for partitions that don't have offset-syncs + .flatMap(Optional::stream) // do not emit checkpoints for partitions that don't have offset-syncs .filter(x -> x.downstreamOffset() >= 0) // ignore offsets we cannot translate accurately .filter(this::checkpointIsMoreRecent) // do not emit checkpoints for partitions that have a later checkpoint .collect(Collectors.toMap(Checkpoint::topicPartition, Function.identity())); @@ -234,7 +233,7 @@ public class MirrorCheckpointTask extends SourceTask { throws InterruptedException, ExecutionException { if (stopping) { // short circuit if stopping - return Collections.emptyMap(); + return Map.of(); } return adminCall( () -> sourceAdminClient.listConsumerGroupOffsets(group).partitionsToOffsetAndMetadata().get(), diff --git a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorCheckpointTaskConfig.java b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorCheckpointTaskConfig.java index a8db4989b29..0617a4728c2 100644 --- a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorCheckpointTaskConfig.java +++ b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorCheckpointTaskConfig.java @@ -18,7 +18,6 @@ package org.apache.kafka.connect.mirror; import org.apache.kafka.common.config.ConfigDef; -import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Map; @@ -35,7 +34,7 @@ public class MirrorCheckpointTaskConfig extends MirrorCheckpointConfig { Set taskConsumerGroups() { List fields = getList(TASK_CONSUMER_GROUPS); if (fields == null || fields.isEmpty()) { - return Collections.emptySet(); + return Set.of(); } return new HashSet<>(fields); } diff --git a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorHeartbeatConnector.java b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorHeartbeatConnector.java index f9a844fecfa..20133922937 100644 --- a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorHeartbeatConnector.java +++ b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorHeartbeatConnector.java @@ -24,7 +24,6 @@ import org.apache.kafka.connect.connector.Task; import org.apache.kafka.connect.errors.ConnectException; import org.apache.kafka.connect.source.SourceConnector; -import java.util.Collections; import java.util.List; import java.util.Map; @@ -73,10 +72,10 @@ public class MirrorHeartbeatConnector extends SourceConnector { // if the heartbeats emission is disabled by setting `emit.heartbeats.enabled` to `false`, // the interval heartbeat emission will be negative and no `MirrorHeartbeatTask` will be created if (config.emitHeartbeatsInterval().isNegative()) { - return Collections.emptyList(); + return List.of(); } // just need a single task - return Collections.singletonList(config.originalsStrings()); + return List.of(config.originalsStrings()); } @Override diff --git a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorHeartbeatTask.java b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorHeartbeatTask.java index 35c9c8feccb..0a4a1374ca2 100644 --- a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorHeartbeatTask.java +++ b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorHeartbeatTask.java @@ -22,7 +22,6 @@ import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.source.SourceTask; import java.time.Duration; -import java.util.Collections; import java.util.List; import java.util.Map; import java.util.concurrent.CountDownLatch; @@ -76,7 +75,7 @@ public class MirrorHeartbeatTask extends SourceTask { Schema.BYTES_SCHEMA, heartbeat.recordKey(), Schema.BYTES_SCHEMA, heartbeat.recordValue(), timestamp); - return Collections.singletonList(record); + return List.of(record); } @Override diff --git a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorMaker.java b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorMaker.java index b04a4d7bb72..c26d326b223 100644 --- a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorMaker.java +++ b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorMaker.java @@ -57,7 +57,6 @@ import java.net.URI; import java.net.URLEncoder; import java.net.UnknownHostException; import java.nio.charset.StandardCharsets; -import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -250,7 +249,7 @@ public class MirrorMaker { SharedTopicAdmin sharedAdmin = new SharedTopicAdmin(adminProps); KafkaOffsetBackingStore offsetBackingStore = new KafkaOffsetBackingStore(sharedAdmin, () -> clientIdBase, plugins.newInternalConverter(true, JsonConverter.class.getName(), - Collections.singletonMap(JsonConverterConfig.SCHEMAS_ENABLE_CONFIG, "false"))); + Map.of(JsonConverterConfig.SCHEMAS_ENABLE_CONFIG, "false"))); offsetBackingStore.configure(distributedConfig); ConnectorClientConfigOverridePolicy clientConfigOverridePolicy = new AllConnectorClientConfigOverridePolicy(); clientConfigOverridePolicy.configure(config.originals()); diff --git a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorMakerConfig.java b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorMakerConfig.java index aba62cf8464..01e70e0af97 100644 --- a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorMakerConfig.java +++ b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorMakerConfig.java @@ -31,8 +31,6 @@ import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.runtime.rest.RestServerConfig; import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -215,14 +213,9 @@ public final class MirrorMakerConfig extends AbstractConfig { Set allConfigNames() { Set allNames = new HashSet<>(); - List connectorConfigDefs = Arrays.asList( - MirrorCheckpointConfig.CONNECTOR_CONFIG_DEF, - MirrorSourceConfig.CONNECTOR_CONFIG_DEF, - MirrorHeartbeatConfig.CONNECTOR_CONFIG_DEF - ); - for (ConfigDef cd : connectorConfigDefs) { - allNames.addAll(cd.names()); - } + allNames.addAll(MirrorCheckpointConfig.CONNECTOR_CONFIG_DEF.names()); + allNames.addAll(MirrorSourceConfig.CONNECTOR_CONFIG_DEF.names()); + allNames.addAll(MirrorHeartbeatConfig.CONNECTOR_CONFIG_DEF.names()); return allNames; } @@ -288,7 +281,7 @@ public final class MirrorMakerConfig extends AbstractConfig { ConfigDef result = new ConfigDef() .define(CLUSTERS_CONFIG, Type.LIST, Importance.HIGH, CLUSTERS_DOC) .define(ENABLE_INTERNAL_REST_CONFIG, Type.BOOLEAN, false, Importance.HIGH, ENABLE_INTERNAL_REST_DOC) - .define(CONFIG_PROVIDERS_CONFIG, Type.LIST, Collections.emptyList(), Importance.LOW, CONFIG_PROVIDERS_DOC) + .define(CONFIG_PROVIDERS_CONFIG, Type.LIST, List.of(), Importance.LOW, CONFIG_PROVIDERS_DOC) // security support .define(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, Type.STRING, diff --git a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorSourceConnector.java b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorSourceConnector.java index a129390b397..a9d7779673e 100644 --- a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorSourceConnector.java +++ b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorSourceConnector.java @@ -55,7 +55,6 @@ import org.slf4j.LoggerFactory; import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -99,8 +98,8 @@ public class MirrorSourceConnector extends SourceConnector { private String connectorName; private TopicFilter topicFilter; private ConfigPropertyFilter configPropertyFilter; - private List knownSourceTopicPartitions = Collections.emptyList(); - private List knownTargetTopicPartitions = Collections.emptyList(); + private List knownSourceTopicPartitions = List.of(); + private List knownTargetTopicPartitions = List.of(); private ReplicationPolicy replicationPolicy; private int replicationFactor; private Admin sourceAdminClient; @@ -202,7 +201,7 @@ public class MirrorSourceConnector extends SourceConnector { @Override public List> taskConfigs(int maxTasks) { if (!config.enabled() || knownSourceTopicPartitions.isEmpty()) { - return Collections.emptyList(); + return List.of(); } int numTasks = Math.min(maxTasks, knownSourceTopicPartitions.size()); List> roundRobinByTask = new ArrayList<>(numTasks); diff --git a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorSourceTaskConfig.java b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorSourceTaskConfig.java index f0c562bbcbb..3d99d12cdd5 100644 --- a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorSourceTaskConfig.java +++ b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorSourceTaskConfig.java @@ -19,7 +19,6 @@ package org.apache.kafka.connect.mirror; import org.apache.kafka.common.TopicPartition; import org.apache.kafka.common.config.ConfigDef; -import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Set; @@ -36,7 +35,7 @@ public class MirrorSourceTaskConfig extends MirrorSourceConfig { Set taskTopicPartitions() { List fields = getList(TASK_TOPIC_PARTITIONS); if (fields == null || fields.isEmpty()) { - return Collections.emptySet(); + return Set.of(); } return fields.stream() .map(MirrorUtils::decodeTopicPartition) diff --git a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorUtils.java b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorUtils.java index d8cbba184a4..fdf091c106f 100644 --- a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorUtils.java +++ b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/MirrorUtils.java @@ -38,19 +38,16 @@ import org.apache.kafka.connect.util.TopicAdmin; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.Set; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.function.Supplier; import java.util.regex.Pattern; -import static java.util.Collections.singleton; - /** Internal utility methods. */ public final class MirrorUtils { @@ -84,7 +81,7 @@ public final class MirrorUtils { } public static Map wrapOffset(long offset) { - return Collections.singletonMap(OFFSET_KEY, offset); + return Map.of(OFFSET_KEY, offset); } public static TopicPartition unwrapPartition(Map wrapped) { @@ -265,7 +262,7 @@ public final class MirrorUtils { } static Pattern compilePatternList(String fields) { - return compilePatternList(Arrays.asList(fields.split("\\W*,\\W*"))); + return compilePatternList(List.of(fields.split("\\W*,\\W*"))); } static void createCompactedTopic(String topicName, short partitions, short replicationFactor, Admin admin) { @@ -277,7 +274,7 @@ public final class MirrorUtils { CreateTopicsOptions args = new CreateTopicsOptions().validateOnly(false); try { - admin.createTopics(singleton(topicDescription), args).values().get(topicName).get(); + admin.createTopics(Set.of(topicDescription), args).values().get(topicName).get(); log.info("Created topic '{}'", topicName); } catch (InterruptedException e) { Thread.interrupted(); diff --git a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/rest/MirrorRestServer.java b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/rest/MirrorRestServer.java index f09cb12b0f0..3cc50819e2c 100644 --- a/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/rest/MirrorRestServer.java +++ b/connect/mirror/src/main/java/org/apache/kafka/connect/mirror/rest/MirrorRestServer.java @@ -28,7 +28,7 @@ import org.glassfish.hk2.utilities.binding.AbstractBinder; import org.glassfish.jersey.server.ResourceConfig; import java.util.Collection; -import java.util.Collections; +import java.util.List; import java.util.Map; public class MirrorRestServer extends RestServer { @@ -48,14 +48,12 @@ public class MirrorRestServer extends RestServer { @Override protected Collection> regularResources() { - return Collections.singletonList( - InternalMirrorResource.class - ); + return List.of(InternalMirrorResource.class); } @Override protected Collection> adminResources() { - return Collections.emptyList(); + return List.of(); } @Override @@ -70,5 +68,4 @@ public class MirrorRestServer extends RestServer { bind(restClient).to(RestClient.class); } } - } diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/CheckpointStoreTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/CheckpointStoreTest.java index 476fbcceaef..b11d1ffdc99 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/CheckpointStoreTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/CheckpointStoreTest.java @@ -23,7 +23,6 @@ import org.apache.kafka.connect.util.Callback; import org.junit.jupiter.api.Test; -import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Map; @@ -63,7 +62,7 @@ public class CheckpointStoreTest { assertTrue(store.isInitialized()); Map> expected = new HashMap<>(); - expected.put("group1", Collections.singletonMap(new TopicPartition("t1", 0), + expected.put("group1", Map.of(new TopicPartition("t1", 0), new Checkpoint("group1", new TopicPartition("t1", 0), 1, 1, ""))); assertEquals(expected, store.checkpointsPerConsumerGroup); } diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorCheckpointConfigTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorCheckpointConfigTest.java index ccd381ceadb..1ee27ba0ffe 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorCheckpointConfigTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorCheckpointConfigTest.java @@ -20,8 +20,6 @@ import org.apache.kafka.common.config.ConfigDef; import org.junit.jupiter.api.Test; -import java.util.Arrays; -import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Map; @@ -37,7 +35,7 @@ public class MirrorCheckpointConfigTest { @Test public void testTaskConfigConsumerGroups() { - List groups = Arrays.asList("consumer-1", "consumer-2", "consumer-3"); + List groups = List.of("consumer-1", "consumer-2", "consumer-3"); MirrorCheckpointConfig config = new MirrorCheckpointConfig(makeProps()); Map props = config.taskConfigForConsumerGroups(groups, 1); MirrorCheckpointTaskConfig taskConfig = new MirrorCheckpointTaskConfig(props); @@ -118,7 +116,7 @@ public class MirrorCheckpointConfigTest { Map configValues = MirrorCheckpointConfig.validate(makeProps( MirrorCheckpointConfig.EMIT_CHECKPOINTS_ENABLED, "false", MirrorCheckpointConfig.SYNC_GROUP_OFFSETS_ENABLED, "false")); - assertEquals(configValues.keySet(), Collections.singleton(MirrorCheckpointConfig.EMIT_CHECKPOINTS_ENABLED)); + assertEquals(configValues.keySet(), Set.of(MirrorCheckpointConfig.EMIT_CHECKPOINTS_ENABLED)); configValues = MirrorCheckpointConfig.validate(makeProps(MirrorCheckpointConfig.EMIT_CHECKPOINTS_ENABLED, "true", MirrorCheckpointConfig.EMIT_OFFSET_SYNCS_ENABLED, "false")); diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorCheckpointConnectorTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorCheckpointConnectorTest.java index 4ae32701bb9..d800e74fbfc 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorCheckpointConnectorTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorCheckpointConnectorTest.java @@ -26,7 +26,6 @@ import org.apache.kafka.connect.errors.RetriableException; import org.junit.jupiter.api.Test; -import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.HashMap; @@ -144,10 +143,10 @@ public class MirrorCheckpointConnectorTest { @Test public void testFindConsumerGroups() throws Exception { MirrorCheckpointConfig config = new MirrorCheckpointConfig(makeProps()); - MirrorCheckpointConnector connector = new MirrorCheckpointConnector(Collections.emptySet(), config); + MirrorCheckpointConnector connector = new MirrorCheckpointConnector(Set.of(), config); connector = spy(connector); - Collection groups = Arrays.asList( + Collection groups = List.of( new GroupListing("g1", Optional.of(GroupType.CLASSIC), "", Optional.empty()), new GroupListing("g2", Optional.of(GroupType.CLASSIC), ConsumerProtocol.PROTOCOL_TYPE, Optional.empty())); Map offsets = new HashMap<>(); @@ -168,16 +167,16 @@ public class MirrorCheckpointConnectorTest { doReturn(false).when(connector).shouldReplicateByTopicFilter(anyString()); Set topicFilterGroupFound = connector.findConsumerGroups(); - assertEquals(Collections.emptySet(), topicFilterGroupFound); + assertEquals(Set.of(), topicFilterGroupFound); } @Test public void testFindConsumerGroupsInCommonScenarios() throws Exception { MirrorCheckpointConfig config = new MirrorCheckpointConfig(makeProps()); - MirrorCheckpointConnector connector = new MirrorCheckpointConnector(Collections.emptySet(), config); + MirrorCheckpointConnector connector = new MirrorCheckpointConnector(Set.of(), config); connector = spy(connector); - Collection groups = Arrays.asList( + Collection groups = List.of( new GroupListing("g1", Optional.of(GroupType.CLASSIC), "", Optional.empty()), new GroupListing("g2", Optional.of(GroupType.CLASSIC), ConsumerProtocol.PROTOCOL_TYPE, Optional.empty()), new GroupListing("g3", Optional.of(GroupType.CLASSIC), ConsumerProtocol.PROTOCOL_TYPE, Optional.empty()), @@ -203,7 +202,7 @@ public class MirrorCheckpointConnectorTest { groupToOffsets.put("g1", offsetsForGroup1); groupToOffsets.put("g2", offsetsForGroup2); groupToOffsets.put("g3", offsetsForGroup3); - doReturn(groupToOffsets).when(connector).listConsumerGroupOffsets(Arrays.asList("g1", "g2", "g3")); + doReturn(groupToOffsets).when(connector).listConsumerGroupOffsets(List.of("g1", "g2", "g3")); Set groupFound = connector.findConsumerGroups(); Set verifiedSet = new HashSet<>(); @@ -215,8 +214,8 @@ public class MirrorCheckpointConnectorTest { @Test public void testAlterOffsetsIncorrectPartitionKey() { MirrorCheckpointConnector connector = new MirrorCheckpointConnector(); - assertThrows(ConnectException.class, () -> connector.alterOffsets(null, Collections.singletonMap( - Collections.singletonMap("unused_partition_key", "unused_partition_value"), + assertThrows(ConnectException.class, () -> connector.alterOffsets(null, Map.of( + Map.of("unused_partition_key", "unused_partition_value"), SOURCE_OFFSET ))); @@ -231,7 +230,7 @@ public class MirrorCheckpointConnectorTest { public void testAlterOffsetsMissingPartitionKey() { MirrorCheckpointConnector connector = new MirrorCheckpointConnector(); - Function, Boolean> alterOffsets = partition -> connector.alterOffsets(null, Collections.singletonMap( + Function, Boolean> alterOffsets = partition -> connector.alterOffsets(null, Map.of( partition, SOURCE_OFFSET )); @@ -240,7 +239,7 @@ public class MirrorCheckpointConnectorTest { // Sanity check to make sure our valid partition is actually valid assertTrue(alterOffsets.apply(validPartition)); - for (String key : Arrays.asList(CONSUMER_GROUP_ID_KEY, TOPIC_KEY, PARTITION_KEY)) { + for (String key : List.of(CONSUMER_GROUP_ID_KEY, TOPIC_KEY, PARTITION_KEY)) { Map invalidPartition = new HashMap<>(validPartition); invalidPartition.remove(key); assertThrows(ConnectException.class, () -> alterOffsets.apply(invalidPartition)); @@ -252,7 +251,7 @@ public class MirrorCheckpointConnectorTest { MirrorCheckpointConnector connector = new MirrorCheckpointConnector(); Map partition = sourcePartition("consumer-app-2", "t", 3); partition.put(PARTITION_KEY, "a string"); - assertThrows(ConnectException.class, () -> connector.alterOffsets(null, Collections.singletonMap( + assertThrows(ConnectException.class, () -> connector.alterOffsets(null, Map.of( partition, SOURCE_OFFSET ))); @@ -276,9 +275,9 @@ public class MirrorCheckpointConnectorTest { public void testAlterOffsetsIncorrectOffsetKey() { MirrorCheckpointConnector connector = new MirrorCheckpointConnector(); - Map, Map> offsets = Collections.singletonMap( + Map, Map> offsets = Map.of( sourcePartition("consumer-app-5", "t1", 2), - Collections.singletonMap("unused_offset_key", 0) + Map.of("unused_offset_key", 0) ); assertThrows(ConnectException.class, () -> connector.alterOffsets(null, offsets)); } @@ -287,7 +286,7 @@ public class MirrorCheckpointConnectorTest { public void testAlterOffsetsOffsetValues() { MirrorCheckpointConnector connector = new MirrorCheckpointConnector(); - Function alterOffsets = offset -> connector.alterOffsets(null, Collections.singletonMap( + Function alterOffsets = offset -> connector.alterOffsets(null, Map.of( sourcePartition("consumer-app-6", "t", 5), Collections.singletonMap(MirrorUtils.OFFSET_KEY, offset) )); @@ -308,7 +307,7 @@ public class MirrorCheckpointConnectorTest { public void testSuccessfulAlterOffsets() { MirrorCheckpointConnector connector = new MirrorCheckpointConnector(); - Map, Map> offsets = Collections.singletonMap( + Map, Map> offsets = Map.of( sourcePartition("consumer-app-7", "t2", 0), SOURCE_OFFSET ); @@ -317,7 +316,7 @@ public class MirrorCheckpointConnectorTest { // since it could indicate that the offsets were reset previously or that no offsets have been committed yet // (for a reset operation) assertTrue(connector.alterOffsets(null, offsets)); - assertTrue(connector.alterOffsets(null, Collections.emptyMap())); + assertTrue(connector.alterOffsets(null, Map.of())); } @Test @@ -337,8 +336,8 @@ public class MirrorCheckpointConnectorTest { assertTrue(() -> alterOffsets.apply(partition)); assertTrue(() -> alterOffsets.apply(null)); - assertTrue(() -> alterOffsets.apply(Collections.emptyMap())); - assertTrue(() -> alterOffsets.apply(Collections.singletonMap("unused_partition_key", "unused_partition_value"))); + assertTrue(() -> alterOffsets.apply(Map.of())); + assertTrue(() -> alterOffsets.apply(Map.of("unused_partition_key", "unused_partition_value"))); } private static Map sourcePartition(String consumerGroupId, String topic, int partition) { diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorCheckpointTaskTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorCheckpointTaskTest.java index f4cc1e4ced6..7ce554d5f66 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorCheckpointTaskTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorCheckpointTaskTest.java @@ -22,12 +22,12 @@ import org.apache.kafka.connect.source.SourceRecord; import org.junit.jupiter.api.Test; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Optional; import java.util.OptionalLong; +import java.util.Set; import java.util.concurrent.ExecutionException; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -43,8 +43,8 @@ public class MirrorCheckpointTaskTest { @Test public void testDownstreamTopicRenaming() { MirrorCheckpointTask mirrorCheckpointTask = new MirrorCheckpointTask("source1", "target2", - new DefaultReplicationPolicy(), null, Collections.emptySet(), Collections.emptyMap(), - new CheckpointStore(Collections.emptyMap())); + new DefaultReplicationPolicy(), null, Set.of(), Map.of(), + new CheckpointStore(Map.of())); assertEquals(new TopicPartition("source1.topic3", 4), mirrorCheckpointTask.renameTopicPartition(new TopicPartition("topic3", 4)), "Renaming source1.topic3 failed"); @@ -65,8 +65,8 @@ public class MirrorCheckpointTaskTest { OffsetSyncStoreTest.FakeOffsetSyncStore offsetSyncStore = new OffsetSyncStoreTest.FakeOffsetSyncStore(); offsetSyncStore.start(true); MirrorCheckpointTask mirrorCheckpointTask = new MirrorCheckpointTask("source1", "target2", - new DefaultReplicationPolicy(), offsetSyncStore, Collections.emptySet(), - Collections.emptyMap(), new CheckpointStore(Collections.emptyMap())); + new DefaultReplicationPolicy(), offsetSyncStore, Set.of(), + Map.of(), new CheckpointStore(Map.of())); offsetSyncStore.sync(new TopicPartition("topic1", 2), t1UpstreamOffset, t1DownstreamOffset); offsetSyncStore.sync(new TopicPartition("target2.topic5", 6), t2UpstreamOffset, t2DownstreamOffset); Optional optionalCheckpoint1 = mirrorCheckpointTask.checkpoint("group9", new TopicPartition("topic1", 2), @@ -166,7 +166,7 @@ public class MirrorCheckpointTaskTest { checkpointsPerConsumerGroup.put(consumer2, checkpointMapC2); MirrorCheckpointTask mirrorCheckpointTask = new MirrorCheckpointTask("source1", "target2", - new DefaultReplicationPolicy(), null, Collections.emptySet(), idleConsumerGroupsOffset, + new DefaultReplicationPolicy(), null, Set.of(), idleConsumerGroupsOffset, new CheckpointStore(checkpointsPerConsumerGroup)); Map> output = mirrorCheckpointTask.syncGroupOffset(); @@ -197,7 +197,7 @@ public class MirrorCheckpointTaskTest { checkpointsPerConsumerGroup.put(consumer, checkpointMap); MirrorCheckpointTask mirrorCheckpointTask = new MirrorCheckpointTask("source", "target", - new DefaultReplicationPolicy(), null, Collections.emptySet(), idleConsumerGroupsOffset, + new DefaultReplicationPolicy(), null, Set.of(), idleConsumerGroupsOffset, new CheckpointStore(checkpointsPerConsumerGroup)); Map> output = mirrorCheckpointTask.syncGroupOffset(); @@ -210,8 +210,8 @@ public class MirrorCheckpointTaskTest { OffsetSyncStoreTest.FakeOffsetSyncStore offsetSyncStore = new OffsetSyncStoreTest.FakeOffsetSyncStore(); offsetSyncStore.start(true); MirrorCheckpointTask mirrorCheckpointTask = new MirrorCheckpointTask("source1", "target2", - new DefaultReplicationPolicy(), offsetSyncStore, Collections.emptySet(), Collections.emptyMap(), - new CheckpointStore(Collections.emptyMap())); + new DefaultReplicationPolicy(), offsetSyncStore, Set.of(), Map.of(), + new CheckpointStore(Map.of())); offsetSyncStore.sync(new TopicPartition("topic1", 0), 3L, 4L); Optional checkpoint1 = mirrorCheckpointTask.checkpoint("group9", new TopicPartition("topic1", 1), @@ -227,8 +227,8 @@ public class MirrorCheckpointTaskTest { OffsetSyncStoreTest.FakeOffsetSyncStore offsetSyncStore = new OffsetSyncStoreTest.FakeOffsetSyncStore(); offsetSyncStore.start(true); MirrorCheckpointTask mirrorCheckpointTask = new MirrorCheckpointTask("source1", "target2", - new DefaultReplicationPolicy(), offsetSyncStore, Collections.emptySet(), Collections.emptyMap(), - new CheckpointStore(Collections.emptyMap())); + new DefaultReplicationPolicy(), offsetSyncStore, Set.of(), Map.of(), + new CheckpointStore(Map.of())); offsetSyncStore.sync(new TopicPartition("topic1", 0), 1L, 3L); Optional checkpoint = mirrorCheckpointTask.checkpoint("g1", new TopicPartition("topic1", 0), null); assertFalse(checkpoint.isPresent()); @@ -240,7 +240,7 @@ public class MirrorCheckpointTaskTest { offsetSyncStore.start(true); Map> checkpointsPerConsumerGroup = new HashMap<>(); MirrorCheckpointTask mirrorCheckpointTask = new MirrorCheckpointTask("source1", "target2", - new DefaultReplicationPolicy(), offsetSyncStore, Collections.emptySet(), Collections.emptyMap(), + new DefaultReplicationPolicy(), offsetSyncStore, Set.of(), Map.of(), new CheckpointStore(checkpointsPerConsumerGroup)); TopicPartition tp = new TopicPartition("topic1", 0); TopicPartition targetTP = new TopicPartition("source1.topic1", 0); @@ -277,7 +277,7 @@ public class MirrorCheckpointTaskTest { private Map assertCheckpointForTopic( MirrorCheckpointTask task, TopicPartition tp, TopicPartition remoteTp, long consumerGroupOffset, boolean truth ) { - Map consumerGroupOffsets = Collections.singletonMap(tp, new OffsetAndMetadata(consumerGroupOffset)); + Map consumerGroupOffsets = Map.of(tp, new OffsetAndMetadata(consumerGroupOffset)); Map checkpoints = task.checkpointsForGroup(consumerGroupOffsets, "g1"); assertEquals(truth, checkpoints.containsKey(remoteTp), "should" + (truth ? "" : " not") + " emit offset sync"); return checkpoints; @@ -299,8 +299,8 @@ public class MirrorCheckpointTaskTest { offsetSyncStore.start(false); MirrorCheckpointTask mirrorCheckpointTask = new MirrorCheckpointTask("source1", "target2", - new DefaultReplicationPolicy(), offsetSyncStore, Collections.emptySet(), Collections.emptyMap(), - new CheckpointStore(Collections.emptyMap())); + new DefaultReplicationPolicy(), offsetSyncStore, Set.of(), Map.of(), + new CheckpointStore(Map.of())); // Generate a checkpoint for upstream offset 250, and assert it maps to downstream 201 // (as nearest mapping in OffsetSyncStore is 200->200) @@ -327,7 +327,7 @@ public class MirrorCheckpointTaskTest { Map> checkpointsPerConsumerGroup = new HashMap<>(); checkpointsPerConsumerGroup.put("group1", checkpoints); MirrorCheckpointTask mirrorCheckpointTask2 = new MirrorCheckpointTask("source1", "target2", - new DefaultReplicationPolicy(), offsetSyncStore2, Collections.emptySet(), Collections.emptyMap(), + new DefaultReplicationPolicy(), offsetSyncStore2, Set.of(), Map.of(), new CheckpointStore(checkpointsPerConsumerGroup)); // Upstream offsets 250 and 370 now have the closest downstream value of 176, but this is @@ -354,14 +354,14 @@ public class MirrorCheckpointTaskTest { MirrorCheckpointTask task = new MirrorCheckpointTask("source1", "target2", new DefaultReplicationPolicy(), new OffsetSyncStoreTest.FakeOffsetSyncStore(), - Collections.singleton("group"), - Collections.emptyMap(), + Set.of("group"), + Map.of(), checkpointStore) { @Override List sourceRecordsForGroup(String group) { - SourceRecord sr = new SourceRecord(Collections.emptyMap(), Collections.emptyMap(), "", 0, null, null); - return Collections.singletonList(sr); + SourceRecord sr = new SourceRecord(Map.of(), Map.of(), "", 0, null, null); + return List.of(sr); } }; diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorHeartBeatConnectorTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorHeartBeatConnectorTest.java index 190f749d4e7..8c5be805a93 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorHeartBeatConnectorTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorHeartBeatConnectorTest.java @@ -20,7 +20,6 @@ import org.apache.kafka.connect.errors.ConnectException; import org.junit.jupiter.api.Test; -import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; @@ -67,8 +66,8 @@ public class MirrorHeartBeatConnectorTest { @Test public void testAlterOffsetsIncorrectPartitionKey() { MirrorHeartbeatConnector connector = new MirrorHeartbeatConnector(); - assertThrows(ConnectException.class, () -> connector.alterOffsets(null, Collections.singletonMap( - Collections.singletonMap("unused_partition_key", "unused_partition_value"), + assertThrows(ConnectException.class, () -> connector.alterOffsets(null, Map.of( + Map.of("unused_partition_key", "unused_partition_value"), SOURCE_OFFSET ))); @@ -83,7 +82,7 @@ public class MirrorHeartBeatConnectorTest { public void testAlterOffsetsMissingPartitionKey() { MirrorHeartbeatConnector connector = new MirrorHeartbeatConnector(); - Function, Boolean> alterOffsets = partition -> connector.alterOffsets(null, Collections.singletonMap( + Function, Boolean> alterOffsets = partition -> connector.alterOffsets(null, Map.of( partition, SOURCE_OFFSET )); @@ -92,7 +91,7 @@ public class MirrorHeartBeatConnectorTest { // Sanity check to make sure our valid partition is actually valid assertTrue(alterOffsets.apply(validPartition)); - for (String key : Arrays.asList(SOURCE_CLUSTER_ALIAS_KEY, TARGET_CLUSTER_ALIAS_KEY)) { + for (String key : List.of(SOURCE_CLUSTER_ALIAS_KEY, TARGET_CLUSTER_ALIAS_KEY)) { Map invalidPartition = new HashMap<>(validPartition); invalidPartition.remove(key); assertThrows(ConnectException.class, () -> alterOffsets.apply(invalidPartition)); @@ -117,9 +116,9 @@ public class MirrorHeartBeatConnectorTest { public void testAlterOffsetsIncorrectOffsetKey() { MirrorHeartbeatConnector connector = new MirrorHeartbeatConnector(); - Map, Map> offsets = Collections.singletonMap( + Map, Map> offsets = Map.of( sourcePartition("primary", "backup"), - Collections.singletonMap("unused_offset_key", 0) + Map.of("unused_offset_key", 0) ); assertThrows(ConnectException.class, () -> connector.alterOffsets(null, offsets)); } @@ -128,7 +127,7 @@ public class MirrorHeartBeatConnectorTest { public void testAlterOffsetsOffsetValues() { MirrorHeartbeatConnector connector = new MirrorHeartbeatConnector(); - Function alterOffsets = offset -> connector.alterOffsets(null, Collections.singletonMap( + Function alterOffsets = offset -> connector.alterOffsets(null, Map.of( sourcePartition("primary", "backup"), Collections.singletonMap(MirrorUtils.OFFSET_KEY, offset) )); @@ -149,7 +148,7 @@ public class MirrorHeartBeatConnectorTest { public void testSuccessfulAlterOffsets() { MirrorHeartbeatConnector connector = new MirrorHeartbeatConnector(); - Map, Map> offsets = Collections.singletonMap( + Map, Map> offsets = Map.of( sourcePartition("primary", "backup"), SOURCE_OFFSET ); @@ -158,7 +157,7 @@ public class MirrorHeartBeatConnectorTest { // since it could indicate that the offsets were reset previously or that no offsets have been committed yet // (for a reset operation) assertTrue(connector.alterOffsets(null, offsets)); - assertTrue(connector.alterOffsets(null, Collections.emptyMap())); + assertTrue(connector.alterOffsets(null, Map.of())); } @Test @@ -178,8 +177,8 @@ public class MirrorHeartBeatConnectorTest { assertTrue(() -> alterOffsets.apply(partition)); assertTrue(() -> alterOffsets.apply(null)); - assertTrue(() -> alterOffsets.apply(Collections.emptyMap())); - assertTrue(() -> alterOffsets.apply(Collections.singletonMap("unused_partition_key", "unused_partition_value"))); + assertTrue(() -> alterOffsets.apply(Map.of())); + assertTrue(() -> alterOffsets.apply(Map.of("unused_partition_key", "unused_partition_value"))); } private static Map sourcePartition(String sourceClusterAlias, String targetClusterAlias) { diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorHeartbeatTaskTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorHeartbeatTaskTest.java index 0ffe2635d14..8faf52a12b6 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorHeartbeatTaskTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorHeartbeatTaskTest.java @@ -35,9 +35,9 @@ public class MirrorHeartbeatTaskTest { List records = heartbeatTask.poll(); assertEquals(1, records.size()); Map sourcePartition = records.iterator().next().sourcePartition(); - assertEquals(sourcePartition.get(Heartbeat.SOURCE_CLUSTER_ALIAS_KEY), "testSource", + assertEquals("testSource", sourcePartition.get(Heartbeat.SOURCE_CLUSTER_ALIAS_KEY), "sourcePartition's " + Heartbeat.SOURCE_CLUSTER_ALIAS_KEY + " record was not created"); - assertEquals(sourcePartition.get(Heartbeat.TARGET_CLUSTER_ALIAS_KEY), "testTarget", + assertEquals("testTarget", sourcePartition.get(Heartbeat.TARGET_CLUSTER_ALIAS_KEY), "sourcePartition's " + Heartbeat.TARGET_CLUSTER_ALIAS_KEY + " record was not created"); } } diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorMakerConfigTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorMakerConfigTest.java index 638db3de370..7dfdf460c44 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorMakerConfigTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorMakerConfigTest.java @@ -28,8 +28,6 @@ import org.apache.kafka.common.security.auth.SecurityProtocol; import org.junit.jupiter.api.Test; -import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Locale; @@ -152,11 +150,11 @@ public class MirrorMakerConfigTest { MirrorSourceConfig sourceConfig = new MirrorSourceConfig(connectorProps); assertEquals(100, (int) sourceConfig.getInt("tasks.max"), "Connector properties like tasks.max should be passed through to underlying Connectors."); - assertEquals(Collections.singletonList("topic-1"), sourceConfig.getList("topics"), + assertEquals(List.of("topic-1"), sourceConfig.getList("topics"), "Topics include should be passed through to underlying Connectors."); - assertEquals(Collections.singletonList("property-3"), sourceConfig.getList("config.properties.exclude"), + assertEquals(List.of("property-3"), sourceConfig.getList("config.properties.exclude"), "Config properties exclude should be passed through to underlying Connectors."); - assertEquals(Collections.singletonList("FakeMetricsReporter"), sourceConfig.getList("metric.reporters"), + assertEquals(List.of("FakeMetricsReporter"), sourceConfig.getList("metric.reporters"), "Metrics reporters should be passed through to underlying Connectors."); assertEquals("DefaultTopicFilter", sourceConfig.getClass("topic.filter.class").getSimpleName(), "Filters should be passed through to underlying Connectors."); @@ -166,7 +164,7 @@ public class MirrorMakerConfigTest { "Unknown properties should not be passed through to Connectors."); MirrorCheckpointConfig checkpointConfig = new MirrorCheckpointConfig(connectorProps); - assertEquals(Collections.singletonList("group-2"), checkpointConfig.getList("groups"), + assertEquals(List.of("group-2"), checkpointConfig.getList("groups"), "Groups include should be passed through to underlying Connectors."); } @@ -182,9 +180,9 @@ public class MirrorMakerConfigTest { MirrorSourceConnector.class); DefaultTopicFilter.TopicFilterConfig filterConfig = new DefaultTopicFilter.TopicFilterConfig(connectorProps); - assertEquals(Arrays.asList("topic1", "topic2"), filterConfig.getList("topics"), + assertEquals(List.of("topic1", "topic2"), filterConfig.getList("topics"), "source->target.topics should be passed through to TopicFilters."); - assertEquals(Collections.singletonList("topic3"), filterConfig.getList("topics.exclude"), + assertEquals(List.of("topic3"), filterConfig.getList("topics.exclude"), "source->target.topics.exclude should be passed through to TopicFilters."); } @@ -367,7 +365,7 @@ public class MirrorMakerConfigTest { public static class FakeConfigProvider implements ConfigProvider { - Map secrets = Collections.singletonMap("password", "secret2"); + Map secrets = Map.of("password", "secret2"); @Override public void configure(Map props) { diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorSourceConfigTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorSourceConfigTest.java index ccdc7a878a5..c7f7f4e19a5 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorSourceConfigTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorSourceConfigTest.java @@ -22,7 +22,6 @@ import org.apache.kafka.common.config.ConfigException; import org.junit.jupiter.api.Test; -import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Map; @@ -38,7 +37,7 @@ public class MirrorSourceConfigTest { @Test public void testTaskConfigTopicPartitions() { - List topicPartitions = Arrays.asList(new TopicPartition("topic-1", 2), + List topicPartitions = List.of(new TopicPartition("topic-1", 2), new TopicPartition("topic-3", 4), new TopicPartition("topic-5", 6)); MirrorSourceConfig config = new MirrorSourceConfig(makeProps()); Map props = config.taskConfigForTopicPartitions(topicPartitions, 1); diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorSourceConnectorTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorSourceConnectorTest.java index 21bcc7cbad5..1d106d6deaa 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorSourceConnectorTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorSourceConnectorTest.java @@ -44,7 +44,6 @@ import org.apache.logging.log4j.Level; import org.junit.jupiter.api.Test; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.HashMap; @@ -55,7 +54,6 @@ import java.util.Optional; import java.util.Set; import java.util.concurrent.ExecutionException; import java.util.function.Function; -import java.util.stream.Collectors; import static org.apache.kafka.clients.consumer.ConsumerConfig.ISOLATION_LEVEL_CONFIG; import static org.apache.kafka.connect.mirror.MirrorConnectorConfig.CONSUMER_CLIENT_PREFIX; @@ -106,7 +104,7 @@ public class MirrorSourceConnectorTest { assertTrue(connector.shouldReplicateTopic("heartbeats"), "should replicate heartbeats"); assertTrue(connector.shouldReplicateTopic("us-west.heartbeats"), "should replicate upstream heartbeats"); - Map configs = Collections.singletonMap(DefaultReplicationPolicy.SEPARATOR_CONFIG, "_"); + Map configs = Map.of(DefaultReplicationPolicy.SEPARATOR_CONFIG, "_"); defaultReplicationPolicy.configure(configs); assertTrue(connector.shouldReplicateTopic("heartbeats"), "should replicate heartbeats"); assertFalse(connector.shouldReplicateTopic("us-west.heartbeats"), "should not consider this topic as a heartbeats topic"); @@ -184,15 +182,15 @@ public class MirrorSourceConnectorTest { String expectedRemoteTopicName = "source" + DefaultReplicationPolicy.SEPARATOR_DEFAULT + allowAllAclBinding.pattern().name(); assertEquals(expectedRemoteTopicName, processedAllowAllAclBinding.pattern().name(), "should change topic name"); - assertEquals(processedAllowAllAclBinding.entry().operation(), AclOperation.READ, "should change ALL to READ"); - assertEquals(processedAllowAllAclBinding.entry().permissionType(), AclPermissionType.ALLOW, "should not change ALLOW"); + assertEquals(AclOperation.READ, processedAllowAllAclBinding.entry().operation(), "should change ALL to READ"); + assertEquals(AclPermissionType.ALLOW, processedAllowAllAclBinding.entry().permissionType(), "should not change ALLOW"); AclBinding denyAllAclBinding = new AclBinding( new ResourcePattern(ResourceType.TOPIC, "test_topic", PatternType.LITERAL), new AccessControlEntry("kafka", "", AclOperation.ALL, AclPermissionType.DENY)); AclBinding processedDenyAllAclBinding = connector.targetAclBinding(denyAllAclBinding); - assertEquals(processedDenyAllAclBinding.entry().operation(), AclOperation.ALL, "should not change ALL"); - assertEquals(processedDenyAllAclBinding.entry().permissionType(), AclPermissionType.DENY, "should not change DENY"); + assertEquals(AclOperation.ALL, processedDenyAllAclBinding.entry().operation(), "should not change ALL"); + assertEquals(AclPermissionType.DENY, processedDenyAllAclBinding.entry().permissionType(), "should not change DENY"); } @Test @@ -280,7 +278,7 @@ public class MirrorSourceConnectorTest { new DefaultReplicationPolicy(), x -> true, new DefaultConfigPropertyFilter()); ArrayList entries = new ArrayList<>(); entries.add(new ConfigEntry("name-1", "value-1")); - entries.add(new ConfigEntry("name-2", "value-2", ConfigEntry.ConfigSource.DEFAULT_CONFIG, false, false, Collections.emptyList(), ConfigEntry.ConfigType.STRING, "")); + entries.add(new ConfigEntry("name-2", "value-2", ConfigEntry.ConfigSource.DEFAULT_CONFIG, false, false, List.of(), ConfigEntry.ConfigType.STRING, "")); entries.add(new ConfigEntry("min.insync.replicas", "2")); Config config = new Config(entries); Config targetConfig = connector.targetConfig(config, true); @@ -300,7 +298,7 @@ public class MirrorSourceConnectorTest { List entries = new ArrayList<>(); entries.add(new ConfigEntry("name-1", "value-1")); // When "use.defaults.from" set to "target" by default, the config with default value should be excluded - entries.add(new ConfigEntry("name-2", "value-2", ConfigEntry.ConfigSource.DEFAULT_CONFIG, false, false, Collections.emptyList(), ConfigEntry.ConfigType.STRING, "")); + entries.add(new ConfigEntry("name-2", "value-2", ConfigEntry.ConfigSource.DEFAULT_CONFIG, false, false, List.of(), ConfigEntry.ConfigType.STRING, "")); entries.add(new ConfigEntry("min.insync.replicas", "2")); Config config = new Config(entries); Config targetConfig = connector.targetConfig(config, false); @@ -315,7 +313,7 @@ public class MirrorSourceConnectorTest { @Test @Deprecated public void testConfigPropertyFilteringWithAlterConfigsAndSourceDefault() { - Map filterConfig = Collections.singletonMap(DefaultConfigPropertyFilter.USE_DEFAULTS_FROM, "source"); + Map filterConfig = Map.of(DefaultConfigPropertyFilter.USE_DEFAULTS_FROM, "source"); DefaultConfigPropertyFilter filter = new DefaultConfigPropertyFilter(); filter.configure(filterConfig); @@ -324,7 +322,7 @@ public class MirrorSourceConnectorTest { List entries = new ArrayList<>(); entries.add(new ConfigEntry("name-1", "value-1")); // When "use.defaults.from" explicitly set to "source", the config with default value should be replicated - entries.add(new ConfigEntry("name-2", "value-2", ConfigEntry.ConfigSource.DEFAULT_CONFIG, false, false, Collections.emptyList(), ConfigEntry.ConfigType.STRING, "")); + entries.add(new ConfigEntry("name-2", "value-2", ConfigEntry.ConfigSource.DEFAULT_CONFIG, false, false, List.of(), ConfigEntry.ConfigType.STRING, "")); entries.add(new ConfigEntry("min.insync.replicas", "2")); Config config = new Config(entries); Config targetConfig = connector.targetConfig(config, false); @@ -358,7 +356,7 @@ public class MirrorSourceConnectorTest { entries.add(new ConfigEntry("exclude_param.param1", "value-param1")); entries.add(new ConfigEntry("min.insync.replicas", "2")); Config config = new Config(entries); - doReturn(Collections.singletonMap(topic, config)).when(connector).describeTopicConfigs(any()); + doReturn(Map.of(topic, config)).when(connector).describeTopicConfigs(any()); doAnswer(invocation -> { Map newTopics = invocation.getArgument(0); assertNotNull(newTopics.get("source." + topic)); @@ -375,7 +373,7 @@ public class MirrorSourceConnectorTest { assertNull(targetConfig.get(prop2), "should not replicate excluded properties " + prop2); return null; }).when(connector).createNewTopics(any()); - connector.createNewTopics(Collections.singleton(topic), Collections.singletonMap(topic, 1L)); + connector.createNewTopics(Set.of(topic), Map.of(topic, 1L)); verify(connector).createNewTopics(any(), any()); } @@ -433,15 +431,15 @@ public class MirrorSourceConnectorTest { connector.initialize(mock(ConnectorContext.class)); connector = spy(connector); - Config topicConfig = new Config(Arrays.asList( + Config topicConfig = new Config(List.of( new ConfigEntry("cleanup.policy", "compact"), new ConfigEntry("segment.bytes", "100"))); - Map configs = Collections.singletonMap("topic", topicConfig); + Map configs = Map.of("topic", topicConfig); - List sourceTopicPartitions = Collections.singletonList(new TopicPartition("topic", 0)); + List sourceTopicPartitions = List.of(new TopicPartition("topic", 0)); doReturn(sourceTopicPartitions).when(connector).findSourceTopicPartitions(); - doReturn(Collections.emptyList()).when(connector).findTargetTopicPartitions(); - doReturn(configs).when(connector).describeTopicConfigs(Collections.singleton("topic")); + doReturn(List.of()).when(connector).findTargetTopicPartitions(); + doReturn(configs).when(connector).describeTopicConfigs(Set.of("topic")); doNothing().when(connector).createNewTopics(any()); connector.refreshTopicPartitions(); @@ -460,7 +458,7 @@ public class MirrorSourceConnectorTest { verify(connector, times(2)).createNewTopics(eq(expectedNewTopics)); verify(connector, times(0)).createNewPartitions(any()); - List targetTopicPartitions = Collections.singletonList(new TopicPartition("source.topic", 0)); + List targetTopicPartitions = List.of(new TopicPartition("source.topic", 0)); doReturn(targetTopicPartitions).when(connector).findTargetTopicPartitions(); connector.refreshTopicPartitions(); @@ -475,17 +473,17 @@ public class MirrorSourceConnectorTest { connector.initialize(mock(ConnectorContext.class)); connector = spy(connector); - Config topicConfig = new Config(Arrays.asList( + Config topicConfig = new Config(List.of( new ConfigEntry("cleanup.policy", "compact"), new ConfigEntry("segment.bytes", "100"))); - Map configs = Collections.singletonMap("source.topic", topicConfig); + Map configs = Map.of("source.topic", topicConfig); - List sourceTopicPartitions = Collections.emptyList(); - List targetTopicPartitions = Collections.singletonList(new TopicPartition("source.topic", 0)); + List sourceTopicPartitions = List.of(); + List targetTopicPartitions = List.of(new TopicPartition("source.topic", 0)); doReturn(sourceTopicPartitions).when(connector).findSourceTopicPartitions(); doReturn(targetTopicPartitions).when(connector).findTargetTopicPartitions(); - doReturn(configs).when(connector).describeTopicConfigs(Collections.singleton("source.topic")); - doReturn(Collections.emptyMap()).when(connector).describeTopicConfigs(Collections.emptySet()); + doReturn(configs).when(connector).describeTopicConfigs(Set.of("source.topic")); + doReturn(Map.of()).when(connector).describeTopicConfigs(Set.of()); doNothing().when(connector).createNewTopics(any()); doNothing().when(connector).createNewPartitions(any()); @@ -494,7 +492,7 @@ public class MirrorSourceConnectorTest { connector.refreshTopicPartitions(); verify(connector, times(0)).computeAndCreateTopicPartitions(); - sourceTopicPartitions = Collections.singletonList(new TopicPartition("topic", 0)); + sourceTopicPartitions = List.of(new TopicPartition("topic", 0)); doReturn(sourceTopicPartitions).when(connector).findSourceTopicPartitions(); // when partitions are added to the source cluster, reconfiguration is triggered @@ -620,7 +618,7 @@ public class MirrorSourceConnectorTest { List results = new MirrorSourceConnector().validate(props) .configValues().stream() .filter(cv -> name.equals(cv.name())) - .collect(Collectors.toList()); + .toList(); assertTrue(results.size() <= 1, "Connector produced multiple config values for '" + name + "' property"); @@ -635,8 +633,8 @@ public class MirrorSourceConnectorTest { @Test public void testAlterOffsetsIncorrectPartitionKey() { MirrorSourceConnector connector = new MirrorSourceConnector(); - assertThrows(ConnectException.class, () -> connector.alterOffsets(null, Collections.singletonMap( - Collections.singletonMap("unused_partition_key", "unused_partition_value"), + assertThrows(ConnectException.class, () -> connector.alterOffsets(null, Map.of( + Map.of("unused_partition_key", "unused_partition_value"), MirrorUtils.wrapOffset(10) ))); @@ -651,7 +649,7 @@ public class MirrorSourceConnectorTest { public void testAlterOffsetsMissingPartitionKey() { MirrorSourceConnector connector = new MirrorSourceConnector(); - Function, Boolean> alterOffsets = partition -> connector.alterOffsets(null, Collections.singletonMap( + Function, Boolean> alterOffsets = partition -> connector.alterOffsets(null, Map.of( partition, MirrorUtils.wrapOffset(64) )); @@ -660,7 +658,7 @@ public class MirrorSourceConnectorTest { // Sanity check to make sure our valid partition is actually valid assertTrue(alterOffsets.apply(validPartition)); - for (String key : Arrays.asList(SOURCE_CLUSTER_KEY, TOPIC_KEY, PARTITION_KEY)) { + for (String key : List.of(SOURCE_CLUSTER_KEY, TOPIC_KEY, PARTITION_KEY)) { Map invalidPartition = new HashMap<>(validPartition); invalidPartition.remove(key); assertThrows(ConnectException.class, () -> alterOffsets.apply(invalidPartition)); @@ -672,7 +670,7 @@ public class MirrorSourceConnectorTest { MirrorSourceConnector connector = new MirrorSourceConnector(); Map partition = sourcePartition("t", 3, "us-west-2"); partition.put(PARTITION_KEY, "a string"); - assertThrows(ConnectException.class, () -> connector.alterOffsets(null, Collections.singletonMap( + assertThrows(ConnectException.class, () -> connector.alterOffsets(null, Map.of( partition, MirrorUtils.wrapOffset(49) ))); @@ -696,9 +694,9 @@ public class MirrorSourceConnectorTest { public void testAlterOffsetsIncorrectOffsetKey() { MirrorSourceConnector connector = new MirrorSourceConnector(); - Map, Map> offsets = Collections.singletonMap( + Map, Map> offsets = Map.of( sourcePartition("t1", 2, "backup"), - Collections.singletonMap("unused_offset_key", 0) + Map.of("unused_offset_key", 0) ); assertThrows(ConnectException.class, () -> connector.alterOffsets(null, offsets)); } @@ -707,7 +705,7 @@ public class MirrorSourceConnectorTest { public void testAlterOffsetsOffsetValues() { MirrorSourceConnector connector = new MirrorSourceConnector(); - Function alterOffsets = offset -> connector.alterOffsets(null, Collections.singletonMap( + Function alterOffsets = offset -> connector.alterOffsets(null, Map.of( sourcePartition("t", 5, "backup"), Collections.singletonMap(MirrorUtils.OFFSET_KEY, offset) )); @@ -728,7 +726,7 @@ public class MirrorSourceConnectorTest { public void testSuccessfulAlterOffsets() { MirrorSourceConnector connector = new MirrorSourceConnector(); - Map, Map> offsets = Collections.singletonMap( + Map, Map> offsets = Map.of( sourcePartition("t2", 0, "backup"), MirrorUtils.wrapOffset(5) ); @@ -737,7 +735,7 @@ public class MirrorSourceConnectorTest { // since it could indicate that the offsets were reset previously or that no offsets have been committed yet // (for a reset operation) assertTrue(connector.alterOffsets(null, offsets)); - assertTrue(connector.alterOffsets(null, Collections.emptyMap())); + assertTrue(connector.alterOffsets(null, Map.of())); } @Test @@ -757,8 +755,8 @@ public class MirrorSourceConnectorTest { assertTrue(() -> alterOffsets.apply(partition)); assertTrue(() -> alterOffsets.apply(null)); - assertTrue(() -> alterOffsets.apply(Collections.emptyMap())); - assertTrue(() -> alterOffsets.apply(Collections.singletonMap("unused_partition_key", "unused_partition_value"))); + assertTrue(() -> alterOffsets.apply(Map.of())); + assertTrue(() -> alterOffsets.apply(Map.of("unused_partition_key", "unused_partition_value"))); } private static Map sourcePartition(String topic, int partition, String sourceClusterAlias) { diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorUtilsTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorUtilsTest.java index e6de8a58f7b..daa818e293e 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorUtilsTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/MirrorUtilsTest.java @@ -29,7 +29,6 @@ import org.apache.kafka.connect.errors.ConnectException; import org.junit.jupiter.api.Test; -import java.util.Collections; import java.util.Map; import java.util.concurrent.ExecutionException; @@ -51,7 +50,7 @@ public class MirrorUtilsTest { @Test public void testCreateCompactedTopic() throws Exception { - Map> values = Collections.singletonMap(TOPIC, future); + Map> values = Map.of(TOPIC, future); when(future.get()).thenReturn(null); when(ctr.values()).thenReturn(values); when(admin.createTopics(any(), any())).thenReturn(ctr); @@ -64,7 +63,7 @@ public class MirrorUtilsTest { @Test public void testCreateCompactedTopicAlreadyExists() throws Exception { - Map> values = Collections.singletonMap(TOPIC, future); + Map> values = Map.of(TOPIC, future); when(future.get()).thenThrow(new ExecutionException(new TopicExistsException("topic exists"))); when(ctr.values()).thenReturn(values); when(admin.createTopics(any(), any())).thenReturn(ctr); @@ -77,7 +76,7 @@ public class MirrorUtilsTest { @Test public void testCreateCompactedTopicAssumeTopicAlreadyExistsWithUnsupportedVersionException() throws Exception { - Map> values = Collections.singletonMap(TOPIC, future); + Map> values = Map.of(TOPIC, future); when(future.get()).thenThrow(new ExecutionException(new UnsupportedVersionException("unsupported"))); when(ctr.values()).thenReturn(values); when(admin.createTopics(any(), any())).thenReturn(ctr); @@ -90,7 +89,7 @@ public class MirrorUtilsTest { @Test public void testCreateCompactedTopicAssumeTopicAlreadyExistsWithClusterAuthorizationException() throws Exception { - Map> values = Collections.singletonMap(TOPIC, future); + Map> values = Map.of(TOPIC, future); when(future.get()).thenThrow(new ExecutionException(new ClusterAuthorizationException("not authorised"))); when(ctr.values()).thenReturn(values); when(admin.createTopics(any(), any())).thenReturn(ctr); @@ -103,7 +102,7 @@ public class MirrorUtilsTest { @Test public void testCreateCompactedTopicAssumeTopicAlreadyExistsWithTopicAuthorizationException() throws Exception { - Map> values = Collections.singletonMap(TOPIC, future); + Map> values = Map.of(TOPIC, future); when(future.get()).thenThrow(new ExecutionException(new TopicAuthorizationException("not authorised"))); when(ctr.values()).thenReturn(values); when(admin.createTopics(any(), any())).thenReturn(ctr); @@ -116,7 +115,7 @@ public class MirrorUtilsTest { @Test public void testCreateCompactedTopicFailsWithInvalidConfigurationException() throws Exception { - Map> values = Collections.singletonMap(TOPIC, future); + Map> values = Map.of(TOPIC, future); when(future.get()).thenThrow(new ExecutionException(new InvalidConfigurationException("wrong config"))); when(ctr.values()).thenReturn(values); when(admin.createTopics(any(), any())).thenReturn(ctr); @@ -130,7 +129,7 @@ public class MirrorUtilsTest { @Test public void testCreateCompactedTopicFailsWithTimeoutException() throws Exception { - Map> values = Collections.singletonMap(TOPIC, future); + Map> values = Map.of(TOPIC, future); when(future.get()).thenThrow(new ExecutionException(new TimeoutException("Timeout"))); when(ctr.values()).thenReturn(values); when(admin.createTopics(any(), any())).thenReturn(ctr); diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/OffsetSyncWriterTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/OffsetSyncWriterTest.java index 9a6b10920a0..19c8d9d3952 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/OffsetSyncWriterTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/OffsetSyncWriterTest.java @@ -55,11 +55,11 @@ public class OffsetSyncWriterTest { offsetSyncWriter.maybeQueueOffsetSyncs(topicPartition, 0, 1); assertFalse(offsetSyncWriter.getDelayedOffsetSyncs().containsKey(topicPartition)); assertTrue(offsetSyncWriter.getPendingOffsetSyncs().containsKey(topicPartition)); - assertEquals(offsetSyncWriter.partitionStates().get(topicPartition).lastSyncDownstreamOffset, 1); + assertEquals(1, offsetSyncWriter.partitionStates().get(topicPartition).lastSyncDownstreamOffset); offsetSyncWriter.maybeQueueOffsetSyncs(topicPartition, 1, 2); assertTrue(offsetSyncWriter.getDelayedOffsetSyncs().containsKey(topicPartition)); - assertEquals(offsetSyncWriter.partitionStates().get(topicPartition).lastSyncDownstreamOffset, 1); + assertEquals(1, offsetSyncWriter.partitionStates().get(topicPartition).lastSyncDownstreamOffset); } @Test @@ -71,7 +71,7 @@ public class OffsetSyncWriterTest { OffsetSyncWriter offsetSyncWriter = new OffsetSyncWriter(producer, topicName, outstandingOffsetSyncs, maxOffsetLag); offsetSyncWriter.maybeQueueOffsetSyncs(topicPartition, 0, 100); - assertEquals(offsetSyncWriter.partitionStates().get(topicPartition).lastSyncDownstreamOffset, 100); + assertEquals(100, offsetSyncWriter.partitionStates().get(topicPartition).lastSyncDownstreamOffset); offsetSyncWriter.firePendingOffsetSyncs(); @@ -85,7 +85,7 @@ public class OffsetSyncWriterTest { verify(producer, times(1)).send(any(), any()); offsetSyncWriter.maybeQueueOffsetSyncs(topicPartition, 2, 102); - assertEquals(offsetSyncWriter.partitionStates().get(topicPartition).lastSyncDownstreamOffset, 102); + assertEquals(102, offsetSyncWriter.partitionStates().get(topicPartition).lastSyncDownstreamOffset); offsetSyncWriter.firePendingOffsetSyncs(); // in-flight offset syncs; will not try to send remaining offset syncs immediately diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/DedicatedMirrorIntegrationTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/DedicatedMirrorIntegrationTest.java index 2ba4438bdba..a8d5d520e39 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/DedicatedMirrorIntegrationTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/DedicatedMirrorIntegrationTest.java @@ -45,8 +45,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.time.Duration; -import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -58,7 +56,6 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Predicate; -import java.util.stream.Collectors; import static org.apache.kafka.clients.consumer.ConsumerConfig.AUTO_OFFSET_RESET_CONFIG; import static org.apache.kafka.connect.mirror.MirrorMaker.CONNECTOR_CLASSES; @@ -230,7 +227,7 @@ public class DedicatedMirrorIntegrationTest { // Bring up a single-node cluster final MirrorMaker mm = startMirrorMaker("no-offset-syncing", mmProps); final SourceAndTarget sourceAndTarget = new SourceAndTarget(a, b); - awaitMirrorMakerStart(mm, sourceAndTarget, Arrays.asList(MirrorSourceConnector.class, MirrorHeartbeatConnector.class)); + awaitMirrorMakerStart(mm, sourceAndTarget, List.of(MirrorSourceConnector.class, MirrorHeartbeatConnector.class)); // wait for mirror source and heartbeat connectors to start a task awaitConnectorTasksStart(mm, MirrorHeartbeatConnector.class, sourceAndTarget); @@ -256,7 +253,7 @@ public class DedicatedMirrorIntegrationTest { .stream() .filter(Optional::isPresent) .map(Optional::get) - .collect(Collectors.toList()); + .toList(); assertTrue(offsetSyncTopic.isEmpty()); } @@ -451,8 +448,8 @@ public class DedicatedMirrorIntegrationTest { } private void awaitTopicContent(EmbeddedKafkaCluster cluster, String clusterName, String topic, int numMessages) throws Exception { - try (Consumer consumer = cluster.createConsumer(Collections.singletonMap(AUTO_OFFSET_RESET_CONFIG, "earliest"))) { - consumer.subscribe(Collections.singleton(topic)); + try (Consumer consumer = cluster.createConsumer(Map.of(AUTO_OFFSET_RESET_CONFIG, "earliest"))) { + consumer.subscribe(Set.of(topic)); AtomicInteger messagesRead = new AtomicInteger(0); waitForCondition( () -> { diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/MirrorConnectorsIntegrationBaseTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/MirrorConnectorsIntegrationBaseTest.java index a83189757c8..a34850c8b4c 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/MirrorConnectorsIntegrationBaseTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/MirrorConnectorsIntegrationBaseTest.java @@ -67,9 +67,7 @@ import org.slf4j.LoggerFactory; import java.time.Duration; 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.List; @@ -127,7 +125,7 @@ public class MirrorConnectorsIntegrationBaseTest { protected static final Duration CONSUMER_POLL_TIMEOUT = Duration.ofMillis(500L); protected static final String PRIMARY_CLUSTER_ALIAS = "primary"; protected static final String BACKUP_CLUSTER_ALIAS = "backup"; - protected static final List> CONNECTOR_LIST = Arrays.asList( + protected static final List> CONNECTOR_LIST = List.of( MirrorSourceConnector.class, MirrorCheckpointConnector.class, MirrorHeartbeatConnector.class); @@ -243,7 +241,7 @@ public class MirrorConnectorsIntegrationBaseTest { waitForTopicCreated(backup, "mm2-configs.primary.internal"); waitForTopicCreated(backup, "test-topic-1"); waitForTopicCreated(primary, "test-topic-1"); - warmUpConsumer(Collections.singletonMap("group.id", "consumer-group-dummy")); + warmUpConsumer(Map.of("group.id", "consumer-group-dummy")); log.info(PRIMARY_CLUSTER_ALIAS + " REST service: {}", primary.endpointForResource("connectors")); log.info(BACKUP_CLUSTER_ALIAS + " REST service: {}", backup.endpointForResource("connectors")); @@ -290,14 +288,14 @@ public class MirrorConnectorsIntegrationBaseTest { } String reverseTopic1 = remoteTopicName("test-topic-1", BACKUP_CLUSTER_ALIAS); String consumerGroupName = "consumer-group-testReplication"; - Map consumerProps = Collections.singletonMap("group.id", consumerGroupName); + Map consumerProps = Map.of("group.id", consumerGroupName); // warm up consumers before starting the connectors, so we don't need to wait for discovery warmUpConsumer(consumerProps); mm2Config = new MirrorMakerConfig(mm2Props); waitUntilMirrorMakerIsRunning(backup, CONNECTOR_LIST, mm2Config, PRIMARY_CLUSTER_ALIAS, BACKUP_CLUSTER_ALIAS); - List> primaryConnectors = replicateBackupToPrimary ? CONNECTOR_LIST : Collections.singletonList(MirrorHeartbeatConnector.class); + List> primaryConnectors = replicateBackupToPrimary ? CONNECTOR_LIST : List.of(MirrorHeartbeatConnector.class); waitUntilMirrorMakerIsRunning(primary, primaryConnectors, mm2Config, BACKUP_CLUSTER_ALIAS, PRIMARY_CLUSTER_ALIAS); MirrorClient primaryClient = new MirrorClient(mm2Config.clientConfig(PRIMARY_CLUSTER_ALIAS)); @@ -370,7 +368,7 @@ public class MirrorConnectorsIntegrationBaseTest { backupClient, consumerGroupName, PRIMARY_CLUSTER_ALIAS, backupTopic1); // Failover consumer group to backup cluster. - try (Consumer primaryConsumer = backup.kafka().createConsumer(Collections.singletonMap("group.id", consumerGroupName))) { + try (Consumer primaryConsumer = backup.kafka().createConsumer(Map.of("group.id", consumerGroupName))) { primaryConsumer.assign(backupOffsets.keySet()); backupOffsets.forEach(primaryConsumer::seek); primaryConsumer.poll(CONSUMER_POLL_TIMEOUT); @@ -391,7 +389,7 @@ public class MirrorConnectorsIntegrationBaseTest { primaryClient, consumerGroupName, BACKUP_CLUSTER_ALIAS, reverseTopic1); // Failback consumer group to primary cluster - try (Consumer primaryConsumer = primary.kafka().createConsumer(Collections.singletonMap("group.id", consumerGroupName))) { + try (Consumer primaryConsumer = primary.kafka().createConsumer(Map.of("group.id", consumerGroupName))) { primaryConsumer.assign(primaryOffsets.keySet()); primaryOffsets.forEach(primaryConsumer::seek); primaryConsumer.poll(CONSUMER_POLL_TIMEOUT); @@ -435,7 +433,7 @@ public class MirrorConnectorsIntegrationBaseTest { @Test public void testReplicationWithEmptyPartition() throws Exception { String consumerGroupName = "consumer-group-testReplicationWithEmptyPartition"; - Map consumerProps = Collections.singletonMap("group.id", consumerGroupName); + Map consumerProps = Map.of("group.id", consumerGroupName); // create topic String topic = "test-topic-with-empty-partition"; @@ -526,7 +524,7 @@ public class MirrorConnectorsIntegrationBaseTest { try (Consumer backupConsumer = backup.kafka().createConsumerAndSubscribeTo( consumerProps, backupTopic1)) { - waitForConsumerGroupFullSync(backup, Collections.singletonList(backupTopic1), + waitForConsumerGroupFullSync(backup, List.of(backupTopic1), consumerGroupName, NUM_RECORDS_PRODUCED, offsetLagMax); assertDownstreamRedeliveriesBoundedByMaxLag(backupConsumer, offsetLagMax); } @@ -541,17 +539,17 @@ public class MirrorConnectorsIntegrationBaseTest { produceMessages(primaryProducer, "test-topic-2"); // create a consumer at primary cluster to consume the new topic - try (Consumer consumer1 = primary.kafka().createConsumerAndSubscribeTo(Collections.singletonMap( + try (Consumer consumer1 = primary.kafka().createConsumerAndSubscribeTo(Map.of( "group.id", consumerGroupName), "test-topic-2")) { // we need to wait for consuming all the records for MM2 replicating the expected offsets waitForConsumingAllRecords(consumer1, NUM_RECORDS_PRODUCED); } // create a consumer at backup cluster with same consumer group ID to consume old and new topic - try (Consumer backupConsumer = backup.kafka().createConsumerAndSubscribeTo(Collections.singletonMap( + try (Consumer backupConsumer = backup.kafka().createConsumerAndSubscribeTo(Map.of( "group.id", consumerGroupName), backupTopic1, remoteTopic2)) { - waitForConsumerGroupFullSync(backup, Arrays.asList(backupTopic1, remoteTopic2), + waitForConsumerGroupFullSync(backup, List.of(backupTopic1, remoteTopic2), consumerGroupName, NUM_RECORDS_PRODUCED, offsetLagMax); assertDownstreamRedeliveriesBoundedByMaxLag(backupConsumer, offsetLagMax); } @@ -567,7 +565,7 @@ public class MirrorConnectorsIntegrationBaseTest { produceMessages(backupProducer, "test-topic-1"); } String consumerGroupName = "consumer-group-testReplication"; - Map consumerProps = Collections.singletonMap("group.id", consumerGroupName); + Map consumerProps = Map.of("group.id", consumerGroupName); // warm up consumers before starting the connectors, so we don't need to wait for discovery warmUpConsumer(consumerProps); @@ -576,7 +574,7 @@ public class MirrorConnectorsIntegrationBaseTest { mm2Config = new MirrorMakerConfig(mm2Props); - waitUntilMirrorMakerIsRunning(backup, Arrays.asList(MirrorSourceConnector.class, MirrorHeartbeatConnector.class), mm2Config, PRIMARY_CLUSTER_ALIAS, BACKUP_CLUSTER_ALIAS); + waitUntilMirrorMakerIsRunning(backup, List.of(MirrorSourceConnector.class, MirrorHeartbeatConnector.class), mm2Config, PRIMARY_CLUSTER_ALIAS, BACKUP_CLUSTER_ALIAS); MirrorClient primaryClient = new MirrorClient(mm2Config.clientConfig(PRIMARY_CLUSTER_ALIAS)); MirrorClient backupClient = new MirrorClient(mm2Config.clientConfig(BACKUP_CLUSTER_ALIAS)); @@ -595,7 +593,7 @@ public class MirrorConnectorsIntegrationBaseTest { .stream() .filter(Optional::isPresent) .map(Optional::get) - .collect(Collectors.toList()); + .toList(); assertTrue(offsetSyncTopic.isEmpty()); primaryClient.close(); @@ -617,7 +615,7 @@ public class MirrorConnectorsIntegrationBaseTest { waitForTopicCreated(backup, "mm2-offset-syncs." + PRIMARY_CLUSTER_ALIAS + ".internal"); String consumerGroupName = "consumer-group-syncs-on-target"; - Map consumerProps = Collections.singletonMap("group.id", consumerGroupName); + Map consumerProps = Map.of("group.id", consumerGroupName); produceMessages(primaryProducer, "test-topic-1"); @@ -626,7 +624,7 @@ public class MirrorConnectorsIntegrationBaseTest { String remoteTopic = remoteTopicName("test-topic-1", PRIMARY_CLUSTER_ALIAS); // Check offsets are pushed to the checkpoint topic - try (Consumer backupConsumer = backup.kafka().createConsumerAndSubscribeTo(Collections.singletonMap( + try (Consumer backupConsumer = backup.kafka().createConsumerAndSubscribeTo(Map.of( "auto.offset.reset", "earliest"), PRIMARY_CLUSTER_ALIAS + ".checkpoints.internal")) { waitForCondition(() -> { ConsumerRecords records = backupConsumer.poll(Duration.ofSeconds(1L)); @@ -655,7 +653,7 @@ public class MirrorConnectorsIntegrationBaseTest { @Test public void testNoCheckpointsIfNoRecordsAreMirrored() throws InterruptedException { String consumerGroupName = "consumer-group-no-checkpoints"; - Map consumerProps = Collections.singletonMap("group.id", consumerGroupName); + Map consumerProps = Map.of("group.id", consumerGroupName); // ensure there are some records in the topic on the source cluster produceMessages(primaryProducer, "test-topic-1"); @@ -676,7 +674,7 @@ public class MirrorConnectorsIntegrationBaseTest { TopicPartition tp1 = new TopicPartition("test-topic-1", 0); TopicPartition tp2 = new TopicPartition("test-topic-no-checkpoints", 0); try (Consumer consumer = primary.kafka().createConsumer(consumerProps)) { - Collection tps = Arrays.asList(tp1, tp2); + Collection tps = List.of(tp1, tp2); Map endOffsets = consumer.endOffsets(tps); Map offsetsToCommit = endOffsets.entrySet().stream() .collect(Collectors.toMap( @@ -699,7 +697,7 @@ public class MirrorConnectorsIntegrationBaseTest { produceMessages(primaryProducer, "test-topic-no-checkpoints"); try (Consumer consumer = primary.kafka().createConsumer(consumerProps)) { - Collection tps = Arrays.asList(tp1, tp2); + Collection tps = List.of(tp1, tp2); Map endOffsets = consumer.endOffsets(tps); Map offsetsToCommit = endOffsets.entrySet().stream() .collect(Collectors.toMap( @@ -722,7 +720,7 @@ public class MirrorConnectorsIntegrationBaseTest { @Test public void testRestartReplication() throws InterruptedException { String consumerGroupName = "consumer-group-restart"; - Map consumerProps = Collections.singletonMap("group.id", consumerGroupName); + Map consumerProps = Map.of("group.id", consumerGroupName); String remoteTopic = remoteTopicName("test-topic-1", PRIMARY_CLUSTER_ALIAS); warmUpConsumer(consumerProps); mm2Props.put("sync.group.offsets.enabled", "true"); @@ -734,7 +732,7 @@ public class MirrorConnectorsIntegrationBaseTest { try (Consumer primaryConsumer = primary.kafka().createConsumerAndSubscribeTo(consumerProps, "test-topic-1")) { waitForConsumingAllRecords(primaryConsumer, NUM_RECORDS_PRODUCED); } - waitForConsumerGroupFullSync(backup, Collections.singletonList(remoteTopic), consumerGroupName, NUM_RECORDS_PRODUCED, OFFSET_LAG_MAX); + waitForConsumerGroupFullSync(backup, List.of(remoteTopic), consumerGroupName, NUM_RECORDS_PRODUCED, OFFSET_LAG_MAX); restartMirrorMakerConnectors(backup, CONNECTOR_LIST); assertMonotonicCheckpoints(backup, "primary.checkpoints.internal"); Thread.sleep(5000); @@ -742,14 +740,14 @@ public class MirrorConnectorsIntegrationBaseTest { try (Consumer primaryConsumer = primary.kafka().createConsumerAndSubscribeTo(consumerProps, "test-topic-1")) { waitForConsumingAllRecords(primaryConsumer, NUM_RECORDS_PRODUCED); } - waitForConsumerGroupFullSync(backup, Collections.singletonList(remoteTopic), consumerGroupName, 2 * NUM_RECORDS_PRODUCED, OFFSET_LAG_MAX); + waitForConsumerGroupFullSync(backup, List.of(remoteTopic), consumerGroupName, 2 * NUM_RECORDS_PRODUCED, OFFSET_LAG_MAX); assertMonotonicCheckpoints(backup, "primary.checkpoints.internal"); } @Test public void testOffsetTranslationBehindReplicationFlow() throws InterruptedException { String consumerGroupName = "consumer-group-lagging-behind"; - Map consumerProps = Collections.singletonMap("group.id", consumerGroupName); + Map consumerProps = Map.of("group.id", consumerGroupName); String remoteTopic = remoteTopicName("test-topic-1", PRIMARY_CLUSTER_ALIAS); warmUpConsumer(consumerProps); mm2Props.put("sync.group.offsets.enabled", "true"); @@ -839,7 +837,7 @@ public class MirrorConnectorsIntegrationBaseTest { Collection ops = new ArrayList<>(); ops.add(new AlterConfigOp(new ConfigEntry("delete.retention.ms", "2000"), AlterConfigOp.OpType.SET)); ops.add(new AlterConfigOp(new ConfigEntry("retention.bytes", "2000"), AlterConfigOp.OpType.SET)); - Map> configOps = Collections.singletonMap(configResource, ops); + Map> configOps = Map.of(configResource, ops); // alter configs on target cluster backup.kafka().incrementalAlterConfigs(configOps); @@ -879,7 +877,7 @@ public class MirrorConnectorsIntegrationBaseTest { Collection ops = new ArrayList<>(); ops.add(new AlterConfigOp(new ConfigEntry("delete.retention.ms", "2000"), AlterConfigOp.OpType.SET)); ops.add(new AlterConfigOp(new ConfigEntry("retention.bytes", "2000"), AlterConfigOp.OpType.SET)); - Map> configOps = Collections.singletonMap(configResource, ops); + Map> configOps = Map.of(configResource, ops); backup.kafka().incrementalAlterConfigs(configOps); waitForCondition(() -> { @@ -933,7 +931,7 @@ public class MirrorConnectorsIntegrationBaseTest { ConfigResource configResource = new ConfigResource(ConfigResource.Type.TOPIC, topic); Collection ops = new ArrayList<>(); ops.add(new AlterConfigOp(new ConfigEntry("retention.bytes", "1000"), AlterConfigOp.OpType.DELETE)); - Map> configOps = Collections.singletonMap(configResource, ops); + Map> configOps = Map.of(configResource, ops); primary.kafka().incrementalAlterConfigs(configOps); waitForCondition(() -> { @@ -1155,7 +1153,7 @@ public class MirrorConnectorsIntegrationBaseTest { String connectorName = connectorClass.getSimpleName(); connectCluster.resetConnectorOffsets(connectorName); assertEquals( - Collections.emptyList(), + List.of(), connectCluster.connectorOffsets(connectorName).offsets(), "Offsets for connector should be completely empty after full reset" ); @@ -1181,7 +1179,7 @@ public class MirrorConnectorsIntegrationBaseTest { */ protected static String getTopicConfig(EmbeddedKafkaCluster cluster, String topic, String configName) throws Exception { try (Admin client = cluster.createAdminClient()) { - Collection cr = Collections.singleton( + Collection cr = Set.of( new ConfigResource(ConfigResource.Type.TOPIC, topic)); DescribeConfigsResult configsResult = client.describeConfigs(cr); @@ -1200,7 +1198,7 @@ public class MirrorConnectorsIntegrationBaseTest { protected Producer initializeProducer(EmbeddedConnectCluster cluster) { - return cluster.kafka().createProducer(Collections.emptyMap()); + return cluster.kafka().createProducer(Map.of()); } /** @@ -1224,7 +1222,7 @@ public class MirrorConnectorsIntegrationBaseTest { private static Map waitForCheckpointOnAllPartitions( MirrorClient client, String consumerGroupName, String remoteClusterAlias, String topicName ) throws InterruptedException { - return waitForNewCheckpointOnAllPartitions(client, consumerGroupName, remoteClusterAlias, topicName, Collections.emptyMap()); + return waitForNewCheckpointOnAllPartitions(client, consumerGroupName, remoteClusterAlias, topicName, Map.of()); } protected static Map waitForNewCheckpointOnAllPartitions( @@ -1318,7 +1316,7 @@ public class MirrorConnectorsIntegrationBaseTest { private static void assertMonotonicCheckpoints(EmbeddedConnectCluster cluster, String checkpointTopic) { TopicPartition checkpointTopicPartition = new TopicPartition(checkpointTopic, 0); - try (Consumer backupConsumer = cluster.kafka().createConsumerAndSubscribeTo(Collections.singletonMap( + try (Consumer backupConsumer = cluster.kafka().createConsumerAndSubscribeTo(Map.of( "auto.offset.reset", "earliest"), checkpointTopic)) { Map> checkpointsByGroup = new HashMap<>(); long deadline = System.currentTimeMillis() + CHECKPOINT_DURATION_MS; @@ -1390,11 +1388,11 @@ public class MirrorConnectorsIntegrationBaseTest { private void createTopics() { // to verify topic config will be sync-ed across clusters - Map topicConfig = Collections.singletonMap(TopicConfig.CLEANUP_POLICY_CONFIG, TopicConfig.CLEANUP_POLICY_COMPACT); - Map emptyMap = Collections.emptyMap(); + Map topicConfig = Map.of(TopicConfig.CLEANUP_POLICY_CONFIG, TopicConfig.CLEANUP_POLICY_COMPACT); + Map emptyMap = Map.of(); // increase admin client request timeout value to make the tests reliable. - Map adminClientConfig = Collections.singletonMap( + Map adminClientConfig = Map.of( AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, REQUEST_TIMEOUT_DURATION_MS); // create these topics before starting the connectors, so we don't need to wait for discovery @@ -1465,7 +1463,7 @@ public class MirrorConnectorsIntegrationBaseTest { topicPartitionsPendingPosition.removeAll(topicPartitionsWithPosition); } assertEquals( - Collections.emptySet(), + Set.of(), topicPartitionsPendingPosition, "Failed to calculate consumer position for one or more partitions on cluster " + clusterName + " in time" ); @@ -1494,7 +1492,7 @@ public class MirrorConnectorsIntegrationBaseTest { */ protected static void waitForTopicPartitionCreated(EmbeddedConnectCluster cluster, String topicName, int totalNumPartitions) throws InterruptedException { try (final Admin adminClient = cluster.kafka().createAdminClient()) { - waitForCondition(() -> adminClient.describeTopics(Collections.singleton(topicName)).allTopicNames().get() + waitForCondition(() -> adminClient.describeTopics(Set.of(topicName)).allTopicNames().get() .get(topicName).partitions().size() == totalNumPartitions, TOPIC_SYNC_DURATION_MS, "Topic: " + topicName + "'s partitions didn't get created on cluster: " + cluster.getName() ); diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/MirrorConnectorsIntegrationExactlyOnceTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/MirrorConnectorsIntegrationExactlyOnceTest.java index e02cc4c02b3..f08e5688592 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/MirrorConnectorsIntegrationExactlyOnceTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/MirrorConnectorsIntegrationExactlyOnceTest.java @@ -24,7 +24,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; -import java.util.Arrays; +import java.util.List; import java.util.Properties; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -45,7 +45,7 @@ public class MirrorConnectorsIntegrationExactlyOnceTest extends MirrorConnectors BACKUP_CLUSTER_ALIAS + "." + DistributedConfig.EXACTLY_ONCE_SOURCE_SUPPORT_CONFIG, DistributedConfig.ExactlyOnceSourceSupport.ENABLED.toString() ); - for (Properties brokerProps : Arrays.asList(primaryBrokerProps, backupBrokerProps)) { + for (Properties brokerProps : List.of(primaryBrokerProps, backupBrokerProps)) { brokerProps.put("transaction.state.log.replication.factor", "1"); brokerProps.put("transaction.state.log.min.isr", "1"); } diff --git a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/MirrorConnectorsWithCustomForwardingAdminIntegrationTest.java b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/MirrorConnectorsWithCustomForwardingAdminIntegrationTest.java index 853cd02f134..a43af44329c 100644 --- a/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/MirrorConnectorsWithCustomForwardingAdminIntegrationTest.java +++ b/connect/mirror/src/test/java/org/apache/kafka/connect/mirror/integration/MirrorConnectorsWithCustomForwardingAdminIntegrationTest.java @@ -43,9 +43,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; -import java.util.Arrays; import java.util.Collection; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -172,7 +170,7 @@ public class MirrorConnectorsWithCustomForwardingAdminIntegrationTest extends Mi startClusters(additionalConfig); try (Admin adminClient = primary.kafka().createAdminClient()) { - adminClient.createAcls(Collections.singletonList( + adminClient.createAcls(List.of( new AclBinding( new ResourcePattern(ResourceType.TOPIC, "*", PatternType.LITERAL), new AccessControlEntry("User:connector", "*", AclOperation.ALL, AclPermissionType.ALLOW) @@ -180,7 +178,7 @@ public class MirrorConnectorsWithCustomForwardingAdminIntegrationTest extends Mi )).all().get(); } try (Admin adminClient = backup.kafka().createAdminClient()) { - adminClient.createAcls(Collections.singletonList( + adminClient.createAcls(List.of( new AclBinding( new ResourcePattern(ResourceType.TOPIC, "*", PatternType.LITERAL), new AccessControlEntry("User:connector", "*", AclOperation.ALL, AclPermissionType.ALLOW) @@ -202,7 +200,7 @@ public class MirrorConnectorsWithCustomForwardingAdminIntegrationTest extends Mi produceMessages(primaryProducer, "test-topic-1"); produceMessages(backupProducer, "test-topic-1"); String consumerGroupName = "consumer-group-testReplication"; - Map consumerProps = Collections.singletonMap("group.id", consumerGroupName); + Map consumerProps = Map.of("group.id", consumerGroupName); // warm up consumers before starting the connectors so we don't need to wait for discovery warmUpConsumer(consumerProps); @@ -239,7 +237,7 @@ public class MirrorConnectorsWithCustomForwardingAdminIntegrationTest extends Mi produceMessages(backupProducer, "test-topic-1"); produceMessages(primaryProducer, "test-topic-1"); String consumerGroupName = "consumer-group-testReplication"; - Map consumerProps = Collections.singletonMap("group.id", consumerGroupName); + Map consumerProps = Map.of("group.id", consumerGroupName); // warm up consumers before starting the connectors so we don't need to wait for discovery warmUpConsumer(consumerProps); @@ -255,7 +253,7 @@ public class MirrorConnectorsWithCustomForwardingAdminIntegrationTest extends Mi waitForTopicToPersistInFakeLocalMetadataStore("primary.test-topic-1"); // increase number of partitions - Map newPartitions = Collections.singletonMap("test-topic-1", NewPartitions.increaseTo(NUM_PARTITIONS + 1)); + Map newPartitions = Map.of("test-topic-1", NewPartitions.increaseTo(NUM_PARTITIONS + 1)); try (Admin adminClient = primary.kafka().createAdminClient()) { adminClient.createPartitions(newPartitions).all().get(); } @@ -274,7 +272,7 @@ public class MirrorConnectorsWithCustomForwardingAdminIntegrationTest extends Mi produceMessages(backupProducer, "test-topic-1"); produceMessages(primaryProducer, "test-topic-1"); String consumerGroupName = "consumer-group-testReplication"; - Map consumerProps = Collections.singletonMap("group.id", consumerGroupName); + Map consumerProps = Map.of("group.id", consumerGroupName); // warm up consumers before starting the connectors so we don't need to wait for discovery warmUpConsumer(consumerProps); @@ -302,7 +300,7 @@ public class MirrorConnectorsWithCustomForwardingAdminIntegrationTest extends Mi mm2Props.put("sync.topic.acls.enabled", "true"); mm2Props.put("sync.topic.acls.interval.seconds", "1"); mm2Config = new MirrorMakerConfig(mm2Props); - List aclBindings = Collections.singletonList( + List aclBindings = List.of( new AclBinding( new ResourcePattern(ResourceType.TOPIC, "test-topic-1", PatternType.LITERAL), new AccessControlEntry("User:dummy", "*", AclOperation.DESCRIBE, AclPermissionType.ALLOW) @@ -344,7 +342,7 @@ public class MirrorConnectorsWithCustomForwardingAdminIntegrationTest extends Mi ); // expect to use FakeForwardingAdminWithLocalMetadata to update topic ACLs in FakeLocalMetadataStore.allAcls - assertTrue(FakeLocalMetadataStore.aclBindings("dummy").containsAll(Arrays.asList(expectedACLOnBackupCluster, expectedACLOnPrimaryCluster))); + assertTrue(FakeLocalMetadataStore.aclBindings("dummy").containsAll(List.of(expectedACLOnBackupCluster, expectedACLOnPrimaryCluster))); } void waitForTopicToPersistInFakeLocalMetadataStore(String topicName) throws InterruptedException {