FM / api

/usr/share/doc/nodejs/api

Name	Size	Mode	Actions
assets/	-	0755	rm
addons.html	85172	0644	edit dl rm
addons.json.gz	11188	0644	edit dl rm
addons.md	41013	0644	edit dl rm
all.html	4598048	0644	edit dl rm
all.json.gz	681643	0644	edit dl rm
assert.html	110665	0644	edit dl rm
assert.json.gz	12007	0644	edit dl rm
assert.md	47147	0644	edit dl rm
async_hooks.html	83599	0644	edit dl rm
async_hooks.json.gz	14085	0644	edit dl rm
async_hooks.md	38888	0644	edit dl rm
buffer.html	245762	0644	edit dl rm
buffer.json.gz	24105	0644	edit dl rm
buffer.md	105044	0644	edit dl rm
child_process.html	136767	0644	edit dl rm
child_process.json.gz	19399	0644	edit dl rm
child_process.md	62919	0644	edit dl rm
cli.html	87936	0644	edit dl rm
cli.json.gz	16615	0644	edit dl rm
cli.md	42263	0644	edit dl rm
cluster.html	60116	0644	edit dl rm
cluster.json.gz	9557	0644	edit dl rm
cluster.md	25426	0644	edit dl rm
console.html	46093	0644	edit dl rm
console.json.gz	6056	0644	edit dl rm
console.md	16431	0644	edit dl rm
crypto.html	283043	0644	edit dl rm
crypto.json.gz	32118	0644	edit dl rm
crypto.md	125198	0644	edit dl rm
debugger.html	18089	0644	edit dl rm
debugger.json.gz	2820	0644	edit dl rm
debugger.md	6133	0644	edit dl rm
deprecations.html	138537	0644	edit dl rm
deprecations.json.gz	18470	0644	edit dl rm
deprecations.md	79120	0644	edit dl rm
dgram.html	62425	0644	edit dl rm
dgram.json.gz	9630	0644	edit dl rm
dgram.md	27746	0644	edit dl rm
dns.html	98289	0644	edit dl rm
dns.json.gz	13838	0644	edit dl rm
dns.md	40799	0644	edit dl rm
documentation.html	10978	0644	edit dl rm
documentation.json	3328	0644	edit dl rm
documentation.md	2247	0644	edit dl rm
domain.html	36301	0644	edit dl rm
domain.json.gz	6355	0644	edit dl rm
domain.md	15521	0644	edit dl rm
embedding.html	18165	0644	edit dl rm
embedding.json.gz	3625	0644	edit dl rm
embedding.md	8811	0644	edit dl rm
errors.html	182982	0644	edit dl rm
errors.json.gz	36479	0644	edit dl rm
errors.md	81734	0644	edit dl rm
esm.html	92490	0644	edit dl rm
esm.json.gz	15054	0644	edit dl rm
esm.md	48466	0644	edit dl rm
events.html	75986	0644	edit dl rm
events.json.gz	9561	0644	edit dl rm
events.md	28823	0644	edit dl rm
fs.html	437179	0644	edit dl rm
fs.json.gz	47095	0644	edit dl rm
fs.md	187735	0644	edit dl rm
globals.html	19795	0644	edit dl rm
globals.json.gz	2525	0644	edit dl rm
globals.md	5838	0644	edit dl rm
http.html	164378	0644	edit dl rm
http.json.gz	25888	0644	edit dl rm
http.md	74465	0644	edit dl rm
http2.html	256451	0644	edit dl rm
http2.json.gz	37157	0644	edit dl rm
http2.md	121722	0644	edit dl rm
https.html	38345	0644	edit dl rm
https.json.gz	4847	0644	edit dl rm
https.md	13942	0644	edit dl rm
index.html	10087	0644	edit dl rm
index.json	54	0644	edit dl rm
index.md	1825	0644	edit dl rm
inspector.html	22433	0644	edit dl rm
inspector.json.gz	3338	0644	edit dl rm
inspector.md	6825	0644	edit dl rm
intl.html	23154	0644	edit dl rm
intl.json.gz	4038	0644	edit dl rm
intl.md	11092	0644	edit dl rm
module.html	21739	0644	edit dl rm
module.json.gz	2821	0644	edit dl rm
module.md	5341	0644	edit dl rm
modules.html	61333	0644	edit dl rm
modules.json.gz	11897	0644	edit dl rm
modules.md	30610	0644	edit dl rm
n-api.html	340382	0644	edit dl rm
n-api.json.gz	48682	0644	edit dl rm
n-api.md	206268	0644	edit dl rm
net.html	95113	0644	edit dl rm
net.json.gz	14265	0644	edit dl rm
net.md	40473	0644	edit dl rm
os.html	58658	0644	edit dl rm
os.json.gz	8576	0644	edit dl rm
os.md	34632	0644	edit dl rm
packages.html	65483	0644	edit dl rm
packages.json.gz	12401	0644	edit dl rm
packages.md	36538	0644	edit dl rm
path.html	39321	0644	edit dl rm
path.json.gz	4873	0644	edit dl rm
path.md	14750	0644	edit dl rm
perf_hooks.html	56215	0644	edit dl rm
perf_hooks.json.gz	6973	0644	edit dl rm
perf_hooks.md	20116	0644	edit dl rm
policy.html	15908	0644	edit dl rm
policy.json.gz	2908	0644	edit dl rm
policy.md	6324	0644	edit dl rm
process.html	169341	0644	edit dl rm
process.json.gz	27734	0644	edit dl rm
process.md	82162	0644	edit dl rm
punycode.html	16904	0644	edit dl rm
punycode.json.gz	1939	0644	edit dl rm
punycode.md	4063	0644	edit dl rm
querystring.html	19334	0644	edit dl rm
querystring.json.gz	2519	0644	edit dl rm
querystring.md	5423	0644	edit dl rm
readline.html	58434	0644	edit dl rm
readline.json.gz	8835	0644	edit dl rm
readline.md	25133	0644	edit dl rm
repl.html	54152	0644	edit dl rm
repl.json.gz	10053	0644	edit dl rm
repl.md	23754	0644	edit dl rm
report.html	44941	0644	edit dl rm
report.json.gz	6227	0644	edit dl rm
report.md	18287	0644	edit dl rm
stream.html	200501	0644	edit dl rm
stream.json.gz	34485	0644	edit dl rm
stream.md	98619	0644	edit dl rm
string_decoder.html	14415	0644	edit dl rm
string_decoder.json.gz	1545	0644	edit dl rm
string_decoder.md	2934	0644	edit dl rm
synopsis.html	11475	0644	edit dl rm
synopsis.json	3013	0644	edit dl rm
synopsis.md	2129	0644	edit dl rm
timers.html	27467	0644	edit dl rm
timers.json.gz	3637	0644	edit dl rm
timers.md	9738	0644	edit dl rm
tls.html	148381	0644	edit dl rm
tls.json.gz	29988	0644	edit dl rm
tls.md	81388	0644	edit dl rm
tracing.html	19586	0644	edit dl rm
tracing.json.gz	2829	0644	edit dl rm
tracing.md	6756	0644	edit dl rm
tty.html	26930	0644	edit dl rm
tty.json.gz	3758	0644	edit dl rm
tty.md	8989	0644	edit dl rm
url.html	97495	0644	edit dl rm
url.json.gz	13611	0644	edit dl rm
url.md	44869	0644	edit dl rm
util.html	178081	0644	edit dl rm
util.json.gz	20542	0644	edit dl rm
util.md	71255	0644	edit dl rm
v8.html	44688	0644	edit dl rm
v8.json.gz	6082	0644	edit dl rm
v8.md	15533	0644	edit dl rm
vm.html	103392	0644	edit dl rm
vm.json.gz	14023	0644	edit dl rm
vm.md	48293	0644	edit dl rm
wasi.html	17088	0644	edit dl rm
wasi.json.gz	2814	0644	edit dl rm
wasi.md	5932	0644	edit dl rm
worker_threads.html	70808	0644	edit dl rm
worker_threads.json.gz	11326	0644	edit dl rm
worker_threads.md	33883	0644	edit dl rm
zlib.html	90124	0644	edit dl rm
zlib.json.gz	10569	0644	edit dl rm
zlib.md	35697	0644	edit dl rm

