← Back to branch summary

~ubuntu-branches/ubuntu/saucy/nodejs/saucy-proposed

« back to all changes in this revision

Viewing changes to doc/api/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/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(&apos;assert&apos;)</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 a <code>true</code> value, 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, [error], [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": "error",
228
 
                  "optional": true
229
 
                },
230
 
                {
231
 
                  "name": "message",
232
 
                  "optional": true
233
 
                }
234
 
              ]
235
 
            }
236
 
          ]
237
 
        },
238
 
        {
239
 
          "textRaw": "assert.ifError(value)",
240
 
          "type": "method",
241
 
          "name": "ifError",
242
 
          "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",
243
 
          "signatures": [
244
 
            {
245
 
              "params": [
246
 
                {
247
 
                  "name": "value"
248
 
                }
249
 
              ]
250
 
            }
251
 
          ]
252
 
        }
253
 
      ],
254
 
      "type": "module",
255
 
      "displayName": "Assert"
256
 
    }
257
 
  ]
258
 
}