diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5cb720fb984c..9efb72ecf5a0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -90,6 +90,7 @@
 - `[jest-config]` Use strings instead of `RegExp` instances in normalized configuration ([#7251](https://github.com/facebook/jest/pull/7251))
 - `[jest-circus]` Make sure to display real duration even if time is mocked ([#7264](https://github.com/facebook/jest/pull/7264))
 - `[expect]` Improves the failing message for `toStrictEqual` matcher. ([#7224](https://github.com/facebook/jest/pull/7224))
+- `[expect]` Improves the failing message for `toEqual` matcher. ([#7325](https://github.com/facebook/jest/pull/7325))
 - `[jest-resolve]` Fix not being able to resolve path to mapped file with custom platform ([#7312](https://github.com/facebook/jest/pull/7312))
 - `[jest-message-util]` Improve parsing of error messages for unusually formatted stack traces ([#7319](https://github.com/facebook/jest/pull/7319))
 - `[jest-runtime]` Ensure error message text is not lost on errors with code frames ([#7319](https://github.com/facebook/jest/pull/7319))
diff --git a/e2e/__tests__/__snapshots__/failures.test.js.snap b/e2e/__tests__/__snapshots__/failures.test.js.snap
index 467a8bd7a448..4c00d72b044f 100644
--- a/e2e/__tests__/__snapshots__/failures.test.js.snap
+++ b/e2e/__tests__/__snapshots__/failures.test.js.snap
@@ -272,10 +272,8 @@ exports[`works with assertions in separate files 1`] = `
 
     expect(received).toEqual(expected)
 
-    Expected value to equal:
-      2
-    Received:
-      1
+    Expected: 2
+    Received: 1
 
       10 | 
       11 | module.exports = (one: any, two: any) => {
@@ -302,11 +300,6 @@ exports[`works with async failures 1`] = `
 
     expect(received).toEqual(expected)
 
-    Expected value to equal:
-      {\\"baz\\": \\"bar\\"}
-    Received:
-      {\\"foo\\": \\"bar\\"}
-
     Difference:
 
     - Expected
@@ -331,11 +324,6 @@ exports[`works with async failures 1`] = `
 
     expect(received).toEqual(expected)
 
-    Expected value to equal:
-      {\\"baz\\": \\"bar\\"}
-    Received:
-      {\\"foo\\": \\"bar\\"}
-
     Difference:
 
     - Expected
diff --git a/packages/expect/src/__tests__/__snapshots__/extend.test.js.snap b/packages/expect/src/__tests__/__snapshots__/extend.test.js.snap
index 73440c1c56ea..fa8c8daae7bc 100644
--- a/packages/expect/src/__tests__/__snapshots__/extend.test.js.snap
+++ b/packages/expect/src/__tests__/__snapshots__/extend.test.js.snap
@@ -3,11 +3,6 @@
 exports[`defines asymmetric unary matchers 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>{\\"value\\": toBeDivisibleBy<2>}</>
-Received:
-  <red>{\\"value\\": 3}</>
-
 Difference:
 
 <green>- Expected</>
@@ -22,11 +17,6 @@ Difference:
 exports[`defines asymmetric unary matchers that can be prefixed by not 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>{\\"value\\": not.toBeDivisibleBy<2>}</>
-Received:
-  <red>{\\"value\\": 2}</>
-
 Difference:
 
 <green>- Expected</>
@@ -41,11 +31,6 @@ Difference:
 exports[`defines asymmetric variadic matchers 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>{\\"value\\": toBeWithinRange<4, 11>}</>
-Received:
-  <red>{\\"value\\": 3}</>
-
 Difference:
 
 <green>- Expected</>
@@ -60,11 +45,6 @@ Difference:
 exports[`defines asymmetric variadic matchers that can be prefixed by not 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>{\\"value\\": not.toBeWithinRange<1, 3>}</>
-Received:
-  <red>{\\"value\\": 2}</>
-
 Difference:
 
 <green>- Expected</>
diff --git a/packages/expect/src/__tests__/__snapshots__/matchers.test.js.snap b/packages/expect/src/__tests__/__snapshots__/matchers.test.js.snap
index 19fe16e74e51..4be8e0d6e1ed 100644
--- a/packages/expect/src/__tests__/__snapshots__/matchers.test.js.snap
+++ b/packages/expect/src/__tests__/__snapshots__/matchers.test.js.snap
@@ -1711,103 +1711,83 @@ Received has value: <red>null</>"
 `;
 
 exports[`.toEqual() {pass: false} expect("Alice").not.toEqual({"asymmetricMatch": [Function asymmetricMatch]}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>{\\"asymmetricMatch\\": [Function asymmetricMatch]}</>
-Received:
-  <red>\\"Alice\\"</>"
+Expected: <green>{\\"asymmetricMatch\\": [Function asymmetricMatch]}</>
+Received: <red>\\"Alice\\"</>"
 `;
 
 exports[`.toEqual() {pass: false} expect("Eve").toEqual({"asymmetricMatch": [Function asymmetricMatch]}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>{\\"asymmetricMatch\\": [Function asymmetricMatch]}</>
-Received:
-  <red>\\"Eve\\"</>"
+Expected: <green>{\\"asymmetricMatch\\": [Function asymmetricMatch]}</>
+Received: <red>\\"Eve\\"</>"
 `;
 
 exports[`.toEqual() {pass: false} expect("abc").not.toEqual("abc") 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>\\"abc\\"</>
-Received:
-  <red>\\"abc\\"</>"
+Expected: <green>\\"abc\\"</>
+Received: <red>\\"abc\\"</>"
 `;
 
 exports[`.toEqual() {pass: false} expect("abcd").not.toEqual(StringContaining "bc") 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>StringContaining \\"bc\\"</>
-Received:
-  <red>\\"abcd\\"</>"
+Expected: <green>StringContaining \\"bc\\"</>
+Received: <red>\\"abcd\\"</>"
 `;
 
 exports[`.toEqual() {pass: false} expect("abcd").not.toEqual(StringMatching /bc/) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>StringMatching /bc/</>
-Received:
-  <red>\\"abcd\\"</>"
+Expected: <green>StringMatching /bc/</>
+Received: <red>\\"abcd\\"</>"
 `;
 
 exports[`.toEqual() {pass: false} expect("abd").toEqual(StringContaining "bc") 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>StringContaining \\"bc\\"</>
-Received:
-  <red>\\"abd\\"</>"
+Expected: <green>StringContaining \\"bc\\"</>
+Received: <red>\\"abd\\"</>"
 `;
 
 exports[`.toEqual() {pass: false} expect("abd").toEqual(StringMatching /bc/i) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>StringMatching /bc/i</>
-Received:
-  <red>\\"abd\\"</>"
+Expected: <green>StringMatching /bc/i</>
+Received: <red>\\"abd\\"</>"
 `;
 
 exports[`.toEqual() {pass: false} expect("banana").toEqual("apple") 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>\\"apple\\"</>
-Received:
-  <red>\\"banana\\"</>"
+Difference:
+
+<green>- Expected</>
+<red>+ Received</>
+
+<green>- apple</>
+<red>+ banana</>"
 `;
 
 exports[`.toEqual() {pass: false} expect([1, 2, 3]).not.toEqual(ArrayContaining [2, 3]) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>ArrayContaining [2, 3]</>
-Received:
-  <red>[1, 2, 3]</>"
+Expected: <green>ArrayContaining [2, 3]</>
+Received: <red>[1, 2, 3]</>"
 `;
 
 exports[`.toEqual() {pass: false} expect([1, 2]).not.toEqual([1, 2]) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>[1, 2]</>
-Received:
-  <red>[1, 2]</>"
+Expected: <green>[1, 2]</>
+Received: <red>[1, 2]</>"
 `;
 
 exports[`.toEqual() {pass: false} expect([1, 2]).toEqual([2, 1]) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>[2, 1]</>
-Received:
-  <red>[1, 2]</>
-
 Difference:
 
 <green>- Expected</>
@@ -1823,11 +1803,6 @@ Difference:
 exports[`.toEqual() {pass: false} expect([1, 3]).toEqual(ArrayContaining [1, 2]) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>ArrayContaining [1, 2]</>
-Received:
-  <red>[1, 3]</>
-
 Difference:
 
 <green>- Expected</>
@@ -1842,22 +1817,15 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect([1]).not.toEqual([1]) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>[1]</>
-Received:
-  <red>[1]</>"
+Expected: <green>[1]</>
+Received: <red>[1]</>"
 `;
 
 exports[`.toEqual() {pass: false} expect([1]).toEqual([2]) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>[2]</>
-Received:
-  <red>[1]</>
-
 Difference:
 
 <green>- Expected</>
@@ -1870,40 +1838,29 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect([Function anonymous]).not.toEqual(Any<Function>) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Any<Function></>
-Received:
-  <red>[Function anonymous]</>"
+Expected: <green>Any<Function></>
+Received: <red>[Function anonymous]</>"
 `;
 
 exports[`.toEqual() {pass: false} expect({"a": 1, "b": [Function b], "c": true}).not.toEqual({"a": 1, "b": Any<Function>, "c": Anything}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>{\\"a\\": 1, \\"b\\": Any<Function>, \\"c\\": Anything}</>
-Received:
-  <red>{\\"a\\": 1, \\"b\\": [Function b], \\"c\\": true}</>"
+Expected: <green>{\\"a\\": 1, \\"b\\": Any<Function>, \\"c\\": Anything}</>
+Received: <red>{\\"a\\": 1, \\"b\\": [Function b], \\"c\\": true}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect({"a": 1, "b": 2}).not.toEqual(ObjectContaining {"a": 1}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>ObjectContaining {\\"a\\": 1}</>
-Received:
-  <red>{\\"a\\": 1, \\"b\\": 2}</>"
+Expected: <green>ObjectContaining {\\"a\\": 1}</>
+Received: <red>{\\"a\\": 1, \\"b\\": 2}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect({"a": 1, "b": 2}).toEqual(ObjectContaining {"a": 2}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>ObjectContaining {\\"a\\": 2}</>
-Received:
-  <red>{\\"a\\": 1, \\"b\\": 2}</>
-
 Difference:
 
 <green>- Expected</>
@@ -1920,11 +1877,6 @@ Difference:
 exports[`.toEqual() {pass: false} expect({"a": 5}).toEqual({"b": 6}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>{\\"b\\": 6}</>
-Received:
-  <red>{\\"a\\": 5}</>
-
 Difference:
 
 <green>- Expected</>
@@ -1937,22 +1889,15 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect({"a": 99}).not.toEqual({"a": 99}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>{\\"a\\": 99}</>
-Received:
-  <red>{\\"a\\": 99}</>"
+Expected: <green>{\\"a\\": 99}</>
+Received: <red>{\\"a\\": 99}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect({"target": {"nodeType": 1, "value": "a"}}).toEqual({"target": {"nodeType": 1, "value": "b"}}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>{\\"target\\": {\\"nodeType\\": 1, \\"value\\": \\"b\\"}}</>
-Received:
-  <red>{\\"target\\": {\\"nodeType\\": 1, \\"value\\": \\"a\\"}}</>
-
 Difference:
 
 <green>- Expected</>
@@ -1968,75 +1913,50 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect({}).not.toEqual({}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>{}</>
-Received:
-  <red>{}</>"
+Expected: <green>{}</>
+Received: <red>{}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(0).toEqual(-0) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>-0</>
-Received:
-  <red>0</>
-
-Difference:
-
-<dim>Compared values have no visual difference.</>"
+Expected: <green>-0</>
+Received: <red>0</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(1).not.toEqual(1) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>1</>
-Received:
-  <red>1</>"
+Expected: <green>1</>
+Received: <red>1</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(1).toEqual(2) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>2</>
-Received:
-  <red>1</>"
+Expected: <green>2</>
+Received: <red>1</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(1).toEqual(ArrayContaining [1, 2]) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>ArrayContaining [1, 2]</>
-Received:
-  <red>1</>
-
-Difference:
-
-  Comparing two different types of values. Expected <green>array</> but received <red>number</>."
+Expected: <green>ArrayContaining [1, 2]</>
+Received: <red>1</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.List [1, 2]).not.toEqual(Immutable.List [1, 2]) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Immutable.List [1, 2]</>
-Received:
-  <red>Immutable.List [1, 2]</>"
+Expected: <green>Immutable.List [1, 2]</>
+Received: <red>Immutable.List [1, 2]</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.List [1, 2]).toEqual(Immutable.List [2, 1]) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Immutable.List [2, 1]</>
-Received:
-  <red>Immutable.List [1, 2]</>
-
 Difference:
 
 <green>- Expected</>
@@ -2050,22 +1970,15 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.List [1]).not.toEqual(Immutable.List [1]) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Immutable.List [1]</>
-Received:
-  <red>Immutable.List [1]</>"
+Expected: <green>Immutable.List [1]</>
+Received: <red>Immutable.List [1]</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.List [1]).toEqual(Immutable.List [2]) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Immutable.List [2]</>
-Received:
-  <red>Immutable.List [1]</>
-
 Difference:
 
 <green>- Expected</>
@@ -2078,22 +1991,15 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.Map {"1": Immutable.Map {"2": {"a": 99}}}).not.toEqual(Immutable.Map {"1": Immutable.Map {"2": {"a": 99}}}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Immutable.Map {\\"1\\": Immutable.Map {\\"2\\": {\\"a\\": 99}}}</>
-Received:
-  <red>Immutable.Map {\\"1\\": Immutable.Map {\\"2\\": {\\"a\\": 99}}}</>"
+Expected: <green>Immutable.Map {\\"1\\": Immutable.Map {\\"2\\": {\\"a\\": 99}}}</>
+Received: <red>Immutable.Map {\\"1\\": Immutable.Map {\\"2\\": {\\"a\\": 99}}}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.Map {"1": Immutable.Map {"2": {"a": 99}}}).toEqual(Immutable.Map {"1": Immutable.Map {"2": {"a": 11}}}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Immutable.Map {\\"1\\": Immutable.Map {\\"2\\": {\\"a\\": 11}}}</>
-Received:
-  <red>Immutable.Map {\\"1\\": Immutable.Map {\\"2\\": {\\"a\\": 99}}}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2112,11 +2018,6 @@ Difference:
 exports[`.toEqual() {pass: false} expect(Immutable.Map {"a": 0}).toEqual(Immutable.Map {"b": 0}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Immutable.Map {\\"b\\": 0}</>
-Received:
-  <red>Immutable.Map {\\"a\\": 0}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2131,11 +2032,6 @@ Difference:
 exports[`.toEqual() {pass: false} expect(Immutable.Map {"v": 1}).toEqual(Immutable.Map {"v": 2}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Immutable.Map {\\"v\\": 2}</>
-Received:
-  <red>Immutable.Map {\\"v\\": 1}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2148,49 +2044,36 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.Map {}).not.toEqual(Immutable.Map {}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Immutable.Map {}</>
-Received:
-  <red>Immutable.Map {}</>"
+Expected: <green>Immutable.Map {}</>
+Received: <red>Immutable.Map {}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.Map {1: "one", 2: "two"}).not.toEqual(Immutable.Map {1: "one", 2: "two"}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Immutable.Map {1: \\"one\\", 2: \\"two\\"}</>
-Received:
-  <red>Immutable.Map {1: \\"one\\", 2: \\"two\\"}</>"
+Expected: <green>Immutable.Map {1: \\"one\\", 2: \\"two\\"}</>
+Received: <red>Immutable.Map {1: \\"one\\", 2: \\"two\\"}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.Map {1: "one", 2: "two"}).not.toEqual(Immutable.Map {2: "two", 1: "one"}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Immutable.Map {2: \\"two\\", 1: \\"one\\"}</>
-Received:
-  <red>Immutable.Map {1: \\"one\\", 2: \\"two\\"}</>"
+Expected: <green>Immutable.Map {2: \\"two\\", 1: \\"one\\"}</>
+Received: <red>Immutable.Map {1: \\"one\\", 2: \\"two\\"}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.OrderedMap {1: "one", 2: "two"}).not.toEqual(Immutable.OrderedMap {1: "one", 2: "two"}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Immutable.OrderedMap {1: \\"one\\", 2: \\"two\\"}</>
-Received:
-  <red>Immutable.OrderedMap {1: \\"one\\", 2: \\"two\\"}</>"
+Expected: <green>Immutable.OrderedMap {1: \\"one\\", 2: \\"two\\"}</>
+Received: <red>Immutable.OrderedMap {1: \\"one\\", 2: \\"two\\"}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.OrderedMap {1: "one", 2: "two"}).toEqual(Immutable.OrderedMap {2: "two", 1: "one"}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Immutable.OrderedMap {2: \\"two\\", 1: \\"one\\"}</>
-Received:
-  <red>Immutable.OrderedMap {1: \\"one\\", 2: \\"two\\"}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2204,31 +2087,22 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.OrderedSet []).not.toEqual(Immutable.OrderedSet []) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Immutable.OrderedSet []</>
-Received:
-  <red>Immutable.OrderedSet []</>"
+Expected: <green>Immutable.OrderedSet []</>
+Received: <red>Immutable.OrderedSet []</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.OrderedSet [1, 2]).not.toEqual(Immutable.OrderedSet [1, 2]) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Immutable.OrderedSet [1, 2]</>
-Received:
-  <red>Immutable.OrderedSet [1, 2]</>"
+Expected: <green>Immutable.OrderedSet [1, 2]</>
+Received: <red>Immutable.OrderedSet [1, 2]</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.OrderedSet [1, 2]).toEqual(Immutable.OrderedSet [2, 1]) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Immutable.OrderedSet [2, 1]</>
-Received:
-  <red>Immutable.OrderedSet [1, 2]</>
-
 Difference:
 
 <green>- Expected</>
@@ -2242,40 +2116,29 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.Set []).not.toEqual(Immutable.Set []) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Immutable.Set []</>
-Received:
-  <red>Immutable.Set []</>"
+Expected: <green>Immutable.Set []</>
+Received: <red>Immutable.Set []</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.Set [1, 2]).not.toEqual(Immutable.Set [1, 2]) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Immutable.Set [1, 2]</>
-Received:
-  <red>Immutable.Set [1, 2]</>"
+Expected: <green>Immutable.Set [1, 2]</>
+Received: <red>Immutable.Set [1, 2]</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.Set [1, 2]).not.toEqual(Immutable.Set [2, 1]) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Immutable.Set [2, 1]</>
-Received:
-  <red>Immutable.Set [1, 2]</>"
+Expected: <green>Immutable.Set [2, 1]</>
+Received: <red>Immutable.Set [1, 2]</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Immutable.Set [1, 2]).toEqual(Immutable.Set []) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Immutable.Set []</>
-Received:
-  <red>Immutable.Set [1, 2]</>
-
 Difference:
 
 <green>- Expected</>
@@ -2291,11 +2154,6 @@ Difference:
 exports[`.toEqual() {pass: false} expect(Immutable.Set [1, 2]).toEqual(Immutable.Set [1, 2, 3]) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Immutable.Set [1, 2, 3]</>
-Received:
-  <red>Immutable.Set [1, 2]</>
-
 Difference:
 
 <green>- Expected</>
@@ -2311,11 +2169,6 @@ Difference:
 exports[`.toEqual() {pass: false} expect(Map {"a" => 0}).toEqual(Map {"b" => 0}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Map {\\"b\\" => 0}</>
-Received:
-  <red>Map {\\"a\\" => 0}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2330,11 +2183,6 @@ Difference:
 exports[`.toEqual() {pass: false} expect(Map {"v" => 1}).toEqual(Map {"v" => 2}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Map {\\"v\\" => 2}</>
-Received:
-  <red>Map {\\"v\\" => 1}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2349,11 +2197,6 @@ Difference:
 exports[`.toEqual() {pass: false} expect(Map {["v"] => 1}).toEqual(Map {["v"] => 2}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Map {[\\"v\\"] => 2}</>
-Received:
-  <red>Map {[\\"v\\"] => 1}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2368,40 +2211,29 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect(Map {[1] => "one", [2] => "two", [3] => "three", [3] => "four"}).not.toEqual(Map {[3] => "three", [3] => "four", [2] => "two", [1] => "one"}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Map {[3] => \\"three\\", [3] => \\"four\\", [2] => \\"two\\", [1] => \\"one\\"}</>
-Received:
-  <red>Map {[1] => \\"one\\", [2] => \\"two\\", [3] => \\"three\\", [3] => \\"four\\"}</>"
+Expected: <green>Map {[3] => \\"three\\", [3] => \\"four\\", [2] => \\"two\\", [1] => \\"one\\"}</>
+Received: <red>Map {[1] => \\"one\\", [2] => \\"two\\", [3] => \\"three\\", [3] => \\"four\\"}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Map {[1] => "one", [2] => "two"}).not.toEqual(Map {[2] => "two", [1] => "one"}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Map {[2] => \\"two\\", [1] => \\"one\\"}</>
-Received:
-  <red>Map {[1] => \\"one\\", [2] => \\"two\\"}</>"
+Expected: <green>Map {[2] => \\"two\\", [1] => \\"one\\"}</>
+Received: <red>Map {[1] => \\"one\\", [2] => \\"two\\"}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Map {[1] => Map {[1] => "one"}, [2] => Map {[2] => "two"}}).not.toEqual(Map {[2] => Map {[2] => "two"}, [1] => Map {[1] => "one"}}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Map {[2] => Map {[2] => \\"two\\"}, [1] => Map {[1] => \\"one\\"}}</>
-Received:
-  <red>Map {[1] => Map {[1] => \\"one\\"}, [2] => Map {[2] => \\"two\\"}}</>"
+Expected: <green>Map {[2] => Map {[2] => \\"two\\"}, [1] => Map {[1] => \\"one\\"}}</>
+Received: <red>Map {[1] => Map {[1] => \\"one\\"}, [2] => Map {[2] => \\"two\\"}}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Map {[1] => Map {[1] => "one"}}).toEqual(Map {[1] => Map {[1] => "two"}}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Map {[1] => Map {[1] => \\"two\\"}}</>
-Received:
-  <red>Map {[1] => Map {[1] => \\"one\\"}}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2420,62 +2252,43 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect(Map {{"a": 1} => "one", {"b": 2} => "two"}).not.toEqual(Map {{"b": 2} => "two", {"a": 1} => "one"}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Map {{\\"b\\": 2} => \\"two\\", {\\"a\\": 1} => \\"one\\"}</>
-Received:
-  <red>Map {{\\"a\\": 1} => \\"one\\", {\\"b\\": 2} => \\"two\\"}</>"
+Expected: <green>Map {{\\"b\\": 2} => \\"two\\", {\\"a\\": 1} => \\"one\\"}</>
+Received: <red>Map {{\\"a\\": 1} => \\"one\\", {\\"b\\": 2} => \\"two\\"}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Map {}).not.toEqual(Map {}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Map {}</>
-Received:
-  <red>Map {}</>"
+Expected: <green>Map {}</>
+Received: <red>Map {}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Map {}).toEqual(Set {}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Set {}</>
-Received:
-  <red>Map {}</>
-
-Difference:
-
-  Comparing two different types of values. Expected <green>set</> but received <red>map</>."
+Expected: <green>Set {}</>
+Received: <red>Map {}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Map {1 => "one", 2 => "two"}).not.toEqual(Map {1 => "one", 2 => "two"}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Map {1 => \\"one\\", 2 => \\"two\\"}</>
-Received:
-  <red>Map {1 => \\"one\\", 2 => \\"two\\"}</>"
+Expected: <green>Map {1 => \\"one\\", 2 => \\"two\\"}</>
+Received: <red>Map {1 => \\"one\\", 2 => \\"two\\"}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Map {1 => "one", 2 => "two"}).not.toEqual(Map {2 => "two", 1 => "one"}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Map {2 => \\"two\\", 1 => \\"one\\"}</>
-Received:
-  <red>Map {1 => \\"one\\", 2 => \\"two\\"}</>"
+Expected: <green>Map {2 => \\"two\\", 1 => \\"one\\"}</>
+Received: <red>Map {1 => \\"one\\", 2 => \\"two\\"}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Map {1 => "one", 2 => "two"}).toEqual(Map {1 => "one"}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Map {1 => \\"one\\"}</>
-Received:
-  <red>Map {1 => \\"one\\", 2 => \\"two\\"}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2488,40 +2301,29 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect(Map {1 => ["one"], 2 => ["two"]}).not.toEqual(Map {2 => ["two"], 1 => ["one"]}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Map {2 => [\\"two\\"], 1 => [\\"one\\"]}</>
-Received:
-  <red>Map {1 => [\\"one\\"], 2 => [\\"two\\"]}</>"
+Expected: <green>Map {2 => [\\"two\\"], 1 => [\\"one\\"]}</>
+Received: <red>Map {1 => [\\"one\\"], 2 => [\\"two\\"]}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Set {[1], [2], [3], [3]}).not.toEqual(Set {[3], [3], [2], [1]}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Set {[3], [3], [2], [1]}</>
-Received:
-  <red>Set {[1], [2], [3], [3]}</>"
+Expected: <green>Set {[3], [3], [2], [1]}</>
+Received: <red>Set {[1], [2], [3], [3]}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Set {[1], [2]}).not.toEqual(Set {[2], [1]}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Set {[2], [1]}</>
-Received:
-  <red>Set {[1], [2]}</>"
+Expected: <green>Set {[2], [1]}</>
+Received: <red>Set {[1], [2]}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Set {[1], [2]}).toEqual(Set {[1], [2], [2]}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Set {[1], [2], [2]}</>
-Received:
-  <red>Set {[1], [2]}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2542,11 +2344,6 @@ Difference:
 exports[`.toEqual() {pass: false} expect(Set {[1], [2]}).toEqual(Set {[1], [2], [3]}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Set {[1], [2], [3]}</>
-Received:
-  <red>Set {[1], [2]}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2565,49 +2362,36 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect(Set {{"a": 1}, {"b": 2}}).not.toEqual(Set {{"b": 2}, {"a": 1}}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Set {{\\"b\\": 2}, {\\"a\\": 1}}</>
-Received:
-  <red>Set {{\\"a\\": 1}, {\\"b\\": 2}}</>"
+Expected: <green>Set {{\\"b\\": 2}, {\\"a\\": 1}}</>
+Received: <red>Set {{\\"a\\": 1}, {\\"b\\": 2}}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Set {}).not.toEqual(Set {}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Set {}</>
-Received:
-  <red>Set {}</>"
+Expected: <green>Set {}</>
+Received: <red>Set {}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Set {1, 2}).not.toEqual(Set {1, 2}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Set {1, 2}</>
-Received:
-  <red>Set {1, 2}</>"
+Expected: <green>Set {1, 2}</>
+Received: <red>Set {1, 2}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Set {1, 2}).not.toEqual(Set {2, 1}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Set {2, 1}</>
-Received:
-  <red>Set {1, 2}</>"
+Expected: <green>Set {2, 1}</>
+Received: <red>Set {1, 2}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Set {1, 2}).toEqual(Set {}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Set {}</>
-Received:
-  <red>Set {1, 2}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2623,11 +2407,6 @@ Difference:
 exports[`.toEqual() {pass: false} expect(Set {1, 2}).toEqual(Set {1, 2, 3}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Set {1, 2, 3}</>
-Received:
-  <red>Set {1, 2}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2641,22 +2420,15 @@ Difference:
 `;
 
 exports[`.toEqual() {pass: false} expect(Set {Set {[1]}, Set {[2]}}).not.toEqual(Set {Set {[2]}, Set {[1]}}) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Set {Set {[2]}, Set {[1]}}</>
-Received:
-  <red>Set {Set {[1]}, Set {[2]}}</>"
+Expected: <green>Set {Set {[2]}, Set {[1]}}</>
+Received: <red>Set {Set {[1]}, Set {[2]}}</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(Set {Set {1}, Set {2}}).toEqual(Set {Set {1}, Set {3}}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Set {Set {1}, Set {3}}</>
-Received:
-  <red>Set {Set {1}, Set {2}}</>
-
 Difference:
 
 <green>- Expected</>
@@ -2676,76 +2448,71 @@ Difference:
 exports[`.toEqual() {pass: false} expect(false).toEqual(ObjectContaining {"a": 2}) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>ObjectContaining {\\"a\\": 2}</>
-Received:
-  <red>false</>
-
-Difference:
-
-  Comparing two different types of values. Expected <green>object</> but received <red>boolean</>."
+Expected: <green>ObjectContaining {\\"a\\": 2}</>
+Received: <red>false</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(null).toEqual(undefined) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>undefined</>
-Received:
-  <red>null</>
-
-Difference:
-
-  Comparing two different types of values. Expected <green>undefined</> but received <red>null</>."
+Expected: <green>undefined</>
+Received: <red>null</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(true).not.toEqual(Anything) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>Anything</>
-Received:
-  <red>true</>"
+Expected: <green>Anything</>
+Received: <red>true</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(true).not.toEqual(true) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toEqual(</><green>expected</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
 
-Expected value to not equal:
-  <green>true</>
-Received:
-  <red>true</>"
+Expected: <green>true</>
+Received: <red>true</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(true).toEqual(false) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>false</>
-Received:
-  <red>true</>"
+Expected: <green>false</>
+Received: <red>true</>"
 `;
 
 exports[`.toEqual() {pass: false} expect(undefined).toEqual(Any<Function>) 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Any<Function></>
-Received:
-  <red>undefined</>
+Expected: <green>Any<Function></>
+Received: <red>undefined</>"
+`;
 
-Difference:
+exports[`.toEqual() {pass: false} expect(undefined).toEqual(Anything) 1`] = `
+"<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-  Comparing two different types of values. Expected <green>function</> but received <red>undefined</>."
+Expected: <green>Anything</>
+Received: <red>undefined</>"
 `;
 
-exports[`.toEqual() {pass: false} expect(undefined).toEqual(Anything) 1`] = `
+exports[`.toEqual() failure message matches the expected snapshot 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>Anything</>
-Received:
-  <red>undefined</>"
+Difference:
+
+<green>- Expected</>
+<red>+ Received</>
+
+<dim>  Object {</>
+<green>-   \\"a\\": 2,</>
+<red>+   \\"a\\": 1,</>
+<dim>  }</>"
+`;
+
+exports[`.toEqual() failure message matches the expected snapshot 2`] = `
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toEqual(</><green>expected</><dim>)</>
+
+Expected: <green>{\\"a\\": 1}</>
+Received: <red>{\\"a\\": 1}</>"
 `;
 
 exports[`.toHaveLength {pass: false} expect("").toHaveLength(1) 1`] = `
diff --git a/packages/expect/src/__tests__/matchers.test.js b/packages/expect/src/__tests__/matchers.test.js
index 15c1f9c62c56..321220daa061 100644
--- a/packages/expect/src/__tests__/matchers.test.js
+++ b/packages/expect/src/__tests__/matchers.test.js
@@ -500,6 +500,16 @@ describe('.toEqual()', () => {
     }
   });
 
+  test('failure message matches the expected snapshot', () => {
+    expect(() =>
+      jestExpect({a: 1}).toEqual({a: 2}),
+    ).toThrowErrorMatchingSnapshot();
+
+    expect(() =>
+      jestExpect({a: 1}).not.toEqual({a: 1}),
+    ).toThrowErrorMatchingSnapshot();
+  });
+
   test('symbol based keys in arrays are processed correctly', () => {
     const mySymbol = Symbol('test');
     const actual1 = [];
diff --git a/packages/expect/src/matchers.js b/packages/expect/src/matchers.js
index eb2609442f43..4e68a4ee2849 100644
--- a/packages/expect/src/matchers.js
+++ b/packages/expect/src/matchers.js
@@ -384,24 +384,24 @@ const matchers: MatchersObject = {
 
     const message = pass
       ? () =>
-          matcherHint('.not.toEqual') +
+          matcherHint('.toEqual', undefined, undefined, {
+            isNot: this.isNot,
+          }) +
           '\n\n' +
-          `Expected value to not equal:\n` +
-          `  ${printExpected(expected)}\n` +
-          `Received:\n` +
-          `  ${printReceived(received)}`
+          `Expected: ${printExpected(expected)}\n` +
+          `Received: ${printReceived(received)}`
       : () => {
-          const oneline = isOneline(expected, received);
           const diffString = diff(expected, received, {expand: this.expand});
 
           return (
-            matcherHint('.toEqual') +
+            matcherHint('.toEqual', undefined, undefined, {
+              isNot: this.isNot,
+            }) +
             '\n\n' +
-            `Expected value to equal:\n` +
-            `  ${printExpected(expected)}\n` +
-            `Received:\n` +
-            `  ${printReceived(received)}` +
-            (diffString && !oneline ? `\n\nDifference:\n\n${diffString}` : '')
+            (diffString && diffString.includes('- Expect')
+              ? `Difference:\n\n${diffString}`
+              : `Expected: ${printExpected(expected)}\n` +
+                `Received: ${printReceived(received)}`)
           );
         };
 
diff --git a/packages/jest-matcher-utils/src/__tests__/__snapshots__/index.test.js.snap b/packages/jest-matcher-utils/src/__tests__/__snapshots__/index.test.js.snap
index fb80b64d1896..68b90892609a 100644
--- a/packages/jest-matcher-utils/src/__tests__/__snapshots__/index.test.js.snap
+++ b/packages/jest-matcher-utils/src/__tests__/__snapshots__/index.test.js.snap
@@ -43,11 +43,6 @@ exports[`.stringify() reduces maxDepth if stringifying very large objects 2`] =
 exports[`.stringify() toJSON errors when comparing two objects 1`] = `
 "<dim>expect(</><red>received</><dim>).toEqual(</><green>expected</><dim>)</>
 
-Expected value to equal:
-  <green>{\\"b\\": 1, \\"toJSON\\": [Function toJSON]}</>
-Received:
-  <red>{\\"a\\": 1, \\"toJSON\\": [Function toJSON]}</>
-
 Difference:
 
 <green>- Expected</>