Edit: /usr/share/doc/nodejs/api/assert.html (110665B)

<!doctype html>
<html lang="en">
<head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width">
 <meta name="nodejs.org:node-version" content="v12.20.0">
 <title>Assert | Node.js v12.20.0 Documentation</title>
 <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
 <link rel="stylesheet" href="assets/style.css">
 <link rel="stylesheet" href="assets/hljs.css">
 <link rel="canonical" href="https://nodejs.org/api/assert.html">
</head>
<body class="alt apidoc" id="api-section-assert">
 <div id="content" class="clearfix">
 <div id="column2" class="interior">
 <div id="intro" class="interior">
 <a href="/" title="Go back to the home page">
 Node.js
 </a>
 </div>
 <ul>
<li><a href="documentation.html" class="nav-documentation">About this documentation</a></li>
<li><a href="synopsis.html" class="nav-synopsis">Usage and example</a></li>
</ul>
<hr class="line">
<ul>
<li><a href="assert.html" class="nav-assert active">Assertion testing</a></li>
<li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
<li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
<li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
<li><a href="cli.html" class="nav-cli">Command line options</a></li>
<li><a href="console.html" class="nav-console">Console</a></li>
<li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
<li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
<li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
<li><a href="dns.html" class="nav-dns">DNS</a></li>
<li><a href="domain.html" class="nav-domain">Domain</a></li>
<li><a href="errors.html" class="nav-errors">Errors</a></li>
<li><a href="events.html" class="nav-events">Events</a></li>
<li><a href="fs.html" class="nav-fs">File system</a></li>
<li><a href="globals.html" class="nav-globals">Globals</a></li>
<li><a href="http.html" class="nav-http">HTTP</a></li>
<li><a href="http2.html" class="nav-http2">HTTP/2</a></li>
<li><a href="https.html" class="nav-https">HTTPS</a></li>
<li><a href="inspector.html" class="nav-inspector">Inspector</a></li>
<li><a href="intl.html" class="nav-intl">Internationalization</a></li>
<li><a href="modules.html" class="nav-modules">Modules: CommonJS modules</a></li>
<li><a href="esm.html" class="nav-esm">Modules: ECMAScript modules</a></li>
<li><a href="module.html" class="nav-module">Modules: <code>module</code> API</a></li>
<li><a href="packages.html" class="nav-packages">Modules: Packages</a></li>
<li><a href="net.html" class="nav-net">Net</a></li>
<li><a href="os.html" class="nav-os">OS</a></li>
<li><a href="path.html" class="nav-path">Path</a></li>
<li><a href="perf_hooks.html" class="nav-perf_hooks">Performance hooks</a></li>
<li><a href="policy.html" class="nav-policy">Policies</a></li>
<li><a href="process.html" class="nav-process">Process</a></li>
<li><a href="punycode.html" class="nav-punycode">Punycode</a></li>
<li><a href="querystring.html" class="nav-querystring">Query strings</a></li>
<li><a href="readline.html" class="nav-readline">Readline</a></li>
<li><a href="repl.html" class="nav-repl">REPL</a></li>
<li><a href="report.html" class="nav-report">Report</a></li>
<li><a href="stream.html" class="nav-stream">Stream</a></li>
<li><a href="string_decoder.html" class="nav-string_decoder">String decoder</a></li>
<li><a href="timers.html" class="nav-timers">Timers</a></li>
<li><a href="tls.html" class="nav-tls">TLS/SSL</a></li>
<li><a href="tracing.html" class="nav-tracing">Trace events</a></li>
<li><a href="tty.html" class="nav-tty">TTY</a></li>
<li><a href="dgram.html" class="nav-dgram">UDP/datagram</a></li>
<li><a href="url.html" class="nav-url">URL</a></li>
<li><a href="util.html" class="nav-util">Utilities</a></li>
<li><a href="v8.html" class="nav-v8">V8</a></li>
<li><a href="vm.html" class="nav-vm">VM</a></li>
<li><a href="wasi.html" class="nav-wasi">WASI</a></li>
<li><a href="worker_threads.html" class="nav-worker_threads">Worker threads</a></li>
<li><a href="zlib.html" class="nav-zlib">Zlib</a></li>
</ul>
<hr class="line">
<ul>
<li><a href="https://github.com/nodejs/node" class="nav-https-github-com-nodejs-node">Code repository and issue tracker</a></li>
</ul>
 </div>

<div id="column1" data-id="assert" class="interior">
 <header>
 <h1>Node.js v12.20.0 Documentation</h1>
 <div id="gtoc">
 <ul>
 <li>
 <a href="index.html">Index</a>
 </li>
 <li>
 <a href="all.html">View on single page</a>
 </li>
 <li>
 <a href="assert.json">View as JSON</a>
 </li>
 
 <li class="version-picker">
 <a href="#">View another version &#x25bc;</a>
 <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v15.x/api/assert.html">15.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v14.x/api/assert.html">14.x LTS</a></li>
<li><a href="https://nodejs.org/docs/latest-v13.x/api/assert.html">13.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v12.x/api/assert.html">12.x LTS</a></li>
<li><a href="https://nodejs.org/docs/latest-v11.x/api/assert.html">11.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v10.x/api/assert.html">10.x LTS</a></li>
<li><a href="https://nodejs.org/docs/latest-v9.x/api/assert.html">9.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v8.x/api/assert.html">8.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v7.x/api/assert.html">7.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v6.x/api/assert.html">6.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v5.x/api/assert.html">5.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v4.x/api/assert.html">4.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v0.12.x/api/assert.html">0.12.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v0.10.x/api/assert.html">0.10.x</a></li></ol>
 </li>
 
 <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/assert.md"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg>Edit on GitHub</a></li>
 </ul>
 </div>
 <hr>
 </header>

<div id="toc">
 <h2>Table of Contents</h2>
 <ul>
<li><a href="#assert_assert">Assert</a>
<ul>
<li><a href="#assert_strict_assertion_mode">Strict assertion mode</a></li>
<li><a href="#assert_legacy_assertion_mode">Legacy assertion mode</a></li>
<li><a href="#assert_class_assert_assertionerror">Class: assert.AssertionError</a>
<ul>
<li><a href="#assert_new_assert_assertionerror_options"><code>new assert.AssertionError(options)</code></a></li>
</ul>
</li>
<li><a href="#assert_class_assert_calltracker">Class: <code>assert.CallTracker</code></a>
<ul>
<li><a href="#assert_tracker_calls_fn_exact"><code>tracker.calls([fn][, exact])</code></a></li>
<li><a href="#assert_tracker_report"><code>tracker.report()</code></a></li>
<li><a href="#assert_tracker_verify"><code>tracker.verify()</code></a></li>
</ul>
</li>
<li><a href="#assert_assert_value_message"><code>assert(value[, message])</code></a></li>
<li><a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual(actual, expected[, message])</code></a>
<ul>
<li><a href="#assert_comparison_details">Comparison details</a></li>
</ul>
</li>
<li><a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual(actual, expected[, message])</code></a>
<ul>
<li><a href="#assert_comparison_details_1">Comparison details</a></li>
</ul>
</li>
<li><a href="#assert_assert_doesnotmatch_string_regexp_message"><code>assert.doesNotMatch(string, regexp[, message])</code></a></li>
<li><a href="#assert_assert_doesnotreject_asyncfn_error_message"><code>assert.doesNotReject(asyncFn[, error][, message])</code></a></li>
<li><a href="#assert_assert_doesnotthrow_fn_error_message"><code>assert.doesNotThrow(fn[, error][, message])</code></a></li>
<li><a href="#assert_assert_equal_actual_expected_message"><code>assert.equal(actual, expected[, message])</code></a></li>
<li><a href="#assert_assert_fail_message"><code>assert.fail([message])</code></a></li>
<li><a href="#assert_assert_fail_actual_expected_message_operator_stackstartfn"><code>assert.fail(actual, expected[, message[, operator[, stackStartFn]]])</code></a></li>
<li><a href="#assert_assert_iferror_value"><code>assert.ifError(value)</code></a></li>
<li><a href="#assert_assert_match_string_regexp_message"><code>assert.match(string, regexp[, message])</code></a></li>
<li><a href="#assert_assert_notdeepequal_actual_expected_message"><code>assert.notDeepEqual(actual, expected[, message])</code></a></li>
<li><a href="#assert_assert_notdeepstrictequal_actual_expected_message"><code>assert.notDeepStrictEqual(actual, expected[, message])</code></a></li>
<li><a href="#assert_assert_notequal_actual_expected_message"><code>assert.notEqual(actual, expected[, message])</code></a></li>
<li><a href="#assert_assert_notstrictequal_actual_expected_message"><code>assert.notStrictEqual(actual, expected[, message])</code></a></li>
<li><a href="#assert_assert_ok_value_message"><code>assert.ok(value[, message])</code></a></li>
<li><a href="#assert_assert_rejects_asyncfn_error_message"><code>assert.rejects(asyncFn[, error][, message])</code></a></li>
<li><a href="#assert_assert_strictequal_actual_expected_message"><code>assert.strictEqual(actual, expected[, message])</code></a></li>
<li><a href="#assert_assert_throws_fn_error_message"><code>assert.throws(fn[, error][, message])</code></a></li>
</ul>
</li>
</ul>
 </div>

