spyMatchers.test.js.snap

// Jest Snapshot v1, https://goo.gl/fbAQLP

exports[`lastCalledWith includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).not.lastCalledWith(</><green>expected</><dim>)</>

Expected mock function \\"named-mock\\" to not have been last called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`lastCalledWith works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>lastCalledWith<dim>(</><green>...expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`lastCalledWith works when not called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been last called with:
  <green>[\\"foo\\", \\"bar\\"]</>
But it was <red>not called</>."
`;

exports[`lastCalledWith works with Immutable.js objects 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.lastCalledWith(</><green>expected</><dim>)</>

Expected mock function to not have been last called with:
  <green>[Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}, Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}]</>"
`;

exports[`lastCalledWith works with Map 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.lastCalledWith(</><green>expected</><dim>)</>

Expected mock function to not have been last called with:
  <green>[Map {1 => 2, 2 => 1}]</>"
`;

exports[`lastCalledWith works with Map 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been last called with:
  <green>Map {\\"a\\" => \\"b\\", \\"b\\" => \\"a\\"}</>
as argument 1, but it was called with
  <red>Map {1 => 2, 2 => 1}</>.

Difference:

<green>- Expected</>
<red>+ Received</>

<dim>  Map {</>
<green>-   \\"a\\" => \\"b\\",</>
<green>-   \\"b\\" => \\"a\\",</>
<red>+   1 => 2,</>
<red>+   2 => 1,</>
<dim>  }</>"
`;

exports[`lastCalledWith works with Set 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.lastCalledWith(</><green>expected</><dim>)</>

Expected mock function to not have been last called with:
  <green>[Set {1, 2}]</>"
`;

exports[`lastCalledWith works with Set 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been last called with:
  <green>Set {3, 4}</>
as argument 1, but it was called with
  <red>Set {1, 2}</>.

Difference:

<green>- Expected</>
<red>+ Received</>

<dim>  Set {</>
<green>-   3,</>
<green>-   4,</>
<red>+   1,</>
<red>+   2,</>
<dim>  }</>"
`;

exports[`lastCalledWith works with arguments that don't match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been last called with:
  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar1\\"</>."
`;

exports[`lastCalledWith works with arguments that match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.lastCalledWith(</><green>expected</><dim>)</>

Expected mock function to not have been last called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`lastCalledWith works with many arguments 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.lastCalledWith(</><green>expected</><dim>)</>

Expected mock function to not have been last called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`lastCalledWith works with many arguments that don't match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been last called with:
  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar3\\"</>."
`;

exports[`lastCalledWith works with trailing undefined arguments 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been last called with:
  Did not expect argument 2 but it was called with <red>undefined</>."
`;

exports[`lastReturnedWith a call that throws is not considered to have returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>undefined</>
But the last call <red>threw an error</>"
`;

exports[`lastReturnedWith a call that throws undefined is not considered to have returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>undefined</>
But the last call <red>threw an error</>"
`;

exports[`lastReturnedWith includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function \\"named-mock\\" to have last returned:
  <green>\\"foo\\"</>
But it was <red>not called</>"
`;

exports[`lastReturnedWith lastReturnedWith incomplete recursive calls are handled properly 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>0</>
But the last call <red>has not returned yet</>"
`;

exports[`lastReturnedWith lastReturnedWith works with three calls 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>\\"foo3\\"</>
But it last returned exactly:
  <red>\\"foo3\\"</>"
`;

exports[`lastReturnedWith works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>lastReturnedWith<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`lastReturnedWith works when not called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>\\"foo\\"</>
But it was <red>not called</>"
`;

exports[`lastReturnedWith works with Immutable.js objects directly created 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>
But it last returned exactly:
  <red>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>"
`;

exports[`lastReturnedWith works with Immutable.js objects indirectly created 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>
But it last returned exactly:
  <red>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>"
`;

exports[`lastReturnedWith works with Map 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>Map {1 => 2, 2 => 1}</>
But it last returned exactly:
  <red>Map {1 => 2, 2 => 1}</>"
`;

exports[`lastReturnedWith works with Map 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>Map {\\"a\\" => \\"b\\", \\"b\\" => \\"a\\"}</>
But the last call returned:
  <red>Map {1 => 2, 2 => 1}</>"
`;

exports[`lastReturnedWith works with Set 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>Set {1, 2}</>
But it last returned exactly:
  <red>Set {1, 2}</>"
`;

exports[`lastReturnedWith works with Set 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>Set {3, 4}</>
But the last call returned:
  <red>Set {1, 2}</>"
`;

exports[`lastReturnedWith works with argument that does match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>\\"foo\\"</>
But it last returned exactly:
  <red>\\"foo\\"</>"
`;

exports[`lastReturnedWith works with argument that does not match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>\\"bar\\"</>
But the last call returned:
  <red>\\"foo\\"</>"
`;

exports[`lastReturnedWith works with undefined 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.lastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>undefined</>
But it last returned exactly:
  <red>undefined</>"
`;

exports[`nthCalledWith includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).not.nthCalledWith(</><green>expected</><dim>)</>

Expected mock function \\"named-mock\\" first call to not have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`nthCalledWith negative throw matcher error for n that is not integer 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>nthCalledWith<dim>(</><green>n</><dim>, </><green>...expected</><dim>)</>

<bold>Matcher error</>: <green>n</> must be a positive integer

n has type:  number
n has value: <green>Infinity</>"
`;

exports[`nthCalledWith positive throw matcher error for n that is not integer 1`] = `
"<dim>expect(</><red>received</><dim>).</>nthCalledWith<dim>(</><green>n</><dim>, </><green>...expected</><dim>)</>

<bold>Matcher error</>: <green>n</> must be a positive integer

n has type:  number
n has value: <green>0.1</>"
`;

exports[`nthCalledWith positive throw matcher error for n that is not positive integer 1`] = `
"<dim>expect(</><red>received</><dim>).</>nthCalledWith<dim>(</><green>n</><dim>, </><green>...expected</><dim>)</>

<bold>Matcher error</>: <green>n</> must be a positive integer

n has type:  number
n has value: <green>0</>"
`;

exports[`nthCalledWith should replace 1st, 2nd, 3rd with first, second, third 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to have been called with:
  <green>\\"foo\\"</>
as argument 1, but it was called with
  <red>\\"foo1\\"</>."
`;

exports[`nthCalledWith should replace 1st, 2nd, 3rd with first, second, third 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to not have been called with:
  <green>[\\"foo1\\", \\"bar\\"]</>"
`;

exports[`nthCalledWith works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>nthCalledWith<dim>(</><green>n</><dim>, </><green>...expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`nthCalledWith works when not called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>
But it was <red>not called</>."
`;

exports[`nthCalledWith works with Immutable.js objects 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to not have been called with:
  <green>[Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}, Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}]</>"
`;

exports[`nthCalledWith works with Map 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to not have been called with:
  <green>[Map {1 => 2, 2 => 1}]</>"
`;

exports[`nthCalledWith works with Map 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to have been called with:
  <green>Map {\\"a\\" => \\"b\\", \\"b\\" => \\"a\\"}</>
as argument 1, but it was called with
  <red>Map {1 => 2, 2 => 1}</>.

Difference:

<green>- Expected</>
<red>+ Received</>

<dim>  Map {</>
<green>-   \\"a\\" => \\"b\\",</>
<green>-   \\"b\\" => \\"a\\",</>
<red>+   1 => 2,</>
<red>+   2 => 1,</>
<dim>  }</>"
`;

exports[`nthCalledWith works with Set 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to not have been called with:
  <green>[Set {1, 2}]</>"
`;

exports[`nthCalledWith works with Set 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to have been called with:
  <green>Set {3, 4}</>
as argument 1, but it was called with
  <red>Set {1, 2}</>.

Difference:

<green>- Expected</>
<red>+ Received</>

<dim>  Set {</>
<green>-   3,</>
<green>-   4,</>
<red>+   1,</>
<red>+   2,</>
<dim>  }</>"
`;

exports[`nthCalledWith works with arguments that don't match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to have been called with:
  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar1\\"</>."
`;

exports[`nthCalledWith works with arguments that match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to not have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`nthCalledWith works with three calls 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to not have been called with:
  <green>[\\"foo1\\", \\"bar\\"]</>"
`;

exports[`nthCalledWith works with trailing undefined arguments 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to have been called with:
  Did not expect argument 2 but it was called with <red>undefined</>."
`;

exports[`nthReturnedWith a call that throws is not considered to have returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>undefined</>
But the first call <red>threw an error</>"
`;

exports[`nthReturnedWith a call that throws undefined is not considered to have returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>undefined</>
But the first call <red>threw an error</>"
`;

exports[`nthReturnedWith includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function \\"named-mock\\" first call to have returned with:
  <green>\\"foo\\"</>
But it was <red>not called</>"
`;

exports[`nthReturnedWith nthReturnedWith incomplete recursive calls are handled properly 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>6</>
But the first call <red>has not returned yet</>"
`;

exports[`nthReturnedWith nthReturnedWith incomplete recursive calls are handled properly 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function second call to have returned with:
  <green>3</>
But the second call <red>has not returned yet</>"
`;

exports[`nthReturnedWith nthReturnedWith incomplete recursive calls are handled properly 3`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function third call to not have returned with:
  <green>1</>
But the third call returned exactly:
  <red>1</>"
`;

exports[`nthReturnedWith nthReturnedWith incomplete recursive calls are handled properly 4`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function 4th call to not have returned with:
  <green>0</>
But the 4th call returned exactly:
  <red>0</>"
`;

exports[`nthReturnedWith nthReturnedWith negative throw matcher error for n that is not number 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>nthReturnedWith<dim>(</><green>n</><dim>, </><green>expected</><dim>)</>

<bold>Matcher error</>: <green>n</> must be a positive integer

n has value: <green>undefined</>"
`;

exports[`nthReturnedWith nthReturnedWith positive throw matcher error for n that is not integer 1`] = `
"<dim>expect(</><red>received</><dim>).</>nthReturnedWith<dim>(</><green>n</><dim>, </><green>expected</><dim>)</>

<bold>Matcher error</>: <green>n</> must be a positive integer

n has type:  number
n has value: <green>0.1</>"
`;

exports[`nthReturnedWith nthReturnedWith positive throw matcher error for n that is not positive integer 1`] = `
"<dim>expect(</><red>received</><dim>).</>nthReturnedWith<dim>(</><green>n</><dim>, </><green>expected</><dim>)</>

<bold>Matcher error</>: <green>n</> must be a positive integer

n has type:  number
n has value: <green>0</>"
`;

exports[`nthReturnedWith nthReturnedWith should reject nth value greater than number of calls 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function 4th call to have returned with:
  <green>\\"foo\\"</>
But it was only called <red>3</> times"
`;

exports[`nthReturnedWith nthReturnedWith should replace 1st, 2nd, 3rd with first, second, third 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>\\"bar1\\"</>
But the first call returned with:
  <red>\\"foo1\\"</>"
`;

exports[`nthReturnedWith nthReturnedWith should replace 1st, 2nd, 3rd with first, second, third 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>\\"foo1\\"</>
But the first call returned exactly:
  <red>\\"foo1\\"</>"
`;

exports[`nthReturnedWith nthReturnedWith works with three calls 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>\\"foo1\\"</>
But the first call returned exactly:
  <red>\\"foo1\\"</>"
`;

exports[`nthReturnedWith works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>nthReturnedWith<dim>(</><green>n</><dim>, </><green>expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`nthReturnedWith works when not called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>\\"foo\\"</>
But it was <red>not called</>"
`;

exports[`nthReturnedWith works with Immutable.js objects directly created 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>
But the first call returned exactly:
  <red>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>"
`;

exports[`nthReturnedWith works with Immutable.js objects indirectly created 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>
But the first call returned exactly:
  <red>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>"
`;

exports[`nthReturnedWith works with Map 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>Map {1 => 2, 2 => 1}</>
But the first call returned exactly:
  <red>Map {1 => 2, 2 => 1}</>"
`;

exports[`nthReturnedWith works with Map 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>Map {\\"a\\" => \\"b\\", \\"b\\" => \\"a\\"}</>
But the first call returned with:
  <red>Map {1 => 2, 2 => 1}</>"
`;

exports[`nthReturnedWith works with Set 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>Set {1, 2}</>
But the first call returned exactly:
  <red>Set {1, 2}</>"
`;

exports[`nthReturnedWith works with Set 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>Set {3, 4}</>
But the first call returned with:
  <red>Set {1, 2}</>"
`;

exports[`nthReturnedWith works with argument that does match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>\\"foo\\"</>
But the first call returned exactly:
  <red>\\"foo\\"</>"
`;

exports[`nthReturnedWith works with argument that does not match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>\\"bar\\"</>
But the first call returned with:
  <red>\\"foo\\"</>"
`;

exports[`nthReturnedWith works with undefined 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.nthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>undefined</>
But the first call returned exactly:
  <red>undefined</>"
`;

exports[`toBeCalled .not fails with any argument passed 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toBeCalled<dim>()</>

<bold>Matcher error</>: this matcher must not have an expected argument

Expected has type:  number
Expected has value: <green>555</>"
`;

exports[`toBeCalled .not passes when called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toBeCalled<dim>()</>

Expected number of calls: >= <green>1</>
Received number of calls:    <red>0</>"
`;

exports[`toBeCalled fails with any argument passed 1`] = `
"<dim>expect(</><red>received</><dim>).</>toBeCalled<dim>()</>

<bold>Matcher error</>: this matcher must not have an expected argument

Expected has type:  number
Expected has value: <green>555</>"
`;

exports[`toBeCalled includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).</>not<dim>.</>toBeCalled<dim>()</>

Expected number of calls: <green>0</>
Received number of calls: <red>1</>

1: called with no arguments"
`;

exports[`toBeCalled passes when called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toBeCalled<dim>()</>

Expected number of calls: <green>0</>
Received number of calls: <red>1</>

1: <red>\\"arg0\\"</>, <red>\\"arg1\\"</>, <red>\\"arg2\\"</>"
`;

exports[`toBeCalled works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>toBeCalled<dim>()</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toBeCalledTimes .not only accepts a number argument 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  object
Expected has value: <green>{}</>"
`;

exports[`toBeCalledTimes .not only accepts a number argument 2`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  array
Expected has value: <green>[]</>"
`;

exports[`toBeCalledTimes .not only accepts a number argument 3`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  boolean
Expected has value: <green>true</>"
`;

exports[`toBeCalledTimes .not only accepts a number argument 4`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  string
Expected has value: <green>\\"a\\"</>"
`;

exports[`toBeCalledTimes .not only accepts a number argument 5`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  map
Expected has value: <green>Map {}</>"
`;

exports[`toBeCalledTimes .not only accepts a number argument 6`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  function
Expected has value: <green>[Function anonymous]</>"
`;

exports[`toBeCalledTimes .not passes if function called less than expected times 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

Expected number of calls: <green>2</>
Received number of calls: <red>1</>"
`;

exports[`toBeCalledTimes .not passes if function called more than expected times 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

Expected number of calls: <green>2</>
Received number of calls: <red>3</>"
`;

exports[`toBeCalledTimes .not works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toBeCalledTimes includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

Expected number of calls: <green>2</>
Received number of calls: <red>1</>"
`;

exports[`toBeCalledTimes only accepts a number argument 1`] = `
"<dim>expect(</><red>received</><dim>).</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  object
Expected has value: <green>{}</>"
`;

exports[`toBeCalledTimes only accepts a number argument 2`] = `
"<dim>expect(</><red>received</><dim>).</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  array
Expected has value: <green>[]</>"
`;

exports[`toBeCalledTimes only accepts a number argument 3`] = `
"<dim>expect(</><red>received</><dim>).</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  boolean
Expected has value: <green>true</>"
`;

exports[`toBeCalledTimes only accepts a number argument 4`] = `
"<dim>expect(</><red>received</><dim>).</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  string
Expected has value: <green>\\"a\\"</>"
`;

exports[`toBeCalledTimes only accepts a number argument 5`] = `
"<dim>expect(</><red>received</><dim>).</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  map
Expected has value: <green>Map {}</>"
`;

exports[`toBeCalledTimes only accepts a number argument 6`] = `
"<dim>expect(</><red>received</><dim>).</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  function
Expected has value: <green>[Function anonymous]</>"
`;

exports[`toBeCalledTimes passes if function called equal to expected times 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toBeCalledTimes<dim>(</><green>expected</><dim>)</>

Expected number of calls: not <green>2</>"
`;

exports[`toBeCalledWith includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).not.toBeCalledWith(</><green>expected</><dim>)</>

Expected mock function \\"named-mock\\" not to have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`toBeCalledWith works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>toBeCalledWith<dim>(</><green>...expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toBeCalledWith works when not called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toBeCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>
But it was <red>not called</>."
`;

exports[`toBeCalledWith works with Immutable.js objects 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toBeCalledWith(</><green>expected</><dim>)</>

Expected mock function not to have been called with:
  <green>[Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}, Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}]</>"
`;

exports[`toBeCalledWith works with Map 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toBeCalledWith(</><green>expected</><dim>)</>

Expected mock function not to have been called with:
  <green>[Map {1 => 2, 2 => 1}]</>"
`;

exports[`toBeCalledWith works with Map 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toBeCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been called with:
  <green>Map {\\"a\\" => \\"b\\", \\"b\\" => \\"a\\"}</>
as argument 1, but it was called with
  <red>Map {1 => 2, 2 => 1}</>.

Difference:

<green>- Expected</>
<red>+ Received</>

<dim>  Map {</>
<green>-   \\"a\\" => \\"b\\",</>
<green>-   \\"b\\" => \\"a\\",</>
<red>+   1 => 2,</>
<red>+   2 => 1,</>
<dim>  }</>"
`;

exports[`toBeCalledWith works with Set 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toBeCalledWith(</><green>expected</><dim>)</>

Expected mock function not to have been called with:
  <green>[Set {1, 2}]</>"
`;

exports[`toBeCalledWith works with Set 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toBeCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been called with:
  <green>Set {3, 4}</>
as argument 1, but it was called with
  <red>Set {1, 2}</>.

Difference:

<green>- Expected</>
<red>+ Received</>

<dim>  Set {</>
<green>-   3,</>
<green>-   4,</>
<red>+   1,</>
<red>+   2,</>
<dim>  }</>"
`;

exports[`toBeCalledWith works with arguments that don't match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toBeCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been called with:
  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar1\\"</>."
`;

exports[`toBeCalledWith works with arguments that match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toBeCalledWith(</><green>expected</><dim>)</>

Expected mock function not to have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`toBeCalledWith works with many arguments 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toBeCalledWith(</><green>expected</><dim>)</>

Expected mock function not to have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`toBeCalledWith works with many arguments that don't match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toBeCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been called with:
  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar3\\"</>.

  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar2\\"</>.

  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar1\\"</>."
`;

exports[`toBeCalledWith works with trailing undefined arguments 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toBeCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been called with:
  Did not expect argument 2 but it was called with <red>undefined</>."
`;

exports[`toHaveBeenCalled .not fails with any argument passed 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveBeenCalled<dim>()</>

<bold>Matcher error</>: this matcher must not have an expected argument

Expected has type:  number
Expected has value: <green>555</>"
`;

exports[`toHaveBeenCalled .not passes when called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toHaveBeenCalled<dim>()</>

Expected number of calls: >= <green>1</>
Received number of calls:    <red>0</>"
`;

exports[`toHaveBeenCalled fails with any argument passed 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenCalled<dim>()</>

<bold>Matcher error</>: this matcher must not have an expected argument

Expected has type:  number
Expected has value: <green>555</>"
`;

exports[`toHaveBeenCalled includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).</>not<dim>.</>toHaveBeenCalled<dim>()</>

Expected number of calls: <green>0</>
Received number of calls: <red>1</>

1: called with no arguments"
`;

exports[`toHaveBeenCalled passes when called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toHaveBeenCalled<dim>()</>

Expected number of calls: <green>0</>
Received number of calls: <red>1</>

1: <red>\\"arg0\\"</>, <red>\\"arg1\\"</>, <red>\\"arg2\\"</>"
`;

exports[`toHaveBeenCalled works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenCalled<dim>()</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toHaveBeenCalledTimes .not only accepts a number argument 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  object
Expected has value: <green>{}</>"
`;

exports[`toHaveBeenCalledTimes .not only accepts a number argument 2`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  array
Expected has value: <green>[]</>"
`;

exports[`toHaveBeenCalledTimes .not only accepts a number argument 3`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  boolean
Expected has value: <green>true</>"
`;

exports[`toHaveBeenCalledTimes .not only accepts a number argument 4`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  string
Expected has value: <green>\\"a\\"</>"
`;

exports[`toHaveBeenCalledTimes .not only accepts a number argument 5`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  map
Expected has value: <green>Map {}</>"
`;

exports[`toHaveBeenCalledTimes .not only accepts a number argument 6`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  function
Expected has value: <green>[Function anonymous]</>"
`;

exports[`toHaveBeenCalledTimes .not passes if function called less than expected times 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

Expected number of calls: <green>2</>
Received number of calls: <red>1</>"
`;

exports[`toHaveBeenCalledTimes .not passes if function called more than expected times 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

Expected number of calls: <green>2</>
Received number of calls: <red>3</>"
`;

exports[`toHaveBeenCalledTimes .not works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toHaveBeenCalledTimes includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

Expected number of calls: <green>2</>
Received number of calls: <red>1</>"
`;

exports[`toHaveBeenCalledTimes only accepts a number argument 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  object
Expected has value: <green>{}</>"
`;

exports[`toHaveBeenCalledTimes only accepts a number argument 2`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  array
Expected has value: <green>[]</>"
`;

exports[`toHaveBeenCalledTimes only accepts a number argument 3`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  boolean
Expected has value: <green>true</>"
`;

exports[`toHaveBeenCalledTimes only accepts a number argument 4`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  string
Expected has value: <green>\\"a\\"</>"
`;

exports[`toHaveBeenCalledTimes only accepts a number argument 5`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  map
Expected has value: <green>Map {}</>"
`;

exports[`toHaveBeenCalledTimes only accepts a number argument 6`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  function
Expected has value: <green>[Function anonymous]</>"
`;

exports[`toHaveBeenCalledTimes passes if function called equal to expected times 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toHaveBeenCalledTimes<dim>(</><green>expected</><dim>)</>

Expected number of calls: not <green>2</>"
`;

exports[`toHaveBeenCalledWith includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).not.toHaveBeenCalledWith(</><green>expected</><dim>)</>

Expected mock function \\"named-mock\\" not to have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`toHaveBeenCalledWith works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenCalledWith<dim>(</><green>...expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toHaveBeenCalledWith works when not called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>
But it was <red>not called</>."
`;

exports[`toHaveBeenCalledWith works with Immutable.js objects 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenCalledWith(</><green>expected</><dim>)</>

Expected mock function not to have been called with:
  <green>[Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}, Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}]</>"
`;

exports[`toHaveBeenCalledWith works with Map 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenCalledWith(</><green>expected</><dim>)</>

Expected mock function not to have been called with:
  <green>[Map {1 => 2, 2 => 1}]</>"
`;

exports[`toHaveBeenCalledWith works with Map 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been called with:
  <green>Map {\\"a\\" => \\"b\\", \\"b\\" => \\"a\\"}</>
as argument 1, but it was called with
  <red>Map {1 => 2, 2 => 1}</>.

Difference:

<green>- Expected</>
<red>+ Received</>

<dim>  Map {</>
<green>-   \\"a\\" => \\"b\\",</>
<green>-   \\"b\\" => \\"a\\",</>
<red>+   1 => 2,</>
<red>+   2 => 1,</>
<dim>  }</>"
`;

exports[`toHaveBeenCalledWith works with Set 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenCalledWith(</><green>expected</><dim>)</>

Expected mock function not to have been called with:
  <green>[Set {1, 2}]</>"
`;

exports[`toHaveBeenCalledWith works with Set 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been called with:
  <green>Set {3, 4}</>
as argument 1, but it was called with
  <red>Set {1, 2}</>.

Difference:

<green>- Expected</>
<red>+ Received</>

<dim>  Set {</>
<green>-   3,</>
<green>-   4,</>
<red>+   1,</>
<red>+   2,</>
<dim>  }</>"
`;

exports[`toHaveBeenCalledWith works with arguments that don't match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been called with:
  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar1\\"</>."
`;

exports[`toHaveBeenCalledWith works with arguments that match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenCalledWith(</><green>expected</><dim>)</>

Expected mock function not to have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`toHaveBeenCalledWith works with many arguments 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenCalledWith(</><green>expected</><dim>)</>

Expected mock function not to have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`toHaveBeenCalledWith works with many arguments that don't match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been called with:
  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar3\\"</>.

  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar2\\"</>.

  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar1\\"</>."
`;

exports[`toHaveBeenCalledWith works with trailing undefined arguments 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been called with:
  Did not expect argument 2 but it was called with <red>undefined</>."
`;

exports[`toHaveBeenLastCalledWith includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).not.toHaveBeenLastCalledWith(</><green>expected</><dim>)</>

Expected mock function \\"named-mock\\" to not have been last called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`toHaveBeenLastCalledWith works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenLastCalledWith<dim>(</><green>...expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toHaveBeenLastCalledWith works when not called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenLastCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been last called with:
  <green>[\\"foo\\", \\"bar\\"]</>
But it was <red>not called</>."
`;

exports[`toHaveBeenLastCalledWith works with Immutable.js objects 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenLastCalledWith(</><green>expected</><dim>)</>

Expected mock function to not have been last called with:
  <green>[Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}, Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}]</>"
`;

exports[`toHaveBeenLastCalledWith works with Map 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenLastCalledWith(</><green>expected</><dim>)</>

Expected mock function to not have been last called with:
  <green>[Map {1 => 2, 2 => 1}]</>"
`;

exports[`toHaveBeenLastCalledWith works with Map 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenLastCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been last called with:
  <green>Map {\\"a\\" => \\"b\\", \\"b\\" => \\"a\\"}</>
as argument 1, but it was called with
  <red>Map {1 => 2, 2 => 1}</>.

Difference:

<green>- Expected</>
<red>+ Received</>

<dim>  Map {</>
<green>-   \\"a\\" => \\"b\\",</>
<green>-   \\"b\\" => \\"a\\",</>
<red>+   1 => 2,</>
<red>+   2 => 1,</>
<dim>  }</>"
`;

exports[`toHaveBeenLastCalledWith works with Set 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenLastCalledWith(</><green>expected</><dim>)</>

Expected mock function to not have been last called with:
  <green>[Set {1, 2}]</>"
`;

exports[`toHaveBeenLastCalledWith works with Set 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenLastCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been last called with:
  <green>Set {3, 4}</>
as argument 1, but it was called with
  <red>Set {1, 2}</>.

Difference:

<green>- Expected</>
<red>+ Received</>

<dim>  Set {</>
<green>-   3,</>
<green>-   4,</>
<red>+   1,</>
<red>+   2,</>
<dim>  }</>"
`;

exports[`toHaveBeenLastCalledWith works with arguments that don't match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenLastCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been last called with:
  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar1\\"</>."
`;

exports[`toHaveBeenLastCalledWith works with arguments that match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenLastCalledWith(</><green>expected</><dim>)</>

Expected mock function to not have been last called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`toHaveBeenLastCalledWith works with many arguments 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenLastCalledWith(</><green>expected</><dim>)</>

Expected mock function to not have been last called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`toHaveBeenLastCalledWith works with many arguments that don't match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenLastCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been last called with:
  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar3\\"</>."
`;

exports[`toHaveBeenLastCalledWith works with trailing undefined arguments 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenLastCalledWith(</><green>expected</><dim>)</>

Expected mock function to have been last called with:
  Did not expect argument 2 but it was called with <red>undefined</>."
`;

exports[`toHaveBeenNthCalledWith includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).not.toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function \\"named-mock\\" first call to not have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`toHaveBeenNthCalledWith negative throw matcher error for n that is not integer 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveBeenNthCalledWith<dim>(</><green>n</><dim>, </><green>...expected</><dim>)</>

<bold>Matcher error</>: <green>n</> must be a positive integer

n has type:  number
n has value: <green>Infinity</>"
`;

exports[`toHaveBeenNthCalledWith positive throw matcher error for n that is not integer 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenNthCalledWith<dim>(</><green>n</><dim>, </><green>...expected</><dim>)</>

<bold>Matcher error</>: <green>n</> must be a positive integer

n has type:  number
n has value: <green>0.1</>"
`;

exports[`toHaveBeenNthCalledWith positive throw matcher error for n that is not positive integer 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenNthCalledWith<dim>(</><green>n</><dim>, </><green>...expected</><dim>)</>

<bold>Matcher error</>: <green>n</> must be a positive integer

n has type:  number
n has value: <green>0</>"
`;

exports[`toHaveBeenNthCalledWith should replace 1st, 2nd, 3rd with first, second, third 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to have been called with:
  <green>\\"foo\\"</>
as argument 1, but it was called with
  <red>\\"foo1\\"</>."
`;

exports[`toHaveBeenNthCalledWith should replace 1st, 2nd, 3rd with first, second, third 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to not have been called with:
  <green>[\\"foo1\\", \\"bar\\"]</>"
`;

exports[`toHaveBeenNthCalledWith works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveBeenNthCalledWith<dim>(</><green>n</><dim>, </><green>...expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toHaveBeenNthCalledWith works when not called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>
But it was <red>not called</>."
`;

exports[`toHaveBeenNthCalledWith works with Immutable.js objects 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to not have been called with:
  <green>[Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}, Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}]</>"
`;

exports[`toHaveBeenNthCalledWith works with Map 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to not have been called with:
  <green>[Map {1 => 2, 2 => 1}]</>"
`;

exports[`toHaveBeenNthCalledWith works with Map 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to have been called with:
  <green>Map {\\"a\\" => \\"b\\", \\"b\\" => \\"a\\"}</>
as argument 1, but it was called with
  <red>Map {1 => 2, 2 => 1}</>.

Difference:

<green>- Expected</>
<red>+ Received</>

<dim>  Map {</>
<green>-   \\"a\\" => \\"b\\",</>
<green>-   \\"b\\" => \\"a\\",</>
<red>+   1 => 2,</>
<red>+   2 => 1,</>
<dim>  }</>"
`;

exports[`toHaveBeenNthCalledWith works with Set 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to not have been called with:
  <green>[Set {1, 2}]</>"
`;

exports[`toHaveBeenNthCalledWith works with Set 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to have been called with:
  <green>Set {3, 4}</>
as argument 1, but it was called with
  <red>Set {1, 2}</>.

Difference:

<green>- Expected</>
<red>+ Received</>

<dim>  Set {</>
<green>-   3,</>
<green>-   4,</>
<red>+   1,</>
<red>+   2,</>
<dim>  }</>"
`;

exports[`toHaveBeenNthCalledWith works with arguments that don't match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to have been called with:
  <green>\\"bar\\"</>
as argument 2, but it was called with
  <red>\\"bar1\\"</>."
`;

exports[`toHaveBeenNthCalledWith works with arguments that match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to not have been called with:
  <green>[\\"foo\\", \\"bar\\"]</>"
`;

exports[`toHaveBeenNthCalledWith works with three calls 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to not have been called with:
  <green>[\\"foo1\\", \\"bar\\"]</>"
`;

exports[`toHaveBeenNthCalledWith works with trailing undefined arguments 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveBeenNthCalledWith(</><green>expected</><dim>)</>

Expected mock function first call to have been called with:
  Did not expect argument 2 but it was called with <red>undefined</>."
`;

exports[`toHaveLastReturnedWith a call that throws is not considered to have returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>undefined</>
But the last call <red>threw an error</>"
`;

exports[`toHaveLastReturnedWith a call that throws undefined is not considered to have returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>undefined</>
But the last call <red>threw an error</>"
`;

exports[`toHaveLastReturnedWith includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function \\"named-mock\\" to have last returned:
  <green>\\"foo\\"</>
But it was <red>not called</>"
`;

exports[`toHaveLastReturnedWith lastReturnedWith incomplete recursive calls are handled properly 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>0</>
But the last call <red>has not returned yet</>"
`;

exports[`toHaveLastReturnedWith lastReturnedWith works with three calls 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>\\"foo3\\"</>
But it last returned exactly:
  <red>\\"foo3\\"</>"
`;

exports[`toHaveLastReturnedWith works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveLastReturnedWith<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toHaveLastReturnedWith works when not called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>\\"foo\\"</>
But it was <red>not called</>"
`;

exports[`toHaveLastReturnedWith works with Immutable.js objects directly created 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>
But it last returned exactly:
  <red>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>"
`;

exports[`toHaveLastReturnedWith works with Immutable.js objects indirectly created 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>
But it last returned exactly:
  <red>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>"
`;

exports[`toHaveLastReturnedWith works with Map 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>Map {1 => 2, 2 => 1}</>
But it last returned exactly:
  <red>Map {1 => 2, 2 => 1}</>"
`;

exports[`toHaveLastReturnedWith works with Map 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>Map {\\"a\\" => \\"b\\", \\"b\\" => \\"a\\"}</>
But the last call returned:
  <red>Map {1 => 2, 2 => 1}</>"
`;

exports[`toHaveLastReturnedWith works with Set 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>Set {1, 2}</>
But it last returned exactly:
  <red>Set {1, 2}</>"
`;

exports[`toHaveLastReturnedWith works with Set 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>Set {3, 4}</>
But the last call returned:
  <red>Set {1, 2}</>"
`;

exports[`toHaveLastReturnedWith works with argument that does match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>\\"foo\\"</>
But it last returned exactly:
  <red>\\"foo\\"</>"
`;

exports[`toHaveLastReturnedWith works with argument that does not match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have last returned:
  <green>\\"bar\\"</>
But the last call returned:
  <red>\\"foo\\"</>"
`;

exports[`toHaveLastReturnedWith works with undefined 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveLastReturnedWith(</><green>expected</><dim>)</>

Expected mock function to not have last returned:
  <green>undefined</>
But it last returned exactly:
  <red>undefined</>"
`;

exports[`toHaveNthReturnedWith a call that throws is not considered to have returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>undefined</>
But the first call <red>threw an error</>"
`;

exports[`toHaveNthReturnedWith a call that throws undefined is not considered to have returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>undefined</>
But the first call <red>threw an error</>"
`;

exports[`toHaveNthReturnedWith includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function \\"named-mock\\" first call to have returned with:
  <green>\\"foo\\"</>
But it was <red>not called</>"
`;

exports[`toHaveNthReturnedWith nthReturnedWith incomplete recursive calls are handled properly 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>6</>
But the first call <red>has not returned yet</>"
`;

exports[`toHaveNthReturnedWith nthReturnedWith incomplete recursive calls are handled properly 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function second call to have returned with:
  <green>3</>
But the second call <red>has not returned yet</>"
`;

exports[`toHaveNthReturnedWith nthReturnedWith incomplete recursive calls are handled properly 3`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function third call to not have returned with:
  <green>1</>
But the third call returned exactly:
  <red>1</>"
`;

exports[`toHaveNthReturnedWith nthReturnedWith incomplete recursive calls are handled properly 4`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function 4th call to not have returned with:
  <green>0</>
But the 4th call returned exactly:
  <red>0</>"
`;

exports[`toHaveNthReturnedWith nthReturnedWith negative throw matcher error for n that is not number 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveNthReturnedWith<dim>(</><green>n</><dim>, </><green>expected</><dim>)</>

<bold>Matcher error</>: <green>n</> must be a positive integer

n has value: <green>undefined</>"
`;

exports[`toHaveNthReturnedWith nthReturnedWith positive throw matcher error for n that is not integer 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveNthReturnedWith<dim>(</><green>n</><dim>, </><green>expected</><dim>)</>

<bold>Matcher error</>: <green>n</> must be a positive integer

n has type:  number
n has value: <green>0.1</>"
`;

exports[`toHaveNthReturnedWith nthReturnedWith positive throw matcher error for n that is not positive integer 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveNthReturnedWith<dim>(</><green>n</><dim>, </><green>expected</><dim>)</>

<bold>Matcher error</>: <green>n</> must be a positive integer

n has type:  number
n has value: <green>0</>"
`;

exports[`toHaveNthReturnedWith nthReturnedWith should reject nth value greater than number of calls 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function 4th call to have returned with:
  <green>\\"foo\\"</>
But it was only called <red>3</> times"
`;

exports[`toHaveNthReturnedWith nthReturnedWith should replace 1st, 2nd, 3rd with first, second, third 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>\\"bar1\\"</>
But the first call returned with:
  <red>\\"foo1\\"</>"
`;

exports[`toHaveNthReturnedWith nthReturnedWith should replace 1st, 2nd, 3rd with first, second, third 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>\\"foo1\\"</>
But the first call returned exactly:
  <red>\\"foo1\\"</>"
`;

exports[`toHaveNthReturnedWith nthReturnedWith works with three calls 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>\\"foo1\\"</>
But the first call returned exactly:
  <red>\\"foo1\\"</>"
`;

exports[`toHaveNthReturnedWith works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveNthReturnedWith<dim>(</><green>n</><dim>, </><green>expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toHaveNthReturnedWith works when not called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>\\"foo\\"</>
But it was <red>not called</>"
`;

exports[`toHaveNthReturnedWith works with Immutable.js objects directly created 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>
But the first call returned exactly:
  <red>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>"
`;

exports[`toHaveNthReturnedWith works with Immutable.js objects indirectly created 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>
But the first call returned exactly:
  <red>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>"
`;

exports[`toHaveNthReturnedWith works with Map 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>Map {1 => 2, 2 => 1}</>
But the first call returned exactly:
  <red>Map {1 => 2, 2 => 1}</>"
`;

exports[`toHaveNthReturnedWith works with Map 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>Map {\\"a\\" => \\"b\\", \\"b\\" => \\"a\\"}</>
But the first call returned with:
  <red>Map {1 => 2, 2 => 1}</>"
`;

exports[`toHaveNthReturnedWith works with Set 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>Set {1, 2}</>
But the first call returned exactly:
  <red>Set {1, 2}</>"
`;

exports[`toHaveNthReturnedWith works with Set 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>Set {3, 4}</>
But the first call returned with:
  <red>Set {1, 2}</>"
`;

exports[`toHaveNthReturnedWith works with argument that does match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>\\"foo\\"</>
But the first call returned exactly:
  <red>\\"foo\\"</>"
`;

exports[`toHaveNthReturnedWith works with argument that does not match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to have returned with:
  <green>\\"bar\\"</>
But the first call returned with:
  <red>\\"foo\\"</>"
`;

exports[`toHaveNthReturnedWith works with undefined 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveNthReturnedWith(</><green>expected</><dim>)</>

Expected mock function first call to not have returned with:
  <green>undefined</>
But the first call returned exactly:
  <red>undefined</>"
`;

exports[`toHaveReturned .not fails with any argument passed 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveReturned<dim>()</>

<bold>Matcher error</>: this matcher must not have an expected argument

Expected has type:  number
Expected has value: <green>555</>"
`;

exports[`toHaveReturned .not passes when a call throws undefined 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toHaveReturned<dim>()</>

Expected number of returns: >= <green>1</>
Received number of returns:    <red>0</>
Received number of calls:      <red>1</>"
`;

exports[`toHaveReturned .not passes when all calls throw 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toHaveReturned<dim>()</>

Expected number of returns: >= <green>1</>
Received number of returns:    <red>0</>
Received number of calls:      <red>2</>"
`;

exports[`toHaveReturned .not passes when not returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toHaveReturned<dim>()</>

Expected number of returns: >= <green>1</>
Received number of returns:    <red>0</>"
`;

exports[`toHaveReturned .not works only on jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveReturned<dim>()</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toHaveReturned fails with any argument passed 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveReturned<dim>()</>

<bold>Matcher error</>: this matcher must not have an expected argument

Expected has type:  number
Expected has value: <green>555</>"
`;

exports[`toHaveReturned includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).</>not<dim>.</>toHaveReturned<dim>()</>

Expected number of returns: <green>0</>
Received number of returns: <red>1</>

1: <red>42</>"
`;

exports[`toHaveReturned incomplete recursive calls are handled properly 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toHaveReturned<dim>()</>

Expected number of returns: >= <green>1</>
Received number of returns:    <red>0</>
Received number of calls:      <red>4</>"
`;

exports[`toHaveReturned passes when at least one call does not throw 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toHaveReturned<dim>()</>

Expected number of returns: <green>0</>
Received number of returns: <red>2</>

1: <red>42</>
3: <red>42</>

Received number of calls:   <red>3</>"
`;

exports[`toHaveReturned passes when returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toHaveReturned<dim>()</>

Expected number of returns: <green>0</>
Received number of returns: <red>1</>

1: <red>42</>"
`;

exports[`toHaveReturned passes when undefined is returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toHaveReturned<dim>()</>

Expected number of returns: <green>0</>
Received number of returns: <red>1</>

1: <red>undefined</>"
`;

exports[`toHaveReturnedTimes .not only accepts a number argument 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  object
Expected has value: <green>{}</>"
`;

exports[`toHaveReturnedTimes .not only accepts a number argument 2`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  array
Expected has value: <green>[]</>"
`;

exports[`toHaveReturnedTimes .not only accepts a number argument 3`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  boolean
Expected has value: <green>true</>"
`;

exports[`toHaveReturnedTimes .not only accepts a number argument 4`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  string
Expected has value: <green>\\"a\\"</>"
`;

exports[`toHaveReturnedTimes .not only accepts a number argument 5`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  map
Expected has value: <green>Map {}</>"
`;

exports[`toHaveReturnedTimes .not only accepts a number argument 6`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  function
Expected has value: <green>[Function anonymous]</>"
`;

exports[`toHaveReturnedTimes .not passes if function called less than expected times 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: <green>2</>
Received number of returns: <red>1</>"
`;

exports[`toHaveReturnedTimes .not passes if function returned more than expected times 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: <green>2</>
Received number of returns: <red>3</>"
`;

exports[`toHaveReturnedTimes calls that return undefined are counted as returns 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: not <green>2</>"
`;

exports[`toHaveReturnedTimes calls that throw are not counted 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: <green>3</>
Received number of returns: <red>2</>
Received number of calls:   <red>3</>"
`;

exports[`toHaveReturnedTimes calls that throw undefined are not counted 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: not <green>2</>

Received number of calls:       <red>3</>"
`;

exports[`toHaveReturnedTimes includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: <green>1</>
Received number of returns: <red>2</>"
`;

exports[`toHaveReturnedTimes incomplete recursive calls are handled properly 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: not <green>2</>

Received number of calls:       <red>4</>"
`;

exports[`toHaveReturnedTimes only accepts a number argument 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  object
Expected has value: <green>{}</>"
`;

exports[`toHaveReturnedTimes only accepts a number argument 2`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  array
Expected has value: <green>[]</>"
`;

exports[`toHaveReturnedTimes only accepts a number argument 3`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  boolean
Expected has value: <green>true</>"
`;

exports[`toHaveReturnedTimes only accepts a number argument 4`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  string
Expected has value: <green>\\"a\\"</>"
`;

exports[`toHaveReturnedTimes only accepts a number argument 5`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  map
Expected has value: <green>Map {}</>"
`;

exports[`toHaveReturnedTimes only accepts a number argument 6`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  function
Expected has value: <green>[Function anonymous]</>"
`;

exports[`toHaveReturnedTimes passes if function returned equal to expected times 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: not <green>2</>"
`;

exports[`toHaveReturnedTimes works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveReturnedTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toHaveReturnedWith a call that throws is not considered to have returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>undefined</>
But it did <red>not return</>."
`;

exports[`toHaveReturnedWith a call that throws undefined is not considered to have returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>undefined</>
But it did <red>not return</>."
`;

exports[`toHaveReturnedWith includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function \\"named-mock\\" to have returned:
  <green>\\"foo\\"</>
But it did <red>not return</>."
`;

exports[`toHaveReturnedWith returnedWith incomplete recursive calls are handled properly 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>undefined</>
But it did <red>not return</>."
`;

exports[`toHaveReturnedWith returnedWith works with more calls than the limit 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>\\"bar\\"</>
But it returned:
  <red>\\"foo1\\"</>

  <red>\\"foo2\\"</>

  <red>\\"foo3\\"</>

  <red>\\"foo4\\"</>

  <red>\\"foo5\\"</>

  ...and <red>1</> more"
`;

exports[`toHaveReturnedWith works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>toHaveReturnedWith<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toHaveReturnedWith works when not called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>\\"foo\\"</>
But it did <red>not return</>."
`;

exports[`toHaveReturnedWith works with Immutable.js objects directly created 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function not to have returned:
  <green>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>
But it returned exactly:
  <red>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>"
`;

exports[`toHaveReturnedWith works with Immutable.js objects indirectly created 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function not to have returned:
  <green>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>
But it returned exactly:
  <red>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>"
`;

exports[`toHaveReturnedWith works with Map 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function not to have returned:
  <green>Map {1 => 2, 2 => 1}</>
But it returned exactly:
  <red>Map {1 => 2, 2 => 1}</>"
`;

exports[`toHaveReturnedWith works with Map 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>Map {\\"a\\" => \\"b\\", \\"b\\" => \\"a\\"}</>
But it returned:
  <red>Map {1 => 2, 2 => 1}</>"
`;

exports[`toHaveReturnedWith works with Set 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function not to have returned:
  <green>Set {1, 2}</>
But it returned exactly:
  <red>Set {1, 2}</>"
`;

exports[`toHaveReturnedWith works with Set 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>Set {3, 4}</>
But it returned:
  <red>Set {1, 2}</>"
`;

exports[`toHaveReturnedWith works with argument that does match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function not to have returned:
  <green>\\"foo\\"</>
But it returned exactly:
  <red>\\"foo\\"</>"
`;

exports[`toHaveReturnedWith works with argument that does not match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>\\"bar\\"</>
But it returned:
  <red>\\"foo\\"</>"
`;

exports[`toHaveReturnedWith works with undefined 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toHaveReturnedWith(</><green>expected</><dim>)</>

Expected mock function not to have returned:
  <green>undefined</>
But it returned exactly:
  <red>undefined</>"
`;

exports[`toReturn .not fails with any argument passed 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toReturn<dim>()</>

<bold>Matcher error</>: this matcher must not have an expected argument

Expected has type:  number
Expected has value: <green>555</>"
`;

exports[`toReturn .not passes when a call throws undefined 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toReturn<dim>()</>

Expected number of returns: >= <green>1</>
Received number of returns:    <red>0</>
Received number of calls:      <red>1</>"
`;

exports[`toReturn .not passes when all calls throw 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toReturn<dim>()</>

Expected number of returns: >= <green>1</>
Received number of returns:    <red>0</>
Received number of calls:      <red>2</>"
`;

exports[`toReturn .not passes when not returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toReturn<dim>()</>

Expected number of returns: >= <green>1</>
Received number of returns:    <red>0</>"
`;

exports[`toReturn .not works only on jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toReturn<dim>()</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toReturn fails with any argument passed 1`] = `
"<dim>expect(</><red>received</><dim>).</>toReturn<dim>()</>

<bold>Matcher error</>: this matcher must not have an expected argument

Expected has type:  number
Expected has value: <green>555</>"
`;

exports[`toReturn includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).</>not<dim>.</>toReturn<dim>()</>

Expected number of returns: <green>0</>
Received number of returns: <red>1</>

1: <red>42</>"
`;

exports[`toReturn incomplete recursive calls are handled properly 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toReturn<dim>()</>

Expected number of returns: >= <green>1</>
Received number of returns:    <red>0</>
Received number of calls:      <red>4</>"
`;

exports[`toReturn passes when at least one call does not throw 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toReturn<dim>()</>

Expected number of returns: <green>0</>
Received number of returns: <red>2</>

1: <red>42</>
3: <red>42</>

Received number of calls:   <red>3</>"
`;

exports[`toReturn passes when returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toReturn<dim>()</>

Expected number of returns: <green>0</>
Received number of returns: <red>1</>

1: <red>42</>"
`;

exports[`toReturn passes when undefined is returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toReturn<dim>()</>

Expected number of returns: <green>0</>
Received number of returns: <red>1</>

1: <red>undefined</>"
`;

exports[`toReturnTimes .not only accepts a number argument 1`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  object
Expected has value: <green>{}</>"
`;

exports[`toReturnTimes .not only accepts a number argument 2`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  array
Expected has value: <green>[]</>"
`;

exports[`toReturnTimes .not only accepts a number argument 3`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  boolean
Expected has value: <green>true</>"
`;

exports[`toReturnTimes .not only accepts a number argument 4`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  string
Expected has value: <green>\\"a\\"</>"
`;

exports[`toReturnTimes .not only accepts a number argument 5`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  map
Expected has value: <green>Map {}</>"
`;

exports[`toReturnTimes .not only accepts a number argument 6`] = `
"<dim>expect(</><red>received</><dim>).</>not<dim>.</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  function
Expected has value: <green>[Function anonymous]</>"
`;

exports[`toReturnTimes .not passes if function called less than expected times 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toReturnTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: <green>2</>
Received number of returns: <red>1</>"
`;

exports[`toReturnTimes .not passes if function returned more than expected times 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toReturnTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: <green>2</>
Received number of returns: <red>3</>"
`;

exports[`toReturnTimes calls that return undefined are counted as returns 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toReturnTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: not <green>2</>"
`;

exports[`toReturnTimes calls that throw are not counted 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>toReturnTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: <green>3</>
Received number of returns: <red>2</>
Received number of calls:   <red>3</>"
`;

exports[`toReturnTimes calls that throw undefined are not counted 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toReturnTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: not <green>2</>

Received number of calls:       <red>3</>"
`;

exports[`toReturnTimes includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).</>toReturnTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: <green>1</>
Received number of returns: <red>2</>"
`;

exports[`toReturnTimes incomplete recursive calls are handled properly 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toReturnTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: not <green>2</>

Received number of calls:       <red>4</>"
`;

exports[`toReturnTimes only accepts a number argument 1`] = `
"<dim>expect(</><red>received</><dim>).</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  object
Expected has value: <green>{}</>"
`;

exports[`toReturnTimes only accepts a number argument 2`] = `
"<dim>expect(</><red>received</><dim>).</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  array
Expected has value: <green>[]</>"
`;

exports[`toReturnTimes only accepts a number argument 3`] = `
"<dim>expect(</><red>received</><dim>).</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  boolean
Expected has value: <green>true</>"
`;

exports[`toReturnTimes only accepts a number argument 4`] = `
"<dim>expect(</><red>received</><dim>).</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  string
Expected has value: <green>\\"a\\"</>"
`;

exports[`toReturnTimes only accepts a number argument 5`] = `
"<dim>expect(</><red>received</><dim>).</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  map
Expected has value: <green>Map {}</>"
`;

exports[`toReturnTimes only accepts a number argument 6`] = `
"<dim>expect(</><red>received</><dim>).</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <green>expected</> value must be a number

Expected has type:  function
Expected has value: <green>[Function anonymous]</>"
`;

exports[`toReturnTimes passes if function returned equal to expected times 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).</>not<dim>.</>toReturnTimes<dim>(</><green>expected</><dim>)</>

Expected number of returns: not <green>2</>"
`;

exports[`toReturnTimes works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>toReturnTimes<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toReturnWith a call that throws is not considered to have returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toReturnWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>undefined</>
But it did <red>not return</>."
`;

exports[`toReturnWith a call that throws undefined is not considered to have returned 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toReturnWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>undefined</>
But it did <red>not return</>."
`;

exports[`toReturnWith includes the custom mock name in the error message 1`] = `
"<dim>expect(</><red>named-mock</><dim>).toReturnWith(</><green>expected</><dim>)</>

Expected mock function \\"named-mock\\" to have returned:
  <green>\\"foo\\"</>
But it did <red>not return</>."
`;

exports[`toReturnWith returnedWith incomplete recursive calls are handled properly 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toReturnWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>undefined</>
But it did <red>not return</>."
`;

exports[`toReturnWith returnedWith works with more calls than the limit 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toReturnWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>\\"bar\\"</>
But it returned:
  <red>\\"foo1\\"</>

  <red>\\"foo2\\"</>

  <red>\\"foo3\\"</>

  <red>\\"foo4\\"</>

  <red>\\"foo5\\"</>

  ...and <red>1</> more"
`;

exports[`toReturnWith works only on spies or jest.fn 1`] = `
"<dim>expect(</><red>received</><dim>).</>toReturnWith<dim>(</><green>expected</><dim>)</>

<bold>Matcher error</>: <red>received</> value must be a mock or spy function

Received has type:  function
Received has value: <red>[Function fn]</>"
`;

exports[`toReturnWith works when not called 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toReturnWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>\\"foo\\"</>
But it did <red>not return</>."
`;

exports[`toReturnWith works with Immutable.js objects directly created 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toReturnWith(</><green>expected</><dim>)</>

Expected mock function not to have returned:
  <green>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>
But it returned exactly:
  <red>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>"
`;

exports[`toReturnWith works with Immutable.js objects indirectly created 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toReturnWith(</><green>expected</><dim>)</>

Expected mock function not to have returned:
  <green>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>
But it returned exactly:
  <red>Immutable.Map {\\"a\\": {\\"b\\": \\"c\\"}}</>"
`;

exports[`toReturnWith works with Map 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toReturnWith(</><green>expected</><dim>)</>

Expected mock function not to have returned:
  <green>Map {1 => 2, 2 => 1}</>
But it returned exactly:
  <red>Map {1 => 2, 2 => 1}</>"
`;

exports[`toReturnWith works with Map 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toReturnWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>Map {\\"a\\" => \\"b\\", \\"b\\" => \\"a\\"}</>
But it returned:
  <red>Map {1 => 2, 2 => 1}</>"
`;

exports[`toReturnWith works with Set 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toReturnWith(</><green>expected</><dim>)</>

Expected mock function not to have returned:
  <green>Set {1, 2}</>
But it returned exactly:
  <red>Set {1, 2}</>"
`;

exports[`toReturnWith works with Set 2`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toReturnWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>Set {3, 4}</>
But it returned:
  <red>Set {1, 2}</>"
`;

exports[`toReturnWith works with argument that does match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toReturnWith(</><green>expected</><dim>)</>

Expected mock function not to have returned:
  <green>\\"foo\\"</>
But it returned exactly:
  <red>\\"foo\\"</>"
`;

exports[`toReturnWith works with argument that does not match 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).toReturnWith(</><green>expected</><dim>)</>

Expected mock function to have returned:
  <green>\\"bar\\"</>
But it returned:
  <red>\\"foo\\"</>"
`;

exports[`toReturnWith works with undefined 1`] = `
"<dim>expect(</><red>jest.fn()</><dim>).not.toReturnWith(</><green>expected</><dim>)</>

Expected mock function not to have returned:
  <green>undefined</>
But it returned exactly:
  <red>undefined</>"
`;