断言
assert 样式与 Node.js 的内置断言模块非常相似，只是多了一些额外的糖衣。在三种样式选项中，assert 是唯一不可链式调用的。查看 样式指南 以进行比较。
API 参考
assert(expression, message)
编写您自己的测试表达式。
assert('foo' !== 'bar', 'foo is not bar');
assert(Array.isArray([]), 'empty arrays are arrays');
.fail([message])
.fail(actual, expected, [message], [operator])
抛出失败。Node.js assert 模块兼容。
assert.fail();
assert.fail("custom error message");
assert.fail(1, 2);
assert.fail(1, 2, "custom error message");
assert.fail(1, 2, "custom error message", ">");
assert.fail(1, 2, undefined, ">");
.isOk(object, [message])
断言 object 为真值。
assert.isOk('everything', 'everything is ok');
assert.isOk(false, 'this will fail');
.isNotOk(object, [message])
断言 object 为假值。
assert.isNotOk('everything', 'this will fail');
assert.isNotOk(false, 'this will pass');
.equal(actual, expected, [message])
断言 actual 和 expected 非严格相等 (==)。
assert.equal(3, '3', '== coerces values to strings');
.notEqual(actual, expected, [message])
断言 actual 和 expected 非严格不等 (!=)。
assert.notEqual(3, 4, 'these numbers are not equal');
.strictEqual(actual, expected, [message])
断言 actual 和 expected 严格相等 (===)。
assert.strictEqual(true, true, 'these booleans are strictly equal');
.notStrictEqual(actual, expected, [message])
断言 actual 和 expected 严格不等 (!==)。
assert.notStrictEqual(3, '3', 'no coercion for strict equality');
.deepEqual(actual, expected, [message])
断言 actual 深度等于 expected。
assert.deepEqual({ tea: 'green' }, { tea: 'green' });
.notDeepEqual(actual, expected, [message])
断言 actual 不深度等于 expected。
assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });
.isAbove(valueToCheck, valueToBeAbove, [message])
断言 valueToCheck 严格大于 (>) valueToBeAbove。
assert.isAbove(5, 2, '5 is strictly greater than 2');
.isAtLeast(valueToCheck, valueToBeAtLeast, [message])
断言 valueToCheck 大于或等于 (>=) valueToBeAtLeast。
assert.isAtLeast(5, 2, '5 is greater or equal to 2');
assert.isAtLeast(3, 3, '3 is greater or equal to 3');
.isBelow(valueToCheck, valueToBeBelow, [message])
断言 valueToCheck 严格小于 (<) valueToBeBelow。
assert.isBelow(3, 6, '3 is strictly less than 6');
.isAtMost(valueToCheck, valueToBeAtMost, [message])
断言 valueToCheck 小于或等于 (<=) valueToBeAtMost。
assert.isAtMost(3, 6, '3 is less than or equal to 6');
assert.isAtMost(4, 4, '4 is less than or equal to 4');
.isTrue(value, [message])
断言 value 为真。
var teaServed = true;
assert.isTrue(teaServed, 'the tea has been served');
.isNotTrue(value, [message])
断言 value 不为真。
var tea = 'tasty chai';
assert.isNotTrue(tea, 'great, time for tea!');
.isFalse(value, [message])
断言 value 为假。
var teaServed = false;
assert.isFalse(teaServed, 'no tea yet? hmm...');
.isNotFalse(value, [message])
断言 value 不为假。
var tea = 'tasty chai';
assert.isNotFalse(tea, 'great, time for tea!');
.isNull(value, [message])
断言 value 为 null。
assert.isNull(err, 'there was no error');
.isNotNull(value, [message])
断言 value 不为 null。
var tea = 'tasty chai';
assert.isNotNull(tea, 'great, time for tea!');
.isNaN
断言 value 为 NaN。
assert.isNaN(NaN, 'NaN is NaN');
.isNotNaN
断言 value 不为 NaN。
assert.isNotNaN(4, '4 is not NaN');
.exists
断言目标既不为 null 也不为 undefined。
var foo = 'hi';
assert.exists(foo, 'foo is neither `null` nor `undefined`');
.notExists
断言目标为 null 或 undefined。
var bar = null
, baz;
assert.notExists(bar);
assert.notExists(baz, 'baz is either null or undefined');
.isUndefined(value, [message])
断言 value 为 undefined。
var tea;
assert.isUndefined(tea, 'no tea defined');
.isDefined(value, [message])
断言 value 不是 undefined。
var tea = 'cup of chai';
assert.isDefined(tea, 'tea has been defined');
.isFunction(value, [message])
断言 value 是一个函数。
function serveTea() { return 'cup of tea'; };
assert.isFunction(serveTea, 'great, we can have tea now');
.isNotFunction(value, [message])
断言 value 不是 一个函数。
var serveTea = [ 'heat', 'pour', 'sip' ];
assert.isNotFunction(serveTea, 'great, we have listed the steps');
.isObject(value, [message])
断言 value 是一个类型为 ‘Object’ 的对象（通过 Object.prototype.toString 揭示）。此断言不匹配子类对象。
var selection = { name: 'Chai', serve: 'with spices' };
assert.isObject(selection, 'tea selection is an object');
.isNotObject(value, [message])
断言 value 不是 一个类型为 ‘Object’ 的对象（通过 Object.prototype.toString 揭示）。
var selection = 'chai'
assert.isNotObject(selection, 'tea selection is not an object');
assert.isNotObject(null, 'null is not an object');
.isArray(value, [message])
断言 value 是一个数组。
var menu = [ 'green', 'chai', 'oolong' ];
assert.isArray(menu, 'what kind of tea do we want?');
.isNotArray(value, [message])
断言 value 不是 一个数组。
var menu = 'green|chai|oolong';
assert.isNotArray(menu, 'what kind of tea do we want?');
.isString(value, [message])
断言 value 是一个字符串。
var teaOrder = 'chai';
assert.isString(teaOrder, 'order placed');
.isNotString(value, [message])
断言 value 不是 一个字符串。
var teaOrder = 4;
assert.isNotString(teaOrder, 'order placed');
.isNumber(value, [message])
断言 value 是一个数字。
var cups = 2;
assert.isNumber(cups, 'how many cups');
.isNotNumber(value, [message])
断言 value 不是 一个数字。
var cups = '2 cups please';
assert.isNotNumber(cups, 'how many cups');
.isFinite(value, [message])
断言 value 是一个有限数字。与 .isNumber 不同，这对于 NaN 和 Infinity 会失败。
var cups = 2;
assert.isFinite(cups, 'how many cups');
assert.isFinite(NaN); // throws
.isBoolean(value, [message])
断言 value 是一个布尔值。
var teaReady = true
, teaServed = false;
assert.isBoolean(teaReady, 'is the tea ready');
assert.isBoolean(teaServed, 'has tea been served');
.isNotBoolean(value, [message])
断言 value 不是 一个布尔值。
var teaReady = 'yep'
, teaServed = 'nope';
assert.isNotBoolean(teaReady, 'is the tea ready');
assert.isNotBoolean(teaServed, 'has tea been served');
.typeOf(value, name, [message])
断言 value 的类型是 name，由 Object.prototype.toString 决定。
assert.typeOf({ tea: 'chai' }, 'object', 'we have an object');
assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array');
assert.typeOf('tea', 'string', 'we have a string');
assert.typeOf(/tea/, 'regexp', 'we have a regular expression');
assert.typeOf(null, 'null', 'we have a null');
assert.typeOf(undefined, 'undefined', 'we have an undefined');
.notTypeOf(value, name, [message])
断言 value 的类型不是 name，由 Object.prototype.toString 决定。
assert.notTypeOf('tea', 'number', 'strings are not numbers');
.instanceOf(object, constructor, [message])
断言 value 是 constructor 的实例。
var Tea = function (name) { this.name = name; }
, chai = new Tea('chai');
assert.instanceOf(chai, Tea, 'chai is an instance of tea');
.notInstanceOf(object, constructor, [message])
断言 value 不是 constructor 的实例。
var Tea = function (name) { this.name = name; }
, chai = new String('chai');
assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea');
.include(haystack, needle, [message])
断言 haystack 包含 needle。可以用来断言数组中是否包含一个值、字符串中是否包含一个子字符串、或者对象中是否包含一组属性。
assert.include([1,2,3], 2, 'array contains value');
assert.include('foobar', 'foo', 'string contains substring');
assert.include({ foo: 'bar', hello: 'universe' }, { foo: 'bar' }, 'object contains property');
使用严格相等（===）。当断言数组中是否包含一个值时，会搜索该数组中是否包含严格等于给定值的元素。当断言对象中是否包含一组属性时，会搜索该对象中是否包含给定的属性键，并检查每个属性键是否存在并且是否严格等于给定的属性值。例如
var obj1 = {a: 1}
, obj2 = {b: 2};
assert.include([obj1, obj2], obj1);
assert.include({foo: obj1, bar: obj2}, {foo: obj1});
assert.include({foo: obj1, bar: obj2}, {foo: obj1, bar: obj2});
.notInclude(haystack, needle, [message])
断言 haystack 不包含 needle。可以用来断言数组中是否不包含一个值、字符串中是否不包含一个子字符串、或者对象中是否不包含一组属性。
assert.notInclude([1,2,3], 4, "array doesn't contain value");
assert.notInclude('foobar', 'baz', "string doesn't contain substring");
assert.notInclude({ foo: 'bar', hello: 'universe' }, { foo: 'baz' }, 'object doesn't contain property');
使用严格相等（===）。当断言数组中是否不包含一个值时，会搜索该数组以确认是否不存在严格等于给定值的元素。当断言对象中是否不包含一组属性时，会搜索该对象以确认给定的属性键中至少有一个不存在或不严格等于给定的属性值。例如
var obj1 = {a: 1}
, obj2 = {b: 2};
assert.notInclude([obj1, obj2], {a: 1});
assert.notInclude({foo: obj1, bar: obj2}, {foo: {a: 1}});
assert.notInclude({foo: obj1, bar: obj2}, {foo: obj1, bar: {b: 2}});
.deepInclude(haystack, needle, [message])
断言 haystack 包含 needle。可以用来断言数组中是否包含一个值或对象中是否包含一组属性。使用深度相等。
var obj1 = {a: 1}
, obj2 = {b: 2};
assert.deepInclude([obj1, obj2], {a: 1});
assert.deepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}});
assert.deepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}, bar: {b: 2}});
.notDeepInclude(haystack, needle, [message])
断言 haystack 不包含 needle。可以用来断言数组中是否不包含一个值或对象中是否不包含一组属性。使用深度相等。
var obj1 = {a: 1}
, obj2 = {b: 2};
assert.notDeepInclude([obj1, obj2], {a: 9});
assert.notDeepInclude({foo: obj1, bar: obj2}, {foo: {a: 9}});
assert.notDeepInclude({foo: obj1, bar: obj2}, {foo: {a: 1}, bar: {b: 9}});
.nestedInclude(haystack, needle, [message])
断言 ‘haystack’ 包含 ‘needle’。可以用来断言对象中是否包含一组属性。允许使用点和括号表示法来引用嵌套属性。属性名中的 ‘[]’ 和 ‘.’ 可以使用双反斜杠转义。
assert.nestedInclude({'.a': {'b': 'x'}}, {'\\.a.[b]': 'x'});
assert.nestedInclude({'a': {'[b]': 'x'}}, {'a.\\[b\\]': 'x'});
.notNestedInclude(haystack, needle, [message])
断言 ‘haystack’ 不包含 ‘needle’。可以用来断言对象中是否不包含一组属性。允许使用点和括号表示法来引用嵌套属性。属性名中的 ‘[]’ 和 ‘.’ 可以使用双反斜杠转义。
assert.notNestedInclude({'.a': {'b': 'x'}}, {'\\.a.b': 'y'});
assert.notNestedInclude({'a': {'[b]': 'x'}}, {'a.\\[b\\]': 'y'});
.deepNestedInclude(haystack, needle, [message])
断言 ‘haystack’ 包含 ‘needle’。可以用来断言对象中是否包含一组属性，同时检查深度相等性。允许使用点和括号表示法来引用嵌套属性。属性名中的 ‘[]’ 和 ‘.’ 可以使用双反斜杠转义。
assert.deepNestedInclude({a: {b: [{x: 1}]}}, {'a.b[0]': {x: 1}});
assert.deepNestedInclude({'.a': {'[b]': {x: 1}}}, {'\\.a.\\[b\\]': {x: 1}});
.notDeepNestedInclude(haystack, needle, [message])
断言 ‘haystack’ 不包含 ‘needle’。可以用来断言对象中是否不包含一组属性，同时检查深度相等性。允许使用点和括号表示法来引用嵌套属性。属性名中的 ‘[]’ 和 ‘.’ 可以使用双反斜杠转义。
assert.notDeepNestedInclude({a: {b: [{x: 1}]}}, {'a.b[0]': {y: 1}})
assert.notDeepNestedInclude({'.a': {'[b]': {x: 1}}}, {'\\.a.\\[b\\]': {y: 2}});
.ownInclude(haystack, needle, [message])
断言 ‘haystack’ 包含 ‘needle’。可以用来断言对象中是否包含一组属性，同时忽略继承的属性。
assert.ownInclude({ a: 1 }, { a: 1 });
.notOwnInclude(haystack, needle, [message])
断言 ‘haystack’ 包含 ‘needle’。可以用来断言对象中是否不包含一组属性，同时忽略继承的属性。
Object.prototype.b = 2;
assert.notOwnInclude({ a: 1 }, { b: 2 });
.deepOwnInclude(haystack, needle, [message])
断言 ‘haystack’ 包含 ‘needle’。可以用来断言对象中是否包含一组属性，同时忽略继承的属性并检查深度相等性。
assert.deepOwnInclude({a: {b: 2}}, {a: {b: 2}});
.notDeepOwnInclude(haystack, needle, [message])
断言 ‘haystack’ 包含 ‘needle’。可以用来断言对象中是否不包含一组属性，同时忽略继承的属性并检查深度相等性。
assert.notDeepOwnInclude({a: {b: 2}}, {a: {c: 3}});
.match(value, regexp, [message])
断言 value 匹配正则表达式 regexp。
assert.match('foobar', /^foo/, 'regexp matches');
.notMatch(value, regexp, [message])
断言 value 不匹配正则表达式 regexp。
assert.notMatch('foobar', /^foo/, 'regexp does not match');
.property(object, property, [message])
断言 object 具有由 property 指定的直接或继承属性。
assert.property({ tea: { green: 'matcha' }}, 'tea');
assert.property({ tea: { green: 'matcha' }}, 'toString');
.notProperty(object, property, [message])
断言 object 没有 由 property 指定的直接或继承属性。
assert.notProperty({ tea: { green: 'matcha' }}, 'coffee');
.propertyVal(object, property, value, [message])
断言 object 具有由 property 指定的直接或继承属性，其值为 value。使用严格相等检查（===）。
assert.propertyVal({ tea: 'is good' }, 'tea', 'is good');
.notPropertyVal(object, property, value, [message])
断言 object 没有 由 property 指定的直接或继承属性，其值为 value。使用严格相等检查（===）。
assert.notPropertyVal({ tea: 'is good' }, 'tea', 'is bad');
assert.notPropertyVal({ tea: 'is good' }, 'coffee', 'is good');
.deepPropertyVal(object, property, value, [message])
断言 object 具有由 property 指定的直接或继承属性，其值为 value。使用深度相等检查。
assert.deepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'matcha' });
.notDeepPropertyVal(object, property, value, [message])
断言 object 没有 由 property 指定的直接或继承属性，其值为 value。使用深度相等检查。
assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { black: 'matcha' });
assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'tea', { green: 'oolong' });
assert.notDeepPropertyVal({ tea: { green: 'matcha' } }, 'coffee', { green: 'matcha' });
.nestedProperty(object, property, [message])
断言 object 具有由 property 指定的直接或继承属性，它可以是一个字符串，使用点和括号表示法来引用嵌套的引用。
assert.nestedProperty({ tea: { green: 'matcha' }}, 'tea.green');
.notNestedProperty(object, property, [message])
断言 object 没有 由 property 指定的属性，它可以是一个字符串，使用点和括号表示法来引用嵌套的引用。该属性不能存在于对象上，也不能存在于其原型链中的任何地方。
assert.notNestedProperty({ tea: { green: 'matcha' }}, 'tea.oolong');
.nestedPropertyVal(object, property, value, [message])
断言 object 具有由 property 指定的属性，其值为 value 给出。 property 可以使用点和方括号表示法进行嵌套引用。使用严格相等检查 (===)。
assert.nestedPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha');
.notNestedPropertyVal(object, property, value, [message])
断言 object 没有 由 property 指定的属性，其值为 value 给出。 property 可以使用点和方括号表示法进行嵌套引用。使用严格相等检查 (===)。
assert.notNestedPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha');
assert.notNestedPropertyVal({ tea: { green: 'matcha' }}, 'coffee.green', 'matcha');
.deepNestedPropertyVal(object, property, value, [message])
断言 object 具有由 property 指定的属性，其值为 value 给出。 property 可以使用点和方括号表示法进行嵌套引用。使用深度相等检查。
assert.deepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { matcha: 'yum' });
.notDeepNestedPropertyVal(object, property, value, [message])
断言 object 没有 由 property 指定的属性，其值为 value 给出。 property 可以使用点和方括号表示法进行嵌套引用。使用深度相等检查。
assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { oolong: 'yum' });
assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.green', { matcha: 'yuck' });
assert.notDeepNestedPropertyVal({ tea: { green: { matcha: 'yum' } } }, 'tea.black', { matcha: 'yum' });
.lengthOf(object, length, [message])
断言 object 具有预期的 length 或 size 值。
assert.lengthOf([1,2,3], 3, 'array has length of 3');
assert.lengthOf('foobar', 6, 'string has length of 6');
assert.lengthOf(new Set([1,2,3]), 3, 'set has size of 3');
assert.lengthOf(new Map([['a',1],['b',2],['c',3]]), 3, 'map has size of 3');
.hasAnyKeys(object, [keys], [message])
断言 object 至少拥有一个提供的 keys。你也可以提供一个单独的对象而不是一个 keys 数组，它的键将被用作预期的键集。
assert.hasAnyKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'iDontExist', 'baz']);
assert.hasAnyKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, iDontExist: 99, baz: 1337});
assert.hasAnyKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);
assert.hasAnyKeys(new Set([{foo: 'bar'}, 'anotherKey']), [{foo: 'bar'}, 'anotherKey']);
.hasAllKeys(object, [keys], [message])
断言 object 拥有且仅拥有所有提供的 keys。你也可以提供一个单独的对象而不是一个 keys 数组，它的键将被用作预期的键集。
assert.hasAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'bar', 'baz']);
assert.hasAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, bar: 99, baz: 1337]);
assert.hasAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);
assert.hasAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}, 'anotherKey']);
.containsAllKeys(object, [keys], [message])
断言 object 拥有所有提供的 keys，但可能还有更多未列出的键。你也可以提供一个单独的对象而不是一个 keys 数组，它的键将被用作预期的键集。
assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'baz']);
assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, ['foo', 'bar', 'baz']);
assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, baz: 1337});
assert.containsAllKeys({foo: 1, bar: 2, baz: 3}, {foo: 30, bar: 99, baz: 1337});
assert.containsAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}]);
assert.containsAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{foo: 1}, 'key']);
assert.containsAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}]);
assert.containsAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{foo: 'bar'}, 'anotherKey']);
.doesNotHaveAnyKeys(object, [keys], [message])
断言 object 不拥有任何提供的 keys。你也可以提供一个单独的对象而不是一个 keys 数组，它的键将被用作预期的键集。
assert.doesNotHaveAnyKeys({foo: 1, bar: 2, baz: 3}, ['one', 'two', 'example']);
assert.doesNotHaveAnyKeys({foo: 1, bar: 2, baz: 3}, {one: 1, two: 2, example: 'foo'});
assert.doesNotHaveAnyKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{one: 'two'}, 'example']);
assert.doesNotHaveAnyKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{one: 'two'}, 'example']);
.doesNotHaveAllKeys(object, [keys], [message])
断言 object 至少不拥有一个提供的 keys。你也可以提供一个单独的对象而不是一个 keys 数组，它的键将被用作预期的键集。
assert.doesNotHaveAllKeys({foo: 1, bar: 2, baz: 3}, ['one', 'two', 'example']);
assert.doesNotHaveAllKeys({foo: 1, bar: 2, baz: 3}, {one: 1, two: 2, example: 'foo'});
assert.doesNotHaveAllKeys(new Map([[{foo: 1}, 'bar'], ['key', 'value']]), [{one: 'two'}, 'example']);
assert.doesNotHaveAllKeys(new Set([{foo: 'bar'}, 'anotherKey'], [{one: 'two'}, 'example']);
.hasAnyDeepKeys(object, [keys], [message])
断言 object 至少拥有一个提供的 keys。由于 Set 和 Map 可以拥有对象作为键，你可以使用这个断言来进行深度比较。你也可以提供一个单独的对象而不是一个 keys 数组，它的键将被用作预期的键集。
assert.hasAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {one: 'one'});
assert.hasAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), [{one: 'one'}, {two: 'two'}]);
assert.hasAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{one: 'one'}, {two: 'two'}]);
assert.hasAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {one: 'one'});
assert.hasAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {three: 'three'}]);
assert.hasAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {two: 'two'}]);
.hasAllDeepKeys(object, [keys], [message])
断言 object 拥有且仅拥有所有提供的 keys。由于 Set 和 Map 可以拥有对象作为键，你可以使用这个断言来进行深度比较。你也可以提供一个单独的对象而不是一个 keys 数组，它的键将被用作预期的键集。
assert.hasAllDeepKeys(new Map([[{one: 'one'}, 'valueOne']]), {one: 'one'});
assert.hasAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{one: 'one'}, {two: 'two'}]);
assert.hasAllDeepKeys(new Set([{one: 'one'}]), {one: 'one'});
assert.hasAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {two: 'two'}]);
.containsAllDeepKeys(object, [keys], [message])
断言 object 包含所有提供的 keys。由于 Set 和 Map 可以拥有对象作为键，你可以使用这个断言来进行深度比较。你也可以提供一个单独的对象而不是一个 keys 数组，它的键将被用作预期的键集。
assert.containsAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {one: 'one'});
assert.containsAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{one: 'one'}, {two: 'two'}]);
assert.containsAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {one: 'one'});
assert.containsAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {two: 'two'}]);
.doesNotHaveAnyDeepKeys(object, [keys], [message])
断言 object 不拥有任何提供的 keys。由于 Set 和 Map 可以拥有对象作为键，你可以使用这个断言来进行深度比较。你也可以提供一个单独的对象而不是一个 keys 数组，它的键将被用作预期的键集。
assert.doesNotHaveAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {thisDoesNot: 'exist'});
assert.doesNotHaveAnyDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{twenty: 'twenty'}, {fifty: 'fifty'}]);
assert.doesNotHaveAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {twenty: 'twenty'});
assert.doesNotHaveAnyDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{twenty: 'twenty'}, {fifty: 'fifty'}]);
.doesNotHaveAllDeepKeys(object, [keys], [message])
断言 object 至少不拥有一个提供的 keys。由于 Set 和 Map 可以拥有对象作为键，你可以使用这个断言来进行深度比较。你也可以提供一个单独的对象而不是一个 keys 数组，它的键将被用作预期的键集。
assert.doesNotHaveAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [1, 2]]), {thisDoesNot: 'exist'});
assert.doesNotHaveAllDeepKeys(new Map([[{one: 'one'}, 'valueOne'], [{two: 'two'}, 'valueTwo']]), [{twenty: 'twenty'}, {one: 'one'}]);
assert.doesNotHaveAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), {twenty: 'twenty'});
assert.doesNotHaveAllDeepKeys(new Set([{one: 'one'}, {two: 'two'}]), [{one: 'one'}, {fifty: 'fifty'}]);
.throws(fn, [errorLike/string/regexp], [string/regexp], [message])
如果 errorLike 是一个 Error 构造函数，则断言 fn 将抛出一个 errorLike 实例的错误。如果 errorLike 是一个 Error 实例，则断言抛出的错误与 errorLike 是同一个实例。如果提供了 errMsgMatcher，它还断言抛出的错误将具有与 errMsgMatcher 相匹配的消息。
assert.throws(fn, 'Error thrown must have this msg');
assert.throws(fn, /Error thrown must have a msg that matches this/);
assert.throws(fn, ReferenceError);
assert.throws(fn, errorInstance);
assert.throws(fn, ReferenceError, 'Error thrown must be a ReferenceError and have this msg');
assert.throws(fn, errorInstance, 'Error thrown must be the same errorInstance and have this msg');
assert.throws(fn, ReferenceError, /Error thrown must be a ReferenceError and match this/);
assert.throws(fn, errorInstance, /Error thrown must be the same errorInstance and match this/);
.doesNotThrow(fn, [errorLike/string/regexp], [string/regexp], [message])
如果 errorLike 是一个 Error 构造函数，则断言 fn 不会 抛出一个 errorLike 实例的错误。如果 errorLike 是一个 Error 实例，则断言抛出的错误不是 与 errorLike 是同一个实例。如果提供了 errMsgMatcher，它还断言抛出的错误不会 具有与 errMsgMatcher 相匹配的消息。
assert.doesNotThrow(fn, 'Any Error thrown must not have this message');
assert.doesNotThrow(fn, /Any Error thrown must not match this/);
assert.doesNotThrow(fn, Error);
assert.doesNotThrow(fn, errorInstance);
assert.doesNotThrow(fn, Error, 'Error must not have this message');
assert.doesNotThrow(fn, errorInstance, 'Error must not have this message');
assert.doesNotThrow(fn, Error, /Error must not match this/);
assert.doesNotThrow(fn, errorInstance, /Error must not match this/);
.operator(val1, operator, val2, [message])
使用 operator 比较两个值。
assert.operator(1, '<', 2, 'everything is ok');
assert.operator(1, '>', 2, 'this will fail');
.closeTo(actual, expected, delta, [message])
断言目标等于 expected，误差范围在 +/- delta 内。
assert.closeTo(1.5, 1, 0.5, 'numbers are close');
.approximately(actual, expected, delta, [message])
断言目标等于 expected，误差范围在 +/- delta 内。
assert.approximately(1.5, 1, 0.5, 'numbers are close');
.sameMembers(set1, set2, [message])
断言 set1 和 set2 具有相同的成员，但顺序可以不同。使用严格相等检查 (===)。
assert.sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members');
.notSameMembers(set1, set2, [message])
断言 set1 和 set2 不具有相同的成员，但顺序可以不同。使用严格相等检查 (===)。
assert.notSameMembers([ 1, 2, 3 ], [ 5, 1, 3 ], 'not same members');
.sameDeepMembers(set1, set2, [message])
断言 set1 和 set2 具有相同的成员，但顺序可以不同。使用深度相等检查。
assert.sameDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [{ b: 2 }, { a: 1 }, { c: 3 }], 'same deep members');
.notSameDeepMembers(set1, set2, [message])
断言 set1 和 set2 不具有相同的成员，但顺序可以不同。使用深度相等检查。
assert.notSameDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [{ b: 2 }, { a: 1 }, { f: 5 }], 'not same deep members');
.sameOrderedMembers(set1, set2, [message])
断言 set1 和 set2 具有相同的成员，并且顺序也相同。使用严格相等检查 (===)。
assert.sameOrderedMembers([ 1, 2, 3 ], [ 1, 2, 3 ], 'same ordered members');
.notSameOrderedMembers(set1, set2, [message])
断言 set1 和 set2 的成员不相同或顺序不同。使用严格相等比较 (===)。
assert.notSameOrderedMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'not same ordered members');
.sameDeepOrderedMembers(set1, set2, [message])
断言 set1 和 set2 的成员相同且顺序相同。使用深度相等比较。
assert.sameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 }, { c: 3 } ], 'same deep ordered members');
.notSameDeepOrderedMembers(set1, set2, [message])
断言 set1 和 set2 的成员不相同或顺序不同。使用深度相等比较。
assert.notSameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 }, { z: 5 } ], 'not same deep ordered members');
assert.notSameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 }, { c: 3 } ], 'not same deep ordered members');
.includeMembers(superset, subset, [message])
断言 subset 被包含在 superset 中，顺序可以不同。使用严格相等比较 (===)。忽略重复项。
assert.includeMembers([ 1, 2, 3 ], [ 2, 1, 2 ], 'include members');
.notIncludeMembers(superset, subset, [message])
断言 subset 未被包含在 superset 中，顺序可以不同。使用严格相等比较 (===)。忽略重复项。
assert.notIncludeMembers([ 1, 2, 3 ], [ 5, 1 ], 'not include members');
.includeDeepMembers(superset, subset, [message])
断言 subset 被包含在 superset 中，顺序可以不同。使用深度相等比较。忽略重复项。
assert.includeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 }, { b: 2 } ], 'include deep members');
.notIncludeDeepMembers(superset, subset, [message])
断言 subset 未被包含在 superset 中，顺序可以不同。使用深度相等比较。忽略重复项。
assert.notIncludeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { f: 5 } ], 'not include deep members');
.includeOrderedMembers(superset, subset, [message])
断言 subset 被包含在 superset 中，顺序相同，从 superset 中的第一个元素开始。使用严格相等比较 (===)。
assert.includeOrderedMembers([ 1, 2, 3 ], [ 1, 2 ], 'include ordered members');
.notIncludeOrderedMembers(superset, subset, [message])
断言 subset 未被包含在 superset 中，顺序相同，从 superset 中的第一个元素开始。使用严格相等比较 (===)。
assert.notIncludeOrderedMembers([ 1, 2, 3 ], [ 2, 1 ], 'not include ordered members');
assert.notIncludeOrderedMembers([ 1, 2, 3 ], [ 2, 3 ], 'not include ordered members');
.includeDeepOrderedMembers(superset, subset, [message])
断言 subset 被包含在 superset 中，顺序相同，从 superset 中的第一个元素开始。使用深度相等比较。
assert.includeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 } ], 'include deep ordered members');
.notIncludeDeepOrderedMembers(superset, subset, [message])
断言 subset 未被包含在 superset 中，顺序相同，从 superset 中的第一个元素开始。使用深度相等比较。
assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { f: 5 } ], 'not include deep ordered members');
assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 } ], 'not include deep ordered members');
assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { c: 3 } ], 'not include deep ordered members');
.oneOf(inList, list, [message])
断言非对象、非数组值 inList 出现在扁平数组 list 中。
assert.oneOf(1, [ 2, 1 ], 'Not found in list');
.changes(function, object, property, [message])
断言函数更改属性的值。
var obj = { val: 10 };
var fn = function() { obj.val = 22 };
assert.changes(fn, obj, 'val');
.changesBy(function, object, property, delta, [message])
断言函数更改属性的值，改变量为 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val += 2 };
assert.changesBy(fn, obj, 'val', 2);
.doesNotChange(function, object, property, [message])
断言函数不更改属性的值。
var obj = { val: 10 };
var fn = function() { console.log('foo'); };
assert.doesNotChange(fn, obj, 'val');
.changesButNotBy(function, object, property, delta, [message])
断言函数不更改属性的值或函数返回值的改变量为 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val += 10 };
assert.changesButNotBy(fn, obj, 'val', 5);
.increases(function, object, property, [message])p>
断言函数增加数值型对象属性的值。
var obj = { val: 10 };
var fn = function() { obj.val = 13 };
assert.increases(fn, obj, 'val');
.increasesBy(function, object, property, delta, [message])
断言函数增加数值型对象属性或函数返回值的值，改变量为 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val += 10 };
assert.increasesBy(fn, obj, 'val', 10);
.doesNotIncrease(function, object, property, [message])
断言函数不增加数值型对象属性的值。
var obj = { val: 10 };
var fn = function() { obj.val = 8 };
assert.doesNotIncrease(fn, obj, 'val');
.increasesButNotBy(function, object, property, delta, [message])
断言函数不增加数值型对象属性或函数返回值的值，改变量为 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val = 15 };
assert.increasesButNotBy(fn, obj, 'val', 10);
.decreases(function, object, property, [message])
断言函数减少数值型对象属性的值。
var obj = { val: 10 };
var fn = function() { obj.val = 5 };
assert.decreases(fn, obj, 'val');
.decreasesBy(function, object, property, delta, [message])
断言函数减少数值型对象属性或函数返回值的值，改变量为 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val -= 5 };
assert.decreasesBy(fn, obj, 'val', 5);
.doesNotDecrease(function, object, property, [message])
断言函数不减少数值型对象属性的值。
var obj = { val: 10 };
var fn = function() { obj.val = 15 };
assert.doesNotDecrease(fn, obj, 'val');
.doesNotDecreaseBy(function, object, property, delta, [message])
断言函数不减少数值型对象属性或函数返回值的值，改变量为 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val = 5 };
assert.doesNotDecreaseBy(fn, obj, 'val', 1);
.decreasesButNotBy(function, object, property, delta, [message])
断言函数不减少数值型对象属性或函数返回值的值，改变量为 (delta)。
var obj = { val: 10 };
var fn = function() { obj.val = 5 };
assert.decreasesButNotBy(fn, obj, 'val', 1);
.ifError(object)
断言如果值不是假值，如果它是真值则抛出错误。这是为了允许 chai 作为 Node 的 assert 类的一个直接替代品。
var err = new Error('I am a custom error');
assert.ifError(err); // Rethrows err!
.isExtensible(object)
断言 object 是可扩展的（可以向其添加新的属性）。
assert.isExtensible({});
.isNotExtensible(object)
断言 object 不可扩展。
var nonExtensibleObject = Object.preventExtensions({});
var sealedObject = Object.seal({});
var frozenObject = Object.freeze({});
assert.isNotExtensible(nonExtensibleObject);
assert.isNotExtensible(sealedObject);
assert.isNotExtensible(frozenObject);
.isSealed(object)
断言 object 是密封的（不能向其添加新的属性，也不能删除其现有属性）。
var sealedObject = Object.seal({});
var frozenObject = Object.seal({});
assert.isSealed(sealedObject);
assert.isSealed(frozenObject);
.isNotSealed(object)
断言 object 未被密封。
assert.isNotSealed({});
.isFrozen(object)
断言 object 是冻结的（不能向其添加新的属性，也不能修改其现有属性）。
var frozenObject = Object.freeze({});
assert.frozen(frozenObject);
.isNotFrozen(object)
断言 object 未被冻结。
assert.isNotFrozen({});
.isEmpty(target)
断言目标不包含任何值。对于数组和字符串，它检查 length 属性。对于 Map 和 Set 实例，它检查 size 属性。对于非函数对象，它获取自身可枚举字符串键的数量。
assert.isEmpty([]);
assert.isEmpty('');
assert.isEmpty(new Map);
assert.isEmpty({});
.isNotEmpty(target)
断言目标包含值。对于数组和字符串，它检查 length 属性。对于 Map 和 Set 实例，它检查 size 属性。对于非函数对象，它获取自身可枚举字符串键的数量。
assert.isNotEmpty([1, 2]);
assert.isNotEmpty('34');
assert.isNotEmpty(new Set([5, 6]));
assert.isNotEmpty({ key: 7 });