<div id="apicontent">
 <h1>Assert<a class="mark" href="#assert_assert" id="assert_assert">#</a></h1>

<div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">Stability: 2</a> - Stable</div>
Source Code: <a href="https://github.com/nodejs/node/blob/v12.20.0/lib/assert.js">lib/assert.js</a>
The <code>assert</code> module provides a set of assertion functions for verifying
invariants.
<h2>Strict assertion mode<a class="mark" href="#assert_strict_assertion_mode" id="assert_strict_assertion_mode">#</a></h2>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v12.16.2</td>
<td>Changed "strict mode" to "strict assertion mode" and "legacy mode" to "legacy assertion mode" to avoid confusion with the more usual meaning of "strict mode".</td></tr>
<tr><td>v9.9.0</td>
<td>Added error diffs to the strict assertion mode.</td></tr>
<tr><td>v9.9.0</td>
<td>Added strict assertion mode to the assert module.</td></tr>
<tr><td>v9.9.0</td>
<td>Added in: v9.9.0</td></tr>
</tbody></table>
</details>
</div>
In strict assertion mode, non-strict methods behave like their corresponding
strict methods. For example, <a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a> will behave like
<a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a>.
In strict assertion mode, error messages for objects display a diff. In legacy
assertion mode, error messages for objects display the objects, often truncated.
To use strict assertion mode:
<pre><code class="language-js">const assert = require('assert').strict;</code></pre>
Example error diff:
<pre><code class="language-js">const assert = require('assert').strict;

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected ... Lines skipped
//
// [
// [
// ...
// 2,
// + 3
// - '3'
// ],
// ...
// 5
// ]</code></pre>
To deactivate the colors, use the <code>NO_COLOR</code> or <code>NODE_DISABLE_COLORS</code>
environment variables. This will also deactivate the colors in the REPL. For
more on color support in terminal environments, read the tty
<a href="tty.html#tty_writestream_getcolordepth_env">getColorDepth()</a> documentation.
<h2>Legacy assertion mode<a class="mark" href="#assert_legacy_assertion_mode" id="assert_legacy_assertion_mode">#</a></h2>
Legacy assertion mode uses the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a> in:
<ul>
<li><a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a></li>
<li><a href="#assert_assert_equal_actual_expected_message"><code>assert.equal()</code></a></li>
<li><a href="#assert_assert_notdeepequal_actual_expected_message"><code>assert.notDeepEqual()</code></a></li>
<li><a href="#assert_assert_notequal_actual_expected_message"><code>assert.notEqual()</code></a></li>
</ul>
To use legacy assertion mode:
<pre><code class="language-js">const assert = require('assert');</code></pre>
Whenever possible, use the <a href="#assert_strict_assertion_mode">strict assertion mode</a> instead. Otherwise, the
<a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a> may cause surprising results. This is
especially true for <a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a>, where the comparison rules are
lax:
<pre><code class="language-js">// WARNING: This does not throw an AssertionError!
assert.deepEqual(/a/gi, new Date());</code></pre>
<h2>Class: assert.AssertionError<a class="srclink" href="https://github.com/nodejs/node/blob/d84392fe9320e3d87abc04e64643ff26a65daeac/lib/assert.js#L147">[src]</a><a class="mark" href="#assert_class_assert_assertionerror" id="assert_class_assert_assertionerror">#</a></h2>
<ul>
<li>Extends: <a href="errors.html#errors_class_error" class="type">&#x3C;errors.Error></a></li>
</ul>
Indicates the failure of an assertion. All errors thrown by the <code>assert</code> module
will be instances of the <code>AssertionError</code> class.
<h3><code>new assert.AssertionError(options)</code><a class="mark" href="#assert_new_assert_assertionerror_options" id="assert_new_assert_assertionerror_options">#</a></h3>
<div class="api_metadata">
Added in: v0.1.21
</div>
<ul>
<li><code>options</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
<ul>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> If provided, the error message is set to this value.</li>
<li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> The <code>actual</code> property on the error instance.</li>
<li><code>expected</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> The <code>expected</code> property on the error instance.</li>
<li><code>operator</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The <code>operator</code> property on the error instance.</li>
<li><code>stackStartFn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> If provided, the generated stack trace omits
frames before this function.</li>
</ul>
</li>
</ul>
A subclass of <code>Error</code> that indicates the failure of an assertion.
All instances contain the built-in <code>Error</code> properties (<code>message</code> and <code>name</code>)
and:
<ul>
<li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Set to the <code>actual</code> argument for methods such as
<a href="#assert_assert_strictequal_actual_expected_message"><code>assert.strictEqual()</code></a>.</li>
<li><code>expected</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> Set to the <code>expected</code> value for methods such as
<a href="#assert_assert_strictequal_actual_expected_message"><code>assert.strictEqual()</code></a>.</li>
<li><code>generatedMessage</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&#x3C;boolean></a> Indicates if the message was auto-generated
(<code>true</code>) or not.</li>
<li><code>code</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Value is always <code>ERR_ASSERTION</code> to show that the error is an
assertion error.</li>
<li><code>operator</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Set to the passed in operator value.</li>
</ul>
<pre><code class="language-js">const assert = require('assert');

// Generate an AssertionError to compare the error message later:
const { message } = new assert.AssertionError({
 actual: 1,
 expected: 2,
 operator: 'strictEqual'
});

// Verify error output:
try {
 assert.strictEqual(1, 2);
} catch (err) {
 assert(err instanceof assert.AssertionError);
 assert.strictEqual(err.message, message);
 assert.strictEqual(err.name, 'AssertionError');
 assert.strictEqual(err.actual, 1);
 assert.strictEqual(err.expected, 2);
 assert.strictEqual(err.code, 'ERR_ASSERTION');
 assert.strictEqual(err.operator, 'strictEqual');
 assert.strictEqual(err.generatedMessage, true);
}</code></pre>
<h2>Class: <code>assert.CallTracker</code><a class="mark" href="#assert_class_assert_calltracker" id="assert_class_assert_calltracker">#</a></h2>
<div class="api_metadata">
Added in: v12.19.0
</div>
<div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div>
This feature is currently experimental and behavior might still change.
### <code>new assert.CallTracker()</code>
<div class="api_metadata">
Added in: v12.19.0
</div>
Creates a new <a href="#assert_class_assert_calltracker"><code>CallTracker</code></a> object which can be used to track if functions
were called a specific number of times. The <code>tracker.verify()</code> must be called
for the verification to take place. The usual pattern would be to call it in a
<a href="process.html#process_event_exit"><code>process.on('exit')</code></a> handler.
<pre><code class="language-js">const assert = require('assert');

const tracker = new assert.CallTracker();

function func() {}

// callsfunc() must be called exactly 1 time before tracker.verify().
const callsfunc = tracker.calls(func, 1);

callsfunc();

