package scalamock

ScalaMock: Native Scala mocking

ScalaMock supports three different mocking styles:

In all cases, mix the relevant MockFactory trait into your test class. For ScalaTest useMockFactory, and for JUnit3 use MockFactory.

Function mocks

Function mocks are created with mockFunction. The following, for example, creates a mock function taking a single Int argument and returning a String:

val m = mockFunction[Int, String]

Expectations then can be set on a mock function. The following, for example, says that we expect our mock to be called once with the argument 42, and that when called like that it should return the value "Forty two":

m expects (42) returning "Forty two" once

Proxy mocks

Proxy mocks can only be used to mock traits and interfaces. To mock classes, singleton/companion objects etc, please use generated mocks. To use proxy mocks, mix ProxyMockFactory into your test suite. Proxy mocks are created with mock. The following, for example, creates a mock which implements all the Turtle trait (interface):

val m = mock[Turtle]

Expectations can then be set on each of the methods within those traits. For example:

m expects 'setPosition withArgs (10.0, 10.0)
m expects 'forward withArgs (5.0)
m expects 'getPosition returning (15.0, 10.0)

By default, an expectation accepts any arguments and a single call. The following two statements are equivalent:

m expects 'forward withArgs (*) once
m expects 'forward

As a convenience, proxy mocks also support the stubs method. The following two statements are equivalent:

m expects 'forward anyNumberOfTimes
m stubs 'forward

Generated mocks

Generated mocks rely on the ScalaMock compiler plugin. Seefull worked example.

Classes that are going to be mocked need to be declared with the mockannotation. To mock a class together with its companion object, usemockWithCompanion. To mock a singleton object, usemockObject.

As well as MockFactory, your test class also needs to mix in GeneratedMockFactory.

Create a mock object with mock:

val m = mock[Turtle]

m.expects.forward(10.0) twice

Create a mock object (singleton or companion) with mockObject:

val m = mockObject(Turtle)


To mock construtor invocation, use newInstance:

val m = mock[Turtle]



Expectations can be set on the arguments a function or method is called with and how many times it should be called. In addition, mocks can be instructed to return a particular value or throw an exception when that expectation is met.


To specify expected arguments for a functional mock, use expects. To specify expected arguments for a proxy mock, use withArgs or withArguments.

If no expected arguments are given, mocks accept any arguments.

To specify arguments that should simply be tested for equality, provide the expected arguments as a tuple:

m expects ("this", "that")

ScalaMock currently supports two types of generalized matching: wildcards and epsilon matching.


Wildcard values are specified with an * (asterisk). For example:

m expects ("this", *)

will match any of the following:

m("this", 42)
m("this", 1.0)
m("this", null)
Epsilon matching

Epsilon matching is useful when dealing with floating point values. An epsilon match is specified with the ~ (tilde) operator:

m expects (~42.0)

will match:


but will not match:

Repeated parameters

If you're using generated mocks, you need do nothing special to set expectations on methods that take repeated parameters. If you're using proxy mocks you will need to use the ** operator. For example, given:

def takesRepeatedParameter(x: Int, ys: String*)

you can set an expectation with:

m expects 'takesRepeatedParameter withArgs(42, **("red", "green", "blue"))
Predicate matching

More complicated argument matching can be implemented by using where to pass a predicate:

m = mockFunction[Double, Double, Unit]
m expects { where _ < _ }
m = mock[Turtle]
m expects 'setPosition where { (x: Double, y: Double) => x < y }
Return value

Mocks can be instructed to return a specific value with returns or returning:

m1 returns 42
m2 expects ("this", "that") returning "the other"

If no return value is specified, functional mocks return null.asInstanceOf[R] where R is the return type (which equates to 0 for Int, 0.0 for Double etc.).

If no return value is specified, proxy mocks return null. This works correctly for most return types, but not for methods returning primitive types (Int, Double etc.), where returningnull leads to a NullPointerException. So you will need to explicitly specify a return value for such methods. This restriction may be lifted in the future.

You can return a computed value (or throw a computed exception) with onCall, for example:

