diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 536df406..8fad6778 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -41,9 +41,9 @@ dependencies {
   api(libs.kotlin.stdlib)
   api(libs.kotlin.compilerEmbeddable)
   implementation(libs.ec4j)
-  testImplementation(libs.kotlin.test.junit4)
-  testImplementation(libs.googleTruth)
-  testImplementation(libs.junit)
+  testImplementation(platform(libs.junit.bom))
+  testImplementation(libs.junit.jupiter)
+  testRuntimeOnly(libs.junit.platform.launcher)
 }
 
 val generateSources by tasks.registering {
@@ -53,7 +53,10 @@ val generateSources by tasks.registering {
 
 tasks {
   // Run tests with UTF-16 encoding
-  test { jvmArgs("-Dfile.encoding=UTF-16") }
+  test {
+    useJUnitPlatform()
+    jvmArgs("-Dfile.encoding=UTF-16")
+  }
 
   // Handle multiple versions of Kotlin here
   withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
diff --git a/core/src/test/java/com/facebook/ktfmt/cli/EditorConfigResolverTest.kt b/core/src/test/java/com/facebook/ktfmt/cli/EditorConfigResolverTest.kt
index 407d0c3c..2c4063a0 100644
--- a/core/src/test/java/com/facebook/ktfmt/cli/EditorConfigResolverTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/cli/EditorConfigResolverTest.kt
@@ -19,29 +19,26 @@ package com.facebook.ktfmt.cli
 import com.facebook.ktfmt.format.Formatter
 import com.facebook.ktfmt.format.TrailingCommaManagementStrategy
 import com.facebook.ktfmt.format.TrailingCommaManagementStrategy.ONLY_ADD
-import com.google.common.truth.Truth.assertThat
 import java.nio.charset.Charset
 import java.nio.charset.StandardCharsets
 import kotlin.io.path.createTempDirectory
 import kotlin.text.Charsets.UTF_8
-import org.junit.After
-import org.junit.Before
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
 
 @Suppress("FunctionNaming")
-@RunWith(JUnit4::class)
 class EditorConfigResolverTest {
   private val root = createTempDirectory().toFile()
   private val testCharset = StandardCharsets.UTF_16
 
-  @Before
+  @BeforeEach
   fun setUp() {
-    assertThat(Charset.defaultCharset()).isEqualTo(testCharset) // Verify the test JVM flags
+    assertEquals(testCharset, Charset.defaultCharset()) // Verify the test JVM flags
   }
 
-  @After
+  @AfterEach
   fun tearDown() {
     root.deleteRecursively()
   }
@@ -52,7 +49,7 @@ class EditorConfigResolverTest {
     src.parentFile.mkdirs()
     src.writeText("", UTF_8)
     val resolved = EditorConfigResolver.resolveFormattingOptions(src, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT)
+    assertEquals(Formatter.GOOGLE_FORMAT, resolved)
   }
 
   @Test
@@ -69,7 +66,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT)
+    assertEquals(Formatter.GOOGLE_FORMAT, resolved)
   }
 
   @Test
@@ -86,7 +83,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT.copy(maxWidth = 80))
+    assertEquals(Formatter.GOOGLE_FORMAT.copy(maxWidth = 80), resolved)
   }
 
   @Test
@@ -103,7 +100,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT)
+    assertEquals(Formatter.GOOGLE_FORMAT, resolved)
   }
 
   @Test
@@ -120,7 +117,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT.copy(blockIndent = 3))
+    assertEquals(Formatter.GOOGLE_FORMAT.copy(blockIndent = 3), resolved)
   }
 
   @Test
@@ -137,7 +134,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT)
+    assertEquals(Formatter.GOOGLE_FORMAT, resolved)
   }
 
   @Test
@@ -155,7 +152,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT.copy(blockIndent = 8))
+    assertEquals(Formatter.GOOGLE_FORMAT.copy(blockIndent = 8), resolved)
   }
 
   @Test
@@ -172,7 +169,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT.copy(blockIndent = 3))
+    assertEquals(Formatter.GOOGLE_FORMAT.copy(blockIndent = 3), resolved)
   }
 
   @Test
@@ -190,7 +187,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT.copy(blockIndent = 3))
+    assertEquals(Formatter.GOOGLE_FORMAT.copy(blockIndent = 3), resolved)
   }
 
   @Test
@@ -207,7 +204,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT.copy(continuationIndent = 3))
+    assertEquals(Formatter.GOOGLE_FORMAT.copy(continuationIndent = 3), resolved)
   }
 
   @Test
@@ -224,7 +221,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT.copy(continuationIndent = 3))
+    assertEquals(Formatter.GOOGLE_FORMAT.copy(continuationIndent = 3), resolved)
   }
 
   @Test
@@ -242,7 +239,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT.copy(continuationIndent = 3))
+    assertEquals(Formatter.GOOGLE_FORMAT.copy(continuationIndent = 3), resolved)
   }
 
   @Test
@@ -259,8 +256,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved)
-        .isEqualTo(Formatter.GOOGLE_FORMAT.copy(trailingCommaManagementStrategy = ONLY_ADD))
+    assertEquals(Formatter.GOOGLE_FORMAT.copy(trailingCommaManagementStrategy = ONLY_ADD), resolved)
   }
 
   @Test
@@ -277,7 +273,7 @@ class EditorConfigResolverTest {
 
     val file = root.resolve("src/main/kotlin/Example.kt")
     val resolved = EditorConfigResolver.resolveFormattingOptions(file, Formatter.GOOGLE_FORMAT)
-    assertThat(resolved).isEqualTo(Formatter.GOOGLE_FORMAT)
+    assertEquals(Formatter.GOOGLE_FORMAT, resolved)
   }
 
   @Test
@@ -340,23 +336,33 @@ class EditorConfigResolverTest {
         )
 
     val fileInRoot = root.resolve("build.gradle.kts")
-    assertThat(EditorConfigResolver.resolveFormattingOptions(fileInRoot, Formatter.GOOGLE_FORMAT))
-        .isEqualTo(rootOptions)
+    assertEquals(
+        rootOptions,
+        EditorConfigResolver.resolveFormattingOptions(fileInRoot, Formatter.GOOGLE_FORMAT),
+    )
 
     val fileInMain = root.resolve("src/main/kotlin/Example.kt")
-    assertThat(EditorConfigResolver.resolveFormattingOptions(fileInMain, Formatter.GOOGLE_FORMAT))
-        .isEqualTo(mainOptions)
+    assertEquals(
+        mainOptions,
+        EditorConfigResolver.resolveFormattingOptions(fileInMain, Formatter.GOOGLE_FORMAT),
+    )
 
     val fileInTest = root.resolve("src/test/kotlin/ExampleTest.kt")
-    assertThat(EditorConfigResolver.resolveFormattingOptions(fileInTest, Formatter.GOOGLE_FORMAT))
-        .isEqualTo(testOptions)
+    assertEquals(
+        testOptions,
+        EditorConfigResolver.resolveFormattingOptions(fileInTest, Formatter.GOOGLE_FORMAT),
+    )
 
     val ktsInMain = root.resolve("src/main/kotlin/ExampleTest.kts")
-    assertThat(EditorConfigResolver.resolveFormattingOptions(ktsInMain, Formatter.GOOGLE_FORMAT))
-        .isEqualTo(rootOptions.copy(maxWidth = 120))
+    assertEquals(
+        rootOptions.copy(maxWidth = 120),
+        EditorConfigResolver.resolveFormattingOptions(ktsInMain, Formatter.GOOGLE_FORMAT),
+    )
 
     val ktsInTest = root.resolve("src/test/kotlin/ExampleTest.kts")
-    assertThat(EditorConfigResolver.resolveFormattingOptions(ktsInTest, Formatter.GOOGLE_FORMAT))
-        .isEqualTo(Formatter.GOOGLE_FORMAT) // root=true stops even non-matching fall-through
+    assertEquals(
+        Formatter.GOOGLE_FORMAT,
+        EditorConfigResolver.resolveFormattingOptions(ktsInTest, Formatter.GOOGLE_FORMAT),
+    ) // root=true stops even non-matching fall-through
   }
 }
diff --git a/core/src/test/java/com/facebook/ktfmt/cli/MainTest.kt b/core/src/test/java/com/facebook/ktfmt/cli/MainTest.kt
index 4d08a796..22049f7f 100644
--- a/core/src/test/java/com/facebook/ktfmt/cli/MainTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/cli/MainTest.kt
@@ -16,7 +16,9 @@
 
 package com.facebook.ktfmt.cli
 
-import com.google.common.truth.Truth.assertThat
+import com.facebook.ktfmt.testutil.assertContains
+import com.facebook.ktfmt.testutil.assertDoesNotContain
+import com.facebook.ktfmt.testutil.assertStartsWith
 import java.io.ByteArrayOutputStream
 import java.io.PrintStream
 import java.nio.charset.Charset
@@ -25,14 +27,13 @@ import java.nio.charset.StandardCharsets.UTF_8
 import java.nio.file.Files
 import java.util.concurrent.ForkJoinPool
 import kotlin.io.path.createTempDirectory
-import org.junit.After
-import org.junit.Before
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
 
 @Suppress("FunctionNaming")
