Custom Differ Support

[cheeseng]

Added overridable differ to Prettifier trait, and added functions to create prettifier instance with supplied Differ.

[charpov]

How does one use a custom Differ? It looks like the Differ type is not public...

[cheeseng]

@charpov I think you are right, @charpov at the moment perhaps the only way is to have your custom Differ use org.scalactic package.

@bvenners Shall we make Differ public in next 3.2 release?

[charpov]

Actually, this works:

   val prettifier = Prettifier(Prettifier.default, (l,r,p) => PrettyPair("","",None))

It may not be the most convenient (and Differ might as well be a type alias for a function in that case)

[charpov]

I don't know if this is the right place for this discussion (given the "merged" nature of the issue), but I still think the design could be improved.

I can now use a truncated prettifier do deal with large collections:

given defaultPrettifier: Prettifier = Prettifier.truncateAt(SizeLimit(32))

Then, in a test suite that uses large lists and large random trees, I further customize the prettifier:

given Prettifier = o =>
   o.asMatchable match
      case _: Tree[?] | _: Forest[?] => o.toString.short(512)
      case _                         => defaultPrettifier(o)

Now, I noticed that while assertions of the form assertResult(l2)(l1) don't, assert(l1 == l2) generates an "analysis". On large lists, this analysis still produces undesirable strings. It is trying to limit things, but uses a test:

case tp: TruncatingPrettifier => ...

and my prettifier is not a TruncatingPrettifier anymore.

It seems I can turn off this analysis with:

given Prettifier with
   def apply(o: Any): String = o.asMatchable match
      case _: Tree[?] | _: Forest[?] => o.toString.short(512)
      case _                         => defaultPrettifier(o)

   override def apply(left: Any, right: Any): PrettyPair =
      PrettyPair(apply(left), apply(right), None)

but that's a bit radical.

So, my questions:

• Is there a way to turn "analysis" on and off? The fact that assert has it but assertResult doesn't is confusing.
• Would it make sense for the Prettifier type to implement a limit (defaulting to None) and use it in Differ instead of checking that the type is TruncatingPrettifier? I could then specify a limit in my custom prettifier and rely on the existing behavior of the Differ.difference methods.