val mockIncrement = mockFunction[Int, Int]
m expects (*) onCall { x: Int => x + 1 }

Instead of a return value, a mock can be instructed to throw:

m expects ("this", "that") throws new RuntimeException("what's that?")
Call count

By default, mocks expect one or more calls (i.e. only fail if the function or method is never called). An exact number of calls or a range can be set with repeat:

m1 returns 42 repeat 3 to 7
m2 expects (3) repeat 10

There are various aliases for common expectations and styles:

m1 expects ("this", "that") once
m2 returns "foo" noMoreThanTwice
m3 expects (42) repeated 3 times

For a full list, see Expectation.


By default, expectations can be satisfied in any order. For example:

m expects (1)
m expects (2)

A specific sequence can be enforced with inSequence:

inSequence {
  m expects (1)
  m expects (2)
m(2) // throws ExpectationException

Multiple sequences can be specified. As long as the calls within each sequence happen in the correct order, calls within different sequences can be interleaved. For example:

val m1 = mock[Turtle]
val m2 = mock[Turtle]

inSequence {
  m1.expects.setPosition(0.0, 0.0)
inSequence {
  m2.expects.setPosition(1.0, 1.0)
  m2.expects.getPosition returning (2.0, 1.0)

m2.setPosition(1.0, 1.0)
m1.setPosition(0.0, 0.0)
expect((2.0, 1.0)) { m2.getPosition }

To specify that there is no constraint on ordering, use inAnyOrder (there is an implicitinAnyOrder at the top level). Calls to inSequence and inAnyOrder can be arbitrarily nested. For example:

inSequence {
  inAnyOrder {
    inSequence {


If faced with a difficult to debug failing expectation, consider mixing one or both of the VerboseErrors or CallLogging traits into your test suite:

class MyTest extends Suite with MockFactory with VerboseErrors with CallLogging
  1. Public
  2. All
  1. Concrete
  2. Abstract

Type Members

  1. trait CallLogging extends AnyRef

    Trait that can be mixed into a MockFactoryBase to switch on call logging.

  2. trait ClassLoaderStrategy extends AnyRef

  3. class EpsilonMockParameter extends MockParameter[Double]

  4. class Expectation extends Handler

    Represents a single expectation

  5. case class ExpectationException (msg: String) extends RuntimeException with Product

  6. trait GeneratedMockFactoryBase extends AnyRef

  7. class MatchAny extends Equals

  8. class MatchEpsilon extends Equals

  9. class MatchRepeated extends Equals

    Matches repeated (varargs) parameters

  10. trait Mock extends AnyRef

  11. class MockConstructor [R] extends MockFunction

  12. class MockConstructorDummy extends AnyRef

  13. trait MockFactoryBase extends AnyRef

  14. class MockFunction extends AnyRef

  15. class MockFunction0 [R] extends MockFunction with () ⇒ R with NiceToString

  16. class MockFunction1 [T1, R] extends MockFunction with (T1) ⇒ R with NiceToString

  17. class MockFunction10 [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R] extends MockFunction with (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) ⇒ R with NiceToString

  18. class MockFunction2 [T1, T2, R] extends MockFunction with (T1, T2) ⇒ R with NiceToString

  19. class MockFunction3 [T1, T2, T3, R] extends MockFunction with (T1, T2, T3) ⇒ R with NiceToString

  20. class MockFunction4 [T1, T2, T3, T4, R] extends MockFunction with (T1, T2, T3, T4) ⇒ R with NiceToString

  21. class MockFunction5 [T1, T2, T3, T4, T5, R] extends MockFunction with (T1, T2, T3, T4, T5) ⇒ R with NiceToString

  22. class MockFunction6 [T1, T2, T3, T4, T5, T6, R] extends MockFunction with (T1, T2, T3, T4, T5, T6) ⇒ R with NiceToString

  23. class MockFunction7 [T1, T2, T3, T4, T5, T6, T7, R] extends MockFunction with (T1, T2, T3, T4, T5, T6, T7) ⇒ R with NiceToString

  24. class MockFunction8 [T1, T2, T3, T4, T5, T6, T7, T8, R] extends MockFunction with (T1, T2, T3, T4, T5, T6, T7, T8) ⇒ R with NiceToString

  25. class MockFunction9 [T1, T2, T3, T4, T5, T6, T7, T8, T9, R] extends MockFunction with (T1, T2, T3, T4, T5, T6, T7, T8, T9) ⇒ R with NiceToString

  26. class MockMatcher1 [T1] extends FunctionAdapter1[T1, Boolean]

  27. class MockMatcher10 [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] extends FunctionAdapter10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, Boolean]

  28. class MockMatcher2 [T1, T2] extends FunctionAdapter2[T1, T2, Boolean]

  29. class MockMatcher3 [T1, T2, T3] extends FunctionAdapter3[T1, T2, T3, Boolean]

  30. class MockMatcher4 [T1, T2, T3, T4] extends FunctionAdapter4[T1, T2, T3, T4, Boolean]

  31. class MockMatcher5 [T1, T2, T3, T4, T5] extends FunctionAdapter5[T1, T2, T3, T4, T5, Boolean]

  32. class MockMatcher6 [T1, T2, T3, T4, T5, T6] extends FunctionAdapter6[T1, T2, T3, T4, T5, T6, Boolean]

  33. class MockMatcher7 [T1, T2, T3, T4, T5, T6, T7] extends FunctionAdapter7[T1, T2, T3, T4, T5, T6, T7, Boolean]

  34. class MockMatcher8 [T1, T2, T3, T4, T5, T6, T7, T8] extends FunctionAdapter8[T1, T2, T3, T4, T5, T6, T7, T8, Boolean]

  35. class MockMatcher9 [T1, T2, T3, T4, T5, T6, T7, T8, T9] extends FunctionAdapter9[T1, T2, T3, T4, T5, T6, T7, T8, T9, Boolean]

  36. class MockParameter [T] extends AnyRef

  37. class MockingClassLoader extends ClassLoader

    attributes: abstract
  38. class MockingURLClassLoader extends MockingClassLoader

  39. trait NiceToString extends AnyRef

  40. trait ProxyMockFactory extends AnyRef

  41. class TypeSafeExpectation [R] extends Expectation

    attributes: abstract
  42. class TypeSafeExpectation0 [R] extends TypeSafeExpectation[R]

  43. class TypeSafeExpectation1 [T1, R] extends TypeSafeExpectation[R]

  44. class TypeSafeExpectation10 [T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R] extends TypeSafeExpectation[R]

  45. class TypeSafeExpectation2 [T1, T2, R] extends TypeSafeExpectation[R]

  46. class TypeSafeExpectation3 [T1, T2, T3, R] extends TypeSafeExpectation[R]

  47. class TypeSafeExpectation4 [T1, T2, T3, T4, R] extends TypeSafeExpectation[R]

  48. class TypeSafeExpectation5 [T1, T2, T3, T4, T5, R] extends TypeSafeExpectation[R]

  49. class TypeSafeExpectation6 [T1, T2, T3, T4, T5, T6, R] extends TypeSafeExpectation[R]

  50. class TypeSafeExpectation7 [T1, T2, T3, T4, T5, T6, T7, R] extends TypeSafeExpectation[R]

  51. class TypeSafeExpectation8 [T1, T2, T3, T4, T5, T6, T7, T8, R] extends TypeSafeExpectation[R]

  52. class TypeSafeExpectation9 [T1, T2, T3, T4, T5, T6, T7, T8, T9, R] extends TypeSafeExpectation[R]

  53. class TypeUnsafeExpectation extends Expectation

  54. trait VerboseErrors extends AnyRef

    Trait that can be mixed into a MockFactoryBase to switch on verbose error messages.

Value Members

  1. object ClassLoaderStrategy extends AnyRef

  2. object MatchEpsilon extends AnyRef

  3. object ReflectionUtilities extends AnyRef

  4. package annotation

  5. object classClassLoaderStrategy extends ClassLoaderStrategy

  6. package junit3

  7. package scalatest

  8. object threadContextClassLoaderStrategy extends ClassLoaderStrategy