-@RunWith(JUnit4::class)
 class MainTest {
 
   private val root = createTempDirectory().toFile()
@@ -43,12 +44,12 @@ class MainTest {
 
   private val testCharset = StandardCharsets.UTF_16
 
-  @Before
+  @BeforeEach
   fun setUp() {
-    assertThat(Charset.defaultCharset()).isEqualTo(testCharset) // Verify the test JVM flags
+    assertEquals(testCharset, Charset.defaultCharset()) // Verify the test JVM flags
   }
 
-  @After
+  @AfterEach
   fun tearDown() {
     root.deleteRecursively()
   }
@@ -61,13 +62,13 @@ class MainTest {
   fun `expandArgsToFileNames - single file arg is used as is`() {
     val fooBar = root.resolve("foo.bar")
     fooBar.writeText("hi", UTF_8)
-    assertThat(Main.expandArgsToFileNames(listOf(fooBar.toString()))).containsExactly(fooBar)
+    assertEquals(listOf(fooBar), Main.expandArgsToFileNames(listOf(fooBar.toString())))
   }
 
   @Test
   fun `expandArgsToFileNames - single arg which is not a file is not returned`() {
     val fooBar = root.resolve("foo.bar")
-    assertThat(Main.expandArgsToFileNames(listOf(fooBar.toString()))).isEmpty()
+    assertTrue(Main.expandArgsToFileNames(listOf(fooBar.toString())).isEmpty())
   }
 
   @Test
@@ -78,7 +79,7 @@ class MainTest {
     foo.writeText("", UTF_8)
     val bar = dir.resolve("bar.kt")
     bar.writeText("", UTF_8)
-    assertThat(Main.expandArgsToFileNames(listOf(dir.toString()))).containsExactly(foo, bar)
+    assertEquals(setOf(foo, bar), Main.expandArgsToFileNames(listOf(dir.toString())).toSet())
   }
 
   @Test
@@ -97,8 +98,10 @@ class MainTest {
     val bar2 = dir1.resolve("bar2.kt")
     bar2.writeText("", UTF_8)
 
-    assertThat(Main.expandArgsToFileNames(listOf(dir1.toString(), dir2.toString())))
-        .containsExactly(foo1, bar1, foo2, bar2)
+    assertEquals(
+        setOf(foo1, bar1, foo2, bar2),
+        Main.expandArgsToFileNames(listOf(dir1.toString(), dir2.toString())).toSet(),
+    )
   }
 
   @Test
@@ -107,7 +110,7 @@ class MainTest {
     Main(code.byteInputStream(), PrintStream(out), PrintStream(err), arrayOf("-")).run()
 
     val expected = "fun f1(): Int = 0\n"
-    assertThat(out.toString(UTF_8)).isEqualTo(expected)
+    assertEquals(expected, out.toString(UTF_8))
   }
 
   @Test
@@ -116,8 +119,8 @@ class MainTest {
     val returnValue =
         Main(code.byteInputStream(), PrintStream(out), PrintStream(err), arrayOf("-")).run()
 
-    assertThat(returnValue).isEqualTo(1)
-    assertThat(err.toString(testCharset)).startsWith("<stdin>:1:14: error: ")
+    assertEquals(1, returnValue)
+    assertStartsWith(err.toString(testCharset), "<stdin>:1:14: error: ")
   }
 
   @Test
@@ -131,8 +134,8 @@ class MainTest {
     )
         .run()
 
-    assertThat(returnValue).isEqualTo(1)
-    assertThat(err.toString(testCharset)).startsWith("file/Foo.kt:1:14: error: ")
+    assertEquals(1, returnValue)
+    assertStartsWith(err.toString(testCharset), "file/Foo.kt:1:14: error: ")
   }
 
   @Test
@@ -142,8 +145,8 @@ class MainTest {
     val returnValue =
         Main(emptyInput, PrintStream(out), PrintStream(err), arrayOf(fooBar.toString())).run()
 
-    assertThat(returnValue).isEqualTo(1)
-    assertThat(err.toString(testCharset)).contains("foo.kt:1:14: error: ")
+    assertEquals(1, returnValue)
+    assertContains(err.toString(testCharset), "foo.kt:1:14: error: ")
   }
 
   @Test
@@ -153,9 +156,11 @@ class MainTest {
     val returnValue =
         Main(emptyInput, PrintStream(out), PrintStream(err), arrayOf(fooBar.toString())).run()
 
-    assertThat(returnValue).isEqualTo(1)
-    assertThat(err.toString(testCharset))
-        .contains("foo.kt:1:21: error: Maximum one trailing lambda is allowed")
+    assertEquals(1, returnValue)
+    assertContains(
+        err.toString(testCharset),
+        "foo.kt:1:21: error: Maximum one trailing lambda is allowed",
+    )
   }
 
   @Test
@@ -183,10 +188,10 @@ class MainTest {
             }
             .get()
 
-    assertThat(returnValue).isEqualTo(1)
-    assertThat(err.toString(testCharset)).contains("Done formatting $file1")
-    assertThat(err.toString(testCharset)).contains("file2.kt:1:14: error: ")
-    assertThat(err.toString(testCharset)).contains("Done formatting $file3")
+    assertEquals(1, returnValue)
+    assertContains(err.toString(testCharset), "Done formatting $file1")
+    assertContains(err.toString(testCharset), "file2.kt:1:14: error: ")
+    assertContains(err.toString(testCharset), "Done formatting $file3")
   }
 
   @Test
@@ -202,8 +207,7 @@ class MainTest {
     val lastModifiedTimeAfterRunningFormatter =
         Files.getLastModifiedTime(formattedFilePath).toMillis()
 
-    assertThat(lastModifiedTimeBeforeRunningFormatter)
-        .isEqualTo(lastModifiedTimeAfterRunningFormatter)
+    assertEquals(lastModifiedTimeAfterRunningFormatter, lastModifiedTimeBeforeRunningFormatter)
   }
 
   @Test
@@ -221,8 +225,7 @@ class MainTest {
     val lastModifiedTimeAfterRunningFormatter =
         Files.getLastModifiedTime(unformattedFilePath).toMillis()
 
-    assertThat(lastModifiedTimeBeforeRunningFormatter)
-        .isLessThan(lastModifiedTimeAfterRunningFormatter)
+    assertTrue(lastModifiedTimeBeforeRunningFormatter < lastModifiedTimeAfterRunningFormatter)
   }
 
   @Test
@@ -246,7 +249,7 @@ class MainTest {
     )
         .run()
 
-    assertThat(fooBar.readText()).isEqualTo(code)
+    assertEquals(code, fooBar.readText())
   }
 
   @Test
@@ -279,7 +282,7 @@ class MainTest {
     )
         .run()
 
-    assertThat(out.toString(UTF_8)).isEqualTo(formatted)
+    assertEquals(formatted, out.toString(UTF_8))
   }
 
   @Test
@@ -299,8 +302,10 @@ class MainTest {
     for (f in files) {
       f.createNewFile()
     }
-    assertThat(Main.expandArgsToFileNames(files.map { it.toString() }))
-        .containsExactly(f1, f2, f5, f6, f7)
+    assertEquals(
+        setOf(f1, f2, f5, f6, f7),
+        Main.expandArgsToFileNames(files.map { it.toString() }).toSet(),
+    )
   }
 
   @Test
@@ -314,7 +319,7 @@ class MainTest {
         arrayOf("-"),
     )
         .run()
-    assertThat(out.toString(UTF_8)).isEqualTo(expected)
+    assertEquals(expected, out.toString(UTF_8))
 
     out.reset()
 
@@ -325,7 +330,7 @@ class MainTest {
         arrayOf("-"),
     )
         .run()
-    assertThat(out.toString(UTF_8)).isEqualTo(expected)
+    assertEquals(expected, out.toString(UTF_8))
   }
 
   @Test
@@ -337,8 +342,8 @@ class MainTest {
     Main(emptyInput, PrintStream(out), PrintStream(err), arrayOf("--dry-run", file.toString()))
         .run()
 
-    assertThat(file.readText()).isEqualTo(code)
-    assertThat(out.toString(testCharset)).contains(file.toString())
+    assertEquals(code, file.readText())
+    assertContains(out.toString(testCharset), file.toString())
   }
 
   @Test
@@ -348,8 +353,8 @@ class MainTest {
     Main(code.byteInputStream(), PrintStream(out), PrintStream(err), arrayOf("--dry-run", "-"))
         .run()
 
-    assertThat(out.toString(UTF_8)).doesNotContain("hello, world")
-    assertThat(out.toString(testCharset)).isEqualTo("<stdin>${System.lineSeparator()}")
+    assertDoesNotContain(out.toString(UTF_8), "hello, world")
+    assertEquals("<stdin>${System.lineSeparator()}", out.toString(testCharset))
   }
 
   @Test
@@ -361,7 +366,7 @@ class MainTest {
     Main(emptyInput, PrintStream(out), PrintStream(err), arrayOf("--dry-run", file.toString()))
         .run()
 
-    assertThat(out.toString(UTF_8)).isEmpty()
+    assertEquals("", out.toString(UTF_8))
   }
 
   @Test
@@ -371,7 +376,7 @@ class MainTest {
     Main(code.byteInputStream(), PrintStream(out), PrintStream(err), arrayOf("--dry-run", "-"))
         .run()
 
-    assertThat(out.toString(UTF_8)).isEmpty()
+    assertEquals("", out.toString(UTF_8))
   }
 
   @Test
@@ -383,7 +388,7 @@ class MainTest {
     val exitCode =
         Main(emptyInput, PrintStream(out), PrintStream(err), arrayOf(file.toString())).run()
 
-    assertThat(exitCode).isEqualTo(0)
+    assertEquals(0, exitCode)
   }
 
   @Test
@@ -393,7 +398,7 @@ class MainTest {
     val exitCode =
         Main(code.byteInputStream(), PrintStream(out), PrintStream(err), arrayOf("-")).run()
 
-    assertThat(exitCode).isEqualTo(0)
+    assertEquals(0, exitCode)
   }
 
   @Test
@@ -410,7 +415,7 @@ class MainTest {
     )
         .run()
 
-    assertThat(exitCode).isEqualTo(1)
+    assertEquals(1, exitCode)
   }
 
   @Test
@@ -425,7 +430,7 @@ class MainTest {
     )
         .run()
 
-    assertThat(exitCode).isEqualTo(1)
+    assertEquals(1, exitCode)
   }
 
   @Test
@@ -442,9 +447,9 @@ class MainTest {
     )
         .run()
 
-    assertThat(file.readText()).isEqualTo(code)
-    assertThat(out.toString(testCharset)).contains(file.toString())
-    assertThat(exitCode).isEqualTo(1)
+    assertEquals(code, file.readText())
+    assertContains(out.toString(testCharset), file.toString())
+    assertEquals(1, exitCode)
   }
 
   @Test
@@ -459,9 +464,9 @@ class MainTest {
     )
         .run()
 
-    assertThat(out.toString(UTF_8)).doesNotContain("hello, world")
-    assertThat(out.toString(testCharset)).isEqualTo("<stdin>${System.lineSeparator()}")
-    assertThat(exitCode).isEqualTo(1)
+    assertDoesNotContain(out.toString(UTF_8), "hello, world")
+    assertEquals("<stdin>${System.lineSeparator()}", out.toString(testCharset))
+    assertEquals(1, exitCode)
   }
 
   @Test
@@ -477,8 +482,8 @@ class MainTest {
     )
         .run()
 
-    assertThat(exitCode).isEqualTo(0)
-    assertThat(out.toString(UTF_8)).isEqualTo(expected)
+    assertEquals(0, exitCode)
+    assertEquals(expected, out.toString(UTF_8))
   }
 
   @Test
@@ -495,8 +500,8 @@ class MainTest {
     )
         .run()
 
-    assertThat(exitCode).isEqualTo(0)
-    assertThat(file.readText(UTF_8)).isEqualTo("""fun f() = println("hello, world")""" + "\n")
+    assertEquals(0, exitCode)
+    assertEquals("""fun f() = println("hello, world")""" + "\n", file.readText(UTF_8))
   }
 
   @Test
@@ -513,8 +518,8 @@ class MainTest {
     )
         .run()
 
-    assertThat(exitCode).isEqualTo(0)
-    assertThat(file.readText(UTF_8)).isEqualTo("""fun f() = println("hello, world")""" + "\n")
+    assertEquals(0, exitCode)
+    assertEquals("""fun f() = println("hello, world")""" + "\n", file.readText(UTF_8))
   }
 
   @Test
@@ -527,7 +532,7 @@ class MainTest {
     )
         .run()
 
-    assertThat(exitCode).isEqualTo(0)
+    assertEquals(0, exitCode)
   }
 
   @Test
