diff --git a/CHANGELOG.md b/CHANGELOG.md
index 66062e923d47..60c67811be0f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -26,6 +26,7 @@
 - `[jest-snapshot]` Enable configurable snapshot paths ([#6143](https://github.com/facebook/jest/pull/6143))
 - `[pretty-format]` Support HTMLCollection and NodeList in DOMCollection plugin ([#7125](https://github.com/facebook/jest/pull/7125))
 - `[jest-runtime]` Pass the normalized configuration to script transformers ([#7148](https://github.com/facebook/jest/pull/7148))
+- `[expect]` Improve report when assertion fails, part 3 ([#7152](https://github.com/facebook/jest/pull/7152))
 - `[jest-runtime]` If `require` fails without a file extension, print all files that match with one ([#7160](https://github.com/facebook/jest/pull/7160))
 - `[jest-haste-map]` Make `ignorePattern` optional ([#7166](https://github.com/facebook/jest/pull/7166))
 - `[jest-haste-map]` Add `getCacheFilePath` to get the path to the cache file for a `HasteMap` instance ([#7217](https://github.com/facebook/jest/pull/7217))
diff --git a/packages/expect/src/__tests__/__snapshots__/matchers.test.js.snap b/packages/expect/src/__tests__/__snapshots__/matchers.test.js.snap
index f1503dbd4ff4..19fe16e74e51 100644
--- a/packages/expect/src/__tests__/__snapshots__/matchers.test.js.snap
+++ b/packages/expect/src/__tests__/__snapshots__/matchers.test.js.snap
@@ -396,136 +396,136 @@ exports[`.toBeCloseTo() {pass: false} expect(-Infinity)toBeCloseTo( -1.23) 1`] =
 "<dim>expect(</><red>received</><dim>).toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>-1.23</>
-Received: <red>-Infinity</>"
+Expected:  <green>-1.23</>
+Received:  <red>-Infinity</>"
 `;
 
 exports[`.toBeCloseTo() {pass: false} expect(Infinity)toBeCloseTo( -Infinity) 1`] = `
 "<dim>expect(</><red>received</><dim>).toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>-Infinity</>
-Received: <red>Infinity</>"
+Expected:  <green>-Infinity</>
+Received:  <red>Infinity</>"
 `;
 
 exports[`.toBeCloseTo() {pass: false} expect(Infinity)toBeCloseTo( 1.23) 1`] = `
 "<dim>expect(</><red>received</><dim>).toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>1.23</>
-Received: <red>Infinity</>"
+Expected:  <green>1.23</>
+Received:  <red>Infinity</>"
 `;
 
 exports[`.toBeCloseTo() {pass: true} expect(-Infinity)toBeCloseTo( -Infinity) 1`] = `
 "<dim>expect(</><red>received</><dim>).</>not<dim>.toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>-Infinity</>
-Received: <red>-Infinity</>"
+Expected:  <green>-Infinity</>
+Received:  <red>-Infinity</>"
 `;
 
 exports[`.toBeCloseTo() {pass: true} expect(0)toBeCloseTo( 0) 1`] = `
 "<dim>expect(</><red>received</><dim>).</>not<dim>.toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>0</>
-Received: <red>0</>"
+Expected:  <green>0</>
+Received:  <red>0</>"
 `;
 
 exports[`.toBeCloseTo() {pass: true} expect(0)toBeCloseTo( 0.001) 1`] = `
 "<dim>expect(</><red>received</><dim>).</>not<dim>.toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>0.001</>
-Received: <red>0</>"
+Expected:  <green>0.001</>
+Received:  <red>0</>"
 `;
 
 exports[`.toBeCloseTo() {pass: true} expect(1.23)toBeCloseTo( 1.225) 1`] = `
 "<dim>expect(</><red>received</><dim>).</>not<dim>.toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>1.225</>
-Received: <red>1.23</>"
+Expected:  <green>1.225</>
+Received:  <red>1.23</>"
 `;
 
 exports[`.toBeCloseTo() {pass: true} expect(1.23)toBeCloseTo( 1.226) 1`] = `
 "<dim>expect(</><red>received</><dim>).</>not<dim>.toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>1.226</>
-Received: <red>1.23</>"
+Expected:  <green>1.226</>
+Received:  <red>1.23</>"
 `;
 
 exports[`.toBeCloseTo() {pass: true} expect(1.23)toBeCloseTo( 1.229) 1`] = `
 "<dim>expect(</><red>received</><dim>).</>not<dim>.toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>1.229</>
-Received: <red>1.23</>"
+Expected:  <green>1.229</>
+Received:  <red>1.23</>"
 `;
 
 exports[`.toBeCloseTo() {pass: true} expect(1.23)toBeCloseTo( 1.234) 1`] = `
 "<dim>expect(</><red>received</><dim>).</>not<dim>.toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>1.234</>
-Received: <red>1.23</>"
+Expected:  <green>1.234</>
+Received:  <red>1.23</>"
 `;
 
 exports[`.toBeCloseTo() {pass: true} expect(Infinity)toBeCloseTo( Infinity) 1`] = `
 "<dim>expect(</><red>received</><dim>).</>not<dim>.toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>Infinity</>
-Received: <red>Infinity</>"
+Expected:  <green>Infinity</>
+Received:  <red>Infinity</>"
 `;
 
 exports[`.toBeCloseTo() accepts an optional precision argument: [0, 0.000004, 5] 1`] = `
 "<dim>expect(</><red>received</><dim>).</>not<dim>.toBeCloseTo(</><green>expected</><dim>, </><green>precision</><dim>)</>
 
 Precision: <green>5</>-digit
-Expected: <green>0.000004</>
-Received: <red>0</>"
+Expected:  <green>0.000004</>
+Received:  <red>0</>"
 `;
 
 exports[`.toBeCloseTo() accepts an optional precision argument: [0, 0.0001, 3] 1`] = `
 "<dim>expect(</><red>received</><dim>).</>not<dim>.toBeCloseTo(</><green>expected</><dim>, </><green>precision</><dim>)</>
 
 Precision: <green>3</>-digit
-Expected: <green>0.0001</>
-Received: <red>0</>"
+Expected:  <green>0.0001</>
+Received:  <red>0</>"
 `;
 
 exports[`.toBeCloseTo() accepts an optional precision argument: [0, 0.1, 0] 1`] = `
 "<dim>expect(</><red>received</><dim>).</>not<dim>.toBeCloseTo(</><green>expected</><dim>, </><green>precision</><dim>)</>
 
 Precision: <green>0</>-digit
-Expected: <green>0.1</>
-Received: <red>0</>"
+Expected:  <green>0.1</>
+Received:  <red>0</>"
 `;
 
 exports[`.toBeCloseTo() throws: [0, 0.01] 1`] = `
 "<dim>expect(</><red>received</><dim>).toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>0.01</>
-Received: <red>0</>"
+Expected:  <green>0.01</>
+Received:  <red>0</>"
 `;
 
 exports[`.toBeCloseTo() throws: [1, 1.23] 1`] = `
 "<dim>expect(</><red>received</><dim>).toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>1.23</>
-Received: <red>1</>"
+Expected:  <green>1.23</>
+Received:  <red>1</>"
 `;
 
 exports[`.toBeCloseTo() throws: [1.23, 1.2249999] 1`] = `
 "<dim>expect(</><red>received</><dim>).toBeCloseTo(</><green>expected</><dim>)</>
 
 Precision: <green>2</>-digit
-Expected: <green>1.2249999</>
-Received: <red>1.23</>"
+Expected:  <green>1.2249999</>
+Received:  <red>1.23</>"
 `;
 
 exports[`.toBeDefined(), .toBeUndefined() '"a"' is defined 1`] = `
@@ -1537,222 +1537,161 @@ Expected has value: <green>null</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '"11112111"' contains '"2"' 1`] = `
-"<dim>expect(</><red>string</><dim>).not.toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>string</><dim>).</>not<dim>.toContain(</><green>value</><dim>) // indexOf</>
 
-Expected string:
-  <red>\\"11112111\\"</>
-Not to contain value:
-  <green>\\"2\\"</>
-"
+Expected value:  <green>\\"2\\"</>
+Received string: <red>\\"11112111\\"</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '"abcdef"' contains '"abc"' 1`] = `
-"<dim>expect(</><red>string</><dim>).not.toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>string</><dim>).</>not<dim>.toContain(</><green>value</><dim>) // indexOf</>
 
-Expected string:
-  <red>\\"abcdef\\"</>
-Not to contain value:
-  <green>\\"abc\\"</>
-"
+Expected value:  <green>\\"abc\\"</>
+Received string: <red>\\"abcdef\\"</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '["a", "b", "c", "d"]' contains '"a"' 1`] = `
-"<dim>expect(</><red>array</><dim>).not.toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).</>not<dim>.toContain(</><green>value</><dim>) // indexOf</>
 
-Expected array:
-  <red>[\\"a\\", \\"b\\", \\"c\\", \\"d\\"]</>
-Not to contain value:
-  <green>\\"a\\"</>
-"
+Expected value: <green>\\"a\\"</>
+Received array: <red>[\\"a\\", \\"b\\", \\"c\\", \\"d\\"]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '["a", "b", "c", "d"]' contains a value equal to '"a"' 1`] = `
-"<dim>expect(</><red>array</><dim>).not.toContainEqual(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).</>not<dim>.toContainEqual(</><green>value</><dim>) // deep equality</>
 
-Expected array:
-  <red>[\\"a\\", \\"b\\", \\"c\\", \\"d\\"]</>
-Not to contain a value equal to:
-  <green>\\"a\\"</>
-"
+Expected value: <green>\\"a\\"</>
+Received array: <red>[\\"a\\", \\"b\\", \\"c\\", \\"d\\"]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[{"a": "b"}, {"a": "c"}]' contains a value equal to '{"a": "b"}' 1`] = `
-"<dim>expect(</><red>array</><dim>).not.toContainEqual(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).</>not<dim>.toContainEqual(</><green>value</><dim>) // deep equality</>
 
-Expected array:
-  <red>[{\\"a\\": \\"b\\"}, {\\"a\\": \\"c\\"}]</>
-Not to contain a value equal to:
-  <green>{\\"a\\": \\"b\\"}</>
-"
+Expected value: <green>{\\"a\\": \\"b\\"}</>
+Received array: <red>[{\\"a\\": \\"b\\"}, {\\"a\\": \\"c\\"}]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[{"a": "b"}, {"a": "c"}]' does not contain a value equal to'{"a": "d"}' 1`] = `
-"<dim>expect(</><red>array</><dim>).toContainEqual(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).toContainEqual(</><green>value</><dim>) // deep equality</>
 
-Expected array:
-  <red>[{\\"a\\": \\"b\\"}, {\\"a\\": \\"c\\"}]</>
-To contain a value equal to:
-  <green>{\\"a\\": \\"d\\"}</>"
+Expected value: <green>{\\"a\\": \\"d\\"}</>
+Received array: <red>[{\\"a\\": \\"b\\"}, {\\"a\\": \\"c\\"}]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[{}, []]' does not contain '[]' 1`] = `
-"<dim>expect(</><red>array</><dim>).toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).toContain(</><green>value</><dim>) // indexOf</>
 
-Expected array:
-  <red>[{}, []]</>
-To contain value:
-  <green>[]</>
+Expected value: <green>[]</>
+Received array: <red>[{}, []]</>
 
 <dim>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`] = `
-"<dim>expect(</><red>array</><dim>).toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).toContain(</><green>value</><dim>) // indexOf</>
 
-Expected array:
-  <red>[{}, []]</>
-To contain value:
-  <green>{}</>
+Expected value: <green>{}</>
+Received array: <red>[{}, []]</>
 
 <dim>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`] = `
-"<dim>expect(</><red>object</><dim>).not.toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>object</><dim>).</>not<dim>.toContain(</><green>value</><dim>) // indexOf</>
 
-Expected object:
-  <red>[0, 1]</>
-Not to contain value:
-  <green>1</>
-"
+Expected value:  <green>1</>
+Received object: <red>[0, 1]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[0, 1]' contains a value equal to '1' 1`] = `
-"<dim>expect(</><red>object</><dim>).not.toContainEqual(</><green>value</><dim>)</>
+"<dim>expect(</><red>object</><dim>).</>not<dim>.toContainEqual(</><green>value</><dim>) // deep equality</>
 
-Expected object:
-  <red>[0, 1]</>
-Not to contain a value equal to:
-  <green>1</>
-"
+Expected value:  <green>1</>
+Received object: <red>[0, 1]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[1, 2, 3, 4]' contains '1' 1`] = `
-"<dim>expect(</><red>array</><dim>).not.toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).</>not<dim>.toContain(</><green>value</><dim>) // indexOf</>
 
-Expected array:
-  <red>[1, 2, 3, 4]</>
-Not to contain value:
-  <green>1</>
-"
+Expected value: <green>1</>
+Received array: <red>[1, 2, 3, 4]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[1, 2, 3, 4]' contains a value equal to '1' 1`] = `
-"<dim>expect(</><red>array</><dim>).not.toContainEqual(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).</>not<dim>.toContainEqual(</><green>value</><dim>) // deep equality</>
 
-Expected array:
-  <red>[1, 2, 3, 4]</>
-Not to contain a value equal to:
-  <green>1</>
-"
+Expected value: <green>1</>
+Received array: <red>[1, 2, 3, 4]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[1, 2, 3]' does not contain '4' 1`] = `
-"<dim>expect(</><red>array</><dim>).toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).toContain(</><green>value</><dim>) // indexOf</>
 
-Expected array:
-  <red>[1, 2, 3]</>
-To contain value:
-  <green>4</>"
+Expected value: <green>4</>
+Received array: <red>[1, 2, 3]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[Symbol(a)]' contains 'Symbol(a)' 1`] = `
-"<dim>expect(</><red>array</><dim>).not.toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).</>not<dim>.toContain(</><green>value</><dim>) // indexOf</>
 
-Expected array:
-  <red>[Symbol(a)]</>
-Not to contain value:
-  <green>Symbol(a)</>
-"
+Expected value: <green>Symbol(a)</>
+Received array: <red>[Symbol(a)]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[Symbol(a)]' contains a value equal to 'Symbol(a)' 1`] = `
-"<dim>expect(</><red>array</><dim>).not.toContainEqual(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).</>not<dim>.toContainEqual(</><green>value</><dim>) // deep equality</>
 
-Expected array:
-  <red>[Symbol(a)]</>
-Not to contain a value equal to:
-  <green>Symbol(a)</>
-"
+Expected value: <green>Symbol(a)</>
+Received array: <red>[Symbol(a)]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[null, undefined]' does not contain '1' 1`] = `
-"<dim>expect(</><red>array</><dim>).toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).toContain(</><green>value</><dim>) // indexOf</>
 
-Expected array:
-  <red>[null, undefined]</>
-To contain value:
-  <green>1</>"
+Expected value: <green>1</>
+Received array: <red>[null, undefined]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[undefined, null]' contains 'null' 1`] = `
-"<dim>expect(</><red>array</><dim>).not.toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).</>not<dim>.toContain(</><green>value</><dim>) // indexOf</>
 
-Expected array:
-  <red>[undefined, null]</>
-Not to contain value:
-  <green>null</>
-"
+Expected value: <green>null</>
+Received array: <red>[undefined, null]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[undefined, null]' contains 'undefined' 1`] = `
-"<dim>expect(</><red>array</><dim>).not.toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).</>not<dim>.toContain(</><green>value</><dim>) // indexOf</>
 
-Expected array:
-  <red>[undefined, null]</>
-Not to contain value:
-  <green>undefined</>
-"
+Expected value: <green>undefined</>
+Received array: <red>[undefined, null]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[undefined, null]' contains a value equal to 'null' 1`] = `
-"<dim>expect(</><red>array</><dim>).not.toContainEqual(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).</>not<dim>.toContainEqual(</><green>value</><dim>) // deep equality</>
 
-Expected array:
-  <red>[undefined, null]</>
-Not to contain a value equal to:
-  <green>null</>
-"
+Expected value: <green>null</>
+Received array: <red>[undefined, null]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() '[undefined, null]' contains a value equal to 'undefined' 1`] = `
-"<dim>expect(</><red>array</><dim>).not.toContainEqual(</><green>value</><dim>)</>
+"<dim>expect(</><red>array</><dim>).</>not<dim>.toContainEqual(</><green>value</><dim>) // deep equality</>
 
-Expected array:
-  <red>[undefined, null]</>
-Not to contain a value equal to:
-  <green>undefined</>
-"
+Expected value: <green>undefined</>
+Received array: <red>[undefined, null]</>"
 `;
 
 exports[`.toContain(), .toContainEqual() 'Set {"abc", "def"}' contains '"abc"' 1`] = `
-"<dim>expect(</><red>set</><dim>).not.toContain(</><green>value</><dim>)</>
+"<dim>expect(</><red>set</><dim>).</>not<dim>.toContain(</><green>value</><dim>) // indexOf</>
 
-Expected set:
-  <red>Set {\\"abc\\", \\"def\\"}</>
-Not to contain value:
-  <green>\\"abc\\"</>
-"
+Expected value: <green>\\"abc\\"</>
+Received set:   <red>Set {\\"abc\\", \\"def\\"}</>"
 `;
 
 exports[`.toContain(), .toContainEqual() 'Set {1, 2, 3, 4}' contains a value equal to '1' 1`] = `
-"<dim>expect(</><red>set</><dim>).not.toContainEqual(</><green>value</><dim>)</>
+"<dim>expect(</><red>set</><dim>).</>not<dim>.toContainEqual(</><green>value</><dim>) // deep equality</>
 
-Expected set:
-  <red>Set {1, 2, 3, 4}</>
-Not to contain a value equal to:
-  <green>1</>
-"
+Expected value: <green>1</>
+Received set:   <red>Set {1, 2, 3, 4}</>"
 `;
 
 exports[`.toContain(), .toContainEqual() error cases 1`] = `
@@ -2812,111 +2751,81 @@ Received:
 exports[`.toHaveLength {pass: false} expect("").toHaveLength(1) 1`] = `
 "<dim>expect(</><red>received</><dim>).toHaveLength(</><green>length</><dim>)</>
 
-Expected value to have length:
-  <green>1</>
-Received:
-  <red>\\"\\"</>
-received.length:
-  <red>0</>"
+Expected length: <green>1</>
+Received length: <red>0</>
+Received string: <red>\\"\\"</>"
 `;
 
 exports[`.toHaveLength {pass: false} expect("abc").toHaveLength(66) 1`] = `
 "<dim>expect(</><red>received</><dim>).toHaveLength(</><green>length</><dim>)</>
 
-Expected value to have length:
-  <green>66</>
-Received:
-  <red>\\"abc\\"</>
-received.length:
-  <red>3</>"
+Expected length: <green>66</>
+Received length: <red>3</>
+Received string: <red>\\"abc\\"</>"
 `;
 
 exports[`.toHaveLength {pass: false} expect(["a", "b"]).toHaveLength(99) 1`] = `
 "<dim>expect(</><red>received</><dim>).toHaveLength(</><green>length</><dim>)</>
 
-Expected value to have length:
-  <green>99</>
-Received:
-  <red>[\\"a\\", \\"b\\"]</>
-received.length:
-  <red>2</>"
+Expected length: <green>99</>
+Received length: <red>2</>
+Received array:  <red>[\\"a\\", \\"b\\"]</>"
 `;
 
 exports[`.toHaveLength {pass: false} expect([]).toHaveLength(1) 1`] = `
 "<dim>expect(</><red>received</><dim>).toHaveLength(</><green>length</><dim>)</>
 
-Expected value to have length:
-  <green>1</>
-Received:
-  <red>[]</>
-received.length:
-  <red>0</>"
+Expected length: <green>1</>
+Received length: <red>0</>
+Received array:  <red>[]</>"
 `;
 
 exports[`.toHaveLength {pass: false} expect([1, 2]).toHaveLength(3) 1`] = `
 "<dim>expect(</><red>received</><dim>).toHaveLength(</><green>length</><dim>)</>
 
-Expected value to have length:
-  <green>3</>
-Received:
-  <red>[1, 2]</>
-received.length:
-  <red>2</>"
+Expected length: <green>3</>
+Received length: <red>2</>
+Received array:  <red>[1, 2]</>"
 `;
 
 exports[`.toHaveLength {pass: true} expect("").toHaveLength(0) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toHaveLength(</><green>length</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toHaveLength(</><green>length</><dim>)</>
 
-Expected value to not have length:
-  <green>0</>
-Received:
-  <red>\\"\\"</>
-received.length:
-  <red>0</>"
+Expected length: <green>0</>
+Received length: <red>0</>
+Received string: <red>\\"\\"</>"
 `;
 
 exports[`.toHaveLength {pass: true} expect("abc").toHaveLength(3) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toHaveLength(</><green>length</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toHaveLength(</><green>length</><dim>)</>
 
-Expected value to not have length:
-  <green>3</>
-Received:
-  <red>\\"abc\\"</>
-received.length:
-  <red>3</>"
+Expected length: <green>3</>
+Received length: <red>3</>
+Received string: <red>\\"abc\\"</>"
 `;
 
 exports[`.toHaveLength {pass: true} expect(["a", "b"]).toHaveLength(2) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toHaveLength(</><green>length</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toHaveLength(</><green>length</><dim>)</>
 
-Expected value to not have length:
-  <green>2</>
-Received:
-  <red>[\\"a\\", \\"b\\"]</>
-received.length:
-  <red>2</>"
+Expected length: <green>2</>
+Received length: <red>2</>
+Received array:  <red>[\\"a\\", \\"b\\"]</>"
 `;
 
 exports[`.toHaveLength {pass: true} expect([]).toHaveLength(0) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toHaveLength(</><green>length</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toHaveLength(</><green>length</><dim>)</>
 
-Expected value to not have length:
-  <green>0</>
-Received:
-  <red>[]</>
-received.length:
-  <red>0</>"
+Expected length: <green>0</>
+Received length: <red>0</>
+Received array:  <red>[]</>"
 `;
 
 exports[`.toHaveLength {pass: true} expect([1, 2]).toHaveLength(2) 1`] = `
-"<dim>expect(</><red>received</><dim>).not.toHaveLength(</><green>length</><dim>)</>
+"<dim>expect(</><red>received</><dim>).</>not<dim>.toHaveLength(</><green>length</><dim>)</>
 
-Expected value to not have length:
-  <green>2</>
-Received:
-  <red>[1, 2]</>
-received.length:
-  <red>2</>"
+Expected length: <green>2</>
+Received length: <red>2</>
+Received array:  <red>[1, 2]</>"
 `;
 
 exports[`.toHaveLength error cases 1`] = `
diff --git a/packages/expect/src/matchers.js b/packages/expect/src/matchers.js
index adcbe91ae50e..1baa47fa44af 100644
--- a/packages/expect/src/matchers.js
+++ b/packages/expect/src/matchers.js
@@ -19,6 +19,7 @@ import {
   SUGGEST_TO_CONTAIN_EQUAL,
   ensureNoExpected,
   ensureNumbers,
+  getLabelPrinter,
   matcherErrorMessage,
   matcherHint,
   printReceived,
@@ -102,8 +103,8 @@ const matchers: MatchersObject = {
       }) +
       '\n\n' +
       `Precision: ${printExpected(precision)}-digit\n` +
-      `Expected: ${printExpected(expected)}\n` +
-      `Received: ${printReceived(actual)}`;
+      `Expected:  ${printExpected(expected)}\n` +
+      `Received:  ${printReceived(actual)}`;
 
     return {message, pass};
   },
@@ -305,32 +306,29 @@ const matchers: MatchersObject = {
     // At this point, we're either a string or an Array,
     // which was converted from an array-like structure.
     const pass = converted.indexOf(value) != -1;
-    const message = pass
-      ? () =>
-          matcherHint('.not.toContain', collectionType, 'value') +
-          '\n\n' +
-          `Expected ${collectionType}:\n` +
-          `  ${printReceived(collection)}\n` +
-          `Not to contain value:\n` +
-          `  ${printExpected(value)}\n`
-      : () => {
-          const suggestToContainEqual =
-            converted !== null &&
-            typeof converted !== 'string' &&
-            converted instanceof Array &&
-            converted.findIndex(item =>
-              equals(item, value, [iterableEquality]),
-            ) !== -1;
-          return (
-            matcherHint('.toContain', collectionType, 'value') +
-            '\n\n' +
-            `Expected ${collectionType}:\n` +
-            `  ${printReceived(collection)}\n` +
-            `To contain value:\n` +
-            `  ${printExpected(value)}` +
-            (suggestToContainEqual ? `\n\n${SUGGEST_TO_CONTAIN_EQUAL}` : '')
-          );
-        };
+    const message = () => {
+      const stringExpected = 'Expected value';
+      const stringReceived = `Received ${collectionType}`;
+      const printLabel = getLabelPrinter(stringExpected, stringReceived);
+      const suggestToContainEqual =
+        !pass &&
+        converted !== null &&
+        typeof converted !== 'string' &&
+        converted instanceof Array &&
+        converted.findIndex(item => equals(item, value, [iterableEquality])) !==
+          -1;
+
+      return (
+        matcherHint('.toContain', collectionType, 'value', {
+          comment: 'indexOf',
+          isNot: this.isNot,
+        }) +
+        '\n\n' +
+        `${printLabel(stringExpected)}${printExpected(value)}\n` +
+        `${printLabel(stringReceived)}${printReceived(collection)}` +
+        (suggestToContainEqual ? `\n\n${SUGGEST_TO_CONTAIN_EQUAL}` : '')
+      );
+    };
 
     return {message, pass};
   },
@@ -361,21 +359,21 @@ const matchers: MatchersObject = {
     const pass =
       converted.findIndex(item => equals(item, value, [iterableEquality])) !==
       -1;
-    const message = pass
-      ? () =>
-          matcherHint('.not.toContainEqual', collectionType, 'value') +
-          '\n\n' +
-          `Expected ${collectionType}:\n` +
-          `  ${printReceived(collection)}\n` +
-          `Not to contain a value equal to:\n` +
-          `  ${printExpected(value)}\n`
-      : () =>
-          matcherHint('.toContainEqual', collectionType, 'value') +
-          '\n\n' +
-          `Expected ${collectionType}:\n` +
-          `  ${printReceived(collection)}\n` +
-          `To contain a value equal to:\n` +
-          `  ${printExpected(value)}`;
+    const message = () => {
+      const stringExpected = 'Expected value';
+      const stringReceived = `Received ${collectionType}`;
+      const printLabel = getLabelPrinter(stringExpected, stringReceived);
+
+      return (
+        matcherHint('.toContainEqual', collectionType, 'value', {
+          comment: 'deep equality',
+          isNot: this.isNot,
+        }) +
+        '\n\n' +
+        `${printLabel(stringExpected)}${printExpected(value)}\n` +
+        `${printLabel(stringReceived)}${printReceived(collection)}`
+      );
+    };
 
     return {message, pass};
   },
@@ -443,25 +441,28 @@ const matchers: MatchersObject = {
     }
 
     const pass = received.length === length;
-    const message = pass
-      ? () =>
-          matcherHint('.not.toHaveLength', 'received', 'length') +
-          '\n\n' +
-          `Expected value to not have length:\n` +
-          `  ${printExpected(length)}\n` +
-          `Received:\n` +
-          `  ${printReceived(received)}\n` +
-          `received.length:\n` +
-          `  ${printReceived(received.length)}`
-      : () =>
-          matcherHint('.toHaveLength', 'received', 'length') +
-          '\n\n' +
-          `Expected value to have length:\n` +
-          `  ${printExpected(length)}\n` +
-          `Received:\n` +
-          `  ${printReceived(received)}\n` +
-          `received.length:\n` +
-          `  ${printReceived(received.length)}`;
+    const message = () => {
+      const stringExpected = 'Expected length';
+      const stringReceivedLength = 'Received length';
+      const stringReceivedValue = `Received ${getType(received)}`;
+      const printLabel = getLabelPrinter(
+        stringExpected,
+        stringReceivedLength,
+        stringReceivedValue,
+      );
+
+      return (
+        matcherHint('.toHaveLength', 'received', 'length', {
+          isNot: this.isNot,
+        }) +
+        '\n\n' +
+        `${printLabel(stringExpected)}${printExpected(length)}\n` +
+        `${printLabel(stringReceivedLength)}${printReceived(
+          received.length,
+        )}\n` +
+        `${printLabel(stringReceivedValue)}${printReceived(received)}`
+      );
+    };
 
     return {message, pass};
   },
diff --git a/packages/jest-matcher-utils/src/__tests__/index.test.js b/packages/jest-matcher-utils/src/__tests__/index.test.js
index 9db8878662b1..b6ab75a5722c 100644
--- a/packages/jest-matcher-utils/src/__tests__/index.test.js
+++ b/packages/jest-matcher-utils/src/__tests__/index.test.js
@@ -6,9 +6,13 @@
  *
  */
 
-'use strict';
-
-import {ensureNoExpected, ensureNumbers, pluralize, stringify} from '../';
+import {
+  ensureNumbers,
+  ensureNoExpected,
+  getLabelPrinter,
+  pluralize,
+  stringify,
+} from '../';
 
 describe('.stringify()', () => {
   [
@@ -130,3 +134,53 @@ describe('.pluralize()', () => {
   test('two', () => expect(pluralize('apple', 2)).toEqual('two apples'));
   test('20', () => expect(pluralize('apple', 20)).toEqual('20 apples'));
 });
+
+describe('getLabelPrinter', () => {
+  test('0 args', () => {
+    const printLabel = getLabelPrinter();
+    expect(printLabel('')).toBe(': ');
+  });
+  test('1 empty string', () => {
+    const printLabel = getLabelPrinter();
+    expect(printLabel('')).toBe(': ');
+  });
+  test('1 non-empty string', () => {
+    const string = 'Expected';
+    const printLabel = getLabelPrinter(string);
+    expect(printLabel(string)).toBe('Expected: ');
+  });
+  test('2 equal lengths', () => {
+    const stringExpected = 'Expected value';
+    const collectionType = 'array';
+    const stringReceived = `Received ${collectionType}`;
+    const printLabel = getLabelPrinter(stringExpected, stringReceived);
+    expect(printLabel(stringExpected)).toBe('Expected value: ');
+    expect(printLabel(stringReceived)).toBe('Received array: ');
+  });
+  test('2 unequal lengths', () => {
+    const stringExpected = 'Expected value';
+    const collectionType = 'set';
+    const stringReceived = `Received ${collectionType}`;
+    const printLabel = getLabelPrinter(stringExpected, stringReceived);
+    expect(printLabel(stringExpected)).toBe('Expected value: ');
+    expect(printLabel(stringReceived)).toBe('Received set:   ');
+  });
+  test('returns incorrect padding if inconsistent arg is shorter', () => {
+    const stringConsistent = 'Expected';
+    const stringInconsistent = 'Received value';
+    const stringInconsistentShorter = 'Received set';
+    const printLabel = getLabelPrinter(stringConsistent, stringInconsistent);
+    expect(printLabel(stringConsistent)).toBe('Expected:       ');
+    expect(printLabel(stringInconsistentShorter)).toBe('Received set:   ');
+  });
+  test('throws if inconsistent arg is longer', () => {
+    const stringConsistent = 'Expected';
+    const stringInconsistent = 'Received value';
+    const stringInconsistentLonger = 'Received string';
+    const printLabel = getLabelPrinter(stringConsistent, stringInconsistent);
+    expect(printLabel(stringConsistent)).toBe('Expected:       ');
+    expect(() => {
+      printLabel(stringInconsistentLonger);
+    }).toThrow();
+  });
+});
diff --git a/packages/jest-matcher-utils/src/index.js b/packages/jest-matcher-utils/src/index.js
index 03f0e6369826..4b0b8be351fe 100644
--- a/packages/jest-matcher-utils/src/index.js
+++ b/packages/jest-matcher-utils/src/index.js
@@ -153,6 +153,21 @@ export const ensureNumbers = (
 export const pluralize = (word: string, count: number) =>
   (NUMBERS[count] || count) + ' ' + word + (count === 1 ? '' : 's');
 
+// To display lines of labeled values as two columns with monospace alignment:
+// given the strings which will describe the values,
+// return function which given each string, returns the label:
+// string, colon, space, and enough padding spaces to align the value.
+
+type PrintLabel = string => string;
+
+export const getLabelPrinter = (...strings: Array<string>): PrintLabel => {
+  const maxLength = strings.reduce(
+    (max, string) => (string.length > max ? string.length : max),
+    0,
+  );
+  return string => `${string}: ${' '.repeat(maxLength - string.length)}`;
+};
+
 export const matcherErrorMessage = (
   hint: string, // assertion returned from call to matcherHint
   generic: string, // condition which correct value must fulfill