(kafka) branch test-catalog updated: Update test catalog data for GHA workflow run 12137414582

github-bot Tue, 03 Dec 2024 04:23:14 -0800

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 62c05ac8bcb Update test catalog data for GHA workflow run 12137414582
62c05ac8bcb is described below

commit 62c05ac8bcb82312092cbf4fc2babc9529e0a548
Author: github-actions[bot] 
<41898282+github-actions[bot]@users.noreply.github.com>
AuthorDate: Tue Dec 3 12:22:45 2024 +0000

    Update test catalog data for GHA workflow run 12137414582
    
    Commit: 
https://github.com/apache/kafka/commit/184b64fb41651f95e038f402fa24f58761f4c185
    GitHub Run: https://github.com/apache/kafka/actions/runs/12137414582
---
 test-catalog/connect/mirror/tests.yaml            |  249 ++++
 test-catalog/connect/runtime/tests.yaml           | 1411 +++++++++++++++++++++
 test-catalog/raft/tests.yaml                      |   11 +
 test-catalog/storage/tests.yaml                   |    3 +
 test-catalog/streams/integration-tests/tests.yaml |  360 ++++++
 test-catalog/streams/tests.yaml                   |   12 +-
 6 files changed, 2044 insertions(+), 2 deletions(-)

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/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/tests.yaml b/test-catalog/storage/tests.yaml
index c138b24a84d..2d91d503378 100644
--- a/test-catalog/storage/tests.yaml
+++ b/test-catalog/storage/tests.yaml
@@ -356,6 +356,8 @@ 
org.apache.kafka.tiered.storage.integration.RollAndOffloadActiveSegmentTest:
 org.apache.kafka.tiered.storage.integration.TransactionsWithTieredStoreTest:
 - testAbortTransactionTimeout
 - testBasicTransactions
+- testBumpTransactionalEpochWithTV2Disabled
+- testBumpTransactionalEpochWithTV2Enabled
 - testCommitTransactionTimeout
 - testConsecutivelyRunInitTransactions
 - testDelayedFetchIncludesAbortedTransaction
@@ -368,5 +370,6 @@ 
org.apache.kafka.tiered.storage.integration.TransactionsWithTieredStoreTest:
 - testInitTransactionsTimeout
 - testMultipleMarkersOneLeader
 - testOffsetMetadataInSendOffsetsToTransaction
+- testReadCommittedConsumerShouldNotSeeUndecidedData
 - testSendOffsetsToTransactionTimeout
 - testSendOffsetsWithGroupMetadata
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/tests.yaml b/test-catalog/streams/tests.yaml
index a9825d0a09e..c048929bd83 100644
--- a/test-catalog/streams/tests.yaml
+++ b/test-catalog/streams/tests.yaml
@@ -152,10 +152,18 @@ org.apache.kafka.streams.StreamsBuilderTest:
 - shouldUseSpecifiedStoreSuppliersOuterJoinStoreEvenIfThisSupplierIsSupplied
 - shouldUseThisStoreSupplierEvenIfDslStoreSuppliersConfiguredInTopologyConfig
 - shouldUseTopologyOverrideStoreTypeOverConfiguredDslStoreSupplier
-- shouldWrapProcessorsForAggregationOperators
+- shouldWrapProcessorsForCoGroupedStreamAggregate
+- shouldWrapProcessorsForMaterializedSourceTable
 - shouldWrapProcessorsForProcess
+- shouldWrapProcessorsForSessionWindowStreamAggregate
+- shouldWrapProcessorsForSlidingWindowStreamAggregate
 - shouldWrapProcessorsForStatelessOperators
-- shouldWrapProcessorsForTableSource
+- shouldWrapProcessorsForStreamAggregate
+- shouldWrapProcessorsForStreamReduce
+- shouldWrapProcessorsForTableAggregate
+- shouldWrapProcessorsForTableReduce
+- shouldWrapProcessorsForTimeWindowStreamAggregate
+- shouldWrapProcessorsForUnmaterializedSourceTable
 org.apache.kafka.streams.StreamsConfigTest:
 - consumerConfigMustContainStreamPartitionAssignorConfig
 - defaultSerdeShouldBeConfigured

(kafka) branch test-catalog updated: Update test catalog data for GHA workflow run 12137414582

Reply via email to