Update tests for Node@8

Author: wooorm

test/children.js

@@ -8,15 +8,15 @@ test('children', function (t) {
     function () {
       assert({type: 'foo', children: {alpha: 'bravo'}});
     },
-    /^AssertionError: `children` should be an array: `{ type: 'foo', children: { alpha: 'bravo' } }`$/,
+    /`children` should be an array: `{ type: 'foo', children: { alpha: 'bravo' } }`$/,
     'should throw if given a non-node child in children'
   );
 
   t.throws(
     function () {
       assert({type: 'foo', children: ['one']});
     },
-    /^AssertionError: node should be an object: `'one'` in `{ type: 'foo', children: \[ 'one' ] }`$/,
+    /node should be an object: `'one'` in `{ type: 'foo', 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/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)'
   );
 

test/non-defined.js

@@ -29,7 +29,7 @@ test('non-defined', function (t) {
         data: {foo: Function}
       });
     },
-    /^AssertionError: non-specced property `data` should be JSON: `{ type: 'break', data: { foo: \[Function: Function] } }`$/,
+    /non-specced property `data` should be JSON: `{ type: 'break', data: { foo: \[Function: Function] } }`$/,
     'should throw if non-defined properties are not serialisable'
   );
 

test/parent.js

@@ -8,23 +8,23 @@ test('assert.parent()', function (t) {
     function () {
       assert.parent({});
     },
-    /^AssertionError: node should have a type: `{}`$/,
+    /node should have a type: `{}`$/,
     'should throw the same errors as `assert()`'
   );
 
   t.throws(
     function () {
       assert.parent({type: 'text', value: 'foo'});
     },
-    /^AssertionError: parent should not have `value`: `{ type: 'text', value: 'foo' }`$/,
+    /parent should not have `value`: `{ type: 'text', value: 'foo' }`$/,
     'should throw if the given node has a `value`'
   );
 
   t.throws(
     function () {
       assert.parent({type: 'break'});
     },
-    /^AssertionError: parent should have `children`: `{ type: 'break' }`$/,
+    /parent should have `children`: `{ type: 'break' }`$/,
     'should throw if the given node has `children`'
   );
 

test/position.js

@@ -8,7 +8,7 @@ test('position', function (t) {
     function () {
       assert({type: 'foo', position: 1});
     },
-    /^AssertionError: `position` should be an object: `{ type: 'foo', position: 1 }`$/,
+    /`position` should be an object: `{ type: 'foo', position: 1 }`$/,
     'should throw if given a non-object `position`'
   );
 
@@ -30,7 +30,7 @@ test('position', function (t) {
     function () {
       assert({type: 'foo', position: {start: 1}});
     },
-    /^AssertionError: `position.start` should be an object: `{ type: 'foo', position: { start: 1 } }`$/,
+    /`position.start` should be an object: `{ type: 'foo', position: { start: 1 } }`$/,
     'should throw if given a non-object `position.start`'
   );
 
@@ -52,7 +52,7 @@ test('position', function (t) {
     function () {
       assert({type: 'foo', position: {end: 1}});
     },
-    /^AssertionError: `position.end` should be an object: `{ type: 'foo', position: { end: 1 } }`$/,
+    /`position.end` should be an object: `{ type: 'foo', position: { end: 1 } }`$/,
     'should throw if given a non-object `position.end`'
   );
 
@@ -102,31 +102,31 @@ test('position', function (t) {
     function () {
       assert({type: 'foo', position: {start: {line: 0}}});
     },
-    /^AssertionError: `position.start.line` should be gte `1`: `{ type: 'foo', position: { start: { line: 0 } } }`$/,
+    /`position.start.line` should be gte `1`: `{ type: 'foo', position: { start: { line: 0 } } }`$/,
     'should throw if `position.start.line` is less than 1'
   );
 
   t.throws(
     function () {
       assert({type: 'foo', position: {start: {column: 0}}});
     },
-    /^AssertionError: `position.start.column` should be gte `1`: `{ type: 'foo', position: { start: { column: 0 } } }`$/,
+    /`position.start.column` should be gte `1`: `{ type: 'foo', position: { start: { column: 0 } } }`$/,
     'should throw if `position.start.column` is less than 1'
   );
 
   t.throws(
     function () {
       assert({type: 'foo', position: {end: {line: 0}}});
     },
-    /^AssertionError: `position.end.line` should be gte `1`: `{ type: 'foo', position: { end: { line: 0 } } }`$/,
+    /`position.end.line` should be gte `1`: `{ type: 'foo', position: { end: { line: 0 } } }`$/,
     'should throw if `position.end.line` is less than 1'
   );
 
   t.throws(
     function () {
       assert({type: 'foo', position: {end: {column: 0}}});
     },
-  /^AssertionError: `position.end.column` should be gte `1`: `{ type: 'foo', position: { end: { column: 0 } } }`$/,
+    /`position.end.column` should be gte `1`: `{ type: 'foo', position: { end: { column: 0 } } }`$/,
     'should throw if `position.end.column` is less than 1'
   );
 

test/text.js

@@ -8,23 +8,23 @@ test('assert.text()', function (t) {
     function () {
       assert.text({});
     },
-    /^AssertionError: node should have a type: `{}`$/,
+    /node should have a type: `{}`$/,
     'should throw the same errors as `assert()`'
   );
 
   t.throws(
     function () {
       assert.text({type: 'strong', children: []});
     },
-    /^AssertionError: text should not have `children`: `{ type: 'strong', children: \[] }`$/,
+    /text should not have `children`: `{ type: 'strong', children: \[] }`$/,
     'should throw if the given node has `children`'
   );
 
   t.throws(
     function () {
       assert.text({type: 'break'});
     },
-    /^AssertionError: text should have `value`: `{ type: 'break' }`$/,
+    /text should have `value`: `{ type: 'break' }`$/,
     'should throw if the given node has no `value`'
   );
 

test/type.js

@@ -8,31 +8,31 @@ test('type', function (t) {
     function () {
       assert([1, 5]);
     },
-    /^AssertionError: node should have a type: `\[ 1, 5 ]`$/,
+    /node should have a type: `\[ 1, 5 ]`$/,
     'should throw if not given a `type` (#1)'
   );
 
   t.throws(
     function () {
       assert({value: 'foo'});
     },
-    /^AssertionError: node should have a type: `{ value: 'foo' }`$/,
+    /node should have a type: `{ value: 'foo' }`$/,
     'should throw if not given a type (#2)'
   );
 
   t.throws(
     function () {
       assert({type: 1});
     },
-    /^AssertionError: `type` should be a string: `{ type: 1 }`$/,
+    /`type` should be a string: `{ type: 1 }`$/,
     'should throw if not given a non-string type'
   );
 
   t.throws(
     function () {
       assert({type: ''});
     },
-    /^AssertionError: `type` should not be empty: `{ type: '' }`$/,
+    /`type` should not be empty: `{ type: '' }`$/,
     'should throw if given an empty string type'
   );
 

test/value.js

@@ -8,7 +8,7 @@ test('value', function (t) {
     function () {
       assert({type: 'foo', value: 1});
     },
-    /^AssertionError: `value` should be a string: `{ type: 'foo', value: 1 }`$/,
+    /`value` should be a string: `{ type: 'foo', value: 1 }`$/,
     'should throw if given a non-string `value`'
   );
 

test/void.js

@@ -19,23 +19,23 @@ test('assert.void()', function (t) {
     function () {
       assert.void({});
     },
-    /^AssertionError: node should have a type: `{}`$/,
+    /node should have a type: `{}`$/,
     'should throw the same errors as `assert()`'
   );
 
   t.throws(
     function () {
       assert.void({type: 'text', value: 'foo'});
     },
-    /^AssertionError: void should not have `value`: `{ type: 'text', value: 'foo' }`$/,
+    /void should not have `value`: `{ type: 'text', value: 'foo' }`$/,
     'should throw if the given node has a `value`'
   );
 
   t.throws(
     function () {
       assert.void({type: 'strong', children: []});
     },
-    /^AssertionError: void should not have `children`: `{ type: 'strong', children: \[] }`$/,
+    /void should not have `children`: `{ type: 'strong', children: \[] }`$/,
     'should throw if the given node has `children`'
   );