matchers.test.js.snap

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

exports[`.rejects fails for promise that resolves 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>toBe<d>()</>

Received promise resolved instead of rejected
Resolved to value: <r>4</>
`;

exports[`.rejects fails non-promise value "a" 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise or a function returning a promise

Received has type:  string
Received has value: <r>"a"</>
`;

exports[`.rejects fails non-promise value [1] 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise or a function returning a promise

Received has type:  array
Received has value: <r>[1]</>
`;

exports[`.rejects fails non-promise value [Function anonymous] 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise or a function returning a promise

Received has type:  function
Received has value: <r>[Function anonymous]</>
`;

exports[`.rejects fails non-promise value {"a": 1} 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise or a function returning a promise

Received has type:  object
Received has value: <r>{"a": 1}</>
`;

exports[`.rejects fails non-promise value 4 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>not<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise or a function returning a promise

Received has type:  number
Received has value: <r>4</>
`;

exports[`.rejects fails non-promise value null 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>not<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise or a function returning a promise

Received has value: <r>null</>
`;

exports[`.rejects fails non-promise value true 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>not<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise or a function returning a promise

Received has type:  boolean
Received has value: <r>true</>
`;

exports[`.rejects fails non-promise value undefined 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>not<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise or a function returning a promise

Received has value: <r>undefined</>
`;

exports[`.resolves fails for promise that rejects 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>toBe<d>()</>

Received promise rejected instead of resolved
Rejected to value: <r>4</>
`;

exports[`.resolves fails non-promise value "a" 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has type:  string
Received has value: <r>"a"</>
`;

exports[`.resolves fails non-promise value "a" synchronously 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has type:  string
Received has value: <r>"a"</>
`;

exports[`.resolves fails non-promise value [1] 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has type:  array
Received has value: <r>[1]</>
`;

exports[`.resolves fails non-promise value [1] synchronously 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has type:  array
Received has value: <r>[1]</>
`;

exports[`.resolves fails non-promise value [Function anonymous] 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has type:  function
Received has value: <r>[Function anonymous]</>
`;

exports[`.resolves fails non-promise value [Function anonymous] synchronously 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has type:  function
Received has value: <r>[Function anonymous]</>
`;

exports[`.resolves fails non-promise value {"a": 1} 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has type:  object
Received has value: <r>{"a": 1}</>
`;

exports[`.resolves fails non-promise value {"a": 1} synchronously 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has type:  object
Received has value: <r>{"a": 1}</>
`;

exports[`.resolves fails non-promise value 4 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>not<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has type:  number
Received has value: <r>4</>
`;

exports[`.resolves fails non-promise value 4 synchronously 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>not<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has type:  number
Received has value: <r>4</>
`;

exports[`.resolves fails non-promise value null 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>not<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has value: <r>null</>
`;

exports[`.resolves fails non-promise value null synchronously 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>not<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has value: <r>null</>
`;

exports[`.resolves fails non-promise value true 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>not<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has type:  boolean
Received has value: <r>true</>
`;

exports[`.resolves fails non-promise value true synchronously 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>not<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has type:  boolean
Received has value: <r>true</>
`;

exports[`.resolves fails non-promise value undefined 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>not<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has value: <r>undefined</>
`;

exports[`.resolves fails non-promise value undefined synchronously 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>not<d>.</>toBeDefined<d>()</>

<b>Matcher error</>: <r>received</> value must be a promise

Received has value: <r>undefined</>
`;

exports[`.toBe() does not crash on circular references 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

<g>- Expected  - 1</>
<r>+ Received  + 3</>

<g>- Object {}</>
<r>+ Object {</>
<r>+   "circular": [Circular],</>
<r>+ }</>
`;

exports[`.toBe() fails for '"a"' with '.not' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: not <g>"a"</>
`;

exports[`.toBe() fails for '[]' with '.not' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: not <g>[]</>
`;

exports[`.toBe() fails for '{}' with '.not' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: not <g>{}</>
`;

exports[`.toBe() fails for '1' with '.not' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: not <g>1</>
`;

exports[`.toBe() fails for 'false' with '.not' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: not <g>false</>
`;

exports[`.toBe() fails for 'null' with '.not' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: not <g>null</>
`;

exports[`.toBe() fails for 'undefined' with '.not' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: not <g>undefined</>
`;

exports[`.toBe() fails for: "" and "compare one-line string to empty string" 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: <g>"compare one-line string to empty string"</>
Received: <r>""</>
`;

exports[`.toBe() fails for: "abc" and "cde" 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: <g>"cde"</>
Received: <r>"abc"</>
`;

exports[`.toBe() fails for: "four
4
line
string" and "3
line
string" 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

<g>- Expected  - 1</>
<r>+ Received  + 2</>

<g>- 3</>
<r>+ four</>
<r>+ 4</>
<d>  line</>
<d>  string</>
`;

exports[`.toBe() fails for: "painless JavaScript testing" and "delightful JavaScript testing" 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: <g>"<i>delightful</i> JavaScript testing"</>
Received: <r>"<i>painless</i> JavaScript testing"</>
`;

exports[`.toBe() fails for: "with 
trailing space" and "without trailing space" 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

<g>- Expected  - 1</>
<r>+ Received  + 2</>

<g>- with<i>out</i> trailing space</>
<r>+ with<Y> </></>
<r>+ trailing space</>
`;

exports[`.toBe() fails for: /received/ and /expected/ 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: <g>/expected/</>
Received: <r>/received/</>
`;

exports[`.toBe() fails for: [] and [] 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

<d>If it should pass with deep equality, replace "toBe" with "toStrictEqual"</>

Expected: <g>[]</>
Received: serializes to the same string
`;

exports[`.toBe() fails for: [Error: received] and [Error: expected] 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: <g>[Error: expected]</>
Received: <r>[Error: received]</>
`;

exports[`.toBe() fails for: [Function anonymous] and [Function anonymous] 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: <g>[Function anonymous]</>
Received: serializes to the same string
`;

exports[`.toBe() fails for: {"a": [Function a], "b": 2} and {"a": Any<Function>, "b": 2} 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

<d>If it should pass with deep equality, replace "toBe" with "toStrictEqual"</>

Expected: <g>{"a": Any<Function>, "b": 2}</>
Received: <r>{"a": [Function a], "b": 2}</>
`;

exports[`.toBe() fails for: {"a": 1} and {"a": 1} 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

<d>If it should pass with deep equality, replace "toBe" with "toStrictEqual"</>

Expected: <g>{"a": 1}</>
Received: serializes to the same string
`;

exports[`.toBe() fails for: {"a": 1} and {"a": 5} 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": 5,</>
<r>+   "a": 1,</>
<d>  }</>
`;

exports[`.toBe() fails for: {"a": undefined, "b": 2} and {"b": 2} 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

<d>If it should pass with deep equality, replace "toBe" with "toEqual"</>

<g>- Expected  - 0</>
<r>+ Received  + 1</>

<d>  Object {</>
<r>+   "a": undefined,</>
<d>    "b": 2,</>
<d>  }</>
`;

exports[`.toBe() fails for: {} and {} 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

<d>If it should pass with deep equality, replace "toBe" with "toStrictEqual"</>

Expected: <g>{}</>
Received: serializes to the same string
`;

exports[`.toBe() fails for: -0 and 0 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: <g>0</>
Received: <r>-0</>
`;

exports[`.toBe() fails for: 1 and 2 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: <g>2</>
Received: <r>1</>
`;

exports[`.toBe() fails for: 2020-02-20T00:00:00.000Z and 2020-02-20T00:00:00.000Z 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

<d>If it should pass with deep equality, replace "toBe" with "toStrictEqual"</>

Expected: <g>2020-02-20T00:00:00.000Z</>
Received: serializes to the same string
`;

exports[`.toBe() fails for: 2020-02-21T00:00:00.000Z and 2020-02-20T00:00:00.000Z 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: <g>2020-02-20T00:00:00.000Z</>
Received: <r>2020-02-21T00:00:00.000Z</>
`;

exports[`.toBe() fails for: Symbol(received) and Symbol(expected) 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: <g>Symbol(expected)</>
Received: <r>Symbol(received)</>
`;

exports[`.toBe() fails for: null and undefined 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: <g>undefined</>
Received: <r>null</>
`;

exports[`.toBe() fails for: true and false 1`] = `
<d>expect(</><r>received</><d>).</>toBe<d>(</><g>expected</><d>) // Object.is equality</>

Expected: <g>false</>
Received: <r>true</>
`;

exports[`.toBeCloseTo {pass: false} expect(-Infinity).toBeCloseTo(-1.23) 1`] = `
<d>expect(</><r>received</><d>).</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: <g>-1.23</>
Received: <r>-Infinity</>

Expected precision:    2
Expected difference: < <g>0.005</>
Received difference:   <r>Infinity</>
`;

exports[`.toBeCloseTo {pass: false} expect(0).toBeCloseTo(0.01) 1`] = `
<d>expect(</><r>received</><d>).</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: <g>0.01</>
Received: <r>0</>

Expected precision:    2
Expected difference: < <g>0.005</>
Received difference:   <r>0.01</>
`;

exports[`.toBeCloseTo {pass: false} expect(1).toBeCloseTo(1.23) 1`] = `
<d>expect(</><r>received</><d>).</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: <g>1.23</>
Received: <r>1</>

Expected precision:    2
Expected difference: < <g>0.005</>
Received difference:   <r>0.22999999999999998</>
`;

exports[`.toBeCloseTo {pass: false} expect(1.23).toBeCloseTo(1.2249999) 1`] = `
<d>expect(</><r>received</><d>).</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: <g>1.2249999</>
Received: <r>1.23</>

Expected precision:    2
Expected difference: < <g>0.005</>
Received difference:   <r>0.005000099999999952</>
`;

exports[`.toBeCloseTo {pass: false} expect(3.141592e-7).toBeCloseTo(3e-7, 8) 1`] = `
<d>expect(</><r>received</><d>).</>toBeCloseTo<d>(</><g>expected</><d>, </>precision<d>)</>

Expected: <g>3e-7</>
Received: <r>3.141592e-7</>

Expected precision:    8
Expected difference: < <g>5e-9</>
Received difference:   <r>1.4159200000000025e-8</>
`;

exports[`.toBeCloseTo {pass: false} expect(56789).toBeCloseTo(51234, -4) 1`] = `
<d>expect(</><r>received</><d>).</>toBeCloseTo<d>(</><g>expected</><d>, </>precision<d>)</>

Expected: <g>51234</>
Received: <r>56789</>

Expected precision:    -4
Expected difference: < <g>5000</>
Received difference:   <r>5555</>
`;

exports[`.toBeCloseTo {pass: false} expect(Infinity).toBeCloseTo(-Infinity) 1`] = `
<d>expect(</><r>received</><d>).</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: <g>-Infinity</>
Received: <r>Infinity</>

Expected precision:    2
Expected difference: < <g>0.005</>
Received difference:   <r>Infinity</>
`;

exports[`.toBeCloseTo {pass: false} expect(Infinity).toBeCloseTo(1.23) 1`] = `
<d>expect(</><r>received</><d>).</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: <g>1.23</>
Received: <r>Infinity</>

Expected precision:    2
Expected difference: < <g>0.005</>
Received difference:   <r>Infinity</>
`;

exports[`.toBeCloseTo {pass: true} expect(-Infinity).toBeCloseTo(-Infinity) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: not <g>-Infinity</>

`;

exports[`.toBeCloseTo {pass: true} expect(0).toBeCloseTo(0) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: not <g>0</>

`;

exports[`.toBeCloseTo {pass: true} expect(0).toBeCloseTo(0.000004, 5) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>, </>precision<d>)</>

Expected: not <g>0.000004</>
Received:     <r>0</>

Expected precision:        5
Expected difference: not < <g>0.000005</>
Received difference:       <r>0.000004</>
`;

exports[`.toBeCloseTo {pass: true} expect(0).toBeCloseTo(0.0001, 3) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>, </>precision<d>)</>

Expected: not <g>0.0001</>
Received:     <r>0</>

Expected precision:        3
Expected difference: not < <g>0.0005</>
Received difference:       <r>0.0001</>
`;

exports[`.toBeCloseTo {pass: true} expect(0).toBeCloseTo(0.001) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: not <g>0.001</>
Received:     <r>0</>

Expected precision:        2
Expected difference: not < <g>0.005</>
Received difference:       <r>0.001</>
`;

exports[`.toBeCloseTo {pass: true} expect(0).toBeCloseTo(0.1, 0) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>, </>precision<d>)</>

Expected: not <g>0.1</>
Received:     <r>0</>

Expected precision:        0
Expected difference: not < <g>0.5</>
Received difference:       <r>0.1</>
`;

exports[`.toBeCloseTo {pass: true} expect(1.23).toBeCloseTo(1.225) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: not <g>1.225</>
Received:     <r>1.23</>

Expected precision:        2
Expected difference: not < <g>0.005</>
Received difference:       <r>0.004999999999999893</>
`;

exports[`.toBeCloseTo {pass: true} expect(1.23).toBeCloseTo(1.226) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: not <g>1.226</>
Received:     <r>1.23</>

Expected precision:        2
Expected difference: not < <g>0.005</>
Received difference:       <r>0.0040000000000000036</>
`;

exports[`.toBeCloseTo {pass: true} expect(1.23).toBeCloseTo(1.229) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: not <g>1.229</>
Received:     <r>1.23</>

Expected precision:        2
Expected difference: not < <g>0.005</>
Received difference:       <r>0.0009999999999998899</>
`;

exports[`.toBeCloseTo {pass: true} expect(1.23).toBeCloseTo(1.234) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: not <g>1.234</>
Received:     <r>1.23</>

Expected precision:        2
Expected difference: not < <g>0.005</>
Received difference:       <r>0.0040000000000000036</>
`;

exports[`.toBeCloseTo {pass: true} expect(2.0000002).toBeCloseTo(2, 5) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>, </>precision<d>)</>

Expected: not <g>2</>
Received:     <r>2.0000002</>

Expected precision:        5
Expected difference: not < <g>5e-6</>
Received difference:       <r>2.0000000011677344e-7</>
`;

exports[`.toBeCloseTo {pass: true} expect(Infinity).toBeCloseTo(Infinity) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>)</>

Expected: not <g>Infinity</>

`;

exports[`.toBeCloseTo throws: Matcher error promise empty isNot false received 1`] = `
<d>expect(</><r>received</><d>).</>toBeCloseTo<d>(</><g>expected</><d>, </>precision<d>)</>

<b>Matcher error</>: <r>received</> value must be a number

Received has type:  string
Received has value: <r>""</>
`;

exports[`.toBeCloseTo throws: Matcher error promise empty isNot true expected 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a number

Expected has value: <g>undefined</>
`;

exports[`.toBeCloseTo throws: Matcher error promise rejects isNot false expected 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>toBeCloseTo<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a number

Expected has type:  string
Expected has value: <g>"0"</>
`;

exports[`.toBeCloseTo throws: Matcher error promise rejects isNot true received 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a number

Received has type:  symbol
Received has value: <r>Symbol(0.1)</>
`;

exports[`.toBeCloseTo throws: Matcher error promise resolves isNot false received 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>toBeCloseTo<d>(</><g>expected</><d>, </>precision<d>)</>

<b>Matcher error</>: <r>received</> value must be a number

Received has type:  boolean
Received has value: <r>false</>
`;

exports[`.toBeCloseTo throws: Matcher error promise resolves isNot true expected 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>not<d>.</>toBeCloseTo<d>(</><g>expected</><d>, </>precision<d>)</>

<b>Matcher error</>: <g>expected</> value must be a number

Expected has value: <g>null</>
`;

exports[`.toBeDefined(), .toBeUndefined() '"a"' is defined 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeDefined<d>()</>

Received: <r>"a"</>
`;

exports[`.toBeDefined(), .toBeUndefined() '"a"' is defined 2`] = `
<d>expect(</><r>received</><d>).</>toBeUndefined<d>()</>

Received: <r>"a"</>
`;

exports[`.toBeDefined(), .toBeUndefined() '[]' is defined 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeDefined<d>()</>

Received: <r>[]</>
`;

exports[`.toBeDefined(), .toBeUndefined() '[]' is defined 2`] = `
<d>expect(</><r>received</><d>).</>toBeUndefined<d>()</>

Received: <r>[]</>
`;

exports[`.toBeDefined(), .toBeUndefined() '[Function anonymous]' is defined 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeDefined<d>()</>

Received: <r>[Function anonymous]</>
`;

exports[`.toBeDefined(), .toBeUndefined() '[Function anonymous]' is defined 2`] = `
<d>expect(</><r>received</><d>).</>toBeUndefined<d>()</>

Received: <r>[Function anonymous]</>
`;

exports[`.toBeDefined(), .toBeUndefined() '{}' is defined 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeDefined<d>()</>

Received: <r>{}</>
`;

exports[`.toBeDefined(), .toBeUndefined() '{}' is defined 2`] = `
<d>expect(</><r>received</><d>).</>toBeUndefined<d>()</>

Received: <r>{}</>
`;

exports[`.toBeDefined(), .toBeUndefined() '0.5' is defined 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeDefined<d>()</>

Received: <r>0.5</>
`;

exports[`.toBeDefined(), .toBeUndefined() '0.5' is defined 2`] = `
<d>expect(</><r>received</><d>).</>toBeUndefined<d>()</>

Received: <r>0.5</>
`;

exports[`.toBeDefined(), .toBeUndefined() '1' is defined 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeDefined<d>()</>

Received: <r>1</>
`;

exports[`.toBeDefined(), .toBeUndefined() '1' is defined 2`] = `
<d>expect(</><r>received</><d>).</>toBeUndefined<d>()</>

Received: <r>1</>
`;

exports[`.toBeDefined(), .toBeUndefined() 'Infinity' is defined 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeDefined<d>()</>

Received: <r>Infinity</>
`;

exports[`.toBeDefined(), .toBeUndefined() 'Infinity' is defined 2`] = `
<d>expect(</><r>received</><d>).</>toBeUndefined<d>()</>

Received: <r>Infinity</>
`;

exports[`.toBeDefined(), .toBeUndefined() 'Map {}' is defined 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeDefined<d>()</>

Received: <r>Map {}</>
`;

exports[`.toBeDefined(), .toBeUndefined() 'Map {}' is defined 2`] = `
<d>expect(</><r>received</><d>).</>toBeUndefined<d>()</>

Received: <r>Map {}</>
`;

exports[`.toBeDefined(), .toBeUndefined() 'true' is defined 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeDefined<d>()</>

Received: <r>true</>
`;

exports[`.toBeDefined(), .toBeUndefined() 'true' is defined 2`] = `
<d>expect(</><r>received</><d>).</>toBeUndefined<d>()</>

Received: <r>true</>
`;

exports[`.toBeDefined(), .toBeUndefined() undefined is undefined 1`] = `
<d>expect(</><r>received</><d>).</>toBeDefined<d>()</>

Received: <r>undefined</>
`;

exports[`.toBeDefined(), .toBeUndefined() undefined is undefined 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeUndefined<d>()</>

Received: <r>undefined</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() equal numbers: [-Infinity, -Infinity] 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not >= <g>-Infinity</>
Received:        <r>-Infinity</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() equal numbers: [-Infinity, -Infinity] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not <= <g>-Infinity</>
Received:        <r>-Infinity</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() equal numbers: [1, 1] 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not >= <g>1</>
Received:        <r>1</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() equal numbers: [1, 1] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not <= <g>1</>
Received:        <r>1</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() equal numbers: [1.7976931348623157e+308, 1.7976931348623157e+308] 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not >= <g>1.7976931348623157e+308</>
Received:        <r>1.7976931348623157e+308</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() equal numbers: [1.7976931348623157e+308, 1.7976931348623157e+308] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not <= <g>1.7976931348623157e+308</>
Received:        <r>1.7976931348623157e+308</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() equal numbers: [5e-324, 5e-324] 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not >= <g>5e-324</>
Received:        <r>5e-324</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() equal numbers: [5e-324, 5e-324] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not <= <g>5e-324</>
Received:        <r>5e-324</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() equal numbers: [Infinity, Infinity] 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not >= <g>Infinity</>
Received:        <r>Infinity</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() equal numbers: [Infinity, Infinity] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not <= <g>Infinity</>
Received:        <r>Infinity</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [-Infinity, Infinity] 1`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: > <g>Infinity</>
Received:   <r>-Infinity</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [-Infinity, Infinity] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: not < <g>Infinity</>
Received:       <r>-Infinity</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [-Infinity, Infinity] 3`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: not > <g>-Infinity</>
Received:       <r>Infinity</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [-Infinity, Infinity] 4`] = `
<d>expect(</><r>received</><d>).</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: < <g>-Infinity</>
Received:   <r>Infinity</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [-Infinity, Infinity] 5`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: >= <g>Infinity</>
Received:    <r>-Infinity</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [-Infinity, Infinity] 6`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not <= <g>Infinity</>
Received:        <r>-Infinity</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [-Infinity, Infinity] 7`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not >= <g>-Infinity</>
Received:        <r>Infinity</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [-Infinity, Infinity] 8`] = `
<d>expect(</><r>received</><d>).</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: <= <g>-Infinity</>
Received:    <r>Infinity</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [0.1, 0.2] 1`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: > <g>0.2</>
Received:   <r>0.1</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [0.1, 0.2] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: not < <g>0.2</>
Received:       <r>0.1</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [0.1, 0.2] 3`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: not > <g>0.1</>
Received:       <r>0.2</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [0.1, 0.2] 4`] = `
<d>expect(</><r>received</><d>).</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: < <g>0.1</>
Received:   <r>0.2</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [0.1, 0.2] 5`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: >= <g>0.2</>
Received:    <r>0.1</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [0.1, 0.2] 6`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not <= <g>0.2</>
Received:        <r>0.1</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [0.1, 0.2] 7`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not >= <g>0.1</>
Received:        <r>0.2</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [0.1, 0.2] 8`] = `
<d>expect(</><r>received</><d>).</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: <= <g>0.1</>
Received:    <r>0.2</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [1, 2] 1`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: > <g>2</>
Received:   <r>1</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [1, 2] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: not < <g>2</>
Received:       <r>1</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [1, 2] 3`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: not > <g>1</>
Received:       <r>2</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [1, 2] 4`] = `
<d>expect(</><r>received</><d>).</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: < <g>1</>
Received:   <r>2</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [1, 2] 5`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: >= <g>2</>
Received:    <r>1</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [1, 2] 6`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not <= <g>2</>
Received:        <r>1</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [1, 2] 7`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not >= <g>1</>
Received:        <r>2</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [1, 2] 8`] = `
<d>expect(</><r>received</><d>).</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: <= <g>1</>
Received:    <r>2</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [3, 7] 1`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: > <g>7</>
Received:   <r>3</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [3, 7] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: not < <g>7</>
Received:       <r>3</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [3, 7] 3`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: not > <g>3</>
Received:       <r>7</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [3, 7] 4`] = `
<d>expect(</><r>received</><d>).</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: < <g>3</>
Received:   <r>7</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [3, 7] 5`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: >= <g>7</>
Received:    <r>3</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [3, 7] 6`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not <= <g>7</>
Received:        <r>3</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [3, 7] 7`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not >= <g>3</>
Received:        <r>7</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [3, 7] 8`] = `
<d>expect(</><r>received</><d>).</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: <= <g>3</>
Received:    <r>7</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [5e-324, 1.7976931348623157e+308] 1`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: > <g>1.7976931348623157e+308</>
Received:   <r>5e-324</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [5e-324, 1.7976931348623157e+308] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: not < <g>1.7976931348623157e+308</>
Received:       <r>5e-324</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [5e-324, 1.7976931348623157e+308] 3`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: not > <g>5e-324</>
Received:       <r>1.7976931348623157e+308</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [5e-324, 1.7976931348623157e+308] 4`] = `
<d>expect(</><r>received</><d>).</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: < <g>5e-324</>
Received:   <r>1.7976931348623157e+308</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [5e-324, 1.7976931348623157e+308] 5`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: >= <g>1.7976931348623157e+308</>
Received:    <r>5e-324</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [5e-324, 1.7976931348623157e+308] 6`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not <= <g>1.7976931348623157e+308</>
Received:        <r>5e-324</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [5e-324, 1.7976931348623157e+308] 7`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not >= <g>5e-324</>
Received:        <r>1.7976931348623157e+308</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [5e-324, 1.7976931348623157e+308] 8`] = `
<d>expect(</><r>received</><d>).</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: <= <g>5e-324</>
Received:    <r>1.7976931348623157e+308</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [9, 18] 1`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: > <g>18</>
Received:   <r>9</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [9, 18] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: not < <g>18</>
Received:       <r>9</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [9, 18] 3`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: not > <g>9</>
Received:       <r>18</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [9, 18] 4`] = `
<d>expect(</><r>received</><d>).</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: < <g>9</>
Received:   <r>18</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [9, 18] 5`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: >= <g>18</>
Received:    <r>9</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [9, 18] 6`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not <= <g>18</>
Received:        <r>9</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [9, 18] 7`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not >= <g>9</>
Received:        <r>18</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [9, 18] 8`] = `
<d>expect(</><r>received</><d>).</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: <= <g>9</>
Received:    <r>18</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [17, 34] 1`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: > <g>34</>
Received:   <r>17</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [17, 34] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: not < <g>34</>
Received:       <r>17</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [17, 34] 3`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThan<d>(</><g>expected</><d>)</>

Expected: not > <g>17</>
Received:       <r>34</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [17, 34] 4`] = `
<d>expect(</><r>received</><d>).</>toBeLessThan<d>(</><g>expected</><d>)</>

Expected: < <g>17</>
Received:   <r>34</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [17, 34] 5`] = `
<d>expect(</><r>received</><d>).</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: >= <g>34</>
Received:    <r>17</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [17, 34] 6`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not <= <g>34</>
Received:        <r>17</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [17, 34] 7`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeGreaterThanOrEqual<d>(</><g>expected</><d>)</>

Expected: not >= <g>17</>
Received:        <r>34</>
`;

exports[`.toBeGreaterThan(), .toBeLessThan(), .toBeGreaterThanOrEqual(), .toBeLessThanOrEqual() throws: [17, 34] 8`] = `
<d>expect(</><r>received</><d>).</>toBeLessThanOrEqual<d>(</><g>expected</><d>)</>

Expected: <= <g>17</>
Received:    <r>34</>
`;

exports[`.toBeInstanceOf() failing "a" and [Function String] 1`] = `
<d>expect(</><r>received</><d>).</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: <g>String</>

Received value has no prototype
Received value: <r>"a"</>
`;

exports[`.toBeInstanceOf() failing /\\w+/ and [Function anonymous] 1`] = `
<d>expect(</><r>received</><d>).</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor name is an empty string
Received constructor: <r>RegExp</>

`;

exports[`.toBeInstanceOf() failing {} and [Function A] 1`] = `
<d>expect(</><r>received</><d>).</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: <g>A</>

Received value has no prototype
Received value: <r>{}</>
`;

exports[`.toBeInstanceOf() failing {} and [Function B] 1`] = `
<d>expect(</><r>received</><d>).</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: <g>B</>
Received constructor: <r>A</>

`;

exports[`.toBeInstanceOf() failing {} and [Function RegExp] 1`] = `
<d>expect(</><r>received</><d>).</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: <g>RegExp</>
Received constructor name is an empty string

`;

exports[`.toBeInstanceOf() failing 1 and [Function Number] 1`] = `
<d>expect(</><r>received</><d>).</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: <g>Number</>

Received value has no prototype
Received value: <r>1</>
`;

exports[`.toBeInstanceOf() failing null and [Function String] 1`] = `
<d>expect(</><r>received</><d>).</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: <g>String</>

Received value has no prototype
Received value: <r>null</>
`;

exports[`.toBeInstanceOf() failing true and [Function Boolean] 1`] = `
<d>expect(</><r>received</><d>).</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: <g>Boolean</>

Received value has no prototype
Received value: <r>true</>
`;

exports[`.toBeInstanceOf() failing undefined and [Function String] 1`] = `
<d>expect(</><r>received</><d>).</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: <g>String</>

Received value has no prototype
Received value: <r>undefined</>
`;

exports[`.toBeInstanceOf() passing [] and [Function Array] 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: not <g>Array</>

`;

exports[`.toBeInstanceOf() passing {} and [Function A] 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: not <g>A</>

`;

exports[`.toBeInstanceOf() passing {} and [Function B] 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: not <g>B</>
Received constructor:     <r>C</> extends <g>B</>

`;

exports[`.toBeInstanceOf() passing {} and [Function B] 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: not <g>B</>
Received constructor:     <r>E</> extends … extends <g>B</>

`;

exports[`.toBeInstanceOf() passing {} and [Function B] 3`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: not <g>B</>
Received constructor name is not a string

`;

exports[`.toBeInstanceOf() passing {} and [Function anonymous] 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor name is an empty string
Received constructor: <r>SubHasNameProp</>

`;

exports[`.toBeInstanceOf() passing {} and [Function name() {}] 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor name is not a string

`;

exports[`.toBeInstanceOf() passing Map {} and [Function Map] 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeInstanceOf<d>(</><g>expected</><d>)</>

Expected constructor: not <g>Map</>

`;

exports[`.toBeInstanceOf() throws if constructor is not a function 1`] = `
<d>expect(</><r>received</><d>).</>toBeInstanceOf<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a function

Expected has type:  number
Expected has value: <g>4</>
`;

exports[`.toBeNaN() {pass: true} expect(NaN).toBeNaN() 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeNaN<d>()</>

Received: <r>NaN</>
`;

exports[`.toBeNaN() {pass: true} expect(NaN).toBeNaN() 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeNaN<d>()</>

Received: <r>NaN</>
`;

exports[`.toBeNaN() {pass: true} expect(NaN).toBeNaN() 3`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeNaN<d>()</>

Received: <r>NaN</>
`;

exports[`.toBeNaN() {pass: true} expect(NaN).toBeNaN() 4`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeNaN<d>()</>

Received: <r>NaN</>
`;

exports[`.toBeNaN() throws 1`] = `
<d>expect(</><r>received</><d>).</>toBeNaN<d>()</>

Received: <r>1</>
`;

exports[`.toBeNaN() throws 2`] = `
<d>expect(</><r>received</><d>).</>toBeNaN<d>()</>

Received: <r>""</>
`;

exports[`.toBeNaN() throws 3`] = `
<d>expect(</><r>received</><d>).</>toBeNaN<d>()</>

Received: <r>null</>
`;

exports[`.toBeNaN() throws 4`] = `
<d>expect(</><r>received</><d>).</>toBeNaN<d>()</>

Received: <r>undefined</>
`;

exports[`.toBeNaN() throws 5`] = `
<d>expect(</><r>received</><d>).</>toBeNaN<d>()</>

Received: <r>{}</>
`;

exports[`.toBeNaN() throws 6`] = `
<d>expect(</><r>received</><d>).</>toBeNaN<d>()</>

Received: <r>[]</>
`;

exports[`.toBeNaN() throws 7`] = `
<d>expect(</><r>received</><d>).</>toBeNaN<d>()</>

Received: <r>0.2</>
`;

exports[`.toBeNaN() throws 8`] = `
<d>expect(</><r>received</><d>).</>toBeNaN<d>()</>

Received: <r>0</>
`;

exports[`.toBeNaN() throws 9`] = `
<d>expect(</><r>received</><d>).</>toBeNaN<d>()</>

Received: <r>Infinity</>
`;

exports[`.toBeNaN() throws 10`] = `
<d>expect(</><r>received</><d>).</>toBeNaN<d>()</>

Received: <r>-Infinity</>
`;

exports[`.toBeNull() fails for '"a"' 1`] = `
<d>expect(</><r>received</><d>).</>toBeNull<d>()</>

Received: <r>"a"</>
`;

exports[`.toBeNull() fails for '[]' 1`] = `
<d>expect(</><r>received</><d>).</>toBeNull<d>()</>

Received: <r>[]</>
`;

exports[`.toBeNull() fails for '[Function anonymous]' 1`] = `
<d>expect(</><r>received</><d>).</>toBeNull<d>()</>

Received: <r>[Function anonymous]</>
`;

exports[`.toBeNull() fails for '{}' 1`] = `
<d>expect(</><r>received</><d>).</>toBeNull<d>()</>

Received: <r>{}</>
`;

exports[`.toBeNull() fails for '0.5' 1`] = `
<d>expect(</><r>received</><d>).</>toBeNull<d>()</>

Received: <r>0.5</>
`;

exports[`.toBeNull() fails for '1' 1`] = `
<d>expect(</><r>received</><d>).</>toBeNull<d>()</>

Received: <r>1</>
`;

exports[`.toBeNull() fails for 'Infinity' 1`] = `
<d>expect(</><r>received</><d>).</>toBeNull<d>()</>

Received: <r>Infinity</>
`;

exports[`.toBeNull() fails for 'Map {}' 1`] = `
<d>expect(</><r>received</><d>).</>toBeNull<d>()</>

Received: <r>Map {}</>
`;

exports[`.toBeNull() fails for 'true' 1`] = `
<d>expect(</><r>received</><d>).</>toBeNull<d>()</>

Received: <r>true</>
`;

exports[`.toBeNull() fails for null with .not 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeNull<d>()</>

Received: <r>null</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '""' is falsy 1`] = `
<d>expect(</><r>received</><d>).</>toBeTruthy<d>()</>

Received: <r>""</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '""' is falsy 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeFalsy<d>()</>

Received: <r>""</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '"a"' is truthy 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeTruthy<d>()</>

Received: <r>"a"</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '"a"' is truthy 2`] = `
<d>expect(</><r>received</><d>).</>toBeFalsy<d>()</>

Received: <r>"a"</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '[]' is truthy 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeTruthy<d>()</>

Received: <r>[]</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '[]' is truthy 2`] = `
<d>expect(</><r>received</><d>).</>toBeFalsy<d>()</>

Received: <r>[]</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '[Function anonymous]' is truthy 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeTruthy<d>()</>

Received: <r>[Function anonymous]</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '[Function anonymous]' is truthy 2`] = `
<d>expect(</><r>received</><d>).</>toBeFalsy<d>()</>

Received: <r>[Function anonymous]</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '{}' is truthy 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeTruthy<d>()</>

Received: <r>{}</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '{}' is truthy 2`] = `
<d>expect(</><r>received</><d>).</>toBeFalsy<d>()</>

Received: <r>{}</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '0' is falsy 1`] = `
<d>expect(</><r>received</><d>).</>toBeTruthy<d>()</>

Received: <r>0</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '0' is falsy 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeFalsy<d>()</>

Received: <r>0</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '0.5' is truthy 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeTruthy<d>()</>

Received: <r>0.5</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '0.5' is truthy 2`] = `
<d>expect(</><r>received</><d>).</>toBeFalsy<d>()</>

Received: <r>0.5</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '1' is truthy 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeTruthy<d>()</>

Received: <r>1</>
`;

exports[`.toBeTruthy(), .toBeFalsy() '1' is truthy 2`] = `
<d>expect(</><r>received</><d>).</>toBeFalsy<d>()</>

Received: <r>1</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'Infinity' is truthy 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeTruthy<d>()</>

Received: <r>Infinity</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'Infinity' is truthy 2`] = `
<d>expect(</><r>received</><d>).</>toBeFalsy<d>()</>

Received: <r>Infinity</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'Map {}' is truthy 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeTruthy<d>()</>

Received: <r>Map {}</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'Map {}' is truthy 2`] = `
<d>expect(</><r>received</><d>).</>toBeFalsy<d>()</>

Received: <r>Map {}</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'NaN' is falsy 1`] = `
<d>expect(</><r>received</><d>).</>toBeTruthy<d>()</>

Received: <r>NaN</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'NaN' is falsy 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeFalsy<d>()</>

Received: <r>NaN</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'false' is falsy 1`] = `
<d>expect(</><r>received</><d>).</>toBeTruthy<d>()</>

Received: <r>false</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'false' is falsy 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeFalsy<d>()</>

Received: <r>false</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'null' is falsy 1`] = `
<d>expect(</><r>received</><d>).</>toBeTruthy<d>()</>

Received: <r>null</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'null' is falsy 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeFalsy<d>()</>

Received: <r>null</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'true' is truthy 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeTruthy<d>()</>

Received: <r>true</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'true' is truthy 2`] = `
<d>expect(</><r>received</><d>).</>toBeFalsy<d>()</>

Received: <r>true</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'undefined' is falsy 1`] = `
<d>expect(</><r>received</><d>).</>toBeTruthy<d>()</>

Received: <r>undefined</>
`;

exports[`.toBeTruthy(), .toBeFalsy() 'undefined' is falsy 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeFalsy<d>()</>

Received: <r>undefined</>
`;

exports[`.toBeTruthy(), .toBeFalsy() does not accept arguments 1`] = `
<d>expect(</><r>received</><d>).</>toBeTruthy<d>()</>

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

Expected has value: <g>null</>
`;

exports[`.toBeTruthy(), .toBeFalsy() does not accept arguments 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toBeFalsy<d>()</>

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

Expected has value: <g>null</>
`;

exports[`.toContain(), .toContainEqual() '"11112111"' contains '"2"' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected substring: not <g>"2"</>
Received string:        <r>"1111<i>2</i>111"</>
`;

exports[`.toContain(), .toContainEqual() '"abcdef"' contains '"abc"' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected substring: not <g>"abc"</>
Received string:        <r>"<i>abc</i>def"</>
`;

exports[`.toContain(), .toContainEqual() '["a", "b", "c", "d"]' contains '"a"' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected value: not <g>"a"</>
Received array:     <r>[<i>"a"</i>, "b", "c", "d"]</>
`;

exports[`.toContain(), .toContainEqual() '["a", "b", "c", "d"]' contains a value equal to '"a"' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContainEqual<d>(</><g>expected</><d>) // deep equality</>

Expected value: not <g>"a"</>
Received array:     <r>[<i>"a"</i>, "b", "c", "d"]</>
`;

exports[`.toContain(), .toContainEqual() '[{"a": "b"}, {"a": "c"}]' contains a value equal to '{"a": "b"}' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContainEqual<d>(</><g>expected</><d>) // deep equality</>

Expected value: not <g>{"a": "b"}</>
Received array:     <r>[<i>{"a": "b"}</i>, {"a": "c"}]</>
`;

exports[`.toContain(), .toContainEqual() '[{"a": "b"}, {"a": "c"}]' does not contain a value equal to'{"a": "d"}' 1`] = `
<d>expect(</><r>received</><d>).</>toContainEqual<d>(</><g>expected</><d>) // deep equality</>

Expected value: <g>{"a": "d"}</>
Received array: <r>[{"a": "b"}, {"a": "c"}]</>
`;

exports[`.toContain(), .toContainEqual() '[{}, []]' does not contain '[]' 1`] = `
<d>expect(</><r>received</><d>).</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected value: <g>[]</>
Received array: <r>[{}, []]</>

<d>Looks like you wanted to test for object/array equality with the stricter \`toContain\` matcher. You probably need to use \`toContainEqual\` instead.</>
`;

exports[`.toContain(), .toContainEqual() '[{}, []]' does not contain '{}' 1`] = `
<d>expect(</><r>received</><d>).</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected value: <g>{}</>
Received array: <r>[{}, []]</>

<d>Looks like you wanted to test for object/array equality with the stricter \`toContain\` matcher. You probably need to use \`toContainEqual\` instead.</>
`;

exports[`.toContain(), .toContainEqual() '[0, 1]' contains '1' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected value:  not <g>1</>
Received object:     <r>[0, 1]</>
`;

exports[`.toContain(), .toContainEqual() '[0, 1]' contains a value equal to '1' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContainEqual<d>(</><g>expected</><d>) // deep equality</>

Expected value:  not <g>1</>
Received object:     <r>[0, 1]</>
`;

exports[`.toContain(), .toContainEqual() '[1, 2, 3, 4]' contains '1' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected value: not <g>1</>
Received array:     <r>[<i>1</i>, 2, 3, 4]</>
`;

exports[`.toContain(), .toContainEqual() '[1, 2, 3, 4]' contains a value equal to '1' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContainEqual<d>(</><g>expected</><d>) // deep equality</>

Expected value: not <g>1</>
Received array:     <r>[<i>1</i>, 2, 3, 4]</>
`;

exports[`.toContain(), .toContainEqual() '[1, 2, 3]' does not contain '4' 1`] = `
<d>expect(</><r>received</><d>).</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected value: <g>4</>
Received array: <r>[1, 2, 3]</>
`;

exports[`.toContain(), .toContainEqual() '[Symbol(a)]' contains 'Symbol(a)' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected value: not <g>Symbol(a)</>
Received array:     <r>[<i>Symbol(a)</i>]</>
`;

exports[`.toContain(), .toContainEqual() '[Symbol(a)]' contains a value equal to 'Symbol(a)' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContainEqual<d>(</><g>expected</><d>) // deep equality</>

Expected value: not <g>Symbol(a)</>
Received array:     <r>[<i>Symbol(a)</i>]</>
`;

exports[`.toContain(), .toContainEqual() '[null, undefined]' does not contain '1' 1`] = `
<d>expect(</><r>received</><d>).</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected value: <g>1</>
Received array: <r>[null, undefined]</>
`;

exports[`.toContain(), .toContainEqual() '[undefined, null]' contains 'null' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected value: not <g>null</>
Received array:     <r>[undefined, <i>null</i>]</>
`;

exports[`.toContain(), .toContainEqual() '[undefined, null]' contains 'undefined' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected value: not <g>undefined</>
Received array:     <r>[<i>undefined</i>, null]</>
`;

exports[`.toContain(), .toContainEqual() '[undefined, null]' contains a value equal to 'null' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContainEqual<d>(</><g>expected</><d>) // deep equality</>

Expected value: not <g>null</>
Received array:     <r>[undefined, <i>null</i>]</>
`;

exports[`.toContain(), .toContainEqual() '[undefined, null]' contains a value equal to 'undefined' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContainEqual<d>(</><g>expected</><d>) // deep equality</>

Expected value: not <g>undefined</>
Received array:     <r>[<i>undefined</i>, null]</>
`;

exports[`.toContain(), .toContainEqual() 'Set {"abc", "def"}' contains '"abc"' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContain<d>(</><g>expected</><d>) // indexOf</>

Expected value: not <g>"abc"</>
Received set:       <r>Set {"abc", "def"}</>
`;

exports[`.toContain(), .toContainEqual() 'Set {1, 2, 3, 4}' contains a value equal to '1' 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toContainEqual<d>(</><g>expected</><d>) // deep equality</>

Expected value: not <g>1</>
Received set:       <r>Set {1, 2, 3, 4}</>
`;

exports[`.toContain(), .toContainEqual() error cases 1`] = `
<d>expect(</><r>received</><d>).</>toContain<d>(</><g>expected</><d>) // indexOf</>

<b>Matcher error</>: <r>received</> value must not be null nor undefined

Received has value: <r>null</>
`;

exports[`.toContain(), .toContainEqual() error cases 2`] = `
<d>expect(</><r>-0</><d>).</>toContain<d>(</><g>0</><d>) // indexOf</>

<b>Matcher error</>: <g>expected</> value must be a string if <r>received</> value is a string

Expected has type:  number
Expected has value: <g>-0</>
Received has type:  string
Received has value: <r>"-0"</>
`;

exports[`.toContain(), .toContainEqual() error cases 3`] = `
<d>expect(</><r>null</><d>).</>toContain<d>(</><g>null</><d>) // indexOf</>

<b>Matcher error</>: <g>expected</> value must be a string if <r>received</> value is a string

Expected has value: <g>null</>
Received has type:  string
Received has value: <r>"null"</>
`;

exports[`.toContain(), .toContainEqual() error cases 4`] = `
<d>expect(</><r>undefined</><d>).</>toContain<d>(</><g>undefined</><d>) // indexOf</>

<b>Matcher error</>: <g>expected</> value must be a string if <r>received</> value is a string

Expected has value: <g>undefined</>
Received has type:  string
Received has value: <r>"undefined"</>
`;

exports[`.toContain(), .toContainEqual() error cases for toContainEqual 1`] = `
<d>expect(</><r>received</><d>).</>toContainEqual<d>(</><g>expected</><d>) // deep equality</>

<b>Matcher error</>: <r>received</> value must not be null nor undefined

Received has value: <r>null</>
`;

exports[`.toEqual() {pass: false} expect("1 234,57 $").toEqual("1 234,57 $") 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>"1<i> </i>234,57<i> </i>$"</>
Received: <r>"1<i> </i>234,57<i> </i>$"</>
`;

exports[`.toEqual() {pass: false} expect("Eve").toEqual({"asymmetricMatch": [Function asymmetricMatch]}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>{"asymmetricMatch": [Function asymmetricMatch]}</>
Received: <r>"Eve"</>
`;

exports[`.toEqual() {pass: false} expect("abc").toEqual({"0": "a", "1": "b", "2": "c"}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>{"0": "a", "1": "b", "2": "c"}</>
Received: <r>"abc"</>
`;

exports[`.toEqual() {pass: false} expect("abd").toEqual(StringContaining "bc") 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>StringContaining "bc"</>
Received: <r>"abd"</>
`;

exports[`.toEqual() {pass: false} expect("abd").toEqual(StringMatching /bc/i) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>StringMatching /bc/i</>
Received: <r>"abd"</>
`;

exports[`.toEqual() {pass: false} expect("banana").toEqual("apple") 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>"apple"</>
Received: <r>"banana"</>
`;

exports[`.toEqual() {pass: false} expect("type TypeName<T> = T extends Function ? \\"function\\" : \\"object\\";").toEqual("type TypeName<T> = T extends Function
? \\"function\\"
: \\"object\\";") 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 3</>
<r>+ Received  + 1</>

<g>- type TypeName<T> = T extends Function</>
<g>- ? "function"</>
<g>- : "object";</>
<r>+ type TypeName<T> = T extends Function<i> </i>? "function"<i> </i>: "object";</>
`;

exports[`.toEqual() {pass: false} expect(/abc/gsy).toEqual(/abc/g) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>/abc/g</>
Received: <r>/abc/gsy</>
`;

exports[`.toEqual() {pass: false} expect([1, 2]).toEqual([2, 1]) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Array [</>
<g>-   2,</>
<d>    1,</>
<r>+   2,</>
<d>  ]</>
`;

exports[`.toEqual() {pass: false} expect([1, 3]).toEqual(ArrayContaining [1, 2]) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>ArrayContaining [1, 2]</>
Received: <r>[1, 3]</>
`;

exports[`.toEqual() {pass: false} expect([1]).toEqual([2]) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Array [</>
<g>-   2,</>
<r>+   1,</>
<d>  ]</>
`;

exports[`.toEqual() {pass: false} expect([97, 98, 99]).toEqual([97, 98, 100]) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Uint8Array [</>
<d>    97,</>
<d>    98,</>
<g>-   100,</>
<r>+   99,</>
<d>  ]</>
`;

exports[`.toEqual() {pass: false} expect({"0": "a", "1": "b", "2": "c"}).toEqual("abc") 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>"abc"</>
Received: <r>{"0": "a", "1": "b", "2": "c"}</>
`;

exports[`.toEqual() {pass: false} expect({"a": 1, "b": 2}).toEqual(ObjectContaining {"a": 2}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>ObjectContaining {"a": 2}</>
Received: <r>{"a": 1, "b": 2}</>
`;

exports[`.toEqual() {pass: false} expect({"a": 1}).toEqual({"a": 2}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": 2,</>
<r>+   "a": 1,</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect({"a": 5}).toEqual({"b": 6}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "b": 6,</>
<r>+   "a": 5,</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect({"foo": {"bar": 1}}).toEqual({"foo": {}}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 3</>

<d>  Object {</>
<g>-   "foo": Object {},</>
<r>+   "foo": Object {</>
<r>+     "bar": 1,</>
<r>+   },</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect({"frozenGetter": {}}).toEqual({"frozenGetter": {"foo": "bar"}}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 3</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "frozenGetter": Object {</>
<g>-     "foo": "bar",</>
<g>-   },</>
<r>+   "frozenGetter": Object {},</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect({"frozenGetterAndSetter": {}}).toEqual({"frozenGetterAndSetter": {"foo": "bar"}}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 3</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "frozenGetterAndSetter": Object {</>
<g>-     "foo": "bar",</>
<g>-   },</>
<r>+   "frozenGetterAndSetter": Object {},</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect({"frozenSetter": undefined}).toEqual({"frozenSetter": {"foo": "bar"}}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 3</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "frozenSetter": Object {</>
<g>-     "foo": "bar",</>
<g>-   },</>
<r>+   "frozenSetter": undefined,</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect({"getter": {}}).toEqual({"getter": {"foo": "bar"}}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 3</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "getter": Object {</>
<g>-     "foo": "bar",</>
<g>-   },</>
<r>+   "getter": Object {},</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect({"getterAndSetter": {}}).toEqual({"getterAndSetter": {"foo": "bar"}}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 3</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "getterAndSetter": Object {</>
<g>-     "foo": "bar",</>
<g>-   },</>
<r>+   "getterAndSetter": Object {},</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect({"nodeName": "div", "nodeType": 1}).toEqual({"nodeName": "p", "nodeType": 1}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "nodeName": "p",</>
<r>+   "nodeName": "div",</>
<d>    "nodeType": 1,</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect({"setter": undefined}).toEqual({"setter": {"foo": "bar"}}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 3</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "setter": Object {</>
<g>-     "foo": "bar",</>
<g>-   },</>
<r>+   "setter": undefined,</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect({"target": {"nodeType": 1, "value": "a"}}).toEqual({"target": {"nodeType": 1, "value": "b"}}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<d>    "target": Object {</>
<d>      "nodeType": 1,</>
<g>-     "value": "b",</>
<r>+     "value": "a",</>
<d>    },</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect({}).toEqual({}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>{}</>
Received: serializes to the same string
`;

exports[`.toEqual() {pass: false} expect({}).toEqual(0) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>0</>
Received: <r>{}</>
`;

exports[`.toEqual() {pass: false} expect({Symbol(foo): 1, Symbol(bar): 2}).toEqual({Symbol(foo): Any<Number>, Symbol(bar): 1}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<d>    Symbol(foo): Any<Number>,</>
<g>-   Symbol(bar): 1,</>
<r>+   Symbol(bar): 2,</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(0).toEqual({}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>{}</>
Received: <r>0</>
`;

exports[`.toEqual() {pass: false} expect(0).toEqual(-0) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>-0</>
Received: <r>0</>
`;

exports[`.toEqual() {pass: false} expect(0).toEqual(5e-324) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>5e-324</>
Received: <r>0</>
`;

exports[`.toEqual() {pass: false} expect(1).toEqual(2) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>2</>
Received: <r>1</>
`;

exports[`.toEqual() {pass: false} expect(1).toEqual(ArrayContaining [1, 2]) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>ArrayContaining [1, 2]</>
Received: <r>1</>
`;

exports[`.toEqual() {pass: false} expect(5e-324).toEqual(0) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>0</>
Received: <r>5e-324</>
`;

exports[`.toEqual() {pass: false} expect(Immutable.List [1, 2]).toEqual(Immutable.List [2, 1]) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Immutable.List [</>
<g>-   2,</>
<d>    1,</>
<r>+   2,</>
<d>  ]</>
`;

exports[`.toEqual() {pass: false} expect(Immutable.List [1]).toEqual(Immutable.List [2]) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Immutable.List [</>
<g>-   2,</>
<r>+   1,</>
<d>  ]</>
`;

exports[`.toEqual() {pass: false} expect(Immutable.Map {"1": Immutable.Map {"2": {"a": 99}}}).toEqual(Immutable.Map {"1": Immutable.Map {"2": {"a": 11}}}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Immutable.Map {</>
<d>    "1": Immutable.Map {</>
<d>      "2": Object {</>
<g>-       "a": 11,</>
<r>+       "a": 99,</>
<d>      },</>
<d>    },</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(Immutable.Map {"a": 0}).toEqual(Immutable.Map {"b": 0}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Immutable.Map {</>
<g>-   "b": 0,</>
<r>+   "a": 0,</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(Immutable.Map {"v": 1}).toEqual(Immutable.Map {"v": 2}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Immutable.Map {</>
<g>-   "v": 2,</>
<r>+   "v": 1,</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(Immutable.OrderedMap {1: "one", 2: "two"}).toEqual(Immutable.OrderedMap {2: "two", 1: "one"}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Immutable.OrderedMap {</>
<g>-   2: "two",</>
<d>    1: "one",</>
<r>+   2: "two",</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(Immutable.OrderedSet [1, 2]).toEqual(Immutable.OrderedSet [2, 1]) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Immutable.OrderedSet [</>
<g>-   2,</>
<d>    1,</>
<r>+   2,</>
<d>  ]</>
`;

exports[`.toEqual() {pass: false} expect(Immutable.Set [1, 2]).toEqual(Immutable.Set []) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 4</>

<g>- Immutable.Set []</>
<r>+ Immutable.Set [</>
<r>+   1,</>
<r>+   2,</>
<r>+ ]</>
`;

exports[`.toEqual() {pass: false} expect(Immutable.Set [1, 2]).toEqual(Immutable.Set [1, 2, 3]) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 0</>

<d>  Immutable.Set [</>
<d>    1,</>
<d>    2,</>
<g>-   3,</>
<d>  ]</>
`;

exports[`.toEqual() {pass: false} expect(Map {"a" => 0}).toEqual(Map {"b" => 0}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Map {</>
<g>-   "b" => 0,</>
<r>+   "a" => 0,</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(Map {"v" => 1}).toEqual(Map {"v" => 2}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Map {</>
<g>-   "v" => 2,</>
<r>+   "v" => 1,</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(Map {["v"] => 1}).toEqual(Map {["v"] => 2}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Map {</>
<d>    Array [</>
<d>      "v",</>
<g>-   ] => 2,</>
<r>+   ] => 1,</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(Map {[1] => Map {[1] => "one"}}).toEqual(Map {[1] => Map {[1] => "two"}}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<y>@@ -2,8 +2,8 @@</>
<d>    Array [</>
<d>      1,</>
<d>    ] => Map {</>
<d>      Array [</>
<d>        1,</>
<g>-     ] => "two",</>
<r>+     ] => "one",</>
<d>    },</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(Map {}).toEqual(Set {}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>Set {}</>
Received: <r>Map {}</>
`;

exports[`.toEqual() {pass: false} expect(Map {1 => "one", 2 => "two"}).toEqual(Map {1 => "one"}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 0</>
<r>+ Received  + 1</>

<d>  Map {</>
<d>    1 => "one",</>
<r>+   2 => "two",</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(Set {[1], [2]}).toEqual(Set {[1], [2], [2]}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 3</>
<r>+ Received  + 0</>

<y>@@ -3,9 +3,6 @@</>
<d>      1,</>
<d>    ],</>
<d>    Array [</>
<d>      2,</>
<d>    ],</>
<g>-   Array [</>
<g>-     2,</>
<g>-   ],</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(Set {[1], [2]}).toEqual(Set {[1], [2], [3]}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 3</>
<r>+ Received  + 0</>

<y>@@ -3,9 +3,6 @@</>
<d>      1,</>
<d>    ],</>
<d>    Array [</>
<d>      2,</>
<d>    ],</>
<g>-   Array [</>
<g>-     3,</>
<g>-   ],</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(Set {1, 2}).toEqual(Set {}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 4</>

<g>- Set {}</>
<r>+ Set {</>
<r>+   1,</>
<r>+   2,</>
<r>+ }</>
`;

exports[`.toEqual() {pass: false} expect(Set {1, 2}).toEqual(Set {1, 2, 3}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 0</>

<d>  Set {</>
<d>    1,</>
<d>    2,</>
<g>-   3,</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(Set {Set {1}, Set {2}}).toEqual(Set {Set {1}, Set {3}}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Set {</>
<d>    Set {</>
<d>      1,</>
<d>    },</>
<d>    Set {</>
<g>-     3,</>
<r>+     2,</>
<d>    },</>
<d>  }</>
`;

exports[`.toEqual() {pass: false} expect(false).toEqual(ObjectContaining {"a": 2}) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>ObjectContaining {"a": 2}</>
Received: <r>false</>
`;

exports[`.toEqual() {pass: false} expect(null).toEqual(undefined) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>undefined</>
Received: <r>null</>
`;

exports[`.toEqual() {pass: false} expect(true).toEqual(false) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>false</>
Received: <r>true</>
`;

exports[`.toEqual() {pass: false} expect(undefined).toEqual(Any<Function>) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>Any<Function></>
Received: <r>undefined</>
`;

exports[`.toEqual() {pass: false} expect(undefined).toEqual(Anything) 1`] = `
<d>expect(</><r>received</><d>).</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>Anything</>
Received: <r>undefined</>
`;

exports[`.toEqual() {pass: true} expect("Alice").not.toEqual({"asymmetricMatch": [Function asymmetricMatch]}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>{"asymmetricMatch": [Function asymmetricMatch]}</>
Received:     <r>"Alice"</>
`;

exports[`.toEqual() {pass: true} expect("abc").not.toEqual("abc") 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>"abc"</>

`;

exports[`.toEqual() {pass: true} expect("abc").not.toEqual("abc") 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>"abc"</>

`;

exports[`.toEqual() {pass: true} expect("abc").not.toEqual("abc") 3`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>"abc"</>

`;

exports[`.toEqual() {pass: true} expect("abcd").not.toEqual(StringContaining "bc") 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>StringContaining "bc"</>
Received:     <r>"abcd"</>
`;

exports[`.toEqual() {pass: true} expect("abcd").not.toEqual(StringMatching /bc/) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>StringMatching /bc/</>
Received:     <r>"abcd"</>
`;

exports[`.toEqual() {pass: true} expect([1, 2, 3]).not.toEqual(ArrayContaining [2, 3]) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>ArrayContaining [2, 3]</>
Received:     <r>[1, 2, 3]</>
`;

exports[`.toEqual() {pass: true} expect([1, 2]).not.toEqual([1, 2]) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>[1, 2]</>

`;

exports[`.toEqual() {pass: true} expect([1]).not.toEqual([1]) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>[1]</>

`;

exports[`.toEqual() {pass: true} expect([97, 98, 99]).not.toEqual([97, 98, 99]) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>[97, 98, 99]</>

`;

exports[`.toEqual() {pass: true} expect([Function anonymous]).not.toEqual(Any<Function>) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Any<Function></>
Received:     <r>[Function anonymous]</>
`;

exports[`.toEqual() {pass: true} expect({"a": 1, "b": [Function b], "c": true}).not.toEqual({"a": 1, "b": Any<Function>, "c": Anything}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>{"a": 1, "b": Any<Function>, "c": Anything}</>
Received:     <r>{"a": 1, "b": [Function b], "c": true}</>
`;

exports[`.toEqual() {pass: true} expect({"a": 1, "b": 2}).not.toEqual(ObjectContaining {"a": 1}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>ObjectContaining {"a": 1}</>
Received:     <r>{"a": 1, "b": 2}</>
`;

exports[`.toEqual() {pass: true} expect({"a": 99}).not.toEqual({"a": 99}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>{"a": 99}</>

`;

exports[`.toEqual() {pass: true} expect({"nodeName": "div", "nodeType": 1}).not.toEqual({"nodeName": "div", "nodeType": 1}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>{"nodeName": "div", "nodeType": 1}</>

`;

exports[`.toEqual() {pass: true} expect({}).not.toEqual({}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>{}</>

`;

exports[`.toEqual() {pass: true} expect({}).not.toEqual({}) 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>{}</>

`;

exports[`.toEqual() {pass: true} expect({Symbol(foo): 1, Symbol(bar): 2}).not.toEqual({Symbol(foo): Any<Number>, Symbol(bar): 2}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>{Symbol(foo): Any<Number>, Symbol(bar): 2}</>
Received:     <r>{Symbol(foo): 1, Symbol(bar): 2}</>
`;

exports[`.toEqual() {pass: true} expect(0).not.toEqual(0) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>0</>

`;

exports[`.toEqual() {pass: true} expect(0).not.toEqual(0) 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>0</>

`;

exports[`.toEqual() {pass: true} expect(1).not.toEqual(1) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>1</>

`;

exports[`.toEqual() {pass: true} expect(Immutable.List [1, 2]).not.toEqual(Immutable.List [1, 2]) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Immutable.List [1, 2]</>

`;

exports[`.toEqual() {pass: true} expect(Immutable.List [1]).not.toEqual(Immutable.List [1]) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Immutable.List [1]</>

`;

exports[`.toEqual() {pass: true} expect(Immutable.Map {"1": Immutable.Map {"2": {"a": 99}}}).not.toEqual(Immutable.Map {"1": Immutable.Map {"2": {"a": 99}}}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Immutable.Map {"1": Immutable.Map {"2": {"a": 99}}}</>

`;

exports[`.toEqual() {pass: true} expect(Immutable.Map {}).not.toEqual(Immutable.Map {}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Immutable.Map {}</>

`;

exports[`.toEqual() {pass: true} expect(Immutable.Map {1: "one", 2: "two"}).not.toEqual(Immutable.Map {1: "one", 2: "two"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Immutable.Map {1: "one", 2: "two"}</>

`;

exports[`.toEqual() {pass: true} expect(Immutable.Map {1: "one", 2: "two"}).not.toEqual(Immutable.Map {2: "two", 1: "one"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Immutable.Map {2: "two", 1: "one"}</>
Received:     <r>Immutable.Map {1: "one", 2: "two"}</>
`;

exports[`.toEqual() {pass: true} expect(Immutable.OrderedMap {1: "one", 2: "two"}).not.toEqual(Immutable.OrderedMap {1: "one", 2: "two"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Immutable.OrderedMap {1: "one", 2: "two"}</>

`;

exports[`.toEqual() {pass: true} expect(Immutable.OrderedSet []).not.toEqual(Immutable.OrderedSet []) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Immutable.OrderedSet []</>

`;

exports[`.toEqual() {pass: true} expect(Immutable.OrderedSet [1, 2]).not.toEqual(Immutable.OrderedSet [1, 2]) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Immutable.OrderedSet [1, 2]</>

`;

exports[`.toEqual() {pass: true} expect(Immutable.Set []).not.toEqual(Immutable.Set []) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Immutable.Set []</>

`;

exports[`.toEqual() {pass: true} expect(Immutable.Set [1, 2]).not.toEqual(Immutable.Set [1, 2]) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Immutable.Set [1, 2]</>

`;

exports[`.toEqual() {pass: true} expect(Immutable.Set [1, 2]).not.toEqual(Immutable.Set [2, 1]) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Immutable.Set [2, 1]</>
Received:     <r>Immutable.Set [1, 2]</>
`;

exports[`.toEqual() {pass: true} expect(Map {[1] => "one", [2] => "two", [3] => "three", [3] => "four"}).not.toEqual(Map {[3] => "three", [3] => "four", [2] => "two", [1] => "one"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Map {[3] => "three", [3] => "four", [2] => "two", [1] => "one"}</>
Received:     <r>Map {[1] => "one", [2] => "two", [3] => "three", [3] => "four"}</>
`;

exports[`.toEqual() {pass: true} expect(Map {[1] => "one", [2] => "two"}).not.toEqual(Map {[2] => "two", [1] => "one"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Map {[2] => "two", [1] => "one"}</>
Received:     <r>Map {[1] => "one", [2] => "two"}</>
`;

exports[`.toEqual() {pass: true} expect(Map {[1] => Map {[1] => "one"}, [2] => Map {[2] => "two"}}).not.toEqual(Map {[2] => Map {[2] => "two"}, [1] => Map {[1] => "one"}}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Map {[2] => Map {[2] => "two"}, [1] => Map {[1] => "one"}}</>
Received:     <r>Map {[1] => Map {[1] => "one"}, [2] => Map {[2] => "two"}}</>
`;

exports[`.toEqual() {pass: true} expect(Map {{"a": 1} => "one", {"b": 2} => "two"}).not.toEqual(Map {{"b": 2} => "two", {"a": 1} => "one"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Map {{"b": 2} => "two", {"a": 1} => "one"}</>
Received:     <r>Map {{"a": 1} => "one", {"b": 2} => "two"}</>
`;

exports[`.toEqual() {pass: true} expect(Map {}).not.toEqual(Map {}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Map {}</>

`;

exports[`.toEqual() {pass: true} expect(Map {1 => "one", 2 => "two"}).not.toEqual(Map {1 => "one", 2 => "two"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Map {1 => "one", 2 => "two"}</>

`;

exports[`.toEqual() {pass: true} expect(Map {1 => "one", 2 => "two"}).not.toEqual(Map {2 => "two", 1 => "one"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Map {2 => "two", 1 => "one"}</>
Received:     <r>Map {1 => "one", 2 => "two"}</>
`;

exports[`.toEqual() {pass: true} expect(Map {1 => ["one"], 2 => ["two"]}).not.toEqual(Map {2 => ["two"], 1 => ["one"]}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Map {2 => ["two"], 1 => ["one"]}</>
Received:     <r>Map {1 => ["one"], 2 => ["two"]}</>
`;

exports[`.toEqual() {pass: true} expect(NaN).not.toEqual(NaN) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>NaN</>

`;

exports[`.toEqual() {pass: true} expect(Set {[1], [2], [3], [3]}).not.toEqual(Set {[3], [3], [2], [1]}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Set {[3], [3], [2], [1]}</>
Received:     <r>Set {[1], [2], [3], [3]}</>
`;

exports[`.toEqual() {pass: true} expect(Set {[1], [2]}).not.toEqual(Set {[2], [1]}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Set {[2], [1]}</>
Received:     <r>Set {[1], [2]}</>
`;

exports[`.toEqual() {pass: true} expect(Set {{"a": 1}, {"b": 2}}).not.toEqual(Set {{"b": 2}, {"a": 1}}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Set {{"b": 2}, {"a": 1}}</>
Received:     <r>Set {{"a": 1}, {"b": 2}}</>
`;

exports[`.toEqual() {pass: true} expect(Set {}).not.toEqual(Set {}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Set {}</>

`;

exports[`.toEqual() {pass: true} expect(Set {1, 2}).not.toEqual(Set {1, 2}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Set {1, 2}</>

`;

exports[`.toEqual() {pass: true} expect(Set {1, 2}).not.toEqual(Set {2, 1}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Set {2, 1}</>
Received:     <r>Set {1, 2}</>
`;

exports[`.toEqual() {pass: true} expect(Set {Set {[1]}, Set {[2]}}).not.toEqual(Set {Set {[2]}, Set {[1]}}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Set {Set {[2]}, Set {[1]}}</>
Received:     <r>Set {Set {[1]}, Set {[2]}}</>
`;

exports[`.toEqual() {pass: true} expect(true).not.toEqual(Anything) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>Anything</>
Received:     <r>true</>
`;

exports[`.toEqual() {pass: true} expect(true).not.toEqual(true) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>true</>

`;

exports[`.toHaveLength {pass: false} expect("").toHaveLength(1) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveLength<d>(</><g>expected</><d>)</>

Expected length: <g>1</>
Received length: <r>0</>
Received string: <r>""</>
`;

exports[`.toHaveLength {pass: false} expect("abc").toHaveLength(66) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveLength<d>(</><g>expected</><d>)</>

Expected length: <g>66</>
Received length: <r>3</>
Received string: <r>"abc"</>
`;

exports[`.toHaveLength {pass: false} expect(["a", "b"]).toHaveLength(99) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveLength<d>(</><g>expected</><d>)</>

Expected length: <g>99</>
Received length: <r>2</>
Received array:  <r>["a", "b"]</>
`;

exports[`.toHaveLength {pass: false} expect([]).toHaveLength(1) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveLength<d>(</><g>expected</><d>)</>

Expected length: <g>1</>
Received length: <r>0</>
Received array:  <r>[]</>
`;

exports[`.toHaveLength {pass: false} expect([1, 2]).toHaveLength(3) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveLength<d>(</><g>expected</><d>)</>

Expected length: <g>3</>
Received length: <r>2</>
Received array:  <r>[1, 2]</>
`;

exports[`.toHaveLength {pass: true} expect("").toHaveLength(0) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveLength<d>(</><g>expected</><d>)</>

Expected length: not <g>0</>
Received string:     <r>""</>
`;

exports[`.toHaveLength {pass: true} expect("abc").toHaveLength(3) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveLength<d>(</><g>expected</><d>)</>

Expected length: not <g>3</>
Received string:     <r>"abc"</>
`;

exports[`.toHaveLength {pass: true} expect(["a", "b"]).toHaveLength(2) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveLength<d>(</><g>expected</><d>)</>

Expected length: not <g>2</>
Received array:      <r>["a", "b"]</>
`;

exports[`.toHaveLength {pass: true} expect([]).toHaveLength(0) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveLength<d>(</><g>expected</><d>)</>

Expected length: not <g>0</>
Received array:      <r>[]</>
`;

exports[`.toHaveLength {pass: true} expect([1, 2]).toHaveLength(2) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveLength<d>(</><g>expected</><d>)</>

Expected length: not <g>2</>
Received array:      <r>[1, 2]</>
`;

exports[`.toHaveLength {pass: true} expect([Function anonymous]).toHaveLength(0) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveLength<d>(</><g>expected</><d>)</>

Expected length:   not <g>0</>
Received function:     <r>[Function anonymous]</>
`;

exports[`.toHaveLength error cases 1`] = `
<d>expect(</><r>received</><d>).</>toHaveLength<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must have a length property whose value must be a number

Received has type:  object
Received has value: <r>{"a": 9}</>
`;

exports[`.toHaveLength error cases 2`] = `
<d>expect(</><r>received</><d>).</>toHaveLength<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must have a length property whose value must be a number

Received has type:  number
Received has value: <r>0</>
`;

exports[`.toHaveLength error cases 3`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveLength<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must have a length property whose value must be a number

Received has value: <r>undefined</>
`;

exports[`.toHaveLength matcher error expected length not number 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveLength<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a non-negative integer

Expected has type:  string
Expected has value: <g>"3"</>
`;

exports[`.toHaveLength matcher error expected length number Infinity 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>toHaveLength<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a non-negative integer

Expected has type:  number
Expected has value: <g>Infinity</>
`;

exports[`.toHaveLength matcher error expected length number NaN 1`] = `
<d>expect(</><r>received</><d>).</>rejects<d>.</>not<d>.</>toHaveLength<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a non-negative integer

Expected has type:  number
Expected has value: <g>NaN</>
`;

exports[`.toHaveLength matcher error expected length number float 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>toHaveLength<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a non-negative integer

Expected has type:  number
Expected has value: <g>0.5</>
`;

exports[`.toHaveLength matcher error expected length number negative integer 1`] = `
<d>expect(</><r>received</><d>).</>resolves<d>.</>not<d>.</>toHaveLength<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a non-negative integer

Expected has type:  number
Expected has value: <g>-3</>
`;

exports[`.toHaveProperty() {error} expect({"a": {"b": {}}}).toHaveProperty('1') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

<b>Matcher error</>: <g>expected</> path must be a string or array

Expected has type:  number
Expected has value: <g>1</>
`;

exports[`.toHaveProperty() {error} expect({"a": {"b": {}}}).toHaveProperty('null') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

<b>Matcher error</>: <g>expected</> path must be a string or array

Expected has value: <g>null</>
`;

exports[`.toHaveProperty() {error} expect({"a": {"b": {}}}).toHaveProperty('undefined') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

<b>Matcher error</>: <g>expected</> path must be a string or array

Expected has value: <g>undefined</>
`;

exports[`.toHaveProperty() {error} expect({}).toHaveProperty('') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

<b>Matcher error</>: <g>expected</> path must not be an empty array

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

exports[`.toHaveProperty() {error} expect(null).toHaveProperty('a.b') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

<b>Matcher error</>: <r>received</> value must not be null nor undefined

Received has value: <r>null</>
`;

exports[`.toHaveProperty() {error} expect(undefined).toHaveProperty('a') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

<b>Matcher error</>: <r>received</> value must not be null nor undefined

Received has value: <r>undefined</>
`;

exports[`.toHaveProperty() {pass: false} expect("").toHaveProperty('key') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: <g>"key"</>
Received path: <r>[]</>

Received value: <r>""</>
`;

exports[`.toHaveProperty() {pass: false} expect("abc").toHaveProperty('a.b.c') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: <g>"a.b.c"</>
Received path: <r>[]</>

Received value: <r>"abc"</>
`;

exports[`.toHaveProperty() {pass: false} expect("abc").toHaveProperty('a.b.c', {"a": 5}) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b.c"</>
Received path: <r>[]</>

Expected value: <g>{"a": 5}</>
Received value: <r>"abc"</>
`;

exports[`.toHaveProperty() {pass: false} expect({"a": {"b": {"c": {"d": 1}}}}).toHaveProperty('a,b,c,d', 2) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>["a", "b", "c", "d"]</>

Expected value: <g>2</>
Received value: <r>1</>
`;

exports[`.toHaveProperty() {pass: false} expect({"a": {"b": {"c": {"d": 1}}}}).toHaveProperty('a.b.c.d', 2) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b.c.d"</>

Expected value: <g>2</>
Received value: <r>1</>
`;

exports[`.toHaveProperty() {pass: false} expect({"a": {"b": {"c": {"d": 1}}}}).toHaveProperty('a.b.ttt.d', 1) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b.ttt.d"</>
Received path: <r>"a.b"</>

Expected value: <g>1</>
Received value: <r>{"c": {"d": 1}}</>
`;

exports[`.toHaveProperty() {pass: false} expect({"a": {"b": {"c": {}}}}).toHaveProperty('a.b.c.d') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: <g>"a.b.c.d"</>
Received path: <r>"a.b.c"</>

Received value: <r>{}</>
`;

exports[`.toHaveProperty() {pass: false} expect({"a": {"b": {"c": {}}}}).toHaveProperty('a.b.c.d', 1) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b.c.d"</>
Received path: <r>"a.b.c"</>

Expected value: <g>1</>
Received value: <r>{}</>
`;

exports[`.toHaveProperty() {pass: false} expect({"a": {"b": {"c": 5}}}).toHaveProperty('a.b', {"c": 4}) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b"</>

<g>- Expected value  - 1</>
<r>+ Received value  + 1</>

<d>  Object {</>
<g>-   "c": 4,</>
<r>+   "c": 5,</>
<d>  }</>
`;

exports[`.toHaveProperty() {pass: false} expect({"a": {"b": 3}}).toHaveProperty('a.b', undefined) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b"</>

Expected value: <g>undefined</>
Received value: <r>3</>
`;

exports[`.toHaveProperty() {pass: false} expect({"a": 1}).toHaveProperty('a.b.c.d') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: <g>"a.b.c.d"</>
Received path: <r>"a"</>

Received value: <r>1</>
`;

exports[`.toHaveProperty() {pass: false} expect({"a": 1}).toHaveProperty('a.b.c.d', 5) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b.c.d"</>
Received path: <r>"a"</>

Expected value: <g>5</>
Received value: <r>1</>
`;

exports[`.toHaveProperty() {pass: false} expect({"a.b.c.d": 1}).toHaveProperty('a.b.c.d', 2) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b.c.d"</>
Received path: <r>[]</>

Expected value: <g>2</>
Received value: <r>{"a.b.c.d": 1}</>
`;

exports[`.toHaveProperty() {pass: false} expect({"a.b.c.d": 1}).toHaveProperty('a.b.c.d', 2) 2`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>["a.b.c.d"]</>

Expected value: <g>2</>
Received value: <r>1</>
`;

exports[`.toHaveProperty() {pass: false} expect({"children": ["\\"That cartoon\\""], "props": null, "type": "p"}).toHaveProperty('children,0', "\\"That cat cartoon\\"") 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>["children", 0]</>

Expected value: <g>"\\"That <i>cat </i>cartoon\\""</>
Received value: <r>"\\"That cartoon\\""</>
`;

exports[`.toHaveProperty() {pass: false} expect({"children": ["Roses are red.
Violets are blue.
Testing with Jest is good for you."], "props": null, "type": "pre"}).toHaveProperty('children,0', "Roses are red, violets are blue.
Testing with Jest
Is good for you.") 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>["children", 0]</>

<g>- Expected value  - 3</>
<r>+ Received value  + 3</>

<g>- Roses are red<i>, v</i>iolets are blue.</>
<r>+ Roses are red<i>.</i></>
<r>+ <i>V</i>iolets are blue.</>
<g>- Testing with Jest</>
<g>- <i>I</i>s good for you.</>
<r>+ Testing with Jest<i> i</i>s good for you.</>
`;

exports[`.toHaveProperty() {pass: false} expect({"key": 1}).toHaveProperty('not') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: <g>"not"</>
Received path: <r>[]</>

Received value: <r>{"key": 1}</>
`;

exports[`.toHaveProperty() {pass: false} expect({}).toHaveProperty('a') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: <g>"a"</>
Received path: <r>[]</>

Received value: <r>{}</>
`;

exports[`.toHaveProperty() {pass: false} expect({}).toHaveProperty('a', "a") 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a"</>

Expected value: <g>"a"</>
Received value: <r>undefined</>
`;

exports[`.toHaveProperty() {pass: false} expect({}).toHaveProperty('a', "test") 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a"</>
Received path: <r>[]</>

Expected value: <g>"test"</>
Received value: <r>{}</>
`;

exports[`.toHaveProperty() {pass: false} expect({}).toHaveProperty('b', undefined) 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"b"</>

Expected value: <g>undefined</>
Received value: <r>"b"</>
`;

exports[`.toHaveProperty() {pass: false} expect(0).toHaveProperty('key') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: <g>"key"</>
Received path: <r>[]</>

Received value: <r>0</>
`;

exports[`.toHaveProperty() {pass: false} expect(1).toHaveProperty('a.b.c') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: <g>"a.b.c"</>
Received path: <r>[]</>

Received value: <r>1</>
`;

exports[`.toHaveProperty() {pass: false} expect(1).toHaveProperty('a.b.c', "test") 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b.c"</>
Received path: <r>[]</>

Expected value: <g>"test"</>
Received value: <r>1</>
`;

exports[`.toHaveProperty() {pass: false} expect(Symbol()).toHaveProperty('key') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: <g>"key"</>
Received path: <r>[]</>

Received value: <r>Symbol()</>
`;

exports[`.toHaveProperty() {pass: false} expect(false).toHaveProperty('key') 1`] = `
<d>expect(</><r>received</><d>).</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: <g>"key"</>
Received path: <r>[]</>

Received value: <r>false</>
`;

exports[`.toHaveProperty() {pass: true} expect("").toHaveProperty('length', 0) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"length"</>

Expected value: not <g>0</>
`;

exports[`.toHaveProperty() {pass: true} expect([Function memoized]).toHaveProperty('memo', []) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"memo"</>

Expected value: not <g>[]</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": {"b": [1, 2, 3]}}).toHaveProperty('a,b,1') 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: not <g>["a", "b", 1]</>

Received value: <r>2</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": {"b": [1, 2, 3]}}).toHaveProperty('a,b,1', 2) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>["a", "b", 1]</>

Expected value: not <g>2</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": {"b": [1, 2, 3]}}).toHaveProperty('a,b,1', Any<Number>) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>["a", "b", 1]</>

Expected value: not <g>Any<Number></>
Received value:     <r>2</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": {"b": {"c": {"d": 1}}}}).toHaveProperty('a,b,c,d') 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: not <g>["a", "b", "c", "d"]</>

Received value: <r>1</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": {"b": {"c": {"d": 1}}}}).toHaveProperty('a,b,c,d', 1) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>["a", "b", "c", "d"]</>

Expected value: not <g>1</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": {"b": {"c": {"d": 1}}}}).toHaveProperty('a.b.c.d') 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: not <g>"a.b.c.d"</>

Received value: <r>1</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": {"b": {"c": {"d": 1}}}}).toHaveProperty('a.b.c.d', 1) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b.c.d"</>

Expected value: not <g>1</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": {"b": {"c": 5}}}).toHaveProperty('a.b', {"c": 5}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b"</>

Expected value: not <g>{"c": 5}</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": {"b": undefined}}).toHaveProperty('a.b') 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: not <g>"a.b"</>

Received value: <r>undefined</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": {"b": undefined}}).toHaveProperty('a.b', undefined) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b"</>

Expected value: not <g>undefined</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": {}}).toHaveProperty('a.b', undefined) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a.b"</>
Received path: <r>"a"</>

Expected value: not <g>undefined</>
Received value:     <r>{}</>

<d>Because a positive assertion passes for expected value undefined if the property does not exist, this negative assertion fails unless the property does exist and has a defined value</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": 0}).toHaveProperty('a') 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: not <g>"a"</>

Received value: <r>0</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a": 0}).toHaveProperty('a', 0) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a"</>

Expected value: not <g>0</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a.b.c.d": 1}).toHaveProperty('a.b.c.d') 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>)</>

Expected path: not <g>["a.b.c.d"]</>

Received value: <r>1</>
`;

exports[`.toHaveProperty() {pass: true} expect({"a.b.c.d": 1}).toHaveProperty('a.b.c.d', 1) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>["a.b.c.d"]</>

Expected value: not <g>1</>
`;

exports[`.toHaveProperty() {pass: true} expect({"nodeName": "DIV"}).toHaveProperty('nodeType', 1) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"nodeType"</>

Expected value: not <g>1</>
`;

exports[`.toHaveProperty() {pass: true} expect({"property": 1}).toHaveProperty('property', 1) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"property"</>

Expected value: not <g>1</>
`;

exports[`.toHaveProperty() {pass: true} expect({"val": true}).toHaveProperty('a', undefined) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a"</>

Expected value: not <g>undefined</>
`;

exports[`.toHaveProperty() {pass: true} expect({"val": true}).toHaveProperty('c', "c") 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"c"</>

Expected value: not <g>"c"</>
`;

exports[`.toHaveProperty() {pass: true} expect({"val": true}).toHaveProperty('val', true) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"val"</>

Expected value: not <g>true</>
`;

exports[`.toHaveProperty() {pass: true} expect({}).toHaveProperty('a', undefined) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"a"</>

Expected value: not <g>undefined</>
`;

exports[`.toHaveProperty() {pass: true} expect({}).toHaveProperty('b', "b") 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"b"</>

Expected value: not <g>"b"</>
`;

exports[`.toHaveProperty() {pass: true} expect({}).toHaveProperty('setter', undefined) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toHaveProperty<d>(</><g>path</><d>, </><g>value</><d>)</>

Expected path: <g>"setter"</>

Expected value: not <g>undefined</>
`;

exports[`.toMatch() {pass: true} expect(Foo bar).toMatch(/^foo/i) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatch<d>(</><g>expected</><d>)</>

Expected pattern: not <g>/^foo/i</>
Received string:      <r>"<i>Foo</i> bar"</>
`;

exports[`.toMatch() {pass: true} expect(foo).toMatch(foo) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatch<d>(</><g>expected</><d>)</>

Expected substring: not <g>"foo"</>
Received string:        <r>"<i>foo</i>"</>
`;

exports[`.toMatch() throws if non String actual value passed: [/foo/i, "foo"] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a string

Received has type:  regexp
Received has value: <r>/foo/i</>
`;

exports[`.toMatch() throws if non String actual value passed: [[], "foo"] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a string

Received has type:  array
Received has value: <r>[]</>
`;

exports[`.toMatch() throws if non String actual value passed: [[Function anonymous], "foo"] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a string

Received has type:  function
Received has value: <r>[Function anonymous]</>
`;

exports[`.toMatch() throws if non String actual value passed: [{}, "foo"] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a string

Received has type:  object
Received has value: <r>{}</>
`;

exports[`.toMatch() throws if non String actual value passed: [1, "foo"] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a string

Received has type:  number
Received has value: <r>1</>
`;

exports[`.toMatch() throws if non String actual value passed: [true, "foo"] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a string

Received has type:  boolean
Received has value: <r>true</>
`;

exports[`.toMatch() throws if non String actual value passed: [undefined, "foo"] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a string

Received has value: <r>undefined</>
`;

exports[`.toMatch() throws if non String/RegExp expected value passed: ["foo", []] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a string or regular expression

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

exports[`.toMatch() throws if non String/RegExp expected value passed: ["foo", [Function anonymous]] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a string or regular expression

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

exports[`.toMatch() throws if non String/RegExp expected value passed: ["foo", {}] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a string or regular expression

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

exports[`.toMatch() throws if non String/RegExp expected value passed: ["foo", 1] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a string or regular expression

Expected has type:  number
Expected has value: <g>1</>
`;

exports[`.toMatch() throws if non String/RegExp expected value passed: ["foo", true] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a string or regular expression

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

exports[`.toMatch() throws if non String/RegExp expected value passed: ["foo", undefined] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a string or regular expression

Expected has value: <g>undefined</>
`;

exports[`.toMatch() throws: [bar, /foo/] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

Expected pattern: <g>/foo/</>
Received string:  <r>"bar"</>
`;

exports[`.toMatch() throws: [bar, foo] 1`] = `
<d>expect(</><r>received</><d>).</>toMatch<d>(</><g>expected</><d>)</>

Expected substring: <g>"foo"</>
Received string:    <r>"bar"</>
`;

exports[`.toStrictEqual() displays substring diff 1`] = `
<d>expect(</><r>received</><d>).</>toStrictEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: <g>"<i>Another caveat is that</i> Jest will not typecheck your tests."</>
Received: <r>"<i>Because TypeScript support in Babel is just transpilation,</i> Jest will not type<i>-</i>check your tests<i> as they run</i>."</>
`;

exports[`.toStrictEqual() displays substring diff for multiple lines 1`] = `
<d>expect(</><r>received</><d>).</>toStrictEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 7</>
<r>+ Received  + 7</>

<g>-     6<i>9</i> |<Y> </></>
<r>+     6<i>8</i> |<Y> </></>
<g>-     <i>70</i> | test('assert.doesNotThrow', () => {</>
<r>+     <i>69</i> | test('assert.doesNotThrow', () => {</>
<g>-   > 7<i>1</i> |   assert.doesNotThrow(() => {</>
<r>+   > 7<i>0</i> |   assert.doesNotThrow(() => {</>
<d>         |          ^</>
<g>-     7<i>2</i> |     throw Error('err!');</>
<r>+     7<i>1</i> |     throw Error('err!');</>
<g>-     7<i>3</i> |   });</>
<r>+     7<i>2</i> |   });</>
<g>-     7<i>4</i> | });</>
<r>+     7<i>3</i> | });</>
<g>-     at Object.doesNotThrow (__tests__/assertionError.test.js:7<i>1</i>:10)</>
<r>+     at Object.doesNotThrow (__tests__/assertionError.test.js:7<i>0</i>:10)</>
`;

exports[`.toStrictEqual() matches the expected snapshot when it fails 1`] = `
<d>expect(</><r>received</><d>).</>toStrictEqual<d>(</><g>expected</><d>) // deep equality</>

<g>- Expected  - 4</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "test": TestClassA {</>
<g>-     "a": 1,</>
<g>-     "b": 2,</>
<g>-   },</>
<r>+   "test": 2,</>
<d>  }</>
`;

exports[`.toStrictEqual() matches the expected snapshot when it fails 2`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toStrictEqual<d>(</><g>expected</><d>) // deep equality</>

Expected: not <g>{"test": {"a": 1, "b": 2}}</>

`;

exports[`toMatchObject() {pass: false} expect([0]).toMatchObject([-0]) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Array [</>
<g>-   -0,</>
<r>+   0,</>
<d>  ]</>
`;

exports[`toMatchObject() {pass: false} expect([1, 2, 3]).toMatchObject([1, 2, 2]) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Array [</>
<d>    1,</>
<d>    2,</>
<g>-   2,</>
<r>+   3,</>
<d>  ]</>
`;

exports[`toMatchObject() {pass: false} expect([1, 2, 3]).toMatchObject([2, 3, 1]) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Array [</>
<r>+   1,</>
<d>    2,</>
<d>    3,</>
<g>-   1,</>
<d>  ]</>
`;

exports[`toMatchObject() {pass: false} expect([1, 2]).toMatchObject([1, 3]) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Array [</>
<d>    1,</>
<g>-   3,</>
<r>+   2,</>
<d>  ]</>
`;

exports[`toMatchObject() {pass: false} expect([Error: foo]).toMatchObject([Error: bar]) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: <g>[Error: bar]</>
Received: <r>[Error: foo]</>
`;

exports[`toMatchObject() {pass: false} expect({"a": "a", "c": "d"}).toMatchObject({"a": Any<Number>}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": Any<Number>,</>
<r>+   "a": "a",</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": "b", "c": "d", Symbol(jest): "jest"}).toMatchObject({"a": "c", Symbol(jest): Any<String>}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 2</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": "c",</>
<g>-   Symbol(jest): Any<String>,</>
<r>+   "a": "b",</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": "b", "c": "d"}).toMatchObject({"a": "b!", "c": "d"}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": "b!",</>
<r>+   "a": "b",</>
<d>    "c": "d",</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": "b", "c": "d"}).toMatchObject({"e": "b"}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 2</>

<d>  Object {</>
<g>-   "e": "b",</>
<r>+   "a": "b",</>
<r>+   "c": "d",</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": "b", "t": {"x": {"r": "r"}, "z": "z"}}).toMatchObject({"a": "b", "t": {"z": [3]}}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 3</>
<r>+ Received  + 1</>

<d>  Object {</>
<d>    "a": "b",</>
<d>    "t": Object {</>
<g>-     "z": Array [</>
<g>-       3,</>
<g>-     ],</>
<r>+     "z": "z",</>
<d>    },</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": "b", "t": {"x": {"r": "r"}, "z": "z"}}).toMatchObject({"t": {"l": {"r": "r"}}}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 2</>

<d>  Object {</>
<d>    "t": Object {</>
<g>-     "l": Object {</>
<r>+     "x": Object {</>
<d>        "r": "r",</>
<d>      },</>
<r>+     "z": "z",</>
<d>    },</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": "b"}).toMatchObject({"c": "d"}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "c": "d",</>
<r>+   "a": "b",</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": [{"a": "a", "b": "b"}]}).toMatchObject({"a": [{"a": "c"}]}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<d>    "a": Array [</>
<d>      Object {</>
<g>-       "a": "c",</>
<r>+       "a": "a",</>
<d>      },</>
<d>    ],</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": [3, 4, "v"], "b": "b"}).toMatchObject({"a": ["v"]}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 0</>
<r>+ Received  + 2</>

<d>  Object {</>
<d>    "a": Array [</>
<r>+     3,</>
<r>+     4,</>
<d>      "v",</>
<d>    ],</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": [3, 4, 5], "b": "b"}).toMatchObject({"a": [3, 4, 5, 6]}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 0</>

<d>  Object {</>
<d>    "a": Array [</>
<d>      3,</>
<d>      4,</>
<d>      5,</>
<g>-     6,</>
<d>    ],</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": [3, 4, 5], "b": "b"}).toMatchObject({"a": [3, 4]}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 0</>
<r>+ Received  + 1</>

<d>  Object {</>
<d>    "a": Array [</>
<d>      3,</>
<d>      4,</>
<r>+     5,</>
<d>    ],</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": [3, 4, 5], "b": "b"}).toMatchObject({"a": {"b": 4}}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 3</>
<r>+ Received  + 5</>

<d>  Object {</>
<g>-   "a": Object {</>
<g>-     "b": 4,</>
<g>-   },</>
<r>+   "a": Array [</>
<r>+     3,</>
<r>+     4,</>
<r>+     5,</>
<r>+   ],</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": [3, 4, 5], "b": "b"}).toMatchObject({"a": {"b": Any<String>}}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 3</>
<r>+ Received  + 5</>

<d>  Object {</>
<g>-   "a": Object {</>
<g>-     "b": Any<String>,</>
<g>-   },</>
<r>+   "a": Array [</>
<r>+     3,</>
<r>+     4,</>
<r>+     5,</>
<r>+   ],</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": 1, "b": 1, "c": 1, "d": {"e": {"f": 555}}}).toMatchObject({"d": {"e": {"f": 222}}}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<d>    "d": Object {</>
<d>      "e": Object {</>
<g>-       "f": 222,</>
<r>+       "f": 555,</>
<d>      },</>
<d>    },</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": 2015-11-30T00:00:00.000Z, "b": "b"}).toMatchObject({"a": 2015-10-10T00:00:00.000Z}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": 2015-10-10T00:00:00.000Z,</>
<r>+   "a": 2015-11-30T00:00:00.000Z,</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": null, "b": "b"}).toMatchObject({"a": "4"}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": "4",</>
<r>+   "a": null,</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": null, "b": "b"}).toMatchObject({"a": undefined}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": undefined,</>
<r>+   "a": null,</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({"a": undefined}).toMatchObject({"a": null}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": null,</>
<r>+   "a": undefined,</>
<d>  }</>
`;

exports[`toMatchObject() {pass: false} expect({}).toMatchObject({"a": undefined}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 3</>
<r>+ Received  + 1</>

<g>- Object {</>
<g>-   "a": undefined,</>
<g>- }</>
<r>+ Object {}</>
`;

exports[`toMatchObject() {pass: false} expect(2015-11-30T00:00:00.000Z).toMatchObject(2015-10-10T00:00:00.000Z) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: <g>2015-10-10T00:00:00.000Z</>
Received: <r>2015-11-30T00:00:00.000Z</>
`;

exports[`toMatchObject() {pass: false} expect(Set {1, 2}).toMatchObject(Set {2}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 0</>
<r>+ Received  + 1</>

<d>  Set {</>
<r>+   1,</>
<d>    2,</>
<d>  }</>
`;

exports[`toMatchObject() {pass: true} expect([]).toMatchObject([]) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>[]</>
`;

exports[`toMatchObject() {pass: true} expect([1, 2]).toMatchObject([1, 2]) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>[1, 2]</>
`;

exports[`toMatchObject() {pass: true} expect([Error: bar]).toMatchObject({"message": "bar"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"message": "bar"}</>
Received:     <r>[Error: bar]</>
`;

exports[`toMatchObject() {pass: true} expect([Error: foo]).toMatchObject([Error: foo]) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>[Error: foo]</>
`;

exports[`toMatchObject() {pass: true} expect({"a": "b", "c": "d", Symbol(jest): "jest"}).toMatchObject({"a": "b", "c": "d", Symbol(jest): "jest"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": "b", "c": "d", Symbol(jest): "jest"}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": "b", "c": "d", Symbol(jest): "jest"}).toMatchObject({"a": "b", Symbol(jest): "jest"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": "b", Symbol(jest): "jest"}</>
Received:     <r>{"a": "b", "c": "d", Symbol(jest): "jest"}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": "b", "c": "d"}).toMatchObject({"a": "b", "c": "d"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": "b", "c": "d"}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": "b", "c": "d"}).toMatchObject({"a": "b"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": "b"}</>
Received:     <r>{"a": "b", "c": "d"}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": "b", "t": {"x": {"r": "r"}, "z": "z"}}).toMatchObject({"a": "b", "t": {"z": "z"}}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": "b", "t": {"z": "z"}}</>
Received:     <r>{"a": "b", "t": {"x": {"r": "r"}, "z": "z"}}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": "b", "t": {"x": {"r": "r"}, "z": "z"}}).toMatchObject({"t": {"x": {"r": "r"}}}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"t": {"x": {"r": "r"}}}</>
Received:     <r>{"a": "b", "t": {"x": {"r": "r"}, "z": "z"}}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": "b"}).toMatchObject({"a": "b"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": "b"}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": [{"a": "a", "b": "b"}]}).toMatchObject({"a": [{"a": "a"}]}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": [{"a": "a"}]}</>
Received:     <r>{"a": [{"a": "a", "b": "b"}]}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": [3, 4, 5, "v"], "b": "b"}).toMatchObject({"a": [3, 4, 5, "v"]}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": [3, 4, 5, "v"]}</>
Received:     <r>{"a": [3, 4, 5, "v"], "b": "b"}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": [3, 4, 5], "b": "b"}).toMatchObject({"a": [3, 4, 5]}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": [3, 4, 5]}</>
Received:     <r>{"a": [3, 4, 5], "b": "b"}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": {"x": "x", "y": "y"}}).toMatchObject({"a": {"x": Any<String>}}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": {"x": Any<String>}}</>
Received:     <r>{"a": {"x": "x", "y": "y"}}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": 1, "c": 2}).toMatchObject({"a": Any<Number>}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": Any<Number>}</>
Received:     <r>{"a": 1, "c": 2}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": 2015-11-30T00:00:00.000Z, "b": "b"}).toMatchObject({"a": 2015-11-30T00:00:00.000Z}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": 2015-11-30T00:00:00.000Z}</>
Received:     <r>{"a": 2015-11-30T00:00:00.000Z, "b": "b"}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": null, "b": "b"}).toMatchObject({"a": null}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": null}</>
Received:     <r>{"a": null, "b": "b"}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": undefined, "b": "b"}).toMatchObject({"a": undefined}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": undefined}</>
Received:     <r>{"a": undefined, "b": "b"}</>
`;

exports[`toMatchObject() {pass: true} expect({"a": undefined}).toMatchObject({"a": undefined}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": undefined}</>
`;

exports[`toMatchObject() {pass: true} expect({}).toMatchObject({"a": undefined, "b": "b"}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": undefined, "b": "b"}</>
Received:     <r>{}</>
`;

exports[`toMatchObject() {pass: true} expect(2015-11-30T00:00:00.000Z).toMatchObject(2015-11-30T00:00:00.000Z) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>2015-11-30T00:00:00.000Z</>
`;

exports[`toMatchObject() {pass: true} expect(Set {1, 2}).toMatchObject(Set {1, 2}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>Set {1, 2}</>
`;

exports[`toMatchObject() {pass: true} expect(Set {1, 2}).toMatchObject(Set {2, 1}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>Set {2, 1}</>
Received:     <r>Set {1, 2}</>
`;

exports[`toMatchObject() circular references simple circular references {pass: false} expect({"a": "hello", "ref": [Circular]}).toMatchObject({"a": "world", "ref": [Circular]}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": "world",</>
<r>+   "a": "hello",</>
<d>    "ref": [Circular],</>
<d>  }</>
`;

exports[`toMatchObject() circular references simple circular references {pass: false} expect({"ref": "not a ref"}).toMatchObject({"a": "hello", "ref": [Circular]}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 2</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": "hello",</>
<g>-   "ref": [Circular],</>
<r>+   "ref": "not a ref",</>
<d>  }</>
`;

exports[`toMatchObject() circular references simple circular references {pass: false} expect({}).toMatchObject({"a": "hello", "ref": [Circular]}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 4</>
<r>+ Received  + 1</>

<g>- Object {</>
<g>-   "a": "hello",</>
<g>-   "ref": [Circular],</>
<g>- }</>
<r>+ Object {}</>
`;

exports[`toMatchObject() circular references simple circular references {pass: true} expect({"a": "hello", "ref": [Circular]}).toMatchObject({"a": "hello", "ref": [Circular]}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": "hello", "ref": [Circular]}</>
`;

exports[`toMatchObject() circular references simple circular references {pass: true} expect({"a": "hello", "ref": [Circular]}).toMatchObject({}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{}</>
Received:     <r>{"a": "hello", "ref": [Circular]}</>
`;

exports[`toMatchObject() circular references transitive circular references {pass: false} expect({"a": "world", "nestedObj": {"parentObj": [Circular]}}).toMatchObject({"a": "hello", "nestedObj": {"parentObj": [Circular]}}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": "hello",</>
<r>+   "a": "world",</>
<d>    "nestedObj": Object {</>
<d>      "parentObj": [Circular],</>
<d>    },</>
<d>  }</>
`;

exports[`toMatchObject() circular references transitive circular references {pass: false} expect({"nestedObj": {"parentObj": "not the parent ref"}}).toMatchObject({"a": "hello", "nestedObj": {"parentObj": [Circular]}}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 2</>
<r>+ Received  + 1</>

<d>  Object {</>
<g>-   "a": "hello",</>
<d>    "nestedObj": Object {</>
<g>-     "parentObj": [Circular],</>
<r>+     "parentObj": "not the parent ref",</>
<d>    },</>
<d>  }</>
`;

exports[`toMatchObject() circular references transitive circular references {pass: false} expect({}).toMatchObject({"a": "hello", "nestedObj": {"parentObj": [Circular]}}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 6</>
<r>+ Received  + 1</>

<g>- Object {</>
<g>-   "a": "hello",</>
<g>-   "nestedObj": Object {</>
<g>-     "parentObj": [Circular],</>
<g>-   },</>
<g>- }</>
<r>+ Object {}</>
`;

exports[`toMatchObject() circular references transitive circular references {pass: true} expect({"a": "hello", "nestedObj": {"parentObj": [Circular]}}).toMatchObject({"a": "hello", "nestedObj": {"parentObj": [Circular]}}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{"a": "hello", "nestedObj": {"parentObj": [Circular]}}</>
`;

exports[`toMatchObject() circular references transitive circular references {pass: true} expect({"a": "hello", "nestedObj": {"parentObj": [Circular]}}).toMatchObject({}) 1`] = `
<d>expect(</><r>received</><d>).</>not<d>.</>toMatchObject<d>(</><g>expected</><d>)</>

Expected: not <g>{}</>
Received:     <r>{"a": "hello", "nestedObj": {"parentObj": [Circular]}}</>
`;

exports[`toMatchObject() does not match properties up in the prototype chain 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<g>- Expected  - 1</>
<r>+ Received  + 0</>

<d>  Object {</>
<d>    "other": "child",</>
<g>-   "ref": [Circular],</>
<d>  }</>
`;

exports[`toMatchObject() throws expect("44").toMatchObject({}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a non-null object

Received has type:  string
Received has value: <r>"44"</>
`;

exports[`toMatchObject() throws expect({}).toMatchObject("some string") 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a non-null object

Expected has type:  string
Expected has value: <g>"some string"</>
`;

exports[`toMatchObject() throws expect({}).toMatchObject(4) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a non-null object

Expected has type:  number
Expected has value: <g>4</>
`;

exports[`toMatchObject() throws expect({}).toMatchObject(null) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a non-null object

Expected has value: <g>null</>
`;

exports[`toMatchObject() throws expect({}).toMatchObject(true) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a non-null object

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

exports[`toMatchObject() throws expect({}).toMatchObject(undefined) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <g>expected</> value must be a non-null object

Expected has value: <g>undefined</>
`;

exports[`toMatchObject() throws expect(4).toMatchObject({}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a non-null object

Received has type:  number
Received has value: <r>4</>
`;

exports[`toMatchObject() throws expect(null).toMatchObject({}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a non-null object

Received has value: <r>null</>
`;

exports[`toMatchObject() throws expect(true).toMatchObject({}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a non-null object

Received has type:  boolean
Received has value: <r>true</>
`;

exports[`toMatchObject() throws expect(undefined).toMatchObject({}) 1`] = `
<d>expect(</><r>received</><d>).</>toMatchObject<d>(</><g>expected</><d>)</>

<b>Matcher error</>: <r>received</> value must be a non-null object

Received has value: <r>undefined</>
`;