diff --git a/build.sbt b/build.sbt
index b35c9723ed..88e2183ac6 100644
--- a/build.sbt
+++ b/build.sbt
@@ -26,6 +26,30 @@ val jsr305Lib = "com.google.code.findbugs" % "jsr305" % "2.0.1"
 val scalacheckLib = "org.scalacheck" %% "scalacheck" % "1.15.4" % "test"
 val slf4jApi = "org.slf4j" % "slf4j-api" % slf4jVersion
 
+def scalatestLib(scalaBinaryVersion: String) =
+  if (isScala3(scalaBinaryVersion))
+    "org.scalatest" %% "scalatest" % "3.2.9" % "test"
+  else
+    "org.scalatest" %% "scalatest" % "3.1.2" % "test"
+
+def scalatestplusScalacheckLib(scalaBinaryVersion: String) =
+  if (isScala3(scalaBinaryVersion))
+    "org.scalatestplus" %% "scalacheck-1-15" % "3.2.9.0" % "test"
+  else
+    "org.scalatestplus" %% "scalacheck-1-14" % "3.1.2.0" % "test"
+
+def scalatestplusJUnitLib(scalaBinaryVersion: String) =
+  if (isScala3(scalaBinaryVersion))
+    "org.scalatestplus" %% "junit-4-13" % "3.2.9.0" % "test"
+  else
+    "org.scalatestplus" %% "junit-4-12" % "3.1.2.0" % "test"
+
+def scalatestplusMockitoLib(scalaBinaryVersion: String) =
+  if (isScala3(scalaBinaryVersion))
+    "org.scalatestplus" %% "mockito-3-4" % "3.2.9.0" % "test"
+  else
+    "org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test"
+
 def travisTestJavaOptions: Seq[String] = {
   // We have some custom configuration for the Travis environment
   // https://docs.travis-ci.com/user/environment-variables/#default-environment-variables
@@ -82,20 +106,23 @@ def jdk11GcJavaOptions: Seq[String] = {
 
 val defaultProjectSettings = Seq(
   scalaVersion := "2.13.6",
-  crossScalaVersions := Seq("2.12.12", "2.13.6")
+  crossScalaVersions := Seq("2.12.12", "2.13.6", "3.0.2-RC1") // TODO Scala3 use 3.0.2 once released
 )
 
+def isScala3(scalaBinaryVersion: String): Boolean =
+  scalaBinaryVersion == "3"
+
 val baseSettings = Seq(
   version := releaseVersion,
   organization := "com.twitter",
   // Workaround for a scaladoc bug which causes it to choke on empty classpaths.
   Compile / unmanagedClasspath += Attributed.blank(new java.io.File("doesnotexist")),
   libraryDependencies ++= Seq(
-    "org.scala-lang.modules" %% "scala-collection-compat" % "2.1.2",
+    "org.scala-lang.modules" %% "scala-collection-compat" % "2.4.4",
     // See https://www.scala-sbt.org/0.13/docs/Testing.html#JUnit
     "com.novocode" % "junit-interface" % "0.11" % "test",
-    "org.scalatest" %% "scalatest" % "3.1.2" % "test",
-    "org.scalatestplus" %% "junit-4-12" % "3.1.2.0" % "test"
+    scalatestLib(scalaBinaryVersion.value),
+    scalatestplusJUnitLib(scalaBinaryVersion.value),
   ),
   Test / fork := true, // We have to fork to get the JavaOptions
   // Workaround for cross building HealthyQueue.scala, which is not compatible between
@@ -103,6 +130,7 @@ val baseSettings = Seq(
   Compile / unmanagedSourceDirectories += {
     val sourceDir = (Compile / sourceDirectory).value
     CrossVersion.partialVersion(scalaVersion.value) match {
+      case Some((3, _)) => sourceDir / "scala-2.13+"
       case Some((2, n)) if n >= 13 => sourceDir / "scala-2.13+"
       case _ => sourceDir / "scala-2.12-"
     }
@@ -120,7 +148,12 @@ val baseSettings = Seq(
     // Needs -missing-interpolator due to https://issues.scala-lang.org/browse/SI-8761
     "-Xlint:-missing-interpolator",
     "-Yrangepos"
-  ),
+  ) ++ Seq(
+    "-source:3.0-migration",
+    //"-rewrite",
+    "-explain",
+    "-explain-types",
+  ).filter(_ => isScala3(scalaBinaryVersion.value)),
   // Note: Use -Xlint rather than -Xlint:unchecked when TestThriftStructure
   // warnings are resolved
   javacOptions ++= Seq("-Xlint:unchecked", "-source", "1.8", "-target", "1.8"),
@@ -206,7 +239,7 @@ lazy val util = Project(
     utilJvm,
     utilLint,
     utilLogging,
-    utilMock,
+    //utilMock,  // TODO Scala3
     utilReflect,
     utilRegistry,
     utilRouting,
@@ -232,7 +265,7 @@ lazy val utilApp = Project(
     name := "util-app",
     libraryDependencies ++= Seq(
       "org.mockito" % "mockito-core" % mockitoVersion % "test",
-      "org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test"
+      ("org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test").cross(CrossVersion.for3Use2_13)
     )
   ).dependsOn(utilAppLifecycle, utilCore, utilRegistry)
 
@@ -275,7 +308,7 @@ lazy val utilCache = Project(
       caffeineLib,
       jsr305Lib,
       "org.mockito" % "mockito-core" % mockitoVersion % "test",
-      "org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test"
+      ("org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test").cross(CrossVersion.for3Use2_13)
     )
   ).dependsOn(utilCore)
 
@@ -318,13 +351,12 @@ lazy val utilCore = Project(
     // so that util-core would work better for Pants projects in IntelliJ.
     Compile / unmanagedSourceDirectories += baseDirectory.value / "concurrent-extra",
     libraryDependencies ++= Seq(
+      "org.scala-lang.modules" %% "scala-parser-combinators" % "2.0.0",
       caffeineLib % "test",
       scalacheckLib,
-      "org.scala-lang" % "scala-reflect" % scalaVersion.value,
-      "org.scala-lang.modules" %% "scala-parser-combinators" % "1.1.2",
       "org.mockito" % "mockito-core" % mockitoVersion % "test",
-      "org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test",
-      "org.scalatestplus" %% "scalacheck-1-14" % "3.1.2.0" % "test"
+      scalatestplusScalacheckLib(scalaBinaryVersion.value),
+      scalatestplusMockitoLib(scalaBinaryVersion.value),
     ),
     Compile / resourceGenerators += Def.task {
       val projectName = name.value
@@ -371,7 +403,10 @@ lazy val utilReflect = Project(
 ).settings(
     sharedSettings
   ).settings(
-    name := "util-reflect"
+    name := "util-reflect",
+    libraryDependencies ++= Seq(
+      "org.scala-lang" % "scala-reflect" % scalaVersion.value
+    )
   ).dependsOn(utilCore)
 
 lazy val utilHashing = Project(
@@ -384,7 +419,7 @@ lazy val utilHashing = Project(
     libraryDependencies ++= Seq(
       scalacheckLib,
       "org.scalatestplus" %% "scalacheck-1-14" % "3.1.2.0" % "test"
-    )
+    ).map(_.cross(CrossVersion.for3Use2_13))
   ).dependsOn(utilCore % "test")
 
 lazy val utilJacksonAnnotations = Project(
@@ -427,7 +462,7 @@ lazy val utilJvm = Project(
     name := "util-jvm",
     libraryDependencies ++= Seq(
       "org.mockito" % "mockito-core" % mockitoVersion % "test",
-      "org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test"
+      ("org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test").cross(CrossVersion.for3Use2_13)
     )
   ).dependsOn(utilApp, utilCore, utilStats)
 
@@ -460,7 +495,7 @@ lazy val utilMock = Project(
       // only depend on mockito-scala; it will pull in the correct corresponding version of mockito.
       "org.mockito" %% "mockito-scala" % mockitoScalaVersion,
       "org.mockito" %% "mockito-scala-scalatest" % mockitoScalaVersion % "test"
-    )
+    ).map(_.cross(CrossVersion.for3Use2_13))
   ).dependsOn(utilCore % "test")
 
 lazy val utilRegistry = Project(
@@ -472,7 +507,7 @@ lazy val utilRegistry = Project(
     name := "util-registry",
     libraryDependencies ++= Seq(
       "org.mockito" % "mockito-core" % mockitoVersion % "test",
-      "org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test"
+      ("org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test").cross(CrossVersion.for3Use2_13)
     )
   ).dependsOn(utilCore)
 
@@ -494,10 +529,10 @@ lazy val utilSlf4jApi = Project(
     name := "util-slf4j-api",
     libraryDependencies ++= Seq(
       slf4jApi,
-      "org.mockito" %% "mockito-scala" % mockitoScalaVersion % "test",
+      "org.mockito" % "mockito-core" % mockitoVersion % "test",
       "org.slf4j" % "slf4j-simple" % slf4jVersion % "test"
     )
-  ).dependsOn(utilCore % "test", utilMock % "test")
+  ).dependsOn(utilCore % "test")
 
 lazy val utilSlf4jJulBridge = Project(
   id = "util-slf4j-jul-bridge",
@@ -519,7 +554,7 @@ lazy val utilSecurity = Project(
     libraryDependencies ++= Seq(
       scalacheckLib,
       "org.scalatestplus" %% "scalacheck-1-14" % "3.1.2.0" % "test"
-    )
+    ).map(_.cross(CrossVersion.for3Use2_13))
   ).dependsOn(utilCore, utilLogging, utilSecurityTestCerts % "test")
 
 lazy val utilSecurityTestCerts = Project(
@@ -541,15 +576,18 @@ lazy val utilStats = Project(
     libraryDependencies ++= Seq(
       caffeineLib,
       jsr305Lib,
-      scalacheckLib,
       "com.fasterxml.jackson.core" % "jackson-core" % jacksonVersion,
       "com.fasterxml.jackson.core" % "jackson-databind" % jacksonVersion,
-      "com.fasterxml.jackson.module" %% "jackson-module-scala" % jacksonVersion exclude ("com.google.guava", "guava"),
       "org.mockito" % "mockito-core" % mockitoVersion % "test",
+    ) ++ Seq(
+      scalacheckLib,
+      "com.fasterxml.jackson.module" %% "jackson-module-scala" % jacksonVersion exclude ("com.google.guava", "guava"),
       "org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test",
-      "org.scalatestplus" %% "scalacheck-1-14" % "3.1.2.0" % "test"
-    ) ++ {
+      "org.scalatestplus" %% "scalacheck-1-14" % "3.1.2.0" % "test",
+    ).map(_.cross(CrossVersion.for3Use2_13)) ++ {
       CrossVersion.partialVersion(scalaVersion.value) match {
+        case Some((3, major)) =>
+          Seq("org.scala-lang.modules" %% "scala-parallel-collections" % "1.0.3" % "test")
         case Some((2, major)) if major >= 13 =>
           Seq("org.scala-lang.modules" %% "scala-parallel-collections" % "0.2.0" % "test")
         case _ =>
@@ -567,9 +605,12 @@ lazy val utilTest = Project(
     name := "util-test",
     libraryDependencies ++= Seq(
       "org.mockito" % "mockito-all" % "1.10.19",
-      "org.scalatest" %% "scalatest" % "3.1.2",
-      "org.scalatestplus" %% "junit-4-12" % "3.1.2.0",
-      "org.scalatestplus" %% "mockito-1-10" % "3.1.0.0"
+      (if (isScala3(scalaBinaryVersion.value))
+        "org.scalatest" %% "scalatest" % "3.2.9"
+      else
+        "org.scalatest" %% "scalatest" % "3.1.2"),
+      ("org.scalatestplus" %% "junit-4-12" % "3.1.2.0").cross(CrossVersion.for3Use2_13),
+      ("org.scalatestplus" %% "mockito-1-10" % "3.1.0.0").cross(CrossVersion.for3Use2_13)
     )
   ).dependsOn(utilCore, utilLogging)
 
@@ -595,10 +636,13 @@ lazy val utilTunable = Project(
     sharedSettings
   ).settings(
     name := "util-tunable",
+    resolvers += // TODO Scala3 remove this once the library is published properly
+      "Sonatype OSS Snapshots" at "https://oss.sonatype.org/content/repositories/snapshots",
     libraryDependencies ++= Seq(
       "com.fasterxml.jackson.core" % "jackson-core" % jacksonVersion,
       "com.fasterxml.jackson.core" % "jackson-databind" % jacksonVersion,
-      "com.fasterxml.jackson.module" %% "jackson-module-scala" % jacksonVersion exclude ("com.google.guava", "guava")
+      //("com.fasterxml.jackson.module" %% "jackson-module-scala" % jacksonVersion exclude ("com.google.guava", "guava")).cross(CrossVersion.for3Use2_13)
+      "com.fasterxml.jackson.module" %% "jackson-module-scala" % "2.13.0-SNAPSHOT", // TODO Scala3 global jackson upgrade first?
     )
   ).dependsOn(utilApp, utilCore)
 
@@ -611,15 +655,16 @@ lazy val utilValidator = Project(
     name := "util-validator",
     libraryDependencies ++= Seq(
       caffeineLib,
-      scalacheckLib,
       "jakarta.validation" % "jakarta.validation-api" % "3.0.0",
       "org.hibernate.validator" % "hibernate-validator" % "7.0.1.Final",
       "org.glassfish" % "jakarta.el" % "4.0.0",
-      "org.json4s" %% "json4s-core" % "3.6.7",
       "com.fasterxml.jackson.core" % "jackson-annotations" % jacksonVersion % "test",
-      "org.scalatestplus" %% "scalacheck-1-14" % "3.1.2.0" % "test",
       "org.slf4j" % "slf4j-simple" % slf4jVersion % "test"
-    )
+    ) ++ Seq(
+      "org.json4s" %% "json4s-core" % "3.6.7",
+      scalacheckLib,
+      "org.scalatestplus" %% "scalacheck-1-14" % "3.1.2.0" % "test",
+    ).map(_.cross(CrossVersion.for3Use2_13))
   ).dependsOn(utilCore, utilReflect, utilSlf4jApi)
 
 lazy val utilZk = Project(
@@ -632,7 +677,7 @@ lazy val utilZk = Project(
     libraryDependencies ++= Seq(
       zkDependency,
       "org.mockito" % "mockito-core" % mockitoVersion % "test",
-      "org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test"
+      ("org.scalatestplus" %% "mockito-3-3" % "3.1.2.0" % "test").cross(CrossVersion.for3Use2_13)
     )
   ).dependsOn(utilCore, utilLogging)
 
diff --git a/project/plugins.sbt b/project/plugins.sbt
index e2cefb38da..6afca74feb 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -2,5 +2,5 @@ resolvers += Classpaths.sbtPluginReleases
 resolvers += Resolver.sonatypeRepo("snapshots")
 
 addSbtPlugin("com.typesafe.sbt" % "sbt-site" % "1.3.0")
-addSbtPlugin("org.scoverage" % "sbt-scoverage" % "1.6.1")
+addSbtPlugin("org.scoverage" % "sbt-scoverage" % "1.8.2")
 addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.4.0")
diff --git a/util-app/src/main/scala/com/twitter/app/ClassPath.scala b/util-app/src/main/scala/com/twitter/app/ClassPath.scala
index 261cfd4129..eb28fb15aa 100644
--- a/util-app/src/main/scala/com/twitter/app/ClassPath.scala
+++ b/util-app/src/main/scala/com/twitter/app/ClassPath.scala
@@ -71,7 +71,7 @@ private[app] sealed abstract class ClassPath[CpInfo <: ClassPath.Info] {
   // TODO - add suppport for the ModulePath after dropping JDK 8 support.
   private[this] def urlsFromClasspath(): Array[URL] = {
     val classpath: String = System.getProperty("java.class.path")
-    classpath.split(File.pathSeparator).map { pathEntry: String =>
+    classpath.split(File.pathSeparator).map { (pathEntry: String) =>
       Paths.get(pathEntry).toAbsolutePath().toUri().toURL
     }
   }
diff --git a/util-app/src/main/scala/com/twitter/app/Flaggable.scala b/util-app/src/main/scala/com/twitter/app/Flaggable.scala
index 43646031fd..d84696c59c 100644
--- a/util-app/src/main/scala/com/twitter/app/Flaggable.scala
+++ b/util-app/src/main/scala/com/twitter/app/Flaggable.scala
@@ -132,19 +132,19 @@ object Flaggable {
 
   implicit val ofInt: Flaggable[Int] = mandatory(_.toInt)
   implicit val ofJavaInteger: Flaggable[JInteger] =
-    mandatory { s: String => JInteger.valueOf(s.toInt) }
+    mandatory { (s: String) => JInteger.valueOf(s.toInt) }
 
   implicit val ofLong: Flaggable[Long] = mandatory(_.toLong)
   implicit val ofJavaLong: Flaggable[JLong] =
-    mandatory { s: String => JLong.valueOf(s.toLong) }
+    mandatory { (s: String) => JLong.valueOf(s.toLong) }
 
   implicit val ofFloat: Flaggable[Float] = mandatory(_.toFloat)
   implicit val ofJavaFloat: Flaggable[JFloat] =
-    mandatory { s: String => JFloat.valueOf(s.toFloat) }
+    mandatory { (s: String) => JFloat.valueOf(s.toFloat) }
 
   implicit val ofDouble: Flaggable[Double] = mandatory(_.toDouble)
   implicit val ofJavaDouble: Flaggable[JDouble] =
-    mandatory { s: String => JDouble.valueOf(s.toDouble) }
+    mandatory { (s: String) => JDouble.valueOf(s.toDouble) }
 
   // Conversions for common non-primitive types and collections.
   implicit val ofDuration: Flaggable[Duration] = mandatory(Duration.parse(_))
diff --git a/util-app/src/main/scala/com/twitter/app/Flags.scala b/util-app/src/main/scala/com/twitter/app/Flags.scala
index f92faf104a..815ca5aece 100644
--- a/util-app/src/main/scala/com/twitter/app/Flags.scala
+++ b/util-app/src/main/scala/com/twitter/app/Flags.scala
@@ -4,6 +4,7 @@ import scala.collection.immutable.TreeSet
 import scala.collection.mutable
 import scala.collection.mutable.ArrayBuffer
 import scala.jdk.CollectionConverters._
+import scala.reflect.ClassTag
 import scala.util.control.NonFatal
 
 /**
@@ -277,8 +278,9 @@ class Flags(argv0: String, includeGlobal: Boolean, failFastUntilParsed: Boolean)
    * @param name The name of the flag.
    * @param help The help string of the flag.
    */
-  def apply[T](name: String, help: String)(implicit _f: Flaggable[T], m: Manifest[T]): Flag[T] = {
-    val f = new Flag[T](name, help, m.toString, failFastUntilParsed)
+  def apply[T](name: String, help: String)(implicit _f: Flaggable[T], m: ClassTag[T]): Flag[T] = {
+    // TODO Scala3 Is ClassTag ok? Should we capitalize the type name?
+    val f = new Flag[T](name, help, m.runtimeClass.getTypeName.capitalize, failFastUntilParsed)
     add(f)
     f
   }
diff --git a/util-app/src/main/scala/com/twitter/app/GlobalFlag.scala b/util-app/src/main/scala/com/twitter/app/GlobalFlag.scala
index 89c537a65e..051e906b64 100644
--- a/util-app/src/main/scala/com/twitter/app/GlobalFlag.scala
+++ b/util-app/src/main/scala/com/twitter/app/GlobalFlag.scala
@@ -1,6 +1,7 @@
 package com.twitter.app
 
 import java.lang.reflect.Modifier
+import scala.reflect.ClassTag
 import scala.util.control.NonFatal
 
 /**
@@ -85,8 +86,9 @@ abstract class GlobalFlag[T] private[app] (
    *
    * @param help documentation regarding usage of this [[Flag]].
    */
-  def this(help: String)(implicit _f: Flaggable[T], m: Manifest[T]) =
-    this(Right(m.toString), help)
+  def this(help: String)(implicit _f: Flaggable[T], m: ClassTag[T]) =
+    // TODO Scala3 Is ClassTag ok? Should we capitalize the type name?
+    this(Right(m.runtimeClass.getTypeName.capitalize), help)
 
   /**
    * The "name", or "id", of this [[Flag]].
diff --git a/util-app/src/test/scala/com/twitter/app/AppTest.scala b/util-app/src/test/scala/com/twitter/app/AppTest.scala
index ea66b2fd1b..98e61256e6 100644
--- a/util-app/src/test/scala/com/twitter/app/AppTest.scala
+++ b/util-app/src/test/scala/com/twitter/app/AppTest.scala
@@ -205,7 +205,7 @@ class AppTest extends AnyFunSuite {
     assert(n2 == 0)
     assert(!f.isDefined)
 
-    p.setDone
+    p.setDone()
     assert(n2 == 1)
     assert(f.isDefined)
   }
diff --git a/util-cache-guava/src/main/scala/com/twitter/cache/guava/GuavaCache.scala b/util-cache-guava/src/main/scala/com/twitter/cache/guava/GuavaCache.scala
index 6dc3678dac..4a0f468c1f 100644
--- a/util-cache-guava/src/main/scala/com/twitter/cache/guava/GuavaCache.scala
+++ b/util-cache-guava/src/main/scala/com/twitter/cache/guava/GuavaCache.scala
@@ -53,7 +53,7 @@ object GuavaCache {
    */
   def fromLoadingCache[K, V](cache: LoadingCache[K, Future[V]]): K => Future[V] = {
     val evicting = EvictingCache.lazily(new LoadingFutureCache(cache));
-    { key: K => evicting.get(key).get.interruptible() }
+    { (key: K) => evicting.get(key).get.interruptible() }
   }
 
   /**
diff --git a/util-cache/src/main/scala/com/twitter/cache/ConcurrentMapCache.scala b/util-cache/src/main/scala/com/twitter/cache/ConcurrentMapCache.scala
index 9103966d22..e1f3c7806c 100644
--- a/util-cache/src/main/scala/com/twitter/cache/ConcurrentMapCache.scala
+++ b/util-cache/src/main/scala/com/twitter/cache/ConcurrentMapCache.scala
@@ -20,7 +20,7 @@ class ConcurrentMapCache[K, V](underlying: ConcurrentMap[K, Future[V]]) extends
   def set(key: K, value: Future[V]): Unit = underlying.put(key, value)
 
   def getOrElseUpdate(key: K)(compute: => Future[V]): Future[V] = {
-    val p = Promise[V]
+    val p = Promise[V]()
     underlying.putIfAbsent(key, p) match {
       case null =>
         p.become(compute)
diff --git a/util-cache/src/main/scala/com/twitter/cache/FutureCache.scala b/util-cache/src/main/scala/com/twitter/cache/FutureCache.scala
index 5e370904c5..83e74116d2 100644
--- a/util-cache/src/main/scala/com/twitter/cache/FutureCache.scala
+++ b/util-cache/src/main/scala/com/twitter/cache/FutureCache.scala
@@ -107,7 +107,7 @@ object FutureCache {
    * @see [[standard]] for the equivalent Java API.
    */
   def default[K, V](fn: K => Future[V], cache: FutureCache[K, V]): K => Future[V] =
-    AsyncMemoize(fn, new EvictingCache(cache)) andThen { f: Future[V] => f.interruptible() }
+    AsyncMemoize(fn, new EvictingCache(cache)) andThen { (f: Future[V]) => f.interruptible() }
 
   /**
    * Alias for [[default]] which can be called from Java.
diff --git a/util-cache/src/main/scala/com/twitter/cache/caffeine/CaffeineCache.scala b/util-cache/src/main/scala/com/twitter/cache/caffeine/CaffeineCache.scala
index f8a2ece734..0a853d4949 100644
--- a/util-cache/src/main/scala/com/twitter/cache/caffeine/CaffeineCache.scala
+++ b/util-cache/src/main/scala/com/twitter/cache/caffeine/CaffeineCache.scala
@@ -54,7 +54,7 @@ object CaffeineCache {
    */
   def fromLoadingCache[K, V](cache: LoadingCache[K, Future[V]]): K => Future[V] = {
     val evicting = EvictingCache.lazily(new LoadingFutureCache(cache));
-    { key: K => evicting.get(key).get.interruptible() }
+    { (key: K) => evicting.get(key).get.interruptible() }
   }
 
   /**
diff --git a/util-cache/src/test/scala/com/twitter/cache/EvictingCacheTest.scala b/util-cache/src/test/scala/com/twitter/cache/EvictingCacheTest.scala
index 1868542aed..c7cf5f3ccb 100644
--- a/util-cache/src/test/scala/com/twitter/cache/EvictingCacheTest.scala
+++ b/util-cache/src/test/scala/com/twitter/cache/EvictingCacheTest.scala
@@ -10,7 +10,7 @@ class EvictingCacheTest extends AnyFunSuite with MockitoSugar {
   test("EvictingCache should evict on failed futures for set") {
     val cache = mock[FutureCache[String, String]]
     val fCache = new EvictingCache(cache)
-    val p = Promise[String]
+    val p = Promise[String]()
     fCache.set("key", p)
     verify(cache).set("key", p)
     p.setException(new Exception)
@@ -20,7 +20,7 @@ class EvictingCacheTest extends AnyFunSuite with MockitoSugar {
   test("EvictingCache should keep satisfied futures for set") {
     val cache = mock[FutureCache[String, String]]
     val fCache = new EvictingCache(cache)
-    val p = Promise[String]
+    val p = Promise[String]()
     fCache.set("key", p)
     verify(cache).set("key", p)
     p.setValue("value")
@@ -31,7 +31,7 @@ class EvictingCacheTest extends AnyFunSuite with MockitoSugar {
     val map = new ConcurrentHashMap[String, Future[String]]()
     val cache = new ConcurrentMapCache(map)
     val fCache = new EvictingCache(cache)
-    val p = Promise[String]
+    val p = Promise[String]()
     assert(fCache.getOrElseUpdate("key")(p).poll == p.poll)
     p.setException(new Exception)
     assert(fCache.get("key") == None)
@@ -41,7 +41,7 @@ class EvictingCacheTest extends AnyFunSuite with MockitoSugar {
     val map = new ConcurrentHashMap[String, Future[String]]()
     val cache = new ConcurrentMapCache(map)
     val fCache = new EvictingCache(cache)
-    val p = Promise[String]
+    val p = Promise[String]()
     assert(fCache.getOrElseUpdate("key")(p).poll == p.poll)
     p.setValue("value")
     assert(fCache.get("key").map(_.poll) == Some(p.poll))
diff --git a/util-cache/src/test/scala/com/twitter/cache/KeyEncodingCacheTest.scala b/util-cache/src/test/scala/com/twitter/cache/KeyEncodingCacheTest.scala
index 98bf953b2b..3f7a296aef 100644
--- a/util-cache/src/test/scala/com/twitter/cache/KeyEncodingCacheTest.scala
+++ b/util-cache/src/test/scala/com/twitter/cache/KeyEncodingCacheTest.scala
@@ -10,6 +10,6 @@ class KeyEncodingCacheTest extends AbstractFutureCacheTest {
     val underlyingMap: ConcurrentHashMap[Int, Future[String]] = new ConcurrentHashMap()
     val underlyingCache: FutureCache[Int, String] = new ConcurrentMapCache(underlyingMap)
     val cache: FutureCache[String, String] =
-      new KeyEncodingCache({ num: String => num.hashCode }, underlyingCache)
+      new KeyEncodingCache({ (num: String) => num.hashCode }, underlyingCache)
   }
 }
diff --git a/util-core/src/main/java/com/twitter/util/Vars.java b/util-core/src/main/java/com/twitter/util/Vars.java
index 928c18d1b9..e428aee78f 100644
--- a/util-core/src/main/java/com/twitter/util/Vars.java
+++ b/util-core/src/main/java/com/twitter/util/Vars.java
@@ -35,7 +35,7 @@ public static <T> Var<T> newVar(T init, Event<T> event) {
    * @see com.twitter.util.Var$#value(Object)
    */
   public static <T> Var<T> newConstVar(T constant) {
-    return Var$.MODULE$.value(constant);
+    return (Var<T>) Var$.MODULE$.value(constant);
   }
 
   /**
diff --git a/util-core/src/main/scala/com/twitter/concurrent/AsyncMeter.scala b/util-core/src/main/scala/com/twitter/concurrent/AsyncMeter.scala
index 24b46d63ff..59e61c4d24 100644
--- a/util-core/src/main/scala/com/twitter/concurrent/AsyncMeter.scala
+++ b/util-core/src/main/scala/com/twitter/concurrent/AsyncMeter.scala
@@ -138,7 +138,7 @@ object AsyncMeter {
       val seqWithoutLast: Seq[Future[Unit]] = (0 until num).map(_ => meter.await(meter.burstSize))
       val seq = if (last == 0) seqWithoutLast else seqWithoutLast :+ meter.await(last)
       val result = Future.join(seq)
-      result.onFailure { exc => seq.foreach { f: Future[Unit] => f.raise(exc) } }
+      result.onFailure { exc => seq.foreach { (f: Future[Unit]) => f.raise(exc) } }
       result
     } else meter.await(permits)
   }
diff --git a/util-core/src/main/scala/com/twitter/concurrent/Broker.scala b/util-core/src/main/scala/com/twitter/concurrent/Broker.scala
index 937c416c41..b89c2d3647 100644
--- a/util-core/src/main/scala/com/twitter/concurrent/Broker.scala
+++ b/util-core/src/main/scala/com/twitter/concurrent/Broker.scala
@@ -82,7 +82,6 @@ class Broker[T] {
           val nextState = s match {
             case Quiet => Sending(Queue(elem))
             case Sending(q) => Sending(q enqueue elem)
-            case Receiving(_) => throw new IllegalStateException()
           }
 
           if (state.compareAndSet(s, nextState)) p else prepare()
@@ -111,7 +110,6 @@ class Broker[T] {
           val nextState = s match {
             case Quiet => Receiving(Queue(p))
             case Receiving(q) => Receiving(q enqueue p)
-            case Sending(_) => throw new IllegalStateException()
           }
 
           if (state.compareAndSet(s, nextState)) p else prepare()
diff --git a/util-core/src/main/scala/com/twitter/concurrent/Serialized.scala b/util-core/src/main/scala/com/twitter/concurrent/Serialized.scala
index 4849e9b987..55caf37059 100644
--- a/util-core/src/main/scala/com/twitter/concurrent/Serialized.scala
+++ b/util-core/src/main/scala/com/twitter/concurrent/Serialized.scala
@@ -28,9 +28,9 @@ trait Serialized {
     serializedQueue add { Job(result, () => f) }
 
     if (nwaiters.getAndIncrement() == 0) {
-      do {
+      while ({ {
         Try { serializedQueue.remove()() }
-      } while (nwaiters.decrementAndGet() > 0)
+      } ; nwaiters.decrementAndGet() > 0}) ()
     }
 
     result
diff --git a/util-core/src/main/scala/com/twitter/concurrent/Spool.scala b/util-core/src/main/scala/com/twitter/concurrent/Spool.scala
index c56a55c71e..0fdb10f0a6 100644
--- a/util-core/src/main/scala/com/twitter/concurrent/Spool.scala
+++ b/util-core/src/main/scala/com/twitter/concurrent/Spool.scala
@@ -78,12 +78,12 @@ sealed trait Spool[+A] {
       Future { f(Some(head)) } flatMap { _ =>
         tail transform {
           case Return(s) => s.foreachElem(f)
-          case Throw(_: EOFException) => Future { f(None) }
+          case Throw(_: EOFException) => Future { f(None); () }
           case Throw(cause) => Future.exception(cause)
         }
       }
     } else {
-      Future { f(None) }
+      Future { f(None); () }
     }
   }
 
@@ -273,8 +273,14 @@ sealed trait Spool[+A] {
 
 /**
  * Abstract `Spool` class for Java compatibility.
+ *
+ * The overrides for `++` are needed otherwise the java-compiler complains about two methods having the same erasure.
  */
-abstract class AbstractSpool[A] extends Spool[A]
+abstract class AbstractSpool[A] extends Spool[A] {
+  override def ++[B >: A](that: => Spool[B]): Spool[B] = super.++(that)
+
+  override def ++[B >: A](that: => Future[Spool[B]]): Future[Spool[B]] = super.++(that)
+}
 
 /**
  * Note: [[Spool]] is no longer the recommended asynchronous stream abstraction.
diff --git a/util-core/src/main/scala/com/twitter/conversions/DurationOps.scala b/util-core/src/main/scala/com/twitter/conversions/DurationOps.scala
index 8ca387897b..b802d41a4b 100644
--- a/util-core/src/main/scala/com/twitter/conversions/DurationOps.scala
+++ b/util-core/src/main/scala/com/twitter/conversions/DurationOps.scala
@@ -1,7 +1,9 @@
 package com.twitter.conversions
 
 import com.twitter.util.Duration
+
 import java.util.concurrent.TimeUnit
+import scala.language.implicitConversions
 
 /**
  * Implicits for writing readable [[com.twitter.util.Duration]]s.
@@ -19,7 +21,12 @@ import java.util.concurrent.TimeUnit
  */
 object DurationOps {
 
-  implicit class RichDuration(val numNanos: Long) extends AnyVal {
+  /**
+   * Forwarder for Int, as Scala 3.0 seems to not like the implicit conversion to Long.
+   */
+  implicit def richDurationFromIntNanos(numNanos: Int): RichDuration = new RichDuration(numNanos.toLong)
+
+  implicit class RichDuration(private val numNanos: Long) extends AnyVal {
     def nanoseconds: Duration = Duration(numNanos, TimeUnit.NANOSECONDS)
     def nanosecond: Duration = nanoseconds
     def microseconds: Duration = Duration(numNanos, TimeUnit.MICROSECONDS)
diff --git a/util-core/src/main/scala/com/twitter/conversions/StorageUnitOps.scala b/util-core/src/main/scala/com/twitter/conversions/StorageUnitOps.scala
index 28ee0ef9a5..d6a881e938 100644
--- a/util-core/src/main/scala/com/twitter/conversions/StorageUnitOps.scala
+++ b/util-core/src/main/scala/com/twitter/conversions/StorageUnitOps.scala
@@ -2,6 +2,8 @@ package com.twitter.conversions
 
 import com.twitter.util.StorageUnit
 
+import scala.language.implicitConversions
+
 /**
  * Implicits for writing readable [[com.twitter.util.StorageUnit]]s.
  *
@@ -16,7 +18,12 @@ import com.twitter.util.StorageUnit
  */
 object StorageUnitOps {
 
-  implicit class RichStorageUnit(val numBytes: Long) extends AnyVal {
+  /**
+   * Forwarder for Int, as Scala 3.0 seems to not like the implicit conversion to Long.
+   */
+  implicit def numBytesFromInt(numBytes: Int): RichStorageUnit = new RichStorageUnit(numBytes.toLong)
+
+  implicit class RichStorageUnit(private val numBytes: Long) extends AnyVal {
     def byte: StorageUnit = bytes
     def bytes: StorageUnit = StorageUnit.fromBytes(numBytes)
     def kilobyte: StorageUnit = kilobytes
diff --git a/util-core/src/main/scala/com/twitter/io/Buf.scala b/util-core/src/main/scala/com/twitter/io/Buf.scala
index cc54e985f1..eee08d65cd 100644
--- a/util-core/src/main/scala/com/twitter/io/Buf.scala
+++ b/util-core/src/main/scala/com/twitter/io/Buf.scala
@@ -429,7 +429,7 @@ object Buf {
     def slice(from: Int, until: Int): Buf = {
       checkSliceArgs(from, until)
 
-      if (isSliceEmpty(from, until)) return Buf.Empty
+      if (this.isSliceEmpty(from, until)) return Buf.Empty
       else if (isSliceIdentity(from, until)) return this
 
       var begin = from
@@ -503,7 +503,7 @@ object Buf {
 
     def process(from: Int, until: Int, processor: Processor): Int = {
       checkSliceArgs(from, until)
-      if (isSliceEmpty(from, until)) return -1
+      if (this.isSliceEmpty(from, until)) return -1
       var i = 0
       var bufIdx = 0
       var continue = true
@@ -620,7 +620,7 @@ object Buf {
 
     def process(from: Int, until: Int, processor: Processor): Int = {
       checkSliceArgs(from, until)
-      if (isSliceEmpty(from, until)) return -1
+      if (this.isSliceEmpty(from, until)) return -1
       var i = from
       var continue = true
       val endAt = math.min(until, length)
@@ -647,7 +647,7 @@ object Buf {
 
     def slice(from: Int, until: Int): Buf = {
       checkSliceArgs(from, until)
-      if (isSliceEmpty(from, until)) Buf.Empty
+      if (this.isSliceEmpty(from, until)) Buf.Empty
       else if (isSliceIdentity(from, until)) this
       else {
         val cap = math.min(until, length)
@@ -826,7 +826,7 @@ object Buf {
 
     def process(from: Int, until: Int, processor: Processor): Int = {
       checkSliceArgs(from, until)
-      if (isSliceEmpty(from, until)) return -1
+      if (this.isSliceEmpty(from, until)) return -1
       val pos = underlying.position()
       var i = from
       var continue = true
@@ -856,7 +856,7 @@ object Buf {
 
     def slice(from: Int, until: Int): Buf = {
       checkSliceArgs(from, until)
-      if (isSliceEmpty(from, until)) Buf.Empty
+      if (this.isSliceEmpty(from, until)) Buf.Empty
       else if (isSliceIdentity(from, until)) this
       else {
         val dup = underlying.duplicate()
diff --git a/util-core/src/main/scala/com/twitter/io/Pipe.scala b/util-core/src/main/scala/com/twitter/io/Pipe.scala
index 7f257775b6..a1c53656d7 100644
--- a/util-core/src/main/scala/com/twitter/io/Pipe.scala
+++ b/util-core/src/main/scala/com/twitter/io/Pipe.scala
@@ -145,36 +145,36 @@ final class Pipe[A](timer: Timer) extends Reader[A] with Writer[A] {
   }
 
   def write(buf: A): Future[Unit] = {
-    val (waiter, value, result) = synchronized {
+    val result = synchronized {
       state match {
         case State.Failed(exc) =>
-          (null, null, Future.exception(exc))
+          Right(Future.exception(exc))
 
         case State.Closed | State.Closing(_, _) =>
-          (null, null, Future.exception(new IllegalStateException("write() while closed")))
+          Right(Future.exception(new IllegalStateException("write() while closed")))
 
         case State.Idle =>
           val p = new Promise[Unit]
           state = State.Writing(buf, p)
-          (null, null, p)
+          Right(p)
 
-        case State.Reading(p) =>
+        case State.Reading(p: Promise[Option[A]]) =>
           // pending reader has enough space for the full write
           state = State.Idle
-          (p, Some(buf), Future.Done)
+          Left(() => p.setValue(Some(buf)))
 
         case State.Writing(_, _) =>
-          (
-            null,
-            null,
-            Future.exception(new IllegalStateException("write() while write is pending"))
-          )
+          Right(Future.exception(new IllegalStateException("write() while write is pending")))
       }
     }
 
-    // The waiter and the value are mutually inclusive so just checking against waiter is adequate.
-    if (waiter != null) waiter.setValue(value)
-    result
+    result.fold(
+      { l =>
+        l()
+        Future.Done
+      },
+      r => r
+    )
   }
 
   def fail(cause: Throwable): Unit = fail(cause, discard = false)
diff --git a/util-core/src/main/scala/com/twitter/io/TempFolder.scala b/util-core/src/main/scala/com/twitter/io/TempFolder.scala
index 25b1fd492c..8579904602 100644
--- a/util-core/src/main/scala/com/twitter/io/TempFolder.scala
+++ b/util-core/src/main/scala/com/twitter/io/TempFolder.scala
@@ -39,9 +39,9 @@ trait TempFolder {
     // Note: If we were willing to have a dependency on Guava in util-core
     // we could just use `com.google.common.io.Files.createTempDir()`
     var folder: File = null
-    do {
+    while ({ {
       folder = new File(tempFolder, "scala-test-" + System.currentTimeMillis)
-    } while (!folder.mkdir())
+    } ; !folder.mkdir()}) ()
     _folderName.set(folder)
 
     try {
diff --git a/util-core/src/main/scala/com/twitter/util/Awaitable.scala b/util-core/src/main/scala/com/twitter/util/Awaitable.scala
index 0f5e44b595..1b6ac0bd58 100644
--- a/util-core/src/main/scala/com/twitter/util/Awaitable.scala
+++ b/util-core/src/main/scala/com/twitter/util/Awaitable.scala
@@ -225,7 +225,7 @@ private[util] trait CloseAwaitably0[U <: Unit] extends Awaitable[U] {
 }
 
 // See https://stackoverflow.com/questions/26643045/java-interoperability-woes-with-scala-generics-and-boxing
-private[util] trait CloseOnceAwaitably0[U <: Unit] extends Awaitable[U] { self: CloseOnce =>
+private[util] trait CloseOnceAwaitably0[U <: Unit] extends Awaitable[U] { self: CloseOnce with com.twitter.util.Closable =>
 
   def ready(timeout: Duration)(implicit permit: Awaitable.CanAwait): this.type = {
     closeFuture.ready(timeout)
@@ -251,7 +251,7 @@ private[util] trait CloseOnceAwaitably0[U <: Unit] extends Awaitable[U] { self:
  * }
  * }}}
  */
-trait CloseOnceAwaitably extends CloseOnceAwaitably0[Unit] { self: CloseOnce => }
+trait CloseOnceAwaitably extends CloseOnceAwaitably0[Unit] { self: CloseOnce with com.twitter.util.Closable => }
 
 /**
  * A mixin to make an [[com.twitter.util.Awaitable]] out
diff --git a/util-core/src/main/scala/com/twitter/util/CloseOnce.scala b/util-core/src/main/scala/com/twitter/util/CloseOnce.scala
index f27ea6aca6..cfa2dbed0a 100644
--- a/util-core/src/main/scala/com/twitter/util/CloseOnce.scala
+++ b/util-core/src/main/scala/com/twitter/util/CloseOnce.scala
@@ -13,7 +13,7 @@ import scala.util.control.NonFatal
  * @see [[ClosableOnce.of]] for creating a proxy to a [[Closable]]
  *       that has already been instantiated.
  */
-trait CloseOnce { self: Closable =>
+trait CloseOnce extends Closable {
   // Our intrinsic lock for mutating the `closed` field
   private[this] val closePromise: Promise[Unit] = Promise[Unit]()
   @volatile private[this] var closed: Boolean = false
@@ -55,7 +55,7 @@ trait CloseOnce { self: Closable =>
    */
   final def isClosed: Boolean = closed
 
-  override final def close(deadline: Time): Future[Unit] = {
+  override def close(deadline: Time): Future[Unit] = {
     // only call `closeOnce()` and assign `closePromise` if this is the first `close()` invocation
     if (firstCloseInvoked()) {
       try {
diff --git a/util-core/src/main/scala/com/twitter/util/Disposable.scala b/util-core/src/main/scala/com/twitter/util/Disposable.scala
index d2b502a0f0..78d29bae7f 100644
--- a/util-core/src/main/scala/com/twitter/util/Disposable.scala
+++ b/util-core/src/main/scala/com/twitter/util/Disposable.scala
@@ -112,7 +112,7 @@ trait Managed[+T] { selfT =>
         u.dispose(deadline) transform {
           case Return(_) => t.dispose(deadline)
           case Throw(outer) =>
-            t.dispose transform {
+            t.dispose() transform {
               case Throw(inner) => Future.exception(new DoubleTrouble(outer, inner))
               case Return(_) => Future.exception(outer)
             }
diff --git a/util-core/src/main/scala/com/twitter/util/Duration.scala b/util-core/src/main/scala/com/twitter/util/Duration.scala
index 3125fa086b..5f41dac6fe 100644
--- a/util-core/src/main/scala/com/twitter/util/Duration.scala
+++ b/util-core/src/main/scala/com/twitter/util/Duration.scala
@@ -4,12 +4,12 @@ import java.io.Serializable
 import java.util.concurrent.TimeUnit
 
 object Duration extends TimeLikeOps[Duration] {
-  def fromNanoseconds(nanoseconds: Long): Duration =
+  override def fromNanoseconds(nanoseconds: Long): Duration =
     if (nanoseconds == 0L) Zero
     else new Duration(nanoseconds)
 
   // This is needed for Java compatibility.
-  override def fromFractionalSeconds(seconds: Double): Duration =
+  def fromFractionalSecondsJ(seconds: Double): Duration =
     super.fromFractionalSeconds(seconds)
   override def fromSeconds(seconds: Int): Duration = super.fromSeconds(seconds)
   override def fromMinutes(minutes: Int): Duration = super.fromMinutes(minutes)
diff --git a/util-core/src/main/scala/com/twitter/util/Promise.scala b/util-core/src/main/scala/com/twitter/util/Promise.scala
index 054306811b..f05217a495 100644
--- a/util-core/src/main/scala/com/twitter/util/Promise.scala
+++ b/util-core/src/main/scala/com/twitter/util/Promise.scala
@@ -1,6 +1,8 @@
 package com.twitter.util
 
 import com.twitter.concurrent.Scheduler
+
+import java.util.concurrent.atomic.{AtomicInteger, AtomicReference}
 import scala.annotation.tailrec
 import scala.runtime.NonLocalReturnControl
 import scala.util.control.NonFatal
@@ -144,7 +146,7 @@ object Promise {
    * A template trait for [[com.twitter.util.Promise Promises]] that are derived
    * and capable of being detached from other Promises.
    */
-  trait Detachable { _: Promise[_] =>
+  trait Detachable { self: Promise[_] =>
 
     /**
      * Returns true if successfully detached, will return true at most once.
@@ -184,11 +186,10 @@ object Promise {
       with (Try[A] => Unit) {
 
     // 0 represents not yet detached, 1 represents detached.
-    @volatile
-    private[this] var alreadyDetached: Int = 0
+    private[this] val alreadyDetached: AtomicInteger = new AtomicInteger(0)
 
     def detach(): Boolean =
-      unsafe.compareAndSwapInt(this, detachedFutureOffset, 0, 1)
+      alreadyDetached.compareAndSet(0, 1)
 
     def apply(result: Try[A]): Unit = if (detach()) update(result)
 
@@ -306,13 +307,6 @@ object Promise {
    */
   private class Interrupted[A](val waitq: WaitQueue[A], val signal: Throwable)
 
-  private val unsafe: sun.misc.Unsafe = Unsafe()
-  private val stateOff: Long =
-    unsafe.objectFieldOffset(classOf[Promise[_]].getDeclaredField("state"))
-
-  private val detachedFutureOffset: Long =
-    unsafe.objectFieldOffset(classOf[DetachableFuture[_]].getDeclaredField("alreadyDetached"))
-
   private val AlwaysUnit: Any => Unit = _ => ()
 
   sealed trait Responder[A] { this: Future[A] =>
@@ -467,26 +461,26 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
   // - Transforming
   // - Try[A] (Done)
   // - Promise[A]
-  @volatile private[this] var state: Any = WaitQueue.empty[A]
-  private def theState(): Any = state
+  private[this] val state: AtomicReference[Any] = new AtomicReference[Any](WaitQueue.empty[A])
+  private def theState(): Any = state.get()
 
-  private[util] def this(forwardInterrupts: Future[_]) {
+  private[util] def this(forwardInterrupts: Future[_]) = {
     this()
-    this.state = new Transforming[A](WaitQueue.empty, forwardInterrupts)
+    this.state.set(new Transforming[A](WaitQueue.empty, forwardInterrupts))
   }
 
-  def this(handleInterrupt: PartialFunction[Throwable, Unit]) {
+  def this(handleInterrupt: PartialFunction[Throwable, Unit]) = {
     this()
-    this.state = new Interruptible[A](WaitQueue.empty, handleInterrupt, Local.save())
+    this.state.set(new Interruptible[A](WaitQueue.empty, handleInterrupt, Local.save()))
   }
 
-  def this(result: Try[A]) {
+  def this(result: Try[A]) = {
     this()
-    this.state = result
+    this.state.set(result)
   }
 
   override def toString: String = {
-    val theState = state match {
+    val theState = state.get() match {
       case waitq: WaitQueue[A] => s"Waiting($waitq)"
       case s: Interruptible[A] => s"Interruptible(${s.waitq},${s.handler})"
       case s: Transforming[A] => s"Transforming(${s.waitq},${s.other})"
@@ -498,7 +492,7 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
   }
 
   @inline private[this] def cas(oldState: Any, newState: Any): Boolean =
-    unsafe.compareAndSwapObject(this, stateOff, oldState, newState)
+    state.compareAndSet(oldState, newState)
 
   /**
    * (Re)sets the interrupt handler. There is only
@@ -507,7 +501,7 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
    * @param f the new interrupt handler
    */
   @tailrec
-  final def setInterruptHandler(f: PartialFunction[Throwable, Unit]): Unit = state match {
+  final def setInterruptHandler(f: PartialFunction[Throwable, Unit]): Unit = state.get() match {
     case waitq: WaitQueue[A] =>
       if (!cas(waitq, new Interruptible(waitq, f, Local.save())))
         setInterruptHandler(f)
@@ -529,7 +523,7 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
   }
 
   // Useful for debugging waitq.
-  private[util] def waitqLength: Int = state match {
+  private[util] def waitqLength: Int = state.get() match {
     case waitq: WaitQueue[A] => waitq.size
     case s: Interruptible[A] => s.waitq.size
     case s: Transforming[A] => s.waitq.size
@@ -549,7 +543,7 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
   @tailrec final def forwardInterruptsTo(other: Future[_]): Unit = {
     // This reduces allocations in the common case.
     if (other.isDefined) return
-    state match {
+    state.get() match {
       case waitq: WaitQueue[A] =>
         if (!cas(waitq, new Transforming(waitq, other)))
           forwardInterruptsTo(other)
@@ -571,7 +565,7 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
     }
   }
 
-  @tailrec final def raise(intr: Throwable): Unit = state match {
+  final def raise(intr: Throwable): Unit = state.get() match {
     case waitq: WaitQueue[A] =>
       if (!cas(waitq, new Interrupted(waitq, intr)))
         raise(intr)
@@ -601,7 +595,7 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
     case p: Promise[A] /* Linked */ => p.raise(intr)
   }
 
-  @tailrec protected[Promise] final def detach(k: K[A]): Boolean = state match {
+  @tailrec protected[Promise] final def detach(k: K[A]): Boolean = state.get() match {
     case waitq: WaitQueue[A] =>
       if (!cas(waitq, waitq.remove(k)))
         detach(k)
@@ -634,7 +628,7 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
   // Awaitable
   @throws(classOf[TimeoutException])
   @throws(classOf[InterruptedException])
-  def ready(timeout: Duration)(implicit permit: Awaitable.CanAwait): this.type = state match {
+  def ready(timeout: Duration)(implicit permit: Awaitable.CanAwait): this.type = state.get() match {
     case _: WaitQueue[A] | _: Interruptible[A] | _: Interrupted[A] | _: Transforming[A] =>
       val condition = new ReleaseOnApplyCDL[A]
       respond(condition)
@@ -668,7 +662,7 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
   /**
    * Returns this promise's interrupt if it is interrupted.
    */
-  def isInterrupted: Option[Throwable] = state match {
+  def isInterrupted: Option[Throwable] = state.get() match {
     case _: WaitQueue[A] | _: Interruptible[A] | _: Transforming[A] => None
     case s: Interrupted[A] => Some(s.signal)
     case _: Try[A] /* Done */ => None
@@ -779,7 +773,7 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
    * @return true only if the result is updated, false if it was already set.
    */
   @tailrec
-  final def updateIfEmpty(result: Try[A]): Boolean = state match {
+  final def updateIfEmpty(result: Try[A]): Boolean = state.get() match {
     case waitq: WaitQueue[A] =>
       if (!cas(waitq, result)) updateIfEmpty(result)
       else {
@@ -812,7 +806,7 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
   }
 
   @tailrec
-  protected final def continue(k: K[A]): Unit = state match {
+  protected final def continue(k: K[A]): Unit = state.get() match {
     case waitq: WaitQueue[A] =>
       if (!cas(waitq, WaitQueue(k, waitq)))
         continue(k)
@@ -833,12 +827,12 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
    * Should only be called when this Promise has already been fulfilled
    * or it is becoming another Future via `become`.
    */
-  protected final def compress(): Promise[A] = state match {
+  protected final def compress(): Promise[A] = state.get() match {
     case p: Promise[A] /* Linked */ =>
       val target = p.compress()
       // due to the assumptions stated above regarding when this can be called,
       // there should never be a `cas` fail.
-      state = target
+      state.set(target)
       target
 
     case _ => this
@@ -848,7 +842,7 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
   protected final def link(target: Promise[A]): Unit = {
     if (this eq target) return
 
-    state match {
+    state.get() match {
       case waitq: WaitQueue[A] =>
         if (!cas(waitq, target)) link(target)
         else target.continueAll(waitq)
@@ -885,13 +879,13 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
     }
   }
 
-  def poll: Option[Try[A]] = state match {
+  def poll: Option[Try[A]] = state.get() match {
     case res: Try[A] /* Done */ => Some(res)
     case p: Promise[A] /* Linked */ => p.poll
     case _ /* WaitQueue, Interruptible, Interrupted, or Transforming */ => None
   }
 
-  override def isDefined: Boolean = state match {
+  override def isDefined: Boolean = state.get() match {
     // Note: the basic implementation is the same as `poll()`, but we want to avoid doing
     // object allocations for `Some`s when the caller does not need the result.
     case _: Try[A] /* Done */ => true
diff --git a/util-core/src/main/scala/com/twitter/util/Signal.scala b/util-core/src/main/scala/com/twitter/util/Signal.scala
index 333af1588d..2a945361c1 100644
--- a/util-core/src/main/scala/com/twitter/util/Signal.scala
+++ b/util-core/src/main/scala/com/twitter/util/Signal.scala
@@ -23,7 +23,7 @@ import scala.collection.{Map, Set, mutable}
 object SignalHandlerFactory {
   def apply(): Option[SunSignalHandler] = {
     // only one actual implementation for now
-    SunSignalHandler.instantiate
+    SunSignalHandler.instantiate()
   }
 }
 
diff --git a/util-core/src/main/scala/com/twitter/util/Time.scala b/util-core/src/main/scala/com/twitter/util/Time.scala
index dcf80ad0d0..0d5dced4ad 100644
--- a/util-core/src/main/scala/com/twitter/util/Time.scala
+++ b/util-core/src/main/scala/com/twitter/util/Time.scala
@@ -294,7 +294,7 @@ object Time extends TimeLikeOps[Time] {
   def fromNanoseconds(nanoseconds: Long): Time = new Time(nanoseconds)
 
   // This is needed for Java compatibility.
-  override def fromFractionalSeconds(seconds: Double): Time = super.fromFractionalSeconds(seconds)
+  def fromFractionalSecondsJ(seconds: Double): Time = super.fromFractionalSeconds(seconds)
   override def fromSeconds(seconds: Int): Time = super.fromSeconds(seconds)
   override def fromMinutes(minutes: Int): Time = super.fromMinutes(minutes)
   override def fromMilliseconds(millis: Long): Time = super.fromMilliseconds(millis)
diff --git a/util-core/src/main/scala/com/twitter/util/Var.scala b/util-core/src/main/scala/com/twitter/util/Var.scala
index 0dd17eb98e..9af4c33c07 100644
--- a/util-core/src/main/scala/com/twitter/util/Var.scala
+++ b/util-core/src/main/scala/com/twitter/util/Var.scala
@@ -271,7 +271,7 @@ object Var {
 
     // In order to support unsubscribing from diffs when v is no longer referenced
     // we must avoid diffs keeping a strong reference to v.
-    val witness = Witness.weakReference { diff: Diff[CC, T] =>
+    val witness = Witness.weakReference { (diff: Diff[CC, T]) =>
       synchronized {
         v.update(diff.patch(v()))
       }
diff --git a/util-core/src/test/java/com/twitter/concurrent/SpoolCompilationTest.java b/util-core/src/test/java/com/twitter/concurrent/SpoolCompilationTest.java
index 2b89e1b9d6..d083e6d95b 100644
--- a/util-core/src/test/java/com/twitter/concurrent/SpoolCompilationTest.java
+++ b/util-core/src/test/java/com/twitter/concurrent/SpoolCompilationTest.java
@@ -4,6 +4,7 @@
 import com.twitter.util.Future;
 import org.junit.Assert;
 import org.junit.Test;
+import scala.Function0;
 import scala.collection.JavaConverters;
 
 import java.util.Arrays;
diff --git a/util-core/src/test/java/com/twitter/util/AwaitableCompilationTest.java b/util-core/src/test/java/com/twitter/util/AwaitableCompilationTest.java
index 3fdae8ea17..6e3e6d4e71 100644
--- a/util-core/src/test/java/com/twitter/util/AwaitableCompilationTest.java
+++ b/util-core/src/test/java/com/twitter/util/AwaitableCompilationTest.java
@@ -8,6 +8,8 @@
 import java.util.Arrays;
 import java.util.Collection;
 
+import com.twitter.util.Awaitable.CanAwait;
+
 public class AwaitableCompilationTest {
 
   public static class MockAwaitable implements Awaitable<String> {
diff --git a/util-core/src/test/java/com/twitter/util/TimeCompilationTest.java b/util-core/src/test/java/com/twitter/util/TimeCompilationTest.java
index 810e568407..1c917d4499 100644
--- a/util-core/src/test/java/com/twitter/util/TimeCompilationTest.java
+++ b/util-core/src/test/java/com/twitter/util/TimeCompilationTest.java
@@ -37,7 +37,7 @@ public void testFrom() {
     Time b = Time.fromMilliseconds(1000);
     Time c = Time.fromMicroseconds(1000000);
     Time d = Time.fromNanoseconds(1000000000);
-    Time e = Time.fromFractionalSeconds(1.0);
+    Time e = Time.fromFractionalSecondsJ(1.0);
 
     Assert.assertEquals(e, a);
     Assert.assertEquals(a, b);
diff --git a/util-core/src/test/scala/com/twitter/concurrent/AsyncStreamTest.scala b/util-core/src/test/scala/com/twitter/concurrent/AsyncStreamTest.scala
index 60b394610b..d46da25cb3 100644
--- a/util-core/src/test/scala/com/twitter/concurrent/AsyncStreamTest.scala
+++ b/util-core/src/test/scala/com/twitter/concurrent/AsyncStreamTest.scala
@@ -631,15 +631,15 @@ class AsyncStreamTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     }
 
     test(s"$impl: sum") {
-      forAll { xs: List[Int] => assert(xs.sum == await(fromSeq(xs).sum)) }
+      forAll { (xs: List[Int]) => assert(xs.sum == await(fromSeq(xs).sum)) }
     }
 
     test(s"$impl: size") {
-      forAll { xs: List[Int] => assert(xs.size == await(fromSeq(xs).size)) }
+      forAll { (xs: List[Int]) => assert(xs.size == await(fromSeq(xs).size)) }
     }
 
     test(s"$impl: force") {
-      forAll { xs: List[Int] =>
+      forAll { (xs: List[Int]) =>
         val p = new Promise[Unit]
         // The promise will be defined iff the tail is forced.
         val s = fromSeq(xs) ++ { p.setDone(); AsyncStream.empty }
@@ -745,7 +745,7 @@ class AsyncStreamTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
 
       val stream = tailRecM(0) { i => AsyncStream.of(if (i < n) Left(i + 1) else Right(i)) }
 
-      assert(Await.result(stream.toSeq) == Seq(n))
+      assert(Await.result(stream.toSeq()) == Seq(n))
     }
   }
 
diff --git a/util-core/src/test/scala/com/twitter/conversions/StringOpsTest.scala b/util-core/src/test/scala/com/twitter/conversions/StringOpsTest.scala
index f00df0459d..01aa321732 100644
--- a/util-core/src/test/scala/com/twitter/conversions/StringOpsTest.scala
+++ b/util-core/src/test/scala/com/twitter/conversions/StringOpsTest.scala
@@ -22,23 +22,23 @@ import org.scalatest.funsuite.AnyFunSuite
 class StringOpsTest extends AnyFunSuite {
 
   test("string#quoteC") {
-    assert("nothing".quoteC == "nothing")
+    assert("nothing".quoteC() == "nothing")
     assert(
-      "name\tvalue\t\u20acb\u00fcllet?\u20ac".quoteC == "name\\tvalue\\t\\u20acb\\xfcllet?\\u20ac"
+      "name\tvalue\t\u20acb\u00fcllet?\u20ac".quoteC() == "name\\tvalue\\t\\u20acb\\xfcllet?\\u20ac"
     )
-    assert("she said \"hello\"".quoteC == "she said \\\"hello\\\"")
-    assert("\\backslash".quoteC == "\\\\backslash")
+    assert("she said \"hello\"".quoteC() == "she said \\\"hello\\\"")
+    assert("\\backslash".quoteC() == "\\\\backslash")
   }
 
   test("string#unquoteC") {
-    assert("nothing".unquoteC == "nothing")
+    assert("nothing".unquoteC() == "nothing")
     assert(
-      "name\\tvalue\\t\\u20acb\\xfcllet?\\u20ac".unquoteC == "name\tvalue\t\u20acb\u00fcllet?\u20ac"
+      "name\\tvalue\\t\\u20acb\\xfcllet?\\u20ac".unquoteC() == "name\tvalue\t\u20acb\u00fcllet?\u20ac"
     )
-    assert("she said \\\"hello\\\"".unquoteC == "she said \"hello\"")
-    assert("\\\\backslash".unquoteC == "\\backslash")
-    assert("real\\$dollar".unquoteC == "real\\$dollar")
-    assert("silly\\/quote".unquoteC == "silly/quote")
+    assert("she said \\\"hello\\\"".unquoteC() == "she said \"hello\"")
+    assert("\\\\backslash".unquoteC() == "\\backslash")
+    assert("real\\$dollar".unquoteC() == "real\\$dollar")
+    assert("silly\\/quote".unquoteC() == "silly/quote")
   }
 
   test("string#hexlify") {
@@ -47,10 +47,10 @@ class StringOpsTest extends AnyFunSuite {
   }
 
   test("string#unhexlify") {
-    assert("656c6c".unhexlify.toList == "hello".getBytes.slice(1, 4).toList)
-    assert("68656c6c6f".unhexlify.toList == "hello".getBytes.toList)
-    "5".unhexlify
-    assert("5".unhexlify.hexlify.toInt == 5)
+    assert("656c6c".unhexlify().toList == "hello".getBytes.slice(1, 4).toList)
+    assert("68656c6c6f".unhexlify().toList == "hello".getBytes.toList)
+    "5".unhexlify()
+    assert("5".unhexlify().hexlify.toInt == 5)
   }
 
   test("string#toCamelCase") {
diff --git a/util-core/src/test/scala/com/twitter/conversions/U64OpsTest.scala b/util-core/src/test/scala/com/twitter/conversions/U64OpsTest.scala
index a25f4cf076..942c41bb8c 100644
--- a/util-core/src/test/scala/com/twitter/conversions/U64OpsTest.scala
+++ b/util-core/src/test/scala/com/twitter/conversions/U64OpsTest.scala
@@ -7,11 +7,11 @@ class U64OpsTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
   import com.twitter.conversions.U64Ops._
 
   test("toU64HextString") {
-    forAll { l: Long => assert(l.toU64HexString == "%016x".format(l)) }
+    forAll { (l: Long) => assert(l.toU64HexString == "%016x".format(l)) }
   }
 
   test("toU64Long") {
-    forAll { l: Long =>
+    forAll { (l: Long) =>
       val s = "%016x".format(l)
       assert(s.toU64Long == java.lang.Long.parseUnsignedLong(s, 16))
     }
diff --git a/util-core/src/test/scala/com/twitter/io/BufByteWriterTest.scala b/util-core/src/test/scala/com/twitter/io/BufByteWriterTest.scala
index c6bc755597..7b835ba818 100644
--- a/util-core/src/test/scala/com/twitter/io/BufByteWriterTest.scala
+++ b/util-core/src/test/scala/com/twitter/io/BufByteWriterTest.scala
@@ -33,7 +33,7 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
   }
 
   def testWriteByte(name: String, bwFactory: () => BufByteWriter, overflowOK: Boolean): Unit =
-    test(s"$name: writeByte")(forAll { byte: Byte =>
+    test(s"$name: writeByte")(forAll { (byte: Byte) =>
       val bw = bwFactory()
       val buf = bw.writeByte(byte).owned()
 
@@ -43,7 +43,7 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
     })
 
   def testWriteShort(name: String, bwFactory: () => BufByteWriter, overflowOK: Boolean): Unit =
-    test(s"$name: writeShort{BE,LE}")(forAll { s: Short =>
+    test(s"$name: writeShort{BE,LE}")(forAll { (s: Short) =>
       val be = bwFactory().writeShortBE(s)
       val le = bwFactory().writeShortLE(s)
 
@@ -64,7 +64,7 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
     })
 
   def testWriteMedium(name: String, bwFactory: () => BufByteWriter, overflowOK: Boolean): Unit =
-    test(s"$name: writeMedium{BE,LE}")(forAll { m: Int =>
+    test(s"$name: writeMedium{BE,LE}")(forAll { (m: Int) =>
       val be = bwFactory().writeMediumBE(m)
       val le = bwFactory().writeMediumLE(m)
 
@@ -86,7 +86,7 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
     })
 
   def testWriteInt(name: String, bwFactory: () => BufByteWriter, overflowOK: Boolean): Unit =
-    test(s"$name: writeInt{BE,LE}")(forAll { i: Int =>
+    test(s"$name: writeInt{BE,LE}")(forAll { (i: Int) =>
       val be = bwFactory().writeIntBE(i)
       val le = bwFactory().writeIntLE(i)
 
@@ -109,7 +109,7 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
     })
 
   def testWriteLong(name: String, bwFactory: () => BufByteWriter, overflowOK: Boolean): Unit =
-    test(s"$name: writeLong{BE,LE}")(forAll { l: Long =>
+    test(s"$name: writeLong{BE,LE}")(forAll { (l: Long) =>
       val be = bwFactory().writeLongBE(l)
       val le = bwFactory().writeLongLE(l)
 
@@ -136,7 +136,7 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
     })
 
   def testWriteFloat(name: String, bwFactory: () => BufByteWriter, overflowOK: Boolean): Unit =
-    test(s"$name: writeFloat{BE,LE}")(forAll { f: Float =>
+    test(s"$name: writeFloat{BE,LE}")(forAll { (f: Float) =>
       val be = bwFactory().writeFloatBE(f)
       val le = bwFactory().writeFloatLE(f)
 
@@ -161,7 +161,7 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
     })
 
   def testWriteDouble(name: String, bwFactory: () => BufByteWriter, overflowOK: Boolean): Unit =
-    test(s"$name: writeDouble{BE,LE}")(forAll { d: Double =>
+    test(s"$name: writeDouble{BE,LE}")(forAll { (d: Double) =>
       val be = bwFactory().writeDoubleBE(d)
       val le = bwFactory().writeDoubleLE(d)
 
@@ -195,9 +195,9 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
   }
 
   test("trims unwritten bytes") {
-    assert(BufByteWriter.fixed(5).owned.length == 0)
-    assert(BufByteWriter.fixed(5).writeIntBE(1).owned.length == 4)
-    assert(BufByteWriter.fixed(4).writeIntBE(1).owned.length == 4)
+    assert(BufByteWriter.fixed(5).owned().length == 0)
+    assert(BufByteWriter.fixed(5).writeIntBE(1).owned().length == 4)
+    assert(BufByteWriter.fixed(4).writeIntBE(1).owned().length == 4)
   }
 
   testWriteString("fixed", size => BufByteWriter.fixed(size), overflowOK = false)
@@ -209,7 +209,7 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
   testWriteFloat("fixed", () => BufByteWriter.fixed(4), overflowOK = false)
   testWriteDouble("fixed", () => BufByteWriter.fixed(8), overflowOK = false)
 
-  test("fixed: writeBytes(Array[Byte])")(forAll { bytes: Array[Byte] =>
+  test("fixed: writeBytes(Array[Byte])")(forAll { (bytes: Array[Byte]) =>
     val bw = BufByteWriter.fixed(bytes.length)
     val buf = bw.writeBytes(bytes).owned()
     intercept[OverflowException] { bw.writeByte(0xff) }
@@ -217,7 +217,7 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
     assertIndex(bw, bytes.length)
   })
 
-  test("fixed: writeBytes(Array[Byte]) 2 times")(forAll { bytes: Array[Byte] =>
+  test("fixed: writeBytes(Array[Byte]) 2 times")(forAll { (bytes: Array[Byte]) =>
     val bw = BufByteWriter.fixed(bytes.length * 2)
     val buf = bw.writeBytes(bytes).writeBytes(bytes).owned()
     intercept[OverflowException] { bw.writeByte(0xff) }
@@ -226,7 +226,7 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
     assertIndex(bw, bytes.length * 2)
   })
 
-  test("fixed: writeBytes(Buf)")(forAll { arr: Array[Byte] =>
+  test("fixed: writeBytes(Buf)")(forAll { (arr: Array[Byte]) =>
     val bytes = Buf.ByteArray.Owned(arr)
     val bw = BufByteWriter.fixed(bytes.length)
     val buf = bw.writeBytes(bytes).owned()
@@ -235,7 +235,7 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
     assertIndex(bw, bytes.length)
   })
 
-  test("fixed: writeBytes(Buf) 2 times")(forAll { arr: Array[Byte] =>
+  test("fixed: writeBytes(Buf) 2 times")(forAll { (arr: Array[Byte]) =>
     val bytes = Buf.ByteArray.Owned(arr)
     val bw = BufByteWriter.fixed(bytes.length * 2)
     val buf = bw.writeBytes(bytes).writeBytes(bytes).owned()
@@ -263,20 +263,20 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
     overflowOK = true
   )
 
-  test("dynamic: writeBytes(Array[Byte])")(forAll { bytes: Array[Byte] =>
+  test("dynamic: writeBytes(Array[Byte])")(forAll { (bytes: Array[Byte]) =>
     val bw = BufByteWriter.dynamic()
     val buf = bw.writeBytes(bytes).owned()
     assert(buf == Buf.ByteArray.Owned(bytes))
   })
 
-  test("dynamic: writeBytes(Buf)")(forAll { arr: Array[Byte] =>
+  test("dynamic: writeBytes(Buf)")(forAll { (arr: Array[Byte]) =>
     val bytes = Buf.ByteArray.Owned(arr)
     val bw = BufByteWriter.dynamic()
     val buf = bw.writeBytes(bytes).owned()
     assert(buf == bytes)
   })
 
-  test("dynamic: writeBytes(Array[Byte]) 3 times")(forAll { bytes: Array[Byte] =>
+  test("dynamic: writeBytes(Array[Byte]) 3 times")(forAll { (bytes: Array[Byte]) =>
     val bw = BufByteWriter.dynamic()
     val buf = bw
       .writeBytes(bytes)
@@ -286,7 +286,7 @@ final class BufByteWriterTest extends AnyFunSuite with ScalaCheckDrivenPropertyC
     assert(buf == Buf.ByteArray.Owned(bytes ++ bytes ++ bytes))
   })
 
-  test("dynamic: writeBytes(Buf) 3 times")(forAll { arr: Array[Byte] =>
+  test("dynamic: writeBytes(Buf) 3 times")(forAll { (arr: Array[Byte]) =>
     val bytes = Buf.ByteArray.Owned(arr)
     val bw = BufByteWriter.dynamic()
     val buf = bw
diff --git a/util-core/src/test/scala/com/twitter/io/BufReaderTest.scala b/util-core/src/test/scala/com/twitter/io/BufReaderTest.scala
index c7bb9a4393..ccdca2b0aa 100644
--- a/util-core/src/test/scala/com/twitter/io/BufReaderTest.scala
+++ b/util-core/src/test/scala/com/twitter/io/BufReaderTest.scala
@@ -13,7 +13,7 @@ class BufReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
   private def await[A](f: Future[A]): A = Await.result(f, 5.seconds)
 
   test("BufReader - apply(buf)") {
-    forAll { bytes: String =>
+    forAll { (bytes: String) =>
       val buf = Buf.Utf8(bytes)
       val r = BufReader(buf)
       assert(await(BufReader.readAll(r)) == buf)
@@ -35,7 +35,7 @@ class BufReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
   }
 
   test("BufReader - readAll") {
-    forAll { bytes: String =>
+    forAll { (bytes: String) =>
       val r = Reader.fromBuf(Buf.Utf8(bytes))
       assert(await(BufReader.readAll(r)) == Buf.Utf8(bytes))
     }
@@ -85,7 +85,7 @@ class BufReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
       } yield Buf.ByteArray.Owned(bytes)
     )
 
-    forAll(getByteArrays) { buffers: Seq[Buf] =>
+    forAll(getByteArrays) { (buffers: Seq[Buf]) =>
       val buffersWithLength = buffers.map(buf => Buf.U32BE(buf.length).concat(buf))
 
       val r = BufReader.framed(BufReader(Buf(buffersWithLength)), new BufReaderTest.U32BEFramer())
diff --git a/util-core/src/test/scala/com/twitter/io/BufTest.scala b/util-core/src/test/scala/com/twitter/io/BufTest.scala
index c5156a3e3e..948c3b1293 100644
--- a/util-core/src/test/scala/com/twitter/io/BufTest.scala
+++ b/util-core/src/test/scala/com/twitter/io/BufTest.scala
@@ -1035,7 +1035,7 @@ class BufTest
       buf <- arbBuf.arbitrary
     } yield Buf(Seq.fill(n)(buf))
 
-    forAll(Gen.listOf(bufGen)) { bufs: List[Buf] =>
+    forAll(Gen.listOf(bufGen)) { (bufs: List[Buf]) =>
       val concatLeft = bufs.foldLeft(Buf.Empty) { (l, r) => l.concat(r) }
       val concatRight = bufs.foldRight(Buf.Empty) { (l, r) => l.concat(r) }
       val constructor = Buf(bufs)
diff --git a/util-core/src/test/scala/com/twitter/io/ByteReaderTest.scala b/util-core/src/test/scala/com/twitter/io/ByteReaderTest.scala
index 1239a160df..9b0618fcc2 100644
--- a/util-core/src/test/scala/com/twitter/io/ByteReaderTest.scala
+++ b/util-core/src/test/scala/com/twitter/io/ByteReaderTest.scala
@@ -33,13 +33,13 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     intercept[UnderflowException] { br.readByte() }
   })
 
-  test("readByte")(forAll { byte: Byte =>
+  test("readByte")(forAll { (byte: Byte) =>
     val br = readerWith(byte)
     assert(br.readByte() == byte)
     intercept[UnderflowException] { br.readByte() }
   })
 
-  test("readShortBE")(forAll { s: Short =>
+  test("readShortBE")(forAll { (s: Short) =>
     val br = readerWith(
       ((s >> 8) & 0xff).toByte,
       ((s) & 0xff).toByte
@@ -50,7 +50,7 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     intercept[UnderflowException] { br.readByte() }
   })
 
-  test("readShortLE")(forAll { s: Short =>
+  test("readShortLE")(forAll { (s: Short) =>
     val br = readerWith(
       ((s) & 0xff).toByte,
       ((s >> 8) & 0xff).toByte
@@ -62,7 +62,7 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     intercept[UnderflowException] { br.readByte() }
   })
 
-  test("readUnsignedMediumBE")(forAll { m: Int =>
+  test("readUnsignedMediumBE")(forAll { (m: Int) =>
     val br = readerWith(
       ((m >> 16) & 0xff).toByte,
       ((m >> 8) & 0xff).toByte,
@@ -72,7 +72,7 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     intercept[UnderflowException] { br.readByte() }
   })
 
-  test("readUnsignedMediumLE")(forAll { m: Int =>
+  test("readUnsignedMediumLE")(forAll { (m: Int) =>
     val br = readerWith(
       ((m) & 0xff).toByte,
       ((m >> 8) & 0xff).toByte,
@@ -82,7 +82,7 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     intercept[UnderflowException] { br.readByte() }
   })
 
-  test("readIntBE")(forAll { i: Int =>
+  test("readIntBE")(forAll { (i: Int) =>
     val br = readerWith(
       ((i >> 24) & 0xff).toByte,
       ((i >> 16) & 0xff).toByte,
@@ -93,7 +93,7 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     intercept[UnderflowException] { br.readByte() }
   })
 
-  test("readIntLE")(forAll { i: Int =>
+  test("readIntLE")(forAll { (i: Int) =>
     val br = readerWith(
       ((i) & 0xff).toByte,
       ((i >> 8) & 0xff).toByte,
@@ -104,7 +104,7 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     intercept[UnderflowException] { br.readByte() }
   })
 
-  test("readLongBE")(forAll { l: Long =>
+  test("readLongBE")(forAll { (l: Long) =>
     val br = readerWith(
       ((l >> 56) & 0xff).toByte,
       ((l >> 48) & 0xff).toByte,
@@ -119,7 +119,7 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     intercept[UnderflowException] { br.readByte() }
   })
 
-  test("readLongLE")(forAll { l: Long =>
+  test("readLongLE")(forAll { (l: Long) =>
     val br = readerWith(
       ((l) & 0xff).toByte,
       ((l >> 8) & 0xff).toByte,
@@ -134,41 +134,41 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     intercept[UnderflowException] { br.readByte() }
   })
 
-  test("readUnsignedByte")(forAll { b: Byte =>
+  test("readUnsignedByte")(forAll { (b: Byte) =>
     val br = new ByteReaderImpl(Buf.Empty) { override def readByte() = b }
     assert(br.readUnsignedByte() == (b & 0xff))
   })
 
-  test("readUnsignedShortBE")(forAll { s: Short =>
+  test("readUnsignedShortBE")(forAll { (s: Short) =>
     val br = new ByteReaderImpl(Buf.Empty) { override def readShortBE() = s }
     assert(br.readUnsignedShortBE() == (s & 0xffff))
   })
 
-  test("readUnsignedShortLE")(forAll { s: Short =>
+  test("readUnsignedShortLE")(forAll { (s: Short) =>
     val br = new ByteReaderImpl(Buf.Empty) { override def readShortLE() = s }
     assert(br.readUnsignedShortLE() == (s & 0xffff))
   })
 
-  test("readMediumBE")(forAll { i: Int =>
+  test("readMediumBE")(forAll { (i: Int) =>
     val m = maskMedium(i)
     val br = new ByteReaderImpl(Buf.Empty) { override def readUnsignedMediumBE() = m }
     val expected = if (m > SignedMediumMax) m | 0xff000000 else m
     assert(br.readMediumBE() == expected)
   })
 
-  test("readMediumLE")(forAll { i: Int =>
+  test("readMediumLE")(forAll { (i: Int) =>
     val m = maskMedium(i)
     val br = new ByteReaderImpl(Buf.Empty) { override def readUnsignedMediumLE() = m }
     val expected = if (m > SignedMediumMax) m | 0xff000000 else m
     assert(br.readMediumLE() == expected)
   })
 
-  test("readUnsignedIntBE")(forAll { i: Int =>
+  test("readUnsignedIntBE")(forAll { (i: Int) =>
     val br = new ByteReaderImpl(Buf.Empty) { override def readIntBE() = i }
     assert(br.readUnsignedIntBE() == (i & 0xffffffffL))
   })
 
-  test("readUnsignedIntLE")(forAll { i: Int =>
+  test("readUnsignedIntLE")(forAll { (i: Int) =>
     val br = new ByteReaderImpl(Buf.Empty) { override def readIntLE() = i }
     assert(br.readUnsignedIntLE() == (i & 0xffffffffL))
   })
@@ -177,7 +177,7 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     .chooseNum(Long.MinValue, Long.MaxValue)
     .map(x => BigInt(x) + BigInt(2).pow(63))
 
-  test("readUnsignedLongBE")(forAll(uInt64s) { bi: BigInt =>
+  test("readUnsignedLongBE")(forAll(uInt64s) { (bi: BigInt) =>
     val br = readerWith(
       ((bi >> 56) & 0xff).toByte,
       ((bi >> 48) & 0xff).toByte,
@@ -192,7 +192,7 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     intercept[UnderflowException] { br.readByte() }
   })
 
-  test("readUnsignedLongLE")(forAll(uInt64s) { bi1: BigInt =>
+  test("readUnsignedLongLE")(forAll(uInt64s) { (bi1: BigInt) =>
     val bi = bi1.abs
     val br = readerWith(
       ((bi) & 0xff).toByte,
@@ -209,27 +209,27 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
   })
 
   // .equals is required to handle NaN
-  test("readFloatBE")(forAll { i: Int =>
+  test("readFloatBE")(forAll { (i: Int) =>
     val br = new ByteReaderImpl(Buf.Empty) { override def readIntBE() = i }
     assert(br.readFloatBE().equals(JFloat.intBitsToFloat(i)))
   })
 
-  test("readFloatLE")(forAll { i: Int =>
+  test("readFloatLE")(forAll { (i: Int) =>
     val br = new ByteReaderImpl(Buf.Empty) { override def readIntLE() = i }
     assert(br.readFloatLE().equals(JFloat.intBitsToFloat(i)))
   })
 
-  test("readDoubleBE")(forAll { l: Long =>
+  test("readDoubleBE")(forAll { (l: Long) =>
     val br = new ByteReaderImpl(Buf.Empty) { override def readLongBE() = l }
     assert(br.readDoubleBE().equals(JDouble.longBitsToDouble(l)))
   })
 
-  test("readDoubleLE")(forAll { l: Long =>
+  test("readDoubleLE")(forAll { (l: Long) =>
     val br = new ByteReaderImpl(Buf.Empty) { override def readLongLE() = l }
     assert(br.readDoubleLE().equals(JDouble.longBitsToDouble(l)))
   })
 
-  test("readBytes")(forAll { bytes: Array[Byte] =>
+  test("readBytes")(forAll { (bytes: Array[Byte]) =>
     val buf = Buf.ByteArray.Owned(bytes ++ bytes)
     val br = ByteReader(buf)
     intercept[IllegalArgumentException] { br.readBytes(-1) }
@@ -238,7 +238,7 @@ class ByteReaderTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     assert(br.readBytes(1) == Buf.Empty)
   })
 
-  test("readAll")(forAll { bytes: Array[Byte] =>
+  test("readAll")(forAll { (bytes: Array[Byte]) =>
     val buf = Buf.ByteArray.Owned(bytes ++ bytes)
     val br = ByteReader(buf)
     assert(br.readAll() == Buf.ByteArray.Owned(bytes ++ bytes))
diff --git a/util-core/src/test/scala/com/twitter/io/IteratorReaderTest.scala b/util-core/src/test/scala/com/twitter/io/IteratorReaderTest.scala
index c40715fbc4..2f059a27d5 100644
--- a/util-core/src/test/scala/com/twitter/io/IteratorReaderTest.scala
+++ b/util-core/src/test/scala/com/twitter/io/IteratorReaderTest.scala
@@ -10,14 +10,14 @@ class IteratorReaderTest extends AnyFunSuite with Checkers {
   private def await[A](f: Future[A]): A = Await.result(f, 5.seconds)
 
   test("IteratorReader") {
-    check { list: List[String] =>
+    check { (list: List[String]) =>
       val r = Reader.fromIterator(list.iterator)
       await(Reader.readAllItems(r)).mkString == list.mkString
     }
   }
 
   test("IteratorReader - discard") {
-    check { list: List[String] =>
+    check { (list: List[String]) =>
       val r = Reader.fromIterator(list.iterator)
       r.discard()
 
diff --git a/util-core/src/test/scala/com/twitter/io/ReaderTest.scala b/util-core/src/test/scala/com/twitter/io/ReaderTest.scala
index 1773df41cd..f5ad20e460 100644
--- a/util-core/src/test/scala/com/twitter/io/ReaderTest.scala
+++ b/util-core/src/test/scala/com/twitter/io/ReaderTest.scala
@@ -62,7 +62,7 @@ class ReaderTest
     }
 
   test("Reader.concat collection of readers") {
-    forAll { ss: List[String] =>
+    forAll { (ss: List[String]) =>
       val readers: List[Reader[String]] = ss.map(s => Reader.value(s))
       val concatedReaders = Reader.concat(readers)
       val values = Reader.readAllItems(concatedReaders)
@@ -71,7 +71,7 @@ class ReaderTest
   }
 
   test("Reader.concat from a collection won't force the stream") {
-    forAll { ss: List[String] =>
+    forAll { (ss: List[String]) =>
       val readers: List[Reader[String]] = ss.map(s => Reader.value(s))
       val head = Reader.value("hmm")
       Reader.concat(head +: readers)
@@ -80,7 +80,7 @@ class ReaderTest
   }
 
   test("Reader.concat from a stream of readers") {
-    forAll { ss: List[String] =>
+    forAll { (ss: List[String]) =>
       val readers: List[Reader[String]] = ss.map(s => Reader.value(s))
       val concatedReaders = Reader.concat(AsyncStream.fromSeq(readers))
       val values = Reader.readAllItems(concatedReaders)
@@ -89,7 +89,7 @@ class ReaderTest
   }
 
   test("Reader.concat from a stream of readers forces the stream") {
-    forAll { ss: List[String] =>
+    forAll { (ss: List[String]) =>
       val readers: List[Reader[String]] = ss.map(s => Reader.value(s))
       val head = Reader.value("hmm")
       Reader.concat(AsyncStream.fromSeq(head +: readers))
@@ -154,7 +154,7 @@ class ReaderTest
   }
 
   test("Reader.flatten") {
-    forAll { ss: List[String] =>
+    forAll { (ss: List[String]) =>
       val readers: List[Reader[String]] = ss.map(s => Reader.value(s))
       val value = Reader.readAllItems(Reader.flatten(Reader.fromSeq(readers)))
       assert(await(value) == ss)
@@ -162,7 +162,7 @@ class ReaderTest
   }
 
   test("Reader#flatten") {
-    forAll { ss: List[String] =>
+    forAll { (ss: List[String]) =>
       val readers: List[Reader[String]] = ss.map(s => Reader.value(s))
       val buf = Reader.readAllItems((Reader.fromSeq(readers).flatten))
       assert(await(buf) == ss)
@@ -249,7 +249,7 @@ class ReaderTest
 
     val r1 = Reader.value(1)
     val p2 = new Promise
-    val i2 = p2.interruptible
+    val i2 = p2.interruptible()
     val r2 = Reader.fromFuture(i2)
 
     def rStreams: Stream[Reader[Any]] = r1 #:: r2 #:: rStreams
@@ -331,7 +331,7 @@ class ReaderTest
   }
 
   test("Reader.toAsyncStream") {
-    forAll { l: List[Byte] =>
+    forAll { (l: List[Byte]) =>
       val buf = Buf.ByteArray.Owned(l.toArray)
       val as = Reader.toAsyncStream(Reader.fromBuf(buf, 1))
 
@@ -340,7 +340,7 @@ class ReaderTest
   }
 
   test("Reader.flatMap") {
-    forAll { s: String =>
+    forAll { (s: String) =>
       val reader1 = Reader.fromBuf(Buf.Utf8(s), 8)
       val reader2 = reader1.flatMap { buf =>
         val pipe = new Pipe[Buf]
@@ -429,7 +429,7 @@ class ReaderTest
   }
 
   test("Reader.value") {
-    forAll { a: AnyVal =>
+    forAll { (a: AnyVal) =>
       val r = Reader.value(a)
       assert(await(r.read()) == Some(a))
       assert(r.onClose.isDefined == false)
@@ -439,7 +439,7 @@ class ReaderTest
   }
 
   test("Reader.exception") {
-    forAll { ex: Exception =>
+    forAll { (ex: Exception) =>
       val r = Reader.exception(ex)
       val exr = intercept[Exception] {
         await(r.read())
@@ -467,7 +467,7 @@ class ReaderTest
   }
 
   test("Reader.map") {
-    forAll { l: List[Int] =>
+    forAll { (l: List[Int]) =>
       val pipe = new Pipe[Int]
       writeLoop(l, pipe)
       val reader2 = pipe.map(_.toString)
diff --git a/util-core/src/test/scala/com/twitter/util/ActivityTest.scala b/util-core/src/test/scala/com/twitter/util/ActivityTest.scala
index 44693c17ac..d0d6a05713 100644
--- a/util-core/src/test/scala/com/twitter/util/ActivityTest.scala
+++ b/util-core/src/test/scala/com/twitter/util/ActivityTest.scala
@@ -85,24 +85,24 @@ class ActivityTest extends AnyFunSuite {
   }
 
   test("Activity.future: produce an initially-pending Activity") {
-    assert(Activity.future(Future.never).run.sample == Activity.Pending)
+    assert(Activity.future(Future.never).run.sample() == Activity.Pending)
   }
 
   test("Activity.future: produce an Activity that completes on success of the original Future") {
     val p = new Promise[Int]
     val act = Activity.future(p)
-    assert(act.run.sample == Activity.Pending)
+    assert(act.run.sample() == Activity.Pending)
     p.setValue(4)
-    assert(act.run.sample == Activity.Ok(4))
+    assert(act.run.sample() == Activity.Ok(4))
   }
 
   test("Activity.future: produce an Activity that fails on failure of the original Future") {
     val p = new Promise[Unit]
     val e = new Exception("gooby pls")
     val act = Activity.future(p)
-    assert(act.run.sample == Activity.Pending)
+    assert(act.run.sample() == Activity.Pending)
     p.setException(e)
-    assert(act.run.sample == Activity.Failed(e))
+    assert(act.run.sample() == Activity.Failed(e))
   }
 
   test(
@@ -326,7 +326,7 @@ class ActivityTest extends AnyFunSuite {
     def register(witness: Witness[Activity.State[Int]]): Closable = {
       count += 1
       w = witness
-      Closable.make { deadline: Time =>
+      Closable.make { (deadline: Time) =>
         count -= 1
         w = null
         Future.Done
diff --git a/util-core/src/test/scala/com/twitter/util/Base64LongTest.scala b/util-core/src/test/scala/com/twitter/util/Base64LongTest.scala
index e90007845a..a8c3422153 100644
--- a/util-core/src/test/scala/com/twitter/util/Base64LongTest.scala
+++ b/util-core/src/test/scala/com/twitter/util/Base64LongTest.scala
@@ -65,7 +65,7 @@ class Base64LongTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     assert(toBase64(0) == "A")
 
     val b = new StringBuilder
-    forAll { a: Alphabet =>
+    forAll { (a: Alphabet) =>
       b.setLength(0)
       toBase64(b, 0, a)
       assert(b.result == a(0).toString)
@@ -77,7 +77,7 @@ class Base64LongTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
   }
 
   test("toBase64 uses the expected number of digits") {
-    BoundaryValues.foreach { n: Long => assert(toBase64(n).length == expectedLength(n)) }
+    BoundaryValues.foreach { (n: Long) => assert(toBase64(n).length == expectedLength(n)) }
     forAll((n: Long) => assert(toBase64(n).length == expectedLength(n)))
 
     val b = new StringBuilder
diff --git a/util-core/src/test/scala/com/twitter/util/CancellableTest.scala b/util-core/src/test/scala/com/twitter/util/CancellableTest.scala
index 14d150218d..8b23f172f9 100644
--- a/util-core/src/test/scala/com/twitter/util/CancellableTest.scala
+++ b/util-core/src/test/scala/com/twitter/util/CancellableTest.scala
@@ -21,7 +21,7 @@ class CancellableTest extends AnyFunSuite {
   test("CancellableSink cancel normal case") {
     var count = 2
     def square(): Unit = count *= count
-    val s = new CancellableSink(square)
+    val s = new CancellableSink(square())
     assert(count == 2)
     s.cancel()
     assert(count == 4)
@@ -30,7 +30,7 @@ class CancellableTest extends AnyFunSuite {
   test("CancellableSink cancel once") {
     var count = 0
     def increment(): Unit = count += 1
-    val s = new CancellableSink(increment)
+    val s = new CancellableSink(increment())
     s.cancel()
     assert(count == 1)
     s.cancel()
@@ -40,7 +40,7 @@ class CancellableTest extends AnyFunSuite {
   test("CancellableSink has not cancelled") {
     var count = 0
     def increment(): Unit = count += 1
-    val s = new CancellableSink(increment)
+    val s = new CancellableSink(increment())
     assert(!s.isCancelled)
     assert(count == 0)
   }
@@ -48,7 +48,7 @@ class CancellableTest extends AnyFunSuite {
   test("CancellableSink confirm cancelled") {
     var count = 0
     def increment(): Unit = count += 1
-    val s = new CancellableSink(increment)
+    val s = new CancellableSink(increment())
     s.cancel()
     assert(s.isCancelled)
     assert(count == 1)
@@ -57,8 +57,8 @@ class CancellableTest extends AnyFunSuite {
   test("CancellableSink not support linking") {
     var count = 1
     def multiply(): Unit = count *= 2
-    val s1 = new CancellableSink(multiply)
-    val s2 = new CancellableSink(multiply)
+    val s1 = new CancellableSink(multiply())
+    val s2 = new CancellableSink(multiply())
     assertThrows[Exception] {
       s1.linkTo(s2)
     }
diff --git a/util-core/src/test/scala/com/twitter/util/ClosableTest.scala b/util-core/src/test/scala/com/twitter/util/ClosableTest.scala
index a485a75941..af40791e9a 100644
--- a/util-core/src/test/scala/com/twitter/util/ClosableTest.scala
+++ b/util-core/src/test/scala/com/twitter/util/ClosableTest.scala
@@ -78,7 +78,7 @@ class ClosableTest extends AnyFunSuite with Eventually with IntegrationPatience
 
   test("Closable.all with exceptions") {
     val throwing = Closable.make(_ => sys.error("lolz"))
-    val tracking = new Closable {
+    val tracking: Closable { def calledClose: Boolean } = new Closable {
       @volatile
       var calledClose = false
       override def close(deadline: Time): Future[Unit] = {
diff --git a/util-core/src/test/scala/com/twitter/util/DurationTest.scala b/util-core/src/test/scala/com/twitter/util/DurationTest.scala
index 3342621b79..a49ac0c91e 100644
--- a/util-core/src/test/scala/com/twitter/util/DurationTest.scala
+++ b/util-core/src/test/scala/com/twitter/util/DurationTest.scala
@@ -19,7 +19,7 @@ package com.twitter.util
 import com.twitter.conversions.DurationOps._
 import java.util.concurrent.TimeUnit
 
-class DurationTest extends { val ops: Duration.type = Duration } with TimeLikeSpec[Duration] {
+class DurationTest extends TimeLikeSpec[Duration](ops = Duration) {
 
   "Duration" should {
     "*" in {
diff --git a/util-core/src/test/scala/com/twitter/util/FutureTest.scala b/util-core/src/test/scala/com/twitter/util/FutureTest.scala
index 954ee649d1..f981eb7722 100644
--- a/util-core/src/test/scala/com/twitter/util/FutureTest.scala
+++ b/util-core/src/test/scala/com/twitter/util/FutureTest.scala
@@ -901,8 +901,8 @@ class FutureTest extends AnyWordSpec with MockitoSugar with ScalaCheckDrivenProp
         }
       }
 
-      testJavaFuture("toJavaFuture", { f: Future[Int] => f.toJavaFuture })
-      testJavaFuture("toCompletableFuture", { f: Future[Int] => f.toCompletableFuture })
+      testJavaFuture("toJavaFuture", { (f: Future[Int]) => f.toJavaFuture })
+      testJavaFuture("toCompletableFuture", { (f: Future[Int]) => f.toCompletableFuture })
 
       "monitored" should {
         trait MonitoredHelper {
diff --git a/util-core/src/test/scala/com/twitter/util/LastWriteWinsQueueTest.scala b/util-core/src/test/scala/com/twitter/util/LastWriteWinsQueueTest.scala
index 73fab075e8..2d61bbe02d 100644
--- a/util-core/src/test/scala/com/twitter/util/LastWriteWinsQueueTest.scala
+++ b/util-core/src/test/scala/com/twitter/util/LastWriteWinsQueueTest.scala
@@ -10,7 +10,7 @@ class LastWriteWinsQueueTest extends AnyWordSpec {
       assert(queue.size == 0)
       queue.add("1")
       assert(queue.size == 1)
-      assert(queue.remove() == "1")
+      assert(queue.remove == "1")
       assert(queue.size == 0)
     }
 
diff --git a/util-core/src/test/scala/com/twitter/util/MemoizeTest.scala b/util-core/src/test/scala/com/twitter/util/MemoizeTest.scala
index 2294a8fbab..c84ca34614 100644
--- a/util-core/src/test/scala/com/twitter/util/MemoizeTest.scala
+++ b/util-core/src/test/scala/com/twitter/util/MemoizeTest.scala
@@ -47,7 +47,7 @@ class MemoizeTest extends AnyFunSuite {
     val callCount = new AtomicInteger(0)
 
     val startUpLatch = new JavaCountDownLatch(1)
-    val memoizer = Memoize { i: Int =>
+    val memoizer = Memoize { (i: Int) =>
       // Wait for all of the threads to be started before
       // continuing. This gives races a chance to happen.
       startUpLatch.await()
@@ -85,7 +85,7 @@ class MemoizeTest extends AnyFunSuite {
 
     // A computation that should fail the first time, and then
     // succeed for all subsequent attempts.
-    val memo = Memoize { i: Int =>
+    val memo = Memoize { (i: Int) =>
       // Ensure that all of the callers have been started
       startUpLatch.await(200, TimeUnit.MILLISECONDS)
       // This effect should happen once per exception plus once for
diff --git a/util-core/src/test/scala/com/twitter/util/StorageUnitTest.scala b/util-core/src/test/scala/com/twitter/util/StorageUnitTest.scala
index 3a42c01e27..a057a6ae1d 100644
--- a/util-core/src/test/scala/com/twitter/util/StorageUnitTest.scala
+++ b/util-core/src/test/scala/com/twitter/util/StorageUnitTest.scala
@@ -22,11 +22,11 @@ class StorageUnitTest extends AnyFunSuite {
   }
 
   test("StorageUnit: should confer an essential humanity") {
-    assert(900.bytes.toHuman == "900 B")
-    assert(1.kilobyte.toHuman == "1024 B")
-    assert(2.kilobytes.toHuman == "2.0 KiB")
-    assert(Int.MaxValue.bytes.toHuman == "2.0 GiB")
-    assert(Long.MaxValue.bytes.toHuman == "8.0 EiB")
+    assert(900.bytes.toHuman() == "900 B")
+    assert(1.kilobyte.toHuman() == "1024 B")
+    assert(2.kilobytes.toHuman() == "2.0 KiB")
+    assert(Int.MaxValue.bytes.toHuman() == "2.0 GiB")
+    assert(Long.MaxValue.bytes.toHuman() == "8.0 EiB")
   }
 
   test("StorageUnit: should handle Long value") {
@@ -51,7 +51,7 @@ class StorageUnitTest extends AnyFunSuite {
 
   test("StorageUnit: should deal with negative values") {
     assert(-123.bytes.inBytes == -123)
-    assert(-2.kilobytes.toHuman == "-2.0 KiB")
+    assert(-2.kilobytes.toHuman() == "-2.0 KiB")
   }
 
   test("StorageUnit: should min properly") {
diff --git a/util-core/src/test/scala/com/twitter/util/TimeTest.scala b/util-core/src/test/scala/com/twitter/util/TimeTest.scala
index 62a3d3a237..815006c042 100644
--- a/util-core/src/test/scala/com/twitter/util/TimeTest.scala
+++ b/util-core/src/test/scala/com/twitter/util/TimeTest.scala
@@ -10,8 +10,7 @@ import org.scalatestplus.scalacheck.ScalaCheckDrivenPropertyChecks
 import com.twitter.conversions.DurationOps._
 import org.scalatest.wordspec.AnyWordSpec
 
-trait TimeLikeSpec[T <: TimeLike[T]] extends AnyWordSpec with ScalaCheckDrivenPropertyChecks {
-  val ops: TimeLikeOps[T]
+class TimeLikeSpec[T <: TimeLike[T]](val ops: TimeLikeOps[T]) extends AnyWordSpec with ScalaCheckDrivenPropertyChecks {
   import ops._
 
   "Top, Bottom, Undefined, Nanoseconds(_), Finite(_)" should {
@@ -395,7 +394,7 @@ class TimeFormatTest extends AnyWordSpec {
   }
 }
 
-class TimeTest extends { val ops: Time.type = Time } with TimeLikeSpec[Time] with Eventually
+class TimeTest extends TimeLikeSpec[Time](ops = Time) with Eventually
 with IntegrationPatience {
 
   "Time" should {
@@ -600,13 +599,13 @@ with IntegrationPatience {
     "fromFractionalSeconds" in {
       val tolerance = 2.microseconds // we permit 1us slop
 
-      forAll { i: Int =>
+      forAll { (i: Int) =>
         assert(
           Time.fromSeconds(i).moreOrLessEquals(Time.fromFractionalSeconds(i.toDouble), tolerance)
         )
       }
 
-      forAll { d: Double =>
+      forAll { (d: Double) =>
         val magic = 9223372036854775L // cribbed from Time.fromMicroseconds
         val microseconds = d * 1.second.inMicroseconds
         whenever(microseconds > -magic && microseconds < magic) {
@@ -618,7 +617,7 @@ with IntegrationPatience {
         }
       }
 
-      forAll { l: Long =>
+      forAll { (l: Long) =>
         val seconds: Double = l.toDouble / 1.second.inNanoseconds
         assert(
           Time.fromFractionalSeconds(seconds).moreOrLessEquals(Time.fromNanoseconds(l), tolerance)
diff --git a/util-core/src/test/scala/com/twitter/util/TimerTest.scala b/util-core/src/test/scala/com/twitter/util/TimerTest.scala
index aeb97c0026..ed4c4b6ee8 100644
--- a/util-core/src/test/scala/com/twitter/util/TimerTest.scala
+++ b/util-core/src/test/scala/com/twitter/util/TimerTest.scala
@@ -353,7 +353,7 @@ class TimerTest extends AnyFunSuite with MockitoSugar with Eventually with Integ
     assert(mockTimerLocalPropagation(timer, 99) == 99)
   }
 
-  private class SomeEx extends Exception
+  private case class SomeEx() extends Exception
 
   private def testTimerUsesLocalMonitor(timer: Timer): Unit = {
     val seen = new AtomicInteger(0)
diff --git a/util-core/src/test/scala/com/twitter/util/VarTest.scala b/util-core/src/test/scala/com/twitter/util/VarTest.scala
index d3eb6b8dd9..040d33907d 100644
--- a/util-core/src/test/scala/com/twitter/util/VarTest.scala
+++ b/util-core/src/test/scala/com/twitter/util/VarTest.scala
@@ -225,7 +225,7 @@ class VarTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
   }
 
   test("Var.collect: empty") {
-    assert(Var.collect(List.empty[Var[Int]]).sample == Nil)
+    assert(Var.collect(List.empty[Var[Int]]).sample() == Nil)
   }
 
   test("Var.collect[Seq]") {
@@ -451,7 +451,7 @@ class VarTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
     // in order to avoid extremely long runtimes, we limit the max size
     // of the generated Seqs and Sets. A limit of 50 keeps runtime below
     // 1 second on my crufty old laptop.
-    implicit val generatorDrivenConfig = PropertyCheckConfiguration(sizeRange = 50)
+    implicit val generatorDrivenConfig: PropertyCheckConfiguration = PropertyCheckConfiguration(sizeRange = 50)
 
     forAll(arbitrary[Seq[Set[Int]]].suchThat(_.nonEmpty)) { sets =>
       val v = Var(sets.head)
diff --git a/util-hashing/src/main/scala/com/twitter/hashing/Hashable.scala b/util-hashing/src/main/scala/com/twitter/hashing/Hashable.scala
index 233e713fb8..9ffc61f392 100644
--- a/util-hashing/src/main/scala/com/twitter/hashing/Hashable.scala
+++ b/util-hashing/src/main/scala/com/twitter/hashing/Hashable.scala
@@ -21,7 +21,7 @@ trait LowPriorityHashable {
 
   // Get the UTF-8 bytes of a string to hash it
   implicit def fromString[T](implicit h: Hashable[Array[Byte], T]): Hashable[String, T] =
-    h.compose { s: String => s.getBytes }
+    h.compose { (s: String) => s.getBytes }
 }
 
 object Hashable extends LowPriorityHashable {
diff --git a/util-hashing/src/test/scala/com/twitter/hashing/ConsistentHashingDistributorTest.scala b/util-hashing/src/test/scala/com/twitter/hashing/ConsistentHashingDistributorTest.scala
index 3d4868aa5a..4ea093d237 100644
--- a/util-hashing/src/test/scala/com/twitter/hashing/ConsistentHashingDistributorTest.scala
+++ b/util-hashing/src/test/scala/com/twitter/hashing/ConsistentHashingDistributorTest.scala
@@ -34,14 +34,14 @@ class ConsistentHashingDistributorTest extends AnyWordSpec with ScalaCheckDriven
       val reader = new BufferedReader(new InputStreamReader(stream))
       val expected = new mutable.ListBuffer[Array[String]]
       var line: String = null
-      do {
+      while ({ {
         line = reader.readLine
         if (line != null) {
           val segments = line.split(" ")
           assert(segments.length == 4)
           expected += segments
         }
-      } while (line != null)
+      } ; line != null}) ()
       assert(expected.size == 99)
 
       // Test that ketamaClient.clientOf(key) == expected IP
@@ -86,7 +86,7 @@ class ConsistentHashingDistributorTest extends AnyWordSpec with ScalaCheckDriven
 
     "byteArrayToLE" in {
       val ketama = new ConsistentHashingDistributor[Unit](Seq.empty, 0, false)
-      forAll { s: String =>
+      forAll { (s: String) =>
         val ba = MessageDigest.getInstance("MD5").digest(s.getBytes("UTF-8"))
         val bb = ByteBuffer.wrap(ba).order(ByteOrder.LITTLE_ENDIAN)
 
@@ -110,7 +110,7 @@ class ConsistentHashingDistributorTest extends AnyWordSpec with ScalaCheckDriven
         assert(pid1 == pid2)
       }
 
-      forAll { s: String =>
+      forAll { (s: String) =>
         val hash = keyHasher.hashKey(s.getBytes("UTF-8"))
         val (pid1, _) = ketamaDistributor.entryForHash(hash)
         val pid2 = ketamaDistributor.partitionIdForHash(hash)
diff --git a/util-hashing/src/test/scala/com/twitter/hashing/HashableTest.scala b/util-hashing/src/test/scala/com/twitter/hashing/HashableTest.scala
index 75af619d4c..2a76d0196f 100644
--- a/util-hashing/src/test/scala/com/twitter/hashing/HashableTest.scala
+++ b/util-hashing/src/test/scala/com/twitter/hashing/HashableTest.scala
@@ -18,7 +18,7 @@ class HashableTest extends AnyFunSuite with ScalaCheckDrivenPropertyChecks {
   )
 
   def testConsistency[T](algo: Hashable[Array[Byte], T]): Unit = {
-    forAll { input: Array[Byte] => assert(algo(input) == algo(input)) }
+    forAll { (input: Array[Byte]) => assert(algo(input) == algo(input)) }
   }
 
   algorithms foreach { algo =>
diff --git a/util-jvm/src/main/scala/com/twitter/jvm/Jvm.scala b/util-jvm/src/main/scala/com/twitter/jvm/Jvm.scala
index 2b6f45be5a..5d9a157c76 100644
--- a/util-jvm/src/main/scala/com/twitter/jvm/Jvm.scala
+++ b/util-jvm/src/main/scala/com/twitter/jvm/Jvm.scala
@@ -131,7 +131,7 @@ trait Jvm {
         buffer = (gc :: buffer).takeWhile(_.timestamp > floor)
     }
 
-    since: Time => buffer.takeWhile(_.timestamp > since)
+    (since: Time) => buffer.takeWhile(_.timestamp > since)
   }
 
   def forceGc(): Unit
diff --git a/util-jvm/src/test/scala/com/twitter/jvm/JvmTest.scala b/util-jvm/src/test/scala/com/twitter/jvm/JvmTest.scala
index c0eb0da0d8..ca1ec50c35 100644
--- a/util-jvm/src/test/scala/com/twitter/jvm/JvmTest.scala
+++ b/util-jvm/src/test/scala/com/twitter/jvm/JvmTest.scala
@@ -2,13 +2,17 @@ package com.twitter.jvm
 
 import com.twitter.conversions.DurationOps._
 import com.twitter.util.Time
+
 import java.util.logging.{Level, Logger}
 import org.mockito.ArgumentMatchers.contains
 import org.mockito.Mockito.{times, verify, when}
 import org.scalatestplus.mockito.MockitoSugar
+
 import scala.collection.mutable
 import org.scalatest.wordspec.AnyWordSpec
 
+import java.util.concurrent.ScheduledExecutorService
+
 class JvmTest extends AnyWordSpec with MockitoSugar {
   "Jvm" should {
     class JvmHelper(suppliedLogger: Option[Logger] = None) extends Jvm {
@@ -28,7 +32,8 @@ class JvmTest extends AnyWordSpec with MockitoSugar {
         currentSnap = snap
       }
 
-      override val executor = new MockScheduledExecutorService
+      val mockExecutor = new MockScheduledExecutorService
+      override val executor: ScheduledExecutorService =  mockExecutor
 
       def snap = currentSnap
 
@@ -62,10 +67,10 @@ class JvmTest extends AnyWordSpec with MockitoSugar {
       "Capture interleaving GCs with different names" in {
         val jvm = new JvmHelper()
         val b = mutable.Buffer[Gc]()
-        assert(jvm.executor.schedules == List())
+        assert(jvm.mockExecutor.schedules == List())
         jvm foreachGc { b += _ }
-        assert(jvm.executor.schedules.size == 1)
-        val r = jvm.executor.schedules.head._1
+        assert(jvm.mockExecutor.schedules.size == 1)
+        val r = jvm.mockExecutor.schedules.head._1
         r.run()
         assert(b == List())
         val gc = Gc(0, "pcopy", Time.now, 1.millisecond)
@@ -99,8 +104,8 @@ class JvmTest extends AnyWordSpec with MockitoSugar {
           val jvm = new JvmHelper(Some(logger))
 
           jvm.foreachGc(_ => () /*ignore*/ )
-          assert(jvm.executor.schedules.size == 1)
-          val r = jvm.executor.schedules.head._1
+          assert(jvm.mockExecutor.schedules.size == 1)
+          val r = jvm.mockExecutor.schedules.head._1
           val gc = Gc(0, "pcopy", Time.now, 1.millisecond)
           r.run()
           jvm.pushGc(gc)
@@ -126,8 +131,8 @@ class JvmTest extends AnyWordSpec with MockitoSugar {
       "queries gcs in range, in reverse chronological order" in Time.withCurrentTimeFrozen { tc =>
         val jvm = new JvmHelper()
         val query = jvm.monitorGcs(10.seconds)
-        assert(jvm.executor.schedules.size == 1)
-        val r = jvm.executor.schedules.head._1
+        assert(jvm.mockExecutor.schedules.size == 1)
+        val r = jvm.mockExecutor.schedules.head._1
         val gc0 = Gc(0, "pcopy", Time.now, 1.millisecond)
         val gc1 = Gc(1, "CMS", Time.now, 1.millisecond)
         jvm.pushGc(gc1)
diff --git a/util-logging/src/main/scala/com/twitter/logging/FileHandler.scala b/util-logging/src/main/scala/com/twitter/logging/FileHandler.scala
index b36bfa2f5d..5c4217bd3e 100644
--- a/util-logging/src/main/scala/com/twitter/logging/FileHandler.scala
+++ b/util-logging/src/main/scala/com/twitter/logging/FileHandler.scala
@@ -224,9 +224,9 @@ class FileHandler(
       }
       case Policy.Weekly(weekday) => {
         next.set(Calendar.HOUR_OF_DAY, 0)
-        do {
+        while ({ {
           next.add(Calendar.DAY_OF_MONTH, 1)
-        } while (next.get(Calendar.DAY_OF_WEEK) != weekday)
+        } ; next.get(Calendar.DAY_OF_WEEK) != weekday}) ()
         Some(next)
       }
     }
diff --git a/util-logging/src/main/scala/com/twitter/logging/Logger.scala b/util-logging/src/main/scala/com/twitter/logging/Logger.scala
index 349501c2bb..64340ebfe4 100644
--- a/util-logging/src/main/scala/com/twitter/logging/Logger.scala
+++ b/util-logging/src/main/scala/com/twitter/logging/Logger.scala
@@ -66,7 +66,7 @@ class Logger protected (val name: String, private val wrapped: javalog.Logger) {
    */
   @varargs
   final def log(level: Level, thrown: Throwable, message: String, items: Any*): Unit = {
-    val myLevel = getLevel
+    val myLevel = getLevel()
     if ((myLevel eq null) || (level.intValue >= myLevel.intValue)) {
 
       val record =
@@ -136,7 +136,7 @@ class Logger protected (val name: String, private val wrapped: javalog.Logger) {
    * and attach an exception and stack trace.
    */
   def logLazy(level: Level, thrown: Throwable, message: => AnyRef): Unit = {
-    val myLevel = getLevel
+    val myLevel = getLevel()
     if ((myLevel eq null) || (level.intValue >= myLevel.intValue)) {
       val record = new LazyLogRecord(level, message)
       record.setLoggerName(wrapped.getName)
diff --git a/util-logging/src/test/scala/com/twitter/logging/FileHandlerTest.scala b/util-logging/src/test/scala/com/twitter/logging/FileHandlerTest.scala
index 74bbe2af00..275791d620 100644
--- a/util-logging/src/test/scala/com/twitter/logging/FileHandlerTest.scala
+++ b/util-logging/src/test/scala/com/twitter/logging/FileHandlerTest.scala
@@ -353,7 +353,7 @@ class FileHandlerTest extends AnyWordSpec with TempFolder {
         }
 
         val files = listLogFiles(folderName + "/LogFileDir")
-        files.foreach { f: File =>
+        files.foreach { (f: File) =>
           val len = f.length().bytes
           if (len > fileSizeInMegaBytes.megabytes) {
             fail("Failed to roll over the log file")
diff --git a/util-logging/src/test/scala/com/twitter/logging/LogRecordTest.scala b/util-logging/src/test/scala/com/twitter/logging/LogRecordTest.scala
index 3d16a8e372..7084b90ec2 100644
--- a/util-logging/src/test/scala/com/twitter/logging/LogRecordTest.scala
+++ b/util-logging/src/test/scala/com/twitter/logging/LogRecordTest.scala
@@ -6,7 +6,7 @@ import org.scalatest.funsuite.AnyFunSuite
 class LogRecordTest extends AnyFunSuite {
   test("LogRecord should getMethod properly") {
     Logger.withLoggers(Nil) {
-      new LogRecordTestHelper({ r: JRecord => r.getSourceMethodName() }) {
+      new LogRecordTestHelper({ (r: JRecord) => r.getSourceMethodName() }) {
         def makingLogRecord() = {
           logger.log(Level.INFO, "OK")
           assert(handler.get == "makingLogRecord")
@@ -34,7 +34,7 @@ abstract class LogRecordTestHelper(formats: JRecord => String) {
   logger.addHandler(handler)
 }
 
-class Foo extends LogRecordTestHelper({ r: JRecord => r.getSourceClassName() }) {
+class Foo extends LogRecordTestHelper({ (r: JRecord) => r.getSourceClassName() }) {
   def makingLogRecord(): Unit = {
     logger.log(Level.INFO, "OK")
   }
diff --git a/util-logging/src/test/scala/com/twitter/logging/LoggerTest.scala b/util-logging/src/test/scala/com/twitter/logging/LoggerTest.scala
index 975c3f9db4..deff74acea 100644
--- a/util-logging/src/test/scala/com/twitter/logging/LoggerTest.scala
+++ b/util-logging/src/test/scala/com/twitter/logging/LoggerTest.scala
@@ -124,7 +124,7 @@ class LoggerTest extends AnyWordSpec with TempFolder with BeforeAndAfter {
         "asdf" + executed + " hi there"
       }
 
-      logger.debugLazy(function)
+      logger.debugLazy(function())
       assert(!executed)
     }
 
@@ -136,7 +136,7 @@ class LoggerTest extends AnyWordSpec with TempFolder with BeforeAndAfter {
         executed = true
         "asdf" + executed + " hi there"
       }
-      logger.debugLazy(function)
+      logger.debugLazy(function())
       assert(executed)
     }
 
@@ -263,11 +263,11 @@ class LoggerTest extends AnyWordSpec with TempFolder with BeforeAndAfter {
       val otherFactories = List(LoggerFactory(node = "", level = Some(Level.INFO)))
       Logger.configure(initialFactories)
 
-      assert(Logger.get("").getLevel == Level.DEBUG)
+      assert(Logger.get("").getLevel() == Level.DEBUG)
       Logger.withLoggers(otherFactories) {
         assert(Logger.get("").getLevel() == Level.INFO)
       }
-      assert(Logger.get("").getLevel == Level.DEBUG)
+      assert(Logger.get("").getLevel() == Level.DEBUG)
     }
 
     "configure logging" should {
@@ -294,7 +294,7 @@ class LoggerTest extends AnyWordSpec with TempFolder with BeforeAndAfter {
             ) :: Nil
           ).apply()
 
-          assert(log.getLevel == Level.DEBUG)
+          assert(log.getLevel() == Level.DEBUG)
           assert(log.getHandlers().length == 1)
           val handler = log.getHandlers()(0).asInstanceOf[FileHandler]
           val fileName = folderName + separator + "test.log"
@@ -325,7 +325,7 @@ class LoggerTest extends AnyWordSpec with TempFolder with BeforeAndAfter {
             ) :: Nil
           ).apply()
 
-          assert(log.getHandlers.length == 1)
+          assert(log.getHandlers().length == 1)
           val h = log.getHandlers()(0).asInstanceOf[SyslogHandler]
           assert(h.dest.asInstanceOf[InetSocketAddress].getHostName == "localhost")
           assert(h.dest.asInstanceOf[InetSocketAddress].getPort == 212)
@@ -365,9 +365,9 @@ class LoggerTest extends AnyWordSpec with TempFolder with BeforeAndAfter {
           ) :: Nil
 
           Logger.configure(factories)
-          assert(Logger.get("").getLevel == Level.INFO)
-          assert(Logger.get("w3c").getLevel == Level.OFF)
-          assert(Logger.get("bad_jobs").getLevel == Level.INFO)
+          assert(Logger.get("").getLevel() == Level.INFO)
+          assert(Logger.get("w3c").getLevel() == Level.OFF)
+          assert(Logger.get("bad_jobs").getLevel() == Level.INFO)
           try {
             Logger.get("").getHandlers()(0).asInstanceOf[ThrottledHandler]
           } catch {
diff --git a/util-logging/src/test/scala/com/twitter/logging/SyslogHandlerTest.scala b/util-logging/src/test/scala/com/twitter/logging/SyslogHandlerTest.scala
index b4c84882b1..4e81232976 100644
--- a/util-logging/src/test/scala/com/twitter/logging/SyslogHandlerTest.scala
+++ b/util-logging/src/test/scala/com/twitter/logging/SyslogHandlerTest.scala
@@ -45,7 +45,7 @@ class SyslogHandlerTest extends AnyWordSpec {
       syslog.publish(record1)
       syslog.publish(record2)
 
-      SyslogFuture.sync
+      SyslogFuture.sync()
       val p = new DatagramPacket(new Array[Byte](1024), 1024)
       serverSocket.receive(p)
       assert(
@@ -78,7 +78,7 @@ class SyslogHandlerTest extends AnyWordSpec {
       ).apply()
       syslog.publish(record1)
 
-      SyslogFuture.sync
+      SyslogFuture.sync()
       val p = new DatagramPacket(new Array[Byte](1024), 1024)
       serverSocket.receive(p)
       assert(
@@ -104,7 +104,7 @@ class SyslogHandlerTest extends AnyWordSpec {
       ).apply()
       syslog.publish(record1)
 
-      SyslogFuture.sync
+      SyslogFuture.sync()
       val p = new DatagramPacket(new Array[Byte](1024), 1024)
       serverSocket.receive(p)
       assert(
diff --git a/util-routing/src/test/scala/com/twitter/util/routing/RouterBuilderTest.scala b/util-routing/src/test/scala/com/twitter/util/routing/RouterBuilderTest.scala
index ba5d07d10b..67da8926cc 100644
--- a/util-routing/src/test/scala/com/twitter/util/routing/RouterBuilderTest.scala
+++ b/util-routing/src/test/scala/com/twitter/util/routing/RouterBuilderTest.scala
@@ -15,7 +15,7 @@ class RouterBuilderTest extends AnyFunSuite {
 
   private object ValidatingTestRouterBuilder {
     def newBuilder(): RouterBuilder[String, SimpleRoute, SimpleRouter] =
-      TestRouter.newBuilder.withValidator(
+      TestRouter.newBuilder().withValidator(
         new Validator[SimpleRoute] {
           def apply(routes: Iterable[SimpleRoute]): Iterable[ValidationError] =
             routes.collect {
@@ -40,7 +40,7 @@ class RouterBuilderTest extends AnyFunSuite {
   }
 
   test("throws when invalid route is passed") {
-    val router = ValidatingTestRouterBuilder.newBuilder
+    val router = ValidatingTestRouterBuilder.newBuilder()
       .withRoute(SimpleRoute("x", true))
       .withRoute(SimpleRoute("y", false))
       .withRoute(SimpleRoute("z", true))
@@ -55,7 +55,7 @@ class RouterBuilderTest extends AnyFunSuite {
   }
 
   test("throws when multiple invalid routes are passed") {
-    val router = ValidatingTestRouterBuilder.newBuilder
+    val router = ValidatingTestRouterBuilder.newBuilder()
       .withRoute(SimpleRoute("x", true))
       .withRoute(SimpleRoute("y", false))
       .withRoute(SimpleRoute("z", true))
diff --git a/util-security/src/main/scala/com/twitter/util/security/X509CertificateDeserializer.scala b/util-security/src/main/scala/com/twitter/util/security/X509CertificateDeserializer.scala
index e208cb74c7..7b02db00ef 100644
--- a/util-security/src/main/scala/com/twitter/util/security/X509CertificateDeserializer.scala
+++ b/util-security/src/main/scala/com/twitter/util/security/X509CertificateDeserializer.scala
@@ -15,7 +15,7 @@ import java.security.cert.{CertificateFactory, X509Certificate}
  */
 object X509CertificateDeserializer {
   private[this] val MessageType: String = "CERTIFICATE"
-  private[this] val deserializeX509: Array[Byte] => X509Certificate = { certBytes: Array[Byte] =>
+  private[this] val deserializeX509: Array[Byte] => X509Certificate = { (certBytes: Array[Byte]) =>
     val certFactory = CertificateFactory.getInstance("X.509")
     val certificate = certFactory
       .generateCertificate(new ByteArrayInputStream(certBytes))
diff --git a/util-slf4j-api/src/test/scala/com/twitter/util/logging/LoggingTest.scala b/util-slf4j-api/src/test/scala/com/twitter/util/logging/LoggingTest.scala
index f35af4d1e6..2bdee641ad 100644
--- a/util-slf4j-api/src/test/scala/com/twitter/util/logging/LoggingTest.scala
+++ b/util-slf4j-api/src/test/scala/com/twitter/util/logging/LoggingTest.scala
@@ -1,271 +1,271 @@
 package com.twitter.util.logging
 
-import com.twitter.util.mock.Mockito
-import org.mockito.Mockito.when
+import org.mockito.Mockito._
+import org.mockito.ArgumentMatchers.any
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 import scala.language.reflectiveCalls
 
-class LoggingTest extends AnyFunSuite with Matchers with Mockito {
+class LoggingTest extends AnyFunSuite with Matchers {
 
   /* Trace */
 
   test("Logging#trace enabled") {
-    val f = fixture(_.isTraceEnabled, isEnabled = true)
+    val f = Fixture(_.isTraceEnabled, isEnabled = true)
 
     f.logger.trace(f.message)
-    f.underlying.trace(f.message) was called
+    verify(f.underlying).trace(f.message)
   }
 
   test("Logging#trace not enabled") {
-    val f = fixture(_.isTraceEnabled, isEnabled = false)
+    val f = Fixture(_.isTraceEnabled, isEnabled = false)
 
     f.logger.trace(f.message)
-    f.underlying.trace(any[String]) wasNever called
+    verify(f.underlying, never()).trace(any[String]())
   }
 
   test("Logging#trace enabled with message and cause") {
-    val f = fixture(_.isTraceEnabled, isEnabled = true)
+    val f = Fixture(_.isTraceEnabled, isEnabled = true)
 
     f.logger.trace(f.message, f.cause)
-    f.underlying.trace(f.message, f.cause) was called
+    verify(f.underlying).trace(f.message, f.cause)
   }
 
   test("Logging#trace not enabled with message and cause") {
-    val f = fixture(_.isTraceEnabled, isEnabled = false)
+    val f = Fixture(_.isTraceEnabled, isEnabled = false)
 
     f.logger.trace(f.message, f.cause)
-    f.underlying.trace(any[String], any) wasNever called
+    verify(f.underlying, never()).trace(any[String](), any())
   }
 
   test("Logging#trace enabled with parameters") {
-    val f = fixture(_.isTraceEnabled, isEnabled = true)
+    val f = Fixture(_.isTraceEnabled, isEnabled = true)
 
     f.logger.traceWith(f.message, f.arg1)
-    f.underlying.trace(f.message, Seq(f.arg1): _*) was called
+    verify(f.underlying).trace(f.message, Seq(f.arg1): _*)
     f.logger.traceWith(f.message, f.arg1, f.arg2)
-    f.underlying.trace(f.message, Seq(f.arg1, f.arg2): _*) was called
+    verify(f.underlying).trace(f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.traceWith(f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.trace(f.message, f.arg1, f.arg2, f.arg3) was called
+    verify(f.underlying).trace(f.message, f.arg1, f.arg2, f.arg3)
   }
 
   test("Logging#trace not enabled with parameters") {
-    val f = fixture(_.isTraceEnabled, isEnabled = false)
+    val f = Fixture(_.isTraceEnabled, isEnabled = false)
 
     f.logger.traceWith(f.message, f.arg1)
-    f.underlying.trace(f.message, Seq(f.arg1): _*) wasNever called
+    verify(f.underlying, never()).trace(f.message, Seq(f.arg1): _*)
     f.logger.traceWith(f.message, f.arg1, f.arg2)
-    f.underlying.trace(f.message, Seq(f.arg1, f.arg2): _*) wasNever called
+    verify(f.underlying, never()).trace(f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.traceWith(f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.trace(f.message, f.arg1, f.arg2, f.arg3) wasNever called
+    verify(f.underlying, never()).trace(f.message, f.arg1, f.arg2, f.arg3)
   }
 
   /* Debug */
 
   test("Logging#debug enabled") {
-    val f = fixture(_.isDebugEnabled, isEnabled = true)
+    val f = Fixture(_.isDebugEnabled, isEnabled = true)
 
     f.logger.debug(f.message)
-    f.underlying.debug(f.message) was called
+    verify(f.underlying).debug(f.message)
   }
 
   test("Logging#debug not enabled") {
-    val f = fixture(_.isDebugEnabled, isEnabled = false)
+    val f = Fixture(_.isDebugEnabled, isEnabled = false)
 
     f.logger.debug(f.message)
-    f.underlying.debug(any[String]) wasNever called
+    verify(f.underlying, never()).debug(any[String]())
   }
 
   test("Logging#debug enabled with message and cause") {
-    val f = fixture(_.isDebugEnabled, isEnabled = true)
+    val f = Fixture(_.isDebugEnabled, isEnabled = true)
 
     f.logger.debug(f.message, f.cause)
-    f.underlying.debug(f.message, f.cause) was called
+    verify(f.underlying).debug(f.message, f.cause)
   }
 
   test("Logging#debug not enabled with message and cause") {
-    val f = fixture(_.isDebugEnabled, isEnabled = false)
+    val f = Fixture(_.isDebugEnabled, isEnabled = false)
 
     f.logger.debug(f.message, f.cause)
-    f.underlying.debug(any[String], any) wasNever called
+    verify(f.underlying, never()).debug(any[String](), any())
   }
 
   test("Logging#debug enabled with parameters") {
-    val f = fixture(_.isDebugEnabled, isEnabled = true)
+    val f = Fixture(_.isDebugEnabled, isEnabled = true)
 
     f.logger.debugWith(f.message, f.arg1)
-    f.underlying.debug(f.message, Seq(f.arg1): _*) was called
+    verify(f.underlying).debug(f.message, Seq(f.arg1): _*)
     f.logger.debugWith(f.message, f.arg1, f.arg2)
-    f.underlying.debug(f.message, Seq(f.arg1, f.arg2): _*) was called
+    verify(f.underlying).debug(f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.debugWith(f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.debug(f.message, f.arg1, f.arg2, f.arg3) was called
+    verify(f.underlying).debug(f.message, f.arg1, f.arg2, f.arg3)
   }
 
   test("Logging#debug not enabled with parameters") {
-    val f = fixture(_.isDebugEnabled, isEnabled = false)
+    val f = Fixture(_.isDebugEnabled, isEnabled = false)
 
     f.logger.debugWith(f.message, f.arg1)
-    f.underlying.debug(f.message, Seq(f.arg1): _*) wasNever called
+    verify(f.underlying, never()).debug(f.message, Seq(f.arg1): _*)
     f.logger.debugWith(f.message, f.arg1, f.arg2)
-    f.underlying.debug(f.message, Seq(f.arg1, f.arg2): _*) wasNever called
+    verify(f.underlying, never()).debug(f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.debugWith(f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.debug(f.message, f.arg1, f.arg2, f.arg3) wasNever called
+    verify(f.underlying, never()).debug(f.message, f.arg1, f.arg2, f.arg3)
   }
 
   /* Info */
 
   test("Logging#info enabled") {
-    val f = fixture(_.isInfoEnabled, isEnabled = true)
+    val f = Fixture(_.isInfoEnabled, isEnabled = true)
 
     f.logger.info(f.message)
-    f.underlying.info(f.message) was called
+    verify(f.underlying).info(f.message)
   }
 
   test("Logging#info not enabled") {
-    val f = fixture(_.isInfoEnabled, isEnabled = false)
+    val f = Fixture(_.isInfoEnabled, isEnabled = false)
 
     f.logger.info(f.message)
-    f.underlying.info(any[String]) wasNever called
+    verify(f.underlying, never()).info(any[String]())
   }
 
   test("Logging#info enabled with message and cause") {
-    val f = fixture(_.isInfoEnabled, isEnabled = true)
+    val f = Fixture(_.isInfoEnabled, isEnabled = true)
 
     f.logger.info(f.message, f.cause)
-    f.underlying.info(f.message, f.cause) was called
+    verify(f.underlying).info(f.message, f.cause)
   }
 
   test("Logging#info not enabled with message and cause") {
-    val f = fixture(_.isInfoEnabled, isEnabled = false)
+    val f = Fixture(_.isInfoEnabled, isEnabled = false)
 
     f.logger.info(f.message, f.cause)
-    f.underlying.info(any[String], any) wasNever called
+    verify(f.underlying, never()).info(any[String](), any())
   }
 
   test("Logging#info enabled with parameters") {
-    val f = fixture(_.isInfoEnabled, isEnabled = true)
+    val f = Fixture(_.isInfoEnabled, isEnabled = true)
 
     f.logger.infoWith(f.message, f.arg1)
-    f.underlying.info(f.message, Seq(f.arg1): _*) was called
+    verify(f.underlying).info(f.message, Seq(f.arg1): _*)
     f.logger.infoWith(f.message, f.arg1, f.arg2)
-    f.underlying.info(f.message, Seq(f.arg1, f.arg2): _*) was called
+    verify(f.underlying).info(f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.infoWith(f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.info(f.message, f.arg1, f.arg2, f.arg3) was called
+    verify(f.underlying).info(f.message, f.arg1, f.arg2, f.arg3)
   }
 
   test("Logging#info not enabled with parameters") {
-    val f = fixture(_.isInfoEnabled, isEnabled = false)
+    val f = Fixture(_.isInfoEnabled, isEnabled = false)
 
     f.logger.infoWith(f.message, f.arg1)
-    f.underlying.info(f.message, Seq(f.arg1): _*) wasNever called
+    verify(f.underlying, never()).info(f.message, Seq(f.arg1): _*)
     f.logger.infoWith(f.message, f.arg1, f.arg2)
-    f.underlying.info(f.message, Seq(f.arg1, f.arg2): _*) wasNever called
+    verify(f.underlying, never()).info(f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.infoWith(f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.info(f.message, f.arg1, f.arg2, f.arg3) wasNever called
+    verify(f.underlying, never()).info(f.message, f.arg1, f.arg2, f.arg3)
   }
 
   /* Warn */
 
   test("Logging#warn enabled") {
-    val f = fixture(_.isWarnEnabled, isEnabled = true)
+    val f = Fixture(_.isWarnEnabled, isEnabled = true)
 
     f.logger.warn(f.message)
-    f.underlying.warn(f.message) was called
+    verify(f.underlying).warn(f.message)
   }
 
   test("Logging#warn not enabled") {
-    val f = fixture(_.isWarnEnabled, isEnabled = false)
+    val f = Fixture(_.isWarnEnabled, isEnabled = false)
 
     f.logger.warn(f.message)
-    f.underlying.warn(any[String]) wasNever called
+    verify(f.underlying, never()).warn(any[String]())
   }
 
   test("Logging#warn enabled with message and cause") {
-    val f = fixture(_.isWarnEnabled, isEnabled = true)
+    val f = Fixture(_.isWarnEnabled, isEnabled = true)
 
     f.logger.warn(f.message, f.cause)
-    f.underlying.warn(f.message, f.cause) was called
+    verify(f.underlying).warn(f.message, f.cause)
   }
 
   test("Logging#warn not enabled with message and cause") {
-    val f = fixture(_.isWarnEnabled, isEnabled = false)
+    val f = Fixture(_.isWarnEnabled, isEnabled = false)
 
     f.logger.warn(f.message, f.cause)
-    f.underlying.warn(any[String], any) wasNever called
+    verify(f.underlying, never()).warn(any[String](), any())
   }
 
   test("Logging#warn enabled with parameters") {
-    val f = fixture(_.isWarnEnabled, isEnabled = true)
+    val f = Fixture(_.isWarnEnabled, isEnabled = true)
 
     f.logger.warnWith(f.message, f.arg1)
-    f.underlying.warn(f.message, Seq(f.arg1): _*) was called
+    verify(f.underlying).warn(f.message, Seq(f.arg1): _*)
     f.logger.warnWith(f.message, f.arg1, f.arg2)
-    f.underlying.warn(f.message, Seq(f.arg1, f.arg2): _*) was called
+    verify(f.underlying).warn(f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.warnWith(f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.warn(f.message, f.arg1, f.arg2, f.arg3) was called
+    verify(f.underlying).warn(f.message, f.arg1, f.arg2, f.arg3)
   }
 
   test("Logging#warn not enabled with parameters") {
-    val f = fixture(_.isWarnEnabled, isEnabled = false)
+    val f = Fixture(_.isWarnEnabled, isEnabled = false)
 
     f.logger.warnWith(f.message, f.arg1)
-    f.underlying.warn(f.message, Seq(f.arg1): _*) wasNever called
+    verify(f.underlying, never()).warn(f.message, Seq(f.arg1): _*)
     f.logger.warnWith(f.message, f.arg1, f.arg2)
-    f.underlying.warn(f.message, Seq(f.arg1, f.arg2): _*) wasNever called
+    verify(f.underlying, never()).warn(f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.warnWith(f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.warn(f.message, f.arg1, f.arg2, f.arg3) wasNever called
+    verify(f.underlying, never()).warn(f.message, f.arg1, f.arg2, f.arg3)
   }
 
   /* Error */
 
   test("Logging#error enabled") {
-    val f = fixture(_.isErrorEnabled, isEnabled = true)
+    val f = Fixture(_.isErrorEnabled, isEnabled = true)
 
     f.logger.error(f.message)
-    f.underlying.error(f.message) was called
+    verify(f.underlying).error(f.message)
   }
 
   test("Logging#error not enabled") {
-    val f = fixture(_.isErrorEnabled, isEnabled = false)
+    val f = Fixture(_.isErrorEnabled, isEnabled = false)
 
     f.logger.error(f.message)
-    f.underlying.error(any[String]) wasNever called
+    verify(f.underlying, never()).error(any[String]())
   }
 
   test("Logging#error enabled with message and cause") {
-    val f = fixture(_.isErrorEnabled, isEnabled = true)
+    val f = Fixture(_.isErrorEnabled, isEnabled = true)
 
     f.logger.error(f.message, f.cause)
-    f.underlying.error(f.message, f.cause) was called
+    verify(f.underlying).error(f.message, f.cause)
   }
 
   test("Logging#error not enabled with message and cause") {
-    val f = fixture(_.isErrorEnabled, isEnabled = false)
+    val f = Fixture(_.isErrorEnabled, isEnabled = false)
 
     f.logger.error(f.message, f.cause)
-    f.underlying.error(any[String], any) wasNever called
+    verify(f.underlying, never()).error(any[String](), any())
   }
 
   test("Logging#error enabled with parameters") {
-    val f = fixture(_.isErrorEnabled, isEnabled = true)
+    val f = Fixture(_.isErrorEnabled, isEnabled = true)
 
     f.logger.errorWith(f.message, f.arg1)
-    f.underlying.error(f.message, Seq(f.arg1): _*) was called
+    verify(f.underlying).error(f.message, Seq(f.arg1): _*)
     f.logger.errorWith(f.message, f.arg1, f.arg2)
-    f.underlying.error(f.message, Seq(f.arg1, f.arg2): _*) was called
+    verify(f.underlying).error(f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.errorWith(f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.error(f.message, f.arg1, f.arg2, f.arg3) was called
+    verify(f.underlying).error(f.message, f.arg1, f.arg2, f.arg3)
   }
 
   test("Logging#error not enabled with parameters") {
-    val f = fixture(_.isErrorEnabled, isEnabled = false)
+    val f = Fixture(_.isErrorEnabled, isEnabled = false)
 
     f.logger.errorWith(f.message, f.arg1)
-    f.underlying.error(f.message, Seq(f.arg1): _*) wasNever called
+    verify(f.underlying, never()).error(f.message, Seq(f.arg1): _*)
     f.logger.errorWith(f.message, f.arg1, f.arg2)
-    f.underlying.error(f.message, Seq(f.arg1, f.arg2): _*) wasNever called
+    verify(f.underlying, never()).error(f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.errorWith(f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.error(f.message, f.arg1, f.arg2, f.arg3) wasNever called
+    verify(f.underlying, never()).error(f.message, f.arg1, f.arg2, f.arg3)
   }
 
   /* Instance Logging */
@@ -357,16 +357,17 @@ class LoggingTest extends AnyFunSuite with Matchers with Mockito {
 
   /* Private */
 
-  private def fixture(isEnabledFn: org.slf4j.Logger => Boolean, isEnabled: Boolean) = {
-    new {
-      val message = "msg"
-      val cause = new RuntimeException("TEST EXCEPTION")
-      val arg1 = "arg1"
-      val arg2 = Integer.valueOf(1)
-      val arg3 = "arg3"
-      val underlying: org.slf4j.Logger = mock[org.slf4j.Logger]
-      when(isEnabledFn(underlying)).thenReturn(isEnabled)
-      val logger: Logger = Logger(underlying)
-    }
+  private case class Fixture(
+    isEnabledFn: org.slf4j.Logger => Boolean,
+    isEnabled: Boolean
+  ) {
+    val message = "msg"
+    val cause = new RuntimeException("TEST EXCEPTION")
+    val arg1 = "arg1"
+    val arg2 = Integer.valueOf(1)
+    val arg3 = "arg3"
+    val underlying: org.slf4j.Logger = mock(classOf[org.slf4j.Logger])
+    when(isEnabledFn(underlying)).thenReturn(isEnabled)
+    val logger: Logger = Logger(underlying)
   }
 }
diff --git a/util-slf4j-api/src/test/scala/com/twitter/util/logging/MarkerLoggingTest.scala b/util-slf4j-api/src/test/scala/com/twitter/util/logging/MarkerLoggingTest.scala
index 91689745e9..70fec0f71c 100644
--- a/util-slf4j-api/src/test/scala/com/twitter/util/logging/MarkerLoggingTest.scala
+++ b/util-slf4j-api/src/test/scala/com/twitter/util/logging/MarkerLoggingTest.scala
@@ -1,282 +1,283 @@
 package com.twitter.util.logging
 
-import com.twitter.util.mock.Mockito
 import org.mockito.Mockito.when
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 import org.slf4j.Marker
 import scala.language.reflectiveCalls
+import org.mockito.ArgumentMatchers.any
+import org.mockito.Mockito._
 
-class MarkerLoggingTest extends AnyFunSuite with Matchers with Mockito {
+class MarkerLoggingTest extends AnyFunSuite with Matchers {
 
   test("Marker Logging#trace enabled") {
-    val f = fixture(_.isTraceEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isTraceEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.trace(f.marker, f.message)
-    f.underlying.trace(f.marker, f.message) was called
+    verify(f.underlying).trace(f.marker, f.message)
   }
 
   test("Marker Logging#trace not enabled") {
-    val f = fixture(_.isTraceEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isTraceEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.trace(f.marker, f.message)
-    f.underlying.trace(any[Marker], any[String]) wasNever called
+    verify(f.underlying, never()).trace(any[Marker](), any[String]())
   }
 
   test("Marker Logging#trace enabled with message and cause") {
-    val f = fixture(_.isTraceEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isTraceEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.trace(f.marker, f.message, f.cause)
-    f.underlying.trace(f.marker, f.message, f.cause) was called
+    verify(f.underlying).trace(f.marker, f.message, f.cause)
   }
 
   test("Marker Logging#trace not enabled with message and cause") {
-    val f = fixture(_.isTraceEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isTraceEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.trace(f.marker, f.message, f.cause)
-    f.underlying.trace(any[Marker], any[String], any) wasNever called
+    verify(f.underlying, never()).trace(any[Marker](), any[String](), any)
   }
 
   test("Marker Logging#trace enabled with parameters") {
-    val f = fixture(_.isTraceEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isTraceEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.traceWith(f.marker, f.message, f.arg1)
-    f.underlying.trace(f.marker, f.message, Seq(f.arg1): _*) was called
+    verify(f.underlying).trace(f.marker, f.message, Seq(f.arg1): _*)
     f.logger.traceWith(f.marker, f.message, f.arg1, f.arg2)
-    f.underlying.trace(f.marker, f.message, Seq(f.arg1, f.arg2): _*) was called
+    verify(f.underlying).trace(f.marker, f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.traceWith(f.marker, f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.trace(f.marker, f.message, f.arg1, f.arg2, f.arg3) was called
+    verify(f.underlying).trace(f.marker, f.message, f.arg1, f.arg2, f.arg3)
   }
 
   test("Marker Logging#trace not enabled with parameters") {
-    val f = fixture(_.isTraceEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isTraceEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.traceWith(f.marker, f.message, f.arg1)
-    f.underlying.trace(f.marker, f.message, Seq(f.arg1): _*) wasNever called
+    verify(f.underlying, never()).trace(f.marker, f.message, Seq(f.arg1): _*)
     f.logger.traceWith(f.marker, f.message, f.arg1, f.arg2)
-    f.underlying.trace(f.marker, f.message, Seq(f.arg1, f.arg2): _*) wasNever called
+    verify(f.underlying, never()).trace(f.marker, f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.traceWith(f.marker, f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.trace(f.marker, f.message, f.arg1, f.arg2, f.arg3) wasNever called
+    verify(f.underlying, never()).trace(f.marker, f.message, f.arg1, f.arg2, f.arg3)
   }
 
   /* Debug */
 
   test("Marker Logging#debug enabled") {
-    val f = fixture(_.isDebugEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isDebugEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.debug(f.marker, f.message)
-    f.underlying.debug(f.marker, f.message) was called
+    verify(f.underlying).debug(f.marker, f.message)
   }
 
   test("Marker Logging#debug not enabled") {
-    val f = fixture(_.isDebugEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isDebugEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.debug(f.marker, f.message)
-    f.underlying.debug(any[Marker], any[String]) wasNever called
+    verify(f.underlying, never()).debug(any[Marker](), any[String]())
   }
 
   test("Marker Logging#debug enabled with message and cause") {
-    val f = fixture(_.isDebugEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isDebugEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.debug(f.marker, f.message, f.cause)
-    f.underlying.debug(f.marker, f.message, f.cause) was called
+    verify(f.underlying).debug(f.marker, f.message, f.cause)
   }
 
   test("Marker Logging#debug not enabled with message and cause") {
-    val f = fixture(_.isDebugEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isDebugEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.debug(f.marker, f.message, f.cause)
-    f.underlying.debug(any[Marker], any[String], any) wasNever called
+    verify(f.underlying, never()).debug(any[Marker](), any[String](), any)
   }
 
   test("Marker Logging#debug enabled with parameters") {
-    val f = fixture(_.isDebugEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isDebugEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.debugWith(f.marker, f.message, f.arg1)
-    f.underlying.debug(f.marker, f.message, Seq(f.arg1): _*) was called
+    verify(f.underlying).debug(f.marker, f.message, Seq(f.arg1): _*)
     f.logger.debugWith(f.marker, f.message, f.arg1, f.arg2)
-    f.underlying.debug(f.marker, f.message, Seq(f.arg1, f.arg2): _*) was called
+    verify(f.underlying).debug(f.marker, f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.debugWith(f.marker, f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.debug(f.marker, f.message, f.arg1, f.arg2, f.arg3) was called
+    verify(f.underlying).debug(f.marker, f.message, f.arg1, f.arg2, f.arg3)
   }
 
   test("Marker Logging#debug not enabled with parameters") {
-    val f = fixture(_.isDebugEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isDebugEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.debugWith(f.marker, f.message, f.arg1)
-    f.underlying.debug(f.marker, f.message, Seq(f.arg1): _*) wasNever called
+    verify(f.underlying, never()).debug(f.marker, f.message, Seq(f.arg1): _*)
     f.logger.debugWith(f.marker, f.message, f.arg1, f.arg2)
-    f.underlying.debug(f.marker, f.message, Seq(f.arg1, f.arg2): _*) wasNever called
+    verify(f.underlying, never()).debug(f.marker, f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.debugWith(f.marker, f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.debug(f.marker, f.message, f.arg1, f.arg2, f.arg3) wasNever called
+    verify(f.underlying, never()).debug(f.marker, f.message, f.arg1, f.arg2, f.arg3)
   }
 
   /* Info */
 
   test("Marker Logging#info enabled") {
-    val f = fixture(_.isInfoEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isInfoEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.info(f.marker, f.message)
-    f.underlying.info(f.marker, f.message) was called
+    verify(f.underlying).info(f.marker, f.message)
   }
 
   test("Marker Logging#info not enabled") {
-    val f = fixture(_.isInfoEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isInfoEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.info(f.marker, f.message)
-    f.underlying.info(any[Marker], any[String]) wasNever called
+    verify(f.underlying, never()).info(any[Marker](), any[String]())
   }
 
   test("Marker Logging#info enabled with message and cause") {
-    val f = fixture(_.isInfoEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isInfoEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.info(f.marker, f.message, f.cause)
-    f.underlying.info(f.marker, f.message, f.cause) was called
+    verify(f.underlying).info(f.marker, f.message, f.cause)
   }
 
   test("Marker Logging#info not enabled with message and cause") {
-    val f = fixture(_.isInfoEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isInfoEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.info(f.marker, f.message, f.cause)
-    f.underlying.info(any[Marker], any[String], any) wasNever called
+    verify(f.underlying, never()).info(any[Marker](), any[String](), any)
   }
 
   test("Marker Logging#info enabled with parameters") {
-    val f = fixture(_.isInfoEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isInfoEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.infoWith(f.marker, f.message, f.arg1)
-    f.underlying.info(f.marker, f.message, Seq(f.arg1): _*) was called
+    verify(f.underlying).info(f.marker, f.message, Seq(f.arg1): _*)
     f.logger.infoWith(f.marker, f.message, f.arg1, f.arg2)
-    f.underlying.info(f.marker, f.message, Seq(f.arg1, f.arg2): _*) was called
+    verify(f.underlying).info(f.marker, f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.infoWith(f.marker, f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.info(f.marker, f.message, f.arg1, f.arg2, f.arg3) was called
+    verify(f.underlying).info(f.marker, f.message, f.arg1, f.arg2, f.arg3)
   }
 
   test("Marker Logging#info not enabled with parameters") {
-    val f = fixture(_.isInfoEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isInfoEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.infoWith(f.marker, f.message, f.arg1)
-    f.underlying.info(f.marker, f.message, Seq(f.arg1): _*) wasNever called
+    verify(f.underlying, never()).info(f.marker, f.message, Seq(f.arg1): _*)
     f.logger.infoWith(f.marker, f.message, f.arg1, f.arg2)
-    f.underlying.info(f.marker, f.message, Seq(f.arg1, f.arg2): _*) wasNever called
+    verify(f.underlying, never()).info(f.marker, f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.infoWith(f.marker, f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.info(f.marker, f.message, f.arg1, f.arg2, f.arg3) wasNever called
+    verify(f.underlying, never()).info(f.marker, f.message, f.arg1, f.arg2, f.arg3)
   }
 
   /* Warn */
 
   test("Marker Logging#warn enabled") {
-    val f = fixture(_.isWarnEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isWarnEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.warn(f.marker, f.message)
-    f.underlying.warn(f.marker, f.message) was called
+    verify(f.underlying).warn(f.marker, f.message)
   }
 
   test("Marker Logging#warn not enabled") {
-    val f = fixture(_.isWarnEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isWarnEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.warn(f.marker, f.message)
-    f.underlying.warn(any[Marker], any[String]) wasNever called
+    verify(f.underlying, never()).warn(any[Marker](), any[String]())
   }
 
   test("Marker Logging#warn enabled with message and cause") {
-    val f = fixture(_.isWarnEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isWarnEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.warn(f.marker, f.message, f.cause)
-    f.underlying.warn(f.marker, f.message, f.cause) was called
+    verify(f.underlying).warn(f.marker, f.message, f.cause)
   }
 
   test("Marker Logging#warn not enabled with message and cause") {
-    val f = fixture(_.isWarnEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isWarnEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.warn(f.marker, f.message, f.cause)
-    f.underlying.warn(any[Marker], any[String], any) wasNever called
+    verify(f.underlying, never()).warn(any[Marker](), any[String](), any)
   }
 
   test("Marker Logging#warn enabled with parameters") {
-    val f = fixture(_.isWarnEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isWarnEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.warnWith(f.marker, f.message, f.arg1)
-    f.underlying.warn(f.marker, f.message, Seq(f.arg1): _*) was called
+    verify(f.underlying).warn(f.marker, f.message, Seq(f.arg1): _*)
     f.logger.warnWith(f.marker, f.message, f.arg1, f.arg2)
-    f.underlying.warn(f.marker, f.message, Seq(f.arg1, f.arg2): _*) was called
+    verify(f.underlying).warn(f.marker, f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.warnWith(f.marker, f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.warn(f.marker, f.message, f.arg1, f.arg2, f.arg3) was called
+    verify(f.underlying).warn(f.marker, f.message, f.arg1, f.arg2, f.arg3)
   }
 
   test("Marker Logging#warn not enabled with parameters") {
-    val f = fixture(_.isWarnEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isWarnEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.warnWith(f.marker, f.message, f.arg1)
-    f.underlying.warn(f.marker, f.message, Seq(f.arg1): _*) wasNever called
+    verify(f.underlying, never()).warn(f.marker, f.message, Seq(f.arg1): _*)
     f.logger.warnWith(f.marker, f.message, f.arg1, f.arg2)
-    f.underlying.warn(f.marker, f.message, Seq(f.arg1, f.arg2): _*) wasNever called
+    verify(f.underlying, never()).warn(f.marker, f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.warnWith(f.marker, f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.warn(f.marker, f.message, f.arg1, f.arg2, f.arg3) wasNever called
+    verify(f.underlying, never()).warn(f.marker, f.message, f.arg1, f.arg2, f.arg3)
   }
 
   /* Error */
 
   test("Marker Logging#error enabled") {
-    val f = fixture(_.isErrorEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isErrorEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.error(f.marker, f.message)
-    f.underlying.error(f.marker, f.message) was called
+    verify(f.underlying).error(f.marker, f.message)
   }
 
   test("Marker Logging#error not enabled") {
-    val f = fixture(_.isErrorEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isErrorEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.error(f.marker, f.message)
-    f.underlying.error(any[Marker], any[String]) wasNever called
+    verify(f.underlying, never()).error(any[Marker](), any[String]())
   }
 
   test("Marker Logging#error enabled with message and cause") {
-    val f = fixture(_.isErrorEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isErrorEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.error(f.marker, f.message, f.cause)
-    f.underlying.error(f.marker, f.message, f.cause) was called
+    verify(f.underlying).error(f.marker, f.message, f.cause)
   }
 
   test("Marker Logging#error not enabled with message and cause") {
-    val f = fixture(_.isErrorEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isErrorEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.error(f.marker, f.message, f.cause)
-    f.underlying.error(any[Marker], any[String], any) wasNever called
+    verify(f.underlying, never()).error(any[Marker](), any[String](), any)
   }
 
   test("Marker Logging#error enabled with parameters") {
-    val f = fixture(_.isErrorEnabled(any[Marker]), isEnabled = true)
+    val f = Fixture(_.isErrorEnabled(any[Marker]()), isEnabled = true)
 
     f.logger.errorWith(f.marker, f.message, f.arg1)
-    f.underlying.error(f.marker, f.message, Seq(f.arg1): _*) was called
+    verify(f.underlying).error(f.marker, f.message, Seq(f.arg1): _*)
     f.logger.errorWith(f.marker, f.message, f.arg1, f.arg2)
-    f.underlying.error(f.marker, f.message, Seq(f.arg1, f.arg2): _*) was called
+    verify(f.underlying).error(f.marker, f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.errorWith(f.marker, f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.error(f.marker, f.message, f.arg1, f.arg2, f.arg3) was called
+    verify(f.underlying).error(f.marker, f.message, f.arg1, f.arg2, f.arg3)
   }
 
   test("Marker Logging#error not enabled with parameters") {
-    val f = fixture(_.isErrorEnabled(any[Marker]), isEnabled = false)
+    val f = Fixture(_.isErrorEnabled(any[Marker]()), isEnabled = false)
 
     f.logger.errorWith(f.marker, f.message, f.arg1)
-    f.underlying.error(f.marker, f.message, Seq(f.arg1): _*) wasNever called
+    verify(f.underlying, never()).error(f.marker, f.message, Seq(f.arg1): _*)
     f.logger.errorWith(f.marker, f.message, f.arg1, f.arg2)
-    f.underlying.error(f.marker, f.message, Seq(f.arg1, f.arg2): _*) wasNever called
+    verify(f.underlying, never()).error(f.marker, f.message, Seq(f.arg1, f.arg2): _*)
     f.logger.errorWith(f.marker, f.message, f.arg1, f.arg2, f.arg3)
-    f.underlying.error(f.marker, f.message, f.arg1, f.arg2, f.arg3) wasNever called
+    verify(f.underlying, never()).error(f.marker, f.message, f.arg1, f.arg2, f.arg3)
   }
 
   /* Private */
 
-  private def fixture(p: org.slf4j.Logger => Boolean, isEnabled: Boolean) = new {
+  private case class Fixture(p: org.slf4j.Logger => Boolean, isEnabled: Boolean) {
     val marker: Marker = TestMarker
     val message = "msg"
     val cause = new RuntimeException("TEST EXCEPTION")
     val arg1 = "arg1"
     val arg2 = new Integer(1)
     val arg3 = "arg3"
-    val underlying: org.slf4j.Logger = mock[org.slf4j.Logger]
+    val underlying: org.slf4j.Logger = mock(classOf[org.slf4j.Logger])
     when(p(underlying)).thenReturn(isEnabled)
     val logger: Logger = Logger(underlying)
   }
diff --git a/util-slf4j-api/src/test/scala/com/twitter/util/logging/Stock.scala b/util-slf4j-api/src/test/scala/com/twitter/util/logging/Stock.scala
index e399716c52..4965e71621 100644
--- a/util-slf4j-api/src/test/scala/com/twitter/util/logging/Stock.scala
+++ b/util-slf4j-api/src/test/scala/com/twitter/util/logging/Stock.scala
@@ -1,6 +1,6 @@
 package com.twitter.util.logging
 
 class Stock(symbol: String, price: BigDecimal) extends Logging {
-  info(f"New stock with symbol = $symbol and price = $price%1.2f")
-  def quote: String = f"$symbol = $price%1.2f"
+  info(f"New stock with symbol = $symbol and price = ${price.toDouble}%1.2f")
+  def quote: String = f"$symbol = ${price.toDouble}%1.2f"
 }
diff --git a/util-stats/src/main/scala/com/twitter/finagle/stats/InMemoryStatsReceiver.scala b/util-stats/src/main/scala/com/twitter/finagle/stats/InMemoryStatsReceiver.scala
index 14c565495d..344bf65da8 100644
--- a/util-stats/src/main/scala/com/twitter/finagle/stats/InMemoryStatsReceiver.scala
+++ b/util-stats/src/main/scala/com/twitter/finagle/stats/InMemoryStatsReceiver.scala
@@ -198,7 +198,7 @@ class InMemoryStatsReceiver extends StatsReceiver with WithHistogramDetails {
       p.println("---------")
     }
     for ((k, v) <- sortedCounters)
-      p.print(f"$k%s $v%d\n")
+      p.println(f"$k%s $v%d") // TODO Scala3 bug-report?
     if (includeHeaders && sortedGauges.nonEmpty) {
       p.println("\nGauges:")
       p.println("-------")
diff --git a/util-stats/src/test/scala/com/twitter/finagle/stats/DelegatingStatsReceiverTest.scala b/util-stats/src/test/scala/com/twitter/finagle/stats/DelegatingStatsReceiverTest.scala
index bc7aa742c5..530a37c2b8 100644
--- a/util-stats/src/test/scala/com/twitter/finagle/stats/DelegatingStatsReceiverTest.scala
+++ b/util-stats/src/test/scala/com/twitter/finagle/stats/DelegatingStatsReceiverTest.scala
@@ -64,14 +64,14 @@ class DelegatingStatsReceiverTest extends AnyFunSuite with ScalaCheckDrivenPrope
       Gen.oneOf(seq).flatMap(identity)
     }
 
-    implicit val impl = Arbitrary(Gen.delay(statsReceiverTopology(0)))
+    implicit val impl: Arbitrary[StatsReceiver] = Arbitrary(Gen.delay(statsReceiverTopology(0)))
   }
 
   test("DelegatingStatsReceiver.all collects effectively across many StatsReceivers") {
     val ctx = new Ctx
     import ctx._
 
-    forAll { statsReceiver: StatsReceiver =>
+    forAll { (statsReceiver: StatsReceiver) =>
       assert(DelegatingStatsReceiver.all(statsReceiver).size == leafCounter)
       leafCounter = 0
     }
diff --git a/util-stats/src/test/scala/com/twitter/finagle/stats/InMemoryStatsReceiverTest.scala b/util-stats/src/test/scala/com/twitter/finagle/stats/InMemoryStatsReceiverTest.scala
index 50f1af0b49..ddd23067a2 100644
--- a/util-stats/src/test/scala/com/twitter/finagle/stats/InMemoryStatsReceiverTest.scala
+++ b/util-stats/src/test/scala/com/twitter/finagle/stats/InMemoryStatsReceiverTest.scala
@@ -58,7 +58,7 @@ class InMemoryStatsReceiverTest extends AnyFunSuite with Eventually with Integra
   test("ReadableGauge.toString") {
     var n = 0
     val stats = new InMemoryStatsReceiver()
-    val g = stats.addGauge("a", "b") { n }
+    val g = stats.addGauge("a", "b") { n.toFloat }
     assert("Gauge(a/b=0.0)" == g.toString)
 
     n = 11
@@ -177,6 +177,7 @@ class InMemoryStatsReceiverTest extends AnyFunSuite with Eventually with Integra
 
       inMemoryStatsReceiver.print(ps)
       val content = new String(baos.toByteArray, StandardCharsets.UTF_8)
+      println(content)
       val parts = content.split('\n')
 
       assert(parts.length == 9)
diff --git a/util-stats/src/test/scala/com/twitter/finagle/stats/exp/ExpressionSchemaTest.scala b/util-stats/src/test/scala/com/twitter/finagle/stats/exp/ExpressionSchemaTest.scala
index 1dad70b3ed..84f7e0a882 100644
--- a/util-stats/src/test/scala/com/twitter/finagle/stats/exp/ExpressionSchemaTest.scala
+++ b/util-stats/src/test/scala/com/twitter/finagle/stats/exp/ExpressionSchemaTest.scala
@@ -56,7 +56,7 @@ class ExpressionSchemaTest extends AnyFunSuite {
             case NonFatal(exn) =>
               failuresCounter.incr()
           } finally {
-            latencyStat.add(elapsed().inMilliseconds)
+            latencyStat.add(elapsed().inMilliseconds.toFloat)
           }
         }
       }
diff --git a/util-thrift/src/main/scala/com/twitter/util/ThriftCodec.scala b/util-thrift/src/main/scala/com/twitter/util/ThriftCodec.scala
index 80e97c7ce0..64bd026ebb 100644
--- a/util-thrift/src/main/scala/com/twitter/util/ThriftCodec.scala
+++ b/util-thrift/src/main/scala/com/twitter/util/ThriftCodec.scala
@@ -3,20 +3,22 @@ package com.twitter.util
 import org.apache.thrift.TBase
 import org.apache.thrift.protocol.{TBinaryProtocol, TCompactProtocol, TProtocolFactory}
 
+import scala.reflect.{ClassTag, classTag} // TODO Scala3 Is ClassTag ok here?
+
 object ThriftCodec {
-  def apply[T <: TBase[_, _]: Manifest, P <: TProtocolFactory: Manifest]: ThriftCodec[T, P] =
+  def apply[T <: TBase[_, _]: ClassTag, P <: TProtocolFactory: ClassTag]: ThriftCodec[T, P] =
     new ThriftCodec[T, P]
 }
 
-class ThriftCodec[T <: TBase[_, _]: Manifest, P <: TProtocolFactory: Manifest]
+class ThriftCodec[T <: TBase[_, _]: ClassTag, P <: TProtocolFactory: ClassTag]
     extends Codec[T, Array[Byte]]
     with ThriftSerializer {
 
   protected lazy val prototype: T =
-    manifest[T].runtimeClass.asInstanceOf[Class[T]].newInstance
+    classTag[T].runtimeClass.asInstanceOf[Class[T]].newInstance
 
   lazy val protocolFactory: TProtocolFactory =
-    manifest[P].runtimeClass.asInstanceOf[Class[P]].newInstance
+    classTag[P].runtimeClass.asInstanceOf[Class[P]].newInstance
 
   def encode(item: T): Array[Byte] = toBytes(item)
 
@@ -27,7 +29,7 @@ class ThriftCodec[T <: TBase[_, _]: Manifest, P <: TProtocolFactory: Manifest]
   }
 }
 
-class BinaryThriftCodec[T <: TBase[_, _]: Manifest] extends ThriftCodec[T, TBinaryProtocol.Factory]
+class BinaryThriftCodec[T <: TBase[_, _]: ClassTag] extends ThriftCodec[T, TBinaryProtocol.Factory]
 
-class CompactThriftCodec[T <: TBase[_, _]: Manifest]
+class CompactThriftCodec[T <: TBase[_, _]: ClassTag]
     extends ThriftCodec[T, TCompactProtocol.Factory]
diff --git a/util-tunable/src/main/scala/com/twitter/util/tunable/TunableMap.scala b/util-tunable/src/main/scala/com/twitter/util/tunable/TunableMap.scala
index 8ac4b9aaaa..a3c75b31da 100644
--- a/util-tunable/src/main/scala/com/twitter/util/tunable/TunableMap.scala
+++ b/util-tunable/src/main/scala/com/twitter/util/tunable/TunableMap.scala
@@ -5,6 +5,7 @@ import java.util.function.BiFunction
 import scala.annotation.varargs
 import scala.collection.mutable
 import scala.jdk.CollectionConverters._
+import scala.reflect.ClassTag
 
 /**
  * A Map that can be used to access [[Tunable]]s using [[TunableMap.Key]]s.
@@ -133,7 +134,7 @@ object TunableMap {
   }
 
   object Key {
-    def apply[T](id: String)(implicit m: Manifest[T]): Key[T] =
+    def apply[T](id: String)(implicit m: ClassTag[T]): Key[T] = // TODO Scala3 Is ClassTag ok?
       Key[T](id, m.runtimeClass.asInstanceOf[Class[T]])
   }
 
@@ -199,7 +200,7 @@ object TunableMap {
      * Put a [[Tunable]] with id `id` and value `value` into the [[TunableMap]]. If the [[Tunable]]
      * for that `id` already exists, update the value to `value`.
      */
-    final def put[T](id: String, value: T)(implicit m: Manifest[T]): Key[T] =
+    final def put[T](id: String, value: T)(implicit m: ClassTag[T]): Key[T] = // TODO Scala3 Is ClassTag ok?
       put[T](id, m.runtimeClass.asInstanceOf[Class[T]], value)
 
     /**
diff --git a/util-tunable/src/test/scala/com/twitter/util/tunable/JsonTunableMapperTest.scala b/util-tunable/src/test/scala/com/twitter/util/tunable/JsonTunableMapperTest.scala
index f8e87a2515..3df7d2a800 100644
--- a/util-tunable/src/test/scala/com/twitter/util/tunable/JsonTunableMapperTest.scala
+++ b/util-tunable/src/test/scala/com/twitter/util/tunable/JsonTunableMapperTest.scala
@@ -26,7 +26,9 @@ class JsonTunableMapperTest extends AnyFunSuite {
     JsonTunableMapper().parse("""{ "tunables": [ ] }""") match {
       case Return(map) =>
         assert(map eq NullTunableMap)
-      case Throw(_) => fail()
+      case Throw(exc) =>
+        exc.printStackTrace()
+        fail(exc.getMessage)
     }
   }
 
diff --git a/util-zk/src/main/scala/com/twitter/zk/NativeConnector.scala b/util-zk/src/main/scala/com/twitter/zk/NativeConnector.scala
index ef6755a404..b8f173dc57 100644
--- a/util-zk/src/main/scala/com/twitter/zk/NativeConnector.scala
+++ b/util-zk/src/main/scala/com/twitter/zk/NativeConnector.scala
@@ -53,7 +53,7 @@ case class NativeConnector(
         c.sessionEvents foreach { event => sessionBroker.send(event()).sync() }
         connection = Some(c)
         c
-      }.apply
+      }.apply()
     }.flatten
       .rescue {
         case e: NativeConnector.ConnectTimeoutException =>
diff --git a/util-zk/src/main/scala/com/twitter/zk/ZNode.scala b/util-zk/src/main/scala/com/twitter/zk/ZNode.scala
index 5b5fe3fb58..c645d4782b 100644
--- a/util-zk/src/main/scala/com/twitter/zk/ZNode.scala
+++ b/util-zk/src/main/scala/com/twitter/zk/ZNode.scala
@@ -232,7 +232,7 @@ trait ZNode {
             removed = knownChildren -- children
           )
           log.debug("updating %s with %d children", path, treeUpdate.added.size)
-          broker.send(treeUpdate).sync.onSuccess { _ =>
+          broker.send(treeUpdate).sync().onSuccess { _ =>
             log.debug("updated %s with %d children", path, treeUpdate.added.size)
             treeUpdate.added foreach { z => pipeSubTreeUpdates(z.monitorTree()) }
             eventUpdate onSuccess { event =>
@@ -247,7 +247,7 @@ trait ZNode {
           // Tell the broker about the children we lost; otherwise, if there were no children,
           // this deletion should be reflected in a watch on the parent node, if one exists.
           if (knownChildren.size > 0) {
-            broker.send(ZNode.TreeUpdate(this, removed = knownChildren)).sync
+            broker.send(ZNode.TreeUpdate(this, removed = knownChildren)).sync()
           } else {
             Future.Done
           } onSuccess { _ =>
diff --git a/util-zk/src/main/scala/com/twitter/zk/coordination/ShardCoordinator.scala b/util-zk/src/main/scala/com/twitter/zk/coordination/ShardCoordinator.scala
index 7d02868971..1742475121 100644
--- a/util-zk/src/main/scala/com/twitter/zk/coordination/ShardCoordinator.scala
+++ b/util-zk/src/main/scala/com/twitter/zk/coordination/ShardCoordinator.scala
@@ -55,7 +55,7 @@ class ShardCoordinator(zk: ZkClient, path: String, numShards: Int) {
    *                                    ShardCoordinator.
    */
   def acquire(): Future[ShardPermit] = {
-    semaphore.acquire flatMap { permit =>
+    semaphore.acquire() flatMap { permit =>
       shardNodes() map { nodes =>
         nodes map { node => shardIdOf(node.path) }
       } map { ids =>
diff --git a/util-zk/src/test/scala/com/twitter/zk/ZkClientTest.scala b/util-zk/src/test/scala/com/twitter/zk/ZkClientTest.scala
index 7915d044fc..7885d4bd6c 100644
--- a/util-zk/src/test/scala/com/twitter/zk/ZkClientTest.scala
+++ b/util-zk/src/test/scala/com/twitter/zk/ZkClientTest.scala
@@ -20,7 +20,7 @@ import org.scalatest.wordspec.AnyWordSpec
 class ZkClientTest extends AnyWordSpec with MockitoSugar {
   Logger.get("").setLevel(Level.FATAL)
 
-  implicit val javaTimer = new JavaTimer(true)
+  implicit val javaTimer: JavaTimer = new JavaTimer(true)
 
   class ZkClientHelper {
     val zk = mock[ZooKeeper]
@@ -600,7 +600,7 @@ class ZkClientTest extends AnyWordSpec with MockitoSugar {
             )
             offer.sync()
             intercept[KeeperException.NoNodeException] {
-              offer.syncWait().get
+              offer.syncWait().get()
             }
             assert(offer.sync().isDefined == false)
           }
@@ -611,7 +611,7 @@ class ZkClientTest extends AnyWordSpec with MockitoSugar {
 
             watch(znode.path)(Future(new Stat))(Future(StateEvent.Disconnected()))
             val offer = znode.exists.monitor()
-            assert(offer.syncWait().get == result)
+            assert(offer.syncWait().get() == result)
 
             watch(znode.path) {
               Future.exception(new KeeperException.SessionExpiredException)
@@ -685,7 +685,7 @@ class ZkClientTest extends AnyWordSpec with MockitoSugar {
 
         val update = znode.getChildren.monitor()
         results foreach { result =>
-          val r = update.syncWait().get
+          val r = update.syncWait().get()
           assert(r.path == result.path)
         }
       }
@@ -857,7 +857,7 @@ class ZkClientTest extends AnyWordSpec with MockitoSugar {
             val e = expectedByPath(ztu.parent.path)
             assert(ztu.parent == e.parent)
             assert(ztu.added.map { _.path } == e.added.map { _.path }.toSet)
-            assert(ztu.removed == List())
+            assert(ztu.removed == Set.empty)
           }
           Await.result(offer.sync(), 1.second)
         }
diff --git a/util-zk/src/test/scala/com/twitter/zk/coordination/ShardCoordinatorTest.scala b/util-zk/src/test/scala/com/twitter/zk/coordination/ShardCoordinatorTest.scala
index d275ccd629..aba58d75ae 100644
--- a/util-zk/src/test/scala/com/twitter/zk/coordination/ShardCoordinatorTest.scala
+++ b/util-zk/src/test/scala/com/twitter/zk/coordination/ShardCoordinatorTest.scala
@@ -24,11 +24,11 @@ class ShardCoordinatorTest extends AnyWordSpec with MockitoSugar {
           .withRetryPolicy(RetryPolicy.Basic(3))
           .withAcl(OPEN_ACL_UNSAFE.asScala.toSeq)
 
-        Await.result(Future { f(zk) } ensure { zk.release })
+        Await.result(Future { f(zk) } ensure { zk.release() })
       }
 
       def acquire(coord: ShardCoordinator) = {
-        coord.acquire within (new JavaTimer(true), 1.second)
+        coord.acquire() within (new JavaTimer(true), 1.second)
       }
 
       "provide shards" in {
@@ -52,15 +52,15 @@ class ShardCoordinatorTest extends AnyWordSpec with MockitoSugar {
 
           val fshard5 = acquire(coord)
           assert(fshard5.isDefined == (false))
-          shard3.release
+          shard3.release()
           val shard5 = Await.result(fshard5)
           assert(shard5.id == 3)
 
-          shard0.release
-          shard1.release
-          shard2.release
-          shard4.release
-          shard5.release
+          shard0.release()
+          shard1.release()
+          shard2.release()
+          shard4.release()
+          shard5.release()
         }
       }
 
diff --git a/util-zk/src/test/scala/com/twitter/zk/coordination/ZkAsyncSemaphoreTest.scala b/util-zk/src/test/scala/com/twitter/zk/coordination/ZkAsyncSemaphoreTest.scala
index 806545e6c1..32487c9514 100644
--- a/util-zk/src/test/scala/com/twitter/zk/coordination/ZkAsyncSemaphoreTest.scala
+++ b/util-zk/src/test/scala/com/twitter/zk/coordination/ZkAsyncSemaphoreTest.scala
@@ -29,7 +29,7 @@ class ZkAsyncSemaphoreTest extends AnyWordSpec with MockitoSugar with Waiters {
           .withRetryPolicy(RetryPolicy.Basic(3))
           .withAcl(OPEN_ACL_UNSAFE.asScala.toSeq)
 
-        Await.result(Future { f(zk) } ensure { zk.release })
+        Await.result(Future { f(zk) } ensure { zk.release() })
       }
 
       def acquire(sem: ZkAsyncSemaphore) = {