@@ -538,7 +543,7 @@ class MainTest {
 
     Main(emptyInput, PrintStream(out), PrintStream(err), arrayOf("--quiet", file.toString())).run()
 
-    assertThat(err.toString(testCharset)).doesNotContain("Done formatting")
+    assertDoesNotContain(err.toString(testCharset), "Done formatting")
   }
 
   @Test
@@ -549,8 +554,8 @@ class MainTest {
         Main(emptyInput, PrintStream(out), PrintStream(err), arrayOf("--quiet", fooBar.toString()))
             .run()
 
-    assertThat(returnValue).isEqualTo(1)
-    assertThat(err.toString(testCharset)).contains("foo.kt:1:14: error: ")
+    assertEquals(1, returnValue)
+    assertContains(err.toString(testCharset), "foo.kt:1:14: error: ")
   }
 
   @Test
@@ -572,19 +577,19 @@ class MainTest {
         Main(emptyInput, PrintStream(out), PrintStream(err), arrayOf("--lines=4", file.toString()))
             .run()
 
-    assertThat(exitCode).isEqualTo(0)
-    assertThat(file.readText(UTF_8))
-        .isEqualTo(
-            """
-            |fun untouched ( ) =   1
-            |
-            |fun test() {
-            |  val selected = 2
-            |  val adjacent    =   3
-            |}
-            |"""
-                .trimMargin(),
-        )
+    assertEquals(0, exitCode)
+    assertEquals(
+        """
+        |fun untouched ( ) =   1
+        |
+        |fun test() {
+        |  val selected = 2
+        |  val adjacent    =   3
+        |}
+        |"""
+            .trimMargin(),
+        file.readText(UTF_8),
+    )
   }
 
   @Test
@@ -604,19 +609,19 @@ class MainTest {
         Main(code.byteInputStream(), PrintStream(out), PrintStream(err), arrayOf("--lines=4", "-"))
             .run()
 
-    assertThat(exitCode).isEqualTo(0)
-    assertThat(out.toString(UTF_8))
-        .isEqualTo(
-            """
-            |fun untouched ( ) =   1
-            |
-            |fun test() {
-            |  val selected = 2
-            |  val adjacent    =   3
-            |}
-            |"""
-                .trimMargin(),
-        )
+    assertEquals(0, exitCode)
+    assertEquals(
+        """
+        |fun untouched ( ) =   1
+        |
+        |fun test() {
+        |  val selected = 2
+        |  val adjacent    =   3
+        |}
+        |"""
+            .trimMargin(),
+        out.toString(UTF_8),
+    )
   }
 
   @Test
@@ -638,21 +643,21 @@ class MainTest {
         Main(code.byteInputStream(), PrintStream(out), PrintStream(err), arrayOf("--lines=5", "-"))
             .run()
 
-    assertThat(exitCode).isEqualTo(0)
-    assertThat(out.toString(UTF_8))
-        .isEqualTo(
-            """
-            |class Sample {
-            |  fun untouched ( ) =   1
-            |
-            |  fun test() {
-            |    val selected = 2
-            |    val adjacent    =   3
-            |  }
-            |}
-            |"""
-                .trimMargin(),
-        )
+    assertEquals(0, exitCode)
+    assertEquals(
+        """
+        |class Sample {
+        |  fun untouched ( ) =   1
+        |
+        |  fun test() {
+        |    val selected = 2
+        |    val adjacent    =   3
+        |  }
+        |}
+        |"""
+            .trimMargin(),
+        out.toString(UTF_8),
+    )
   }
 
   @Test
@@ -676,22 +681,22 @@ class MainTest {
         Main(code.byteInputStream(), PrintStream(out), PrintStream(err), arrayOf("--lines=8", "-"))
             .run()
 
-    assertThat(exitCode).isEqualTo(0)
-    assertThat(out.toString(UTF_8))
-        .isEqualTo(
-            """
-            |import com.used.FooBarBaz as Baz
-            |import com.used.bar
-            |
-            |fun untouched ( ) =   1
-            |
-            |fun test() {
-            |  val selected = 2
-            |  Baz(bar)
-            |}
-            |"""
-                .trimMargin(),
-        )
+    assertEquals(0, exitCode)
+    assertEquals(
+        """
+        |import com.used.FooBarBaz as Baz
+        |import com.used.bar
+        |
+        |fun untouched ( ) =   1
+        |
+        |fun test() {
+        |  val selected = 2
+        |  Baz(bar)
+        |}
+        |"""
+            .trimMargin(),
+        out.toString(UTF_8),
+    )
   }
 
   @Test
@@ -721,29 +726,29 @@ class MainTest {
         Main(code.byteInputStream(), PrintStream(out), PrintStream(err), arrayOf("--lines=15", "-"))
             .run()
 
-    assertThat(exitCode).isEqualTo(0)
-    assertThat(out.toString(UTF_8))
-        .isEqualTo(
-            """
-            |val indent =
-            |    ""${'"'}
-            |    example
-            |     of
-            |       a
-            |
-            |    multiline
-            |      string
-            |    ""${'"'}
-            |        .trimIndent()
-            |
-            |fun untouched ( ) =   1
-            |
-            |fun test() {
-            |  val selected = 2
-            |}
-            |"""
-                .trimMargin(),
-        )
+    assertEquals(0, exitCode)
+    assertEquals(
+        """
+        |val indent =
+        |    ""${'"'}
+        |    example
+        |     of
+        |       a
+        |
+        |    multiline
+        |      string
+        |    ""${'"'}
+        |        .trimIndent()
+        |
+        |fun untouched ( ) =   1
+        |
+        |fun test() {
+        |  val selected = 2
+        |}
+        |"""
+            .trimMargin(),
+        out.toString(UTF_8),
+    )
   }
 
   @Test
@@ -773,19 +778,19 @@ class MainTest {
     )
         .run()
 
-    assertThat(exitCode).isEqualTo(0)
-    assertThat(file.readText(UTF_8))
-        .isEqualTo(
-            """
-            |fun untouched ( ) =   1
-            |
-            |fun test() {
-            |  val selected = 2
-            |  val adjacent    =   3
-            |}
-            |"""
-                .trimMargin(),
-        )
+    assertEquals(0, exitCode)
+    assertEquals(
+        """
+        |fun untouched ( ) =   1
+        |
+        |fun test() {
+        |  val selected = 2
+        |  val adjacent    =   3
+        |}
+        |"""
+            .trimMargin(),
+        file.readText(UTF_8),
+    )
   }
 
   @Test
@@ -809,19 +814,19 @@ class MainTest {
     )
         .run()
 
-    assertThat(exitCode).isEqualTo(0)
-    assertThat(out.toString(UTF_8))
-        .isEqualTo(
-            """
-            |fun untouched ( ) =   1
-            |
-            |fun test() {
-            |  val selected = 2
-            |  val adjacent    =   3
-            |}
-            |"""
-                .trimMargin(),
-        )
+    assertEquals(0, exitCode)
+    assertEquals(
+        """
+        |fun untouched ( ) =   1
+        |
+        |fun test() {
+        |  val selected = 2
+        |  val adjacent    =   3
+        |}
+        |"""
+            .trimMargin(),
+        out.toString(UTF_8),
+    )
   }
 
   @Test
@@ -835,8 +840,10 @@ class MainTest {
         Main(emptyInput, PrintStream(out), PrintStream(err), arrayOf("--lines=1", dir.toString()))
             .run()
 
-    assertThat(exitCode).isEqualTo(1)
-    assertThat(err.toString(testCharset))
-        .contains("partial formatting is only supported for a single file")
+    assertEquals(1, exitCode)
+    assertContains(
+        err.toString(testCharset),
+        "partial formatting is only supported for a single file",
+    )
   }
 }
diff --git a/core/src/test/java/com/facebook/ktfmt/cli/ParsedArgsTest.kt b/core/src/test/java/com/facebook/ktfmt/cli/ParsedArgsTest.kt
index 9ff57e06..c74010aa 100644
--- a/core/src/test/java/com/facebook/ktfmt/cli/ParsedArgsTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/cli/ParsedArgsTest.kt
@@ -18,25 +18,26 @@ package com.facebook.ktfmt.cli
 
 import com.facebook.ktfmt.format.Formatter
 import com.facebook.ktfmt.format.FormattingOptions
+import com.facebook.ktfmt.testutil.assertContains
 import com.google.common.collect.Range
 import com.google.common.collect.RangeSet
 import com.google.common.collect.TreeRangeSet
-import com.google.common.truth.Truth.assertThat
 import java.io.FileNotFoundException
 import kotlin.io.path.createTempDirectory
-import kotlin.test.assertFailsWith
-import org.junit.After
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertInstanceOf
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
 
 @Suppress("FunctionNaming")
