kylefang/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/zhigang1992/DefinitelyTyped.git synced 2026-06-04 19:42:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

Adds support for .ordered flag when using the assert syntax.

Browse Source
This commit is contained in:
Thomas Corbière
2017-06-22 10:48:44 +02:00
parent 238e4dd742
commit e04a94ed93
2 changed files with 98 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
types/chai/chai-tests.ts
View File

@@ -1023,6 +1023,16 @@ function orderedMembers() {
expect([1, 2, 3]).to.have.ordered.members([1, 2, 3]);
expect([1, 2, 3]).to.have.members([2, 1, 3]).but.not.ordered.members([2, 1, 3]);
expect([{a: 1}, {b: 2}, {c: 3}]).to.include.deep.ordered.members([{a: 1}, {b: 2}]).but.not.include.deep.ordered.members([{b: 2}, {c: 3}]);
assert.sameOrderedMembers([ 1, 2, 3 ], [ 1, 2, 3 ], 'same ordered members');
assert.notSameOrderedMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'not same ordered members');
assert.sameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 }, { c: 3 } ], 'same deep ordered members');
assert.notSameDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { a: 1 }, { c: 3 } ], 'not same deep ordered members');
assert.includeOrderedMembers([ 1, 2, 3 ], [ 1, 2 ], 'include ordered members');
assert.notIncludeOrderedMembers([ 1, 2, 3 ], [ 2, 1 ], 'not include ordered members');
assert.includeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { a: 1 }, { b: 2 } ], 'include deep ordered members');
assert.notIncludeDeepOrderedMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { c: 3 } ], 'not include deep ordered members');
}
function members() {

88
types/chai/index.d.ts vendored
View File

@@ -1009,6 +1009,94 @@ declare namespace Chai {
*/
sameDeepMembers<T>(set1: T[], set2: T[], message?: string): void;
/**
* Asserts that set1 and set2 have the same members in the same order.
* Uses a strict equality check (===).
*
* @type T Type of set values.
* @param set1 Actual set of values.
* @param set2 Potential expected set of values.
* @param message Message to display on error.
*/
sameOrderedMembers<T>(set1: T[], set2: T[], message?: string): void;
/**
* Asserts that set1 and set2 don’t have the same members in the same order.
* Uses a strict equality check (===).
*
* @type T Type of set values.
* @param set1 Actual set of values.
* @param set2 Potential expected set of values.
* @param message Message to display on error.
*/
notSameOrderedMembers<T>(set1: T[], set2: T[], message?: string): void;
/**
* Asserts that set1 and set2 have the same members in the same order.
* Uses a deep equality check.
*
* @type T Type of set values.
* @param set1 Actual set of values.
* @param set2 Potential expected set of values.
* @param message Message to display on error.
*/
sameDeepOrderedMembers<T>(set1: T[], set2: T[], message?: string): void;
/**
* Asserts that set1 and set2 don’t have the same members in the same order.
* Uses a deep equality check.
*
* @type T Type of set values.
* @param set1 Actual set of values.
* @param set2 Potential expected set of values.
* @param message Message to display on error.
*/
notSameDeepOrderedMembers<T>(set1: T[], set2: T[], message?: string): void;
/**
* Asserts that subset is included in superset in the same order beginning with the first element in superset.
* Uses a strict equality check (===).
*
* @type T Type of set values.
* @param superset Actual set of values.
* @param subset Potential contained set of values.
* @param message Message to display on error.
*/
includeOrderedMembers<T>(superset: T[], subset: T[], message?: string): void;
/**
* Asserts that subset isn’t included in superset in the same order beginning with the first element in superset.
* Uses a strict equality check (===).
*
* @type T Type of set values.
* @param superset Actual set of values.
* @param subset Potential contained set of values.
* @param message Message to display on error.
*/
notIncludeOrderedMembers<T>(superset: T[], subset: T[], message?: string): void;
/**
* Asserts that subset is included in superset in the same order beginning with the first element in superset.
* Uses a deep equality check.
*
* @type T Type of set values.
* @param superset Actual set of values.
* @param subset Potential contained set of values.
* @param message Message to display on error.
*/
includeDeepOrderedMembers<T>(superset: T[], subset: T[], message?: string): void;
/**
* Asserts that subset isn’t included in superset in the same order beginning with the first element in superset.
* Uses a deep equality check.
*
* @type T Type of set values.
* @param superset Actual set of values.
* @param subset Potential contained set of values.
* @param message Message to display on error.
*/
notIncludeDeepOrderedMembers<T>(superset: T[], subset: T[], message?: string): void;
/**
* Asserts that subset is included in superset. Order is not take into account.
*