From f43a0330aa101704231300e3f8cdc30a52d0cc43 Mon Sep 17 00:00:00 2001
From: Tristian Flanagan <tflanagan@datacollaborative.com>
Date: Wed, 4 Nov 2015 10:48:45 -0500
Subject: [PATCH] doc: sort assert alphabetically

Reorders, with no contextual changes, the assert documentation
alphabetically.

PR-URL: https://github.com/nodejs/node/pull/3662
Reviewed-By: Evan Lucas <evanlucas@me.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jeremiah Senkpiel <fishrock123@rocketmail.com>
---
 doc/api/assert.markdown | 108 ++++++++++++++++++++--------------------
 1 file changed, 54 insertions(+), 54 deletions(-)

diff --git a/doc/api/assert.markdown b/doc/api/assert.markdown
index b81037287b499b..a607b92ead197f 100644
--- a/doc/api/assert.markdown
+++ b/doc/api/assert.markdown
@@ -6,25 +6,11 @@ This module is used so that Node.js can test itself. It can be accessed with
 `require('assert')`. However, it is recommended that a userland assertion
 library be used instead.
 
-## assert.fail(actual, expected, message, operator)
-
-Throws an exception that displays the values for `actual` and `expected`
-separated by the provided operator.
-
 ## assert(value[, message]), assert.ok(value[, message])
 
 Tests if value is truthy. It is equivalent to
 `assert.equal(!!value, true, message)`.
 
-## assert.equal(actual, expected[, message])
-
-Tests shallow, coercive equality with the equal comparison operator ( `==` ).
-
-## assert.notEqual(actual, expected[, message])
-
-Tests shallow, coercive inequality with the not equal comparison operator
-( `!=` ).
-
 ## assert.deepEqual(actual, expected[, message])
 
 Tests for deep equality. Primitive values are compared with the equal
@@ -39,27 +25,72 @@ non-enumerable:
     // WARNING: This does not throw an AssertionError!
     assert.deepEqual(Error('a'), Error('b'));
 
+## assert.deepStrictEqual(actual, expected[, message])
+
+Tests for deep equality. Primitive values are compared with the strict equality
+operator ( `===` ).
+
+## assert.doesNotThrow(block[, error][, message])
+
+Expects `block` not to throw an error. See [assert.throws()](#assert_assert_throws_block_error_message) for more details.
+
+If `block` throws an error and if it is of a different type from `error`, the
+thrown error will get propagated back to the caller. The following call will
+throw the `TypeError`, since we're not matching the error types in the
+assertion.
+
+    assert.doesNotThrow(
+      function() {
+        throw new TypeError("Wrong value");
+      },
+      SyntaxError
+    );
+
+In case `error` matches with the error thrown by `block`, an `AssertionError`
+is thrown instead.
+
+    assert.doesNotThrow(
+      function() {
+        throw new TypeError("Wrong value");
+      },
+      TypeError
+    );
+
+## assert.equal(actual, expected[, message])
+
+Tests shallow, coercive equality with the equal comparison operator ( `==` ).
+
+## assert.fail(actual, expected, message, operator)
+
+Throws an exception that displays the values for `actual` and `expected`
+separated by the provided operator.
+
+## assert.ifError(value)
+
+Throws `value` if `value` is truthy. This is useful when testing the `error`
+argument in callbacks.
+
 ## assert.notDeepEqual(actual, expected[, message])
 
 Tests for any deep inequality. Opposite of `assert.deepEqual`.
 
-## assert.strictEqual(actual, expected[, message])
+## assert.notDeepStrictEqual(actual, expected[, message])
 
-Tests strict equality as determined by the strict equality operator ( `===` ).
+Tests for deep inequality. Opposite of `assert.deepStrictEqual`.
+
+## assert.notEqual(actual, expected[, message])
+
+Tests shallow, coercive inequality with the not equal comparison operator
+( `!=` ).
 
 ## assert.notStrictEqual(actual, expected[, message])
 
 Tests strict inequality as determined by the strict not equal operator
 ( `!==` ).
 
-## assert.deepStrictEqual(actual, expected[, message])
-
-Tests for deep equality. Primitive values are compared with the strict equality
-operator ( `===` ).
-
-## assert.notDeepStrictEqual(actual, expected[, message])
+## assert.strictEqual(actual, expected[, message])
 
-Tests for deep inequality. Opposite of `assert.deepStrictEqual`.
+Tests strict equality as determined by the strict equality operator ( `===` ).
 
 ## assert.throws(block[, error][, message])
 
@@ -97,34 +128,3 @@ Custom error validation:
       },
       "unexpected error"
     );
-
-## assert.doesNotThrow(block[, error][, message])
-
-Expects `block` not to throw an error. See [assert.throws()](#assert_assert_throws_block_error_message) for more details.
-
-If `block` throws an error and if it is of a different type from `error`, the
-thrown error will get propagated back to the caller. The following call will
-throw the `TypeError`, since we're not matching the error types in the
-assertion.
-
-    assert.doesNotThrow(
-      function() {
-        throw new TypeError("Wrong value");
-      },
-      SyntaxError
-    );
-
-In case `error` matches with the error thrown by `block`, an `AssertionError`
-is thrown instead.
-
-    assert.doesNotThrow(
-      function() {
-        throw new TypeError("Wrong value");
-      },
-      TypeError
-    );
-
-## assert.ifError(value)
-
-Throws `value` if `value` is truthy. This is useful when testing the `error`
-argument in callbacks.