Decrease usage of deprecated elements

Author: jozic

README.md

@@ -41,7 +41,8 @@ The library has independent developers, release cycle and versioning from core m
 If you're in Scala 2.12 you'll probably want to add the compiler flag `-Ypartial-unification`, if you don't you risk some compile errors when trying to stub complex types using the idiomatic syntax
 
 ## Notes for 2.0.0
-We dropped support for Scala 2.11 and Java 8, as Mockito 5 dropped support for Java 8.
+We dropped support for Scala 2.11 and Java 8, as Mockito 5 dropped support for Java 8. 
+Java 11 is now the minimum supported version.
 
 ## Notes for 1.13.6
 

build.sbt

@@ -1,6 +1,4 @@
-import scala.io.Source
 import scala.language.postfixOps
-import sbt.io.Using
 
 val currentScalaVersion = "2.13.16"
 
@@ -48,7 +46,8 @@ lazy val commonSettings =
         case _ =>
           Seq("org.scala-lang.modules" %% "scala-parallel-collections" % "1.2.0")
       }
-    }
+    },
+    libraryDependencies += "org.scala-lang.modules" %% "scala-collection-compat" % "2.13.0"
   )
 
 lazy val publishSettings = Seq(
@@ -154,8 +153,6 @@ lazy val core = (project in file("core"))
     name := "mockito-scala",
     libraryDependencies ++= Dependencies.commonLibraries,
     libraryDependencies ++= Dependencies.scalaReflection.value,
-    // TODO remove when we remove the deprecated classes in org.mockito.integrations.Dependencies.scalatest
-    libraryDependencies += Dependencies.scalatest % "provided",
     // include the macro classes and resources in the main jar
     Compile / packageBin / mappings ++= (macroSub / Compile / packageBin / mappings).value,
     // include the macro sources in the main source jar

common/src/main/scala/org/mockito/MockitoAPI.scala

@@ -24,10 +24,12 @@ import org.mockito.internal.util.reflection.LenientCopyTool
 import org.mockito.internal.{ ValueClassExtractor, ValueClassWrapper }
 import org.mockito.invocation.{ Invocation, InvocationContainer, InvocationOnMock, MockHandler }
 import org.mockito.mock.MockCreationSettings
+import org.mockito.quality.Strictness
 import org.mockito.stubbing._
 import org.mockito.verification.{ VerificationAfterDelay, VerificationMode, VerificationWithTimeout }
 import org.scalactic.{ Equality, Prettifier }
-import scala.collection.JavaConverters._
+
+import scala.jdk.CollectionConverters._
 import scala.reflect.ClassTag
 import scala.reflect.runtime.universe.WeakTypeTag
 
@@ -543,7 +545,7 @@ private[mockito] trait MockitoEnhancer extends MockCreator {
 
   def spy[T <: AnyRef: ClassTag: WeakTypeTag](realObj: T, lenient: Boolean = false)(implicit $pt: Prettifier): T = {
     def mockSettings: MockSettings = Mockito.withSettings().defaultAnswer(CALLS_REAL_METHODS).spiedInstance(realObj)
-    val settings                   = if (lenient) mockSettings.lenient() else mockSettings
+    val settings                   = if (lenient) mockSettings.strictness(Strictness.LENIENT) else mockSettings
     mock[T](settings)
   }
 
@@ -645,7 +647,7 @@ object LeniencySettings {
   }
 
   val lenientStubs: LeniencySettings = new LeniencySettings {
-    override def apply(settings: MockSettings): MockSettings = settings.lenient()
+    override def apply(settings: MockSettings): MockSettings = settings.strictness(Strictness.LENIENT)
   }
 }
 

common/src/main/scala/org/mockito/ReflectionUtils.scala

@@ -9,19 +9,13 @@ import ru.vyarus.java.generics.resolver.GenericsResolver
 
 import scala.reflect.ClassTag
 import scala.reflect.internal.Symbols
-import scala.util.{ Failure, Success, Try => uTry }
+import scala.util.{ Try => uTry }
 import scala.util.control.NonFatal
 
 object ReflectionUtils {
   import scala.reflect.runtime.{ universe => ru }
   import ru._
 
-  private val JavaVersion: Int =
-    System.getProperty("java.version").split("\\.") match {
-      case Array("1", v, _*) => v.toInt // Java 8 style: 1.8.x
-      case Array(v, _*)      => v.toInt // Java 9+ style: 11.x, 17.x, etc.
-    }
-
   implicit def symbolToMethodSymbol(sym: Symbol): Symbols#MethodSymbol = sym.asInstanceOf[Symbols#MethodSymbol]
 
   private val mirror       = runtimeMirror(getClass.getClassLoader)
@@ -120,39 +114,6 @@ object ReflectionUtils {
     }
 
   def setFinalStatic(field: Field, newValue: AnyRef): Unit =
-    if (JavaVersion < 17)
-      setFinalStatic17Minus(field, newValue)
-    else
-      setFinalStatic17Plus(field, newValue)
-
-  private def setFinalStatic17Minus(field: Field, newValue: AnyRef): Unit = {
-    val clazz = classOf[java.lang.Class[_]]
-    field.setAccessible(true)
-    val modifiersField: Field = uTry(clazz.getDeclaredField("modifiers")) match {
-      case Success(modifiers) => modifiers
-      case Failure(e)         =>
-        uTry {
-          val getDeclaredFields0           = clazz.getDeclaredMethod("getDeclaredFields0", classOf[Boolean])
-          val accessibleBeforeSet: Boolean = getDeclaredFields0.isAccessible
-          getDeclaredFields0.setAccessible(true)
-          val declaredFields: Array[Field] = getDeclaredFields0
-            .invoke(classOf[Field], java.lang.Boolean.FALSE)
-            .asInstanceOf[Array[Field]]
-          getDeclaredFields0.setAccessible(accessibleBeforeSet)
-          declaredFields.find("modifiers" == _.getName).get
-        } match {
-          case Success(modifiers) => modifiers
-          case Failure(ex)        =>
-            e.addSuppressed(ex)
-            throw e
-        }
-    }
-    modifiersField.setAccessible(true)
-    modifiersField.setInt(field, field.getModifiers & ~Modifier.FINAL)
-    field.set(null, newValue)
-  }
-
-  private def setFinalStatic17Plus(field: Field, newValue: AnyRef): Unit =
     try {
       // Try to get Unsafe instance (works with both sun.misc.Unsafe and jdk.internal.misc.Unsafe)
       val unsafeClass: Class[_] =
@@ -171,6 +132,9 @@ object ReflectionUtils {
       val staticFieldOffsetMethod = unsafeClass.getMethod("staticFieldOffset", classOf[Field])
       val putObjectMethod         = unsafeClass.getMethod("putObject", classOf[Object], classOf[Long], classOf[Object])
 
+      // Make the field accessible
+      field.setAccessible(true)
+
       // Get base and offset for the field
       val base: Object = staticFieldBaseMethod.invoke(unsafe, field)
       val offset: Long = staticFieldOffsetMethod.invoke(unsafe, field).asInstanceOf[Long]

common/src/main/scala/org/mockito/internal/handler/ScalaMockHandler.scala

@@ -14,7 +14,8 @@ import org.mockito.mock.MockCreationSettings
 import org.scalactic.Prettifier
 import org.scalactic.TripleEquals._
 
-import scala.collection.JavaConverters._
+import scala.collection.compat._
+import scala.jdk.CollectionConverters._
 
 class ScalaMockHandler[T](mockSettings: MockCreationSettings[T], methodsToProcess: Seq[(Method, Set[Int])])(implicit $pt: Prettifier) extends MockHandlerImpl[T](mockSettings) {
   override def handle(invocation: Invocation): AnyRef =
@@ -43,17 +44,17 @@ class ScalaMockHandler[T](mockSettings: MockCreationSettings[T], methodsToProces
       .collectFirst {
         case (mtd, indices) if method === mtd =>
           val argumentMatcherStorage                     = mockingProgress().getArgumentMatcherStorage
-          val matchers                                   = argumentMatcherStorage.pullLocalizedMatchers().asScala.toIterator
+          val matchers                                   = argumentMatcherStorage.pullLocalizedMatchers().asScala.iterator
           val matchersWereUsed                           = matchers.nonEmpty
           def reportMatcher(): Unit                      = if (matchers.nonEmpty) argumentMatcherStorage.reportMatcher(matchers.next().getMatcher)
           def reportMatchers(varargs: Iterable[_]): Unit =
             if (matchersWereUsed && varargs.nonEmpty) {
               def reportAsEqTo(): Unit = varargs.map(EqTo(_)).foreach(argumentMatcherStorage.reportMatcher(_))
               val matcher              = matchers.next().getMatcher
               matcher match {
-                case EqTo(value: Array[_]) if varargs.sameElements(value) => reportAsEqTo()
-                case EqTo(value) if varargs == value                      => reportAsEqTo()
-                case other                                                =>
+                case EqTo(value: Array[_]) if varargs.iterator.sameElements(value.iterator) => reportAsEqTo()
+                case EqTo(value) if varargs == value                                        => reportAsEqTo()
+                case other                                                                  =>
                   argumentMatcherStorage.reportMatcher(other)
                   varargs.drop(1).foreach(_ => reportMatcher())
               }

common/src/main/scala/org/mockito/internal/invocation/ScalaInvocation.scala

@@ -13,7 +13,7 @@ import org.mockito.invocation.{ Invocation, Location, StubInfo }
 import org.mockito.matchers.EqTo
 import org.scalactic.Prettifier
 
-import scala.collection.JavaConverters._
+import scala.jdk.CollectionConverters._
 
 class ScalaInvocation(
     val mockRef: MockReference[AnyRef],

common/src/main/scala/org/mockito/stubbing/ReturnsSmartNulls.scala

@@ -7,6 +7,7 @@ import org.mockito.internal.exceptions.Reporter.smartNullPointerException
 import org.mockito.internal.stubbing.defaultanswers.ReturnsMoreEmptyValues
 import org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod
 import org.mockito.invocation.{ InvocationOnMock, Location }
+import org.mockito.quality.Strictness
 
 object ReturnsSmartNulls extends DefaultAnswer {
   val delegate = new ReturnsMoreEmptyValues
@@ -16,7 +17,7 @@ object ReturnsSmartNulls extends DefaultAnswer {
       val returnType = invocation.returnType
 
       if (!returnType.isPrimitive && !isFinal(returnType.getModifiers) && classOf[Object] != returnType)
-        Some(mock(returnType, withSettings.defaultAnswer(ThrowsSmartNullPointer(invocation)).lenient()))
+        Some(mock(returnType, withSettings.defaultAnswer(ThrowsSmartNullPointer(invocation)).strictness(Strictness.LENIENT)))
       else
         None
     }

core/src/main/scala/org/mockito/MockitoScalaSession.scala

@@ -11,7 +11,7 @@ import org.mockito.session.MockitoSessionLogger
 import org.scalactic.Equality
 import org.scalactic.TripleEquals._
 
-import scala.collection.JavaConverters._
+import scala.jdk.CollectionConverters._
 import scala.collection.mutable
 
 class MockitoScalaSession(name: String, strictness: Strictness, logger: MockitoSessionLogger) {

macro/src/main/scala/org/mockito/captor/Captor.scala

@@ -9,7 +9,7 @@ import org.mockito.{ clazz, ArgumentCaptor }
 import org.scalactic.Equality
 import org.scalactic.TripleEquals._
 
-import scala.collection.JavaConverters._
+import scala.jdk.CollectionConverters._
 import scala.reflect.ClassTag
 import scala.reflect.macros.blackbox
 import scala.util.{ Failure, Try }

scalatest/src/main/scala/org/mockito/scalatest/ResetMocksAfterEachTestBase.scala

@@ -6,12 +6,12 @@ import org.mockito.stubbing.DefaultAnswer
 import org.mockito.{ MockCreator, MockSettings }
 import org.scalactic.Prettifier
 
-import scala.collection.JavaConverters._
+import scala.jdk.CollectionConverters._
 import scala.reflect.ClassTag
 import scala.reflect.runtime.universe.WeakTypeTag
 
 /**
- * It automatically resets each mock after a each test is run, useful when we need to pass the mocks to some framework once at the beginning of the test suite
+ * It automatically resets each mock after each test is run, useful when we need to pass the mocks to some framework once at the beginning of the test suite
  *
  * Just mix-in after your favourite suite, i.e. {{{class MyTest extends PlaySpec with MockitoSugar with ResetMocksAfterEachTest}}}
  */