← Back to branch summary

~yolanda.robla/ubuntu/trusty/nodejs/add_distribution

« back to all changes in this revision

Viewing changes to doc/api/assert.json

  • Committer: Package Import Robot
  • Author(s): Jérémy Lal
  • Date: 2013-08-14 00:16:46 UTC
  • mfrom: (7.1.40 sid)
  • Revision ID: package-import@ubuntu.com-20130814001646-bzlysfh8sd6mukbo
Tags: 0.10.15~dfsg1-4
* Update 2005 patch, adding a handful of tests that can fail on
  slow platforms.
* Add 1004 patch to fix test failures when writing NaN to buffer
  on mipsel.

Show diffs side-by-side

added added

removed removed

Lines of Context:
doc/api/assert.json
 
1
{
 
2
  "source": "doc/api/assert.markdown",
 
3
  "modules": [
 
4
    {
 
5
      "textRaw": "Assert",
 
6
      "name": "assert",
 
7
      "stability": 5,
 
8
      "stabilityText": "Locked",
 
9
      "desc": "<p>This module is used for writing unit tests for your applications, you can\naccess it with <code>require(&#39;assert&#39;)</code>.\n\n</p>\n",
 
10
      "methods": [
 
11
        {
 
12
          "textRaw": "assert.fail(actual, expected, message, operator)",
 
13
          "type": "method",
 
14
          "name": "fail",
 
15
          "desc": "<p>Throws an exception that displays the values for <code>actual</code> and <code>expected</code> separated by the provided operator.\n\n</p>\n",
 
16
          "signatures": [
 
17
            {
 
18
              "params": [
 
19
                {
 
20
                  "name": "actual"
 
21
                },
 
22
                {
 
23
                  "name": "expected"
 
24
                },
 
25
                {
 
26
                  "name": "message"
 
27
                },
 
28
                {
 
29
                  "name": "operator"
 
30
                }
 
31
              ]
 
32
            }
 
33
          ]
 
34
        },
 
35
        {
 
36
          "textRaw": "assert(value, message), assert.ok(value, [message])",
 
37
          "type": "method",
 
38
          "name": "ok",
 
39
          "desc": "<p>Tests if value is truthy, it is equivalent to <code>assert.equal(true, !!value, message);</code>\n\n</p>\n",
 
40
          "signatures": [
 
41
            {
 
42
              "params": [
 
43
                {
 
44
                  "name": "value"
 
45
                },
 
46
                {
 
47
                  "name": "message)"
 
48
                },
 
49
                {
 
50
                  "name": "assert.ok(value"
 
51
                },
 
52
                {
 
53
                  "name": "message",
 
54
                  "optional": true
 
55
                }
 
56
              ]
 
57
            }
 
58
          ]
 
59
        },
 
60
        {
 
61
          "textRaw": "assert.equal(actual, expected, [message])",
 
62
          "type": "method",
 
63
          "name": "equal",
 
64
          "desc": "<p>Tests shallow, coercive equality with the equal comparison operator ( <code>==</code> ).\n\n</p>\n",
 
65
          "signatures": [
 
66
            {
 
67
              "params": [
 
68
                {
 
69
                  "name": "actual"
 
70
                },
 
71
                {
 
72
                  "name": "expected"
 
73
                },
 
74
                {
 
75
                  "name": "message",
 
76
                  "optional": true
 
77
                }
 
78
              ]
 
79
            }
 
80
          ]
 
81
        },
 
82
        {
 
83
          "textRaw": "assert.notEqual(actual, expected, [message])",
 
84
          "type": "method",
 
85
          "name": "notEqual",
 
86
          "desc": "<p>Tests shallow, coercive non-equality with the not equal comparison operator ( <code>!=</code> ).\n\n</p>\n",
 
87
          "signatures": [
 
88
            {
 
89
              "params": [
 
90
                {
 
91
                  "name": "actual"
 
92
                },
 
93
                {
 
94
                  "name": "expected"
 
95
                },
 
96
                {
 
97
                  "name": "message",
 
98
                  "optional": true
 
99
                }
 
100
              ]
 
101
            }
 
102
          ]
 
103
        },
 
104
        {
 
105
          "textRaw": "assert.deepEqual(actual, expected, [message])",
 
106
          "type": "method",
 
107
          "name": "deepEqual",
 
108
          "desc": "<p>Tests for deep equality.\n\n</p>\n",
 
109
          "signatures": [
 
110
            {
 
111
              "params": [
 
112
                {
 
113
                  "name": "actual"
 
114
                },
 
115
                {
 
116
                  "name": "expected"
 
117
                },
 
118
                {
 
119
                  "name": "message",
 
120
                  "optional": true
 
121
                }
 
122
              ]
 
123
            }
 
124
          ]
 
125
        },
 
126
        {
 
127
          "textRaw": "assert.notDeepEqual(actual, expected, [message])",
 
128
          "type": "method",
 
129
          "name": "notDeepEqual",
 
130
          "desc": "<p>Tests for any deep inequality.\n\n</p>\n",
 
131
          "signatures": [
 
132
            {
 
133
              "params": [
 
134
                {
 
135
                  "name": "actual"
 
136
                },
 
137
                {
 
138
                  "name": "expected"
 
139
                },
 
140
                {
 
141
                  "name": "message",
 
142
                  "optional": true
 
143
                }
 
144
              ]
 
145
            }
 
146
          ]
 
147
        },
 
148
        {
 
149
          "textRaw": "assert.strictEqual(actual, expected, [message])",
 
150
          "type": "method",
 
151
          "name": "strictEqual",
 
152
          "desc": "<p>Tests strict equality, as determined by the strict equality operator ( <code>===</code> )\n\n</p>\n",
 
153
          "signatures": [
 
154
            {
 
155
              "params": [
 
156
                {
 
157
                  "name": "actual"
 
158
                },
 
159
                {
 
160
                  "name": "expected"
 
161
                },
 
162
                {
 
163
                  "name": "message",
 
164
                  "optional": true
 
165
                }
 
166
              ]
 
167
            }
 
168
          ]
 
169
        },
 
170
        {
 
171
          "textRaw": "assert.notStrictEqual(actual, expected, [message])",
 
172
          "type": "method",
 
173
          "name": "notStrictEqual",
 
174
          "desc": "<p>Tests strict non-equality, as determined by the strict not equal operator ( <code>!==</code> )\n\n</p>\n",
 
175
          "signatures": [
 
176
            {
 
177
              "params": [
 
178
                {
 
179
                  "name": "actual"
 
180
                },
 
181
                {
 
182
                  "name": "expected"
 
183
                },
 
184
                {
 
185
                  "name": "message",
 
186
                  "optional": true
 
187
                }
 
188
              ]
 
189
            }
 
190
          ]
 
191
        },
 
192
        {
 
193
          "textRaw": "assert.throws(block, [error], [message])",
 
194
          "type": "method",
 
195
          "name": "throws",
 
196
          "desc": "<p>Expects <code>block</code> to throw an error. <code>error</code> can be constructor, regexp 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",
 
197
          "signatures": [
 
198
            {
 
199
              "params": [
 
200
                {
 
201
                  "name": "block"
 
202
                },
 
203
                {
 
204
                  "name": "error",
 
205
                  "optional": true
 
206
                },
 
207
                {
 
208
                  "name": "message",
 
209
                  "optional": true
 
210
                }
 
211
              ]
 
212
            }
 
213
          ]
 
214
        },
 
215
        {
 
216
          "textRaw": "assert.doesNotThrow(block, [message])",
 
217
          "type": "method",
 
218
          "name": "doesNotThrow",
 
219
          "desc": "<p>Expects <code>block</code> not to throw an error, see assert.throws for details.\n\n</p>\n",
 
220
          "signatures": [
 
221
            {
 
222
              "params": [
 
223
                {
 
224
                  "name": "block"
 
225
                },
 
226
                {
 
227
                  "name": "message",
 
228
                  "optional": true
 
229
                }
 
230
              ]
 
231
            }
 
232
          ]
 
233
        },
 
234
        {
 
235
          "textRaw": "assert.ifError(value)",
 
236
          "type": "method",
 
237
          "name": "ifError",
 
238
          "desc": "<p>Tests if value is not a false value, throws if it is a true value. Useful when\ntesting the first argument, <code>error</code> in callbacks.\n</p>\n",
 
239
          "signatures": [
 
240
            {
 
241
              "params": [
 
242
                {
 
243
                  "name": "value"
 
244
                }
 
245
              ]
 
246
            }
 
247
          ]
 
248
        }
 
249
      ],
 
250
      "type": "module",
 
251
      "displayName": "Assert"
 
252
    }
 
253
  ]
 
254
}