-@RunWith(JUnit4::class)
 class ParsedArgsTest {
 
   private val root = createTempDirectory().toFile()
 
-  @After
+  @AfterEach
   fun tearDown() {
     root.deleteRecursively()
   }
@@ -44,13 +45,13 @@ class ParsedArgsTest {
   @Test
   fun `unknown flags return an error`() {
     val result = parseOptions("--unknown")
-    assertThat(result).isInstanceOf(ParseResult.Error::class.java)
+    assertInstanceOf(ParseResult.Error::class.java, result)
   }
 
   @Test
   fun `unknown flags starting with '@' return an error`() {
     val result = parseOptions("@unknown")
-    assertThat(result).isInstanceOf(ParseResult.Error::class.java)
+    assertInstanceOf(ParseResult.Error::class.java, result)
   }
 
   @Test
@@ -60,91 +61,93 @@ class ParsedArgsTest {
     val formattingOptions = parsed.formattingOptions
 
     val defaultFormattingOptions = Formatter.META_FORMAT
-    assertThat(formattingOptions).isEqualTo(defaultFormattingOptions)
+    assertEquals(defaultFormattingOptions, formattingOptions)
   }
 
   @Test
   fun `parseOptions recognizes --meta-style`() {
     val parsed = assertSucceeds(parseOptions("--meta-style", "foo.kt"))
-    assertThat(parsed.formattingOptions).isEqualTo(Formatter.META_FORMAT)
+    assertEquals(Formatter.META_FORMAT, parsed.formattingOptions)
   }
 
   @Test
   fun `parseOptions recognizes --google-style`() {
     val parsed = assertSucceeds(parseOptions("--google-style", "foo.kt"))
-    assertThat(parsed.formattingOptions).isEqualTo(Formatter.GOOGLE_FORMAT)
+    assertEquals(Formatter.GOOGLE_FORMAT, parsed.formattingOptions)
   }
 
   @Test
   fun `parseOptions recognizes --dry-run`() {
     val parsed = assertSucceeds(parseOptions("--dry-run", "foo.kt"))
-    assertThat(parsed.dryRun).isTrue()
+    assertTrue(parsed.dryRun)
   }
 
   @Test
   fun `parseOptions recognizes -n as --dry-run`() {
     val parsed = assertSucceeds(parseOptions("-n", "foo.kt"))
-    assertThat(parsed.dryRun).isTrue()
+    assertTrue(parsed.dryRun)
   }
 
   @Test
   fun `parseOptions recognizes --set-exit-if-changed`() {
     val parsed = assertSucceeds(parseOptions("--set-exit-if-changed", "foo.kt"))
-    assertThat(parsed.setExitIfChanged).isTrue()
+    assertTrue(parsed.setExitIfChanged)
   }
 
   @Test
   fun `parseOptions defaults to removing imports`() {
     val parsed = assertSucceeds(parseOptions("foo.kt"))
-    assertThat(parsed.formattingOptions.removeUnusedImports).isTrue()
+    assertTrue(parsed.formattingOptions.removeUnusedImports)
   }
 
   @Test
   fun `parseOptions recognizes --do-not-remove-unused-imports to removing imports`() {
     val parsed = assertSucceeds(parseOptions("--do-not-remove-unused-imports", "foo.kt"))
-    assertThat(parsed.formattingOptions.removeUnusedImports).isFalse()
+    assertFalse(parsed.formattingOptions.removeUnusedImports)
   }
 
   @Test
   fun `parseOptions recognizes --enable-editorconfig`() {
     val parsed = assertSucceeds(parseOptions("--enable-editorconfig", "foo.kt"))
-    assertThat(parsed.editorConfig).isEqualTo(true)
+    assertEquals(true, parsed.editorConfig)
   }
 
   @Test
   fun `parseOptions recognizes --quiet`() {
     val parsed = assertSucceeds(parseOptions("--quiet", "foo.kt"))
-    assertThat(parsed.quiet).isTrue()
+    assertTrue(parsed.quiet)
   }
 
   @Test
   fun `parseOptions recognizes --stdin-name`() {
     val parsed = assertSucceeds(parseOptions("--stdin-name=my/foo.kt", "-"))
-    assertThat(parsed.stdinName).isEqualTo("my/foo.kt")
+    assertEquals("my/foo.kt", parsed.stdinName)
   }
 
   @Test
   fun `parseOptions recognizes --lines ranges`() {
     val parsed = assertSucceeds(parseOptions("--lines=1:3,5", "--lines", "7", "foo.kt"))
 
-    assertThat(parsed.lineRanges)
-        .isEqualTo(
-            ranges(
-                Range.closedOpen(0, 3),
-                Range.closedOpen(4, 5),
-                Range.closedOpen(6, 7),
-            ),
-        )
+    assertEquals(
+        ranges(
+            Range.closedOpen(0, 3),
+            Range.closedOpen(4, 5),
+            Range.closedOpen(6, 7),
+        ),
+        parsed.lineRanges,
+    )
   }
 
   @Test
   fun `parseOptions recognizes --line alias`() {
     val parsed = assertSucceeds(parseOptions("--line=1", "foo.kt"))
-    assertThat(parsed.fileNames).containsExactly("foo.kt")
-    assertThat(parsed.lineRanges).isEqualTo(ranges(Range.closedOpen(0, 1)))
+    assertEquals(listOf("foo.kt"), parsed.fileNames)
+    assertEquals(ranges(Range.closedOpen(0, 1)), parsed.lineRanges)
 
-    assertThat(assertSucceeds(parseOptions("--line", "2", "foo.kt")).lineRanges)
-        .isEqualTo(ranges(Range.closedOpen(1, 2)))
+    assertEquals(
+        ranges(Range.closedOpen(1, 2)),
+        assertSucceeds(parseOptions("--line", "2", "foo.kt")).lineRanges,
+    )
   }
 
   @Test
@@ -161,133 +164,136 @@ class ParsedArgsTest {
         ),
     )
 
-    assertThat(parsed.characterRanges)
-        .isEqualTo(
-            ranges(
-                Range.closedOpen(10, 15),
-                Range.closedOpen(20, 21),
-            ),
-        )
+    assertEquals(
+        ranges(
+            Range.closedOpen(10, 15),
+            Range.closedOpen(20, 21),
+        ),
+        parsed.characterRanges,
+    )
   }
 
   @Test
   fun `parseOptions rejects --lines without value`() {
     val parseResult = parseOptions("--lines")
-    assertThat(parseResult)
-        .isEqualTo(ParseResult.Error("required value was not provided for: --lines"))
+    assertEquals(ParseResult.Error("required value was not provided for: --lines"), parseResult)
   }
 
   @Test
   fun `parseOptions rejects invalid --lines range`() {
     val parseResult = parseOptions("--lines=not-a-line", "foo.kt")
-    assertThat(parseResult)
-        .isEqualTo(ParseResult.Error("invalid line range for --lines: not-a-line"))
+    assertEquals(ParseResult.Error("invalid line range for --lines: not-a-line"), parseResult)
   }
 
   @Test
   fun `parseOptions rejects --offset without value`() {
     val parseResult = parseOptions("--offset")
-    assertThat(parseResult)
-        .isEqualTo(ParseResult.Error("required value was not provided for: --offset"))
+    assertEquals(ParseResult.Error("required value was not provided for: --offset"), parseResult)
   }
 
   @Test
   fun `parseOptions rejects invalid --offset`() {
     val parseResult = parseOptions("--offset=not-an-offset", "--length=1", "foo.kt")
-    assertThat(parseResult)
-        .isEqualTo(ParseResult.Error("invalid integer value for --offset: not-an-offset"))
+    assertEquals(
+        ParseResult.Error("invalid integer value for --offset: not-an-offset"),
+        parseResult,
+    )
   }
 
   @Test
   fun `parseOptions rejects mismatched --offset and --length counts`() {
     val parseResult = parseOptions("--offset=1", "foo.kt")
-    assertThat(parseResult)
-        .isEqualTo(
-            ParseResult.Error("--offset and --length flags must be provided in matching pairs"),
-        )
+    assertEquals(
+        ParseResult.Error("--offset and --length flags must be provided in matching pairs"),
+        parseResult,
+    )
   }
 
   @Test
   fun `parseOptions rejects --lines with multiple files`() {
     val parseResult = parseOptions("--lines=1", "foo.kt", "bar.kt")
-    assertThat(parseResult)
-        .isEqualTo(ParseResult.Error("partial formatting is only supported for a single file"))
+    assertEquals(
+        ParseResult.Error("partial formatting is only supported for a single file"),
+        parseResult,
+    )
   }
 
   @Test
   fun `parseOptions rejects --offset with multiple files`() {
     val parseResult = parseOptions("--offset=1", "--length=1", "foo.kt", "bar.kt")
-    assertThat(parseResult)
-        .isEqualTo(ParseResult.Error("partial formatting is only supported for a single file"))
+    assertEquals(
+        ParseResult.Error("partial formatting is only supported for a single file"),
+        parseResult,
+    )
   }
 
   @Test
   fun `parseOptions accepts --stdin-name with empty value`() {
     val parsed = assertSucceeds(parseOptions("--stdin-name=", "-"))
-    assertThat(parsed.stdinName).isEqualTo("")
+    assertEquals("", parsed.stdinName)
   }
 
   @Test
   fun `parseOptions rejects --stdin-name without value`() {
     val parseResult = parseOptions("--stdin-name")
-    assertThat(parseResult).isInstanceOf(ParseResult.Error::class.java)
+    assertInstanceOf(ParseResult.Error::class.java, parseResult)
   }
 
   @Test
   fun `parseOptions rejects '-' and files at the same time`() {
     val parseResult = parseOptions("-", "File.kt")
-    assertThat(parseResult).isInstanceOf(ParseResult.Error::class.java)
+    assertInstanceOf(ParseResult.Error::class.java, parseResult)
   }
 
   @Test
   fun `parseOptions rejects --stdin-name when not reading from stdin`() {
     val parseResult = parseOptions("--stdin-name=foo", "file1.kt")
-    assertThat(parseResult).isInstanceOf(ParseResult.Error::class.java)
+    assertInstanceOf(ParseResult.Error::class.java, parseResult)
   }
 
   @Test
   fun `parseOptions recognises --help`() {
     val parseResult = parseOptions("--help")
-    assertThat(parseResult).isInstanceOf(ParseResult.ShowMessage::class.java)
+    assertInstanceOf(ParseResult.ShowMessage::class.java, parseResult)
   }
 
   @Test
   fun `parseOptions recognises -h`() {
     val parseResult = parseOptions("-h")
-    assertThat(parseResult).isInstanceOf(ParseResult.ShowMessage::class.java)
+    assertInstanceOf(ParseResult.ShowMessage::class.java, parseResult)
   }
 
   @Test
   fun `arg --help overrides all others`() {
     val parseResult = parseOptions("--style=google", "@unknown", "--help", "file.kt")
-    assertThat(parseResult).isInstanceOf(ParseResult.ShowMessage::class.java)
+    assertInstanceOf(ParseResult.ShowMessage::class.java, parseResult)
   }
 
   @Test
   fun `parseOptions recognises --version`() {
     val parseResult = parseOptions("--version")
-    assertThat(parseResult).isInstanceOf(ParseResult.ShowMessage::class.java)
+    assertInstanceOf(ParseResult.ShowMessage::class.java, parseResult)
   }
 
   @Test
   fun `parseOptions recognises -v`() {
     val parseResult = parseOptions("-v")
-    assertThat(parseResult).isInstanceOf(ParseResult.ShowMessage::class.java)
+    assertInstanceOf(ParseResult.ShowMessage::class.java, parseResult)
   }
 
   @Test
   fun `arg --version overrides all others`() {
     val parseResult = parseOptions("--style=google", "@unknown", "--version", "file.kt")
-    assertThat(parseResult).isInstanceOf(ParseResult.ShowMessage::class.java)
+    assertInstanceOf(ParseResult.ShowMessage::class.java, parseResult)
   }
 
   @Test
   fun `processArgs use the @file option with non existing file`() {
     val e =
-        assertFailsWith<FileNotFoundException> {
+        assertThrows<FileNotFoundException> {
           ParsedArgs.processArgs(arrayOf("@non-existing-file"))
         }
-    assertThat(e.message).contains("non-existing-file")
+    assertContains(e.message, "non-existing-file")
   }
 
   @Test
@@ -296,14 +302,14 @@ class ParsedArgsTest {
     file.writeText("--google-style\n--dry-run\n--set-exit-if-changed\nFile1.kt\nFile2.kt\n")
 
     val result = ParsedArgs.processArgs(arrayOf("@" + file.canonicalPath))
-    assertThat(result).isInstanceOf(ParseResult.Ok::class.java)
+    assertInstanceOf(ParseResult.Ok::class.java, result)
 
     val parsed = (result as ParseResult.Ok).parsedValue
 
-    assertThat(parsed.formattingOptions).isEqualTo(Formatter.GOOGLE_FORMAT)
-    assertThat(parsed.dryRun).isTrue()
-    assertThat(parsed.setExitIfChanged).isTrue()
-    assertThat(parsed.fileNames).containsExactlyElementsIn(listOf("File1.kt", "File2.kt"))
+    assertEquals(Formatter.GOOGLE_FORMAT, parsed.formattingOptions)
+    assertTrue(parsed.dryRun)
+    assertTrue(parsed.setExitIfChanged)
+    assertEquals(listOf("File1.kt", "File2.kt"), parsed.fileNames)
   }
 
   @Test
@@ -314,39 +320,39 @@ class ParsedArgsTest {
         "--set-exit-if-changed",
         "File.kt",
     )
-    assertThat(testResult)
-        .isEqualTo(
-            parseResultOk(
-                fileNames = listOf("File.kt"),
-                formattingOptions = Formatter.GOOGLE_FORMAT,
-                dryRun = true,
-                setExitIfChanged = true,
-            ),
-        )
+    assertEquals(
+        parseResultOk(
+            fileNames = listOf("File.kt"),
+            formattingOptions = Formatter.GOOGLE_FORMAT,
+            dryRun = true,
+            setExitIfChanged = true,
+        ),
+        testResult,
+    )
   }
 
   @Test
   fun `last style in args wins`() {
     val testResult = parseOptions("--google-style", "--kotlinlang-style", "File.kt")
-    assertThat(testResult)
-        .isEqualTo(
-            parseResultOk(
-                fileNames = listOf("File.kt"),
-                formattingOptions = Formatter.KOTLINLANG_FORMAT,
-            ),
-        )
+    assertEquals(
+        parseResultOk(
+            fileNames = listOf("File.kt"),
+            formattingOptions = Formatter.KOTLINLANG_FORMAT,
+        ),
+        testResult,
+    )
   }
 
   @Test
   fun `error when parsing multiple args and one is unknown`() {
     val testResult = parseOptions("@unknown", "--google-style", "File.kt")
-    assertThat(testResult).isEqualTo(ParseResult.Error("Unexpected option: @unknown"))
+    assertEquals(ParseResult.Error("Unexpected option: @unknown"), testResult)
   }
 
   private fun parseOptions(vararg options: String): ParseResult = ParsedArgs.parseOptions(options)
 
   private fun assertSucceeds(parseResult: ParseResult): ParsedArgs {
-    assertThat(parseResult).isInstanceOf(ParseResult.Ok::class.java)
+    assertInstanceOf(ParseResult.Ok::class.java, parseResult)
     return (parseResult as ParseResult.Ok).parsedValue
   }
 
