zio · adamgfraser · Jan 16, 2024 · Jan 11, 2024 · Jan 11, 2024 · Jan 12, 2024
diff --git a/core/shared/src/main/scala-2.12/zio/internal/MutableSetCompat.scala b/core/shared/src/main/scala-2.12/zio/internal/MutableSetCompat.scala
@@ -4,14 +4,14 @@ import scala.collection.mutable
 
 trait MutableSetCompat[V] extends mutable.Set[V] {
 
-    override def +=(element: V): this.type = {
-        add(element)
-        this
-    }
+  override def +=(element: V): this.type = {
+      add(element)
+      this
+  }
 
-    override def -=(element: V): this.type = {
-        remove(element)
-        this
-    }
+  override def -=(element: V): this.type = {
+      remove(element)
+      this
+  }
 
-}
+}
diff --git a/test-tests/shared/src/test/scala/zio/test/AssertionSpec.scala b/test-tests/shared/src/test/scala/zio/test/AssertionSpec.scala
@@ -101,6 +101,42 @@ object AssertionSpec extends ZIOBaseSpec {
           )
         )
       } @@ TestAspect.scala2Only,
+      test("equalTo must print out shortened value when using simple class") {
+        val probe: SampleUser    = SampleUser("User", 42)
+        val expected: SampleUser = SampleUser("User", 50)
+        assert(probe)(equalTo(expected))
+      } @@ TestAspect.failing[String] {
+        case TestFailure.Assertion(result, _) => {
+          val failures            = FailureCase.fromTrace(result.failures.get, Chunk.empty)
+          val errorString: String = failures(0).errorMessage.lines(0).fragments(0).text
+          errorString == "SampleUser.age : expected '50' got '42'\n"
+        }
+        case _ => false
+      },
+      test("equalTo must print out shortened error value when using nested class") {
+        val probe: Person    = Person("John", 30, Address("New York", "123 Main St"))
+        val expected: Person = Person("John", 30, Address("San Francisco", "456 Oak St"))
+        assert(probe)(equalTo(expected))
+      } @@ TestAspect.failing[String] {
+        case TestFailure.Assertion(result, _) => {
+          val failures            = FailureCase.fromTrace(result.failures.get, Chunk.empty)
+          val errorString: String = failures(0).errorMessage.lines(0).fragments(0).text
+          errorString == "Person.address.city : expected 'San Francisco' got 'New York'\nPerson.address.street : expected '456 Oak St' got '123 Main St'\n"
+        }
+        case _ => false
+      },
+      test("equalTo must print out shortened value when using list inside class") {
+        val probe: Gambler    = Gambler("User", List(100, 200))
+        val expected: Gambler = Gambler("User", List(100, 300, 500))
+        assert(probe)(equalTo(expected))
+      } @@ TestAspect.failing[String] {
+        case TestFailure.Assertion(result, _) => {
+          val failures            = FailureCase.fromTrace(result.failures.get, Chunk.empty)
+          val errorString: String = failures(0).errorMessage.lines(0).fragments(0).text
+          errorString == "Gambler.bets[1] : expected '300' got '200'\nGambler.bets[2] : expected '500' got 'null'\n"
+        }
+        case _ => false
+      },
       test("equalTo should succeed for same CharSequence value") {
         val probe: CharSequence = "test"
         assert(probe)(equalTo(probe))
@@ -621,6 +657,10 @@ object AssertionSpec extends ZIOBaseSpec {
       } @@ failing
     )
 
+  case class Person(name: String, age: Int, address: Address)
+  case class Address(city: String, street: String)
+  case class Gambler(name: String, bets: List[Int])
+
   case class SampleUser(name: String, age: Int)
   val sampleUser: SampleUser = SampleUser("User", 42)
   val sampleException        = new Exception

