Merge pull request #62 from mockito/return-value-classes

Adds support to return value classes from mocked methods

Author: ultrasecreth

build.sbt

@@ -26,7 +26,7 @@ lazy val commonSettings =
       "-Ypartial-unification",
       "-language:higherKinds",
       "-Xfatal-warnings",
-//      "-Xmacro-settings:mockito-print-when,mockito-print-do-something,mockito-print-verify,mockito-print-captor,mockito-print-matcher"
+//      "-Xmacro-settings:mockito-print-when,mockito-print-do-something,mockito-print-verify,mockito-print-captor,mockito-print-matcher,mockito-print-extractor"
     ),
   )
 
@@ -37,6 +37,7 @@ lazy val commonLibraries = Seq(
 )
 
 lazy val common = (project in file("common"))
+  .dependsOn(macroCommon)
   .settings(
     commonSettings,
     libraryDependencies ++= commonLibraries,
@@ -70,6 +71,14 @@ lazy val core = (project in file("core"))
     mappings in (Compile, packageSrc) ++= mappings
       .in(common, Compile, packageSrc)
       .value,
+    // include the common classes and resources in the main jar
+    mappings in (Compile, packageBin) ++= mappings
+      .in(macroCommon, Compile, packageBin)
+      .value,
+    // include the common sources in the main source jar
+    mappings in (Compile, packageSrc) ++= mappings
+      .in(macroCommon, Compile, packageSrc)
+      .value,
     licenses := Seq("MIT" -> url("https://opensource.org/licenses/MIT")),
     homepage := Some(url("https://github.com/mockito/mockito-scala")),
     scmInfo := Some(
@@ -99,6 +108,15 @@ lazy val macroSub = (project in file("macro"))
     publishArtifact := false
   )
 
+lazy val macroCommon = (project in file("macro-common"))
+  .settings(
+    commonSettings,
+    libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value,
+    publish := {},
+    publishLocal := {},
+    publishArtifact := false
+  )
+
 lazy val root = (project in file("."))
   .settings(
     publish := {},

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

@@ -11,6 +11,7 @@
 
 package org.mockito
 
+import org.mockito.internal.ValueClassExtractor
 import org.mockito.internal.configuration.plugins.Plugins.getMockMaker
 import org.mockito.internal.creation.MockSettingsImpl
 import org.mockito.internal.handler.ScalaMockHandler
@@ -56,10 +57,10 @@ private[mockito] trait DoSomething {
    * match argument types (`Type`)}}}
    *
    */
-  def doReturn[T](toBeReturned: T, toBeReturnedNext: T*): Stubber =
+  def doReturn[T](toBeReturned: T, toBeReturnedNext: T*)(implicit $vce: ValueClassExtractor[T]): Stubber =
     Mockito.doReturn(
-      toBeReturned,
-      toBeReturnedNext.map(_.asInstanceOf[Object]): _*
+      $vce.extract(toBeReturned),
+      toBeReturnedNext.map($vce.extract).map(_.asInstanceOf[Object]): _*
     )
 
   /**
@@ -88,31 +89,36 @@ private[mockito] trait DoSomething {
   /**
    * Delegates to <code>Mockito.doAnswer()</code>, it's only here to expose the full Mockito API
    */