diff --git a/core/src/test/java/com/facebook/ktfmt/format/FormatterTest.kt b/core/src/test/java/com/facebook/ktfmt/format/FormatterTest.kt
index 57612b47..b7e52cd4 100644
--- a/core/src/test/java/com/facebook/ktfmt/format/FormatterTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/format/FormatterTest.kt
@@ -17,18 +17,17 @@
 package com.facebook.ktfmt.format
 
 import com.facebook.ktfmt.format.Formatter.META_FORMAT
+import com.facebook.ktfmt.testutil.assertContains
+import com.facebook.ktfmt.testutil.assertContainsMatch
 import com.facebook.ktfmt.testutil.assertFormatted
 import com.facebook.ktfmt.testutil.assertThatFormatting
 import com.facebook.ktfmt.testutil.defaultTestFormattingOptions
-import com.google.common.truth.Truth.assertThat
-import org.junit.Assert.fail
-import org.junit.BeforeClass
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.fail
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
 
 @Suppress("FunctionNaming")
-@RunWith(JUnit4::class)
 class FormatterTest {
 
   @Test
@@ -3693,9 +3692,9 @@ class FormatterTest {
       Formatter.format(code)
       fail()
     } catch (e: ParseError) {
-      assertThat(e.errorDescription).contains("\\u0003")
-      assertThat(e.lineColumn.line).isEqualTo(1)
-      assertThat(e.lineColumn.column).isEqualTo(5)
+      assertContains(e.errorDescription, "\\u0003")
+      assertEquals(1, e.lineColumn.line)
+      assertEquals(5, e.lineColumn.column)
     }
   }
 
@@ -5750,9 +5749,9 @@ class FormatterTest {
       Formatter.format(code)
       fail()
     } catch (e: ParseError) {
-      assertThat(e.lineColumn.line).isEqualTo(6)
-      assertThat(e.lineColumn.column).isEqualTo(0)
-      assertThat(e.errorDescription).containsMatch("Expecting an (expression|argument)")
+      assertEquals(6, e.lineColumn.line)
+      assertEquals(0, e.lineColumn.column)
+      assertContainsMatch(e.errorDescription, "Expecting an (expression|argument)")
     }
   }
 
@@ -5770,8 +5769,8 @@ class FormatterTest {
       Formatter.format(code)
       fail()
     } catch (e: ParseError) {
-      assertThat(e.lineColumn.line).isEqualTo(2)
-      assertThat(e.lineColumn.column).isEqualTo(8)
+      assertEquals(2, e.lineColumn.line)
+      assertEquals(8, e.lineColumn.column)
     }
   }
 
