Match failure with varargs and multiple parameter lists

[githorse]

Mocking with varargs works as expected:

trait FooWithVarArg {
  def bar(bells: String*) 
}

val foo = mock[FooWithVarArg]

foo.bar("cow", "blue")
foo.bar("cow", "blue") was called // true

foo.bar("cow")
foo.bar("cow") was called // true

So does mocking with a second parameter list:

trait FooWithSecondParameterList {
  def bar(bell: String)(cheese: Cheese) 
}

val foo = mock[FooWithSecondParameterList]
val cheese = new Gouda

foo.bar("cow")(cheese)

foo.bar("cow")(cheese) was called // true
foo.bar("cow")(*) was called // true

But I can't seem to combine varargs with a second parameter list:

trait FooWithBoth {
  def bar(bells: String*)(cheese: Cheese)
}

val foo = mock[FooWithBoth]
val cheese = new Gouda

foo.bar("cow")(cheese)
foo.bar("cow")(cheese) was called // true
foo.bar("cow")(*) was called // false

Instead, I get a match failure:

Argument(s) are different! Wanted:
foo.bar(
    eqTo(cow),
    <any>
);
-> at ...
Actual invocation has different arguments:
foo.bar(
    WrappedArray(cow),
    Cheese
);

Is there some way to match varargs in the first parameter list while ignoring the second parameter list?

[ultrasecreth]

@githorse thanks for reporting this, the issue is that the eqTo() matcher is not playing well with varargs, is not a quick fix as many things have to be considered, but in the meantime, you can overcome it by not mixing matchers with raw values (the raw values will be wrapped by an eqTo by the macro).
If you need to match them, you can use argThat or argMatching for the time being to create a matcher that does what you want.

I'll publish a proper fix soon

[githorse]

@bbonanno - Thanks for your prompt response! In my use case it's difficult to dispense with matching the raw values in the first parameter, so I'm hoping for a workaround here. I tried the argThat and argMatching but could not make that work:

def matches(expected: String) = new ArgumentMatcher[String] {
  override def matches(actual: String): Boolean = actual == expected
}

foo.bar(argThat(matches("cow")))(*)          was called // false
foo.bar(argMatching { case "cow" => true })) was called // false

Am I using these correctly?

I'm still seeing match failures:

Argument(s) are different! Wanted:
fooWithBoth.bar(
    argMatching(...),
    <any>
);
-> at ... 
Actual invocation has different arguments:
fooWithBoth.bar(
    WrappedArray(cow),
    Gouda@6546371
);
-> a

[githorse]

Sorry, closed in error.

[ultrasecreth]

It's a vararg, so what you want is to match for WrappedArray(cow)

The PR is almost ready anyway, so if it's not urgent you should have the working version later today

[githorse]

Ah, cool. Thanks. Yeah, I guess for the price you're charging I can probably wait a couple more hours :)