-  def doAnswer[R](f: => R): Stubber =
-    Mockito.doAnswer(invocationToAnswer(_ => f))
-  def doAnswer[P0: ClassTag, R](f: P0 => R): Stubber = clazz[P0] match {
+  def doAnswer[R: ValueClassExtractor](l: => R): Stubber =
+    Mockito.doAnswer(invocationToAnswer(_ =>
+      l match {
+        case f: Function0[_] => f()
+        case _               => l
+    }))
+  def doAnswer[P0: ClassTag, R: ValueClassExtractor](f: P0 => R): Stubber = clazz[P0] match {
     case c if c == classOf[InvocationOnMock] => Mockito.doAnswer(invocationToAnswer(i => f(i.asInstanceOf[P0])))
     case _                                   => Mockito.doAnswer(functionToAnswer(f))
   }
-  def doAnswer[P0, P1, R](f: (P0, P1) => R): Stubber =
+  def doAnswer[P0, P1, R: ValueClassExtractor](f: (P0, P1) => R): Stubber =
     Mockito.doAnswer(functionToAnswer(f))
-  def doAnswer[P0, P1, P2, R](f: (P0, P1, P2) => R): Stubber =
+  def doAnswer[P0, P1, P2, R: ValueClassExtractor](f: (P0, P1, P2) => R): Stubber =
     Mockito.doAnswer(functionToAnswer(f))
-  def doAnswer[P0, P1, P2, P3, R](f: (P0, P1, P2, P3) => R): Stubber =
+  def doAnswer[P0, P1, P2, P3, R: ValueClassExtractor](f: (P0, P1, P2, P3) => R): Stubber =
     Mockito.doAnswer(functionToAnswer(f))
-  def doAnswer[P0, P1, P2, P3, P4, R](f: (P0, P1, P2, P3, P4) => R): Stubber =
+  def doAnswer[P0, P1, P2, P3, P4, R: ValueClassExtractor](f: (P0, P1, P2, P3, P4) => R): Stubber =
     Mockito.doAnswer(functionToAnswer(f))
-  def doAnswer[P0, P1, P2, P3, P4, P5, R](f: (P0, P1, P2, P3, P4, P5) => R): Stubber =
+  def doAnswer[P0, P1, P2, P3, P4, P5, R: ValueClassExtractor](f: (P0, P1, P2, P3, P4, P5) => R): Stubber =
     Mockito.doAnswer(functionToAnswer(f))
-  def doAnswer[P0, P1, P2, P3, P4, P5, P6, R](f: (P0, P1, P2, P3, P4, P5, P6) => R): Stubber =
+  def doAnswer[P0, P1, P2, P3, P4, P5, P6, R: ValueClassExtractor](f: (P0, P1, P2, P3, P4, P5, P6) => R): Stubber =
     Mockito.doAnswer(functionToAnswer(f))
-  def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, R](f: (P0, P1, P2, P3, P4, P5, P6, P7) => R): Stubber =
+  def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, R: ValueClassExtractor](f: (P0, P1, P2, P3, P4, P5, P6, P7) => R): Stubber =
     Mockito.doAnswer(functionToAnswer(f))
-  def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8) => R): Stubber =
+  def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, R: ValueClassExtractor](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8) => R): Stubber =
     Mockito.doAnswer(functionToAnswer(f))
-  def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) => R): Stubber =
+  def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R: ValueClassExtractor](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) => R): Stubber =
     Mockito.doAnswer(functionToAnswer(f))
-  def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) => R): Stubber =
+  def doAnswer[P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R: ValueClassExtractor](
+      f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) => R): Stubber =
     Mockito.doAnswer(functionToAnswer(f))
 }
 
@@ -325,7 +331,7 @@ private[mockito] trait Rest extends MockitoEnhancer with DoSomething with Verifi
   /**
    * Delegates to <code>Mockito.when()</code>, it's only here to expose the full Mockito API
    */