@@ -9699,7 +9698,7 @@ class FormatterTest {
     private const val TQ = "\"\"\""
 
     @JvmStatic
-    @BeforeClass
+    @BeforeAll
     fun setUp(): Unit {
       defaultTestFormattingOptions =
           META_FORMAT.copy(trailingCommaManagementStrategy = TrailingCommaManagementStrategy.NONE)
diff --git a/core/src/test/java/com/facebook/ktfmt/format/GoogleStyleFormatterKtTest.kt b/core/src/test/java/com/facebook/ktfmt/format/GoogleStyleFormatterKtTest.kt
index 45377751..22762e4d 100644
--- a/core/src/test/java/com/facebook/ktfmt/format/GoogleStyleFormatterKtTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/format/GoogleStyleFormatterKtTest.kt
@@ -19,13 +19,10 @@ package com.facebook.ktfmt.format
 import com.facebook.ktfmt.testutil.assertFormatted
 import com.facebook.ktfmt.testutil.assertThatFormatting
 import com.facebook.ktfmt.testutil.defaultTestFormattingOptions
-import org.junit.BeforeClass
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
 
 @Suppress("FunctionNaming")
-@RunWith(JUnit4::class)
 class GoogleStyleFormatterKtTest {
 
   @Test
@@ -1866,7 +1863,7 @@ class GoogleStyleFormatterKtTest {
     private const val TQ = "\"\"\""
 
     @JvmStatic
-    @BeforeClass
+    @BeforeAll
     fun setUp(): Unit {
       defaultTestFormattingOptions = Formatter.GOOGLE_FORMAT
     }
diff --git a/core/src/test/java/com/facebook/ktfmt/format/KotlinInputTest.kt b/core/src/test/java/com/facebook/ktfmt/format/KotlinInputTest.kt
index d965f058..22bda633 100644
--- a/core/src/test/java/com/facebook/ktfmt/format/KotlinInputTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/format/KotlinInputTest.kt
@@ -16,19 +16,15 @@
 
 package com.facebook.ktfmt.format
 
-import com.google.common.truth.Truth.assertThat
-import org.junit.Test
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
 
 class KotlinInputTest {
   @Test
   fun `Comments are toks not tokens`() {
     val code = "/** foo */ class F {}"
     val input = KotlinInput(code, Parser.parse(code))
-    assertThat(input.getTokens().map { it.tok.text })
-        .containsExactly("class", "F", "{", "}", "")
-        .inOrder()
-    assertThat(input.getTokens()[0].toksBefore.map { it.text })
-        .containsExactly("/** foo */", " ")
-        .inOrder()
+    assertEquals(listOf("class", "F", "{", "}", ""), input.getTokens().map { it.tok.text })
+    assertEquals(listOf("/** foo */", " "), input.getTokens()[0].toksBefore.map { it.text })
   }
 }
diff --git a/core/src/test/java/com/facebook/ktfmt/format/MultilineStringFormatterTest.kt b/core/src/test/java/com/facebook/ktfmt/format/MultilineStringFormatterTest.kt
index cc45b4c4..7aeb91ab 100644
--- a/core/src/test/java/com/facebook/ktfmt/format/MultilineStringFormatterTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/format/MultilineStringFormatterTest.kt
@@ -16,9 +16,11 @@
 
 package com.facebook.ktfmt.format
 
-import com.google.common.truth.Truth.assertThat
 import org.intellij.lang.annotations.Language
-import org.junit.Test
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
 
 class MultilineStringFormatterTest {
   private val TQ = "\"\"\""
@@ -34,26 +36,27 @@ class MultilineStringFormatterTest {
             "        .trimMargin()",
         ),
     ) {
-      assertThat(usesTrimMargin).isTrue()
-      assertThat(indentationSuffix).isEqualTo("|")
-      assertThat(isDollarString).isFalse()
-      assertThat(indentCount).isEqualTo(0)
-      assertThat(lines).hasSize(5)
-      assertThat(lines)
-          .containsExactly(
+      assertTrue(usesTrimMargin)
+      assertEquals("|", indentationSuffix)
+      assertFalse(isDollarString)
+      assertEquals(0, indentCount)
+      assertEquals(5, lines.size)
+      assertEquals(
+          listOf(
               TQ,
               "    |line1",
               "    |line2",
               "    $TQ",
               "        .trimMargin()",
-          )
-          .inOrder()
-      assertThat(lineStart).isEqualTo(0)
-      assertThat(lineEnd).isEqualTo(4)
-      assertThat(lastStringLineIndex).isEqualTo(3)
-      assertThat(openStringOffset).isEqualTo(0)
-      assertThat(trimMethodCallOffset).isEqualTo(42)
-      assertThat(isNestedMultiline).isFalse()
+          ),
+          lines,
+      )
+      assertEquals(0, lineStart)
+      assertEquals(4, lineEnd)
+      assertEquals(3, lastStringLineIndex)
+      assertEquals(0, openStringOffset)
+      assertEquals(42, trimMethodCallOffset)
+      assertFalse(isNestedMultiline)
     }
 
     with(
@@ -65,25 +68,26 @@ class MultilineStringFormatterTest {
             "    $TQ.trimIndent()",
         ),
     ) {
-      assertThat(usesTrimMargin).isFalse()
-      assertThat(indentationSuffix).isEqualTo("")
-      assertThat(isDollarString).isTrue()
-      assertThat(indentCount).isEqualTo(2)
-      assertThat(lines).hasSize(4)
-      assertThat(lines)
-          .containsExactly(
+      assertFalse(usesTrimMargin)
+      assertEquals("", indentationSuffix)
+      assertTrue(isDollarString)
+      assertEquals(2, indentCount)
+      assertEquals(4, lines.size)
+      assertEquals(
+          listOf(
               "  $$$TQ",
               "    line1 |",
               "    |line2",
               "    $TQ.trimIndent()",
-          )
-          .inOrder()
-      assertThat(lineStart).isEqualTo(1)
-      assertThat(lineEnd).isEqualTo(4)
-      assertThat(lastStringLineIndex).isEqualTo(3)
-      assertThat(openStringOffset).isEqualTo(10)
-      assertThat(trimMethodCallOffset).isEqualTo(46)
-      assertThat(isNestedMultiline).isFalse()
+          ),
+          lines,
+      )
+      assertEquals(1, lineStart)
+      assertEquals(4, lineEnd)
+      assertEquals(3, lastStringLineIndex)
+      assertEquals(10, openStringOffset)
+      assertEquals(46, trimMethodCallOffset)
+      assertFalse(isNestedMultiline)
     }
   }
 
@@ -98,13 +102,13 @@ class MultilineStringFormatterTest {
         " $TQ.trimIndent()", // blank final line (should be ignored)
     )
 
-    assertThat(string.minimalIndent).isEqualTo(2)
+    assertEquals(2, string.minimalIndent)
   }
 
   @Test
   fun `MultilineTrimmedString hasTemplateExpression`() {
     // simple string without template expression
-    assertThat(
+    assertFalse(
         multilineTrimmedStringFromLines(
             TQ,
             "    line1",
@@ -113,10 +117,9 @@ class MultilineStringFormatterTest {
         )
             .hasTemplateExpression(),
     )
-        .isFalse()
 
     // dollar string without dollar template expression
-    assertThat(
+    assertFalse(
         multilineTrimmedStringFromLines(
             "$$$TQ",
             "    line1 \${variable}",
@@ -125,10 +128,9 @@ class MultilineStringFormatterTest {
         )
             .hasTemplateExpression(),
     )
-        .isFalse()
 
     // simple string with template expression
-    assertThat(
+    assertTrue(
         multilineTrimmedStringFromLines(
             TQ,
             "    line1 \${variable}",
@@ -137,10 +139,9 @@ class MultilineStringFormatterTest {
         )
             .hasTemplateExpression(),
     )
-        .isTrue()
 
     // dollar string with template expression
-    assertThat(
+    assertTrue(
         multilineTrimmedStringFromLines(
             "$$$TQ",
             "    line1 $$\${variable}",
@@ -149,10 +150,9 @@ class MultilineStringFormatterTest {
         )
             .hasTemplateExpression(),
     )
-        .isTrue()
 
     // simple string with multiline template expression
-    assertThat(
+    assertTrue(
         multilineTrimmedStringFromLines(
             TQ,
             "    line1",
@@ -164,10 +164,9 @@ class MultilineStringFormatterTest {
         )
             .hasTemplateExpression(),
     )
-        .isTrue()
 
     // dollar string with multiline template expression
-    assertThat(
+    assertTrue(
         multilineTrimmedStringFromLines(
             "$$$TQ",
             "    line1",
@@ -179,12 +178,16 @@ class MultilineStringFormatterTest {
         )
             .hasTemplateExpression(),
     )
-        .isTrue()
   }
 
   @Test
   fun `getStringContent handles trimMargin with and without pipe prefix`() {
-    assertThat(
+    assertEquals(
+        listOf(
+            "line1",
+            "line2",
+            "line3",
+        ),
         multilineTrimmedStringFromLines(
             "$TQ  ",
             "    |line1",
@@ -194,14 +197,14 @@ class MultilineStringFormatterTest {
         )
             .getStringContent(),
     )
-        .containsExactly(
-            "line1",
-            "line2",
-            "line3",
-        )
-        .inOrder()
 
-    assertThat(
+    assertEquals(
+        listOf(
+            "    line1",
+            "    line2",
+            "    line3",
+            "",
+        ),
         multilineTrimmedStringFromLines(
             TQ,
             "    line1",
@@ -211,18 +214,17 @@ class MultilineStringFormatterTest {
         )
             .getStringContent(),
     )
-        .containsExactly(
-            "    line1",
-            "    line2",
-            "    line3",
-            "",
-        )
-        .inOrder()
   }
 
   @Test
   fun `getStringContent handles trimIndent`() {
-    assertThat(
+    assertEquals(
+        listOf(
+            "line1",
+            "  line2",
+            "line3",
+            "",
+        ),
         multilineTrimmedStringFromLines(
             "$TQ ",
             "    line1",
@@ -233,15 +235,14 @@ class MultilineStringFormatterTest {
         )
             .getStringContent(),
     )
-        .containsExactly(
+
+    assertEquals(
+        listOf(
             "line1",
             "  line2",
             "line3",
             "",
-        )
-        .inOrder()
-
-    assertThat(
+        ),
         multilineTrimmedStringFromLines(
             "$TQ ",
             "    line1",
@@ -253,18 +254,16 @@ class MultilineStringFormatterTest {
         )
             .getStringContent(),
     )
-        .containsExactly(
-            "line1",
-            "  line2",
-            "line3",
-            "",
-        )
-        .inOrder()
   }
 
   @Test
   fun `getStringContent includes non-blank first line content`() {
-    assertThat(
+    assertEquals(
+        listOf(
+            "content",
+            "line1",
+            "line2",
+        ),
         multilineTrimmedStringFromLines(
             "${TQ}content",
             "    |line1",
@@ -274,14 +273,13 @@ class MultilineStringFormatterTest {
         )
             .getStringContent(),
     )
-        .containsExactly(
+
+    assertEquals(
+        listOf(
             "content",
             "line1",
             "line2",
-        )
-        .inOrder()
-
-    assertThat(
+        ),
         multilineTrimmedStringFromLines(
             "$TQ    content",
             "    line1",
@@ -290,12 +288,6 @@ class MultilineStringFormatterTest {
         )
             .getStringContent(),
     )
-        .containsExactly(
-            "content",
-            "line1",
-            "line2",
-        )
-        .inOrder()
   }
 
   private fun multilineTrimmedStringFrom(
@@ -305,7 +297,7 @@ class MultilineStringFormatterTest {
     val strings =
         MultilineStringFormatter(continuationIndent)
             .getMultilineTrimmedStringList(Parser.parse(code))
-    assertThat(strings.size).isEqualTo(1)
+    assertEquals(1, strings.size)
     return strings.first()
   }
 
diff --git a/core/src/test/java/com/facebook/ktfmt/format/ParserTest.kt b/core/src/test/java/com/facebook/ktfmt/format/ParserTest.kt
index 30d67e96..9dfbe1a7 100644
--- a/core/src/test/java/com/facebook/ktfmt/format/ParserTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/format/ParserTest.kt
@@ -16,12 +16,9 @@
 
 package com.facebook.ktfmt.format
 
-import com.google.common.truth.Truth.assertThat
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
 
-@RunWith(JUnit4::class)
 class ParserTest {
   /**
    * [Parser.env] is initialized lazily, so the `idea.use.native.fs.for.win` property (which
@@ -32,6 +29,6 @@ class ParserTest {
   @Test
   fun `parsing sets idea_use_native_fs_for_win to false`() {
     Parser.parse("val a = 1")
-    assertThat(System.getProperty("idea.use.native.fs.for.win")).isEqualTo("false")
+    assertEquals("false", System.getProperty("idea.use.native.fs.for.win"))
   }
 }
diff --git a/core/src/test/java/com/facebook/ktfmt/format/TokenizerTest.kt b/core/src/test/java/com/facebook/ktfmt/format/TokenizerTest.kt
index 4d081c2b..376ec7fc 100644
--- a/core/src/test/java/com/facebook/ktfmt/format/TokenizerTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/format/TokenizerTest.kt
@@ -16,13 +16,10 @@
 
 package com.facebook.ktfmt.format
 
-import com.google.common.truth.Truth.assertThat
-import kotlin.test.assertFailsWith
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
 
-@RunWith(JUnit4::class)
 class TokenizerTest {
   @Test
   fun `PsiWhiteSpace are split to newlines and maximal-length whitespaces`() {
@@ -38,9 +35,10 @@ class TokenizerTest {
     val tokenizer = Tokenizer(code, file)
     file.accept(tokenizer)
 
-    assertThat(tokenizer.toks.map { it.originalText })
-        .containsExactly("val", "  ", "a", " ", "=", " ", "\n", "\n", "     ", "\n", "     ", "15")
-        .inOrder()
+    assertEquals(
+        listOf("val", "  ", "a", " ", "=", " ", "\n", "\n", "     ", "\n", "     ", "15"),
+        tokenizer.toks.map { it.originalText },
+    )
   }
 
   @Test
@@ -64,8 +62,8 @@ class TokenizerTest {
     val tokenizer = Tokenizer(code, file)
     file.accept(tokenizer)
 
-    assertThat(tokenizer.toks.map { it.originalText })
-        .containsExactly(
+    assertEquals(
+        listOf(
             "val",
             " ",
             "a",
@@ -91,8 +89,9 @@ class TokenizerTest {
             "      ",
             "\n",
             "    ",
-        )
-        .inOrder()
+        ),
+        tokenizer.toks.map { it.originalText },
+    )
   }
 
   @Test
@@ -108,12 +107,11 @@ class TokenizerTest {
     val tokenizer = Tokenizer(code, file)
     file.accept(tokenizer)
 
-    assertThat(tokenizer.toks.map { it.originalText })
-        .containsExactly("val", " ", "b", "=", "\"a\"", "\n", "val", " ", "a", "=", "5", "\n")
-        .inOrder()
-    assertThat(tokenizer.toks.map { it.index })
-        .containsExactly(0, -1, 1, 2, 3, -1, 4, -1, 5, 6, 7, -1)
-        .inOrder()
+    assertEquals(
+        listOf("val", " ", "b", "=", "\"a\"", "\n", "val", " ", "a", "=", "5", "\n"),
+        tokenizer.toks.map { it.originalText },
+    )
+    assertEquals(listOf(0, -1, 1, 2, 3, -1, 4, -1, 5, 6, 7, -1), tokenizer.toks.map { it.index })
   }
 
   @Test
@@ -134,8 +132,8 @@ class TokenizerTest {
     val tokenizer = Tokenizer(code, file)
     file.accept(tokenizer)
 
-    assertThat(tokenizer.toks.map { it.originalText })
-        .containsExactly(
+    assertEquals(
+        listOf(
             "context",
             "(",
             "Something",
@@ -176,10 +174,11 @@ class TokenizerTest {
             "\n",
             "}",
             "\n",
-        )
-        .inOrder()
-    assertThat(tokenizer.toks.map { it.index })
-        .containsExactly(
+        ),
+        tokenizer.toks.map { it.originalText },
+    )
+    assertEquals(
+        listOf(
             0,
             1,
             2,
@@ -220,8 +219,9 @@ class TokenizerTest {
             -1,
             23,
             -1,
-        )
-        .inOrder()
+        ),
+        tokenizer.toks.map { it.index },
+    )
   }
 
   @Test
@@ -242,8 +242,8 @@ class TokenizerTest {
     val tokenizer = Tokenizer(code, file)
     file.accept(tokenizer)
 
-    assertThat(tokenizer.toks.map { it.originalText })
-        .containsExactly(
+    assertEquals(
+        listOf(
             "fun",
             " ",
             "feedAnimal",
@@ -309,10 +309,11 @@ class TokenizerTest {
             "\n",
             "}",
             "\n",
-        )
-        .inOrder()
-    assertThat(tokenizer.toks.map { it.index })
-        .containsExactly(
+        ),
+        tokenizer.toks.map { it.originalText },
+    )
+    assertEquals(
+        listOf(
             0,
             -1,
             1,
@@ -378,8 +379,9 @@ class TokenizerTest {
             -1,
             40,
             -1,
-        )
-        .inOrder()
+        ),
+        tokenizer.toks.map { it.index },
+    )
   }
 
   @Test
@@ -406,8 +408,8 @@ class TokenizerTest {
     val tokenizer = Tokenizer(code, file)
     file.accept(tokenizer)
 
-    assertThat(tokenizer.toks.map { it.originalText })
-        .containsExactly(
+    assertEquals(
+        listOf(
             "//////////////////////////////////////",
             "\n",
             "fun",
@@ -471,10 +473,11 @@ class TokenizerTest {
             "\n",
             "}",
             "\n",
-        )
-        .inOrder()
-    assertThat(tokenizer.toks.map { it.index })
-        .containsExactly(
+        ),
+        tokenizer.toks.map { it.originalText },
+    )
+    assertEquals(
+        listOf(
             0,
             -1,
             1,
@@ -538,8 +541,9 @@ class TokenizerTest {
             -1,
             28,
             -1,
-        )
-        .inOrder()
+        ),
+        tokenizer.toks.map { it.index },
+    )
   }
 
   @Test
@@ -562,8 +566,8 @@ class TokenizerTest {
     val tokenizer = Tokenizer(code, file)
     file.accept(tokenizer)
 
-    assertThat(tokenizer.toks.map { it.originalText })
-        .containsExactly(
+    assertEquals(
+        listOf(
             "context",
             "(",
             "something",
@@ -619,10 +623,11 @@ class TokenizerTest {
             "\n",
             "}",
             "\n",
-        )
-        .inOrder()
-    assertThat(tokenizer.toks.map { it.index })
-        .containsExactly(
+        ),
+        tokenizer.toks.map { it.originalText },
+    )
+    assertEquals(
+        listOf(
             0,
             1,
             2,
@@ -678,8 +683,9 @@ class TokenizerTest {
             -1,
             33,
             -1,
-        )
-        .inOrder()
+        ),
+        tokenizer.toks.map { it.index },
+    )
   }
 
   @Test
@@ -741,8 +747,8 @@ class TokenizerTest {
     if (message == null) {
       file.accept(tokenizer)
     } else {
-      val e = assertFailsWith<ParseError> { file.accept(tokenizer) }
-      assertThat(e).hasMessageThat().isEqualTo(message)
+      val e = assertThrows<ParseError> { file.accept(tokenizer) }
+      assertEquals(message, e.message)
     }
   }
 }
diff --git a/core/src/test/java/com/facebook/ktfmt/format/WhitespaceTombstonesTest.kt b/core/src/test/java/com/facebook/ktfmt/format/WhitespaceTombstonesTest.kt
index b0dc60a8..0cacab36 100644
--- a/core/src/test/java/com/facebook/ktfmt/format/WhitespaceTombstonesTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/format/WhitespaceTombstonesTest.kt
@@ -16,34 +16,36 @@
 
 package com.facebook.ktfmt.format
 
-import com.google.common.truth.Truth.assertThat
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
 
-@RunWith(JUnit4::class)
 class WhitespaceTombstonesTest {
 
   @Test
   fun testReplaceTrailingWhitespaceWithTombstone() {
-    assertThat(WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("")).isEqualTo("")
+    assertEquals("", WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone(""))
 
-    assertThat(WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("  sdfl"))
-        .isEqualTo("  sdfl")
-    assertThat(WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("  sdfl "))
-        .isEqualTo("  sdfl${WhitespaceTombstones.SPACE_TOMBSTONE}")
-    assertThat(WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("  sdfl  "))
-        .isEqualTo("  sdfl ${WhitespaceTombstones.SPACE_TOMBSTONE}")
+    assertEquals("  sdfl", WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("  sdfl"))
+    assertEquals(
+        "  sdfl${WhitespaceTombstones.SPACE_TOMBSTONE}",
+        WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("  sdfl "),
+    )
+    assertEquals(
+        "  sdfl ${WhitespaceTombstones.SPACE_TOMBSTONE}",
+        WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("  sdfl  "),
+    )
 
-    assertThat(WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("  sdfl  \n skdjfh"))
-        .isEqualTo("  sdfl ${WhitespaceTombstones.SPACE_TOMBSTONE}\n skdjfh")
-    assertThat(WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("  sdfl  \n skdjfh "))
-        .isEqualTo(
-            "  sdfl ${WhitespaceTombstones.SPACE_TOMBSTONE}\n skdjfh${WhitespaceTombstones.SPACE_TOMBSTONE}",
-        )
-    assertThat(WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("  sdfl  \n\n skdjfh "))
-        .isEqualTo(
-            "  sdfl ${WhitespaceTombstones.SPACE_TOMBSTONE}\n\n skdjfh${WhitespaceTombstones.SPACE_TOMBSTONE}",
-        )
+    assertEquals(
+        "  sdfl ${WhitespaceTombstones.SPACE_TOMBSTONE}\n skdjfh",
+        WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("  sdfl  \n skdjfh"),
+    )
+    assertEquals(
+        "  sdfl ${WhitespaceTombstones.SPACE_TOMBSTONE}\n skdjfh${WhitespaceTombstones.SPACE_TOMBSTONE}",
+        WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("  sdfl  \n skdjfh "),
+    )
+    assertEquals(
+        "  sdfl ${WhitespaceTombstones.SPACE_TOMBSTONE}\n\n skdjfh${WhitespaceTombstones.SPACE_TOMBSTONE}",
+        WhitespaceTombstones.replaceTrailingWhitespaceWithTombstone("  sdfl  \n\n skdjfh "),
+    )
   }
 }
diff --git a/core/src/test/java/com/facebook/ktfmt/kdoc/DokkaVerifier.kt b/core/src/test/java/com/facebook/ktfmt/kdoc/DokkaVerifier.kt
index 4b102c79..e141a1fb 100644
--- a/core/src/test/java/com/facebook/ktfmt/kdoc/DokkaVerifier.kt
+++ b/core/src/test/java/com/facebook/ktfmt/kdoc/DokkaVerifier.kt
@@ -18,9 +18,9 @@
 
 package com.facebook.ktfmt.kdoc
 
-import com.google.common.truth.Truth.assertThat
 import java.io.BufferedReader
 import java.io.File
+import org.junit.jupiter.api.Assertions.assertEquals
 
 /**
  * Verifies that two KDoc comment strings render to the same HTML documentation using Dokka. This is
@@ -136,11 +136,11 @@ class DokkaVerifier(private val tempFolder: File) {
       val beforeText = getText(indexBefore)
       val afterText = getText(indexAfter)
       if (beforeText != null && afterText != null) {
-        assertThat(beforeText).isEqualTo(afterText)
+        assertEquals(beforeText, afterText)
         return
       }
 
-      assertThat(beforeContents).isEqualTo(afterContents)
+      assertEquals(beforeContents, afterContents)
     }
   }
 
diff --git a/core/src/test/java/com/facebook/ktfmt/kdoc/EscapingTest.kt b/core/src/test/java/com/facebook/ktfmt/kdoc/EscapingTest.kt
index 688f612d..67e5609a 100644
--- a/core/src/test/java/com/facebook/ktfmt/kdoc/EscapingTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/kdoc/EscapingTest.kt
@@ -16,24 +16,19 @@
 
 package com.facebook.ktfmt.kdoc
 
-import com.google.common.truth.Truth.assertThat
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
 
-@RunWith(JUnit4::class)
 class EscapingTest {
 
   @Test
   fun `escaping kdoc`() {
-    assertThat(Escaping.escapeKDoc("/** foo */")).isEqualTo("/** foo */")
-    assertThat(Escaping.escapeKDoc("/*** foo */")).isEqualTo("/*** foo */")
-    assertThat(Escaping.escapeKDoc("/** * foo */")).isEqualTo("/** * foo */")
-    assertThat(Escaping.escapeKDoc("/** /* foo */")).isEqualTo("/** \u0004\u0005 foo */")
-    assertThat(Escaping.escapeKDoc("/** /* foo */ */"))
-        .isEqualTo("/** \u0004\u0005 foo \u0005\u0004 */")
+    assertEquals("/** foo */", Escaping.escapeKDoc("/** foo */"))
+    assertEquals("/*** foo */", Escaping.escapeKDoc("/*** foo */"))
+    assertEquals("/** * foo */", Escaping.escapeKDoc("/** * foo */"))
+    assertEquals("/** \u0004\u0005 foo */", Escaping.escapeKDoc("/** /* foo */"))
+    assertEquals("/** \u0004\u0005 foo \u0005\u0004 */", Escaping.escapeKDoc("/** /* foo */ */"))
 
-    assertThat(Escaping.escapeKDoc("/* /* foo */ */"))
-        .isEqualTo("/* \u0004\u0005 foo \u0005\u0004 */")
+    assertEquals("/* \u0004\u0005 foo \u0005\u0004 */", Escaping.escapeKDoc("/* /* foo */ */"))
   }
 }
diff --git a/core/src/test/java/com/facebook/ktfmt/kdoc/KDocFormatterTest.kt b/core/src/test/java/com/facebook/ktfmt/kdoc/KDocFormatterTest.kt
index 1a7a4175..50af50f8 100644
--- a/core/src/test/java/com/facebook/ktfmt/kdoc/KDocFormatterTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/kdoc/KDocFormatterTest.kt
@@ -32,14 +32,11 @@
 
 package com.facebook.ktfmt.kdoc
 
-import com.google.common.truth.Truth.assertThat
-import com.google.common.truth.Truth.assertWithMessage
 import kotlin.io.path.createTempDirectory
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNotEquals
+import org.junit.jupiter.api.Test
 
-@RunWith(JUnit4::class)
 class KDocFormatterTest {
   private val tempDir = createTempDirectory().toFile()
 
@@ -58,7 +55,7 @@ class KDocFormatterTest {
     // Because .trimIndent() will remove it:
     val indentedExpected = expected.split("\n").joinToString("\n") { indent + it }
 
-    assertThat(reformatted).isEqualTo(indentedExpected)
+    assertEquals(indentedExpected, reformatted)
 
     if (verifyDokka && !options.addPunctuation) {
       DokkaVerifier(tempDir).verify(source, reformatted)
@@ -75,9 +72,11 @@ class KDocFormatterTest {
       )
       val formattedAgain = reformatComment(again)
       if (reformatted != formattedAgain) {
-        assertWithMessage("Formatting is unstable: if formatted a second time, it changes")
-            .that("$indent// FORMATTED TWICE (implies unstable formatting)\n\n$formattedAgain")
-            .isEqualTo("$indent// FORMATTED ONCE\n\n$reformatted")
+        assertEquals(
+            "$indent// FORMATTED ONCE\n\n$reformatted",
+            "$indent// FORMATTED TWICE (implies unstable formatting)\n\n$formattedAgain",
+            "Formatting is unstable: if formatted a second time, it changes",
+        )
       }
     }
   }
@@ -152,8 +151,8 @@ class KDocFormatterTest {
     checkFormatter(source, KDocFormattingOptions(72), reformatted, indent = "    ")
     val initialOffset = source.indexOf("default")
     val newOffset = findSamePosition(source, initialOffset, reformatted)
-    assertThat(newOffset).isNotEqualTo(initialOffset)
-    assertThat(reformatted.substring(newOffset, newOffset + "default".length)).isEqualTo("default")
+    assertNotEquals(initialOffset, newOffset)
+    assertEquals("default", reformatted.substring(newOffset, newOffset + "default".length))
   }
 
   @Test
@@ -177,8 +176,8 @@ class KDocFormatterTest {
     checkFormatter(source, KDocFormattingOptions(72), reformatted, indent = "    ")
     val initialOffset = source.indexOf("default")
     val newOffset = findSamePosition(source, initialOffset, reformatted)
-    assertThat(newOffset).isNotEqualTo(initialOffset)
-    assertThat(reformatted.substring(newOffset, newOffset + "default".length)).isEqualTo("default")
+    assertNotEquals(initialOffset, newOffset)
+    assertEquals("default", reformatted.substring(newOffset, newOffset + "default".length))
   }
 
   @Test
@@ -3189,7 +3188,7 @@ class KDocFormatterTest {
         """
             .trimIndent()
     val lorem = loremize(source)
-    assertThat(lorem).isEqualTo(source)
+    assertEquals(source, lorem)
     checkFormatter(
         source,
         KDocFormattingOptions(72, 72),
diff --git a/core/src/test/java/com/facebook/ktfmt/kdoc/UtilitiesTest.kt b/core/src/test/java/com/facebook/ktfmt/kdoc/UtilitiesTest.kt
index 5295457c..e851df32 100644
--- a/core/src/test/java/com/facebook/ktfmt/kdoc/UtilitiesTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/kdoc/UtilitiesTest.kt
@@ -16,26 +16,25 @@
 
 package com.facebook.ktfmt.kdoc
 
-import com.google.common.truth.Truth.assertThat
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNull
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
 
-@RunWith(JUnit4::class)
 class UtilitiesTest {
   @Test
   fun testFindSamePosition() {
     fun check(newWithCaret: String, oldWithCaret: String) {
       val oldCaretIndex = oldWithCaret.indexOf('|')
       val newCaretIndex = newWithCaret.indexOf('|')
-      assertThat(oldCaretIndex != -1).isTrue()
-      assertThat(newCaretIndex != -1).isTrue()
+      assertTrue(oldCaretIndex != -1)
+      assertTrue(newCaretIndex != -1)
       val old = oldWithCaret.substring(0, oldCaretIndex) + oldWithCaret.substring(oldCaretIndex + 1)
       val new = newWithCaret.substring(0, newCaretIndex) + newWithCaret.substring(newCaretIndex + 1)
       val newPos = findSamePosition(old, oldCaretIndex, new)
 
       val actual = new.substring(0, newPos) + "|" + new.substring(newPos)
-      assertThat(actual).isEqualTo(newWithCaret)
+      assertEquals(newWithCaret, actual)
     }
 
     // Prefix match
@@ -94,14 +93,14 @@ class UtilitiesTest {
 
   @Test
   fun testGetParamName() {
-    assertThat("@param foo".getParamName()).isEqualTo("foo")
-    assertThat("@param foo bar".getParamName()).isEqualTo("foo")
-    assertThat("@param foo;".getParamName()).isEqualTo("foo")
-    assertThat("  \t@param\t   foo  bar.".getParamName()).isEqualTo("foo")
-    assertThat("@param[foo]".getParamName()).isEqualTo("foo")
-    assertThat("@param  [foo]".getParamName()).isEqualTo("foo")
-    assertThat("@param ".getParamName()).isNull()
-    assertThat("@property foo".getParamName()).isEqualTo("foo")
+    assertEquals("foo", "@param foo".getParamName())
+    assertEquals("foo", "@param foo bar".getParamName())
+    assertEquals("foo", "@param foo;".getParamName())
+    assertEquals("foo", "  \t@param\t   foo  bar.".getParamName())
+    assertEquals("foo", "@param[foo]".getParamName())
+    assertEquals("foo", "@param  [foo]".getParamName())
+    assertNull("@param ".getParamName())
+    assertEquals("foo", "@property foo".getParamName())
   }
 
   @Test
@@ -116,7 +115,7 @@ class UtilitiesTest {
       customizeParagraph(paragraph)
       val words = paragraph.computeWords()
 
-      assertThat(words.describe()).isEqualTo(expected.describe())
+      assertEquals(expected.describe(), words.describe())
     }
     check("Foo", listOf("Foo"))
     check("Foo Bar Baz", listOf("Foo", "Bar", "Baz"))
diff --git a/core/src/test/java/com/facebook/ktfmt/nativeImage/NativeImageSubstitutionTest.kt b/core/src/test/java/com/facebook/ktfmt/nativeImage/NativeImageSubstitutionTest.kt
index 0400d162..95fe2710 100644
--- a/core/src/test/java/com/facebook/ktfmt/nativeImage/NativeImageSubstitutionTest.kt
+++ b/core/src/test/java/com/facebook/ktfmt/nativeImage/NativeImageSubstitutionTest.kt
@@ -18,9 +18,7 @@ package com.facebook.ktfmt.nativeImage
 
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.runners.JUnit4
+import org.junit.jupiter.api.Test
 
 /**
  * Guards the GraalVM `@Substitute` in `core/src/main/native-image` that replaces
@@ -30,7 +28,6 @@ import org.junit.runners.JUnit4
  * so a Kotlin compiler upgrade that changes the signature fails here first, before the native image
  * breaks.
  */
-@RunWith(JUnit4::class)
 class NativeImageSubstitutionTest {
   @Test
   fun `substituted Kotlin compiler method still exists with expected signature`() {
diff --git a/core/src/test/java/com/facebook/ktfmt/testutil/KtfmtTruth.kt b/core/src/test/java/com/facebook/ktfmt/testutil/KtfmtAssertions.kt
similarity index 77%
rename from core/src/test/java/com/facebook/ktfmt/testutil/KtfmtTruth.kt
rename to core/src/test/java/com/facebook/ktfmt/testutil/KtfmtAssertions.kt
index f9d0655a..b763622b 100644
--- a/core/src/test/java/com/facebook/ktfmt/testutil/KtfmtTruth.kt
+++ b/core/src/test/java/com/facebook/ktfmt/testutil/KtfmtAssertions.kt
@@ -20,11 +20,11 @@ import com.facebook.ktfmt.debughelpers.PrintAstVisitor
 import com.facebook.ktfmt.format.Formatter
 import com.facebook.ktfmt.format.FormattingOptions
 import com.facebook.ktfmt.format.Parser
-import com.google.common.truth.FailureMetadata
-import com.google.common.truth.Subject
-import com.google.common.truth.Truth
 import org.intellij.lang.annotations.Language
-import org.junit.Assert
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertNotNull
+import org.junit.jupiter.api.Assertions.assertTrue
 
 var defaultTestFormattingOptions: FormattingOptions = Formatter.META_FORMAT
 
@@ -75,17 +75,11 @@ fun assertFormatted(
 }
 
 fun assertThatFormatting(@Language("kts") code: String): FormattedCodeSubject {
-  fun codes(): Subject.Factory<FormattedCodeSubject, String> {
-    return Subject.Factory { metadata, subject ->
-      FormattedCodeSubject(metadata, checkNotNull(subject))
-    }
-  }
-  return Truth.assertAbout(codes()).that(code)
+  return FormattedCodeSubject(code)
 }
 
 @Suppress("ClassNameDoesNotMatchFileName")
-class FormattedCodeSubject(metadata: FailureMetadata, private val code: String) :
-    Subject(metadata, code) {
+class FormattedCodeSubject(private val code: String) {
   private var options: FormattingOptions = defaultTestFormattingOptions
   private var allowTrailingWhitespace = false
 
@@ -130,7 +124,7 @@ class FormattedCodeSubject(metadata: FailureMetadata, private val code: String)
       reportError(code)
       throw e
     }
-    Assert.assertEquals(expectedFormatting, actualFormatting)
+    assertEquals(expectedFormatting, actualFormatting)
   }
 
   private fun reportError(code: String) {
@@ -145,3 +139,24 @@ class FormattedCodeSubject(metadata: FailureMetadata, private val code: String)
     println()
   }
 }
+
+fun assertContains(expected: String?, actual: String, message: String? = null) {
+  assertNotNull(expected, "Subject of `assertContains` should not be null")
+  assertTrue(expected!!.contains(actual), message)
+}
+
+fun assertContainsMatch(expected: String?, actual: String, message: String? = null) {
+  assertNotNull(expected, "Subject of `assertContainsMatch` should not be null")
+  val regex = actual.toRegex()
+  assertTrue(regex.containsMatchIn(expected!!), message)
+}
+
+fun assertDoesNotContain(expected: String?, actual: String, message: String? = null) {
+  assertNotNull(expected, "Subject of `assertDoesNotContain` should not be null")
+  assertFalse(expected!!.contains(actual), message)
+}
+
+fun assertStartsWith(string: String?, prefix: String, message: String? = null) {
+  assertNotNull(string, "Subject of `assertStartsWith` should not be null")
+  assertTrue(string!!.startsWith(prefix), message)
+}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index d9f0bb7e..033a5ba8 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -3,10 +3,9 @@ java = "17"
 kotlin = "2.3.20"
 com-google-googlejavaformat-google-java-format = "1.23.0"
 com-google-guava-guava = "33.5.0-jre"
-com-google-truth-truth = "1.0"
-junit-junit = "4.13.1"
 net-java-dev-jna-jna = "4.2.2"
 org-ec4j-core = "1.2.0"
+org-junit-junit-bom = "6.1.2"
 
 # plugins
 gradlePlugin-dokka = "2.2.0"
@@ -17,13 +16,13 @@ gradlePlugin-shadowJar = "9.0.2"
 [libraries]
 ec4j = { module = "org.ec4j.core:ec4j-core", version.ref = "org-ec4j-core" }
 googleJavaformat = { module = "com.google.googlejavaformat:google-java-format", version.ref = "com-google-googlejavaformat-google-java-format" }
-googleTruth = { module = "com.google.truth:truth", version.ref = "com-google-truth-truth" }
 guava = { module = "com.google.guava:guava", version.ref = "com-google-guava-guava" }
-junit = { module = "junit:junit", version.ref = "junit-junit" }
+junit-bom = { module = "org.junit:junit-bom", version.ref = "org-junit-junit-bom" }
+junit-jupiter = { module = "org.junit.jupiter:junit-jupiter" }
+junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher" }
 jna = { module = "net.java.dev.jna:jna", version.ref = "net-java-dev-jna-jna" }
 kotlin-compilerEmbeddable = { module = "org.jetbrains.kotlin:kotlin-compiler-embeddable", version.ref = "kotlin" }
 kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
-kotlin-test-junit4 = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kotlin" }
 
 [plugins]
 dokka = { id = "org.jetbrains.dokka", version.ref = "gradlePlugin-dokka" }