// Calls tracker.verify() and verifies if all tracker.calls() functions have
// been called exact times.
process.on('exit', () => {
 tracker.verify();
});</code></pre>
<h3><code>tracker.calls([fn][, exact])</code><a class="mark" href="#assert_tracker_calls_fn_exact" id="assert_tracker_calls_fn_exact">#</a></h3>
<div class="api_metadata">
Added in: v12.19.0
</div>
<ul>
<li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Default A no-op function.</li>
<li><code>exact</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> Default <code>1</code>.</li>
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> that wraps <code>fn</code>.</li>
</ul>
The wrapper function is expected to be called exactly <code>exact</code> times. If the
function has not been called exactly <code>exact</code> times when
<a href="#assert_tracker_verify"><code>tracker.verify()</code></a> is called, then <a href="#assert_tracker_verify"><code>tracker.verify()</code></a> will throw an
error.
<pre><code class="language-js">const assert = require('assert');

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func);</code></pre>
<h3><code>tracker.report()</code><a class="mark" href="#assert_tracker_report" id="assert_tracker_report">#</a></h3>
<div class="api_metadata">
Added in: v12.19.0
</div>
<ul>
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a> of objects containing information about the wrapper functions
returned by <a href="#assert_tracker_calls_fn_exact"><code>tracker.calls()</code></a>.</li>
<li>Object <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a>
<ul>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
<li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The actual number of times the function was called.</li>
<li><code>expected</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&#x3C;number></a> The number of times the function was expected to be
called.</li>
<li><code>operator</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> The name of the function that is wrapped.</li>
<li><code>stack</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> A stack trace of the function.</li>
</ul>
</li>
</ul>
The arrays contains information about the expected and actual number of calls of
the functions that have not been called the expected number of times.
<pre><code class="language-js">const assert = require('assert');

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

function foo() {}

// Returns an array containing information on callsfunc()
tracker.report();
// [
// {
// message: 'Expected the func function to be executed 2 time(s) but was
// executed 0 time(s).',
// actual: 0,
// expected: 2,
// operator: 'func',
// stack: stack trace
// }
// ]</code></pre>
<h3><code>tracker.verify()</code><a class="mark" href="#assert_tracker_verify" id="assert_tracker_verify">#</a></h3>
<div class="api_metadata">
Added in: v12.19.0
</div>
Iterates through the list of functions passed to
<a href="#assert_tracker_calls_fn_exact"><code>tracker.calls()</code></a> and will throw an error for functions that
have not been called the expected number of times.
<pre><code class="language-js">const assert = require('assert');

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

callsfunc();

// Will throw an error since callsfunc() was only called once.
tracker.verify();</code></pre>
<h2><code>assert(value[, message])</code><a class="mark" href="#assert_assert_value_message" id="assert_assert_value_message">#</a></h2>
<div class="api_metadata">
Added in: v0.5.9
</div>
<ul>
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a> The input that is checked for being truthy.</li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
</ul>
An alias of <a href="#assert_assert_ok_value_message"><code>assert.ok()</code></a>.
<h2><code>assert.deepEqual(actual, expected[, message])</code><a class="mark" href="#assert_assert_deepequal_actual_expected_message" id="assert_assert_deepequal_actual_expected_message">#</a></h2>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v12.0.0</td>
<td>The type tags are now properly compared and there are a couple minor comparison adjustments to make the check less surprising.</td></tr>
<tr><td>v9.0.0</td>
<td>The <code>Error</code> names and messages are now properly compared</td></tr>
<tr><td>v8.0.0</td>
<td>The <code>Set</code> and <code>Map</code> content is also compared</td></tr>
<tr><td>v6.4.0, v4.7.1</td>
<td>Typed array slices are handled correctly now.</td></tr>
<tr><td>v6.1.0, v4.5.0</td>
<td>Objects with circular references can be used as inputs now.</td></tr>
<tr><td>v5.10.1, v4.4.3</td>
<td>Handle non-<code>Uint8Array</code> typed arrays correctly.</td></tr>
<tr><td>v0.1.21</td>
<td>Added in: v0.1.21</td></tr>
</tbody></table>
</details>
</div>
<ul>
<li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>expected</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
</ul>
Strict assertion mode
An alias of <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a>.
Legacy assertion mode
<div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a> instead.</div>
Tests for deep equality between the <code>actual</code> and <code>expected</code> parameters. Consider
using <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a> instead. <a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a> can have
surprising results.
Deep equality means that the enumerable "own" properties of child objects
are also recursively evaluated by the following rules.
<h3>Comparison details<a class="mark" href="#assert_comparison_details" id="assert_comparison_details">#</a></h3>
<ul>
<li>Primitive values are compared with the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a>
( <code>==</code> ).</li>
<li><a href="https://tc39.github.io/ecma262/#sec-object.prototype.tostring">Type tags</a> of objects should be the same.</li>
<li>Only <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">enumerable "own" properties</a> are considered.</li>
<li><a href="errors.html#errors_class_error"><code>Error</code></a> names and messages are always compared, even if these are not
enumerable properties.</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Glossary/Primitive#Primitive_wrapper_objects_in_JavaScript">Object wrappers</a> are compared both as objects and unwrapped values.</li>
<li><code>Object</code> properties are compared unordered.</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map"><code>Map</code></a> keys and <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set"><code>Set</code></a> items are compared unordered.</li>
<li>Recursion stops when both sides differ or both sides encounter a circular
reference.</li>
<li>Implementation does not test the <a href="https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots"><code>[[Prototype]]</code></a> of
objects.</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol"><code>Symbol</code></a> properties are not compared.</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap"><code>WeakMap</code></a> and <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet"><code>WeakSet</code></a> comparison does not rely on their values.</li>
</ul>
The following example does not throw an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> because the
primitives are considered equal by the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a>
( <code>==</code> ).
<pre><code class="language-js">// WARNING: This does not throw an AssertionError!
assert.deepEqual('+00000000', false);</code></pre>
"Deep" equality means that the enumerable "own" properties of child objects
are evaluated also:
<pre><code class="language-js">const assert = require('assert');

const obj1 = {
 a: {
 b: 1
 }
};
const obj2 = {
 a: {
 b: 2
 }
};
const obj3 = {
 a: {
 b: 1
 }
};
const obj4 = Object.create(obj1);

assert.deepEqual(obj1, obj1);
// OK

// Values of b are different:
assert.deepEqual(obj1, obj2);
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3);
// OK

// Prototypes are ignored:
assert.deepEqual(obj1, obj4);
// AssertionError: { a: { b: 1 } } deepEqual {}</code></pre>
If the values are not equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code>
property set equal to the value of the <code>message</code> parameter. If the <code>message</code>
parameter is undefined, a default error message is assigned. If the <code>message</code>
parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
<a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.
<h2><code>assert.deepStrictEqual(actual, expected[, message])</code><a class="mark" href="#assert_assert_deepstrictequal_actual_expected_message" id="assert_assert_deepstrictequal_actual_expected_message">#</a></h2>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v9.0.0</td>
<td>Enumerable symbol properties are now compared.</td></tr>
<tr><td>v9.0.0</td>
<td>The <code>NaN</code> is now compared using the <a href="https://tc39.github.io/ecma262/#sec-samevaluezero">SameValueZero</a> comparison.</td></tr>
<tr><td>v8.5.0</td>
<td>The <code>Error</code> names and messages are now properly compared</td></tr>
<tr><td>v8.0.0</td>
<td>The <code>Set</code> and <code>Map</code> content is also compared</td></tr>
<tr><td>v6.4.0, v4.7.1</td>
<td>Typed array slices are handled correctly now.</td></tr>
<tr><td>v6.1.0</td>
<td>Objects with circular references can be used as inputs now.</td></tr>
<tr><td>v5.10.1, v4.4.3</td>
<td>Handle non-<code>Uint8Array</code> typed arrays correctly.</td></tr>
<tr><td>v1.2.0</td>
<td>Added in: v1.2.0</td></tr>
</tbody></table>
</details>
</div>
<ul>
<li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>expected</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
</ul>
Tests for deep equality between the <code>actual</code> and <code>expected</code> parameters.
"Deep" equality means that the enumerable "own" properties of child objects
are recursively evaluated also by the following rules.
<h3>Comparison details<a class="mark" href="#assert_comparison_details_1" id="assert_comparison_details_1">#</a></h3>
<ul>
<li>Primitive values are compared using the <a href="https://tc39.github.io/ecma262/#sec-samevalue">SameValue Comparison</a>, used by
<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is()</code></a>.</li>
<li><a href="https://tc39.github.io/ecma262/#sec-object.prototype.tostring">Type tags</a> of objects should be the same.</li>
<li><a href="https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots"><code>[[Prototype]]</code></a> of objects are compared using
the <a href="https://tc39.github.io/ecma262/#sec-strict-equality-comparison">Strict Equality Comparison</a>.</li>
<li>Only <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">enumerable "own" properties</a> are considered.</li>
<li><a href="errors.html#errors_class_error"><code>Error</code></a> names and messages are always compared, even if these are not
enumerable properties.</li>
<li>Enumerable own <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol"><code>Symbol</code></a> properties are compared as well.</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Glossary/Primitive#Primitive_wrapper_objects_in_JavaScript">Object wrappers</a> are compared both as objects and unwrapped values.</li>
<li><code>Object</code> properties are compared unordered.</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map"><code>Map</code></a> keys and <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set"><code>Set</code></a> items are compared unordered.</li>
<li>Recursion stops when both sides differ or both sides encounter a circular
reference.</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap"><code>WeakMap</code></a> and <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet"><code>WeakSet</code></a> comparison does not rely on their values. See
below for further details.</li>
</ul>
<pre><code class="language-js">const assert = require('assert').strict;