-  def when[T](methodCall: T): ScalaFirstStubbing[T] = Mockito.when(methodCall)
+  def when[T: ValueClassExtractor](methodCall: T): ScalaFirstStubbing[T] = Mockito.when(methodCall)
 
   /**
    * Delegates to <code>Mockito.ignoreStubs()</code>, it's only here to expose the full Mockito API

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

@@ -1,5 +1,6 @@
 package org
 
+import org.mockito.internal.ValueClassExtractor
 import org.mockito.invocation.InvocationOnMock
 import org.mockito.stubbing.Answer
 
@@ -9,36 +10,30 @@ package object mockito {
   def clazz[T](implicit classTag: ClassTag[T]): Class[T] = classTag.runtimeClass.asInstanceOf[Class[T]]
 
   //noinspection ConvertExpressionToSAM
-  def invocationToAnswer[T](f: InvocationOnMock => T): Answer[T] = new Answer[T] {
-    override def answer(invocation: InvocationOnMock): T = f(invocation)
+  def invocationToAnswer[T](f: InvocationOnMock => T)(implicit $vce: ValueClassExtractor[T]): Answer[Any] = new Answer[Any] {
+    override def answer(invocation: InvocationOnMock): Any = $vce.extract(f(invocation))
   }
 
-  def functionToAnswer[T, P0](f: P0 => T): Answer[T] = invocationToAnswer(i => f(i.getArgument[P0](0)))
+  def functionToAnswer[T: ValueClassExtractor, P0](f: P0 => T): Answer[Any] =
+    invocationToAnswer(i => f(i.getArgument[P0](0)))
 
-  def functionToAnswer[T, P1, P0](f: (P0, P1) => T): Answer[T] =
+  def functionToAnswer[T: ValueClassExtractor, P1, P0](f: (P0, P1) => T): Answer[Any] =
     invocationToAnswer(i => f(i.getArgument[P0](0), i.getArgument[P1](1)))
 
-  def functionToAnswer[T, P2, P1, P0](f: (P0, P1, P2) => T): Answer[T] =
+  def functionToAnswer[T: ValueClassExtractor, P2, P1, P0](f: (P0, P1, P2) => T): Answer[Any] =
     invocationToAnswer(i => f(i.getArgument[P0](0), i.getArgument[P1](1), i.getArgument[P2](2)))
 
-  def functionToAnswer[T, P3, P2, P1, P0](f: (P0, P1, P2, P3) => T): Answer[T] =
+  def functionToAnswer[T: ValueClassExtractor, P3, P2, P1, P0](f: (P0, P1, P2, P3) => T): Answer[Any] =
     invocationToAnswer(i => f(i.getArgument[P0](0), i.getArgument[P1](1), i.getArgument[P2](2), i.getArgument[P3](3)))
 
-  def functionToAnswer[T, P4, P3, P2, P1, P0](f: (P0, P1, P2, P3, P4) => T): Answer[T] =
-    invocationToAnswer(i =>
-      f(i.getArgument[P0](0), i.getArgument[P1](1), i.getArgument[P2](2), i.getArgument[P3](3), i.getArgument[P4](4)))
+  def functionToAnswer[T: ValueClassExtractor, P4, P3, P2, P1, P0](f: (P0, P1, P2, P3, P4) => T): Answer[Any] =
+    invocationToAnswer(i => f(i.getArgument[P0](0), i.getArgument[P1](1), i.getArgument[P2](2), i.getArgument[P3](3), i.getArgument[P4](4)))
 
-  def functionToAnswer[T, P5, P4, P3, P2, P1, P0](f: (P0, P1, P2, P3, P4, P5) => T): Answer[T] =
-    invocationToAnswer(
-      i =>
-        f(i.getArgument[P0](0),
-          i.getArgument[P1](1),
-          i.getArgument[P2](2),
-          i.getArgument[P3](3),
-          i.getArgument[P4](4),
-          i.getArgument[P5](5)))
+  def functionToAnswer[T: ValueClassExtractor, P5, P4, P3, P2, P1, P0](f: (P0, P1, P2, P3, P4, P5) => T): Answer[Any] =
+    invocationToAnswer(i =>
+      f(i.getArgument[P0](0), i.getArgument[P1](1), i.getArgument[P2](2), i.getArgument[P3](3), i.getArgument[P4](4), i.getArgument[P5](5)))
 
-  def functionToAnswer[T, P6, P5, P4, P3, P2, P1, P0](f: (P0, P1, P2, P3, P4, P5, P6) => T): Answer[T] =
+  def functionToAnswer[T: ValueClassExtractor, P6, P5, P4, P3, P2, P1, P0](f: (P0, P1, P2, P3, P4, P5, P6) => T): Answer[Any] =
     invocationToAnswer(
       i =>
         f(i.getArgument[P0](0),
@@ -49,7 +44,7 @@ package object mockito {
           i.getArgument[P5](5),
           i.getArgument[P6](6)))
 
-  def functionToAnswer[T, P7, P6, P5, P4, P3, P2, P1, P0](f: (P0, P1, P2, P3, P4, P5, P6, P7) => T): Answer[T] =
+  def functionToAnswer[T: ValueClassExtractor, P7, P6, P5, P4, P3, P2, P1, P0](f: (P0, P1, P2, P3, P4, P5, P6, P7) => T): Answer[Any] =
     invocationToAnswer(
       i =>
         f(
@@ -63,7 +58,8 @@ package object mockito {
           i.getArgument[P7](7)
       ))
 
-  def functionToAnswer[T, P8, P7, P6, P5, P4, P3, P2, P1, P0](f: (P0, P1, P2, P3, P4, P5, P6, P7, P8) => T): Answer[T] =
+  def functionToAnswer[T: ValueClassExtractor, P8, P7, P6, P5, P4, P3, P2, P1, P0](
+      f: (P0, P1, P2, P3, P4, P5, P6, P7, P8) => T): Answer[Any] =
     invocationToAnswer(
       i =>
         f(
@@ -78,8 +74,8 @@ package object mockito {
           i.getArgument[P8](8)
       ))
 
-  def functionToAnswer[T, P9, P8, P7, P6, P5, P4, P3, P2, P1, P0](
-      f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) => T): Answer[T] =
+  def functionToAnswer[T: ValueClassExtractor, P9, P8, P7, P6, P5, P4, P3, P2, P1, P0](
+      f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) => T): Answer[Any] =
     invocationToAnswer(
       i =>
         f(
@@ -95,8 +91,8 @@ package object mockito {
           i.getArgument[P9](9)
       ))
 
-  def functionToAnswer[T, P10, P9, P8, P7, P6, P5, P4, P3, P2, P1, P0](
-      f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) => T): Answer[T] =
+  def functionToAnswer[T: ValueClassExtractor, P10, P9, P8, P7, P6, P5, P4, P3, P2, P1, P0](
+      f: (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) => T): Answer[Any] =
     invocationToAnswer(
       i =>
         f(

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

@@ -1,16 +1,17 @@
 package org.mockito.stubbing
 
-import org.mockito.{clazz, functionToAnswer, invocationToAnswer}
+import org.mockito.internal.ValueClassExtractor
+import org.mockito.{ clazz, functionToAnswer, invocationToAnswer }
 import org.mockito.invocation.InvocationOnMock
 
 import scala.language.implicitConversions
 import scala.reflect.ClassTag
 
 object ScalaFirstStubbing {
-  implicit def toScalaFirstStubbing[T](v: OngoingStubbing[T]): ScalaFirstStubbing[T] = ScalaFirstStubbing(v)
+  implicit def toScalaFirstStubbing[T: ValueClassExtractor](v: OngoingStubbing[T]): ScalaFirstStubbing[T] = ScalaFirstStubbing(v)
 }
 
-case class ScalaFirstStubbing[T](delegate: OngoingStubbing[T]) {
+case class ScalaFirstStubbing[T](delegate: OngoingStubbing[T])(implicit $vce: ValueClassExtractor[T]) {
 
   /**
    * Sets consecutive return one or more values to be returned when the method is called. E.g:
@@ -29,7 +30,8 @@ case class ScalaFirstStubbing[T](delegate: OngoingStubbing[T]) {
    * @param values next return values
    * @return object that allows stubbing consecutive calls
    */
