Update tests for Node@8

Author: wooorm

test/children.js

@@ -8,15 +8,15 @@ test('children', function (t) {
     function () {
       assert({type: 'paragraph', children: {alpha: 'bravo'}});
     },
-    /^AssertionError: `children` should be an array: `{ type: 'paragraph', children: { alpha: 'bravo' } }`$/,
+    /`children` should be an array: `{ type: 'paragraph', children: { alpha: 'bravo' } }`$/,
     'should throw if given a non-node child in children'
   );
 
   t.throws(
     function () {
       assert({type: 'paragraph', children: ['one']});
     },
-    /^AssertionError: node should be an object: `'one'` in `{ type: 'paragraph', children: \[ 'one' ] }`$/,
+    /node should be an object: `'one'` in `{ type: 'paragraph', children: \[ 'one' ] }`$/,
     'should throw if given a non-node child in children'
   );
 
@@ -34,7 +34,7 @@ test('children', function (t) {
         children: ['one']
       }]});
     },
-    /^AssertionError: node should be an object: `'one'` in `{ type: 'bar', children: \[ 'one' ] }`$/,
+    /node should be an object: `'one'` in `{ type: 'bar', children: \[ 'one' ] }`$/,
     'should throw on invalid descendants'
   );
 

test/code.js

@@ -8,7 +8,7 @@ test('assert(code)', function (t) {
     function () {
       assert({type: 'code'});
     },
-    /^AssertionError: text should have `value`: `{ type: 'code' }`$/,
+    /text should have `value`: `{ type: 'code' }`$/,
     'should throw if `code` is not a text'
   );
 
@@ -23,7 +23,7 @@ test('assert(code)', function (t) {
     function () {
       assert({type: 'code', lang: 0, value: ''});
     },
-    /^AssertionError: `lang` must be `string`: `{ type: 'code', lang: 0, value: '' }`$/,
+    /`lang` must be `string`: `{ type: 'code', lang: 0, value: '' }`$/,
     'should throw if `lang` is not a string'
   );
 

test/definition.js

@@ -8,15 +8,15 @@ test('assert(definition)', function (t) {
     function () {
       assert({type: 'definition'});
     },
-    /^AssertionError: `identifier` must be `string`: `{ type: 'definition' }`$/,
+    /`identifier` must be `string`: `{ type: 'definition' }`$/,
     'should throw if `definition` has no `identifier`'
   );
 
   t.throws(
     function () {
       assert({type: 'definition', identifier: 1});
     },
-    /^AssertionError: `identifier` must be `string`: `{ type: 'definition', identifier: 1 }`$/,
+    /`identifier` must be `string`: `{ type: 'definition', identifier: 1 }`$/,
     'should throw if `identifier` is not a `string`'
   );
 
@@ -31,15 +31,15 @@ test('assert(definition)', function (t) {
     function () {
       assert({type: 'definition', identifier: '1', url: 1});
     },
-    /^AssertionError: `url` must be `string`: `{ type: 'definition', identifier: '1', url: 1 }`$/,
+    /`url` must be `string`: `{ type: 'definition', identifier: '1', url: 1 }`$/,
     'should throw if `identifier` is not a `string`'
   );
 
   t.throws(
     function () {
       assert({type: 'definition', identifier: '1', title: 1});
     },
-    /^AssertionError: `title` must be `string`: `{ type: 'definition', identifier: '1', title: 1 }`$/,
+    /`title` must be `string`: `{ type: 'definition', identifier: '1', title: 1 }`$/,
     'should throw if `title` is not a `string`'
   );
 

test/footnote-definition.js

@@ -8,23 +8,23 @@ test('assert(footnoteDefinition)', function (t) {
     function () {
       assert({type: 'footnoteDefinition'});
     },
-    /^AssertionError: parent should have `children`: `{ type: 'footnoteDefinition' }`$/,
+    /parent should have `children`: `{ type: 'footnoteDefinition' }`$/,
     'should throw if `footnoteDefinition` is not a parent'
   );
 
   t.throws(
     function () {
       assert({type: 'footnoteDefinition', children: []});
     },
-    /^AssertionError: `footnoteDefinition` must have `identifier`: `{ type: 'footnoteDefinition', children: \[] }`$/,
+    /`footnoteDefinition` must have `identifier`: `{ type: 'footnoteDefinition', children: \[] }`$/,
     'should throw if `footnoteDefinition` has no identifier'
   );
 
   t.throws(
     function () {
       assert({type: 'footnoteDefinition', identifier: 1, children: []});
     },
-    /^AssertionError: `footnoteDefinition` must have `identifier`: `{ type: 'footnoteDefinition', identifier: 1, children: \[] }`$/,
+    /`footnoteDefinition` must have `identifier`: `{ type: 'footnoteDefinition', identifier: 1, children: \[] }`$/,
     'should throw if `identifier` is not a `string`'
   );
 

test/footnote-reference.js

@@ -8,15 +8,15 @@ test('assert(footnoteReference)', function (t) {
     function () {
       assert({type: 'footnoteReference'});
     },
-    /^AssertionError: `identifier` must be `string`: `{ type: 'footnoteReference' }`$/,
+    /`identifier` must be `string`: `{ type: 'footnoteReference' }`$/,
     'should throw if `footnoteReference` has no `identifier`'
   );
 
   t.throws(
     function () {
       assert({type: 'footnoteReference', identifier: 1});
     },
-    /^AssertionError: `identifier` must be `string`: `{ type: 'footnoteReference', identifier: 1 }`$/,
+    /`identifier` must be `string`: `{ type: 'footnoteReference', identifier: 1 }`$/,
     'should throw if `identifier` is not a `string`'
   );
 

test/heading.js

@@ -8,23 +8,23 @@ test('assert(heading)', function (t) {
     function () {
       assert({type: 'heading'});
     },
-    /^AssertionError: parent should have `children`: `{ type: 'heading' }`$/,
+    /parent should have `children`: `{ type: 'heading' }`$/,
     'should throw if a `heading` is not a parent'
   );
 
   t.throws(
     function () {
       assert({type: 'heading', depth: 0, children: []});
     },
-    /^AssertionError: `depth` should be gte `1`: `{ type: 'heading', depth: 0, children: \[] }`$/,
+    /`depth` should be gte `1`: `{ type: 'heading', depth: 0, children: \[] }`$/,
     'should throw if `depth` is lower than 1'
   );
 
   t.throws(
     function () {
       assert({type: 'heading', depth: 7, children: []});
     },
-    /^AssertionError: `depth` should be lte `6`: `{ type: 'heading', depth: 7, children: \[] }`$/,
+    /`depth` should be lte `6`: `{ type: 'heading', depth: 7, children: \[] }`$/,
     'should throw if `depth` is lower than 7'
   );
 

test/image-reference.js

@@ -8,15 +8,15 @@ test('assert(imageReference)', function (t) {
     function () {
       assert({type: 'imageReference'});
     },
-    /^AssertionError: `identifier` must be `string`: `{ type: 'imageReference' }`$/,
+    /`identifier` must be `string`: `{ type: 'imageReference' }`$/,
     'should throw if `imageReference` has no `identifier`'
   );
 
   t.throws(
     function () {
       assert({type: 'imageReference', identifier: 1});
     },
-    /^AssertionError: `identifier` must be `string`: `{ type: 'imageReference', identifier: 1 }`$/,
+    /`identifier` must be `string`: `{ type: 'imageReference', identifier: 1 }`$/,
     'should throw if `identifier` is not a `string`'
   );
 
@@ -31,15 +31,15 @@ test('assert(imageReference)', function (t) {
     function () {
       assert({type: 'imageReference', identifier: '1', alt: 1});
     },
-    /^AssertionError: `alt` must be `string`: `{ type: 'imageReference', identifier: '1', alt: 1 }`$/,
+    /`alt` must be `string`: `{ type: 'imageReference', identifier: '1', alt: 1 }`$/,
     'should throw if `alt` is not a `string`'
   );
 
   t.throws(
     function () {
       assert({type: 'imageReference', identifier: '1', referenceType: 1});
     },
-    /^AssertionError: `referenceType` must be `shortcut`, `collapsed`, or `full`: `{ type: 'imageReference', identifier: '1', referenceType: 1 }`$/,
+    /`referenceType` must be `shortcut`, `collapsed`, or `full`: `{ type: 'imageReference', identifier: '1', referenceType: 1 }`$/,
     'should throw if `referenceType` is not a `string`'
   );
 

test/image.js

@@ -15,23 +15,23 @@ test('assert(image)', function (t) {
     function () {
       assert({type: 'image', url: 1});
     },
-    /^AssertionError: `url` must be `string`: `{ type: 'image', url: 1 }`$/,
+    /`url` must be `string`: `{ type: 'image', url: 1 }`$/,
     'should throw if `identifier` is not a `string`'
   );
 
   t.throws(
     function () {
       assert({type: 'image', title: 1});
     },
-    /^AssertionError: `title` must be `string`: `{ type: 'image', title: 1 }`$/,
+    /`title` must be `string`: `{ type: 'image', title: 1 }`$/,
     'should throw if `title` is not a `string`'
   );
 
   t.throws(
     function () {
       assert({type: 'image', alt: 1});
     },
-    /^AssertionError: `alt` must be `string`: `{ type: 'image', alt: 1 }`$/,
+    /`alt` must be `string`: `{ type: 'image', alt: 1 }`$/,
     'should throw if `alt` is not a `string`'
   );
 

test/link-reference.js

@@ -8,23 +8,23 @@ test('assert(linkReference)', function (t) {
     function () {
       assert({type: 'linkReference'});
     },
-    /^AssertionError: parent should have `children`: `{ type: 'linkReference' }`$/,
+    /parent should have `children`: `{ type: 'linkReference' }`$/,
     'should throw if `linkReference` has no children'
   );
 
   t.throws(
     function () {
       assert({type: 'linkReference', children: []});
     },
-    /^AssertionError: `identifier` must be `string`: `{ type: 'linkReference', children: \[] }`$/,
+    /`identifier` must be `string`: `{ type: 'linkReference', children: \[] }`$/,
     'should throw if `linkReference` has no `identifier`'
   );
 
   t.throws(
     function () {
       assert({type: 'linkReference', identifier: 1, children: []});
     },
-    /^AssertionError: `identifier` must be `string`: `{ type: 'linkReference', identifier: 1, children: \[] }`$/,
+    /`identifier` must be `string`: `{ type: 'linkReference', identifier: 1, children: \[] }`$/,
     'should throw if `identifier` is not a `string`'
   );
 
@@ -39,7 +39,7 @@ test('assert(linkReference)', function (t) {
     function () {
       assert({type: 'linkReference', identifier: '1', referenceType: 1, children: []});
     },
-    /^AssertionError: `referenceType` must be `shortcut`, `collapsed`, or `full`: `{ type: 'linkReference',\n {2}identifier: '1',\n {2}referenceType: 1,\n {2}children: \[] }`$/,
+    /`referenceType` must be `shortcut`, `collapsed`, or `full`: `{ type: 'linkReference',\n {2}identifier: '1',\n {2}referenceType: 1,\n {2}children: \[] }`$/,
     'should throw if `referenceType` is not a `string`'
   );
 

test/link.js

@@ -8,7 +8,7 @@ test('assert(link)', function (t) {
     function () {
       assert({type: 'link'});
     },
-    /^AssertionError: parent should have `children`: `{ type: 'link' }`$/,
+    /parent should have `children`: `{ type: 'link' }`$/,
     'should throw if `link` is not a parent'
   );
 
@@ -23,15 +23,15 @@ test('assert(link)', function (t) {
     function () {
       assert({type: 'link', children: [], url: 1});
     },
-    /^AssertionError: `url` must be `string`: `{ type: 'link', children: \[], url: 1 }`$/,
+    /`url` must be `string`: `{ type: 'link', children: \[], url: 1 }`$/,
     'should throw if `identifier` is not a `string`'
   );
 
   t.throws(
     function () {
       assert({type: 'link', children: [], title: 1});
     },
-    /^AssertionError: `title` must be `string`: `{ type: 'link', children: \[], title: 1 }`$/,
+    /`title` must be `string`: `{ type: 'link', children: \[], title: 1 }`$/,
     'should throw if `title` is not a `string`'
   );
 

test/list-item.js

@@ -8,7 +8,7 @@ test('assert(listItem)', function (t) {
     function () {
       assert({type: 'listItem'});
     },
-    /^AssertionError: parent should have `children`: `{ type: 'listItem' }`$/,
+    /parent should have `children`: `{ type: 'listItem' }`$/,
     'should throw if a `listItem` is not a parent'
   );
 
@@ -23,7 +23,7 @@ test('assert(listItem)', function (t) {
     function () {
       assert({type: 'listItem', loose: 1, children: []});
     },
-    /^AssertionError: `loose` must be `boolean`: `{ type: 'listItem', loose: 1, children: \[] }`$/,
+    /`loose` must be `boolean`: `{ type: 'listItem', loose: 1, children: \[] }`$/,
     'should throw if `loose` is not a `boolean`'
   );
 
@@ -38,7 +38,7 @@ test('assert(listItem)', function (t) {
     function () {
       assert({type: 'listItem', checked: 'yup', children: []});
     },
-    /^AssertionError: `checked` must be `boolean`: `{ type: 'listItem', checked: 'yup', children: \[] }`$/,
+    /`checked` must be `boolean`: `{ type: 'listItem', checked: 'yup', children: \[] }`$/,
     'should throw if a `checked` is not a `boolean`'
   );
 

test/list.js

@@ -8,7 +8,7 @@ test('assert(list)', function (t) {
     function () {
       assert({type: 'list'});
     },
-    /^AssertionError: parent should have `children`: `{ type: 'list' }`$/,
+    /parent should have `children`: `{ type: 'list' }`$/,
     'should throw if a `list` is not a parent'
   );
 
@@ -23,7 +23,7 @@ test('assert(list)', function (t) {
     function () {
       assert({type: 'list', loose: 1, children: []});
     },
-    /^AssertionError: `loose` must be `boolean`: `{ type: 'list', loose: 1, children: \[] }`$/,
+    /`loose` must be `boolean`: `{ type: 'list', loose: 1, children: \[] }`$/,
     'should throw if `loose` is not a `boolean`'
   );
 
@@ -38,7 +38,7 @@ test('assert(list)', function (t) {
     function () {
       assert({type: 'list', ordered: 'yup', children: []});
     },
-    /^AssertionError: `ordered` must be `boolean`: `{ type: 'list', ordered: 'yup', children: \[] }`$/,
+    /`ordered` must be `boolean`: `{ type: 'list', ordered: 'yup', children: \[] }`$/,
     'should throw if a `ordered` is not a `boolean`'
   );
 
@@ -53,23 +53,23 @@ test('assert(list)', function (t) {
     function () {
       assert({type: 'list', ordered: false, start: 1, children: []});
     },
-    /^AssertionError: unordered lists must not have `start`: `{ type: 'list', ordered: false, start: 1, children: \[] }`$/,
+    /unordered lists must not have `start`: `{ type: 'list', ordered: false, start: 1, children: \[] }`$/,
     'should throw if an `ordered: false` list has a `start`'
   );
 
   t.throws(
     function () {
       assert({type: 'list', ordered: true, start: false, children: []});
     },
-    /^AssertionError: ordered lists must have `start`: `{ type: 'list', ordered: true, start: false, children: \[] }`$/,
+    /ordered lists must have `start`: `{ type: 'list', ordered: true, start: false, children: \[] }`$/,
     'should throw if an `ordered` list has a non-numeric `start`'
   );
 
   t.throws(
     function () {
       assert({type: 'list', ordered: true, start: -1, children: []});
     },
-    /^AssertionError: `start` must be gte `0`: `{ type: 'list', ordered: true, start: -1, children: \[] }`$/,
+    /`start` must be gte `0`: `{ type: 'list', ordered: true, start: -1, children: \[] }`$/,
     'should throw if an `ordered` list has a negative `start`'
   );
 

test/node.js

@@ -8,31 +8,31 @@ test('node', function (t) {
     function () {
       assert();
     },
-    /^AssertionError: node should be an object: `undefined`$/,
+    /node should be an object: `undefined`$/,
     'should throw if not given a node (#1)'
   );
 
   t.throws(
     function () {
       assert(null);
     },
-    /^AssertionError: node should be an object: `null`$/,
+    /node should be an object: `null`$/,
     'should throw if not given a node (#2)'
   );
 
   t.throws(
     function () {
       assert('foo');
     },
-    /^AssertionError: node should be an object: `'foo'`$/,
+    /node should be an object: `'foo'`$/,
     'should throw if given a non-node (#1)'
   );
 
   t.throws(
     function () {
       assert(6);
     },
-    /^AssertionError: node should be an object: `6`$/,
+    /node should be an object: `6`$/,
     'should throw if not given a non-node (#2)'
   );