@@ -2548,7 +2548,7 @@ assert.throws(throwingFirst, /Second$/);
2548
2548
Due to the confusing error-prone notation, avoid a string as the second
2549
2549
argument.
2550
2550
2551
- ## ` assert.deepMatch (actual, expected[, message]) `
2551
+ ## ` assert.partialDeepEqual (actual, expected[, message]) `
2552
2552
2553
2553
<!-- YAML
2554
2554
added: REPLACEME
@@ -2558,54 +2558,54 @@ added: REPLACEME
2558
2558
* ` expected ` {any}
2559
2559
* ` message ` {string|Error}
2560
2560
2561
- [ ` assert.deepMatch () ` ] [ ] evaluates the equivalence between the ` actual ` and ` expected ` parameters by
2561
+ [ ` assert.partialDeepEqual () ` ] [ ] evaluates the equivalence between the ` actual ` and ` expected ` parameters by
2562
2562
performing a deep comparison. This function ensures that all properties defined
2563
2563
in the ` expected ` parameter match those in the ` actual ` parameter in
2564
2564
both value and type, allowing type coercion. The main difference with [ ` assert.deepEqual() ` ] [ ] is that
2565
- [ ` assert.deepMatch () ` ] [ ] does not require all properties in the ` actual ` parameter to be present in the
2565
+ [ ` assert.partialDeepEqual () ` ] [ ] does not require all properties in the ` actual ` parameter to be present in the
2566
2566
` expected ` parameter.
2567
2567
2568
2568
``` mjs
2569
2569
import assert from ' node:assert' ;
2570
2570
2571
- assert .deepMatch ({ a: 1 , b: ' 2' }, { a: 1 , b: 2 });
2571
+ assert .partialDeepEqual ({ a: 1 , b: ' 2' }, { a: 1 , b: 2 });
2572
2572
// OK
2573
2573
2574
- assert .deepMatch ({ a: 1 , b: ' 2' , c: 3 }, { a: 1 , b: 2 });
2574
+ assert .partialDeepEqual ({ a: 1 , b: ' 2' , c: 3 }, { a: 1 , b: 2 });
2575
2575
// OK
2576
2576
2577
- assert .deepMatch ({ a: { b: { c: ' 1' } } }, { a: { b: { c: 1 } } });
2577
+ assert .partialDeepEqual ({ a: { b: { c: ' 1' } } }, { a: { b: { c: 1 } } });
2578
2578
// OK
2579
2579
2580
- assert .deepMatch ({ a: 1 }, { a: 1 , b: 2 });
2580
+ assert .partialDeepEqual ({ a: 1 }, { a: 1 , b: 2 });
2581
2581
// AssertionError
2582
2582
2583
- assert .deepMatch ({ a: 1 , b: true }, { a: 1 , b: ' true' });
2583
+ assert .partialDeepEqual ({ a: 1 , b: true }, { a: 1 , b: ' true' });
2584
2584
// AssertionError
2585
2585
2586
- assert .deepMatch ({ a: { b: 2 } }, { a: { b: 2 , c: 3 } });
2586
+ assert .partialDeepEqual ({ a: { b: 2 } }, { a: { b: 2 , c: 3 } });
2587
2587
// AssertionError
2588
2588
```
2589
2589
2590
2590
``` cjs
2591
2591
const assert = require (' node:assert' );
2592
2592
2593
- assert .deepMatch ({ a: 1 , b: ' 2' }, { a: 1 , b: 2 });
2593
+ assert .partialDeepEqual ({ a: 1 , b: ' 2' }, { a: 1 , b: 2 });
2594
2594
// OK
2595
2595
2596
- assert .deepMatch ({ a: 1 , b: ' 2' , c: 3 }, { a: 1 , b: 2 });
2596
+ assert .partialDeepEqual ({ a: 1 , b: ' 2' , c: 3 }, { a: 1 , b: 2 });
2597
2597
// OK
2598
2598
2599
- assert .deepMatch ({ a: { b: { c: ' 1' } } }, { a: { b: { c: 1 } } });
2599
+ assert .partialDeepEqual ({ a: { b: { c: ' 1' } } }, { a: { b: { c: 1 } } });
2600
2600
// OK
2601
2601
2602
- assert .deepMatch ({ a: 1 }, { a: 1 , b: 2 });
2602
+ assert .partialDeepEqual ({ a: 1 }, { a: 1 , b: 2 });
2603
2603
// AssertionError: Expected key b
2604
2604
2605
- assert .deepMatch ({ a: 1 , b: true }, { a: 1 , b: ' true' });
2605
+ assert .partialDeepEqual ({ a: 1 , b: true }, { a: 1 , b: ' true' });
2606
2606
// AssertionError
2607
2607
2608
- assert .deepMatch ({ a: { b: 2 , d: 4 } }, { a: { b: 2 , c: 3 } });
2608
+ assert .partialDeepEqual ({ a: { b: 2 , d: 4 } }, { a: { b: 2 , c: 3 } });
2609
2609
// AssertionError: Expected key c
2610
2610
```
2611
2611
@@ -2615,7 +2615,7 @@ parameter is undefined, a default error message is assigned. If the `message`
2615
2615
parameter is an instance of an [ ` Error ` ] [ ] then it will be thrown instead of the
2616
2616
` AssertionError ` .
2617
2617
2618
- ## ` assert.deepMatchStrict (actual, expected[, message]) `
2618
+ ## ` assert.partialDeepEqualStrict (actual, expected[, message]) `
2619
2619
2620
2620
<!-- YAML
2621
2621
added: REPLACEME
@@ -2625,53 +2625,53 @@ added: REPLACEME
2625
2625
* ` expected ` {any}
2626
2626
* ` message ` {string|Error}
2627
2627
2628
- [ ` assert.deepMatchStrict () ` ] [ ] Assesses the equivalence between the ` actual ` and ` expected ` parameters through a
2628
+ [ ` assert.partialDeepEqualStrict () ` ] [ ] Assesses the equivalence between the ` actual ` and ` expected ` parameters through a
2629
2629
deep comparison, ensuring that all properties in the ` expected ` parameter are
2630
2630
present in the ` actual ` parameter with equivalent values, not allowing type coercion.
2631
- The main difference with [ ` assert.deepStrictEqual() ` ] [ ] is that [ ` assert.deepMatchStrict () ` ] [ ] does not require all
2632
- properties in the ` actual ` parameter to be present in the ` expected ` parameter.
2631
+ The main difference with [ ` assert.deepStrictEqual() ` ] [ ] is that [ ` assert.partialDeepEqualStrict () ` ] [ ] does not require
2632
+ all properties in the ` actual ` parameter to be present in the ` expected ` parameter.
2633
2633
2634
2634
``` mjs
2635
2635
import assert from ' node:assert' ;
2636
2636
2637
- assert .deepMatchStrict ({ a: 1 , b: 2 }, { a: 1 , b: 2 });
2637
+ assert .partialDeepEqualStrict ({ a: 1 , b: 2 }, { a: 1 , b: 2 });
2638
2638
// OK
2639
2639
2640
- assert .deepMatchStrict ({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } });
2640
+ assert .partialDeepEqualStrict ({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } });
2641
2641
// OK
2642
2642
2643
- assert .deepMatchStrict ({ a: 1 , b: 2 , c: 3 }, { a: 1 , b: 2 });
2643
+ assert .partialDeepEqualStrict ({ a: 1 , b: 2 , c: 3 }, { a: 1 , b: 2 });
2644
2644
// OK
2645
2645
2646
- assert .deepMatchStrict ({ a: 1 }, { a: 1 , b: 2 });
2646
+ assert .partialDeepEqualStrict ({ a: 1 }, { a: 1 , b: 2 });
2647
2647
// AssertionError
2648
2648
2649
- assert .deepMatchStrict ({ a: 1 , b: ' 2' }, { a: 1 , b: 2 });
2649
+ assert .partialDeepEqualStrict ({ a: 1 , b: ' 2' }, { a: 1 , b: 2 });
2650
2650
// AssertionError
2651
2651
2652
- assert .deepMatchStrict ({ a: { b: 2 } }, { a: { b: ' 2' } });
2652
+ assert .partialDeepEqualStrict ({ a: { b: 2 } }, { a: { b: ' 2' } });
2653
2653
// AssertionError
2654
2654
```
2655
2655
2656
2656
``` cjs
2657
2657
const assert = require (' node:assert' );
2658
2658
2659
- assert .deepMatchStrict ({ a: 1 , b: 2 }, { a: 1 , b: 2 });
2659
+ assert .partialDeepEqualStrict ({ a: 1 , b: 2 }, { a: 1 , b: 2 });
2660
2660
// OK
2661
2661
2662
- assert .deepMatchStrict ({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } });
2662
+ assert .partialDeepEqualStrict ({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } });
2663
2663
// OK
2664
2664
2665
- assert .deepMatchStrict ({ a: 1 , b: 2 , c: 3 }, { a: 1 , b: 2 });
2665
+ assert .partialDeepEqualStrict ({ a: 1 , b: 2 , c: 3 }, { a: 1 , b: 2 });
2666
2666
// OK
2667
2667
2668
- assert .deepMatchStrict ({ a: 1 }, { a: 1 , b: 2 });
2668
+ assert .partialDeepEqualStrict ({ a: 1 }, { a: 1 , b: 2 });
2669
2669
// AssertionError
2670
2670
2671
- assert .deepMatchStrict ({ a: 1 , b: ' 2' }, { a: 1 , b: 2 });
2671
+ assert .partialDeepEqualStrict ({ a: 1 , b: ' 2' }, { a: 1 , b: 2 });
2672
2672
// AssertionError
2673
2673
2674
- assert .deepMatchStrict ({ a: { b: 2 } }, { a: { b: ' 2' } });
2674
+ assert .partialDeepEqualStrict ({ a: { b: 2 } }, { a: { b: ' 2' } });
2675
2675
// AssertionError
2676
2676
```
2677
2677
@@ -2803,8 +2803,6 @@ parameter is an instance of an [`Error`][] then it will be thrown instead of the
2803
2803
[ `WeakMap` ] : https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
2804
2804
[ `WeakSet` ] : https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet
2805
2805
[ `assert.deepEqual()` ] : #assertdeepequalactual-expected-message
2806
- [ `assert.deepMatch()` ] : #assertdeepmatchactual-expected-message
2807
- [ `assert.deepMatchStrict()` ] : #assertdeepmatchstrictactual-expected-message
2808
2806
[ `assert.deepStrictEqual()` ] : #assertdeepstrictequalactual-expected-message
2809
2807
[ `assert.doesNotThrow()` ] : #assertdoesnotthrowfn-error-message
2810
2808
[ `assert.equal()` ] : #assertequalactual-expected-message
@@ -2815,6 +2813,8 @@ parameter is an instance of an [`Error`][] then it will be thrown instead of the
2815
2813
[ `assert.notEqual()` ] : #assertnotequalactual-expected-message
2816
2814
[ `assert.notStrictEqual()` ] : #assertnotstrictequalactual-expected-message
2817
2815
[ `assert.ok()` ] : #assertokvalue-message
2816
+ [ `assert.partialDeepEqual()` ] : #assertpartialDeepEqualactual-expected-message
2817
+ [ `assert.partialDeepEqualStrict()` ] : #assertpartialDeepEqualstrictactual-expected-message
2818
2818
[ `assert.strictEqual()` ] : #assertstrictequalactual-expected-message
2819
2819
[ `assert.throws()` ] : #assertthrowsfn-error-message
2820
2820
[ `getColorDepth()` ] : tty.md#writestreamgetcolordepthenv
0 commit comments