// This fails because 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' });
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// {
// + a: 1
// - a: '1'
// }

// The following objects don't have own properties
const date = new Date();
const object = {};
const fakeDate = {};
Object.setPrototypeOf(fakeDate, Date.prototype);

// Different [[Prototype]]:
assert.deepStrictEqual(object, fakeDate);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// Different type tags:
assert.deepStrictEqual(date, fakeDate);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN);
// OK, because of the SameValue comparison

// Different unwrapped numbers:
assert.deepStrictEqual(new Number(1), new Number(2));
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'));
// OK because the object and the string are identical when unwrapped.

assert.deepStrictEqual(-0, -0);
// OK

// Different zeros using the SameValue Comparison:
assert.deepStrictEqual(0, -0);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 0
// - -0

const symbol1 = Symbol();
const symbol2 = Symbol();
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 });
// OK, because it is the same symbol on both objects.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 });
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
// [Symbol()]: 1
// }

const weakMap1 = new WeakMap();
const weakMap2 = new WeakMap([[{}, {}]]);
const weakMap3 = new WeakMap();
weakMap3.unequal = true;

assert.deepStrictEqual(weakMap1, weakMap2);
// OK, because it is impossible to compare the entries

// Fails because weakMap3 has a property that weakMap1 does not contain:
assert.deepStrictEqual(weakMap1, weakMap3);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// WeakMap {
// + [items unknown]
// - [items unknown],
// - unequal: true
// }</code></pre>
If the values are not equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code>
property set equal to the value of the <code>message</code> parameter. If the <code>message</code>
parameter is undefined, a default error message is assigned. If the <code>message</code>
parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
<code>AssertionError</code>.
<h2><code>assert.doesNotMatch(string, regexp[, message])</code><a class="mark" href="#assert_assert_doesnotmatch_string_regexp_message" id="assert_assert_doesnotmatch_string_regexp_message">#</a></h2>
<div class="api_metadata">
Added in: v12.16.0
</div>
<ul>
<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
<li><code>regexp</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp" class="type">&#x3C;RegExp></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
</ul>
<div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div>
Expects the <code>string</code> input not to match the regular expression.
This feature is currently experimental and the name might change or it might be
completely removed again.
<pre><code class="language-js">const assert = require('assert').strict;

assert.doesNotMatch('I will fail', /fail/);
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...

assert.doesNotMatch(123, /pass/);
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

assert.doesNotMatch('I will pass', /different/);
// OK</code></pre>
If the values do match, or if the <code>string</code> argument is of another type than
<code>string</code>, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code> property set equal
to the value of the <code>message</code> parameter. If the <code>message</code> parameter is
undefined, a default error message is assigned. If the <code>message</code> parameter is an
instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
<a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.
<h2><code>assert.doesNotReject(asyncFn[, error][, message])</code><a class="mark" href="#assert_assert_doesnotreject_asyncfn_error_message" id="assert_assert_doesnotreject_asyncfn_error_message">#</a></h2>
<div class="api_metadata">
Added in: v10.0.0
</div>
<ul>
<li><code>asyncFn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp" class="type">&#x3C;RegExp></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
</ul>
Awaits the <code>asyncFn</code> promise or, if <code>asyncFn</code> is a function, immediately
calls the function and awaits the returned promise to complete. It will then
check that the promise is not rejected.
If <code>asyncFn</code> is a function and it throws an error synchronously,
<code>assert.doesNotReject()</code> will return a rejected <code>Promise</code> with that error. If
the function does not return a promise, <code>assert.doesNotReject()</code> will return a
rejected <code>Promise</code> with an <a href="errors.html#errors_err_invalid_return_value"><code>ERR_INVALID_RETURN_VALUE</code></a> error. In both cases
the error handler is skipped.
Using <code>assert.doesNotReject()</code> is actually not useful because there is little
benefit in catching a rejection and then rejecting it again. Instead, consider
adding a comment next to the specific code path that should not reject and keep
error messages as expressive as possible.
If specified, <code>error</code> can be a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes"><code>Class</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions"><code>RegExp</code></a> or a validation
function. See <a href="#assert_assert_throws_fn_error_message"><code>assert.throws()</code></a> for more details.
Besides the async nature to await the completion behaves identically to
<a href="#assert_assert_doesnotthrow_fn_error_message"><code>assert.doesNotThrow()</code></a>.

<pre><code class="language-js">(async () => {
 await assert.doesNotReject(
 async () => {
 throw new TypeError('Wrong value');
 },
 SyntaxError
 );
})();</code></pre>

<pre><code class="language-js">assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
 .then(() => {
 // ...
 });</code></pre>
<h2><code>assert.doesNotThrow(fn[, error][, message])</code><a class="mark" href="#assert_assert_doesnotthrow_fn_error_message" id="assert_assert_doesnotthrow_fn_error_message">#</a></h2>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v5.11.0, v4.4.5</td>
<td>The <code>message</code> parameter is respected now.</td></tr>
<tr><td>v4.2.0</td>
<td>The <code>error</code> parameter can now be an arrow function.</td></tr>
<tr><td>v0.1.21</td>
<td>Added in: v0.1.21</td></tr>
</tbody></table>
</details>
</div>
<ul>
<li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp" class="type">&#x3C;RegExp></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
</ul>
Asserts that the function <code>fn</code> does not throw an error.
Using <code>assert.doesNotThrow()</code> is actually not useful because there
is no benefit in catching an error and then rethrowing it. Instead, consider
adding a comment next to the specific code path that should not throw and keep
error messages as expressive as possible.
When <code>assert.doesNotThrow()</code> is called, it will immediately call the <code>fn</code>
function.
If an error is thrown and it is the same type as that specified by the <code>error</code>
parameter, then an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown. If the error is of a
different type, or if the <code>error</code> parameter is undefined, the error is
propagated back to the caller.
If specified, <code>error</code> can be a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes"><code>Class</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions"><code>RegExp</code></a> or a validation
function. See <a href="#assert_assert_throws_fn_error_message"><code>assert.throws()</code></a> for more details.
The following, for instance, will throw the <a href="errors.html#errors_class_typeerror"><code>TypeError</code></a> because there is no
matching error type in the assertion:

<pre><code class="language-js">assert.doesNotThrow(
 () => {
 throw new TypeError('Wrong value');
 },
 SyntaxError
);</code></pre>
However, the following will result in an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> with the message
'Got unwanted exception...':

<pre><code class="language-js">assert.doesNotThrow(
 () => {
 throw new TypeError('Wrong value');
 },
 TypeError
);</code></pre>
If an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown and a value is provided for the <code>message</code>
parameter, the value of <code>message</code> will be appended to the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>
message:

