From 38ecc57eef695e41a168fdc36652b762c076c4b1 Mon Sep 17 00:00:00 2001 From: Jesse Wilson Date: Sat, 1 Nov 2025 08:18:11 -0400 Subject: [PATCH] Use Burst in DiskLruCacheTest (and 7 others) (#9174) * Use Burst in DiskLruCacheTest (and 7 others) * Update okhttp/src/jvmTest/kotlin/okhttp3/SocketChannelTest.kt Co-authored-by: Jake Wharton * Spotless --------- Co-authored-by: Jesse Wilson Co-authored-by: Jake Wharton --- build.gradle.kts | 4 +- gradle/libs.versions.toml | 1 + okhttp/build.gradle.kts | 1 + .../kotlin/okhttp3/ConnectionListenerTest.kt | 69 +- .../src/jvmTest/kotlin/okhttp3/CookieTest.kt | 10 +- .../kotlin/okhttp3/RouteFailureTest.kt | 9 +- .../kotlin/okhttp3/SessionReuseTest.kt | 13 +- .../kotlin/okhttp3/SocketChannelTest.kt | 45 +- .../internal/cache/DiskLruCacheTest.kt | 763 +++++++----------- .../okhttp3/internal/http/CancelTest.kt | 38 +- .../internal/http2/HttpOverHttp2Test.kt | 381 +++------ 11 files changed, 496 insertions(+), 838 deletions(-) diff --git a/build.gradle.kts b/build.gradle.kts index 1e54caa3e..9514641eb 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -2,15 +2,14 @@ import com.diffplug.gradle.spotless.SpotlessExtension import com.vanniktech.maven.publish.MavenPublishBaseExtension +import java.net.URI import kotlinx.validation.ApiValidationExtension import org.gradle.api.tasks.testing.logging.TestExceptionFormat import org.jetbrains.dokka.gradle.DokkaTaskPartial import org.jetbrains.kotlin.gradle.dsl.JvmTarget -import org.jetbrains.kotlin.gradle.dsl.kotlinExtension import org.jetbrains.kotlin.gradle.targets.jvm.tasks.KotlinJvmTest import org.jetbrains.kotlin.gradle.tasks.KotlinCompile import ru.vyarus.gradle.plugin.animalsniffer.AnimalSnifferExtension -import java.net.URI buildscript { dependencies { @@ -20,6 +19,7 @@ buildscript { classpath(libs.gradlePlugin.androidJunit5) classpath(libs.gradlePlugin.android) classpath(libs.gradlePlugin.bnd) + classpath(libs.gradlePlugin.burst) classpath(libs.gradlePlugin.shadow) classpath(libs.gradlePlugin.animalsniffer) classpath(libs.gradlePlugin.errorprone) diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index d02d39bac..80a81bc85 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -52,6 +52,7 @@ gradlePlugin-androidJunit5 = "de.mannodermaus.gradle.plugins:android-junit5:1.14 gradlePlugin-animalsniffer = "ru.vyarus:gradle-animalsniffer-plugin:2.0.1" gradlePlugin-binaryCompatibilityValidator = "org.jetbrains.kotlinx.binary-compatibility-validator:org.jetbrains.kotlinx.binary-compatibility-validator.gradle.plugin:0.18.1" gradlePlugin-bnd = { module = "biz.aQute.bnd:biz.aQute.bnd.gradle", version.ref = "biz-aQute-bnd" } +gradlePlugin-burst = { module = "app.cash.burst:burst-gradle-plugin", version = "2.10.2" } gradlePlugin-dokka = "org.jetbrains.dokka:dokka-gradle-plugin:2.0.0" gradlePlugin-errorprone = "net.ltgt.gradle:gradle-errorprone-plugin:4.3.0" gradlePlugin-graalvmBuildTools = "org.graalvm.buildtools.native:org.graalvm.buildtools.native.gradle.plugin:0.11.2" diff --git a/okhttp/build.gradle.kts b/okhttp/build.gradle.kts index 327e36ca5..2e8cd9dc0 100644 --- a/okhttp/build.gradle.kts +++ b/okhttp/build.gradle.kts @@ -15,6 +15,7 @@ plugins { id("org.jetbrains.dokka") id("com.vanniktech.maven.publish.base") id("binary-compatibility-validator") + id("app.cash.burst") } val platform = System.getProperty("okhttp.platform", "jdk9") diff --git a/okhttp/src/jvmTest/kotlin/okhttp3/ConnectionListenerTest.kt b/okhttp/src/jvmTest/kotlin/okhttp3/ConnectionListenerTest.kt index a21950b83..1d96b0112 100644 --- a/okhttp/src/jvmTest/kotlin/okhttp3/ConnectionListenerTest.kt +++ b/okhttp/src/jvmTest/kotlin/okhttp3/ConnectionListenerTest.kt @@ -47,8 +47,6 @@ import org.junit.jupiter.api.Tag import org.junit.jupiter.api.Test import org.junit.jupiter.api.Timeout import org.junit.jupiter.api.extension.RegisterExtension -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource @Flaky // STDOUT logging enabled for test @Timeout(30) @@ -83,15 +81,14 @@ open class ConnectionListenerTest { listener.forbidLock(client.dispatcher) } - @ParameterizedTest - @ValueSource(booleans = [true, false]) + @Test fun successfulCallEventSequence() { - server!!.enqueue(MockResponse(body = "abc")) + server.enqueue(MockResponse(body = "abc")) val call = client.newCall( Request .Builder() - .url(server!!.url("/")) + .url(server.url("/")) .build(), ) val response = call.execute() @@ -108,7 +105,7 @@ open class ConnectionListenerTest { @Test fun failedCallEventSequence() { - server!!.enqueue( + server.enqueue( MockResponse .Builder() .headersDelay(2, TimeUnit.SECONDS) @@ -123,7 +120,7 @@ open class ConnectionListenerTest { client.newCall( Request .Builder() - .url(server!!.url("/")) + .url(server.url("/")) .build(), ) assertFailsWith { @@ -147,7 +144,7 @@ open class ConnectionListenerTest { client.newCall( Request .Builder() - .url(server!!.url("/")) + .url(server.url("/")) .build(), ) val response = call.execute() @@ -166,17 +163,17 @@ open class ConnectionListenerTest { @Throws(IOException::class) fun secondCallEventSequence() { enableTls() - server!!.protocols = listOf(Protocol.HTTP_2, Protocol.HTTP_1_1) - server!!.enqueue(MockResponse()) - server!!.enqueue(MockResponse()) + server.protocols = listOf(Protocol.HTTP_2, Protocol.HTTP_1_1) + server.enqueue(MockResponse()) + server.enqueue(MockResponse()) client - .newCall(Request(server!!.url("/"))) + .newCall(Request(server.url("/"))) .execute() .close() client - .newCall(Request(server!!.url("/"))) + .newCall(Request(server.url("/"))) .execute() .close() @@ -194,24 +191,24 @@ open class ConnectionListenerTest { @Throws(IOException::class) fun successfulEmptyH2CallEventSequence() { enableTls() - server!!.protocols = Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1) - server!!.enqueue(MockResponse()) + server.protocols = Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1) + server.enqueue(MockResponse()) assertSuccessfulEventOrder() } @Test @Throws(IOException::class) fun multipleDnsLookupsForSingleCall() { - server!!.enqueue( + server.enqueue( MockResponse( code = 301, - headers = headersOf("Location", "http://www.fakeurl:" + server!!.port), + headers = headersOf("Location", "http://www.fakeurl:" + server.port), ), ) - server!!.enqueue(MockResponse()) + server.enqueue(MockResponse()) val dns = FakeDns() - dns["fakeurl"] = client.dns.lookup(server!!.hostName) - dns["www.fakeurl"] = client.dns.lookup(server!!.hostName) + dns["fakeurl"] = client.dns.lookup(server.hostName) + dns["www.fakeurl"] = client.dns.lookup(server.hostName) client = client .newBuilder() @@ -221,7 +218,7 @@ open class ConnectionListenerTest { client.newCall( Request .Builder() - .url("http://fakeurl:" + server!!.port) + .url("http://fakeurl:" + server.port) .build(), ) val response = call.execute() @@ -236,19 +233,19 @@ open class ConnectionListenerTest { @Test @Throws(IOException::class) fun successfulConnect() { - server!!.enqueue(MockResponse()) + server.enqueue(MockResponse()) val call = client.newCall( Request .Builder() - .url(server!!.url("/")) + .url(server.url("/")) .build(), ) val response = call.execute() assertThat(response.code).isEqualTo(200) response.body.close() - val address = client.dns.lookup(server!!.hostName)[0] - val expectedAddress = InetSocketAddress(address, server!!.port) + val address = client.dns.lookup(server.hostName)[0] + val expectedAddress = InetSocketAddress(address, server.port) val event = listener.removeUpToEvent(ConnectionEvent.ConnectStart::class.java) assertThat(event.route.socketAddress).isEqualTo(expectedAddress) } @@ -257,19 +254,19 @@ open class ConnectionListenerTest { @Throws(UnknownHostException::class) fun failedConnect() { enableTls() - server!!.enqueue(MockResponse.Builder().failHandshake().build()) + server.enqueue(MockResponse.Builder().failHandshake().build()) val call = client.newCall( Request .Builder() - .url(server!!.url("/")) + .url(server.url("/")) .build(), ) assertFailsWith { call.execute() } - val address = client.dns.lookup(server!!.hostName)[0] - val expectedAddress = InetSocketAddress(address, server!!.port) + val address = client.dns.lookup(server.hostName)[0] + val expectedAddress = InetSocketAddress(address, server.port) val event = listener.removeUpToEvent(ConnectionEvent.ConnectFailed::class.java) assertThat(event.route.socketAddress).isEqualTo(expectedAddress) @@ -283,8 +280,8 @@ open class ConnectionListenerTest { @Throws(IOException::class) fun multipleConnectsForSingleCall() { enableTls() - server!!.enqueue(MockResponse.Builder().failHandshake().build()) - server!!.enqueue(MockResponse()) + server.enqueue(MockResponse.Builder().failHandshake().build()) + server.enqueue(MockResponse()) client = client .newBuilder() @@ -294,7 +291,7 @@ open class ConnectionListenerTest { client.newCall( Request .Builder() - .url(server!!.url("/")) + .url(server.url("/")) .build(), ) val response = call.execute() @@ -313,8 +310,8 @@ open class ConnectionListenerTest { @Test @Throws(IOException::class) fun successfulHttpProxyConnect() { - server!!.enqueue(MockResponse()) - val proxy = server!!.proxyAddress + server.enqueue(MockResponse()) + val proxy = server.proxyAddress client = client .newBuilder() @@ -349,7 +346,7 @@ open class ConnectionListenerTest { handshakeCertificates.trustManager, ).hostnameVerifier(RecordingHostnameVerifier()) .build() - server!!.useHttps(handshakeCertificates.sslSocketFactory()) + server.useHttps(handshakeCertificates.sslSocketFactory()) } } diff --git a/okhttp/src/jvmTest/kotlin/okhttp3/CookieTest.kt b/okhttp/src/jvmTest/kotlin/okhttp3/CookieTest.kt index a4a0a2dea..7f00f30e4 100644 --- a/okhttp/src/jvmTest/kotlin/okhttp3/CookieTest.kt +++ b/okhttp/src/jvmTest/kotlin/okhttp3/CookieTest.kt @@ -15,6 +15,8 @@ */ package okhttp3 +import app.cash.burst.Burst +import app.cash.burst.burstValues import assertk.assertThat import assertk.assertions.isEqualTo import assertk.assertions.isFalse @@ -35,9 +37,8 @@ import okhttp3.internal.http.MAX_DATE import okhttp3.internal.parseCookie import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertThrows -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource +@Burst class CookieTest { val url = "https://example.com/".toHttpUrl() @@ -613,9 +614,8 @@ class CookieTest { cookieBuilder.sameSite("a").build() } - @ParameterizedTest(name = "{displayName}({arguments})") - @ValueSource(strings = ["Lax", "Strict", "UnrecognizedButValid"]) - fun builderSameSite(sameSite: String) { + @Test + fun builderSameSite(sameSite: String = burstValues("Lax", "Strict", "UnrecognizedButValid")) { val cookie = Cookie .Builder() diff --git a/okhttp/src/jvmTest/kotlin/okhttp3/RouteFailureTest.kt b/okhttp/src/jvmTest/kotlin/okhttp3/RouteFailureTest.kt index ece701a30..dc890c4b2 100644 --- a/okhttp/src/jvmTest/kotlin/okhttp3/RouteFailureTest.kt +++ b/okhttp/src/jvmTest/kotlin/okhttp3/RouteFailureTest.kt @@ -15,6 +15,7 @@ */ package okhttp3 +import app.cash.burst.Burst import assertk.assertThat import assertk.assertions.containsExactly import assertk.assertions.isEmpty @@ -34,9 +35,8 @@ import okhttp3.testing.PlatformRule import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.RegisterExtension -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource +@Burst class RouteFailureTest { private lateinit var socketFactory: SpecificHostSocketFactory private lateinit var client: OkHttpClient @@ -310,9 +310,8 @@ class RouteFailureTest { ) } - @ParameterizedTest - @ValueSource(booleans = [false, true]) - fun proxyMoveTest(cleanClose: Boolean) { + @Test + fun proxyMoveTest(cleanClose: Boolean = true) { // Define a single Proxy at myproxy:8008 that will artificially move during the test val proxySelector = RecordingProxySelector() val socketAddress = InetSocketAddress.createUnresolved("myproxy", 8008) diff --git a/okhttp/src/jvmTest/kotlin/okhttp3/SessionReuseTest.kt b/okhttp/src/jvmTest/kotlin/okhttp3/SessionReuseTest.kt index d08d30995..43e2d5391 100644 --- a/okhttp/src/jvmTest/kotlin/okhttp3/SessionReuseTest.kt +++ b/okhttp/src/jvmTest/kotlin/okhttp3/SessionReuseTest.kt @@ -15,6 +15,8 @@ */ package okhttp3 +import app.cash.burst.Burst +import app.cash.burst.burstValues import assertk.assertThat import assertk.assertions.containsExactlyInAnyOrder import assertk.assertions.isEmpty @@ -23,7 +25,6 @@ import javax.net.ssl.SSLSocket import mockwebserver3.MockResponse import mockwebserver3.MockWebServer import mockwebserver3.junit5.StartStop -import okhttp3.testing.Flaky import okhttp3.testing.PlatformRule import okhttp3.testing.PlatformVersion import okio.ByteString.Companion.toByteString @@ -31,10 +32,10 @@ import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertNotEquals import org.junit.jupiter.api.Assumptions.assumeTrue import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.RegisterExtension -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource +@Burst class SessionReuseTest { @JvmField @RegisterExtension var platform = PlatformRule() @@ -59,10 +60,8 @@ class SessionReuseTest { platform.assumeNotBouncyCastle() } - @ParameterizedTest(name = "{displayName}({arguments})") - @ValueSource(strings = ["TLSv1.2", "TLSv1.3"]) - @Flaky - fun testSessionReuse(tlsVersion: String) { + @Test + fun testSessionReuse(tlsVersion: String = burstValues("TLSv1.2", "TLSv1.3")) { if (tlsVersion == TlsVersion.TLS_1_3.javaName) { assumeTrue(PlatformVersion.majorVersion != 8) } diff --git a/okhttp/src/jvmTest/kotlin/okhttp3/SocketChannelTest.kt b/okhttp/src/jvmTest/kotlin/okhttp3/SocketChannelTest.kt index 515ff8327..760d3b6be 100644 --- a/okhttp/src/jvmTest/kotlin/okhttp3/SocketChannelTest.kt +++ b/okhttp/src/jvmTest/kotlin/okhttp3/SocketChannelTest.kt @@ -15,6 +15,8 @@ */ package okhttp3 +import app.cash.burst.Burst +import app.cash.burst.burstValues import assertk.assertThat import assertk.assertions.isEqualTo import assertk.assertions.isNotEmpty @@ -34,8 +36,6 @@ import mockwebserver3.junit5.StartStop import okhttp3.Protocol.HTTP_1_1 import okhttp3.Protocol.HTTP_2 import okhttp3.Provider.CONSCRYPT -import okhttp3.Provider.JSSE -import okhttp3.TlsExtensionMode.DISABLED import okhttp3.TlsExtensionMode.STANDARD import okhttp3.TlsVersion.TLS_1_2 import okhttp3.TlsVersion.TLS_1_3 @@ -46,14 +46,14 @@ import org.junit.jupiter.api.Assumptions.assumeFalse import org.junit.jupiter.api.Assumptions.assumeTrue import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Tag +import org.junit.jupiter.api.Test import org.junit.jupiter.api.Timeout import org.junit.jupiter.api.extension.RegisterExtension -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.MethodSource @Suppress("UsePropertyAccessSyntax") @Timeout(6) @Tag("slow") +@Burst class SocketChannelTest { @JvmField @RegisterExtension val platform = PlatformRule() @@ -93,9 +93,23 @@ class SocketChannelTest { platform.assumeNotBouncyCastle() } - @ParameterizedTest - @MethodSource("connectionTypes") - fun testConnection(socketMode: SocketMode) { + @Test + fun testHttp(socketMode: SocketMode = burstValues(Channel, Standard)) { + testConnection(socketMode) + } + + @Test + fun testHttps( + provider: Provider = Provider.JSSE, + protocol: Protocol = burstValues(HTTP_1_1, HTTP_2), + tlsVersion: TlsVersion = burstValues(TLS_1_3, TLS_1_2), + socketMode: SocketMode = burstValues(Channel, Standard), + tlsExtensionMode: TlsExtensionMode = TlsExtensionMode.STANDARD, + ) { + testConnection(TlsInstance(provider, protocol, tlsVersion, socketMode, tlsExtensionMode)) + } + + private fun testConnection(socketMode: SocketMode) { // https://github.com/square/okhttp/pull/6554 assumeFalse( socketMode is TlsInstance && @@ -225,23 +239,6 @@ class SocketChannelTest { } } } - - companion object { - @Suppress("unused") - @JvmStatic - fun connectionTypes(): List = - listOf(CONSCRYPT, JSSE).flatMap { provider -> - listOf(HTTP_1_1, HTTP_2).flatMap { protocol -> - listOf(TLS_1_3, TLS_1_2).flatMap { tlsVersion -> - listOf(Channel, Standard).flatMap { socketMode -> - listOf(DISABLED, STANDARD).map { tlsExtensionMode -> - TlsInstance(provider, protocol, tlsVersion, socketMode, tlsExtensionMode) - } - } - } - } - } + Channel + Standard - } } sealed class SocketMode diff --git a/okhttp/src/jvmTest/kotlin/okhttp3/internal/cache/DiskLruCacheTest.kt b/okhttp/src/jvmTest/kotlin/okhttp3/internal/cache/DiskLruCacheTest.kt index 68ef3612b..c07f0a8bf 100644 --- a/okhttp/src/jvmTest/kotlin/okhttp3/internal/cache/DiskLruCacheTest.kt +++ b/okhttp/src/jvmTest/kotlin/okhttp3/internal/cache/DiskLruCacheTest.kt @@ -15,6 +15,7 @@ */ package okhttp3.internal.cache +import app.cash.burst.Burst import assertk.assertThat import assertk.assertions.isEqualTo import assertk.assertions.isFalse @@ -27,7 +28,6 @@ import java.io.FileNotFoundException import java.io.IOException import java.util.ArrayDeque import kotlin.test.assertFailsWith -import okhttp3.SimpleProvider import okhttp3.TestUtil import okhttp3.internal.cache.DiskLruCache.Editor import okhttp3.internal.cache.DiskLruCache.Snapshot @@ -41,29 +41,30 @@ import okio.buffer import okio.fakefilesystem.FakeFileSystem import org.junit.jupiter.api.AfterEach import org.junit.jupiter.api.Assumptions +import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Tag +import org.junit.jupiter.api.Test import org.junit.jupiter.api.Timeout import org.junit.jupiter.api.io.TempDir -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ArgumentsSource - -class FileSystemParamProvider : SimpleProvider() { - override fun arguments() = - listOf( - FakeFileSystem().apply { emulateUnix() } to false, - FileSystem.SYSTEM to TestUtil.windows, - FakeFileSystem().apply { emulateWindows() } to true, - ) -} @Timeout(60) @Tag("Slow") -class DiskLruCacheTest { - private lateinit var filesystem: FaultyFileSystem - private var windows: Boolean = false +@Burst +class DiskLruCacheTest( + subject: Subject = Subject.System, +) { + private val baseFilesystem: FileSystem = subject.create() + private val filesystem = FaultyFileSystem(baseFilesystem) + private val windows = subject.windows - @TempDir lateinit var cacheDirFile: File - lateinit var cacheDir: Path + @TempDir + lateinit var cacheDirFile: File + private val cacheDir: Path + get() = + when (baseFilesystem) { + is FakeFileSystem -> "/cache".toPath() + else -> cacheDirFile.path.toPath() + } private val appVersion = 100 private lateinit var journalFile: Path private lateinit var journalBkpFile: Path @@ -84,15 +85,8 @@ class DiskLruCacheTest { synchronized(cache) { cache.initialize() } } - fun setUp( - baseFilesystem: FileSystem, - windows: Boolean, - ) { - this.cacheDir = - if (baseFilesystem is FakeFileSystem) "/cache".toPath() else cacheDirFile.path.toPath() - this.filesystem = FaultyFileSystem(baseFilesystem) - this.windows = windows - + @BeforeEach + fun setUp() { if (filesystem.exists(cacheDir)) { filesystem.deleteRecursively(cacheDir) } @@ -110,18 +104,14 @@ class DiskLruCacheTest { (filesystem.delegate as? FakeFileSystem)?.checkNoOpenFiles() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun emptyCache(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun emptyCache() { cache.close() assertJournalEquals() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun recoverFromInitializationFailure(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun recoverFromInitializationFailure() { // Add an uncommitted entry. This will get detected on initialization, and the cache will // attempt to delete the file. Do not explicitly close the cache here so the entry is left as // incomplete. @@ -148,10 +138,8 @@ class DiskLruCacheTest { assertThat(snapshot).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun validateKey(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun validateKey() { var key = "" assertFailsWith { key = "has_space " @@ -209,10 +197,8 @@ class DiskLruCacheTest { cache.edit(key)!!.abort() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun writeAndReadEntry(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun writeAndReadEntry() { val creator = cache.edit("k1")!! creator.setString(0, "ABC") creator.setString(1, "DE") @@ -224,10 +210,8 @@ class DiskLruCacheTest { snapshot.assertValue(1, "DE") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun readAndWriteEntryAcrossCacheOpenAndClose(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun readAndWriteEntryAcrossCacheOpenAndClose() { val creator = cache.edit("k1")!! creator.setString(0, "A") creator.setString(1, "B") @@ -240,10 +224,8 @@ class DiskLruCacheTest { snapshot.close() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun readAndWriteEntryWithoutProperClose(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun readAndWriteEntryWithoutProperClose() { val creator = cache.edit("k1")!! creator.setString(0, "A") creator.setString(1, "B") @@ -257,10 +239,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun journalWithEditAndPublish(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun journalWithEditAndPublish() { val creator = cache.edit("k1")!! assertJournalEquals("DIRTY k1") // DIRTY must always be flushed. creator.setString(0, "AB") @@ -270,10 +250,8 @@ class DiskLruCacheTest { assertJournalEquals("DIRTY k1", "CLEAN k1 2 1") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun revertedNewFileIsRemoveInJournal(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun revertedNewFileIsRemoveInJournal() { val creator = cache.edit("k1")!! assertJournalEquals("DIRTY k1") // DIRTY must always be flushed. creator.setString(0, "AB") @@ -284,10 +262,8 @@ class DiskLruCacheTest { } /** On Windows we have to wait until the edit is committed before we can delete its files. */ - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `unterminated edit is reverted on cache close`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `unterminated edit is reverted on cache close`() { val editor = cache.edit("k1")!! editor.setString(0, "AB") editor.setString(1, "C") @@ -298,10 +274,8 @@ class DiskLruCacheTest { assertJournalEquals(*expected) // 'REMOVE k1' not written because journal is closed. } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun journalDoesNotIncludeReadOfYetUnpublishedValue(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun journalDoesNotIncludeReadOfYetUnpublishedValue() { val creator = cache.edit("k1")!! assertThat(cache["k1"]).isNull() creator.setString(0, "A") @@ -311,10 +285,8 @@ class DiskLruCacheTest { assertJournalEquals("DIRTY k1", "CLEAN k1 1 2") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun journalWithEditAndPublishAndRead(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun journalWithEditAndPublishAndRead() { val k1Creator = cache.edit("k1")!! k1Creator.setString(0, "AB") k1Creator.setString(1, "C") @@ -329,10 +301,8 @@ class DiskLruCacheTest { assertJournalEquals("DIRTY k1", "CLEAN k1 2 1", "DIRTY k2", "CLEAN k2 3 1", "READ k1") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun cannotOperateOnEditAfterPublish(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun cannotOperateOnEditAfterPublish() { val editor = cache.edit("k1")!! editor.setString(0, "A") editor.setString(1, "B") @@ -340,10 +310,8 @@ class DiskLruCacheTest { editor.assertInoperable() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun cannotOperateOnEditAfterRevert(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun cannotOperateOnEditAfterRevert() { val editor = cache.edit("k1")!! editor.setString(0, "A") editor.setString(1, "B") @@ -351,10 +319,8 @@ class DiskLruCacheTest { editor.assertInoperable() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun explicitRemoveAppliedToDiskImmediately(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun explicitRemoveAppliedToDiskImmediately() { val editor = cache.edit("k1")!! editor.setString(0, "ABC") editor.setString(1, "B") @@ -365,10 +331,8 @@ class DiskLruCacheTest { assertThat(filesystem.exists(k1)).isFalse() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun removePreventsActiveEditFromStoringAValue(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun removePreventsActiveEditFromStoringAValue() { set("a", "a", "a") val a = cache.edit("a")!! a.setString(0, "a1") @@ -382,10 +346,8 @@ class DiskLruCacheTest { * Each read sees a snapshot of the file at the time read was called. This means that two reads of * the same key can see different data. */ - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun readAndWriteOverlapsMaintainConsistency(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun readAndWriteOverlapsMaintainConsistency() { Assumptions.assumeFalse(windows) // Can't edit while a read is in progress. val v1Creator = cache.edit("k1")!! @@ -414,10 +376,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun openWithDirtyKeyDeletesAllFilesForThatKey(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun openWithDirtyKeyDeletesAllFilesForThatKey() { cache.close() val cleanFile0 = getCleanFile("k1", 0) val cleanFile1 = getCleanFile("k1", 1) @@ -436,10 +396,8 @@ class DiskLruCacheTest { assertThat(cache["k1"]).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun openWithInvalidVersionClearsDirectory(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun openWithInvalidVersionClearsDirectory() { cache.close() generateSomeGarbageFiles() createJournalWithHeader(DiskLruCache.MAGIC, "0", "100", "2", "") @@ -447,10 +405,8 @@ class DiskLruCacheTest { assertGarbageFilesAllDeleted() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun openWithInvalidAppVersionClearsDirectory(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun openWithInvalidAppVersionClearsDirectory() { cache.close() generateSomeGarbageFiles() createJournalWithHeader(DiskLruCache.MAGIC, "1", "101", "2", "") @@ -458,10 +414,8 @@ class DiskLruCacheTest { assertGarbageFilesAllDeleted() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun openWithInvalidValueCountClearsDirectory(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun openWithInvalidValueCountClearsDirectory() { cache.close() generateSomeGarbageFiles() createJournalWithHeader(DiskLruCache.MAGIC, "1", "100", "1", "") @@ -469,10 +423,8 @@ class DiskLruCacheTest { assertGarbageFilesAllDeleted() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun openWithInvalidBlankLineClearsDirectory(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun openWithInvalidBlankLineClearsDirectory() { cache.close() generateSomeGarbageFiles() createJournalWithHeader(DiskLruCache.MAGIC, "1", "100", "2", "x") @@ -480,10 +432,8 @@ class DiskLruCacheTest { assertGarbageFilesAllDeleted() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun openWithInvalidJournalLineClearsDirectory(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun openWithInvalidJournalLineClearsDirectory() { cache.close() generateSomeGarbageFiles() createJournal("CLEAN k1 1 1", "BOGUS") @@ -492,10 +442,8 @@ class DiskLruCacheTest { assertThat(cache["k1"]).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun openWithInvalidFileSizeClearsDirectory(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun openWithInvalidFileSizeClearsDirectory() { cache.close() generateSomeGarbageFiles() createJournal("CLEAN k1 0000x001 1") @@ -504,10 +452,8 @@ class DiskLruCacheTest { assertThat(cache["k1"]).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun openWithTruncatedLineDiscardsThatLine(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun openWithTruncatedLineDiscardsThatLine() { cache.close() writeFile(getCleanFile("k1", 0), "A") writeFile(getCleanFile("k1", 1), "B") @@ -534,10 +480,8 @@ class DiskLruCacheTest { assertValue("k1", "C", "D") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun openWithTooManyFileSizesClearsDirectory(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun openWithTooManyFileSizesClearsDirectory() { cache.close() generateSomeGarbageFiles() createJournal("CLEAN k1 1 1 1") @@ -546,37 +490,29 @@ class DiskLruCacheTest { assertThat(cache["k1"]).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun keyWithSpaceNotPermitted(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun keyWithSpaceNotPermitted() { assertFailsWith { cache.edit("my key") } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun keyWithNewlineNotPermitted(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun keyWithNewlineNotPermitted() { assertFailsWith { cache.edit("my\nkey") } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun keyWithCarriageReturnNotPermitted(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun keyWithCarriageReturnNotPermitted() { assertFailsWith { cache.edit("my\rkey") } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun createNewEntryWithTooFewValuesFails(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun createNewEntryWithTooFewValuesFails() { val creator = cache.edit("k1")!! creator.setString(1, "A") assertFailsWith { @@ -593,10 +529,8 @@ class DiskLruCacheTest { creator2.commit() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun revertWithTooFewValues(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun revertWithTooFewValues() { val creator = cache.edit("k1")!! creator.setString(1, "A") creator.abort() @@ -607,10 +541,8 @@ class DiskLruCacheTest { assertThat(cache["k1"]).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun updateExistingEntryWithTooFewValuesReusesPreviousValues(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun updateExistingEntryWithTooFewValuesReusesPreviousValues() { val creator = cache.edit("k1")!! creator.setString(0, "A") creator.setString(1, "B") @@ -624,10 +556,8 @@ class DiskLruCacheTest { snapshot.close() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun growMaxSize(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun growMaxSize() { cache.close() createNewCacheWithSize(10) set("a", "a", "aaa") // size 4 @@ -637,10 +567,8 @@ class DiskLruCacheTest { assertThat(cache.size()).isEqualTo(12) } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun shrinkMaxSizeEvicts(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun shrinkMaxSizeEvicts() { cache.close() createNewCacheWithSize(20) set("a", "a", "aaa") // size 4 @@ -650,10 +578,8 @@ class DiskLruCacheTest { assertThat(taskFaker.isIdle()).isFalse() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun evictOnInsert(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun evictOnInsert() { cache.close() createNewCacheWithSize(10) set("a", "a", "aaa") // size 4 @@ -688,10 +614,8 @@ class DiskLruCacheTest { assertValue("e", "eeee", "eeee") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun evictOnUpdate(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun evictOnUpdate() { cache.close() createNewCacheWithSize(10) set("a", "a", "aa") // size 3 @@ -708,10 +632,8 @@ class DiskLruCacheTest { assertValue("c", "c", "cc") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun evictionHonorsLruFromCurrentSession(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun evictionHonorsLruFromCurrentSession() { cache.close() createNewCacheWithSize(10) set("a", "a", "a") @@ -735,10 +657,8 @@ class DiskLruCacheTest { assertValue("f", "f", "f") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun evictionHonorsLruFromPreviousSession(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun evictionHonorsLruFromPreviousSession() { set("a", "a", "a") set("b", "b", "b") set("c", "c", "c") @@ -761,10 +681,8 @@ class DiskLruCacheTest { assertValue("g", "g", "g") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun cacheSingleEntryOfSizeGreaterThanMaxSize(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun cacheSingleEntryOfSizeGreaterThanMaxSize() { cache.close() createNewCacheWithSize(10) set("a", "aaaaa", "aaaaaa") // size=11 @@ -772,10 +690,8 @@ class DiskLruCacheTest { assertAbsent("a") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun cacheSingleValueOfSizeGreaterThanMaxSize(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun cacheSingleValueOfSizeGreaterThanMaxSize() { cache.close() createNewCacheWithSize(10) set("a", "aaaaaaaaaaa", "a") // size=12 @@ -783,45 +699,35 @@ class DiskLruCacheTest { assertAbsent("a") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun constructorDoesNotAllowZeroCacheSize(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun constructorDoesNotAllowZeroCacheSize() { assertFailsWith { DiskLruCache(filesystem, cacheDir, appVersion, 2, 0, taskRunner) } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun constructorDoesNotAllowZeroValuesPerEntry(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun constructorDoesNotAllowZeroValuesPerEntry() { assertFailsWith { DiskLruCache(filesystem, cacheDir, appVersion, 0, 10, taskRunner) } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun removeAbsentElement(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun removeAbsentElement() { cache.remove("a") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun readingTheSameStreamMultipleTimes(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun readingTheSameStreamMultipleTimes() { set("a", "a", "b") val snapshot = cache["a"]!! assertThat(snapshot.getSource(0)).isSameAs(snapshot.getSource(0)) snapshot.close() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun rebuildJournalOnRepeatedReads(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun rebuildJournalOnRepeatedReads() { set("a", "a", "a") set("b", "b", "b") while (taskFaker.isIdle()) { @@ -830,10 +736,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun rebuildJournalOnRepeatedEdits(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun rebuildJournalOnRepeatedEdits() { while (taskFaker.isIdle()) { set("a", "a", "a") set("b", "b", "b") @@ -846,10 +750,8 @@ class DiskLruCacheTest { } /** @see [Issue 28](https://github.com/JakeWharton/DiskLruCache/issues/28) */ - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun rebuildJournalOnRepeatedReadsWithOpenAndClose(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun rebuildJournalOnRepeatedReadsWithOpenAndClose() { set("a", "a", "a") set("b", "b", "b") while (taskFaker.isIdle()) { @@ -861,10 +763,8 @@ class DiskLruCacheTest { } /** @see [Issue 28](https://github.com/JakeWharton/DiskLruCache/issues/28) */ - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun rebuildJournalOnRepeatedEditsWithOpenAndClose(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun rebuildJournalOnRepeatedEditsWithOpenAndClose() { while (taskFaker.isIdle()) { set("a", "a", "a") set("b", "b", "b") @@ -873,10 +773,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun rebuildJournalFailurePreventsEditors(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun rebuildJournalFailurePreventsEditors() { while (taskFaker.isIdle()) { set("a", "a", "a") set("b", "b", "b") @@ -894,10 +792,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun rebuildJournalFailureIsRetried(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun rebuildJournalFailureIsRetried() { while (taskFaker.isIdle()) { set("a", "a", "a") set("b", "b", "b") @@ -923,10 +819,8 @@ class DiskLruCacheTest { assertJournalEquals("CLEAN a 1 1", "CLEAN b 1 1") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun rebuildJournalFailureWithInFlightEditors(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun rebuildJournalFailureWithInFlightEditors() { while (taskFaker.isIdle()) { set("a", "a", "a") set("b", "b", "b") @@ -952,10 +846,8 @@ class DiskLruCacheTest { assertJournalEquals("CLEAN a 1 1", "CLEAN b 1 1", "DIRTY e", "CLEAN c 1 1") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun rebuildJournalFailureWithEditorsInFlightThenClose(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun rebuildJournalFailureWithEditorsInFlightThenClose() { while (taskFaker.isIdle()) { set("a", "a", "a") set("b", "b", "b") @@ -984,10 +876,8 @@ class DiskLruCacheTest { assertAbsent("e") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun rebuildJournalFailureAllowsRemovals(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun rebuildJournalFailureAllowsRemovals() { while (taskFaker.isIdle()) { set("a", "a", "a") set("b", "b", "b") @@ -1005,10 +895,8 @@ class DiskLruCacheTest { assertJournalEquals("CLEAN b 1 1") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun rebuildJournalFailureWithRemovalThenClose(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun rebuildJournalFailureWithRemovalThenClose() { while (taskFaker.isIdle()) { set("a", "a", "a") set("b", "b", "b") @@ -1030,10 +918,8 @@ class DiskLruCacheTest { assertThat(cache.size()).isEqualTo(2) } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun rebuildJournalFailureAllowsEvictAll(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun rebuildJournalFailureAllowsEvictAll() { while (taskFaker.isIdle()) { set("a", "a", "a") set("b", "b", "b") @@ -1058,10 +944,8 @@ class DiskLruCacheTest { assertThat(cache.size()).isEqualTo(0) } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun rebuildJournalFailureWithCacheTrim(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun rebuildJournalFailureWithCacheTrim() { while (taskFaker.isIdle()) { set("a", "aa", "aa") set("b", "bb", "bb") @@ -1081,10 +965,8 @@ class DiskLruCacheTest { assertValue("b", "bb", "bb") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun restoreBackupFile(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun restoreBackupFile() { val creator = cache.edit("k1")!! creator.setString(0, "ABC") creator.setString(1, "DE") @@ -1100,10 +982,8 @@ class DiskLruCacheTest { assertThat(filesystem.exists(journalFile)).isTrue() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun journalFileIsPreferredOverBackupFile(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun journalFileIsPreferredOverBackupFile() { var creator = cache.edit("k1")!! creator.setString(0, "ABC") creator.setString(1, "DE") @@ -1128,10 +1008,8 @@ class DiskLruCacheTest { assertThat(filesystem.exists(journalFile)).isTrue() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun openCreatesDirectoryIfNecessary(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun openCreatesDirectoryIfNecessary() { cache.close() val dir = (cacheDir / "testOpenCreatesDirectoryIfNecessary").also { filesystem.createDirectories(it) } cache = @@ -1144,20 +1022,16 @@ class DiskLruCacheTest { assertThat(filesystem.exists(dir / "journal")).isTrue() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun fileDeletedExternally(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun fileDeletedExternally() { set("a", "a", "a") filesystem.delete(getCleanFile("a", 1)) assertThat(cache["a"]).isNull() assertThat(cache.size()).isEqualTo(0) } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun editSameVersion(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun editSameVersion() { set("a", "a", "a") val snapshot = cache["a"]!! snapshot.close() @@ -1167,10 +1041,8 @@ class DiskLruCacheTest { assertValue("a", "a", "a2") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun editSnapshotAfterChangeAborted(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun editSnapshotAfterChangeAborted() { set("a", "a", "a") val snapshot = cache["a"]!! snapshot.close() @@ -1183,10 +1055,8 @@ class DiskLruCacheTest { assertValue("a", "a", "a2") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun editSnapshotAfterChangeCommitted(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun editSnapshotAfterChangeCommitted() { set("a", "a", "a") val snapshot = cache["a"]!! snapshot.close() @@ -1196,10 +1066,8 @@ class DiskLruCacheTest { assertThat(snapshot.edit()).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun editSinceEvicted(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun editSinceEvicted() { cache.close() createNewCacheWithSize(10) set("a", "aa", "aaa") // size 5 @@ -1211,10 +1079,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun editSinceEvictedAndRecreated(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun editSinceEvictedAndRecreated() { cache.close() createNewCacheWithSize(10) set("a", "aa", "aaa") // size 5 @@ -1228,10 +1094,8 @@ class DiskLruCacheTest { } /** @see [Issue 2](https://github.com/JakeWharton/DiskLruCache/issues/2) */ - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun aggressiveClearingHandlesWrite(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun aggressiveClearingHandlesWrite() { Assumptions.assumeFalse(windows) // Can't deleteContents while the journal is open. filesystem.deleteRecursively(cacheDir) @@ -1240,10 +1104,8 @@ class DiskLruCacheTest { } /** @see [Issue 2](https://github.com/JakeWharton/DiskLruCache/issues/2) */ - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun aggressiveClearingHandlesEdit(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun aggressiveClearingHandlesEdit() { Assumptions.assumeFalse(windows) // Can't deleteContents while the journal is open. set("a", "a", "a") @@ -1253,20 +1115,16 @@ class DiskLruCacheTest { a.commit() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun removeHandlesMissingFile(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun removeHandlesMissingFile() { set("a", "a", "a") filesystem.delete(getCleanFile("a", 0)) cache.remove("a") } /** @see [Issue 2](https://github.com/JakeWharton/DiskLruCache/issues/2) */ - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun aggressiveClearingHandlesPartialEdit(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun aggressiveClearingHandlesPartialEdit() { Assumptions.assumeFalse(windows) // Can't deleteContents while the journal is open. set("a", "a", "a") @@ -1280,10 +1138,8 @@ class DiskLruCacheTest { } /** @see [Issue 2](https://github.com/JakeWharton/DiskLruCache/issues/2) */ - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun aggressiveClearingHandlesRead(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun aggressiveClearingHandlesRead() { Assumptions.assumeFalse(windows) // Can't deleteContents while the journal is open. filesystem.deleteRecursively(cacheDir) @@ -1294,10 +1150,8 @@ class DiskLruCacheTest { * We had a long-lived bug where [DiskLruCache.trimToSize] could infinite loop if entries * being edited required deletion for the operation to complete. */ - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun trimToSizeWithActiveEdit(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun trimToSizeWithActiveEdit() { val expectedByteCount = if (windows) 10L else 0L val afterRemoveFileContents = if (windows) "a1234" else null @@ -1317,10 +1171,8 @@ class DiskLruCacheTest { assertThat(cache.size()).isEqualTo(0) } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun evictAll(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun evictAll() { set("a", "a", "a") set("b", "b", "b") cache.evictAll() @@ -1329,10 +1181,8 @@ class DiskLruCacheTest { assertAbsent("b") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun evictAllWithPartialCreate(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun evictAllWithPartialCreate() { val a = cache.edit("a")!! a.setString(0, "a1") a.setString(1, "a2") @@ -1342,10 +1192,8 @@ class DiskLruCacheTest { assertAbsent("a") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun evictAllWithPartialEditDoesNotStoreAValue(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun evictAllWithPartialEditDoesNotStoreAValue() { val expectedByteCount = if (windows) 2L else 0L set("a", "a", "a") @@ -1358,10 +1206,8 @@ class DiskLruCacheTest { assertAbsent("a") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun evictAllDoesntInterruptPartialRead(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun evictAllDoesntInterruptPartialRead() { val expectedByteCount = if (windows) 2L else 0L val afterRemoveFileContents = if (windows) "a" else null @@ -1377,10 +1223,8 @@ class DiskLruCacheTest { assertThat(cache.size()).isEqualTo(0L) } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun editSnapshotAfterEvictAllReturnsNullDueToStaleValue(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun editSnapshotAfterEvictAllReturnsNullDueToStaleValue() { val expectedByteCount = if (windows) 2L else 0L val afterRemoveFileContents = if (windows) "a" else null @@ -1395,10 +1239,8 @@ class DiskLruCacheTest { assertThat(cache.size()).isEqualTo(0L) } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun iterator(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun iterator() { set("a", "a1", "a2") set("b", "b1", "b2") set("c", "c1", "c2") @@ -1427,10 +1269,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun iteratorElementsAddedDuringIterationAreOmitted(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun iteratorElementsAddedDuringIterationAreOmitted() { set("a", "a1", "a2") set("b", "b1", "b2") val iterator = cache.snapshots() @@ -1444,10 +1284,8 @@ class DiskLruCacheTest { assertThat(iterator.hasNext()).isFalse() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun iteratorElementsUpdatedDuringIterationAreUpdated(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun iteratorElementsUpdatedDuringIterationAreUpdated() { set("a", "a1", "a2") set("b", "b1", "b2") val iterator = cache.snapshots() @@ -1462,10 +1300,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun iteratorElementsRemovedDuringIterationAreOmitted(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun iteratorElementsRemovedDuringIterationAreOmitted() { set("a", "a1", "a2") set("b", "b1", "b2") val iterator = cache.snapshots() @@ -1476,10 +1312,8 @@ class DiskLruCacheTest { assertThat(iterator.hasNext()).isFalse() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun iteratorRemove(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun iteratorRemove() { set("a", "a1", "a2") val iterator = cache.snapshots() val a = iterator.next() @@ -1488,10 +1322,8 @@ class DiskLruCacheTest { assertThat(cache["a"]).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun iteratorRemoveBeforeNext(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun iteratorRemoveBeforeNext() { set("a", "a1", "a2") val iterator = cache.snapshots() assertFailsWith { @@ -1499,10 +1331,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun iteratorRemoveOncePerCallToNext(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun iteratorRemoveOncePerCallToNext() { set("a", "a1", "a2") val iterator = cache.snapshots() iterator.next().use { @@ -1513,20 +1343,16 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun cacheClosedTruncatesIterator(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun cacheClosedTruncatesIterator() { set("a", "a1", "a2") val iterator = cache.snapshots() cache.close() assertThat(iterator.hasNext()).isFalse() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun isClosed_uninitializedCache(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun isClosed_uninitializedCache() { // Create an uninitialized cache. cache = DiskLruCache(filesystem, cacheDir, appVersion, 2, Int.MAX_VALUE.toLong(), taskRunner).also { @@ -1537,10 +1363,8 @@ class DiskLruCacheTest { assertThat(cache.isClosed()).isTrue() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun journalWriteFailsDuringEdit(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun journalWriteFailsDuringEdit() { set("a", "a", "a") set("b", "b", "b") @@ -1568,10 +1392,8 @@ class DiskLruCacheTest { * We had a bug where the cache was left in an inconsistent state after a journal write failed. * https://github.com/square/okhttp/issues/1211 */ - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun journalWriteFailsDuringEditorCommit(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun journalWriteFailsDuringEditorCommit() { set("a", "a", "a") set("b", "b", "b") @@ -1598,10 +1420,8 @@ class DiskLruCacheTest { assertAbsent("d") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun journalWriteFailsDuringEditorAbort(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun journalWriteFailsDuringEditorAbort() { set("a", "a", "a") set("b", "b", "b") @@ -1628,10 +1448,8 @@ class DiskLruCacheTest { assertAbsent("d") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun journalWriteFailsDuringRemove(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun journalWriteFailsDuringRemove() { set("a", "a", "a") set("b", "b", "b") @@ -1650,10 +1468,8 @@ class DiskLruCacheTest { assertValue("b", "b", "b") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun cleanupTrimFailurePreventsNewEditors(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun cleanupTrimFailurePreventsNewEditors() { cache.maxSize = 8 taskFaker.runNextTask() set("a", "aa", "aa") @@ -1672,10 +1488,8 @@ class DiskLruCacheTest { filesystem.setFaultyDelete(cacheDir / "a.0", false) } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun cleanupTrimFailureRetriedOnEditors(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun cleanupTrimFailureRetriedOnEditors() { cache.maxSize = 8 taskFaker.runNextTask() set("a", "aa", "aa") @@ -1697,10 +1511,8 @@ class DiskLruCacheTest { assertValue("c", "cc", "cc") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun cleanupTrimFailureWithInFlightEditor(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun cleanupTrimFailureWithInFlightEditor() { cache.maxSize = 8 taskFaker.runNextTask() set("a", "aa", "aaa") @@ -1722,10 +1534,8 @@ class DiskLruCacheTest { assertValue("c", "cc", "cc") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun cleanupTrimFailureAllowsSnapshotReads(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun cleanupTrimFailureAllowsSnapshotReads() { cache.maxSize = 8 taskFaker.runNextTask() set("a", "aa", "aa") @@ -1743,10 +1553,8 @@ class DiskLruCacheTest { filesystem.setFaultyDelete(cacheDir / "a.0", false) } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun cleanupTrimFailurePreventsSnapshotWrites(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun cleanupTrimFailurePreventsSnapshotWrites() { cache.maxSize = 8 taskFaker.runNextTask() set("a", "aa", "aa") @@ -1768,10 +1576,8 @@ class DiskLruCacheTest { filesystem.setFaultyDelete(cacheDir / "a.0", false) } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun evictAllAfterCleanupTrimFailure(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun evictAllAfterCleanupTrimFailure() { cache.maxSize = 8 taskFaker.runNextTask() set("a", "aa", "aa") @@ -1791,10 +1597,8 @@ class DiskLruCacheTest { assertValue("c", "cc", "cc") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun manualRemovalAfterCleanupTrimFailure(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun manualRemovalAfterCleanupTrimFailure() { cache.maxSize = 8 taskFaker.runNextTask() set("a", "aa", "aa") @@ -1814,10 +1618,8 @@ class DiskLruCacheTest { assertValue("c", "cc", "cc") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun flushingAfterCleanupTrimFailure(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun flushingAfterCleanupTrimFailure() { cache.maxSize = 8 taskFaker.runNextTask() set("a", "aa", "aa") @@ -1837,10 +1639,8 @@ class DiskLruCacheTest { assertValue("c", "cc", "cc") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun cleanupTrimFailureWithPartialSnapshot(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun cleanupTrimFailureWithPartialSnapshot() { cache.maxSize = 8 taskFaker.runNextTask() set("a", "aa", "aa") @@ -1862,10 +1662,8 @@ class DiskLruCacheTest { assertThat(cache["a"]).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun noSizeCorruptionAfterCreatorDetached(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun noSizeCorruptionAfterCreatorDetached() { Assumptions.assumeFalse(windows) // Windows can't have two concurrent editors. // Create an editor for k1. Detach it by clearing the cache. @@ -1884,10 +1682,8 @@ class DiskLruCacheTest { assertValue("k1", "bb", "bb") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun noSizeCorruptionAfterEditorDetached(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun noSizeCorruptionAfterEditorDetached() { Assumptions.assumeFalse(windows) // Windows can't have two concurrent editors. set("k1", "a", "a") @@ -1908,20 +1704,16 @@ class DiskLruCacheTest { assertValue("k1", "ccc", "ccc") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun noNewSourceAfterEditorDetached(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun noNewSourceAfterEditorDetached() { set("k1", "a", "a") val editor = cache.edit("k1")!! cache.evictAll() assertThat(editor.newSource(0)).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `edit discarded after editor detached`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `edit discarded after editor detached`() { set("k1", "a", "a") // Create an editor, then detach it. @@ -1935,10 +1727,8 @@ class DiskLruCacheTest { assertThat(cache["k1"]).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `edit discarded after editor detached with concurrent write`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `edit discarded after editor detached with concurrent write`() { Assumptions.assumeFalse(windows) // Windows can't have two concurrent editors. set("k1", "a", "a") @@ -1957,10 +1747,8 @@ class DiskLruCacheTest { assertValue("k1", "ccc", "ccc") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun abortAfterDetach(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun abortAfterDetach() { set("k1", "a", "a") val editor = cache.edit("k1")!! cache.evictAll() @@ -1969,10 +1757,8 @@ class DiskLruCacheTest { assertAbsent("k1") } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun dontRemoveUnfinishedEntryWhenCreatingSnapshot(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun dontRemoveUnfinishedEntryWhenCreatingSnapshot() { val creator = cache.edit("k1")!! creator.setString(0, "ABC") creator.setString(1, "DE") @@ -1986,10 +1772,8 @@ class DiskLruCacheTest { snapshotAfterCommit.next().close() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `Windows cannot read while writing`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `Windows cannot read while writing`() { Assumptions.assumeTrue(windows) set("k1", "a", "a") @@ -1998,10 +1782,8 @@ class DiskLruCacheTest { editor.commit() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `Windows cannot write while reading`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `Windows cannot write while reading`() { Assumptions.assumeTrue(windows) set("k1", "a", "a") @@ -2010,10 +1792,8 @@ class DiskLruCacheTest { snapshot.close() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `can read while reading`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `can read while reading`() { set("k1", "a", "a") cache["k1"]!!.use { snapshot1 -> snapshot1.assertValue(0, "a") @@ -2025,10 +1805,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `remove while reading creates zombie that is removed when read finishes`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `remove while reading creates zombie that is removed when read finishes`() { val afterRemoveFileContents = if (windows) "a" else null set("k1", "a", "a") @@ -2051,10 +1829,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `remove while writing creates zombie that is removed when write finishes`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `remove while writing creates zombie that is removed when write finishes`() { val afterRemoveFileContents = if (windows) "a" else null set("k1", "a", "a") @@ -2072,10 +1848,8 @@ class DiskLruCacheTest { assertThat(readFileOrNull(getDirtyFile("k1", 0))).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `Windows cannot read zombie entry`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `Windows cannot read zombie entry`() { Assumptions.assumeTrue(windows) set("k1", "a", "a") @@ -2085,10 +1859,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `Windows cannot write zombie entry`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `Windows cannot write zombie entry`() { Assumptions.assumeTrue(windows) set("k1", "a", "a") @@ -2098,10 +1870,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `removed entry absent when iterating`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `removed entry absent when iterating`() { set("k1", "a", "a") cache["k1"]!!.use { cache.remove("k1") @@ -2110,10 +1880,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `close with zombie read`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `close with zombie read`() { val afterRemoveFileContents = if (windows) "a" else null set("k1", "a", "a") @@ -2133,10 +1901,8 @@ class DiskLruCacheTest { } } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `close with zombie write`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `close with zombie write`() { val afterRemoveCleanFileContents = if (windows) "a" else null val afterRemoveDirtyFileContents = if (windows) "" else null @@ -2157,10 +1923,8 @@ class DiskLruCacheTest { assertThat(readFileOrNull(getDirtyFile("k1", 0))).isNull() } - @ParameterizedTest - @ArgumentsSource(FileSystemParamProvider::class) - fun `close with completed zombie write`(parameters: Pair) { - setUp(parameters.first, parameters.second) + @Test + fun `close with completed zombie write`() { val afterRemoveCleanFileContents = if (windows) "a" else null val afterRemoveDirtyFileContents = if (windows) "b" else null @@ -2365,4 +2129,31 @@ class DiskLruCacheTest { writer.writeUtf8(value) } } + + enum class Subject { + System { + override fun create() = FileSystem.SYSTEM + + override val windows: Boolean + get() = TestUtil.windows + }, + + FakeUnix { + override fun create() = FakeFileSystem().apply { emulateUnix() } + + override val windows: Boolean + get() = false + }, + + FakeWindows { + override fun create() = FakeFileSystem().apply { emulateWindows() } + + override val windows: Boolean + get() = true + }, ; + + abstract fun create(): FileSystem + + abstract val windows: Boolean + } } diff --git a/okhttp/src/jvmTest/kotlin/okhttp3/internal/http/CancelTest.kt b/okhttp/src/jvmTest/kotlin/okhttp3/internal/http/CancelTest.kt index 569abda83..24a08d6c4 100644 --- a/okhttp/src/jvmTest/kotlin/okhttp3/internal/http/CancelTest.kt +++ b/okhttp/src/jvmTest/kotlin/okhttp3/internal/http/CancelTest.kt @@ -15,6 +15,7 @@ */ package okhttp3.internal.http +import app.cash.burst.Burst import assertk.assertThat import assertk.assertions.contains import assertk.assertions.doesNotContain @@ -61,21 +62,22 @@ import okhttp3.testing.PlatformRule import okio.Buffer import okio.BufferedSink import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Tag +import org.junit.jupiter.api.Test import org.junit.jupiter.api.Timeout import org.junit.jupiter.api.extension.RegisterExtension -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ArgumentsSource @Timeout(30) @Tag("Slow") -class CancelTest { +@Burst +class CancelTest( + private val cancelMode: CancelMode = INTERRUPT, + private val connectionType: ConnectionType = H2, +) { @JvmField @RegisterExtension val platform = PlatformRule() - lateinit var cancelMode: CancelMode - lateinit var connectionType: ConnectionType - private var threadToCancel: Thread? = null enum class CancelMode { @@ -99,10 +101,8 @@ class CancelTest { val listener = RecordingEventListener() - fun setUp(mode: Pair) { - this.cancelMode = mode.first - this.connectionType = mode.second - + @BeforeEach + fun setUp() { if (connectionType == H2) { platform.assumeHttp2Support() } @@ -147,10 +147,8 @@ class CancelTest { threadToCancel = Thread.currentThread() } - @ParameterizedTest - @ArgumentsSource(CancelModelParamProvider::class) - fun cancelWritingRequestBody(mode: Pair) { - setUp(mode) + @Test + fun cancelWritingRequestBody() { server.enqueue(MockResponse()) val call = client.newCall( @@ -182,10 +180,8 @@ class CancelTest { } } - @ParameterizedTest - @ArgumentsSource(CancelModelParamProvider::class) - fun cancelReadingResponseBody(mode: Pair) { - setUp(mode) + @Test + fun cancelReadingResponseBody() { val responseBodySize = 8 * 1024 * 1024 // 8 MiB. server.enqueue( MockResponse @@ -211,10 +207,8 @@ class CancelTest { assertEquals(if (connectionType == H2) 1 else 0, client.connectionPool.connectionCount()) } - @ParameterizedTest - @ArgumentsSource(CancelModelParamProvider::class) - fun cancelAndFollowup(mode: Pair) { - setUp(mode) + @Test + fun cancelAndFollowup() { val responseBodySize = 8 * 1024 * 1024 // 8 MiB. server.enqueue( MockResponse diff --git a/okhttp/src/jvmTest/kotlin/okhttp3/internal/http2/HttpOverHttp2Test.kt b/okhttp/src/jvmTest/kotlin/okhttp3/internal/http2/HttpOverHttp2Test.kt index b6de0ac91..8485fc2e6 100644 --- a/okhttp/src/jvmTest/kotlin/okhttp3/internal/http2/HttpOverHttp2Test.kt +++ b/okhttp/src/jvmTest/kotlin/okhttp3/internal/http2/HttpOverHttp2Test.kt @@ -15,6 +15,8 @@ */ package okhttp3.internal.http2 +import app.cash.burst.Burst +import app.cash.burst.burstValues import assertk.assertThat import assertk.assertions.contains import assertk.assertions.hasMessage @@ -70,7 +72,6 @@ import okhttp3.Request import okhttp3.RequestBody import okhttp3.Response import okhttp3.Route -import okhttp3.SimpleProvider import okhttp3.TestLogHandler import okhttp3.TestUtil.assumeNotWindows import okhttp3.TestUtil.repeat @@ -91,22 +92,21 @@ import okio.fakefilesystem.FakeFileSystem import org.junit.jupiter.api.AfterEach import org.junit.jupiter.api.Assertions.assertArrayEquals import org.junit.jupiter.api.Assumptions.assumeTrue +import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Disabled import org.junit.jupiter.api.Tag +import org.junit.jupiter.api.Test import org.junit.jupiter.api.Timeout import org.junit.jupiter.api.extension.RegisterExtension -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ArgumentsSource /** Test how HTTP/2 interacts with HTTP features. */ @Timeout(60) @Flaky @Tag("Slow") -class HttpOverHttp2Test { - class ProtocolParamProvider : SimpleProvider() { - override fun arguments() = listOf(Protocol.H2_PRIOR_KNOWLEDGE, Protocol.HTTP_2) - } - +@Burst +class HttpOverHttp2Test( + val protocol: Protocol = burstValues(Protocol.H2_PRIOR_KNOWLEDGE, Protocol.HTTP_2), +) { @RegisterExtension val platform: PlatformRule = PlatformRule() @@ -124,7 +124,6 @@ class HttpOverHttp2Test { @StartStop private val server = MockWebServer() - private lateinit var protocol: Protocol private lateinit var client: OkHttpClient private val fileSystem: FakeFileSystem = FakeFileSystem() private val cache: Cache = Cache(fileSystem, "/tmp/cache".toPath(), Long.MAX_VALUE) @@ -136,8 +135,8 @@ class HttpOverHttp2Test { return clientTestRule } - fun setUp(protocol: Protocol) { - this.protocol = protocol + @BeforeEach + fun setUp() { platform.assumeNotOpenJSSE() if (protocol === Protocol.HTTP_2) { platform.assumeHttp2Support() @@ -171,10 +170,8 @@ class HttpOverHttp2Test { java.net.Authenticator.setDefault(null) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun get(protocol: Protocol) { - setUp(protocol) + @Test + fun get() { server.enqueue(MockResponse(body = "ABCDE")) val call = client.newCall(Request(server.url("/foo"))) val response = call.execute() @@ -188,10 +185,8 @@ class HttpOverHttp2Test { assertThat(request.headers[":authority"]).isEqualTo("${server.hostName}:${server.port}") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun get204Response(protocol: Protocol) { - setUp(protocol) + @Test + fun get204Response() { val responseWithoutBody = MockResponse .Builder() @@ -213,10 +208,8 @@ class HttpOverHttp2Test { assertThat(request.requestLine).isEqualTo("GET /foo HTTP/2") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun head(protocol: Protocol) { - setUp(protocol) + @Test + fun head() { val mockResponse = MockResponse .Builder() @@ -244,10 +237,8 @@ class HttpOverHttp2Test { assertThat(request.requestLine).isEqualTo("HEAD /foo HTTP/2") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun emptyResponse(protocol: Protocol) { - setUp(protocol) + @Test + fun emptyResponse() { server.enqueue(MockResponse()) val call = client.newCall(Request(server.url("/foo"))) val response = call.execute() @@ -255,10 +246,8 @@ class HttpOverHttp2Test { response.body.close() } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun noDefaultContentLengthOnStreamingPost(protocol: Protocol) { - setUp(protocol) + @Test + fun noDefaultContentLengthOnStreamingPost() { val postBytes = "FGHIJ".toByteArray() server.enqueue(MockResponse(body = "ABCDE")) val call = @@ -283,10 +272,8 @@ class HttpOverHttp2Test { assertThat(request.headers["Content-Length"]).isNull() } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun userSuppliedContentLengthHeader(protocol: Protocol) { - setUp(protocol) + @Test + fun userSuppliedContentLengthHeader() { val postBytes = "FGHIJ".toByteArray() server.enqueue(MockResponse(body = "ABCDE")) val call = @@ -313,10 +300,8 @@ class HttpOverHttp2Test { assertThat(request.headers["Content-Length"]!!.toInt()).isEqualTo(postBytes.size) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun closeAfterFlush(protocol: Protocol) { - setUp(protocol) + @Test + fun closeAfterFlush() { val postBytes = "FGHIJ".toByteArray() server.enqueue(MockResponse(body = "ABCDE")) val call = @@ -345,10 +330,8 @@ class HttpOverHttp2Test { assertThat(request.headers["Content-Length"]!!.toInt()).isEqualTo(postBytes.size) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun connectionReuse(protocol: Protocol) { - setUp(protocol) + @Test + fun connectionReuse() { server.enqueue(MockResponse(body = "ABCDEF")) server.enqueue(MockResponse(body = "GHIJKL")) val call1 = client.newCall(Request(server.url("/r1"))) @@ -369,10 +352,8 @@ class HttpOverHttp2Test { response2.close() } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun connectionWindowUpdateAfterCanceling(protocol: Protocol) { - setUp(protocol) + @Test + fun connectionWindowUpdateAfterCanceling() { server.enqueue( MockResponse .Builder() @@ -410,10 +391,8 @@ class HttpOverHttp2Test { } } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun connectionWindowUpdateOnClose(protocol: Protocol) { - setUp(protocol) + @Test + fun connectionWindowUpdateOnClose() { server.enqueue( MockResponse .Builder() @@ -440,10 +419,8 @@ class HttpOverHttp2Test { assertThat(response2.body.string()).isEqualTo("abc") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun concurrentRequestWithEmptyFlowControlWindow(protocol: Protocol) { - setUp(protocol) + @Test + fun concurrentRequestWithEmptyFlowControlWindow() { server.enqueue( MockResponse .Builder() @@ -475,11 +452,9 @@ class HttpOverHttp2Test { } /** https://github.com/square/okhttp/issues/373 */ - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) + @Test @Disabled - fun synchronousRequest(protocol: Protocol) { - setUp(protocol) + fun synchronousRequest() { server.enqueue(MockResponse(body = "A")) server.enqueue(MockResponse(body = "A")) val executor = Executors.newCachedThreadPool(threadFactory("HttpOverHttp2Test")) @@ -491,10 +466,8 @@ class HttpOverHttp2Test { assertThat(server.takeRequest().exchangeIndex).isEqualTo(1) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun gzippedResponseBody(protocol: Protocol) { - setUp(protocol) + @Test + fun gzippedResponseBody() { server.enqueue( MockResponse .Builder() @@ -507,10 +480,8 @@ class HttpOverHttp2Test { assertThat(response.body.string()).isEqualTo("ABCABCABC") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun authenticate(protocol: Protocol) { - setUp(protocol) + @Test + fun authenticate() { server.enqueue( MockResponse( code = HttpURLConnection.HTTP_UNAUTHORIZED, @@ -537,10 +508,8 @@ class HttpOverHttp2Test { assertThat(accepted.headers["Authorization"]).isEqualTo(credential) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun redirect(protocol: Protocol) { - setUp(protocol) + @Test + fun redirect() { server.enqueue( MockResponse( code = HttpURLConnection.HTTP_MOVED_TEMP, @@ -558,10 +527,8 @@ class HttpOverHttp2Test { assertThat(request2.url.encodedPath).isEqualTo("/foo") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun readAfterLastByte(protocol: Protocol) { - setUp(protocol) + @Test + fun readAfterLastByte() { server.enqueue(MockResponse(body = "ABC")) val call = client.newCall(Request(server.url("/"))) val response = call.execute() @@ -574,10 +541,8 @@ class HttpOverHttp2Test { inputStream.close() } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun readResponseHeaderTimeout(protocol: Protocol) { - setUp(protocol) + @Test + fun readResponseHeaderTimeout() { server.enqueue(MockResponse.Builder().onResponseStart(Stall).build()) server.enqueue(MockResponse(body = "A")) client = @@ -609,10 +574,8 @@ class HttpOverHttp2Test { * case, we take a 4KiB body and throttle it to 1KiB/second. We set the read timeout to two * seconds. If our implementation is acting correctly, it will not throw, as it is progressing. */ - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun readTimeoutMoreGranularThanBodySize(protocol: Protocol) { - setUp(protocol) + @Test + fun readTimeoutMoreGranularThanBodySize() { val body = CharArray(4096) // 4KiB to read. Arrays.fill(body, 'y') server.enqueue( @@ -638,10 +601,8 @@ class HttpOverHttp2Test { * second. If our implementation is acting correctly, it will throw, as a byte doesn't arrive in * time. */ - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun readTimeoutOnSlowConnection(protocol: Protocol) { - setUp(protocol) + @Test + fun readTimeoutOnSlowConnection() { val body = repeat('y', 2048) server.enqueue( MockResponse @@ -678,10 +639,8 @@ class HttpOverHttp2Test { assertThat(server.takeRequest().exchangeIndex).isEqualTo(1) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun connectionTimeout(protocol: Protocol) { - setUp(protocol) + @Test + fun connectionTimeout() { server.enqueue( MockResponse .Builder() @@ -726,10 +685,8 @@ class HttpOverHttp2Test { assertThat(server.takeRequest().exchangeIndex).isEqualTo(1) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun responsesAreCached(protocol: Protocol) { - setUp(protocol) + @Test + fun responsesAreCached() { client = client .newBuilder() @@ -758,10 +715,8 @@ class HttpOverHttp2Test { assertThat(cache.hitCount()).isEqualTo(2) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun conditionalCache(protocol: Protocol) { - setUp(protocol) + @Test + fun conditionalCache() { client = client .newBuilder() @@ -790,10 +745,8 @@ class HttpOverHttp2Test { assertThat(cache.hitCount()).isEqualTo(1) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun responseCachedWithoutConsumingFullBody(protocol: Protocol) { - setUp(protocol) + @Test + fun responseCachedWithoutConsumingFullBody() { client = client .newBuilder() @@ -821,10 +774,8 @@ class HttpOverHttp2Test { response2.body.close() } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun sendRequestCookies(protocol: Protocol) { - setUp(protocol) + @Test + fun sendRequestCookies() { val cookieJar = RecordingCookieJar() val requestCookie = Cookie @@ -847,10 +798,8 @@ class HttpOverHttp2Test { assertThat(request.headers["Cookie"]).isEqualTo("a=b") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun receiveResponseCookies(protocol: Protocol) { - setUp(protocol) + @Test + fun receiveResponseCookies() { val cookieJar = RecordingCookieJar() client = client @@ -866,10 +815,8 @@ class HttpOverHttp2Test { cookieJar.assertResponseCookies("a=b; path=/") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun cancelWithStreamNotCompleted(protocol: Protocol) { - setUp(protocol) + @Test + fun cancelWithStreamNotCompleted() { server.enqueue(MockResponse(body = "abc")) server.enqueue(MockResponse(body = "def")) @@ -889,10 +836,8 @@ class HttpOverHttp2Test { response.close() } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun noRecoveryFromOneRefusedStream(protocol: Protocol) { - setUp(protocol) + @Test + fun noRecoveryFromOneRefusedStream() { server.enqueue( MockResponse .Builder() @@ -908,10 +853,8 @@ class HttpOverHttp2Test { } } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun recoverFromRefusedStreamWhenAnotherRouteExists(protocol: Protocol) { - setUp(protocol) + @Test + fun recoverFromRefusedStreamWhenAnotherRouteExists() { client = client .newBuilder() @@ -936,10 +879,8 @@ class HttpOverHttp2Test { assertThat(server.takeRequest().exchangeIndex).isEqualTo(1) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun noRecoveryWhenRoutesExhausted(protocol: Protocol) { - setUp(protocol) + @Test + fun noRecoveryWhenRoutesExhausted() { client = client .newBuilder() @@ -975,10 +916,8 @@ class HttpOverHttp2Test { assertThat(server.takeRequest().exchangeIndex).isEqualTo(0) // New connection. } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun connectionWithOneRefusedStreamIsPooled(protocol: Protocol) { - setUp(protocol) + @Test + fun connectionWithOneRefusedStreamIsPooled() { server.enqueue( MockResponse .Builder() @@ -1002,10 +941,8 @@ class HttpOverHttp2Test { assertThat(server.takeRequest().exchangeIndex).isEqualTo(1) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun connectionWithTwoRefusedStreamsIsNotPooled(protocol: Protocol) { - setUp(protocol) + @Test + fun connectionWithTwoRefusedStreamsIsNotPooled() { server.enqueue( MockResponse .Builder() @@ -1048,10 +985,8 @@ class HttpOverHttp2Test { * errors. The problem was that the logic that decided whether to reuse a route didn't track * certain HTTP/2 errors. https://github.com/square/okhttp/issues/5547 */ - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun noRecoveryFromTwoRefusedStreams(protocol: Protocol) { - setUp(protocol) + @Test + fun noRecoveryFromTwoRefusedStreams() { server.enqueue( MockResponse .Builder() @@ -1075,17 +1010,13 @@ class HttpOverHttp2Test { } } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun recoverFromOneInternalErrorRequiresNewConnection(protocol: Protocol) { - setUp(protocol) + @Test + fun recoverFromOneInternalErrorRequiresNewConnection() { recoverFromOneHttp2ErrorRequiresNewConnection(ErrorCode.INTERNAL_ERROR) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun recoverFromOneCancelRequiresNewConnection(protocol: Protocol) { - setUp(protocol) + @Test + fun recoverFromOneCancelRequiresNewConnection() { recoverFromOneHttp2ErrorRequiresNewConnection(ErrorCode.CANCEL) } @@ -1113,10 +1044,8 @@ class HttpOverHttp2Test { assertThat(c1e0.exchangeIndex).isEqualTo(0) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun recoverFromMultipleRefusedStreamsRequiresNewConnection(protocol: Protocol) { - setUp(protocol) + @Test + fun recoverFromMultipleRefusedStreamsRequiresNewConnection() { server.enqueue( MockResponse .Builder() @@ -1147,10 +1076,8 @@ class HttpOverHttp2Test { assertThat(server.takeRequest().exchangeIndex).isEqualTo(0) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun recoverFromCancelReusesConnection(protocol: Protocol) { - setUp(protocol) + @Test + fun recoverFromCancelReusesConnection() { val responseDequeuedLatches = listOf( // No synchronization for the last request, which is not canceled: @@ -1188,10 +1115,8 @@ class HttpOverHttp2Test { assertThat(server.takeRequest().exchangeIndex).isEqualTo(1) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun recoverFromMultipleCancelReusesConnection(protocol: Protocol) { - setUp(protocol) + @Test + fun recoverFromMultipleCancelReusesConnection() { val responseDequeuedLatches = Arrays.asList( CountDownLatch(1), @@ -1294,24 +1219,18 @@ class HttpOverHttp2Test { latch.await() } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun noRecoveryFromRefusedStreamWithRetryDisabled(protocol: Protocol) { - setUp(protocol) + @Test + fun noRecoveryFromRefusedStreamWithRetryDisabled() { noRecoveryFromErrorWithRetryDisabled(ErrorCode.REFUSED_STREAM) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun noRecoveryFromInternalErrorWithRetryDisabled(protocol: Protocol) { - setUp(protocol) + @Test + fun noRecoveryFromInternalErrorWithRetryDisabled() { noRecoveryFromErrorWithRetryDisabled(ErrorCode.INTERNAL_ERROR) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun noRecoveryFromCancelWithRetryDisabled(protocol: Protocol) { - setUp(protocol) + @Test + fun noRecoveryFromCancelWithRetryDisabled() { noRecoveryFromErrorWithRetryDisabled(ErrorCode.CANCEL) } @@ -1333,10 +1252,8 @@ class HttpOverHttp2Test { } } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun recoverFromConnectionNoNewStreamsOnFollowUp(protocol: Protocol) { - setUp(protocol) + @Test + fun recoverFromConnectionNoNewStreamsOnFollowUp() { server.enqueue(MockResponse(code = 401)) server.enqueue( MockResponse @@ -1410,10 +1327,8 @@ class HttpOverHttp2Test { assertThat(server.takeRequest().exchangeIndex).isEqualTo(2) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun nonAsciiResponseHeader(protocol: Protocol) { - setUp(protocol) + @Test + fun nonAsciiResponseHeader() { server.enqueue( MockResponse .Builder() @@ -1428,10 +1343,8 @@ class HttpOverHttp2Test { assertThat(response.header("β")).isEqualTo("Beta") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun serverSendsPushPromise_GET(protocol: Protocol) { - setUp(protocol) + @Test + fun serverSendsPushPromise_GET() { val pushPromise = PushPromise( "GET", @@ -1462,10 +1375,8 @@ class HttpOverHttp2Test { assertThat(pushedRequest.headers["foo"]).isEqualTo("bar") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun serverSendsPushPromise_HEAD(protocol: Protocol) { - setUp(protocol) + @Test + fun serverSendsPushPromise_HEAD() { val pushPromise = PushPromise( "HEAD", @@ -1496,10 +1407,8 @@ class HttpOverHttp2Test { assertThat(pushedRequest.headers["foo"]).isEqualTo("bar") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun noDataFramesSentWithNullRequestBody(protocol: Protocol) { - setUp(protocol) + @Test + fun noDataFramesSentWithNullRequestBody() { server.enqueue(MockResponse(body = "ABC")) val call = client.newCall( @@ -1517,10 +1426,8 @@ class HttpOverHttp2Test { .contains("HEADERS END_STREAM|END_HEADERS") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun emptyDataFrameSentWithEmptyBody(protocol: Protocol) { - setUp(protocol) + @Test + fun emptyDataFrameSentWithEmptyBody() { server.enqueue(MockResponse(body = "ABC")) val call = client.newCall( @@ -1545,10 +1452,8 @@ class HttpOverHttp2Test { .isEqualTo(1) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun pingsTransmitted(protocol: Protocol) { - setUp(protocol) + @Test + fun pingsTransmitted() { // Ping every 500 ms, starting at 500 ms. client = client @@ -1581,10 +1486,8 @@ class HttpOverHttp2Test { .isEqualTo(1) } - @Flaky @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun missingPongsFailsConnection(protocol: Protocol) { - setUp(protocol) + @Test + fun missingPongsFailsConnection() { if (protocol === Protocol.HTTP_2) { // https://github.com/square/okhttp/issues/5221 platform.expectFailureOnJdkVersion(12) @@ -1623,10 +1526,8 @@ class HttpOverHttp2Test { .isEqualTo(0) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun streamTimeoutDegradesConnectionAfterNoPong(protocol: Protocol) { - setUp(protocol) + @Test + fun streamTimeoutDegradesConnectionAfterNoPong() { assumeNotWindows() client = client @@ -1669,10 +1570,8 @@ class HttpOverHttp2Test { } } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun oneStreamTimeoutDoesNotBreakConnection(protocol: Protocol) { - setUp(protocol) + @Test + fun oneStreamTimeoutDoesNotBreakConnection() { client = client .newBuilder() @@ -1748,10 +1647,8 @@ class HttpOverHttp2Test { * Push a setting that permits up to 2 concurrent streams, then make 3 concurrent requests and * confirm that the third concurrent request prepared a new connection. */ - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun settingsLimitsMaxConcurrentStreams(protocol: Protocol) { - setUp(protocol) + @Test + fun settingsLimitsMaxConcurrentStreams() { val settings = Settings() settings[Settings.MAX_CONCURRENT_STREAMS] = 2 @@ -1793,10 +1690,8 @@ class HttpOverHttp2Test { assertThat(server.takeRequest().exchangeIndex).isEqualTo(0) } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun connectionNotReusedAfterShutdown(protocol: Protocol) { - setUp(protocol) + @Test + fun connectionNotReusedAfterShutdown() { server.enqueue( MockResponse .Builder() @@ -1853,10 +1748,8 @@ class HttpOverHttp2Test { * This simulates a race condition where we receive a healthy HTTP/2 connection and just prior to * writing our request, we get a GOAWAY frame from the server. */ - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun connectionShutdownAfterHealthCheck(protocol: Protocol) { - setUp(protocol) + @Test + fun connectionShutdownAfterHealthCheck() { server.enqueue( MockResponse .Builder() @@ -1901,10 +1794,8 @@ class HttpOverHttp2Test { assertThat(server.takeRequest().exchangeIndex).isEqualTo(0) } - @Flaky @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun responseHeadersAfterGoaway(protocol: Protocol) { - setUp(protocol) + @Test + fun responseHeadersAfterGoaway() { server.enqueue( MockResponse .Builder() @@ -1968,10 +1859,8 @@ class HttpOverHttp2Test { * * This test uses proxy tunnels to get a hook while a connection is being established. */ - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun concurrentHttp2ConnectionsDeduplicated(protocol: Protocol) { - setUp(protocol) + @Test + fun concurrentHttp2ConnectionsDeduplicated() { assumeTrue(protocol === Protocol.HTTP_2) server.useHttps(handshakeCertificates.sslSocketFactory()) val queueDispatcher = QueueDispatcher() @@ -2049,10 +1938,8 @@ class HttpOverHttp2Test { } /** https://github.com/square/okhttp/issues/3103 */ - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun domainFronting(protocol: Protocol) { - setUp(protocol) + @Test + fun domainFronting() { client = client .newBuilder() @@ -2106,10 +1993,8 @@ class HttpOverHttp2Test { } /** https://github.com/square/okhttp/issues/4875 */ - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun shutdownAfterLateCoalescing(protocol: Protocol) { - setUp(protocol) + @Test + fun shutdownAfterLateCoalescing() { val latch = CountDownLatch(2) val callback: Callback = object : Callback { @@ -2159,10 +2044,8 @@ class HttpOverHttp2Test { latch.await() } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun cancelWhileWritingRequestBodySendsCancelToServer(protocol: Protocol) { - setUp(protocol) + @Test + fun cancelWhileWritingRequestBodySendsCancelToServer() { server.enqueue(MockResponse()) val callReference = AtomicReference() val call = @@ -2189,10 +2072,8 @@ class HttpOverHttp2Test { assertThat(recordedRequest.failure!!).hasMessage("stream was reset: CANCEL") } - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun http2WithProxy(protocol: Protocol) { - setUp(protocol) + @Test + fun http2WithProxy() { server.enqueue( MockResponse .Builder() @@ -2231,10 +2112,8 @@ class HttpOverHttp2Test { } /** Respond to a proxy authorization challenge. */ - @ParameterizedTest - @ArgumentsSource(ProtocolParamProvider::class) - fun proxyAuthenticateOnConnect(protocol: Protocol) { - setUp(protocol) + @Test + fun proxyAuthenticateOnConnect() { server.enqueue( MockResponse .Builder()