This is an automated email from the ASF dual-hosted git repository.
github-bot pushed a commit to branch test-catalog
in repository https://gitbox.apache.org/repos/asf/kafka.git
The following commit(s) were added to refs/heads/test-catalog by this push:
new e71a0f0cbfc Update test catalog data for GHA workflow run 12023992591
e71a0f0cbfc is described below
commit e71a0f0cbfc107d9b8a193d3afad7b708f042c1b
Author: github-actions[bot]
<41898282+github-actions[bot]@users.noreply.github.com>
AuthorDate: Tue Nov 26 07:04:19 2024 +0000
Update test catalog data for GHA workflow run 12023992591
Commit:
https://github.com/apache/kafka/commit/5480d54d185e236bffe003c88afa84b924d816b8
GitHub Run: https://github.com/apache/kafka/actions/runs/12023992591
---
test-catalog/connect/mirror-client/tests.yaml | 20 +
test-catalog/connect/mirror/tests.yaml | 249 ++++
test-catalog/connect/runtime/tests.yaml | 1411 ++++++++++++++++++++
test-catalog/connect/transforms/tests.yaml | 244 ++++
test-catalog/core/tests.yaml | 22 +
test-catalog/raft/tests.yaml | 11 +
test-catalog/storage/storage-api/tests.yaml | 4 +
test-catalog/streams/examples/tests.yaml | 15 +
test-catalog/streams/integration-tests/tests.yaml | 360 +++++
test-catalog/streams/streams-scala/tests.yaml | 73 +
test-catalog/streams/test-utils/tests.yaml | 170 +++
.../test-common/test-common-api/tests.yaml | 26 +
.../test-common/test-common-runtime/tests.yaml | 12 +
test-catalog/tools/tools-api/tests.yaml | 2 +
14 files changed, 2619 insertions(+)
diff --git a/test-catalog/connect/mirror-client/tests.yaml
b/test-catalog/connect/mirror-client/tests.yaml
new file mode 100644
index 00000000000..eea8d17edf1
--- /dev/null
+++ b/test-catalog/connect/mirror-client/tests.yaml
@@ -0,0 +1,20 @@
+org.apache.kafka.connect.mirror.MirrorClientTest:
+- checkpointsTopicsTest
+- countHopsForTopicTest
+- heartbeatTopicsTest
+- remoteTopicsSeparatorTest
+- remoteTopicsTest
+- replicationHopsTest
+- testIdentityReplicationRemoteTopics
+- testIdentityReplicationTopicSource
+- testIdentityReplicationUpstreamClusters
+- testIsCheckpointTopic
+- testIsHeartbeatTopic
+- upstreamClustersTest
+org.apache.kafka.connect.mirror.ReplicationPolicyTest:
+- checkpointsTopic_shouldBeEffectedByInternalTopicSeparatorEnabled
+- heartbeatsTopic_shouldNotBeEffectedByInternalTopicSeparatorConfig
+- offsetSyncsTopic_shouldBeEffectedByInternalTopicSeparatorEnabled
+- testInternalTopic
+org.apache.kafka.connect.mirror.SourceAndTargetTest:
+- testEquals
diff --git a/test-catalog/connect/mirror/tests.yaml
b/test-catalog/connect/mirror/tests.yaml
new file mode 100644
index 00000000000..0bd453eca89
--- /dev/null
+++ b/test-catalog/connect/mirror/tests.yaml
@@ -0,0 +1,249 @@
+org.apache.kafka.connect.mirror.CheckpointStoreTest:
+- testReadCheckpointsTopic
+- testReadCheckpointsTopicError
+org.apache.kafka.connect.mirror.CheckpointTest:
+- testSerde
+org.apache.kafka.connect.mirror.HeartbeatTest:
+- testSerde
+org.apache.kafka.connect.mirror.MirrorCheckpointConfigTest:
+- testConsumerConfigsForOffsetSyncsTopic
+- testGroupMatching
+- testNonMutationOfConfigDef
+- testSkipValidationIfConnectorDisabled
+- testTaskConfigConsumerGroups
+- testValidateIfConnectorEnabled
+org.apache.kafka.connect.mirror.MirrorCheckpointConnectorTest:
+- testAlterOffsetsIncorrectOffsetKey
+- testAlterOffsetsIncorrectPartitionKey
+- testAlterOffsetsInvalidPartitionPartition
+- testAlterOffsetsMissingPartitionKey
+- testAlterOffsetsMultiplePartitions
+- testAlterOffsetsOffsetValues
+- testAlterOffsetsTombstones
+- testConsumerGroupInitializeTimeout
+- testFindConsumerGroups
+- testFindConsumerGroupsInCommonScenarios
+- testMirrorCheckpointConnectorDisabled
+- testMirrorCheckpointConnectorEnabled
+- testNoConsumerGroup
+- testReplicationDisabled
+- testReplicationEnabled
+- testSuccessfulAlterOffsets
+org.apache.kafka.connect.mirror.MirrorCheckpointTaskTest:
+- testCheckpoint
+- testCheckpointRecordsMonotonicIfStoreRewinds
+- testCheckpointStoreInitialized
+- testCheckpointsTaskRestartUsesExistingCheckpoints
+- testDownstreamTopicRenaming
+- testNoCheckpointForTopicWithNullOffsetAndMetadata
+- testNoCheckpointForTopicWithoutOffsetSyncs
+- testSyncOffset
+- testSyncOffsetForTargetGroupWithNullOffsetAndMetadata
+org.apache.kafka.connect.mirror.MirrorConnectorConfigTest:
+- testCaseInsensitiveSecurityProtocol
+- testExplicitlyEnableJmxReporter
+- testInvalidSecurityProtocol
+- testMetricsReporters
+- testReplicationPolicy
+- testSourceAdminConfig
+- testSourceAdminConfigWithSourcePrefix
+- testSourceConsumerConfig
+- testSourceConsumerConfigWithSourcePrefix
+- testSourceProducerConfig
+- testSourceProducerConfigWithSourcePrefix
+- testTargetAdminConfig
+- testTargetAdminConfigWithSourcePrefix
+org.apache.kafka.connect.mirror.MirrorHeartBeatConnectorTest:
+- testAlterOffsetsIncorrectOffsetKey
+- testAlterOffsetsIncorrectPartitionKey
+- testAlterOffsetsMissingPartitionKey
+- testAlterOffsetsMultiplePartitions
+- testAlterOffsetsOffsetValues
+- testAlterOffsetsTombstones
+- testMirrorHeartbeatConnectorDisabled
+- testReplicationDisabled
+- testSuccessfulAlterOffsets
+org.apache.kafka.connect.mirror.MirrorHeartbeatTaskTest:
+- testPollCreatesRecords
+org.apache.kafka.connect.mirror.MirrorMakerConfigTest:
+- testAllConfigNames
+- testCaseInsensitiveSecurityProtocol
+- testClientConfigProperties
+- testClientInvalidSecurityProtocol
+- testClusterConfigProperties
+- testClusterPairsWithDefaultSettings
+- testClusterPairsWithGloballyDisabledHeartbeats
+- testClusterPairsWithGloballyDisabledHeartbeatsCentralLocal
+- testClusterPairsWithTwoDisabledHeartbeats
+- testEmptyClusterPairsWithGloballyDisabledHeartbeats
+- testIncludesConnectorConfigProperties
+- testIncludesTopicFilterProperties
+- testInvalidSecurityProtocol
+- testLazyConfigResolution
+- testReplicationConfigProperties
+- testWorkerConfigs
+org.apache.kafka.connect.mirror.MirrorSourceConfigTest:
+- testAdminConfigsForOffsetSyncsTopic
+- testAllTopics
+- testConfigPropertyMatching
+- testListOfTopics
+- testNoTopics
+- testNonMutationOfConfigDef
+- testOffsetSyncsTopic
+- testProducerConfigsForOffsetSyncsTopic
+- testTaskConfigTopicPartitions
+- testTopicMatching
+org.apache.kafka.connect.mirror.MirrorSourceConnectorTest:
+- testAclFiltering
+- testAclTransformation
+- testAlterOffsetsIncorrectOffsetKey
+- testAlterOffsetsIncorrectPartitionKey
+- testAlterOffsetsInvalidPartitionPartition
+- testAlterOffsetsMissingPartitionKey
+- testAlterOffsetsMultiplePartitions
+- testAlterOffsetsOffsetValues
+- testAlterOffsetsTombstones
+- testConfigPropertyFiltering
+- testConfigPropertyFilteringWithAlterConfigs
+- testConfigPropertyFilteringWithAlterConfigsAndSourceDefault
+- testDoesNotReplicateHeartbeatsWhenDisabled
+- testExactlyOnceSupport
+- testExactlyOnceSupportValidation
+- testIdentityReplication
+- testIsCycleWithNullUpstreamTopic
+- testMirrorSourceConnectorTaskConfig
+- testMissingDescribeConfigsAcl
+- testNewTopicConfigs
+- testNoBrokerAclAuthorizer
+- testNoCycles
+- testRefreshTopicPartitions
+- testRefreshTopicPartitionsTopicOnTargetFirst
+- testReplicatesHeartbeatsByDefault
+- testReplicatesHeartbeatsDespiteFilter
+- testReplicatesHeartbeatsWhenDisabledButFilterAllows
+- testSuccessfulAlterOffsets
+org.apache.kafka.connect.mirror.MirrorSourceMetricsTest:
+- testTags
+org.apache.kafka.connect.mirror.MirrorSourceTaskTest:
+- testCommitRecordWithNullMetadata
+- testOffsetSync
+- testPoll
+- testSeekBehaviorDuringStart
+- testSendSyncEvent
+- testSerde
+- testZeroOffsetSync
+org.apache.kafka.connect.mirror.MirrorUtilsTest:
+- testCreateCompactedTopic
+- testCreateCompactedTopicAlreadyExists
+-
testCreateCompactedTopicAssumeTopicAlreadyExistsWithClusterAuthorizationException
+-
testCreateCompactedTopicAssumeTopicAlreadyExistsWithTopicAuthorizationException
+-
testCreateCompactedTopicAssumeTopicAlreadyExistsWithUnsupportedVersionException
+- testCreateCompactedTopicFailsWithInvalidConfigurationException
+- testCreateCompactedTopicFailsWithTimeoutException
+org.apache.kafka.connect.mirror.OffsetSyncStoreTest:
+- testConsistentlySpacedSyncs
+- testDroppedSyncsSpacing
+- testNoTranslationIfNoOffsetSync
+- testNoTranslationIfStoreNotStarted
+- testOffsetTranslation
+- testPastOffsetTranslation
+- testPastOffsetTranslationWithoutInitializationReadToEnd
+- testRandomlySpacedSyncs
+org.apache.kafka.connect.mirror.OffsetSyncTest:
+- testSerde
+org.apache.kafka.connect.mirror.OffsetSyncWriterTest:
+- testFirePendingOffsetSyncs
+- testMaybeQueueOffsetSyncs
+- testPromoteDelayedOffsetSyncs
+org.apache.kafka.connect.mirror.integration.DedicatedMirrorIntegrationTest:
+- testClusterWithEmitOffsetDisabled
+- testMultiNodeCluster
+- testSingleNodeCluster
+org.apache.kafka.connect.mirror.integration.IdentityReplicationIntegrationTest:
+- testNoCheckpointsIfNoRecordsAreMirrored
+- testOffsetSyncsTopicsOnTarget
+- testOffsetTranslationBehindReplicationFlow
+- testOneWayReplicationWithAutoOffsetSync
+- testOneWayReplicationWithFrequentOffsetSyncs
+- testReplicateFromLatest
+- testReplicateSourceDefault
+- testReplicateTargetDefault
+- testReplication
+- testReplicationWithEmptyPartition
+- testReplicationWithoutOffsetSyncWillNotCreateOffsetSyncsTopic
+- testRestartReplication
+- testSyncTopicConfigs
+org.apache.kafka.connect.mirror.integration.MirrorConnectorsIntegrationBaseTest:
+- testNoCheckpointsIfNoRecordsAreMirrored
+- testOffsetSyncsTopicsOnTarget
+- testOffsetTranslationBehindReplicationFlow
+- testOneWayReplicationWithAutoOffsetSync
+- testOneWayReplicationWithFrequentOffsetSyncs
+- testReplicateFromLatest
+- testReplicateSourceDefault
+- testReplicateTargetDefault
+- testReplication
+- testReplicationWithEmptyPartition
+- testReplicationWithoutOffsetSyncWillNotCreateOffsetSyncsTopic
+- testRestartReplication
+- testSyncTopicConfigs
+org.apache.kafka.connect.mirror.integration.MirrorConnectorsIntegrationExactlyOnceTest:
+- testNoCheckpointsIfNoRecordsAreMirrored
+- testOffsetSyncsTopicsOnTarget
+- testOffsetTranslationBehindReplicationFlow
+- testOneWayReplicationWithAutoOffsetSync
+- testOneWayReplicationWithFrequentOffsetSyncs
+- testReplicateFromLatest
+- testReplicateSourceDefault
+- testReplicateTargetDefault
+- testReplication
+- testReplicationWithEmptyPartition
+- testReplicationWithoutOffsetSyncWillNotCreateOffsetSyncsTopic
+- testRestartReplication
+- testSyncTopicConfigs
+org.apache.kafka.connect.mirror.integration.MirrorConnectorsIntegrationSSLTest:
+- testNoCheckpointsIfNoRecordsAreMirrored
+- testOffsetSyncsTopicsOnTarget
+- testOffsetTranslationBehindReplicationFlow
+- testOneWayReplicationWithAutoOffsetSync
+- testOneWayReplicationWithFrequentOffsetSyncs
+- testReplicateFromLatest
+- testReplicateSourceDefault
+- testReplicateTargetDefault
+- testReplication
+- testReplicationWithEmptyPartition
+- testReplicationWithoutOffsetSyncWillNotCreateOffsetSyncsTopic
+- testRestartReplication
+- testSyncTopicConfigs
+org.apache.kafka.connect.mirror.integration.MirrorConnectorsIntegrationTransactionsTest:
+- testNoCheckpointsIfNoRecordsAreMirrored
+- testOffsetSyncsTopicsOnTarget
+- testOffsetTranslationBehindReplicationFlow
+- testOneWayReplicationWithAutoOffsetSync
+- testOneWayReplicationWithFrequentOffsetSyncs
+- testReplicateFromLatest
+- testReplicateSourceDefault
+- testReplicateTargetDefault
+- testReplication
+- testReplicationWithEmptyPartition
+- testReplicationWithoutOffsetSyncWillNotCreateOffsetSyncsTopic
+- testRestartReplication
+- testSyncTopicConfigs
+org.apache.kafka.connect.mirror.integration.MirrorConnectorsWithCustomForwardingAdminIntegrationTest:
+- testCreatePartitionsUseProvidedForwardingAdmin
+- testNoCheckpointsIfNoRecordsAreMirrored
+- testOffsetSyncsTopicsOnTarget
+- testOffsetTranslationBehindReplicationFlow
+- testOneWayReplicationWithAutoOffsetSync
+- testOneWayReplicationWithFrequentOffsetSyncs
+- testReplicateFromLatest
+- testReplicateSourceDefault
+- testReplicateTargetDefault
+- testReplication
+- testReplicationIsCreatingTopicsUsingProvidedForwardingAdmin
+- testReplicationWithEmptyPartition
+- testReplicationWithoutOffsetSyncWillNotCreateOffsetSyncsTopic
+- testRestartReplication
+- testSyncTopicACLsUseProvidedForwardingAdmin
+- testSyncTopicConfigUseProvidedForwardingAdmin
+- testSyncTopicConfigs
diff --git a/test-catalog/connect/runtime/tests.yaml
b/test-catalog/connect/runtime/tests.yaml
new file mode 100644
index 00000000000..950dfa2bb27
--- /dev/null
+++ b/test-catalog/connect/runtime/tests.yaml
@@ -0,0 +1,1411 @@
+org.apache.kafka.connect.cli.ConnectStandaloneTest:
+- testParseJavaPropertiesFile
+- testParseJsonFileWithConnectorConfiguration
+- testParseJsonFileWithCreateConnectorRequest
+- testParseJsonFileWithCreateConnectorRequestWithUnknownField
+- testParseJsonFileWithCreateConnectorRequestWithoutInitialState
+org.apache.kafka.connect.connector.policy.NoneConnectorClientConfigOverridePolicyTest:
+- testNoOverrides
+- testWithOverrides
+org.apache.kafka.connect.connector.policy.PrincipalConnectorClientConfigOverridePolicyTest:
+- testPrincipalOnly
+- testPrincipalPlusOtherConfigs
+org.apache.kafka.connect.converters.BooleanConverterTest:
+- testFromConnect
+- testFromConnectInvalidValue
+- testFromConnectNullSchema
+- testFromConnectNullValue
+- testFromConnectWrongSchema
+- testToConnect
+- testToConnectInvalidValue
+- testToConnectNullValue
+- testVersionRetrievedFromAppInfoParser
+org.apache.kafka.connect.converters.ByteArrayConverterTest:
+- testFromConnect
+- testFromConnectBadSchema
+- testFromConnectByteBufferValue
+- testFromConnectInvalidValue
+- testFromConnectNull
+- testFromConnectSchemaless
+- testToConnect
+- testToConnectNull
+- testVersionRetrievedFromAppInfoParser
+org.apache.kafka.connect.converters.DoubleConverterTest:
+- testBytesNullToNumber
+- testConvertingSamplesToAndFromBytes
+- testDeserializingDataWithTooManyBytes
+- testDeserializingHeaderWithTooManyBytes
+- testInheritedVersionRetrievedFromAppInfoParser
+- testNullToBytes
+- testSerializingIncorrectHeader
+- testSerializingIncorrectType
+org.apache.kafka.connect.converters.FloatConverterTest:
+- testBytesNullToNumber
+- testConvertingSamplesToAndFromBytes
+- testDeserializingDataWithTooManyBytes
+- testDeserializingHeaderWithTooManyBytes
+- testInheritedVersionRetrievedFromAppInfoParser
+- testNullToBytes
+- testSerializingIncorrectHeader
+- testSerializingIncorrectType
+org.apache.kafka.connect.converters.IntegerConverterTest:
+- testBytesNullToNumber
+- testConvertingSamplesToAndFromBytes
+- testDeserializingDataWithTooManyBytes
+- testDeserializingHeaderWithTooManyBytes
+- testInheritedVersionRetrievedFromAppInfoParser
+- testNullToBytes
+- testSerializingIncorrectHeader
+- testSerializingIncorrectType
+org.apache.kafka.connect.converters.LongConverterTest:
+- testBytesNullToNumber
+- testConvertingSamplesToAndFromBytes
+- testDeserializingDataWithTooManyBytes
+- testDeserializingHeaderWithTooManyBytes
+- testInheritedVersionRetrievedFromAppInfoParser
+- testNullToBytes
+- testSerializingIncorrectHeader
+- testSerializingIncorrectType
+org.apache.kafka.connect.converters.ShortConverterTest:
+- testBytesNullToNumber
+- testConvertingSamplesToAndFromBytes
+- testDeserializingDataWithTooManyBytes
+- testDeserializingHeaderWithTooManyBytes
+- testInheritedVersionRetrievedFromAppInfoParser
+- testNullToBytes
+- testSerializingIncorrectHeader
+- testSerializingIncorrectType
+org.apache.kafka.connect.integration.BlockingConnectorTest:
+- testBlockInConnectorConfig
+- testBlockInConnectorInitialize
+- testBlockInConnectorStart
+- testBlockInConnectorStop
+- testBlockInConnectorValidate
+- testBlockInSinkTaskStart
+- testBlockInSinkTaskStop
+- testBlockInSourceTaskStart
+- testBlockInSourceTaskStop
+- testWorkerRestartWithBlockInConnectorStart
+- testWorkerRestartWithBlockInConnectorStop
+org.apache.kafka.connect.integration.ConnectWorkerIntegrationTest:
+- testAddAndRemoveWorker
+- testBrokerCoordinator
+- testCompactedDeletedOlderConnectorConfig
+- testCreateConnectorWithPausedInitialState
+- testCreateSinkConnectorWithStoppedInitialStateAndModifyOffsets
+- testCreateSourceConnectorWithStoppedInitialStateAndModifyOffsets
+- testDeleteConnectorCreatedWithPausedOrStoppedInitialState
+- testPatchConnectorConfig
+- testPauseStopResume
+- testPluginAliases
+- testPollTimeoutExpiry
+- testReconfigureConnectorWithFailingTaskConfigs
+- testRequestTimeouts
+- testRestartFailedTask
+- testRuntimePropertyReconfiguration
+- testSourceTaskNotBlockedOnShutdownWithNonExistentTopic
+- testStoppedState
+- testTaskStatuses
+- testTasksMaxEnforcement
+org.apache.kafka.connect.integration.ConnectorClientPolicyIntegrationTest:
+- testCreateWithAllowedOverridesForAllPolicy
+- testCreateWithAllowedOverridesForDefaultPolicy
+- testCreateWithAllowedOverridesForPrincipalPolicy
+- testCreateWithNoAllowedOverridesForNonePolicy
+- testCreateWithNotAllowedOverridesForPrincipalPolicy
+- testCreateWithOverridesForNonePolicy
+org.apache.kafka.connect.integration.ConnectorRestartApiIntegrationTest:
+- testFailedConnectorRestartBothConnectorAndTasks
+- testFailedConnectorRestartOnlyConnector
+- testFailedConnectorRestartOnlyFailedConnectorAndTasks
+- testFailedTasksRestartBothConnectorAndTasks
+- testFailedTasksRestartOnlyConnector
+- testFailedTasksRestartOnlyTasks
+- testFailedTasksRestartWithoutIncludeTasksNoop
+- testMultiWorkerRestartBothConnectorAndTasks
+- testMultiWorkerRestartOnlyConnector
+- testOneFailedTasksRestartOnlyOneTasks
+- testRestartUnknownConnector
+- testRestartUnknownConnectorNoParams
+- testRunningConnectorAndTasksRestartBothConnectorAndTasks
+- testRunningConnectorAndTasksRestartBothConnectorAndTasksNoop
+- testRunningConnectorAndTasksRestartOnlyConnector
+- testRunningConnectorAndTasksRestartOnlyFailedConnectorNoop
+org.apache.kafka.connect.integration.ConnectorTopicsIntegrationTest:
+- testGetActiveTopics
+- testTopicTrackingIsDisabled
+- testTopicTrackingResetIsDisabled
+org.apache.kafka.connect.integration.ConnectorValidationIntegrationTest:
+- testConnectorHasAbstractConverter
+- testConnectorHasAbstractHeaderConverter
+- testConnectorHasConverterThatThrowsExceptionOnInstantiation
+- testConnectorHasConverterWithNoConfigDef
+- testConnectorHasConverterWithNoSuitableConstructor
+- testConnectorHasDuplicatePredicates
+- testConnectorHasDuplicateTransformations
+- testConnectorHasHeaderConverterThatThrowsExceptionOnInstantiation
+- testConnectorHasHeaderConverterWithNoConfigDef
+- testConnectorHasHeaderConverterWithNoSuitableConstructor
+- testConnectorHasInvalidConverterClassType
+- testConnectorHasInvalidHeaderConverterClassType
+- testConnectorHasInvalidPredicateClass
+- testConnectorHasInvalidTransformClass
+- testConnectorHasMisconfiguredConverter
+- testConnectorHasMisconfiguredHeaderConverter
+- testConnectorHasMissingConverterClass
+- testConnectorHasMissingHeaderConverterClass
+- testConnectorHasMissingPredicateClass
+- testConnectorHasMissingTransformClass
+- testConnectorHasNegationForUndefinedPredicate
+- testSinkConnectorDeadLetterQueueTopicInTopicsList
+- testSinkConnectorDeadLetterQueueTopicMatchesTopicsRegex
+- testSinkConnectorDefaultGroupIdConflictsWithWorkerGroupId
+- testSinkConnectorHasBothTopicsListAndTopicsRegex
+- testSinkConnectorHasNeitherTopicsListNorTopicsRegex
+- testSinkConnectorOverriddenGroupIdConflictsWithWorkerGroupId
+- testSourceConnectorHasDuplicateTopicCreationGroups
+org.apache.kafka.connect.integration.ErrorHandlingIntegrationTest:
+- testErrantRecordReporter
+- testSkipRetryAndDLQWithHeaders
+org.apache.kafka.connect.integration.ExactlyOnceSourceIntegrationTest:
+- testConnectorBoundary
+- testConnectorReconfiguration
+- testFencedLeaderRecovery
+- testIntervalBoundary
+- testPollBoundary
+- testPotentialDeadlockWhenProducingToOffsetsTopic
+- testPreflightValidation
+- testSeparateOffsetsTopic
+- testTasksFailOnInabilityToFence
+org.apache.kafka.connect.integration.ExampleConnectIntegrationTest:
+- testSinkConnector
+- testSourceConnector
+org.apache.kafka.connect.integration.InternalTopicsIntegrationTest:
+- testCreateInternalTopicsWithDefaultSettings
+- testCreateInternalTopicsWithFewerReplicasThanBrokers
+- testFailToCreateInternalTopicsWithMoreReplicasThanBrokers
+- testFailToStartWhenInternalTopicsAreNotCompacted
+-
testStartWhenInternalTopicsCreatedManuallyWithCompactForBrokersDefaultCleanupPolicy
+org.apache.kafka.connect.integration.OffsetsApiIntegrationTest:
+- testAlterOffsetsNonExistentConnector
+- testAlterOffsetsNonStoppedConnector
+- testAlterSinkConnectorOffsets
+- testAlterSinkConnectorOffsetsDifferentKafkaClusterTargeted
+- testAlterSinkConnectorOffsetsInvalidRequestBody
+- testAlterSinkConnectorOffsetsOverriddenConsumerGroupId
+- testAlterSinkConnectorOffsetsZombieSinkTasks
+- testAlterSourceConnectorOffsets
+- testAlterSourceConnectorOffsetsCustomOffsetsTopic
+- testAlterSourceConnectorOffsetsDifferentKafkaClusterTargeted
+- testAlterSourceConnectorOffsetsExactlyOnceSupportEnabled
+- testAlterSourceConnectorOffsetsInvalidRequestBody
+- testGetNonExistentConnectorOffsets
+- testGetSinkConnectorOffsets
+- testGetSinkConnectorOffsetsDifferentKafkaClusterTargeted
+- testGetSinkConnectorOffsetsOverriddenConsumerGroupId
+- testGetSourceConnectorOffsets
+- testGetSourceConnectorOffsetsCustomOffsetsTopic
+- testGetSourceConnectorOffsetsDifferentKafkaClusterTargeted
+- testResetSinkConnectorOffsets
+- testResetSinkConnectorOffsetsDifferentKafkaClusterTargeted
+- testResetSinkConnectorOffsetsOverriddenConsumerGroupId
+- testResetSinkConnectorOffsetsZombieSinkTasks
+- testResetSourceConnectorOffsets
+- testResetSourceConnectorOffsetsCustomOffsetsTopic
+- testResetSourceConnectorOffsetsDifferentKafkaClusterTargeted
+- testResetSourceConnectorOffsetsExactlyOnceSupportEnabled
+org.apache.kafka.connect.integration.RebalanceSourceConnectorsIntegrationTest:
+- testAddingWorker
+- testDeleteConnector
+- testMultipleWorkersRejoining
+- testReconfigConnector
+- testRemovingWorker
+- testStartTwoConnectors
+org.apache.kafka.connect.integration.RestExtensionIntegrationTest:
+- testRestExtensionApi
+org.apache.kafka.connect.integration.RestForwardingIntegrationTest:
+- testRestForwardFollowerSsl
+- testRestForwardLeaderSsl
+- testRestForwardNoSsl
+- testRestForwardNoSslDualListener
+- testRestForwardSsl
+- testRestForwardSslDualListener
+org.apache.kafka.connect.integration.SessionedProtocolIntegrationTest:
+- ensureInternalEndpointIsSecured
+org.apache.kafka.connect.integration.SinkConnectorsIntegrationTest:
+- testCooperativeConsumerPartitionAssignment
+- testEagerConsumerPartitionAssignment
+org.apache.kafka.connect.integration.SourceConnectorsIntegrationTest:
+- testSwitchingToTopicCreationEnabled
+- testTopicsAreCreatedWhenAutoCreateTopicsIsEnabledAtTheBroker
+- testTopicsAreCreatedWhenTopicCreationIsEnabled
+org.apache.kafka.connect.integration.StandaloneWorkerIntegrationTest:
+- testCreateConnectorWithStoppedInitialState
+- testDynamicLogging
+- testHealthCheck
+org.apache.kafka.connect.integration.StartAndStopCounterTest:
+- shouldExpectRestarts
+- shouldFailToWaitForRestartThatNeverHappens
+- shouldRecordStarts
+- shouldRecordStops
+org.apache.kafka.connect.integration.StartAndStopLatchTest:
+- shouldReturnFalseWhenAwaitingForDependentLatchToComplete
+- shouldReturnFalseWhenAwaitingForStartToNeverComplete
+- shouldReturnFalseWhenAwaitingForStopToNeverComplete
+- shouldReturnTrueWhenAwaitingForStartAndStopAndDependentLatch
+- shouldReturnTrueWhenAwaitingForStartAndStopToComplete
+org.apache.kafka.connect.integration.TransformationIntegrationTest:
+- testFilterOnHasHeaderKeyWithSourceConnectorAndTopicCreation
+- testFilterOnTombstonesWithSinkConnector
+- testFilterOnTopicNameWithSinkConnector
+org.apache.kafka.connect.runtime.AbstractHerderTest:
+- testBuildRestartPlanForConnectorAndTasks
+- testBuildRestartPlanForNoRestart
+- testBuildRestartPlanForUnknownConnector
+- testConfigProviderRegex
+- testConfigValidationAllOverride
+- testConfigValidationEmptyConfig
+- testConfigValidationInvalidTopics
+- testConfigValidationMissingName
+- testConfigValidationMultipleNullConfig
+- testConfigValidationNullConfig
+- testConfigValidationPredicatesExtendResults
+- testConfigValidationPrincipalOnlyOverride
+- testConfigValidationTopicsRegexWithDlq
+- testConfigValidationTopicsWithDlq
+- testConfigValidationTransformsExtendResults
+- testConnectorClientConfigOverridePolicyClose
+- testConnectorInfo
+- testConnectorInfoMissingPlugin
+- testConnectorOffsets
+- testConnectorOffsetsConnectorNotFound
+- testConnectorStatus
+- testConnectorStatusMissingPlugin
+- testConnectors
+- testConverterPluginConfig
+- testGenerateResultWithConfigValuesAllUsingConfigKeysAndWithNoErrors
+- testGenerateResultWithConfigValuesAllUsingConfigKeysAndWithSomeErrors
+- testGenerateResultWithConfigValuesMoreThanConfigKeysAndWithSomeErrors
+- testGenerateResultWithConfigValuesWithNoConfigKeysAndWithSomeErrors
+- testGetConnectorConfigDefWithBadName
+- testGetConnectorConfigDefWithInvalidPluginType
+- testGetConnectorTypeWithEmptyConfig
+- testGetConnectorTypeWithMissingPlugin
+- testGetConnectorTypeWithNullConfig
+- testHeaderConverterPluginConfig
+- testPauseConnector
+- testPredicatePluginConfig
+- testResumeConnector
+- testReverseTransformConfigs
+- testSinkConnectorPluginConfig
+- testSinkConnectorPluginConfigIncludingCommon
+- testSourceConnectorPluginConfig
+- testSourceConnectorPluginConfigIncludingCommon
+- testTaskConfigComparison
+- testTaskConfigsChangedWhenAppliedConnectorConfigDiffers
+- testTaskStatus
+- testTransformationPluginConfig
+org.apache.kafka.connect.runtime.AbstractWorkerSourceTaskTest:
+- testHeaders
+- testHeadersWithCustomConverter
+- testMetricsGroup
+- testSendRecordsConvertsData
+- testSendRecordsCorruptTimestamp
+- testSendRecordsNoTimestamp
+- testSendRecordsPropagatesTimestamp
+- testSendRecordsRetriableException
+- testSendRecordsTopicCreateRetries
+- testSendRecordsTopicCreateRetriesMidway
+- testSendRecordsTopicDescribeRetries
+- testSendRecordsTopicDescribeRetriesMidway
+- testTopicCreateFails
+- testTopicCreateFailsWithExceptionWhenCreateReturnsTopicNotCreatedOrFound
+- testTopicCreateSucceedsWhenCreateReturnsExistingTopicFound
+- testTopicCreateSucceedsWhenCreateReturnsNewTopicFound
+- testTopicCreateWhenTopicExists
+- testTopicDescribeFails
+org.apache.kafka.connect.runtime.ConnectMetricsTest:
+- testDisableJmxReporter
+- testExplicitlyEnableJmxReporter
+- testGettingGroupMultipleTimes
+- testGettingGroupWithOddNumberOfTags
+- testGettingGroupWithTags
+- testKafkaMetricsNotNull
+- testMetricGroupIdIdentity
+- testMetricGroupIdWithoutTags
+- testMetricReporters
+- testRecreateWithClose
+- testRecreateWithoutClose
+org.apache.kafka.connect.runtime.ConnectorConfigTest:
+- abstractKeyValueTransform
+- abstractPredicate
+- abstractTransform
+- danglingTransformAlias
+- emptyConnectorName
+- misconfiguredPredicate
+- misconfiguredTransform
+- missingPredicateAliasProperty
+- missingPredicateConfig
+- multipleTransforms
+- multipleTransformsOneDangling
+- negatedButNoPredicate
+- noTransforms
+- predicateNegationDefaultsToFalse
+- singleConditionalTransform
+- singleTransform
+- testEnrichedConfigDef
+- unconfiguredTransform
+- wrongPredicateType
+- wrongTransformationType
+org.apache.kafka.connect.runtime.ErrorHandlingTaskTest:
+- testErrorHandlingInSinkTasks
+- testErrorHandlingInSourceTasks
+- testErrorHandlingInSourceTasksWithBadConverter
+org.apache.kafka.connect.runtime.ExactlyOnceWorkerSourceTaskTest:
+- testCancel
+- testCommitFlushAsyncCallbackFailure
+- testCommitFlushSyncCallbackFailure
+- testCommitTransactionFailure
+- testConnectorAbortOnBatch
+- testConnectorAbortOnRecord
+- testConnectorAbortsEmptyTransaction
+- testConnectorCommitOnBatch
+- testConnectorCommitOnRecord
+- testFailureInOffsetStoreStart
+- testFailureInPoll
+- testFailureInPollAfterCancel
+- testFailureInPollAfterStop
+- testFailureInPostProducerCheck
+- testFailureInPreProducerCheck
+- testFailureInProducerInitialization
+- testIntervalBasedCommit
+- testMixedConnectorTransactionBoundaryAbortLastRecordCommitBatch
+- testMixedConnectorTransactionBoundaryCommitLastRecordAbortBatch
+- testPause
+- testPollBasedCommit
+- testPollReturnsNoRecords
+- testPollsInBackground
+- testRemoveMetrics
+- testSendRecordsProducerSendFailsImmediately
+- testSendRecordsRetries
+- testSlowTaskStart
+- testStartPaused
+org.apache.kafka.connect.runtime.InternalSinkRecordTest:
+- shouldRetainOriginalTopicPartition
+- testNewRecordHeaders
+org.apache.kafka.connect.runtime.LoggersTest:
+- testGetLoggerFallsBackToEffectiveLogLevel
+- testGetLoggersIgnoresNullLevels
+- testGetUnknownLogger
+- testSetLevel
+- testSetLevelNullArguments
+- testSetRootLevel
+org.apache.kafka.connect.runtime.RestartPlanTest:
+- testNoRestartsPlan
+- testRestartPlan
+- testRestartsOnlyConnector
+org.apache.kafka.connect.runtime.RestartRequestTest:
+- compareImpact
+- doNotRestartTasks
+- forciblyRestartConnectorOnly
+- restartAnyStatusConnector
+- restartAnyStatusTasks
+- restartOnlyFailedConnector
+- restartOnlyFailedTasks
+org.apache.kafka.connect.runtime.SourceConnectorConfigTest:
+- noTopicCreation
+- shouldAllowNegativeOneAndPositiveForReplicationFactor
+- shouldAllowSettingTopicProperties
+- shouldNotAllowPartitionsOrReplicationFactorLessThanNegativeOne
+- shouldNotAllowZeroPartitionsOrReplicationFactor
+- shouldNotFailWithExplicitlySpecifiedDefaultTopicCreationGroup
+org.apache.kafka.connect.runtime.SourceTaskOffsetCommitterTest:
+- testCloseInterrupted
+- testCloseTimeout
+- testRemoveCancelledTask
+- testRemoveNonExistentTask
+- testRemoveSuccess
+- testRemoveTaskAndInterrupted
+- testSchedule
+org.apache.kafka.connect.runtime.StateTrackerTest:
+- calculateDurations
+- currentState
+- currentStateIsNullWhenNotInitialized
+org.apache.kafka.connect.runtime.SubmittedRecordsTest:
+- testAwaitMessagesAfterAllAcknowledged
+- testAwaitMessagesAfterAllRemoved
+- testAwaitMessagesNoneSubmitted
+- testAwaitMessagesReturnsAfterAsynchronousAck
+- testAwaitMessagesTimesOut
+- testMultipleAcksAcrossMultiplePartitions
+- testNoCommittedRecords
+- testNoRecords
+- testNullPartitionAndOffset
+- testRemoveLastSubmittedRecord
+- testRemoveNotLastSubmittedRecord
+- testSingleAck
+org.apache.kafka.connect.runtime.TransformationConfigTest:
+- testEmbeddedConfigCast
+- testEmbeddedConfigExtractField
+- testEmbeddedConfigFlatten
+- testEmbeddedConfigHoistField
+- testEmbeddedConfigInsertField
+- testEmbeddedConfigMaskField
+- testEmbeddedConfigRegexRouter
+- testEmbeddedConfigReplaceField
+- testEmbeddedConfigSetSchemaMetadata
+- testEmbeddedConfigTimestampConverter
+- testEmbeddedConfigTimestampRouter
+- testEmbeddedConfigValueToKey
+org.apache.kafka.connect.runtime.TransformationStageTest:
+- apply
+org.apache.kafka.connect.runtime.WorkerConfigTest:
+- testKafkaClusterId
+- testLookupKafkaClusterId
+- testLookupKafkaClusterIdTimeout
+- testLookupNullKafkaClusterId
+org.apache.kafka.connect.runtime.WorkerConfigTransformerTest:
+- testReplaceVariable
+- testReplaceVariableWithTTL
+- testReplaceVariableWithTTLAndScheduleRestart
+- testReplaceVariableWithTTLFirstCancelThenScheduleRestart
+- testTransformNullConfiguration
+org.apache.kafka.connect.runtime.WorkerConnectorTest:
+- testFailConnectorThatIsNeitherSourceNorSink
+- testFailureIsFinalState
+- testInitializeFailure
+- testOnResume
+- testShutdownFailure
+- testStartupAndPause
+- testStartupAndShutdown
+- testStartupAndStop
+- testStartupFailure
+- testStartupPaused
+- testStartupStopped
+- testStopFailure
+- testTransitionPausedToPaused
+- testTransitionStartedToStarted
+- testTransitionStoppedToStopped
+org.apache.kafka.connect.runtime.WorkerMetricsGroupTest:
+- testConnectorFailureAfterStartupRecordedMetrics
+- testConnectorFailureBeforeStartupRecordedMetrics
+- testConnectorStartupRecordedMetrics
+- testTaskFailureAfterStartupRecordedMetrics
+- testTaskFailureBeforeStartupRecordedMetrics
+- testTaskStartupRecordedMetrics
+org.apache.kafka.connect.runtime.WorkerSinkTaskTest:
+- testCommitWithOutOfOrderCallback
+- testDeliveryWithMutatingTransform
+- testErrorInRebalancePartitionAssignment
+- testErrorInRebalancePartitionLoss
+- testErrorInRebalancePartitionRevocation
+- testHeaders
+- testHeadersWithCustomConverter
+- testIgnoredCommit
+- testLongRunningCommitWithoutTimeout
+- testMetricsGroup
+- testMissingTimestampPropagation
+- testOriginalTopicWithTopicMutatingTransformations
+- testPartialRevocationAndAssignment
+- testPartitionCountInCaseOfPartitionRevocation
+- testPause
+- testPollRedelivery
+- testPollRedeliveryWithConsumerRebalance
+- testPreCommit
+- testPreCommitFailure
+- testPreCommitFailureAfterPartialRevocationAndAssignment
+- testRequestCommit
+- testShutdown
+- testSinkTasksHandleCloseErrors
+- testStartPaused
+- testSuppressCloseErrors
+- testTaskCancelPreventsFinalOffsetCommit
+- testTimestampPropagation
+- testTopicsRegex
+- testWakeupInCommitSyncCausesRetry
+- testWakeupNotThrownDuringShutdown
+org.apache.kafka.connect.runtime.WorkerSinkTaskThreadedTest:
+- testAssignmentPauseResume
+- testCommit
+- testCommitConsumerFailure
+- testCommitFailure
+- testCommitSuccessFollowedByFailure
+- testCommitTimeout
+- testPollsInBackground
+- testRewind
+- testRewindOnRebalanceDuringPoll
+org.apache.kafka.connect.runtime.WorkerSourceTaskTest:
+- testCancel
+- testCommit
+- testCommitFailure
+- testFailureInPoll
+- testFailureInPollAfterCancel
+- testFailureInPollAfterStop
+- testPause
+- testPollReturnsNoRecords
+- testPollsInBackground
+- testSendRecordsProducerCallbackFail
+- testSendRecordsProducerSendFailsImmediately
+- testSendRecordsRetries
+- testSendRecordsTaskCommitRecordFail
+- testSlowTaskStart
+- testSourceTaskIgnoresProducerException
+- testStartPaused
+org.apache.kafka.connect.runtime.WorkerTaskTest:
+- cancelBeforeStopping
+- standardStartup
+- stopBeforeStarting
+- testCloseClosesManagedResources
+- testCloseClosesManagedResourcesIfSubclassThrows
+- testErrorReporterConfigurationExceptionPropagation
+- testErrorReportersConfigured
+- updateMetricsOnListenerEventsForStartupPauseResumeAndFailure
+- updateMetricsOnListenerEventsForStartupPauseResumeAndShutdown
+org.apache.kafka.connect.runtime.WorkerTest:
+- testAddConnectorByAlias
+- testAddConnectorByShortAlias
+- testAddRemoveExactlyOnceSourceTask
+- testAddRemoveSinkTask
+- testAddRemoveSourceTask
+- testAdminConfigsClientOverridesWithAllPolicy
+- testAdminConfigsClientOverridesWithNonePolicy
+- testAlterOffsetSinkConnectorOnlyDeletes
+- testAlterOffsetsConnectorDoesNotSupportOffsetAlteration
+- testAlterOffsetsSinkConnectorAlterOffsetsError
+- testAlterOffsetsSinkConnectorAltersAndDeletes
+- testAlterOffsetsSinkConnectorDeleteOffsetsError
+- testAlterOffsetsSinkConnectorNoDeletes
+- testAlterOffsetsSinkConnectorSynchronousError
+- testAlterOffsetsSourceConnector
+- testAlterOffsetsSourceConnectorError
+- testCleanupTasksOnStop
+- testConnectorGeneratesTooManyTasksAndMaxEnforced
+- testConnectorGeneratesTooManyTasksButMaxNotEnforced
+- testConnectorStatusMetricsGroup_taskStatusCounter
+- testConsumerConfigsClientOverridesWithNonePolicy
+- testConsumerConfigsWithClientOverrides
+- testConsumerConfigsWithOverrides
+- testConsumerConfigsWithoutOverrides
+- testConverterOverrides
+- testExactlyOnceSourceOffsetsConsumerConfigs
+- testExactlyOnceSourceTaskProducerConfigs
+- testExecutorServiceShutdown
+- testExecutorServiceShutdownWhenTerminationFails
+- testExecutorServiceShutdownWhenTerminationThrowsException
+- testGetSinkConnectorOffsets
+- testGetSinkConnectorOffsetsAdminClientAsynchronousError
+- testGetSinkConnectorOffsetsAdminClientSynchronousError
+- testGetSourceConnectorOffsets
+- testGetSourceConnectorOffsetsError
+- testModifyOffsetsSinkConnectorTimeout
+- testModifySourceConnectorOffsetsTimeout
+- testNormalizeSourceConnectorOffsets
+- testOffsetStoreForExactlyOnceSourceConnector
+- testOffsetStoreForExactlyOnceSourceTask
+- testOffsetStoreForRegularSourceConnector
+- testOffsetStoreForRegularSourceTask
+- testProducerConfigsWithClientOverrides
+- testProducerConfigsWithOverrides
+- testProducerConfigsWithoutOverrides
+- testReconfigureConnectorTasks
+- testRegularSourceOffsetsConsumerConfigs
+- testResetOffsetsSinkConnector
+- testResetOffsetsSinkConnectorDeleteConsumerGroupError
+- testResetOffsetsSourceConnectorExactlyOnceSupportEnabled
+- testStartAndStopConnector
+- testStartConnectorFailure
+- testStartTaskFailure
+- testStartTaskWithTooManyTaskConfigsAndMaxEnforced
+- testStartTaskWithTooManyTaskConfigsButMaxNotEnforced
+- testStopInvalidConnector
+- testTaskStatusMetricsStatuses
+- testWorkerMetrics
+- testZombieFencing
+org.apache.kafka.connect.runtime.WorkerTransactionContextTest:
+- shouldDisallowConflictingRequests
+- shouldNotAbortBatchRepeatedly
+- shouldNotAbortRecordRepeatedly
+- shouldNotCommitBatchRepeatedly
+- shouldNotCommitRecordRepeatedly
+- shouldNotifyOfBatchAbort
+- shouldNotifyOfBatchCommit
+- shouldNotifyOfRecordAbort
+- shouldNotifyOfRecordCommit
+org.apache.kafka.connect.runtime.distributed.ConnectProtocolCompatibilityTest:
+- testCoopToCoopAssignment
+- testCoopToCoopMetadata
+- testCoopToEagerAssignment
+- testCoopToEagerMetadata
+- testEagerToCoopAssignment
+- testEagerToCoopMetadata
+- testEagerToEagerAssignment
+- testEagerToEagerMetadata
+- testSessionedToCoopMetadata
+- testSessionedToEagerMetadata
+org.apache.kafka.connect.runtime.distributed.DistributedConfigTest:
+- shouldAllowNegativeOneAndPositiveForPartitions
+- shouldAllowNegativeOneAndPositiveForReplicationFactor
+- shouldAllowSettingConfigTopicSettings
+- shouldAllowSettingOffsetTopicSettings
+- shouldAllowSettingStatusTopicSettings
+- shouldConstructExpectedTransactionalId
+- shouldCreateKeyGeneratorWithDefaultSettings
+- shouldCreateKeyGeneratorWithSpecificSettings
+- shouldFailIfSignatureAlgorithmNotInVerificationAlgorithmsList
+- shouldFailWithEmptyListOfVerificationAlgorithms
+- shouldFailWithInvalidKeyAlgorithm
+- shouldFailWithInvalidKeySize
+- shouldIdentifyNeedForTransactionalLeader
+- shouldNotAllowNegativePartitionsLessThanNegativeOne
+- shouldNotAllowNegativeReplicationFactorLessThanNegativeOne
+- shouldNotAllowZeroPartitions
+- shouldNotAllowZeroReplicationFactor
+- shouldNotFailIfKeyAlgorithmNotInVerificationAlgorithmsList
+- shouldRemoveCompactionFromConfigTopicSettings
+- shouldRemoveCompactionFromOffsetTopicSettings
+- shouldRemoveCompactionFromStatusTopicSettings
+- shouldValidateAllVerificationAlgorithms
+- testCaseInsensitiveSecurityProtocol
+- testDefaultAlgorithmsNotPresent
+- testInvalidSecurityProtocol
+- testOsDefaultSocketBufferSizes
+- testSupportedKeyGeneratorAlgorithms
+- testSupportedMacAlgorithms
+org.apache.kafka.connect.runtime.distributed.DistributedHerderTest:
+- preserveHighestImpactRestartRequest
+- processRestartRequestsDequeue
+- processRestartRequestsFailureSuppression
+- putTaskConfigsWorkerStillStarting
+-
shouldThrowWhenStartAndStopExecutorThrowsRejectedExecutionExceptionAndHerderNotStopping
+- testAccessors
+- testConnectorConfigAdded
+- testConnectorConfigDetectedAfterLeaderAlreadyAssigned
+- testConnectorConfigUpdate
+- testConnectorConfigUpdateFailedTransformation
+- testConnectorGroupIdConflictsWithWorkerGroupId
+- testConnectorNameConflictsWithWorkerGroupId
+- testConnectorOffsets
+- testConnectorPaused
+- testConnectorPausedRunningTaskOnly
+- testConnectorResumed
+- testConnectorResumedRunningTaskOnly
+- testConnectorStopped
+- testConnectorTransactionBoundaryValidation
+- testConnectorTransactionBoundaryValidationHandlesConnectorErrorsGracefully
+- testConnectorTransactionBoundaryValidationHandlesInvalidValuesGracefully
+- testConnectorTransactionBoundaryValidationOnUnsupportedConnector
+- testCreateConnector
+- testCreateConnectorAlreadyExists
+- testCreateConnectorConfigBackingStoreError
+- testCreateConnectorFailedValidation
+- testCreateConnectorWithInitialState
+- testDestroyConnector
+- testDoRestartConnectorAndTasksBoth
+- testDoRestartConnectorAndTasksEmptyPlan
+- testDoRestartConnectorAndTasksNoAssignments
+- testDoRestartConnectorAndTasksOnlyConnector
+- testDoRestartConnectorAndTasksOnlyTasks
+- testExactlyOnceSourceSupportValidation
+- testExactlyOnceSourceSupportValidationHandlesConnectorErrorsGracefully
+- testExactlyOnceSourceSupportValidationHandlesInvalidValuesGracefully
+- testExactlyOnceSourceSupportValidationOnUnknownConnector
+- testExactlyOnceSourceSupportValidationOnUnsupportedConnector
+- testExactlyOnceSourceSupportValidationWhenExactlyOnceNotEnabledOnWorker
+- testExternalZombieFencingRequestAsynchronousFailure
+- testExternalZombieFencingRequestDelayedCompletion
+- testExternalZombieFencingRequestForAlreadyFencedConnector
+- testExternalZombieFencingRequestForFreshConnector
+- testExternalZombieFencingRequestForSingleTaskConnector
+- testExternalZombieFencingRequestImmediateCompletion
+- testExternalZombieFencingRequestSynchronousFailure
+- testFailedToReadBackNewlyWrittenSessionKey
+- testFailedToWriteSessionKey
+- testFenceZombiesInvalidSignature
+- testHaltCleansUpWorker
+- testHerderStopServicesClosesUponShutdown
+- testIncompleteRebalanceBeforeRevoke
+- testInconsistentConfigs
+- testIncrementalCooperativeRebalanceForExistingMember
+- testIncrementalCooperativeRebalanceForNewMember
+- testIncrementalCooperativeRebalanceWithDelay
+- testJoinAssignment
+- testJoinLeaderCatchUpFails
+- testJoinLeaderCatchUpFailsForIncrementalCooperative
+- testJoinLeaderCatchUpRetriesForIncrementalCooperative
+- testKeyExceptionDetection
+- testKeyRotationDisabledWhenWorkerBecomesFollower
+- testKeyRotationWhenWorkerBecomesLeader
+- testModifyConnectorOffsetsUnknownConnector
+- testModifyOffsetsConnectorNotInStoppedState
+- testModifyOffsetsNotLeader
+- testModifyOffsetsSinkConnector
+- testModifyOffsetsSourceConnectorExactlyOnceDisabled
+- testModifyOffsetsSourceConnectorExactlyOnceEnabled
+- testModifyOffsetsSourceConnectorExactlyOnceEnabledZombieFencingFailure
+- testPatchConnectorConfig
+- testPatchConnectorConfigNotALeader
+- testPatchConnectorConfigNotFound
+- testPollDurationOnSlowConnectorOperations
+- testPutConnectorConfig
+- testPutTaskConfigsDisallowedSignatureAlgorithm
+- testPutTaskConfigsInvalidSignature
+- testPutTaskConfigsMissingRequiredSignature
+- testPutTaskConfigsSignatureNotRequiredV0
+- testPutTaskConfigsSignatureNotRequiredV1
+- testPutTaskConfigsValidRequiredSignature
+- testRebalance
+- testRebalanceFailedConnector
+- testRequestProcessingOrder
+- testRestartConnector
+- testRestartConnectorAndTasksNotLeader
+- testRestartConnectorAndTasksSuccess
+- testRestartConnectorAndTasksUnknownConnector
+- testRestartConnectorAndTasksUnknownStatus
+- testRestartConnectorRedirectToLeader
+- testRestartConnectorRedirectToOwner
+- testRestartTask
+- testRestartTaskRedirectToLeader
+- testRestartTaskRedirectToOwner
+- testRestartUnknownConnector
+- testRestartUnknownTask
+- testRevoke
+- testStopConnector
+- testStopConnectorFailToWriteTaskConfigs
+- testStopConnectorNotLeader
+- testTaskConfigAdded
+- testTaskReconfigurationNoRetryWithTooManyTasks
+- testTaskReconfigurationRetriesWithConnectorTaskConfigsException
+- testTaskReconfigurationRetriesWithLeaderRequestForwardingException
+- testTaskRequestedZombieFencingFailedForwardToLeader
+- testTaskRequestedZombieFencingForwardedToLeader
+- testThreadNames
+- testUnknownConnectorPaused
+- testVerifyTaskGeneration
+org.apache.kafka.connect.runtime.distributed.IncrementalCooperativeAssignorTest:
+- testAssignConnectorsWhenBalanced
+- testAssignConnectorsWhenImbalanced
+- testAssignTasksWhenBalanced
+- testAssignmentsWhenWorkersJoinAfterRevocations
+- testDuplicatedAssignmentHandleWhenTheDuplicatedAssignmentsDeleted
+- testImmediateRevocationsWhenMaxDelayIs0
+- testLeaderStateUpdated
+- testLostAssignmentHandlingWhenScheduledDelayIsDisabled
+- testLostAssignmentHandlingWhenWorkerBounces
+- testLostAssignmentHandlingWhenWorkerBouncesBackButFinallyLeaves
+- testLostAssignmentHandlingWhenWorkerLeavesPermanently
+- testLostAssignmentHandlingWithMoreThanOneCandidates
+- testProtocolV1
+- testProtocolV2
+- testScheduledDelayIsDisabled
+- testSuccessiveRevocationsWhenMaxDelayIsEqualToExpBackOffInitialInterval
+- testTaskAssignmentWhenConnectorsAreDeleted
+- testTaskAssignmentWhenFirstAssignmentAttemptFails
+- testTaskAssignmentWhenLeaderBounces
+- testTaskAssignmentWhenLeaderLeavesPermanently
+- testTaskAssignmentWhenSubsequentAssignmentAttemptFails
+- testTaskAssignmentWhenSubsequentAssignmentAttemptFailsOutsideTheAssignor
+- testTaskAssignmentWhenTasksDuplicatedInWorkerAssignment
+- testTaskAssignmentWhenWorkerBounces
+- testTaskAssignmentWhenWorkerJoins
+- testTaskAssignmentWhenWorkerLeavesPermanently
+- testWorkerJoiningDuringDelayedRebalance
+org.apache.kafka.connect.runtime.distributed.WorkerCoordinatorIncrementalTest:
+- testMetadata
+- testMetadataWithExistingAssignment
+- testMetadataWithExistingAssignmentButOlderProtocolSelection
+- testTaskAssignmentWhenWorkerBounces
+- testTaskAssignmentWhenWorkerJoins
+- testTaskAssignmentWhenWorkerLeavesPermanently
+org.apache.kafka.connect.runtime.distributed.WorkerCoordinatorTest:
+- testJoinLeaderCannotAssign
+- testLeaderPerformAssignment1
+- testLeaderPerformAssignment2
+- testLeaderPerformAssignmentSingleTaskConnectors
+- testMetadata
+- testNormalJoinGroupFollower
+- testNormalJoinGroupLeader
+- testRejoinGroup
+- testSkippingAssignmentFails
+org.apache.kafka.connect.runtime.distributed.WorkerGroupMemberTest:
+- testDisableJmxReporter
+- testMetrics
+org.apache.kafka.connect.runtime.errors.ErrorReporterTest:
+- initializeDLQWithNullMetrics
+- testCloseDLQ
+- testDLQConfigWithEmptyTopicName
+- testDLQConfigWithValidTopicName
+- testDlqHeaderConsumerRecord
+- testDlqHeaderIsAppended
+- testDlqHeaderOnNullExceptionMessage
+- testLogMessageWithNoRecords
+- testLogMessageWithSinkRecords
+- testLogOnDisabledLogReporter
+- testLogOnEnabledLogReporter
+- testLogReportAndReturnFuture
+- testReportDLQTwice
+- testSetDLQConfigs
+org.apache.kafka.connect.runtime.errors.RetryWithToleranceOperatorTest:
+- testBackoffLimit
+- testCloseErrorReporters
+- testCloseErrorReportersExceptionPropagation
+- testDefaultConfigs
+- testExecAndHandleNonRetriableError
+- testExecAndHandleRetriableErrorOnce
+- testExecAndHandleRetriableErrorThrice
+- testExecAndHandleRetriableErrorWithInfiniteRetries
+- testExecAndHandleRetriableErrorWithMaxRetriesExceeded
+- testExecuteFailed
+- testExecuteFailedNoTolerance
+- testExitLatch
+- testHandleExceptionInHeaderConverter
+- testHandleExceptionInKeyConverter
+- testHandleExceptionInTaskPoll
+- testHandleExceptionInTaskPut
+- testHandleExceptionInTransformations
+- testHandleExceptionInValueConverter
+- testReportWithMultipleReporters
+- testReportWithSingleReporter
+- testSetConfigs
+- testThrowExceptionInKafkaConsume
+- testThrowExceptionInKafkaProduce
+- testThrowExceptionInTaskPoll
+- testThrowExceptionInTaskPut
+- testToleranceLimit
+org.apache.kafka.connect.runtime.errors.WorkerErrantRecordReporterTest:
+- testGetFutures
+- testReportErrorsTolerated
+- testReportNoToleratedErrors
+org.apache.kafka.connect.runtime.health.ConnectClusterStateImplTest:
+- connectorConfig
+- connectors
+- connectorsFailure
+- kafkaClusterId
+org.apache.kafka.connect.runtime.isolation.DelegatingClassLoaderTest:
+- testEmptyConnectorLoader
+- testEmptyGetResource
+- testEmptyLoadClass
+- testInitializedConnectorLoader
+- testInitializedLoadClass
+org.apache.kafka.connect.runtime.isolation.PluginDescTest:
+- testNullArguments
+- testPluginDescComparison
+- testPluginDescEquality
+- testPluginDescWithNullVersion
+- testPluginDescWithSystemClassLoader
+- testRegularPluginDesc
+org.apache.kafka.connect.runtime.isolation.PluginScannerTest:
+- testNonVersionedPluginHasUndefinedVersion
+- testScanningEmptyPluginPath
+- testScanningInvalidUberJar
+- testScanningMixOfValidAndInvalidPlugins
+- testScanningNoPlugins
+- testScanningPluginClasses
+- testScanningPluginDirContainsInvalidJarsOnly
+- testScanningPluginDirEmpty
+- testVersionedPluginsHasVersion
+org.apache.kafka.connect.runtime.isolation.PluginUtilsTest:
+- testAllowedBasicAuthExtensionClasses
+- testAllowedFileConnectors
+- testAllowedJsonConverterClasses
+- testAllowedRuntimeClasses
+- testClientConfigProvider
+- testCollidingPrunedAlias
+- testCollidingSimpleAlias
+- testConnectApiClasses
+- testConnectRuntimeClasses
+- testEmptyPluginUrls
+- testEmptyStructurePluginUrls
+- testJavaLibraryClasses
+- testKafkaDependencyClasses
+- testMirrorClasses
+- testMultiVersionAlias
+- testNonCollidingAliases
+- testOrderOfPluginUrlsWithJars
+- testPluginUrlsWithAbsoluteSymlink
+- testPluginUrlsWithClasses
+- testPluginUrlsWithJars
+- testPluginUrlsWithRelativeSymlinkBackwards
+- testPluginUrlsWithRelativeSymlinkForwards
+- testPluginUrlsWithZips
+- testThirdPartyClasses
+- testTransformsClasses
+org.apache.kafka.connect.runtime.isolation.PluginsTest:
+- newConfigProviderShouldConfigureWithPluginClassLoader
+- newConnectorShouldInstantiateWithPluginClassLoader
+- newConverterShouldConfigureWithPluginClassLoader
+- newHeaderConverterShouldConfigureWithPluginClassLoader
+- newPluginShouldInstantiateWithPluginClassLoader
+- newPluginShouldServiceLoadWithPluginClassLoader
+- newPluginsShouldConfigureWithPluginClassLoader
+- pluginClassLoaderReadVersionFromResourceExistingInParentAndChild
+- pluginClassLoaderReadVersionFromResourceExistingOnlyInChild
+- pluginClassLoaderReadVersionFromResourceExistingOnlyInParent
+- shouldFailToFindConverterInCurrentClassloader
+- shouldFindCoLocatedPluginIfBadPackaging
+- shouldHideIfNoDefaultConstructor
+- shouldInstantiateAndConfigureConnectRestExtension
+- shouldInstantiateAndConfigureConverters
+- shouldInstantiateAndConfigureDefaultHeaderConverter
+-
shouldInstantiateAndConfigureExplicitlySetHeaderConverterWithCurrentClassLoader
+- shouldInstantiateAndConfigureInternalConverters
+- shouldNotThrowIfVersionMethodThrows
+- shouldShareStaticValuesBetweenSamePlugin
+- shouldThrowIfDefaultConstructorPrivate
+- shouldThrowIfDefaultConstructorThrows
+- shouldThrowIfNoDefaultConstructor
+- shouldThrowIfPluginInnerClass
+- shouldThrowIfPluginMissingSuperclass
+- shouldThrowIfPluginThrows
+- shouldThrowIfStaticInitializerThrows
+- shouldThrowIfStaticInitializerThrowsServiceLoader
+- subclassedReflectivePluginShouldNotAppearIsolated
+- subclassedServiceLoadedPluginShouldNotAppearIsolated
+- testAliasesInConverters
+- testHybridFailMissingPlugins
+- testHybridFailNoPlugins
+- testHybridFailWithPlugins
+- testHybridWarnMissingPlugins
+- testHybridWarnNoPlugins
+- testHybridWarnWithPlugins
+- testOnlyScanNoPlugins
+- testOnlyScanWithPlugins
+- testServiceLoadNoPlugins
+- testServiceLoadWithPlugins
+org.apache.kafka.connect.runtime.isolation.SynchronizationTest:
+- testPluginClassLoaderDoesntHoldMonitorLock
+- testSimultaneousUpwardAndDownwardDelegating
+org.apache.kafka.connect.runtime.rest.ConnectRestServerTest:
+- testAdvertisedUri
+- testCORSDisabled
+- testCORSEnabled
+- testDefaultCustomizedHttpResponseHeaders
+- testDisableAdminEndpoint
+- testIndependentAdminEndpoint
+- testLoggerEndpointWithDefaults
+- testOptionsDoesNotIncludeWadlOutput
+- testRequestLogs
+- testStandaloneConfig
+- testValidCustomizedHttpResponseHeaders
+org.apache.kafka.connect.runtime.rest.InternalRequestSignatureTest:
+- addToRequestShouldAddHeadersOnValidSignatureAlgorithm
+- addToRequestShouldThrowExceptionOnInvalidSignatureAlgorithm
+- fromHeadersShouldReturnNonNullResultOnValidSignatureAndSignatureAlgorithm
+- fromHeadersShouldReturnNullIfSignatureAlgorithmHeaderMissing
+- fromHeadersShouldReturnNullIfSignatureHeaderMissing
+- fromHeadersShouldReturnNullOnNullHeaders
+- fromHeadersShouldThrowExceptionOnInvalidBase64Signature
+- fromHeadersShouldThrowExceptionOnInvalidSignatureAlgorithm
+- testSignatureValidation
+org.apache.kafka.connect.runtime.rest.RestClientTest:
+- testFailureDuringRequestCausesInternalServerError
+- testHttpRequestInterrupted
+- testIOExceptionCausesInternalServerError
+- testNoContent
+- testNonEmptyResponseWithVoidResponseType
+- testNullMethod
+- testNullResponseType
+- testNullUrl
+- testRequestSignatureFailureCausesInternalServerError
+- testRuntimeExceptionCausesInternalServerError
+- testStatusCodeAndErrorMessagePreserved
+- testSuccess
+- testUnexpectedHttpResponseCausesInternalServerError
+- testUseSslConfigsOnlyWhenNecessary
+org.apache.kafka.connect.runtime.rest.RestServerConfigTest:
+- testAdminListenersConfigAllowedValues
+- testAdminListenersNotAllowingBlankStrings
+- testAdminListenersNotAllowingEmptyStrings
+- testInvalidHeaderConfigs
+- testInvalidSslClientAuthConfig
+- testListenersConfigAllowedValues
+- testListenersConfigNotAllowedValues
+- testValidHeaderConfigs
+org.apache.kafka.connect.runtime.rest.entities.ConnectorOffsetsTest:
+- testConnectorOffsetsToMap
+org.apache.kafka.connect.runtime.rest.entities.ConnectorTypeTest:
+- testForValue
+- testToStringIsLowerCase
+org.apache.kafka.connect.runtime.rest.entities.CreateConnectorRequestTest:
+- testForValue
+- testToTargetState
+org.apache.kafka.connect.runtime.rest.entities.PluginInfoTest:
+- testNoVersionFilter
+org.apache.kafka.connect.runtime.rest.resources.ConnectorPluginsResourceTest:
+- testConnectorPluginsIncludesClassTypeAndVersionInformation
+- testGetConnectorConfigDef
+- testListAllPlugins
+- testListConnectorPlugins
+- testValidateConfigWithAlias
+- testValidateConfigWithNonExistentAlias
+- testValidateConfigWithNonExistentName
+- testValidateConfigWithSimpleName
+- testValidateConfigWithSingleErrorDueToMissingConnectorClassname
+org.apache.kafka.connect.runtime.rest.resources.ConnectorsResourceTest:
+- testAlterOffsets
+- testAlterOffsetsConnectorNotFound
+- testAlterOffsetsEmptyOffsets
+- testAlterOffsetsNotLeader
+- testCompleteOrForwardWithErrorAndNoForwardUrl
+- testConnectorActiveTopics
+- testConnectorActiveTopicsWithTopicTrackingDisabled
+- testCreateConnector
+- testCreateConnectorConfigNameMismatch
+- testCreateConnectorExists
+- testCreateConnectorNameAllWhitespaces
+- testCreateConnectorNameTrimWhitespaces
+- testCreateConnectorNoName
+- testCreateConnectorNotLeader
+- testCreateConnectorWithControlSequenceInName
+- testCreateConnectorWithHeaders
+- testCreateConnectorWithPausedInitialState
+- testCreateConnectorWithRunningInitialState
+- testCreateConnectorWithSpecialCharsInName
+- testCreateConnectorWithStoppedInitialState
+- testDeleteConnector
+- testDeleteConnectorNotFound
+- testDeleteConnectorNotLeader
+- testExpandConnectorsInfo
+- testExpandConnectorsStatus
+- testExpandConnectorsWithConnectorNotFound
+- testFullExpandConnectors
+- testGetConnector
+- testGetConnectorConfig
+- testGetConnectorConfigConnectorNotFound
+- testGetConnectorTaskConfigs
+- testGetConnectorTaskConfigsConnectorNotFound
+- testGetOffsets
+- testGetOffsetsConnectorNotFound
+- testGetTaskConfigs
+- testListConnectors
+- testPatchConnectorConfig
+- testPatchConnectorConfigLeaderRedirect
+- testPatchConnectorConfigNotFound
+- testPutConnectorConfig
+- testPutConnectorConfigNameMismatch
+- testPutConnectorConfigWithControlSequenceInName
+- testPutConnectorConfigWithSpecialCharsInName
+- testResetConnectorActiveTopics
+- testResetConnectorActiveTopicsWithTopicTrackingDisabled
+- testResetConnectorActiveTopicsWithTopicTrackingEnabled
+- testResetOffsets
+- testResetOffsetsConnectorNotFound
+- testResetOffsetsNotLeader
+- testRestartConnectorAndTasksConnectorNotFound
+- testRestartConnectorAndTasksLeaderRedirect
+- testRestartConnectorAndTasksRebalanceNeeded
+- testRestartConnectorAndTasksRequestAccepted
+- testRestartConnectorLeaderRedirect
+- testRestartConnectorNotFound
+- testRestartConnectorOwnerRedirect
+- testRestartTaskLeaderRedirect
+- testRestartTaskNotFound
+- testRestartTaskOwnerRedirect
+org.apache.kafka.connect.runtime.rest.resources.InternalConnectResourceTest:
+- testFenceZombiesConnectorNotFound
+- testFenceZombiesNoInternalRequestSignature
+- testFenceZombiesWithInternalRequestSignature
+- testPutConnectorTaskConfigsConnectorNotFound
+- testPutConnectorTaskConfigsNoInternalRequestSignature
+- testPutConnectorTaskConfigsWithInternalRequestSignature
+org.apache.kafka.connect.runtime.rest.resources.LoggingResourceTest:
+- setLevelWithEmptyArgTest
+- setLevelWithInvalidArgTest
+- testGetLevel
+- testGetLevelNotFound
+- testSetLevelClusterScope
+- testSetLevelDefaultScope
+- testSetLevelInvalidScope
+- testSetLevelWorkerScope
+org.apache.kafka.connect.runtime.rest.resources.RootResourceTest:
+- testHealthCheckRunning
+- testHealthCheckStarting
+- testHealthCheckStartingWithStage
+- testHealthCheckUnhealthy
+- testHealthCheckUnhealthyWithStage
+- testRootGet
+org.apache.kafka.connect.runtime.rest.util.SSLUtilsTest:
+- testCreateClientSideSslContextFactory
+- testCreateClientSideSslContextFactoryDefaultValues
+- testCreateServerSideSslContextFactory
+- testCreateServerSideSslContextFactoryDefaultValues
+- testGetOrDefault
+org.apache.kafka.connect.runtime.standalone.StandaloneConfigTest:
+- testRestServerNonPrefixedSslConfigs
+- testRestServerPrefixedSslConfigs
+org.apache.kafka.connect.runtime.standalone.StandaloneHerderTest:
+- testAccessors
+- testAlterConnectorOffsets
+- testCorruptConfig
+- testCreateAndStop
+- testCreateConnectorAlreadyExists
+- testCreateConnectorFailedValidation
+- testCreateConnectorWithStoppedInitialState
+- testCreateSinkConnector
+- testCreateSourceConnector
+- testDestroyConnector
+- testModifyConnectorOffsetsConnectorNotInStoppedState
+- testModifyConnectorOffsetsUnknownConnector
+- testPatchConnectorConfig
+- testPatchConnectorConfigNotFound
+- testPutConnectorConfig
+- testPutTaskConfigs
+- testRequestTaskReconfigurationDoesNotDeadlock
+- testResetConnectorOffsets
+- testRestartConnectorAndTasksBoth
+- testRestartConnectorAndTasksNoRestarts
+- testRestartConnectorAndTasksNoStatus
+- testRestartConnectorAndTasksOnlyConnector
+- testRestartConnectorAndTasksOnlyTasks
+- testRestartConnectorAndTasksUnknownConnector
+- testRestartConnectorFailureOnStart
+- testRestartConnectorNewTaskConfigs
+- testRestartConnectorSameTaskConfigs
+- testRestartTask
+- testRestartTaskFailureOnStart
+- testTargetStates
+org.apache.kafka.connect.storage.ConnectorOffsetBackingStoreTest:
+- testFlushFailureWhenWriteToSecondaryStoreFailsForTombstoneOffsets
+-
testFlushFailureWhenWritesToPrimaryStoreFailsAndSecondarySucceedsForRegularAndTombstoneOffsets
+-
testFlushFailureWhenWritesToPrimaryStoreFailsAndSecondarySucceedsForRegularOffsets
+- testFlushFailureWhenWritesToPrimaryStoreFailsWithNoSecondaryStore
+-
testFlushFailureWhenWritesToPrimaryStoreTimesoutAndSecondarySucceedsForTombstoneOffsets
+- testFlushFailureWhenWritesToSecondaryStoreTimesoutForTombstoneOffsets
+- testFlushSuccessWhenWriteToSecondaryStoreFailsForRegularOffsets
+- testFlushSuccessWhenWritesSucceedToBothPrimaryAndSecondaryStores
+- testFlushSuccessWhenWritesToPrimaryStoreSucceedsWithNoSecondaryStore
+- testFlushSuccessWhenWritesToSecondaryStoreTimesoutForRegularOffsets
+org.apache.kafka.connect.storage.FileOffsetBackingStoreTest:
+- testConnectorPartitions
+- testGetSet
+- testSaveRestore
+org.apache.kafka.connect.storage.KafkaConfigBackingStoreTest:
+- testBackgroundConnectorDeletion
+- testBackgroundUpdateTargetState
+- testClientIds
+-
testConsumerPropertiesDoNotOverrideUserSuppliedValuesWithoutExactlyOnceSourceEnabled
+- testConsumerPropertiesInsertedByDefaultWithExactlyOnceSourceEnabled
+- testConsumerPropertiesNotInsertedByDefaultWithoutExactlyOnceSourceEnabled
+- testConsumerPropertiesOverrideUserSuppliedValuesWithExactlyOnceSourceEnabled
+- testExceptionOnStartWhenConfigTopicHasMultiplePartitions
+- testFencableProducerPropertiesInsertedByDefault
+- testFencableProducerPropertiesOverrideUserSuppliedValues
+- testPutConnectorConfig
+- testPutConnectorConfigProducerError
+- testPutConnectorConfigWithTargetState
+- testPutLogLevel
+- testPutRestartRequestOnlyFailed
+- testPutRestartRequestOnlyFailedIncludingTasks
+- testPutTaskConfigs
+- testPutTaskConfigsDoesNotResolveAllInconsistencies
+- testPutTaskConfigsStartsOnlyReconfiguredTasks
+- testPutTaskConfigsZeroTasks
+- testRecordToRestartRequest
+- testRecordToRestartRequestIncludeTasksInconsistent
+- testRecordToRestartRequestOnlyFailedInconsistent
+- testRemoveConnectorConfigSlowProducer
+- testRestore
+- testRestoreConnectorDeletion
+- testRestoreRestartRequestInconsistentState
+- testRestoreTargetState
+- testRestoreTargetStateUnexpectedDeletion
+- testRestoreZeroTasks
+- testSameTargetState
+- testSnapshotCannotMutateInternalState
+- testStartStop
+- testTaskCountRecordsAndGenerations
+- testWritePrivileges
+org.apache.kafka.connect.storage.KafkaOffsetBackingStoreTest:
+- testClientIds
+- testConnectorPartitions
+-
testConsumerPropertiesDoNotOverrideUserSuppliedValuesWithoutExactlyOnceSourceEnabled
+- testConsumerPropertiesInsertedByDefaultWithExactlyOnceSourceEnabled
+- testConsumerPropertiesNotInsertedByDefaultWithoutExactlyOnceSourceEnabled
+- testConsumerPropertiesOverrideUserSuppliedValuesWithExactlyOnceSourceEnabled
+- testGetSet
+- testGetSetNull
+- testReloadOnStart
+- testSetFailure
+- testStartStop
+org.apache.kafka.connect.storage.KafkaStatusBackingStoreFormatTest:
+- deleteTopicStatus
+- putTopicState
+- putTopicStateNonRetriableFailure
+- putTopicStateRetriableFailure
+- putTopicStateShouldOverridePreviousState
+- readInvalidStatus
+- readInvalidStatusValue
+- readTopicStatus
+org.apache.kafka.connect.storage.KafkaStatusBackingStoreTest:
+- deleteConnectorState
+- deleteTaskState
+- misconfigurationOfStatusBackingStore
+- putConnectorState
+- putConnectorStateNonRetriableFailure
+- putConnectorStateRetriableFailure
+- putConnectorStateShouldOverride
+- putSafeConnectorIgnoresStaleStatus
+- putSafeOverridesValueSetBySameWorker
+- putSafeWithNoPreviousValueIsPropagated
+- putTaskState
+- readConnectorState
+- readTaskState
+- readTaskStateShouldIgnoreStaleStatusesFromOtherWorkers
+- testClientIds
+org.apache.kafka.connect.storage.MemoryConfigBackingStoreTest:
+- testPutConnectorConfig
+- testPutConnectorConfigUpdateExisting
+- testPutConnectorConfigWithTargetState
+- testPutTargetState
+- testPutTaskConfigs
+- testRemoveConnectorConfig
+- testRemoveTaskConfigs
+org.apache.kafka.connect.storage.MemoryStatusBackingStoreTest:
+- deleteConnectorStatus
+- deleteTaskStatus
+- putAndGetConnectorStatus
+- putAndGetTaskStatus
+org.apache.kafka.connect.storage.OffsetStorageWriterTest:
+- testAlreadyFlushing
+- testCancelAfterAwaitFlush
+- testCancelBeforeAwaitFlush
+- testFlushFailureReplacesOffsets
+- testNoOffsetsToFlush
+- testWriteFlush
+- testWriteNullKeyFlush
+- testWriteNullValueFlush
+org.apache.kafka.connect.storage.OffsetUtilsTest:
+- testProcessPartitionKeyListWithElementsOfWrongType
+- testProcessPartitionKeyListWithOneElement
+- testProcessPartitionKeyNotList
+- testProcessPartitionKeyNullPartition
+- testProcessPartitionKeyValidList
+- testProcessPartitionKeyWithUnknownSerialization
+- testValidateFormatMapWithNonPrimitiveKeys
+- testValidateFormatMapWithNonStringKeys
+- testValidateFormatNotMap
+- testValidateFormatWithValidFormat
+org.apache.kafka.connect.util.ConnectUtilsTest:
+- testAddMetricsContextPropertiesDistributed
+- testAddMetricsContextPropertiesStandalone
+- testClientIdBase
+- testNoOverrideWarning
+- testOverrideWarning
+- testPatchConfig
+org.apache.kafka.connect.util.ConvertingFutureCallbackTest:
+- shouldBlockUntilCancellation
+- shouldBlockUntilFailedCompletion
+- shouldBlockUntilSuccessfulCompletion
+- shouldCancelBeforeGetIfMayCancelWhileRunning
+- shouldConvertBeforeGetOnSuccessfulCompletion
+- shouldConvertOnlyOnceBeforeGetOnSuccessfulCompletion
+- shouldNotCancelIfMayNotCancelWhileRunning
+- shouldNotConvertBeforeGetOnFailedCompletion
+- shouldRecordOnlyFirstErrorBeforeGetOnFailedCompletion
+org.apache.kafka.connect.util.KafkaBasedLogTest:
+- testGetOffsetsConsumerErrorOnReadToEnd
+- testOffsetReadFailureWhenWorkThreadFails
+- testPollConsumerError
+- testProducerError
+- testReadEndOffsetsUsingAdmin
+- testReadEndOffsetsUsingAdminThatFailsWithRetriable
+- testReadEndOffsetsUsingAdminThatFailsWithUnsupported
+- testReloadOnStart
+- testReloadOnStartWithNoNewRecordsPresent
+- testSendAndReadToEnd
+- testStartStop
+- testWithExistingClientsStartAndStop
+- testWithExistingClientsStopOnly
+org.apache.kafka.connect.util.LoggingContextTest:
+- shouldAllowNestedLoggingContexts
+- shouldCreateAndCloseLoggingContextEvenWithNullContextMap
+- shouldCreateConnectorLoggingContext
+- shouldCreateOffsetsLoggingContext
+- shouldCreateTaskLoggingContext
+- shouldNotAllowNullConnectorNameForConnectorContext
+- shouldNotAllowNullTaskIdForOffsetContext
+- shouldNotAllowNullTaskIdForTaskContext
+org.apache.kafka.connect.util.RetryUtilTest:
+- failWithNonRetriableException
+- noRetryAndFailed
+- noRetryAndSucceed
+- retriesEventuallySucceed
+- testBackoffMoreThanTimeoutWillOnlyExecuteOnce
+- testExhaustingRetries
+- testInvalidRetryTimeout
+- testInvalidTimeDuration
+- testNoBackoffTimeAndFail
+- testNoBackoffTimeAndSucceed
+- testSuccess
+- testSupplier
+- testWakeupException
+org.apache.kafka.connect.util.SharedTopicAdminTest:
+- shouldCloseAfterTopicAdminUsed
+- shouldCloseAfterTopicAdminUsedMultipleTimes
+- shouldCloseWithDurationAfterTopicAdminUsed
+- shouldCloseWithoutBeingUsed
+- shouldFailToGetTopicAdminAfterClose
+org.apache.kafka.connect.util.SinkUtilsTest:
+- testConsumerGroupOffsetsToConnectorOffsets
+- testNullOffset
+- testNullPartition
+- testNullTopic
+- testValidateAndParseEmptyPartitionOffsetMap
+- testValidateAndParseIntegerOffsetValue
+- testValidateAndParseIntegerPartitionValue
+- testValidateAndParseInvalidOffset
+- testValidateAndParseInvalidPartition
+- testValidateAndParseStringOffsetValue
+- testValidateAndParseStringPartitionValue
+org.apache.kafka.connect.util.TableTest:
+- basicOperations
+org.apache.kafka.connect.util.TopicAdminTest:
+- createShouldReturnFalseWhenSuppliedNullTopicDescription
+- describeShouldReturnEmptyWhenTopicDoesNotExist
+- describeShouldReturnTopicDescriptionWhenTopicExists
+- describeTopicConfigShouldReturnEmptyMapWhenClusterAuthorizationFailure
+- describeTopicConfigShouldReturnEmptyMapWhenNoTopicsAreSpecified
+- describeTopicConfigShouldReturnEmptyMapWhenTopicAuthorizationFailure
+- describeTopicConfigShouldReturnEmptyMapWhenUnsupportedVersionFailure
+- describeTopicConfigShouldReturnMapWithNullValueWhenTopicDoesNotExist
+- describeTopicConfigShouldReturnTopicConfigWhenTopicExists
+- endOffsetsShouldFailWhenAnyTopicPartitionHasError
+- endOffsetsShouldFailWithNonRetriableWhenAuthorizationFailureOccurs
+- endOffsetsShouldFailWithNonRetriableWhenUnknownErrorOccurs
+- endOffsetsShouldFailWithTimeoutExceptionWhenTimeoutErrorOccurs
+- endOffsetsShouldFailWithUnsupportedVersionWhenVersionUnsupportedErrorOccurs
+- endOffsetsShouldReturnEmptyMapWhenPartitionsSetIsNull
+- endOffsetsShouldReturnOffsetsForMultiplePartitions
+- endOffsetsShouldReturnOffsetsForOnePartition
+- retryEndOffsetsShouldRethrowUnknownVersionException
+- retryEndOffsetsShouldRetryWhenTopicNotFound
+- retryEndOffsetsShouldWrapNonRetriableExceptionsWithConnectException
+- returnEmptyWithApiVersionMismatchOnCreate
+- returnEmptyWithClusterAuthorizationFailureOnCreate
+- returnEmptyWithTopicAuthorizationFailureOnCreate
+- shouldCreateOneTopicWhenProvidedMultipleDefinitionsWithSameTopicName
+- shouldCreateTopicWithDefaultPartitionsAndReplicationFactorWhenItDoesNotExist
+- shouldCreateTopicWithPartitionsWhenItDoesNotExist
+- shouldCreateTopicWithReplicationFactorWhenItDoesNotExist
+- shouldNotCreateTopicWhenItAlreadyExists
+- shouldRetryCreateTopicWhenAvailableBrokersAreNotEnoughForReplicationFactor
+- shouldRetryWhenTopicCreateThrowsWrappedTimeoutException
+- throwsWithClusterAuthorizationFailureOnDescribe
+- throwsWithTopicAuthorizationFailureOnDescribe
+- verifyingGettingTopicCleanupPolicies
+- verifyingTopicCleanupPolicyShouldFailWhenTopicHasDeleteAndCompactPolicy
+- verifyingTopicCleanupPolicyShouldFailWhenTopicHasDeletePolicy
+- verifyingTopicCleanupPolicyShouldReturnFalseWhenBrokerVersionIsUnsupported
+- verifyingTopicCleanupPolicyShouldReturnFalseWhenClusterAuthorizationError
+- verifyingTopicCleanupPolicyShouldReturnFalseWhenTopicAuthorizationError
+- verifyingTopicCleanupPolicyShouldReturnTrueWhenTopicHasCorrectPolicy
+org.apache.kafka.connect.util.TopicCreationTest:
+- testEmptyTopicCreation
+- testTopicCreationWhenTopicCreationIsDisabled
+- testTopicCreationWhenTopicCreationIsEnabled
+- testTopicCreationWithSingleTransformation
+- topicCreationWithDefaultGroupAndCustomProps
+- topicCreationWithOneGroup
+- topicCreationWithOneGroupAndCombinedRegex
+- topicCreationWithTwoGroups
+- topicCreationWithTwoGroupsAndTwoTransformations
+- withDefaultTopicCreation
diff --git a/test-catalog/connect/transforms/tests.yaml
b/test-catalog/connect/transforms/tests.yaml
new file mode 100644
index 00000000000..350e85a5ef7
--- /dev/null
+++ b/test-catalog/connect/transforms/tests.yaml
@@ -0,0 +1,244 @@
+org.apache.kafka.connect.transforms.CastTest:
+- castFieldWithDefaultValueRecordWithSchema
+- castFieldsSchemaless
+- castFieldsWithSchema
+- castLogicalToPrimitive
+- castLogicalToString
+- castNullKeyRecordSchemaless
+- castNullKeyRecordWithSchema
+- castNullValueRecordSchemaless
+- castNullValueRecordWithSchema
+- castWholeBigDecimalRecordValueWithSchemaString
+- castWholeDateRecordValueWithSchemaString
+- castWholeRecordDefaultValue
+- castWholeRecordKeySchemaless
+- castWholeRecordKeyWithSchema
+- castWholeRecordValueSchemalessBooleanFalse
+- castWholeRecordValueSchemalessBooleanTrue
+- castWholeRecordValueSchemalessFloat32
+- castWholeRecordValueSchemalessFloat64
+- castWholeRecordValueSchemalessInt16
+- castWholeRecordValueSchemalessInt32
+- castWholeRecordValueSchemalessInt64
+- castWholeRecordValueSchemalessInt8
+- castWholeRecordValueSchemalessString
+- castWholeRecordValueSchemalessUnsupportedType
+- castWholeRecordValueWithSchemaBooleanFalse
+- castWholeRecordValueWithSchemaBooleanTrue
+- castWholeRecordValueWithSchemaFloat32
+- castWholeRecordValueWithSchemaFloat64
+- castWholeRecordValueWithSchemaInt16
+- castWholeRecordValueWithSchemaInt32
+- castWholeRecordValueWithSchemaInt64
+- castWholeRecordValueWithSchemaInt8
+- castWholeRecordValueWithSchemaString
+- testCastVersionRetrievedFromAppInfoParser
+- testConfigEmpty
+- testConfigInvalidMap
+- testConfigInvalidSchemaType
+- testConfigInvalidTargetType
+- testConfigMixWholeAndFieldTransformation
+- testUnsupportedTargetType
+org.apache.kafka.connect.transforms.DropHeadersTest:
+- configRejectsEmptyList
+- dropExistingHeader
+- dropExistingHeaderWithMultipleValues
+- dropNonExistingHeader
+- testDropHeadersVersionRetrievedFromAppInfoParser
+org.apache.kafka.connect.transforms.ExtractFieldTest:
+- nonExistentFieldSchemalessShouldReturnNull
+- nonExistentFieldWithSchemaShouldFail
+- nonExistentNestedFieldSchemalessShouldReturnNull
+- nonExistentNestedFieldWithSchemaShouldFail
+- nullSchemaless
+- schemaless
+- schemalessAndNestedPath
+- testExtractFieldVersionRetrievedFromAppInfoParser
+- testNullWithSchema
+- testUnsetOptionalField
+- testUnsetOptionalKey
+- withSchema
+- withSchemaAndNestedPath
+org.apache.kafka.connect.transforms.FlattenTest:
+- testArrayWithSchema
+- testFlattenVersionRetrievedFromAppInfoParser
+- testKey
+- testMapWithNullFields
+- testNestedMapWithDelimiter
+- testNestedStruct
+- testOptionalAndDefaultValuesNested
+- testOptionalFieldMap
+- testOptionalFieldStruct
+- testOptionalNestedStruct
+- testOptionalStruct
+- testSchemalessArray
+- testStructWithNullFields
+- tombstoneEventWithSchemaShouldPassThrough
+- tombstoneEventWithoutSchemaShouldPassThrough
+- topLevelMapRequired
+- topLevelStructRequired
+org.apache.kafka.connect.transforms.HeaderFromTest:
+- invalidConfigEmptyHeadersAndFieldsConfig
+- invalidConfigExtraFieldConfig
+- invalidConfigExtraHeaderConfig
+- schemaless
+- withSchema
+org.apache.kafka.connect.transforms.HoistFieldTest:
+- schemaless
+- testHoistFieldVersionRetrievedFromAppInfoParser
+- testSchemalessMapIsMutable
+- withSchema
+org.apache.kafka.connect.transforms.InsertFieldTest:
+- copySchemaAndInsertConfiguredFields
+- insertConfiguredFieldsIntoTombstoneEventWithSchemaLeavesValueUnchanged
+- insertConfiguredFieldsIntoTombstoneEventWithoutSchemaLeavesValueUnchanged
+- insertIntoNullKeyLeavesRecordUnchanged
+- insertKeyFieldsIntoTombstoneEvent
+- schemalessInsertConfiguredFields
+- testInsertFieldVersionRetrievedFromAppInfoParser
+- testUnsetOptionalField
+- topLevelStructRequired
+org.apache.kafka.connect.transforms.InsertHeaderTest:
+- configRejectsNullHeaderKey
+- configRejectsNullHeaderValue
+- insertionWithByteHeader
+- insertionWithExistingOtherHeader
+- insertionWithExistingSameHeader
+- testInsertHeaderVersionRetrievedFromAppInfoParser
+org.apache.kafka.connect.transforms.MaskFieldTest:
+- testEmptyStringReplacementValue
+- testMaskFieldReturnsVersionFromAppInfoParser
+- testNullListAndMapReplacementsAreMutable
+- testReplacementTypeMismatch
+- testSchemaless
+- testSchemalessUnsupportedReplacementType
+- testSchemalessWithReplacement
+- testWithSchema
+- testWithSchemaAndReplacement
+- testWithSchemaUnsupportedReplacementType
+org.apache.kafka.connect.transforms.RegexRouterTest:
+- addPrefix
+- addSuffix
+- doesntMatch
+- identity
+- slice
+- staticReplacement
+- testRegexRouterRetrievesVersionFromAppInfoParser
+org.apache.kafka.connect.transforms.ReplaceFieldTest:
+- schemaless
+- testReplaceFieldVersionRetrievedFromAppInfoParser
+- testReplaceNullWithDefaultConfigOnKey
+- testReplaceNullWithDefaultConfigOnValue
+- tombstoneSchemaless
+- tombstoneWithSchema
+- withSchema
+org.apache.kafka.connect.transforms.SetSchemaMetadataTest:
+- ignoreRecordWithNullValue
+- schemaNameAndVersionUpdate
+- schemaNameAndVersionUpdateWithStruct
+- schemaNameAndVersionUpdateWithStructAndNullField
+- schemaNameUpdate
+- schemaVersionUpdate
+- testSchemaMetadataVersionRetrievedFromAppInfoParser
+- updateSchemaOfNonStruct
+- updateSchemaOfNull
+- updateSchemaOfStruct
+- valueSchemaRequired
+org.apache.kafka.connect.transforms.TimestampConverterTest:
+- testConfigInvalidFormat
+- testConfigInvalidTargetType
+- testConfigInvalidUnixPrecision
+- testConfigMissingFormat
+- testConfigNoTargetType
+- testConfigValidUnixPrecision
+- testKey
+- testSchemalessDateToTimestamp
+- testSchemalessFieldConversion
+- testSchemalessIdentity
+- testSchemalessNullValueToDate
+- testSchemalessNullValueToString
+- testSchemalessNullValueToTime
+- testSchemalessNullValueToTimestamp
+- testSchemalessNullValueToUnix
+- testSchemalessStringToTimestamp
+- testSchemalessStringToUnix_Micros
+- testSchemalessStringToUnix_Nanos
+- testSchemalessStringToUnix_Seconds
+- testSchemalessTimeToTimestamp
+- testSchemalessTimestampToDate
+- testSchemalessTimestampToString
+- testSchemalessTimestampToTime
+- testSchemalessTimestampToUnix
+- testSchemalessUnixToTimestamp
+- testTimestampConverterVersionRetrievedFromAppInfoParser
+- testWithSchemaDateToTimestamp
+- testWithSchemaFieldConversion
+- testWithSchemaFieldConversion_Micros
+- testWithSchemaFieldConversion_Nanos
+- testWithSchemaFieldConversion_Seconds
+- testWithSchemaIdentity
+- testWithSchemaNullFieldToDate
+- testWithSchemaNullFieldToString
+- testWithSchemaNullFieldToTime
+- testWithSchemaNullFieldToTimestamp
+- testWithSchemaNullFieldToUnix
+- testWithSchemaNullFieldWithDefaultConversion
+- testWithSchemaNullValueToDate
+- testWithSchemaNullValueToString
+- testWithSchemaNullValueToTime
+- testWithSchemaNullValueToTimestamp
+- testWithSchemaNullValueToUnix
+- testWithSchemaStringToTimestamp
+- testWithSchemaTimeToTimestamp
+- testWithSchemaTimestampToDate
+- testWithSchemaTimestampToString
+- testWithSchemaTimestampToTime
+- testWithSchemaTimestampToUnix
+- testWithSchemaUnixToTimestamp
+org.apache.kafka.connect.transforms.TimestampRouterTest:
+- defaultConfiguration
+- testTimestampRouterVersionRetrievedFromAppInfoParser
+org.apache.kafka.connect.transforms.ValueToKeyTest:
+- nonExistingField
+- schemaless
+- testReplaceNullWithDefaultConfig
+- testValueToKeyVersionRetrievedFromAppInfoParser
+- withSchema
+org.apache.kafka.connect.transforms.field.FieldPathNotationTest:
+- shouldBuildV1WithDotsAndBacktickPair
+- shouldBuildV2AndEscapeBackticks
+- shouldBuildV2AndIgnoreBackticksThatAreNotWrapping
+- shouldBuildV2WhenIncludesDots
+- shouldBuildV2WhenIncludesDotsAndBacktickPair
+- shouldBuildV2WithEmptyPath
+- shouldBuildV2WithoutDots
+- shouldBuildV2WithoutWrappingBackticks
+- shouldFailV2WhenIncompleteBackticks
+- shouldIncludeEmptyFieldNames
+org.apache.kafka.connect.transforms.field.FieldSyntaxVersionTest:
+- shouldAppendConfigToDef
+- shouldFailWhenAppendConfigToDefAgain
+- shouldFailWhenWrongVersionIsPassed
+- shouldGetVersionFromConfig
+org.apache.kafka.connect.transforms.field.SingleFieldPathTest:
+- shouldFindField
+- shouldFindValueInMap
+- shouldFindValueInStruct
+- shouldReturnNullFieldWhenFieldNotFound
+- shouldReturnNullValueWhenFieldNotFoundInMap
+- shouldReturnNullValueWhenFieldNotFoundInStruct
+org.apache.kafka.connect.transforms.predicates.HasHeaderKeyTest:
+- testConfig
+- testNameMayNotBeEmptyInConfig
+- testNameRequiredInConfig
+- testTest
+org.apache.kafka.connect.transforms.predicates.TopicNameMatchesTest:
+- testConfig
+- testPatternIsValidRegexInConfig
+- testPatternMayNotBeEmptyInConfig
+- testPatternRequiredInConfig
+- testTest
+org.apache.kafka.connect.transforms.util.NonEmptyListValidatorTest:
+- testEmptyList
+- testNullList
+- testValidList
diff --git a/test-catalog/core/tests.yaml b/test-catalog/core/tests.yaml
index f43742bc5b6..d065a161878 100644
--- a/test-catalog/core/tests.yaml
+++ b/test-catalog/core/tests.yaml
@@ -427,6 +427,7 @@ kafka.api.PlaintextAdminIntegrationTest:
- testClose
- testConsumeAfterDeleteRecords
- testConsumerGroups
+- testConsumerGroupsDeprecatedConsumerGroupState
- testCreateDeleteTopics
- testCreateExistingTopicsThrowTopicExistsException
- testCreatePartitionWithOptionRetryOnQuotaViolation
@@ -559,10 +560,12 @@ kafka.api.PlaintextConsumerSubscriptionTest:
- testUnsubscribeTopic
kafka.api.PlaintextConsumerTest:
- testAutoOffsetReset
+- testCloseLeavesGroupOnInterrupt
- testClusterResourceListener
- testConsumeMessagesWithCreateTime
- testConsumeMessagesWithLogAppendTime
- testConsumingWithNullGroupId
+- testCoordinatorFailover
- testEndOffsets
- testFetchOffsetsForTime
- testGroupConsumption
@@ -670,6 +673,7 @@ kafka.api.SaslGssapiSslEndToEndAuthorizationTest:
- testTwoConsumersWithDifferentSaslCredentials
kafka.api.SaslMultiMechanismConsumerTest:
- testClusterResourceListener
+- testCoordinatorFailover
- testMultipleBrokerMechanisms
- testSimpleConsumption
kafka.api.SaslOAuthBearerSslEndToEndAuthorizationTest:
@@ -688,9 +692,11 @@ kafka.api.SaslOAuthBearerSslEndToEndAuthorizationTest:
- testTwoConsumersWithDifferentSaslCredentials
kafka.api.SaslPlainPlaintextConsumerTest:
- testClusterResourceListener
+- testCoordinatorFailover
- testSimpleConsumption
kafka.api.SaslPlaintextConsumerTest:
- testClusterResourceListener
+- testCoordinatorFailover
- testSimpleConsumption
kafka.api.SaslScramSslEndToEndAuthorizationTest:
- testAuthentications
@@ -728,6 +734,7 @@ kafka.api.SaslSslAdminIntegrationTest:
- testLegacyAclOpsNeverAffectOrReturnPrefixed
kafka.api.SaslSslConsumerTest:
- testClusterResourceListener
+- testCoordinatorFailover
- testSimpleConsumption
kafka.api.SslAdminIntegrationTest:
- testAclAuthorizationDenied
@@ -754,6 +761,7 @@ kafka.api.SslAdminIntegrationTest:
- testSynchronousAuthorizerAclUpdatesBlockRequestThreads
kafka.api.SslConsumerTest:
- testClusterResourceListener
+- testCoordinatorFailover
- testSimpleConsumption
kafka.api.SslEndToEndAuthorizationTest:
- testNoConsumeWithDescribeAclViaAssign
@@ -787,6 +795,7 @@ kafka.api.TransactionsExpirationTest:
kafka.api.TransactionsTest:
- testAbortTransactionTimeout
- testBasicTransactions
+- testBumpTransactionalEpochWithTV2Disabled
- testBumpTransactionalEpochWithTV2Enabled
- testCommitTransactionTimeout
- testConsecutivelyRunInitTransactions
@@ -800,6 +809,7 @@ kafka.api.TransactionsTest:
- testInitTransactionsTimeout
- testMultipleMarkersOneLeader
- testOffsetMetadataInSendOffsetsToTransaction
+- testReadCommittedConsumerShouldNotSeeUndecidedData
- testSendOffsetsToTransactionTimeout
- testSendOffsetsWithGroupMetadata
kafka.api.TransactionsWithMaxInFlightOneTest:
@@ -1937,6 +1947,7 @@ kafka.log.remote.RemoteLogManagerTest:
- testFailedCopyShouldDeleteTheDanglingSegment
- testFailedDeleteExpiredSegments
- testFetchNextSegmentWithTxnIndex
+- testFetchOffsetByTimestampWithTieredStorageDoesNotFetchIndexWhenExistsLocally
- testFetchQuotaManagerConfig
- testFetchRemoteLogSegmentMetadata
- testFindHighestRemoteOffset
@@ -2029,6 +2040,7 @@ kafka.network.ConnectionQuotasTest:
- testNonDefaultConnectionCountLimitAndRateLimit
- testRejectedIpConnectionUnrecordedFromConnectionRateQuotas
kafka.network.DynamicConnectionQuotaTest:
+- testDynamicConnectionQuota
- testDynamicIpConnectionRateQuota
- testDynamicListenerConnectionCreationRateQuota
- testDynamicListenerConnectionQuota
@@ -3388,6 +3400,7 @@ kafka.server.OffsetsForLeaderEpochRequestTest:
kafka.server.PermissiveControllerMutationQuotaTest:
- testControllerMutationQuotaViolation
kafka.server.ProduceRequestTest:
+- quorum
- testCorruptLz4ProduceRequest
- testProduceToNonReplica
- testSimpleProduceRequest
@@ -3917,16 +3930,23 @@ kafka.server.share.SharePartitionTest:
- testWriteShareGroupStateWithWriteException
kafka.test.api.ShareConsumerTest:
- testAcknowledgeCommitCallbackCallsShareConsumerDisallowed
+- testAcknowledgeCommitCallbackCallsShareConsumerWakeup
+- testAcknowledgeCommitCallbackThrowsException
+- testAcknowledgementCommitCallbackInvalidRecordStateException
- testAcknowledgementCommitCallbackOnClose
- testAcknowledgementCommitCallbackSuccessfulAcknowledgement
+- testAcknowledgementSentOnSubscriptionChange
- testAcquisitionLockTimeoutOnConsumer
- testConsumerCloseInGroupSequential
- testControlRecordsSkipped
- testExplicitAcknowledgeCommitSuccess
- testExplicitAcknowledgeReleaseAccept
+- testExplicitAcknowledgeReleaseClose
- testExplicitAcknowledgeReleasePollAccept
- testExplicitAcknowledgeSuccess
- testExplicitAcknowledgeThrowsNotInBatch
+- testExplicitAcknowledgementCommitAsync
+- testExplicitAcknowledgementCommitAsyncPartialBatch
- testFetchRecordLargerThanMaxPartitionFetchBytes
- testHeaders
- testHeadersSerializerDeserializer
@@ -3935,12 +3955,14 @@ kafka.test.api.ShareConsumerTest:
- testImplicitAcknowledgementCommitAsync
- testLsoMovementByRecordsDeletion
- testMaxPollRecords
+- testMultipleConsumersInGroupConcurrentConsumption
- testMultipleConsumersInGroupFailureConcurrentConsumption
- testMultipleConsumersInGroupSequentialConsumption
- testMultipleConsumersInMultipleGroupsConcurrentConsumption
- testMultipleConsumersWithDifferentGroupIds
- testPollNoSubscribeFails
- testPollThrowsInterruptExceptionIfInterrupted
+- testShareAutoOffsetResetDefaultValue
- testShareAutoOffsetResetEarliest
- testShareAutoOffsetResetEarliestAfterLsoMovement
- testShareAutoOffsetResetMultipleGroupsWithDifferentValue
diff --git a/test-catalog/raft/tests.yaml b/test-catalog/raft/tests.yaml
index 21c96566485..170a2e9a8e3 100644
--- a/test-catalog/raft/tests.yaml
+++ b/test-catalog/raft/tests.yaml
@@ -436,6 +436,14 @@ org.apache.kafka.raft.QuorumStateTest:
- testUnattachedVotedToUnattachedHigherEpoch
- testUnattachedVotedToUnattachedSameEpoch
- testUnattachedVotedToUnattachedVotedSameEpoch
+org.apache.kafka.raft.RaftEventSimulationTest:
+- canElectInitialLeader
+- canElectNewLeaderAfterOldLeaderFailure
+- canElectNewLeaderAfterOldLeaderPartitionedAway
+- canMakeProgressAfterBackToBackLeaderFailures
+- canMakeProgressIfMajorityIsReachable
+- canRecoverAfterAllNodesKilled
+- canRecoverFromSingleNodeCommittedDataLoss
org.apache.kafka.raft.RaftUtilTest:
- testErrorResponse
- testSingletonBeginQuorumEpochRequestForAllVersion
@@ -556,7 +564,10 @@ org.apache.kafka.raft.internals.RecordsIteratorTest:
- testControlRecordIterationWithKraftVersion0
- testControlRecordIterationWithKraftVersion1
- testControlRecordTypeValues
+- testCrcValidation
- testEmptyRecords
+- testFileRecords
+- testMemoryRecords
- testWithAllSupportedControlRecords
org.apache.kafka.raft.internals.ThresholdPurgatoryTest:
- testCompleteAll
diff --git a/test-catalog/storage/storage-api/tests.yaml
b/test-catalog/storage/storage-api/tests.yaml
new file mode 100644
index 00000000000..a54cc5d3777
--- /dev/null
+++ b/test-catalog/storage/storage-api/tests.yaml
@@ -0,0 +1,4 @@
+org.apache.kafka.server.log.remote.storage.LogSegmentDataTest:
+- testOptionalTransactionIndex
+org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadataTest:
+- createWithUpdates
diff --git a/test-catalog/streams/examples/tests.yaml
b/test-catalog/streams/examples/tests.yaml
new file mode 100644
index 00000000000..c96a4f3e0b8
--- /dev/null
+++ b/test-catalog/streams/examples/tests.yaml
@@ -0,0 +1,15 @@
+org.apache.kafka.streams.examples.docs.DeveloperGuideTesting:
+- shouldFlushStoreForFirstInput
+- shouldNotUpdateStoreForLargerValue
+- shouldNotUpdateStoreForSmallerValue
+- shouldPunctuateIfEvenTimeAdvances
+- shouldPunctuateIfWallClockTimeAdvances
+- shouldUpdateStoreForNewKey
+org.apache.kafka.streams.examples.wordcount.WordCountDemoTest:
+- testCountListOfWords
+- testOneWord
+- testStreamsConfig
+org.apache.kafka.streams.examples.wordcount.WordCountProcessorTest:
+- test
+org.apache.kafka.streams.examples.wordcount.WordCountTransformerTest:
+- test
diff --git a/test-catalog/streams/integration-tests/tests.yaml
b/test-catalog/streams/integration-tests/tests.yaml
new file mode 100644
index 00000000000..cba7e48ca06
--- /dev/null
+++ b/test-catalog/streams/integration-tests/tests.yaml
@@ -0,0 +1,360 @@
+org.apache.kafka.streams.integration.AdjustStreamThreadCountTest:
+- shouldAddAndRemoveStreamThreadsWhileKeepingNamesCorrect
+- shouldAddAndRemoveThreadsMultipleTimes
+- shouldAddStreamThread
+- shouldRemoveStreamThread
+- shouldRemoveStreamThreadWithStaticMembership
+- shouldResizeCacheAfterThreadRemovalTimesOut
+- shouldResizeCacheAfterThreadReplacement
+- shouldnNotRemoveStreamThreadWithinTimeout
+- testConcurrentlyAccessThreads
+- testRebalanceHappensBeforeStreamThreadGetDown
+org.apache.kafka.streams.integration.ConsistencyVectorIntegrationTest:
+- shouldHaveSamePositionBoundActiveAndStandBy
+org.apache.kafka.streams.integration.EOSUncleanShutdownIntegrationTest:
+- shouldWorkWithUncleanShutdownWipeOutStateStore
+org.apache.kafka.streams.integration.EmitOnChangeIntegrationTest:
+- shouldEmitSameRecordAfterFailover
+org.apache.kafka.streams.integration.EosIntegrationTest:
+- shouldBeAbleToCommitMultiplePartitionOffsets
+- shouldBeAbleToCommitToMultiplePartitions
+- shouldBeAbleToPerformMultipleTransactions
+- shouldBeAbleToRestartAfterClose
+- shouldBeAbleToRunWithEosEnabled
+- shouldBeAbleToRunWithTwoSubtopologies
+- shouldBeAbleToRunWithTwoSubtopologiesAndMultiplePartitions
+-
shouldCheckpointRestoredOffsetsWhenClosingCleanDuringRestoringStateUpdaterDisabled
+-
shouldCheckpointRestoredOffsetsWhenClosingCleanDuringRestoringStateUpdaterEnabled
+- shouldCommitCorrectOffsetIfInputTopicIsTransactional
+- shouldNotViolateEosIfOneTaskFails
+- shouldNotViolateEosIfOneTaskFailsWithState
+- shouldNotViolateEosIfOneTaskGetsFencedUsingIsolatedAppInstances
+- shouldWriteLatestOffsetsToCheckpointOnShutdown
+org.apache.kafka.streams.integration.FineGrainedAutoResetIntegrationTest:
+- shouldOnlyReadRecordsWhereEarliestSpecifiedWithInvalidCommittedOffsets
+-
shouldOnlyReadRecordsWhereEarliestSpecifiedWithNoCommittedOffsetsWithDefaultGlobalAutoOffsetResetEarliest
+-
shouldOnlyReadRecordsWhereEarliestSpecifiedWithNoCommittedOffsetsWithGlobalAutoOffsetResetLatest
+- shouldThrowExceptionOverlappingPattern
+- shouldThrowExceptionOverlappingTopic
+- shouldThrowStreamsExceptionNoResetSpecified
+org.apache.kafka.streams.integration.GlobalKTableEOSIntegrationTest:
+- shouldKStreamGlobalKTableJoin
+- shouldKStreamGlobalKTableLeftJoin
+- shouldNotRestoreAbortedMessages
+- shouldRestoreTransactionalMessages
+- shouldSkipOverAbortedMessagesOnRestore
+- shouldSkipOverTxMarkersOnRestore
+org.apache.kafka.streams.integration.GlobalKTableIntegrationTest:
+- shouldGetToRunningWithOnlyGlobalTopology
+- shouldKStreamGlobalKTableJoin
+- shouldKStreamGlobalKTableLeftJoin
+- shouldRestoreGlobalInMemoryKTableOnRestart
+org.apache.kafka.streams.integration.GlobalStateReprocessTest:
+- shouldReprocessWithUserProvidedStore
+org.apache.kafka.streams.integration.GlobalThreadShutDownOrderTest:
+- shouldFinishGlobalStoreOperationOnShutDown
+org.apache.kafka.streams.integration.HandlingSourceTopicDeletionIntegrationTest:
+- shouldThrowErrorAfterSourceTopicDeleted
+org.apache.kafka.streams.integration.HighAvailabilityTaskAssignorIntegrationTest:
+- shouldScaleOutWithWarmupTasksAndInMemoryStores
+- shouldScaleOutWithWarmupTasksAndPersistentStores
+org.apache.kafka.streams.integration.IQv2IntegrationTest:
+- shouldFailNotStarted
+- shouldFailStopped
+- shouldFailUnknownStore
+- shouldFetchExplicitlyFromAllPartitions
+- shouldFetchFromPartition
+- shouldNotRequireQueryHandler
+- shouldRejectNonRunningActive
+org.apache.kafka.streams.integration.IQv2StoreIntegrationTest:
+- verifyStore
+org.apache.kafka.streams.integration.IQv2VersionedStoreIntegrationTest:
+- verifyStore
+org.apache.kafka.streams.integration.InternalTopicIntegrationTest:
+- shouldCompactAndDeleteTopicsForWindowStoreChangelogs
+- shouldCompactTopicsForKeyValueStoreChangelogs
+- shouldGetToRunningWithWindowedTableInFKJ
+org.apache.kafka.streams.integration.JoinGracePeriodDurabilityIntegrationTest:
+- shouldRecoverBufferAfterShutdown
+org.apache.kafka.streams.integration.JoinStoreIntegrationTest:
+- providingAJoinStoreNameShouldNotMakeTheJoinResultQueryable
+- streamJoinChangelogTopicShouldBeConfiguredWithDeleteOnlyCleanupPolicy
+org.apache.kafka.streams.integration.JoinWithIncompleteMetadataIntegrationTest:
+- testShouldAutoShutdownOnJoinWithIncompleteMetadata
+org.apache.kafka.streams.integration.KStreamAggregationDedupIntegrationTest:
+- shouldGroupByKey
+- shouldReduce
+- shouldReduceWindowed
+org.apache.kafka.streams.integration.KStreamAggregationIntegrationTest:
+- shouldAggregate
+- shouldAggregateSlidingWindows
+- shouldAggregateWindowed
+- shouldCount
+- shouldCountSessionWindows
+- shouldCountUnlimitedWindows
+- shouldCountWithInternalStore
+- shouldGroupByKey
+- shouldReduce
+- shouldReduceSessionWindows
+- shouldReduceSlidingWindows
+- shouldReduceWindowed
+org.apache.kafka.streams.integration.KStreamKStreamIntegrationTest:
+- shouldOuterJoin
+org.apache.kafka.streams.integration.KStreamRepartitionIntegrationTest:
+- shouldCreateOnlyOneRepartitionTopicWhenRepartitionIsFollowedByGroupByKey
+- shouldCreateRepartitionTopicIfKeyChangingOperationWasNotPerformed
+- shouldCreateRepartitionTopicWithSpecifiedNumberOfPartitions
+- shouldDeductNumberOfPartitionsFromRepartitionOperation
+-
shouldDoProperJoiningWhenNumberOfPartitionsAreValidWhenUsingRepartitionOperation
+- shouldGenerateRepartitionTopicWhenNameIsNotSpecified
+- shouldGoThroughRebalancingCorrectly
+-
shouldInheritRepartitionTopicPartitionNumberFromUpstreamTopicWhenNumberOfPartitionsIsNotSpecified
+- shouldPerformKeySelectOperationWhenRepartitionOperationIsUsedWithKeySelector
+- shouldPerformSelectKeyWithRepartitionOperation
+- shouldRepartitionToMultiplePartitions
+-
shouldThrowAnExceptionWhenNumberOfPartitionsOfRepartitionOperationDoNotMatchSourceTopicWhenJoining
+- shouldUseStreamPartitionerForRepartitionOperation
+org.apache.kafka.streams.integration.KTableEfficientRangeQueryTest:
+- testStoreConfig
+org.apache.kafka.streams.integration.KTableKTableForeignKeyInnerJoinCustomPartitionerIntegrationTest:
+- shouldInnerJoinMultiPartitionQueryable
+-
shouldThrowIllegalArgumentExceptionWhenCustomPartitionerReturnsMultiplePartitions
+org.apache.kafka.streams.integration.KTableKTableForeignKeyInnerJoinMultiIntegrationTest:
+- shouldInnerJoinMultiPartitionQueryable
+org.apache.kafka.streams.integration.KTableKTableForeignKeyJoinDistributedTest:
+- shouldBeInitializedWithDefaultSerde
+org.apache.kafka.streams.integration.KTableKTableForeignKeyJoinIntegrationTest:
+- doJoinFromLeftThenDeleteLeftEntity
+- doJoinFromRightThenDeleteRightEntity
+- joinShouldProduceNullsWhenValueHasNonMatchingForeignKey
+- shouldEmitRecordOnNullForeignKeyForLeftJoins
+- shouldEmitRecordWhenOldAndNewFkDiffer
+- shouldEmitTombstoneWhenDeletingNonJoiningRecords
+- shouldIgnoreOutOfOrderRecordsIffVersioned
+- shouldNotEmitTombstonesWhenDeletingNonExistingRecords
+- shouldUnsubscribeOldForeignKeyIfLeftSideIsUpdated
+org.apache.kafka.streams.integration.KTableKTableForeignKeyJoinMaterializationIntegrationTest:
+- shouldEmitTombstoneWhenDeletingNonJoiningRecords
+org.apache.kafka.streams.integration.KTableSourceTopicRestartIntegrationTest:
+- shouldRestoreAndProgressWhenTopicNotWrittenToDuringRestoration
+- shouldRestoreAndProgressWhenTopicWrittenToDuringRestorationWithEosDisabled
+- shouldRestoreAndProgressWhenTopicWrittenToDuringRestorationWithEosV2Enabled
+org.apache.kafka.streams.integration.KafkaStreamsCloseOptionsIntegrationTest:
+- testCloseOptions
+org.apache.kafka.streams.integration.KafkaStreamsTelemetryIntegrationTest:
+- passedMetricsShouldNotLeakIntoClientMetrics
+- shouldPassCorrectMetricsDynamicInstances
+- shouldPassMetrics
+- shouldPushMetricsToBroker
+org.apache.kafka.streams.integration.LagFetchIntegrationTest:
+- shouldFetchLagsDuringRebalancingWithNoOptimization
+- shouldFetchLagsDuringRebalancingWithOptimization
+- shouldFetchLagsDuringRestoration
+org.apache.kafka.streams.integration.MetricsIntegrationTest:
+- shouldAddMetricsForSessionStore
+- shouldAddMetricsForWindowStoreAndSuppressionBuffer
+- shouldAddMetricsOnAllLevels
+org.apache.kafka.streams.integration.MetricsReporterIntegrationTest:
+- shouldBeAbleToProvideInitialMetricValueToMetricsReporter
+org.apache.kafka.streams.integration.NamedTopologyIntegrationTest:
+- shouldAddNamedTopologyToRunningApplicationWithEmptyInitialTopology
+- shouldAddNamedTopologyToRunningApplicationWithMultipleNodes
+- shouldAddToEmptyInitialTopologyRemoveResetOffsetsThenAddSameNamedTopology
+-
shouldAddToEmptyInitialTopologyRemoveResetOffsetsThenAddSameNamedTopologyWithRepartitioning
+- shouldAllowMixedCollectionAndPatternSubscriptionWithMultipleNamedTopologies
+- shouldAllowPatternSubscriptionWithMultipleNamedTopologies
+-
shouldAllowRemovingAndAddingNamedTopologyToRunningApplicationWithMultipleNodesAndResetsOffsets
+- shouldPrefixAllInternalTopicNamesWithNamedTopology
+-
shouldProcessMultipleIdenticalNamedTopologiesWithInMemoryAndPersistentStateStores
+- shouldProcessSingleNamedTopologyAndPrefixInternalTopics
+- shouldRemoveAndReplaceTopologicallyIncompatibleNamedTopology
+org.apache.kafka.streams.integration.OptimizedKTableIntegrationTest:
+- shouldApplyUpdatesToStandbyStore
+org.apache.kafka.streams.integration.PauseResumeIntegrationTest:
+- pauseResumeShouldWorkAcrossInstances
+- pausedTopologyShouldNotRestoreStateStores
+- shouldAllowForNamedTopologiesToStartPaused
+- shouldAllowForTopologiesToStartPaused
+- shouldPauseAndResumeAllKafkaStreamsWithNamedTopologies
+- shouldPauseAndResumeKafkaStreams
+- shouldPauseAndResumeKafkaStreamsWithNamedTopologies
+org.apache.kafka.streams.integration.PositionRestartIntegrationTest:
+- verifyStore
+org.apache.kafka.streams.integration.ProcessingExceptionHandlerIntegrationTest:
+-
shouldContinueWhenProcessingExceptionOccursFromFlushingCacheIfExceptionHandlerReturnsContinue
+- shouldContinueWhenProcessingExceptionOccursIfExceptionHandlerReturnsContinue
+-
shouldFailWhenProcessingExceptionOccursFromFlushingCacheIfExceptionHandlerReturnsFail
+- shouldFailWhenProcessingExceptionOccursIfExceptionHandlerReturnsFail
+-
shouldStopOnFailedProcessorWhenProcessingExceptionOccursInContinueProcessingExceptionHandler
+-
shouldStopOnFailedProcessorWhenProcessingExceptionOccursInFailProcessingExceptionHandler
+- shouldStopProcessingWhenFatalUserExceptionProcessingExceptionHandler
+- shouldStopProcessingWhenProcessingExceptionHandlerReturnsNull
+org.apache.kafka.streams.integration.PurgeRepartitionTopicIntegrationTest:
+- shouldRestoreState
+org.apache.kafka.streams.integration.QueryableStateIntegrationTest:
+- shouldAllowToQueryAfterThreadDied
+- shouldBeAbleQueryStandbyStateDuringRebalance
+- shouldBeAbleToQueryDuringRebalance
+- shouldBeAbleToQueryFilterState
+- shouldBeAbleToQueryKeysWithGivenPrefix
+- shouldBeAbleToQueryMapValuesAfterFilterState
+- shouldBeAbleToQueryMapValuesState
+- shouldBeAbleToQueryStateWithNonZeroSizedCache
+- shouldBeAbleToQueryStateWithZeroSizedCache
+- shouldNotMakeStoreAvailableUntilAllStoresAvailable
+- shouldRejectNonExistentStoreName
+- shouldRejectWronglyTypedStore
+org.apache.kafka.streams.integration.RangeQueryIntegrationTest:
+- testStoreConfig
+org.apache.kafka.streams.integration.RegexSourceIntegrationTest:
+- shouldAddStateStoreToRegexDefinedSource
+- testMultipleConsumersCanReadFromPartitionedTopic
+- testNoMessagesSentExceptionFromOverlappingPatterns
+- testRegexMatchesTopicsAWhenCreated
+- testRegexMatchesTopicsAWhenDeleted
+- testRegexRecordsAreProcessedAfterNewTopicCreatedWithMultipleSubtopologies
+- testShouldReadFromRegexAndNamedTopics
+org.apache.kafka.streams.integration.RelaxedNullKeyRequirementJoinTest:
+- testDropNullKeyRecordsForRepartitionNodesWithNoRelaxedJoinDownstream
+- testRelaxedLeftStreamGlobalTableJoin
+- testRelaxedLeftStreamStreamJoin
+- testRelaxedLeftStreamTableJoin
+- testRelaxedOuterStreamStreamJoin
+org.apache.kafka.streams.integration.ResetPartitionTimeIntegrationTest:
+- shouldPreservePartitionTimeOnKafkaStreamRestart
+org.apache.kafka.streams.integration.RestoreIntegrationTest:
+- shouldInvokeUserDefinedGlobalStateRestoreListener
+- shouldProcessDataFromStoresWithLoggingDisabled
+- shouldRecycleStateFromStandbyTaskPromotedToActiveTaskAndNotRestore
+- shouldRestoreNullRecord
+- shouldRestoreStateFromChangelogTopic
+- shouldRestoreStateFromSourceTopicForGlobalTable
+- shouldRestoreStateFromSourceTopicForReadOnlyStore
+- shouldSuccessfullyStartWhenLoggingDisabled
+org.apache.kafka.streams.integration.RocksDBMetricsIntegrationTest:
+- shouldExposeRocksDBMetricsBeforeAndAfterFailureWithEmptyStateDir
+org.apache.kafka.streams.integration.SelfJoinUpgradeIntegrationTest:
+- shouldRestartWithTopologyOptimizationOn
+- shouldUpgradeWithTopologyOptimizationOff
+org.apache.kafka.streams.integration.SlidingWindowedKStreamIntegrationTest:
+- shouldAggregateWindowedWithGrace
+- shouldAggregateWindowedWithNoGrace
+- shouldRestoreAfterJoinRestart
+org.apache.kafka.streams.integration.SmokeTestDriverIntegrationTest:
+- shouldWorkWithRebalance
+org.apache.kafka.streams.integration.StandbyTaskCreationIntegrationTest:
+- shouldCreateStandByTasksForMaterializedAndOptimizedSourceTables
+- shouldNotCreateAnyStandByTasksForStateStoreWithLoggingDisabled
+org.apache.kafka.streams.integration.StandbyTaskEOSIntegrationTest:
+- shouldSurviveWithOneTaskAsStandby
+- shouldWipeOutStandbyStateDirectoryIfCheckpointIsMissing
+org.apache.kafka.streams.integration.StandbyTaskEOSMultiRebalanceIntegrationTest:
+- shouldHonorEOSWhenUsingCachingAndStandbyReplicas
+org.apache.kafka.streams.integration.StateDirectoryIntegrationTest:
+- testCleanUpStateDirIfEmpty
+- testNotCleanUpStateDirIfNotEmpty
+org.apache.kafka.streams.integration.StoreQueryIntegrationTest:
+-
shouldFailWithIllegalArgumentExceptionWhenIQPartitionerReturnsMultiplePartitions
+- shouldQueryAllStalePartitionStores
+- shouldQueryOnlyActivePartitionStoresByDefault
+- shouldQuerySpecificActivePartitionStores
+- shouldQuerySpecificStalePartitionStores
+- shouldQuerySpecificStalePartitionStoresMultiStreamThreads
+- shouldQuerySpecificStalePartitionStoresMultiStreamThreadsNamedTopology
+- shouldQueryStoresAfterAddingAndRemovingStreamThread
+org.apache.kafka.streams.integration.StoreUpgradeIntegrationTest:
+- shouldMigrateInMemoryKeyValueStoreToTimestampedKeyValueStoreUsingPapi
+- shouldMigrateInMemoryWindowStoreToTimestampedWindowStoreUsingPapi
+- shouldMigratePersistentKeyValueStoreToTimestampedKeyValueStoreUsingPapi
+- shouldMigratePersistentWindowStoreToTimestampedWindowStoreUsingPapi
+- shouldProxyKeyValueStoreToTimestampedKeyValueStoreUsingPapi
+- shouldProxyWindowStoreToTimestampedWindowStoreUsingPapi
+org.apache.kafka.streams.integration.StreamStreamJoinIntegrationTest:
+- testInner
+- testInnerRepartitioned
+- testLeft
+- testLeftRepartitioned
+- testMultiInner
+- testOuter
+- testOuterRepartitioned
+- testSelfJoin
+org.apache.kafka.streams.integration.StreamTableJoinIntegrationTest:
+- testInner
+- testInnerWithVersionedStore
+- testLeft
+- testLeftWithVersionedStore
+org.apache.kafka.streams.integration.StreamTableJoinTopologyOptimizationIntegrationTest:
+- shouldDoStreamTableJoinWithDifferentNumberOfPartitions
+org.apache.kafka.streams.integration.StreamTableJoinWithGraceIntegrationTest:
+- testInnerWithVersionedStore
+- testLeftWithVersionedStore
+org.apache.kafka.streams.integration.StreamToTableJoinScalaIntegrationTestImplicitSerdes:
+- testShouldCountClicksPerRegion
+- testShouldCountClicksPerRegionJava
+- testShouldCountClicksPerRegionWithNamedRepartitionTopic
+org.apache.kafka.streams.integration.StreamsUncaughtExceptionHandlerIntegrationTest:
+- shouldEmitSameRecordAfterFailover
+- shouldReplaceSingleThread
+- shouldReplaceThreads
+- shouldReplaceThreadsWithoutJavaHandler
+- shouldShutDownClientIfGlobalStreamThreadWantsToReplaceThread
+- shouldShutdownClient
+- shouldShutdownMultipleThreadApplication
+- shouldShutdownSingleThreadApplication
+org.apache.kafka.streams.integration.StreamsUpgradeTestIntegrationTest:
+- testVersionProbingUpgrade
+org.apache.kafka.streams.integration.SuppressionDurabilityIntegrationTest:
+- shouldRecoverBufferAfterShutdown
+org.apache.kafka.streams.integration.SuppressionIntegrationTest:
+- shouldAllowDisablingChangelog
+- shouldAllowOverridingChangelogConfig
+- shouldCreateChangelogByDefault
+- shouldInheritSerdes
+- shouldShutdownWhenBytesConstraintIsViolated
+- shouldShutdownWhenRecordConstraintIsViolated
+- shouldUseDefaultSerdes
+org.apache.kafka.streams.integration.SwallowUnknownTopicErrorIntegrationTest:
+- shouldThrowStreamsExceptionWithMissingTopicAndDefaultExceptionHandler
+org.apache.kafka.streams.integration.TableTableJoinIntegrationTest:
+- testInner
+- testInnerInner
+- testInnerLeft
+- testInnerOuter
+- testInnerWithLeftVersionedOnly
+- testInnerWithRightVersionedOnly
+- testInnerWithVersionedStores
+- testLeft
+- testLeftInner
+- testLeftLeft
+- testLeftOuter
+- testLeftWithLeftVersionedOnly
+- testLeftWithRightVersionedOnly
+- testLeftWithVersionedStores
+- testOuter
+- testOuterInner
+- testOuterLeft
+- testOuterOuter
+- testOuterWithLeftVersionedOnly
+- testOuterWithRightVersionedOnly
+- testOuterWithVersionedStores
+org.apache.kafka.streams.integration.TaskAssignorIntegrationTest:
+- shouldProperlyConfigureTheAssignor
+org.apache.kafka.streams.integration.TaskMetadataIntegrationTest:
+- shouldReportCorrectCommittedOffsetInformation
+- shouldReportCorrectEndOffsetInformation
+org.apache.kafka.streams.integration.TimeWindowedKStreamIntegrationTest:
+- shouldAggregateWindowedWithGrace
+- shouldAggregateWindowedWithNoGrace
+- shouldRestoreAfterJoinRestart
+- shouldThrowUnlimitedWindows
+org.apache.kafka.streams.integration.VersionedKeyValueStoreIntegrationTest:
+- shouldAllowCustomIQv2ForCustomStoreImplementations
+- shouldManualUpgradeFromNonVersionedNonTimestampedToVersioned
+- shouldManualUpgradeFromNonVersionedTimestampedToVersioned
+- shouldPutGetAndDelete
+- shouldRestore
+- shouldSetChangelogTopicProperties
+org.apache.kafka.streams.integration.WordCountTest:
+- testShouldCountWords
+- testShouldCountWordsJava
+- testShouldCountWordsMaterialized
diff --git a/test-catalog/streams/streams-scala/tests.yaml
b/test-catalog/streams/streams-scala/tests.yaml
new file mode 100644
index 00000000000..3f4188ad1a5
--- /dev/null
+++ b/test-catalog/streams/streams-scala/tests.yaml
@@ -0,0 +1,73 @@
+org.apache.kafka.streams.scala.TopologyTest:
+- shouldBuildIdenticalTopologyInJavaNScalaAggregate
+- shouldBuildIdenticalTopologyInJavaNScalaCogroup
+- shouldBuildIdenticalTopologyInJavaNScalaCogroupSimple
+- shouldBuildIdenticalTopologyInJavaNScalaJoin
+- shouldBuildIdenticalTopologyInJavaNScalaProcess
+- shouldBuildIdenticalTopologyInJavaNScalaProperties
+- shouldBuildIdenticalTopologyInJavaNScalaSimple
+org.apache.kafka.streams.scala.kstream.ConsumedTest:
+- testCreateConsumed
+- testCreateConsumedWithResetPolicy
+- testCreateConsumedWithTimestampExtractor
+- testCreateConsumedWithTimestampExtractorAndResetPolicy
+org.apache.kafka.streams.scala.kstream.GroupedTest:
+- testCreateGrouped
+- testCreateGroupedWithRepartitionTopicName
+org.apache.kafka.streams.scala.kstream.JoinedTest:
+- testCreateJoined
+- testCreateJoinedWithSerdesAndRepartitionTopicName
+org.apache.kafka.streams.scala.kstream.KStreamSplitTest:
+- testRouteMessagesAccordingToPredicates
+- testRouteMessagesToAnonymousConsumers
+- testRouteMessagesToConsumers
+org.apache.kafka.streams.scala.kstream.KStreamTest:
+- testCorrectlyFlatTransformValuesInRecords
+- testCorrectlyFlatTransformValuesInRecordsWithKey
+- testFilterRecordsNotSatisfyingPredicate
+- testFilterRecordsSatisfyingPredicate
+- testForeachActionsOnRecords
+- testJoinCorrectlyRecords
+- testJoinTwoKStreamToTables
+- testPeekActionsOnRecords
+- testProcessCorrectlyRecords
+- testRepartitionKStream
+- testSelectNewKey
+- testSettingNameOnFilter
+- testSettingNameOnJoin
+- testSettingNameOnOutputTable
+- testSettingNameOnProcess
+org.apache.kafka.streams.scala.kstream.KTableTest:
+- testCorrectlyGroupByKeyWindowedBySlidingWindow
+- testCorrectlySuppressResultsUsingSuppressedUntilTimeLimit
+- testCorrectlySuppressResultsUsingSuppressedUntilTimeLimtByNonWindowed
+- testCorrectlySuppressResultsUsingSuppressedUntilWindowClosesBySession
+- testCorrectlySuppressResultsUsingSuppressedUntilWindowClosesByWindowed
+- testFilterRecordsNotSatisfyingPredicate
+- testFilterRecordsSatisfyingPredicate
+- testJoinCorrectlyRecords
+- testJoinCorrectlyRecordsAndStateStore
+- testMapValuesWithValueMapperWithKeyAndWithMaterialized
+- testMapValuesWithValueMapperWithMaterialized
+- testSettingNameOnCountProcessor
+- testSettingNameOnFilterProcessor
+- testSettingNameOnJoinProcessor
+org.apache.kafka.streams.scala.kstream.MaterializedTest:
+- testCreateMaterializedWithSerdes
+- testCreateMaterializedWithSerdesAndKeyValueStoreSupplier
+- testCreateMaterializedWithSerdesAndSessionStoreSupplier
+- testCreateMaterializedWithSerdesAndStoreName
+- testCreateMaterializedWithSerdesAndWindowStoreSupplier
+org.apache.kafka.streams.scala.kstream.ProducedTest:
+- testCreateProducedWithSerdes
+- testCreateProducedWithSerdesAndStreamPartitioner
+org.apache.kafka.streams.scala.kstream.RepartitionedTest:
+- testCreateRepartitionedWithSerdes
+- testCreateRepartitionedWithSerdesAndNumPartitions
+- testCreateRepartitionedWithSerdesAndTopicName
+-
testCreateRepartitionedWithSerdesAndTopicNameAndNumPartitionsAndStreamPartitioner
+- testCreateRepartitionedWithTopicNameAndNumPartitionsAndStreamPartitioner
+org.apache.kafka.streams.scala.kstream.StreamJoinedTest:
+- testCreateStreamJoinedWithSerdes
+- testCreateStreamJoinedWithSerdesAndStateStoreName
+- testCreateStreamJoinedWithSerdesAndStoreSuppliers
diff --git a/test-catalog/streams/test-utils/tests.yaml
b/test-catalog/streams/test-utils/tests.yaml
new file mode 100644
index 00000000000..6361f616c6a
--- /dev/null
+++ b/test-catalog/streams/test-utils/tests.yaml
@@ -0,0 +1,170 @@
+org.apache.kafka.streams.KeyValueStoreFacadeTest:
+- shouldDeleteAndReturnPlainValue
+- shouldForwardClose
+- shouldForwardFlush
+- shouldForwardInit
+- shouldPutAllWithUnknownTimestamp
+- shouldPutIfAbsentWithUnknownTimestamp
+- shouldPutWithUnknownTimestamp
+- shouldReturnIsOpen
+- shouldReturnIsPersistent
+- shouldReturnName
+org.apache.kafka.streams.MockProcessorContextTest:
+- fullConstructorShouldSetAllExpectedAttributes
+- shouldCaptureApplicationAndRecordMetadata
+- shouldCaptureCommitsAndAllowReset
+- shouldCaptureOutputRecords
+- shouldCaptureOutputRecordsUsingTo
+- shouldCapturePunctuator
+- shouldCaptureRecordsOutputToChildByName
+- shouldStoreAndReturnStateStores
+org.apache.kafka.streams.MockTimeTest:
+- shouldAdvanceTimeOnSleep
+- shouldGetNanosAsMillis
+- shouldNotAllowNegativeSleep
+- shouldSetStartTime
+org.apache.kafka.streams.TestTopicsTest:
+- shouldNotAllowToCreateOutputTopicWithNullTopicName
+- shouldNotAllowToCreateOutputWithNullDriver
+- shouldNotAllowToCreateTopicWithNullTopicName
+- shouldNotAllowToCreateWithNullDriver
+- testDuration
+- testEmptyTopic
+- testInputToString
+- testKeyValue
+- testKeyValueList
+- testKeyValueListDuration
+- testKeyValuesToMap
+- testKeyValuesToMapWithNull
+- testMultipleTopics
+- testNegativeAdvance
+- testNonExistingInputTopic
+- testNonExistingOutputTopic
+- testNonUsedOutputTopic
+- testOutputToString
+- testOutputWrongSerde
+- testRecordList
+- testRecordsToList
+- testStartTimestamp
+- testTimestamp
+- testTimestampAutoAdvance
+- testValue
+- testValueList
+- testWithHeaders
+- testWrongSerde
+org.apache.kafka.streams.TopologyTestDriverAtLeastOnceTest:
+- shouldAllowPrePopulatingStatesStoresWithCachingEnabled
+- shouldApplyGlobalUpdatesCorrectlyInRecursiveTopologies
+- shouldCaptureGlobalTopicNameIfWrittenInto
+- shouldCaptureInternalTopicNamesIfWrittenInto
+- shouldCaptureSinkTopicNamesIfWrittenInto
+- shouldCleanUpPersistentStateStoresOnClose
+- shouldCloseProcessor
+- shouldCreateStateDirectoryForStatefulTopology
+- shouldEnqueueLaterOutputsAfterEarlierOnes
+- shouldFeedStoreFromGlobalKTable
+- shouldFlushStoreForFirstInput
+- shouldForwardRecordsFromSubtopologyToSubtopology
+- shouldInitProcessor
+- shouldNotCreateStateDirectoryForStatelessTopology
+- shouldNotRequireParameters
+- shouldNotUpdateStoreForLargerValue
+- shouldNotUpdateStoreForSmallerValue
+- shouldPassRecordHeadersIntoSerializersAndDeserializers
+- shouldPopulateGlobalStore
+- shouldProcessFromSourceThatMatchPattern
+- shouldProcessFromSourcesThatMatchMultiplePattern
+- shouldProcessRecordForTopic
+- shouldPunctuateIfEvenTimeAdvances
+- shouldPunctuateIfWallClockTimeAdvances
+- shouldPunctuateOnStreamsTime
+- shouldPunctuateOnWallClockTime
+- shouldRespectTaskIdling
+- shouldReturnAllStores
+- shouldReturnAllStoresNames
+- shouldReturnCorrectInMemoryStoreTypeOnly
+- shouldReturnCorrectPersistentStoreTypeOnly
+- shouldSendRecordViaCorrectSourceTopic
+- shouldSetRecordMetadata
+- shouldThrowForMissingTime
+- shouldThrowForUnknownTopic
+- shouldThrowIfInMemoryBuiltInStoreIsAccessedWithUntypedMethod
+- shouldThrowIfPersistentBuiltInStoreIsAccessedWithUntypedMethod
+- shouldThrowNoSuchElementExceptionForUnusedOutputTopicWithDynamicRouting
+- shouldThrowPatternNotValidForTopicNameException
+- shouldUpdateStoreForNewKey
+- shouldUseSinkSpecificSerializers
+- shouldUseSourceSpecificDeserializers
+org.apache.kafka.streams.TopologyTestDriverEosTest:
+- shouldAllowPrePopulatingStatesStoresWithCachingEnabled
+- shouldApplyGlobalUpdatesCorrectlyInRecursiveTopologies
+- shouldCaptureGlobalTopicNameIfWrittenInto
+- shouldCaptureInternalTopicNamesIfWrittenInto
+- shouldCaptureSinkTopicNamesIfWrittenInto
+- shouldCleanUpPersistentStateStoresOnClose
+- shouldCloseProcessor
+- shouldCreateStateDirectoryForStatefulTopology
+- shouldEnqueueLaterOutputsAfterEarlierOnes
+- shouldFeedStoreFromGlobalKTable
+- shouldFlushStoreForFirstInput
+- shouldForwardRecordsFromSubtopologyToSubtopology
+- shouldInitProcessor
+- shouldNotCreateStateDirectoryForStatelessTopology
+- shouldNotRequireParameters
+- shouldNotUpdateStoreForLargerValue
+- shouldNotUpdateStoreForSmallerValue
+- shouldPassRecordHeadersIntoSerializersAndDeserializers
+- shouldPopulateGlobalStore
+- shouldProcessFromSourceThatMatchPattern
+- shouldProcessFromSourcesThatMatchMultiplePattern
+- shouldProcessRecordForTopic
+- shouldPunctuateIfEvenTimeAdvances
+- shouldPunctuateIfWallClockTimeAdvances
+- shouldPunctuateOnStreamsTime
+- shouldPunctuateOnWallClockTime
+- shouldRespectTaskIdling
+- shouldReturnAllStores
+- shouldReturnAllStoresNames
+- shouldReturnCorrectInMemoryStoreTypeOnly
+- shouldReturnCorrectPersistentStoreTypeOnly
+- shouldSendRecordViaCorrectSourceTopic
+- shouldSetRecordMetadata
+- shouldThrowForMissingTime
+- shouldThrowForUnknownTopic
+- shouldThrowIfInMemoryBuiltInStoreIsAccessedWithUntypedMethod
+- shouldThrowIfPersistentBuiltInStoreIsAccessedWithUntypedMethod
+- shouldThrowNoSuchElementExceptionForUnusedOutputTopicWithDynamicRouting
+- shouldThrowPatternNotValidForTopicNameException
+- shouldUpdateStoreForNewKey
+- shouldUseSinkSpecificSerializers
+- shouldUseSourceSpecificDeserializers
+org.apache.kafka.streams.WindowStoreFacadeTest:
+- shouldForwardClose
+- shouldForwardFlush
+- shouldForwardInit
+- shouldPutWindowStartTimestampWithUnknownTimestamp
+- shouldReturnIsOpen
+- shouldReturnIsPersistent
+- shouldReturnName
+org.apache.kafka.streams.test.MockProcessorContextAPITest:
+- fullConstructorShouldSetAllExpectedAttributes
+- shouldCaptureApplicationAndRecordMetadata
+- shouldCaptureCommitsAndAllowReset
+- shouldCaptureOutputRecords
+- shouldCapturePunctuator
+- shouldCaptureRecordsOutputToChildByName
+- shouldStoreAndReturnStateStores
+org.apache.kafka.streams.test.MockProcessorContextStateStoreTest:
+- shouldEitherInitOrThrow
+org.apache.kafka.streams.test.TestRecordTest:
+- testConsumerRecord
+- testEqualsAndHashCode
+- testFields
+- testInvalidRecords
+- testMultiFieldMatcher
+- testPartialConstructorEquals
+- testProducerRecord
+- testToString
+org.apache.kafka.streams.test.wordcount.WindowedWordCountProcessorTest:
+- shouldWorkWithInMemoryStore
+- shouldWorkWithPersistentStore
diff --git a/test-catalog/test-common/test-common-api/tests.yaml
b/test-catalog/test-common/test-common-api/tests.yaml
new file mode 100644
index 00000000000..73088e32b4c
--- /dev/null
+++ b/test-catalog/test-common/test-common-api/tests.yaml
@@ -0,0 +1,26 @@
+org.apache.kafka.common.test.api.ClusterConfigTest:
+- testBrokerLessThanZero
+- testControllersLessThanZero
+- testCopy
+- testDisksPerBrokerIsZero
+- testDisplayTags
+org.apache.kafka.common.test.api.ClusterTestExtensionsTest:
+- testClusterAliveBrokers
+- testClusterTemplate
+- testClusterTest
+- testClusterTestWithDisksPerBroker
+- testClusterTests
+- testCreateDefaultProducerAndConsumer
+- testCreateProducerAndConsumer
+- testCreateTopic
+- testDefaults
+- testNoAutoStart
+- testNotSupportedNewGroupProtocols
+- testShutdownAndSyncMetadata
+- testSupportedNewGroupProtocols
+- testVerifyTopicDeletion
+org.apache.kafka.common.test.api.ClusterTestExtensionsUnitTest:
+- testProcessClusterTemplate
+org.apache.kafka.common.test.api.DetectThreadLeakTest:
+- testDetectThreadLeakWithOverrideExpectedThreadNames
+- testThreadLeak
diff --git a/test-catalog/test-common/test-common-runtime/tests.yaml
b/test-catalog/test-common/test-common-runtime/tests.yaml
new file mode 100644
index 00000000000..140e3c44fc7
--- /dev/null
+++ b/test-catalog/test-common/test-common-runtime/tests.yaml
@@ -0,0 +1,12 @@
+org.apache.kafka.common.test.junit.AutoQuarantinedTestFilterTest:
+- testEmptyCatalog
+- testLoadCatalog
+- testMissingCatalog
+org.apache.kafka.common.test.junit.QuarantinedPostDiscoveryFilterTest:
+- testExistingTestFlaky
+- testExistingTestNonFlaky
+- testNewTest
+- testNoCatalogQuarantinedTest
+- testQuarantinedExistingTestFlaky
+- testQuarantinedExistingTestNonFlaky
+- testQuarantinedNewTest
diff --git a/test-catalog/tools/tools-api/tests.yaml
b/test-catalog/tools/tools-api/tests.yaml
new file mode 100644
index 00000000000..4b4ee6222d5
--- /dev/null
+++ b/test-catalog/tools/tools-api/tests.yaml
@@ -0,0 +1,2 @@
+org.apache.kafka.tools.api.RecordReaderTest:
+- testDefaultCloseAndConfigure