<pre><code class="language-js">assert.doesNotThrow(
 () => {
 throw new TypeError('Wrong value');
 },
 /Wrong value/,
 'Whoops'
);
// Throws: AssertionError: Got unwanted exception: Whoops</code></pre>
<h2><code>assert.equal(actual, expected[, message])</code><a class="mark" href="#assert_assert_equal_actual_expected_message" id="assert_assert_equal_actual_expected_message">#</a></h2>
<div class="api_metadata">
Added in: v0.1.21
</div>
<ul>
<li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>expected</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
</ul>
Strict assertion mode
An alias of <a href="#assert_assert_strictequal_actual_expected_message"><code>assert.strictEqual()</code></a>.
Legacy assertion mode
<div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#assert_assert_strictequal_actual_expected_message"><code>assert.strictEqual()</code></a> instead.</div>
Tests shallow, coercive equality between the <code>actual</code> and <code>expected</code> parameters
using the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a> ( <code>==</code> ).
<pre><code class="language-js">const assert = require('assert');

assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// OK, 1 == '1'

assert.equal(1, 2);
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }</code></pre>
If the values are not equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code>
property set equal to the value of the <code>message</code> parameter. If the <code>message</code>
parameter is undefined, a default error message is assigned. If the <code>message</code>
parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
<code>AssertionError</code>.
<h2><code>assert.fail([message])</code><a class="mark" href="#assert_assert_fail_message" id="assert_assert_fail_message">#</a></h2>
<div class="api_metadata">
Added in: v0.1.21
</div>
<ul>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a> Default: <code>'Failed'</code></li>
</ul>
Throws an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> with the provided error message or a default
error message. If the <code>message</code> parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then
it will be thrown instead of the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.
<pre><code class="language-js">const assert = require('assert').strict;

assert.fail();
// AssertionError [ERR_ASSERTION]: Failed

assert.fail('boom');
// AssertionError [ERR_ASSERTION]: boom

assert.fail(new TypeError('need array'));
// TypeError: need array</code></pre>
Using <code>assert.fail()</code> with more than two arguments is possible but deprecated.
See below for further details.
<h2><code>assert.fail(actual, expected[, message[, operator[, stackStartFn]]])</code><a class="mark" href="#assert_assert_fail_actual_expected_message_operator_stackstartfn" id="assert_assert_fail_actual_expected_message_operator_stackstartfn">#</a></h2>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v10.0.0</td>
<td>Calling <code>assert.fail()</code> with more than one argument is deprecated and emits a warning.</td></tr>
<tr><td>v0.1.21</td>
<td>Added in: v0.1.21</td></tr>
</tbody></table>
</details>
</div>
<div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <code>assert.fail([message])</code> or other assert
functions instead.</div>
<ul>
<li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>expected</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
<li><code>operator</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> Default: <code>'!='</code></li>
<li><code>stackStartFn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> Default: <code>assert.fail</code></li>
</ul>
If <code>message</code> is falsy, the error message is set as the values of <code>actual</code> and
<code>expected</code> separated by the provided <code>operator</code>. If just the two <code>actual</code> and
<code>expected</code> arguments are provided, <code>operator</code> will default to <code>'!='</code>. If
<code>message</code> is provided as third argument it will be used as the error message and
the other arguments will be stored as properties on the thrown object. If
<code>stackStartFn</code> is provided, all stack frames above that function will be
removed from stacktrace (see <a href="errors.html#errors_error_capturestacktrace_targetobject_constructoropt"><code>Error.captureStackTrace</code></a>). If no arguments are
given, the default message <code>Failed</code> will be used.
<pre><code class="language-js">const assert = require('assert').strict;

assert.fail('a', 'b');
// AssertionError [ERR_ASSERTION]: 'a' != 'b'

assert.fail(1, 2, undefined, '>');
// AssertionError [ERR_ASSERTION]: 1 > 2

assert.fail(1, 2, 'fail');
// AssertionError [ERR_ASSERTION]: fail

assert.fail(1, 2, 'whoops', '>');
// AssertionError [ERR_ASSERTION]: whoops

assert.fail(1, 2, new TypeError('need array'));
// TypeError: need array</code></pre>
In the last three cases <code>actual</code>, <code>expected</code>, and <code>operator</code> have no
influence on the error message.
Example use of <code>stackStartFn</code> for truncating the exception's stacktrace:
<pre><code class="language-js">function suppressFrame() {
 assert.fail('a', 'b', undefined, '!==', suppressFrame);
}
suppressFrame();
// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
// at repl:1:1
// at ContextifyScript.Script.runInThisContext (vm.js:44:33)
// ...</code></pre>
<h2><code>assert.ifError(value)</code><a class="mark" href="#assert_assert_iferror_value" id="assert_assert_iferror_value">#</a></h2>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v10.0.0</td>
<td>Instead of throwing the original error it is now wrapped into an [<code>AssertionError</code>][] that contains the full stack trace.</td></tr>
<tr><td>v10.0.0</td>
<td>Value may now only be <code>undefined</code> or <code>null</code>. Before all falsy values were handled the same as <code>null</code> and did not throw.</td></tr>
<tr><td>v0.1.97</td>
<td>Added in: v0.1.97</td></tr>
</tbody></table>
</details>
</div>
<ul>
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
</ul>
Throws <code>value</code> if <code>value</code> is not <code>undefined</code> or <code>null</code>. This is useful when
testing the <code>error</code> argument in callbacks. The stack trace contains all frames
from the error passed to <code>ifError()</code> including the potential new frames for
<code>ifError()</code> itself.
<pre><code class="language-js">const assert = require('assert').strict;

assert.ifError(null);
// OK
assert.ifError(0);
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
assert.ifError('error');
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
assert.ifError(new Error());
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error

// Create some random error frames.
let err;
(function errorFrame() {
 err = new Error('test error');
})();

(function ifErrorFrame() {
 assert.ifError(err);
})();
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
// at ifErrorFrame
// at errorFrame</code></pre>
<h2><code>assert.match(string, regexp[, message])</code><a class="mark" href="#assert_assert_match_string_regexp_message" id="assert_assert_match_string_regexp_message">#</a></h2>
<div class="api_metadata">
Added in: v12.16.0
</div>
<ul>
<li><code>string</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
<li><code>regexp</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp" class="type">&#x3C;RegExp></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
</ul>
<div class="api_stability api_stability_1"><a href="documentation.html#documentation_stability_index">Stability: 1</a> - Experimental</div>
Expects the <code>string</code> input to match the regular expression.
This feature is currently experimental and the name might change or it might be
completely removed again.
<pre><code class="language-js">const assert = require('assert').strict;

assert.match('I will fail', /pass/);
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...

assert.match(123, /pass/);
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

assert.match('I will pass', /pass/);
// OK</code></pre>
If the values do not match, or if the <code>string</code> argument is of another type than
<code>string</code>, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code> property set equal
to the value of the <code>message</code> parameter. If the <code>message</code> parameter is
undefined, a default error message is assigned. If the <code>message</code> parameter is an
instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
<a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.
<h2><code>assert.notDeepEqual(actual, expected[, message])</code><a class="mark" href="#assert_assert_notdeepequal_actual_expected_message" id="assert_assert_notdeepequal_actual_expected_message">#</a></h2>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v9.0.0</td>
<td>The <code>Error</code> names and messages are now properly compared</td></tr>
<tr><td>v8.0.0</td>
<td>The <code>Set</code> and <code>Map</code> content is also compared</td></tr>
<tr><td>v6.4.0, v4.7.1</td>
<td>Typed array slices are handled correctly now.</td></tr>
<tr><td>v6.1.0, v4.5.0</td>
<td>Objects with circular references can be used as inputs now.</td></tr>
<tr><td>v5.10.1, v4.4.3</td>
<td>Handle non-<code>Uint8Array</code> typed arrays correctly.</td></tr>
<tr><td>v0.1.21</td>
<td>Added in: v0.1.21</td></tr>
</tbody></table>
</details>
</div>
<ul>
<li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>expected</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
</ul>
Strict assertion mode
An alias of <a href="#assert_assert_notdeepstrictequal_actual_expected_message"><code>assert.notDeepStrictEqual()</code></a>.
Legacy assertion mode
<div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#assert_assert_notdeepstrictequal_actual_expected_message"><code>assert.notDeepStrictEqual()</code></a> instead.</div>
Tests for any deep inequality. Opposite of <a href="#assert_assert_deepequal_actual_expected_message"><code>assert.deepEqual()</code></a>.
<pre><code class="language-js">const assert = require('assert');