-  def thenReturn(value: T, values: T*): ScalaOngoingStubbing[T] = delegate thenReturn (value, values: _*)
+  def thenReturn(value: T, values: T*): ScalaOngoingStubbing[T] =
+    delegate.thenReturn($vce.extract(value).asInstanceOf[T], values.map($vce.extract).map(_.asInstanceOf[T]): _*)
 
   /**
    * Sets one or more Throwable objects to be thrown when the method is called. E.g:
@@ -105,7 +107,7 @@ case class ScalaFirstStubbing[T](delegate: OngoingStubbing[T]) {
    *
    * @return object that allows stubbing consecutive calls
    */
-  def thenCallRealMethod(): ScalaOngoingStubbing[T] = delegate thenCallRealMethod ()
+  def thenCallRealMethod(): ScalaOngoingStubbing[T] = delegate.thenCallRealMethod()
 
   def thenAnswer(f: => T): ScalaOngoingStubbing[T] = delegate thenAnswer invocationToAnswer(_ => f)
   def thenAnswer[P0: ClassTag](f: P0 => T): ScalaOngoingStubbing[T] = clazz[P0] match {

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

@@ -1,16 +1,17 @@
 package org.mockito.stubbing
 
 import org.mockito._
+import org.mockito.internal.ValueClassExtractor
 import org.mockito.invocation.InvocationOnMock
 
 import scala.language.implicitConversions
 import scala.reflect.ClassTag
 
 object ScalaOngoingStubbing {
-  implicit def toScalaOngoingStubbing[T](v: OngoingStubbing[T]): ScalaOngoingStubbing[T] = ScalaOngoingStubbing(v)
+  implicit def toScalaOngoingStubbing[T: ValueClassExtractor](v: OngoingStubbing[T]): ScalaOngoingStubbing[T] = ScalaOngoingStubbing(v)
 }
 
-case class ScalaOngoingStubbing[T](delegate: OngoingStubbing[T]) {
+case class ScalaOngoingStubbing[T](delegate: OngoingStubbing[T])(implicit $vce: ValueClassExtractor[T]) {
 
   /**
    * Sets consecutive return values to be returned when the method is called. E.g:
@@ -26,7 +27,8 @@ case class ScalaOngoingStubbing[T](delegate: OngoingStubbing[T]) {
    * @param values next return values
    * @return object that allows stubbing consecutive calls
    */
-  def andThen(value: T, values: T*): ScalaOngoingStubbing[T] = delegate thenReturn (value, values: _*)
+  def andThen(value: T, values: T*): ScalaOngoingStubbing[T] =
+    delegate.thenReturn($vce.extract(value).asInstanceOf[T], values.map($vce.extract).map(_.asInstanceOf[T]): _*)
 
   /**
    * Sets Throwable objects to be thrown when the method is called. E.g:

core/src/main/scala/org/mockito/ArgumentMatchersSugar.scala renamed to core/src/main/scala-2.11/org/mockito/ArgumentMatchersSugar.scala

@@ -25,6 +25,7 @@ import org.mockito.matchers._
 trait ArgumentMatchersSugar
     extends AnyMatchers
     with EqMatchers
+    with EqMatchers_211
     with ThatMatchers
     with StringThatMatchers
     with NullMatchers

core/src/main/scala-2.11/org/mockito/matchers/EqMatchers_211.scala

@@ -0,0 +1,22 @@
+package org.mockito.matchers
+
+import org.scalactic.Equality
+
+import scala.language.experimental.macros
+
+trait EqMatchers_211 {
+
+  /**
+    * Creates a matcher that delegates on {{org.scalactic.Equality}} so you can always customise how the values are compared
+    * Also works with value classes
+    */
+  def eqTo[T](value: T)(implicit eq: Equality[T]): T = macro MacroMatchers_211.eqToMatcher[T]
+
+  /**
+    * It was intended to be used instead of eqTo when the argument is a value class,
+    * but eqTo now supports value classes so it is not needed anymore
+    */
+  @deprecated("Use 'eqTo' instead", since = "1.0.2")
+  def eqToVal[T](value: T): T = macro MacroMatchers_211.eqToValMatcher[T]
+
+}

core/src/main/scala-2.12/org/mockito/ArgumentMatchersSugar.scala

@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2017 Morgan Stanley.  All rights reserved.
+ *
+ * THIS SOFTWARE IS SUBJECT TO THE TERMS OF THE MIT LICENSE.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * IN ADDITION, THE FOLLOWING DISCLAIMER APPLIES IN CONNECTION WITH THIS SOFTWARE:
+ * THIS SOFTWARE IS LICENSED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE AND ANY WARRANTY OF NON-INFRINGEMENT, ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. THIS SOFTWARE MAY BE REDISTRIBUTED TO OTHERS ONLY BY EFFECTIVELY USING THIS OR ANOTHER EQUIVALENT DISCLAIMER IN ADDITION TO ANY OTHER REQUIRED LICENSE TERMS.
+ */
+
+package org.mockito
+
+import org.mockito.matchers._
+
+/**
+ * Trait that provides some syntax sugar and type mapping.
+ *
+ * It mostly forwards the calls to org.mockito.ArgumentMatchers, but with a few improvements to make it more scala-like
+ * It also renames the "eq" matcher to "eqTo" as in Scala "eq" is a keyword used to do object identity equality
+ *
+ * @author Bruno Bonanno
+ *
+ */
+trait ArgumentMatchersSugar
+    extends AnyMatchers
+    with EqMatchers
+    with EqMatchers_212
+    with ThatMatchers
+    with StringThatMatchers
+    with NullMatchers
+    with FunctionMatchers
+    with NumericMatchers
+    with MacroBasedMatchers
+
+/**
+ * Simple object to allow the usage of the trait without mixing it in
+ *
+ * @author Bruno Bonanno
+ *
+ */
+object ArgumentMatchersSugar extends ArgumentMatchersSugar

core/src/main/scala-2.12/org/mockito/matchers/EqMatchers_212.scala

@@ -0,0 +1,28 @@
+package org.mockito.matchers
+
+import org.mockito.ArgumentMatcher
+import org.mockito.internal.ValueClassExtractor
+import org.scalactic.Equality
+
+trait EqMatchers_212 {
+
+  /**
+    * Creates a matcher that delegates on {{org.scalactic.Equality}} so you can always customise how the values are compared
+    * Also works with value classes
+    */
+  def eqTo[T](value: T)(implicit $eq: Equality[T], $vce: ValueClassExtractor[T]): T = {
+    val extractedValue = $vce.extract(value)
+    ThatMatchers.argThat(new ArgumentMatcher[T] {
+      override def matches(v: T): Boolean = $eq.areEqual(extractedValue.asInstanceOf[T], v)
+      override def toString: String       = s"eqTo($value)"
+    })
+    value
+  }
+
+  /**
+    * It was intended to be used instead of eqTo when the argument is a value class,
+    * but eqTo now supports value classes so it is not needed anymore
+    */
+  @deprecated("Use 'eqTo' instead", since = "1.0.2")
+  def eqToVal[T](value: T)(implicit $eq: Equality[T], $vce: ValueClassExtractor[T]): T = eqTo(value)
+}