{
  "source": "doc/api/assert.markdown",
  "modules": [
    {
      "textRaw": "Assert",
      "name": "assert",
      "stability": 3,
      "stabilityText": "Locked",
      "desc": "<p>This module is used so that Node.js can test itself. It can be accessed with\n<code>require(&#39;assert&#39;)</code>. However, it is recommended that a userland assertion\nlibrary be used instead.\n\n</p>\n",
      "methods": [
        {
          "textRaw": "assert.fail(actual, expected, message, operator)",
          "type": "method",
          "name": "fail",
          "desc": "<p>Throws an exception that displays the values for <code>actual</code> and <code>expected</code>\nseparated by the provided operator.\n\n</p>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "actual"
                },
                {
                  "name": "expected"
                },
                {
                  "name": "message"
                },
                {
                  "name": "operator"
                }
              ]
            }
          ]
        },
        {
          "textRaw": "assert(value[, message]), assert.ok(value[, message])",
          "type": "method",
          "name": "ok",
          "desc": "<p>Tests if value is truthy. It is equivalent to\n<code>assert.equal(true, !!value, message)</code>.\n\n</p>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "value"
                },
                {
                  "name": "message])"
                },
                {
                  "name": "assert.ok(value"
                },
                {
                  "name": "message",
                  "optional": true
                }
              ]
            }
          ]
        },
        {
          "textRaw": "assert.equal(actual, expected[, message])",
          "type": "method",
          "name": "equal",
          "desc": "<p>Tests shallow, coercive equality with the equal comparison operator ( <code>==</code> ).\n\n</p>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "actual"
                },
                {
                  "name": "expected"
                },
                {
                  "name": "message",
                  "optional": true
                }
              ]
            }
          ]
        },
        {
          "textRaw": "assert.notEqual(actual, expected[, message])",
          "type": "method",
          "name": "notEqual",
          "desc": "<p>Tests shallow, coercive inequality with the not equal comparison operator\n( <code>!=</code> ).\n\n</p>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "actual"
                },
                {
                  "name": "expected"
                },
                {
                  "name": "message",
                  "optional": true
                }
              ]
            }
          ]
        },
        {
          "textRaw": "assert.deepEqual(actual, expected[, message])",
          "type": "method",
          "name": "deepEqual",
          "desc": "<p>Tests for deep equality. Primitive values are compared with the equal\ncomparison operator ( <code>==</code> ).\n\n</p>\n<p>This only considers enumerable properties. It does not test object prototypes,\nattached symbols, or non-enumerable properties. This can lead to some\npotentially surprising results. For example, this does not throw an\n<code>AssertionError</code> because the properties on the <code>Error</code> object are\nnon-enumerable:\n\n</p>\n<pre><code>// WARNING: This does not throw an AssertionError!\nassert.deepEqual(Error(&#39;a&#39;), Error(&#39;b&#39;));</code></pre>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "actual"
                },
                {
                  "name": "expected"
                },
                {
                  "name": "message",
                  "optional": true
                }
              ]
            }
          ]
        },
        {
          "textRaw": "assert.notDeepEqual(actual, expected[, message])",
          "type": "method",
          "name": "notDeepEqual",
          "desc": "<p>Tests for any deep inequality. Opposite of <code>assert.deepEqual</code>.\n\n</p>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "actual"
                },
                {
                  "name": "expected"
                },
                {
                  "name": "message",
                  "optional": true
                }
              ]
            }
          ]
        },
        {
          "textRaw": "assert.strictEqual(actual, expected[, message])",
          "type": "method",
          "name": "strictEqual",
          "desc": "<p>Tests strict equality as determined by the strict equality operator ( <code>===</code> ).\n\n</p>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "actual"
                },
                {
                  "name": "expected"
                },
                {
                  "name": "message",
                  "optional": true
                }
              ]
            }
          ]
        },
        {
          "textRaw": "assert.notStrictEqual(actual, expected[, message])",
          "type": "method",
          "name": "notStrictEqual",
          "desc": "<p>Tests strict inequality as determined by the strict not equal operator\n( <code>!==</code> ).\n\n</p>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "actual"
                },
                {
                  "name": "expected"
                },
                {
                  "name": "message",
                  "optional": true
                }
              ]
            }
          ]
        },
        {
          "textRaw": "assert.deepStrictEqual(actual, expected[, message])",
          "type": "method",
          "name": "deepStrictEqual",
          "desc": "<p>Tests for deep equality. Primitive values are compared with the strict equality\noperator ( <code>===</code> ).\n\n</p>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "actual"
                },
                {
                  "name": "expected"
                },
                {
                  "name": "message",
                  "optional": true
                }
              ]
            }
          ]
        },
        {
          "textRaw": "assert.notDeepStrictEqual(actual, expected[, message])",
          "type": "method",
          "name": "notDeepStrictEqual",
          "desc": "<p>Tests for deep inequality. Opposite of <code>assert.deepStrictEqual</code>.\n\n</p>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "actual"
                },
                {
                  "name": "expected"
                },
                {
                  "name": "message",
                  "optional": true
                }
              ]
            }
          ]
        },
        {
          "textRaw": "assert.throws(block[, error][, message])",
          "type": "method",
          "name": "throws",
          "desc": "<p>Expects <code>block</code> to throw an error. <code>error</code> can be a constructor, <code>RegExp</code>, or\nvalidation function.\n\n</p>\n<p>Validate instanceof using constructor:\n\n</p>\n<pre><code>assert.throws(\n  function() {\n    throw new Error(&quot;Wrong value&quot;);\n  },\n  Error\n);</code></pre>\n<p>Validate error message using RegExp:\n\n</p>\n<pre><code>assert.throws(\n  function() {\n    throw new Error(&quot;Wrong value&quot;);\n  },\n  /value/\n);</code></pre>\n<p>Custom error validation:\n\n</p>\n<pre><code>assert.throws(\n  function() {\n    throw new Error(&quot;Wrong value&quot;);\n  },\n  function(err) {\n    if ( (err instanceof Error) &amp;&amp; /value/.test(err) ) {\n      return true;\n    }\n  },\n  &quot;unexpected error&quot;\n);</code></pre>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "block"
                },
                {
                  "name": "error",
                  "optional": true
                },
                {
                  "name": "message",
                  "optional": true
                }
              ]
            }
          ]
        },
        {
          "textRaw": "assert.doesNotThrow(block[, error][, message])",
          "type": "method",
          "name": "doesNotThrow",
          "desc": "<p>Expects <code>block</code> not to throw an error. See <a href=\"#assert_assert_throws_block_error_message\">assert.throws()</a> for more details.\n\n</p>\n<p>If <code>block</code> throws an error and if it is of a different type from <code>error</code>, the\nthrown error will get propagated back to the caller. The following call will\nthrow the <code>TypeError</code>, since we&#39;re not matching the error types in the\nassertion.\n\n</p>\n<pre><code>assert.doesNotThrow(\n  function() {\n    throw new TypeError(&quot;Wrong value&quot;);\n  },\n  SyntaxError\n);</code></pre>\n<p>In case <code>error</code> matches with the error thrown by <code>block</code>, an <code>AssertionError</code>\nis thrown instead.\n\n</p>\n<pre><code>assert.doesNotThrow(\n  function() {\n    throw new TypeError(&quot;Wrong value&quot;);\n  },\n  TypeError\n);</code></pre>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "block"
                },
                {
                  "name": "error",
                  "optional": true
                },
                {
                  "name": "message",
                  "optional": true
                }
              ]
            }
          ]
        },
        {
          "textRaw": "assert.ifError(value)",
          "type": "method",
          "name": "ifError",
          "desc": "<p>Throws <code>value</code> if <code>value</code> is truthy. This is useful when testing the <code>error</code>\nargument in callbacks.\n</p>\n",
          "signatures": [
            {
              "params": [
                {
                  "name": "value"
                }
              ]
            }
          ]
        }
      ],
      "type": "module",
      "displayName": "Assert"
    }
  ]
}