assert.notDeepEqual(obj1, obj1);
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj2);
// OK

assert.notDeepEqual(obj1, obj3);
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4);
// OK</code></pre>
If the values are deeply equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a
<code>message</code> property set equal to the value of the <code>message</code> parameter. If the
<code>message</code> parameter is undefined, a default error message is assigned. If the
<code>message</code> parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown
instead of the <code>AssertionError</code>.
<h2><code>assert.notDeepStrictEqual(actual, expected[, message])</code><a class="mark" href="#assert_assert_notdeepstrictequal_actual_expected_message" id="assert_assert_notdeepstrictequal_actual_expected_message">#</a></h2>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v9.0.0</td>
<td>The <code>-0</code> and <code>+0</code> are not considered equal anymore.</td></tr>
<tr><td>v9.0.0</td>
<td>The <code>NaN</code> is now compared using the <a href="https://tc39.github.io/ecma262/#sec-samevaluezero">SameValueZero</a> comparison.</td></tr>
<tr><td>v9.0.0</td>
<td>The <code>Error</code> names and messages are now properly compared</td></tr>
<tr><td>v8.0.0</td>
<td>The <code>Set</code> and <code>Map</code> content is also compared</td></tr>
<tr><td>v6.4.0, v4.7.1</td>
<td>Typed array slices are handled correctly now.</td></tr>
<tr><td>v6.1.0</td>
<td>Objects with circular references can be used as inputs now.</td></tr>
<tr><td>v5.10.1, v4.4.3</td>
<td>Handle non-<code>Uint8Array</code> typed arrays correctly.</td></tr>
<tr><td>v1.2.0</td>
<td>Added in: v1.2.0</td></tr>
</tbody></table>
</details>
</div>
<ul>
<li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>expected</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
</ul>
Tests for deep strict inequality. Opposite of <a href="#assert_assert_deepstrictequal_actual_expected_message"><code>assert.deepStrictEqual()</code></a>.
<pre><code class="language-js">const assert = require('assert').strict;

assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
// OK</code></pre>
If the values are deeply and strictly equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown
with a <code>message</code> property set equal to the value of the <code>message</code> parameter. If
the <code>message</code> parameter is undefined, a default error message is assigned. If
the <code>message</code> parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown
instead of the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.
<h2><code>assert.notEqual(actual, expected[, message])</code><a class="mark" href="#assert_assert_notequal_actual_expected_message" id="assert_assert_notequal_actual_expected_message">#</a></h2>
<div class="api_metadata">
Added in: v0.1.21
</div>
<ul>
<li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>expected</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
</ul>
Strict assertion mode
An alias of <a href="#assert_assert_notstrictequal_actual_expected_message"><code>assert.notStrictEqual()</code></a>.
Legacy assertion mode
<div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated: Use <a href="#assert_assert_notstrictequal_actual_expected_message"><code>assert.notStrictEqual()</code></a> instead.</div>
Tests shallow, coercive inequality with the <a href="https://tc39.github.io/ecma262/#sec-abstract-equality-comparison">Abstract Equality Comparison</a>
( <code>!=</code> ).
<pre><code class="language-js">const assert = require('assert');

assert.notEqual(1, 2);
// OK

assert.notEqual(1, 1);
// AssertionError: 1 != 1

assert.notEqual(1, '1');
// AssertionError: 1 != '1'</code></pre>
If the values are equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code>
property set equal to the value of the <code>message</code> parameter. If the <code>message</code>
parameter is undefined, a default error message is assigned. If the <code>message</code>
parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
<code>AssertionError</code>.
<h2><code>assert.notStrictEqual(actual, expected[, message])</code><a class="mark" href="#assert_assert_notstrictequal_actual_expected_message" id="assert_assert_notstrictequal_actual_expected_message">#</a></h2>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v10.0.0</td>
<td>Used comparison changed from Strict Equality to <code>Object.is()</code></td></tr>
<tr><td>v0.1.21</td>
<td>Added in: v0.1.21</td></tr>
</tbody></table>
</details>
</div>
<ul>
<li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>expected</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
</ul>
Tests strict inequality between the <code>actual</code> and <code>expected</code> parameters as
determined by the <a href="https://tc39.github.io/ecma262/#sec-samevalue">SameValue Comparison</a>.
<pre><code class="language-js">const assert = require('assert').strict;

assert.notStrictEqual(1, 2);
// OK

assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1

assert.notStrictEqual(1, '1');
// OK</code></pre>
If the values are strictly equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a
<code>message</code> property set equal to the value of the <code>message</code> parameter. If the
<code>message</code> parameter is undefined, a default error message is assigned. If the
<code>message</code> parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown
instead of the <code>AssertionError</code>.
<h2><code>assert.ok(value[, message])</code><a class="mark" href="#assert_assert_ok_value_message" id="assert_assert_ok_value_message">#</a></h2>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v10.0.0</td>
<td>The <code>assert.ok()</code> (no arguments) will now use a predefined error message.</td></tr>
<tr><td>v0.1.21</td>
<td>Added in: v0.1.21</td></tr>
</tbody></table>
</details>
</div>
<ul>
<li><code>value</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
</ul>
Tests if <code>value</code> is truthy. It is equivalent to
<code>assert.equal(!!value, true, message)</code>.
If <code>value</code> is not truthy, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a <code>message</code>
property set equal to the value of the <code>message</code> parameter. If the <code>message</code>
parameter is <code>undefined</code>, a default error message is assigned. If the <code>message</code>
parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown instead of the
<code>AssertionError</code>.
If no arguments are passed in at all <code>message</code> will be set to the string:
<code>'No value argument passed to `assert.ok()`'</code>.
Be aware that in the <code>repl</code> the error message will be different to the one
thrown in a file! See below for further details.
<pre><code class="language-js">const assert = require('assert').strict;

assert.ok(true);
// OK
assert.ok(1);
// OK

assert.ok();
// AssertionError: No value argument passed to `assert.ok()`

assert.ok(false, 'it\'s false');
// AssertionError: it's false

// In the repl:
assert.ok(typeof 123 === 'string');
// AssertionError: false == true

// In a file (e.g. test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: The expression evaluated to a falsy value:
//
// assert.ok(typeof 123 === 'string')

assert.ok(false);
// AssertionError: The expression evaluated to a falsy value:
//
// assert.ok(false)

assert.ok(0);
// AssertionError: The expression evaluated to a falsy value:
//
// assert.ok(0)