diff --git a/test/shared/src/main/scala-2.12/zio/test/AssertionVariants.scala b/test/shared/src/main/scala-2.12/zio/test/AssertionVariants.scala
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2019-2024 John A. De Goes and the ZIO Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package zio.test
+
+import zio.stacktracer.TracingImplicits.disableAutoTrace
+import zio.test.Assertion.Arguments.valueArgument
+import zio.test.{ErrorMessage => M}
+
+trait AssertionVariants {
+  private def diffProduct[T](
+    obj1: T,
+    obj2: T,
+    paramNames: List[String] = Nil,
+    rootClassName: Option[String] = None
+  ): String = {
+    val currClassName = rootClassName.getOrElse(obj1.getClass.getSimpleName)
+
+    (obj1, obj2) match {
+      case (seq1: Iterable[Any], seq2: Iterable[Any]) => {
+        val maxSize    = math.max(seq1.size, seq2.size)
+        val paddedSeq1 = seq1.toVector.padTo(maxSize, null)
+        val paddedSeq2 = seq2.toVector.padTo(maxSize, null)
+
+        paddedSeq1
+          .zip(paddedSeq2)
+          .zipWithIndex
+          .flatMap { case ((subObj1, subObj2), index) =>
+            val newParamName = s"[$index]"
+
+            if (subObj1 != subObj2 && !subObj1.isInstanceOf[Product]) {
+              val paramName = s"${paramNames.reverse.mkString("")}[$index]"
+              Some(s"$currClassName$paramName : expected '$subObj2' got '$subObj1'\n")
+            } else {
+              diffProduct(subObj1, subObj2, newParamName :: paramNames, Some(currClassName))
+            }
+          }
+          .mkString
+      }
+      case (obj1: Product, obj2: Product) if obj1.productArity == obj2.productArity =>
+        obj1.productIterator
+          .zip(obj2.productIterator)
+          .zip(obj1.getClass.getDeclaredFields.iterator.map(_.getName))
+          .flatMap { case ((subObj1, subObj2), paramName) =>
+            val newParamName = if (paramName.nonEmpty) s".$paramName" else ""
+            if (subObj1 != subObj2 && !subObj1.isInstanceOf[Product])
+              s"$currClassName${paramNames.reverse.mkString("")}$newParamName : expected '$subObj2' got '$subObj1'\n"
+            else
+              diffProduct(subObj1, subObj2, newParamName :: paramNames, Some(currClassName))
+          }
+          .mkString
+      case _ => ""
+    }
+  }
+
+  def equalTo[A, B](expected: A)(implicit eql: Eql[A, B]): Assertion[B] =
+    Assertion[B](
+      TestArrow
+        .make[B, Boolean] { actual =>
+          val result = (actual, expected) match {
+            case (left: Array[_], right: Array[_])         => left.sameElements[Any](right)
+            case (left: CharSequence, right: CharSequence) => left.toString == right.toString
+            case (left, right)                             => left == right
+          }
+          TestTrace.boolean(result) {
+            if (expected.isInstanceOf[Product]) {
+              M.text(diffProduct(actual, expected))
+            } else {
+              M.pretty(actual) + M.equals + M.pretty(expected)
+            }
+          }
+        }
+        .withCode("equalTo", valueArgument(expected))
+    )
+}
diff --git a/test/shared/src/main/scala-2.13/zio/test/AssertionVariants.scala b/test/shared/src/main/scala-2.13/zio/test/AssertionVariants.scala
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2019-2024 John A. De Goes and the ZIO Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package zio.test
+
+import zio.stacktracer.TracingImplicits.disableAutoTrace
+import zio.test.Assertion.Arguments.valueArgument
+import zio.test.{ErrorMessage => M}
+
+trait AssertionVariants {
+  private def diffProduct[T](
+    obj1: T,
+    obj2: T,
+    paramNames: List[String] = Nil,
+    rootClassName: Option[String] = None
+  ): String = {
+    val currClassName = rootClassName.getOrElse(obj1.getClass.getSimpleName)
+
+    (obj1, obj2) match {
+      case (seq1: Iterable[Any], seq2: Iterable[Any]) => {
+        val maxSize    = math.max(seq1.size, seq2.size)
+        val paddedSeq1 = seq1.toVector.padTo(maxSize, null)
+        val paddedSeq2 = seq2.toVector.padTo(maxSize, null)
+
+        paddedSeq1
+          .zip(paddedSeq2)
+          .zipWithIndex
+          .flatMap { case ((subObj1, subObj2), index) =>
+            val newParamName = s"[$index]"
+            if (subObj1 != subObj2 && !subObj1.isInstanceOf[Product]) {
+              val paramName = s"${paramNames.reverse.mkString("")}[$index]"
+              Some(s"$currClassName$paramName : expected '$subObj2' got '$subObj1'\n")
+            } else {
+              diffProduct(subObj1, subObj2, newParamName :: paramNames, Some(currClassName))
+            }
+          }
+          .mkString
+      }
+      case (obj1: Product, obj2: Product) if obj1.productArity == obj2.productArity =>
+        obj1.productIterator
+          .zip(obj2.productIterator)
+          .zip(obj1.productElementNames)
+          .flatMap { case ((subObj1, subObj2), paramName) =>
+            val newParamName = if (paramName.nonEmpty) s".$paramName" else ""
+            if (subObj1 != subObj2 && !subObj1.isInstanceOf[Product])
+              s"$currClassName${paramNames.reverse.mkString("")}$newParamName : expected '$subObj2' got '$subObj1'\n"
+            else
+              diffProduct(subObj1, subObj2, newParamName :: paramNames, Some(currClassName))
+          }
+          .mkString
+      case _ => ""
+    }
+  }
+
+  def equalTo[A, B](expected: A)(implicit eql: Eql[A, B]): Assertion[B] =
+    Assertion[B](
+      TestArrow
+        .make[B, Boolean] { actual =>
+          val result = (actual, expected) match {
+            case (left: Array[_], right: Array[_])         => left.sameElements[Any](right)
+            case (left: CharSequence, right: CharSequence) => left.toString == right.toString
+            case (left, right)                             => left == right
+          }
+          TestTrace.boolean(result) {
+            if (expected.isInstanceOf[Product]) {
+              M.text(diffProduct(actual, expected))
+            } else {
+              M.pretty(actual) + M.equals + M.pretty(expected)
+            }
+          }
+        }
+        .withCode("equalTo", valueArgument(expected))
+    )
+}
diff --git a/test/shared/src/main/scala-2/zio/test/AssertionVariants.scala b/test/shared/src/main/scala-2/zio/test/AssertionVariants.scala
diff --git a/test/shared/src/main/scala-3/zio/test/AssertionVariants.scala b/test/shared/src/main/scala-3/zio/test/AssertionVariants.scala
@@ -21,6 +21,49 @@ import zio.test.{ErrorMessage => M}
 import zio.test.Assertion.Arguments.valueArgument
 
 trait AssertionVariants {
+  private def diffProduct[T](
+    obj1: T,
+    obj2: T,
+    paramNames: List[String] = Nil,
+    rootClassName: Option[String] = None
+  ): String = {
+    val currClassName = rootClassName.getOrElse(obj1.getClass.getSimpleName)
+
+    (obj1, obj2) match {
+      case (seq1: Iterable[Any], seq2: Iterable[Any]) =>{
+        val maxSize = math.max(seq1.size, seq2.size)
+        val paddedSeq1 = seq1.toVector.padTo(maxSize, null)
+        val paddedSeq2 = seq2.toVector.padTo(maxSize, null)
+
+        paddedSeq1
+          .zip(paddedSeq2)
+          .zipWithIndex
+          .flatMap { case ((subObj1, subObj2), index) =>
+            val newParamName = s"[$index]"
+            if(subObj1 != subObj2 && !subObj1.isInstanceOf[Product]){
+              val paramName = s"${paramNames.reverse.mkString("")}[$index]"
+              Some(s"$currClassName$paramName : expected '$subObj2' got '$subObj1'\n")
+            }else{
+              diffProduct(subObj1, subObj2, newParamName :: paramNames, Some(currClassName))
+            }
+          }
+          .mkString
+        }
+      case (obj1: Product, obj2: Product) if obj1.productArity == obj2.productArity =>
+        obj1.productIterator
+          .zip(obj2.productIterator)
+          .zip(obj1.productElementNames)
+          .flatMap { case ((subObj1, subObj2), paramName) =>
+            val newParamName = if (paramName.nonEmpty) s".$paramName" else ""
+            if (subObj1 != subObj2 && !subObj1.isInstanceOf[Product])
+              s"$currClassName${paramNames.reverse.mkString("")}$newParamName : expected '$subObj2' got '$subObj1'\n"
+            else
+              diffProduct(subObj1, subObj2, newParamName :: paramNames, Some(currClassName))
+          }
+          .mkString
+      case _ => ""
+    }
+  }
 
   /**
    * Makes a new assertion that requires a value equal the specified value.
@@ -35,7 +78,11 @@ trait AssertionVariants {
             case (left, right)                     => left == right
           }
           TestTrace.boolean(result) {
-            M.pretty(actual) + M.equals + M.pretty(expected)
+            if(expected.isInstanceOf[Product]){
+              M.text(diffProduct(actual, expected))
+            }else{
+              M.pretty(actual) + M.equals + M.pretty(expected)
+            }
           }
         }
         .withCode("equalTo", valueArgument(expected))