// Using `assert()` works the same:
assert(0);
// AssertionError: The expression evaluated to a falsy value:
//
// assert(0)</code></pre>
<h2><code>assert.rejects(asyncFn[, error][, message])</code><a class="mark" href="#assert_assert_rejects_asyncfn_error_message" id="assert_assert_rejects_asyncfn_error_message">#</a></h2>
<div class="api_metadata">
Added in: v10.0.0
</div>
<ul>
<li><code>asyncFn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" class="type">&#x3C;Promise></a></li>
<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp" class="type">&#x3C;RegExp></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
</ul>
Awaits the <code>asyncFn</code> promise or, if <code>asyncFn</code> is a function, immediately
calls the function and awaits the returned promise to complete. It will then
check that the promise is rejected.
If <code>asyncFn</code> is a function and it throws an error synchronously,
<code>assert.rejects()</code> will return a rejected <code>Promise</code> with that error. If the
function does not return a promise, <code>assert.rejects()</code> will return a rejected
<code>Promise</code> with an <a href="errors.html#errors_err_invalid_return_value"><code>ERR_INVALID_RETURN_VALUE</code></a> error. In both cases the error
handler is skipped.
Besides the async nature to await the completion behaves identically to
<a href="#assert_assert_throws_fn_error_message"><code>assert.throws()</code></a>.
If specified, <code>error</code> can be a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes"><code>Class</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions"><code>RegExp</code></a>, a validation function,
an object where each property will be tested for, or an instance of error where
each property will be tested for including the non-enumerable <code>message</code> and
<code>name</code> properties.
If specified, <code>message</code> will be the message provided by the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>
if the <code>asyncFn</code> fails to reject.
<pre><code class="language-js">(async () => {
 await assert.rejects(
 async () => {
 throw new TypeError('Wrong value');
 },
 {
 name: 'TypeError',
 message: 'Wrong value'
 }
 );
})();</code></pre>
<pre><code class="language-js">(async () => {
 await assert.rejects(
 async () => {
 throw new TypeError('Wrong value');
 },
 (err) => {
 assert.strictEqual(err.name, 'TypeError');
 assert.strictEqual(err.message, 'Wrong value');
 return true;
 }
 );
})();</code></pre>
<pre><code class="language-js">assert.rejects(
 Promise.reject(new Error('Wrong value')),
 Error
).then(() => {
 // ...
});</code></pre>
<code>error</code> cannot be a string. If a string is provided as the second
argument, then <code>error</code> is assumed to be omitted and the string will be used for
<code>message</code> instead. This can lead to easy-to-miss mistakes. Please read the
example in <a href="#assert_assert_throws_fn_error_message"><code>assert.throws()</code></a> carefully if using a string as the second
argument gets considered.
<h2><code>assert.strictEqual(actual, expected[, message])</code><a class="mark" href="#assert_assert_strictequal_actual_expected_message" id="assert_assert_strictequal_actual_expected_message">#</a></h2>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v10.0.0</td>
<td>Used comparison changed from Strict Equality to <code>Object.is()</code></td></tr>
<tr><td>v0.1.21</td>
<td>Added in: v0.1.21</td></tr>
</tbody></table>
</details>
</div>
<ul>
<li><code>actual</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>expected</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
</ul>
Tests strict equality between the <code>actual</code> and <code>expected</code> parameters as
determined by the <a href="https://tc39.github.io/ecma262/#sec-samevalue">SameValue Comparison</a>.
<pre><code class="language-js">const assert = require('assert').strict;

assert.strictEqual(1, 2);
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2

assert.strictEqual(1, 1);
// OK

assert.strictEqual('Hello foobar', 'Hello World!');
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + 'Hello foobar'
// - 'Hello World!'
// ^

const apples = 1;
const oranges = 2;
assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`);
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));
// TypeError: Inputs are not identical</code></pre>
If the values are not strictly equal, an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a> is thrown with a
<code>message</code> property set equal to the value of the <code>message</code> parameter. If the
<code>message</code> parameter is undefined, a default error message is assigned. If the
<code>message</code> parameter is an instance of an <a href="errors.html#errors_class_error"><code>Error</code></a> then it will be thrown
instead of the <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.
<h2><code>assert.throws(fn[, error][, message])</code><a class="mark" href="#assert_assert_throws_fn_error_message" id="assert_assert_throws_fn_error_message">#</a></h2>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v10.2.0</td>
<td>The <code>error</code> parameter can be an object containing regular expressions now.</td></tr>
<tr><td>v9.9.0</td>
<td>The <code>error</code> parameter can now be an object as well.</td></tr>
<tr><td>v4.2.0</td>
<td>The <code>error</code> parameter can now be an arrow function.</td></tr>
<tr><td>v0.1.21</td>
<td>Added in: v0.1.21</td></tr>
</tbody></table>
</details>
</div>
<ul>
<li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
<li><code>error</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp" class="type">&#x3C;RegExp></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&#x3C;Object></a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&#x3C;Error></a></li>
<li><code>message</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&#x3C;string></a></li>
</ul>
Expects the function <code>fn</code> to throw an error.
If specified, <code>error</code> can be a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes"><code>Class</code></a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions"><code>RegExp</code></a>, a validation function,
a validation object where each property will be tested for strict deep equality,
or an instance of error where each property will be tested for strict deep
equality including the non-enumerable <code>message</code> and <code>name</code> properties. When
using an object, it is also possible to use a regular expression, when
validating against a string property. See below for examples.
If specified, <code>message</code> will be appended to the message provided by the
<code>AssertionError</code> if the <code>fn</code> call fails to throw or in case the error validation
fails.
Custom validation object/error instance:
<pre><code class="language-js">const err = new TypeError('Wrong value');
err.code = 404;
err.foo = 'bar';
err.info = {
 nested: true,
 baz: 'text'
};
err.reg = /abc/i;

assert.throws(
 () => {
 throw err;
 },
 {
 name: 'TypeError',
 message: 'Wrong value',
 info: {
 nested: true,
 baz: 'text'
 }
 // Only properties on the validation object will be tested for.
 // Using nested objects requires all properties to be present. Otherwise
 // the validation is going to fail.
 }
);

// Using regular expressions to validate error properties:
assert.throws(
 () => {
 throw err;
 },
 {
 // The `name` and `message` properties are strings and using regular
 // expressions on those will match against the string. If they fail, an
 // error is thrown.
 name: /^TypeError$/,
 message: /Wrong/,
 foo: 'bar',
 info: {
 nested: true,
 // It is not possible to use regular expressions for nested properties!
 baz: 'text'
 },
 // The `reg` property contains a regular expression and only if the
 // validation object contains an identical regular expression, it is going
 // to pass.
 reg: /abc/i
 }
);

// Fails due to the different `message` and `name` properties:
assert.throws(
 () => {
 const otherErr = new Error('Not found');
 // Copy all enumerable properties from `err` to `otherErr`.
 for (const [key, value] of Object.entries(err)) {
 otherErr[key] = value;
 }
 throw otherErr;
 },
 // The error's `message` and `name` properties will also be checked when using
 // an error as validation object.
 err
);</code></pre>
Validate instanceof using constructor:
<pre><code class="language-js">assert.throws(
 () => {
 throw new Error('Wrong value');
 },
 Error
);</code></pre>
Validate error message using <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions"><code>RegExp</code></a>:
Using a regular expression runs <code>.toString</code> on the error object, and will
therefore also include the error name.
<pre><code class="language-js">assert.throws(
 () => {
 throw new Error('Wrong value');
 },
 /^Error: Wrong value$/
);</code></pre>
Custom error validation:
The function must return <code>true</code> to indicate all internal validations passed.
It will otherwise fail with an <a href="#assert_class_assert_assertionerror"><code>AssertionError</code></a>.
<pre><code class="language-js">assert.throws(
 () => {
 throw new Error('Wrong value');
 },
 (err) => {
 assert(err instanceof Error);
 assert(/value/.test(err));
 // Avoid returning anything from validation functions besides `true`.
 // Otherwise, it's not clear what part of the validation failed. Instead,
 // throw an error about the specific validation that failed (as done in this
 // example) and add as much helpful debugging information to that error as
 // possible.
 return true;
 },
 'unexpected error'
);</code></pre>
<code>error</code> cannot be a string. If a string is provided as the second
argument, then <code>error</code> is assumed to be omitted and the string will be used for
<code>message</code> instead. This can lead to easy-to-miss mistakes. Using the same
message as the thrown error message is going to result in an
<code>ERR_AMBIGUOUS_ARGUMENT</code> error. Please read the example below carefully if using
a string as the second argument gets considered:

<pre><code class="language-js">function throwingFirst() {
 throw new Error('First');
}

function throwingSecond() {
 throw new Error('Second');
}

function notThrowing() {}

// The second argument is a string and the input function threw an Error.
// The first case will not throw as it does not match for the error message
// thrown by the input function!
assert.throws(throwingFirst, 'Second');
// In the next example the message has no benefit over the message from the
// error and since it is not clear if the user intended to actually match
// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
assert.throws(throwingSecond, 'Second');
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// The string is only used (as message) in case the function does not throw:
assert.throws(notThrowing, 'Second');
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second

// If it was intended to match for the error message do this instead:
// It does not throw because the error messages match.
assert.throws(throwingSecond, /Second$/);

// If the error message does not match, an AssertionError is thrown.
assert.throws(throwingFirst, /Second$/);
// AssertionError [ERR_ASSERTION]</code></pre>
Due to the confusing error-prone notation, avoid a string as the second
argument.
 
 </div>
 </div>
 </div>
</body>
</html>

cmd: