Add property attribute assertions
[node-assert-extras:jakobwesthoffs-mainline.git] / test / assert_extras_test.js
1 var assert = require("assert");
2 var extras = require("assert-extras");
3
4 assert.doesNotThrow(function () {
5     extras.isNull(null);
6     extras.isNull(null, "Some message");
7
8     extras.isNotNull(undefined);
9     extras.isNotNull(undefined, "Some message");
10     extras.isNotNull({});
11     extras.isNotNull({}, "Some message");
12     extras.isNotNull([]);
13     extras.isNotNull([], "Some message");
14     extras.isNotNull("");
15     extras.isNotNull("", "Some message");
16     extras.isNotNull(0);
17     extras.isNotNull(0, "Some message");
18
19     extras.isTypeOf({}, "object");
20     extras.isTypeOf([], "object");
21     extras.isTypeOf(function () {}, "function");
22     extras.isTypeOf(1, "number");
23     extras.isTypeOf("", "string");
24     extras.isTypeOf(false, "boolean");
25     extras.isTypeOf(null, "object");
26     extras.isTypeOf(undefined, "undefined");
27
28     extras.isNotTypeOf({}, "undefined");
29     extras.isNotTypeOf({}, "function");
30     extras.isNotTypeOf({}, "string");
31     extras.isNotTypeOf({}, "number");
32     extras.isNotTypeOf({}, "boolean");
33     extras.isNotTypeOf("", "object");
34
35     extras.isObject({});
36     extras.isObject({}, "Some message");
37     extras.isObject([]);
38     extras.isObject([], "Some message");
39
40     extras.isFunction(function () {});
41     extras.isFunction(function () {}, "Some message");
42
43     extras.isString("");
44     extras.isString("", "Some message");
45
46     extras.isBoolean(true);
47     extras.isBoolean(true, "Some message");
48
49     extras.isBoolean(false);
50     extras.isBoolean(false, "Some message");
51
52     extras.isNumber(42);
53     extras.isNumber(42, "Some message");
54
55     extras.isUndefined(undefined);
56     extras.isUndefined(undefined, "Some message");
57
58     extras.isNotUndefined({});
59     extras.isNotUndefined({}, "Some message");
60     extras.isNotUndefined([]);
61     extras.isNotUndefined([], "Some message");
62     extras.isNotUndefined("");
63     extras.isNotUndefined("", "Some message");
64     extras.isNotUndefined(0);
65     extras.isNotUndefined(0, "Some message");
66     extras.isNotUndefined(null);
67     extras.isNotUndefined(null, "Some message");
68
69     extras.isArray([]);
70     extras.isArray([], "Some message");
71     extras.isArray([1, 2, 3]);
72     extras.isArray([1, 2, 3], "Some message");
73
74     extras.isNaN("string");
75     extras.isNaN("string", "Some message");
76     extras.isNaN({});
77     extras.isNaN({}, "Some message");
78     extras.isNaN(undefined);
79     extras.isNaN(undefined, "Some message");
80
81     extras.isNotNaN(3);
82     extras.isNotNaN(3, "Some message");
83     extras.isNotNaN(Infinity);
84     extras.isNotNaN(Infinity, "Some message");
85     extras.isNotNaN("");
86     extras.isNotNaN("", "Some message");
87     extras.isNotNaN(null);
88     extras.isNotNaN(null, "Some message");
89
90     extras.match("String", /^Str.ng$/);
91     extras.match("String", /^Str.ng$/, "Some message");
92
93     extras.noMatch("String", /^Stl.ng$/);
94     extras.noMatch("String", /^Stl.ng$/, "Some message");
95
96     extras.isPrototypeOf(Object.prototype, {});
97     extras.isPrototypeOf(Object.prototype, {}, "Some message");
98
99     extras.isPrototypeOf(Object.prototype, function () {});
100     extras.isPrototypeOf(Object.prototype, function () {}, "Some message");
101
102     extras.isNotPrototypeOf(Array.prototype, {});
103     extras.isNotPrototypeOf(Array.prototype, {}, "Some message");
104
105     extras.isNotPrototypeOf({}, {});
106     extras.isNotPrototypeOf({}, {}, "Some message");
107
108     var object = Object.create(Object.prototype, {
109         isWritable: {
110             value: {},
111             writable: true
112         },
113
114         isNotWritable: {
115             value: {},
116             writable: false
117         },
118
119         isConfigurable: {
120             value: {},
121             configurable: true
122         },
123
124         isNotConfigurable: {
125             value: {},
126             configurable: false
127         },
128
129         isEnumerable: {
130             value: {},
131             enumerable: true
132         },
133
134         isNotEnumerable: {
135             value: {},
136             enumerable: false
137         }
138     });
139
140     extras.isWritable(object, "isWritable");
141     extras.isNotWritable(object, "isNotWritable");
142     extras.isConfigurable(object, "isConfigurable");
143     extras.isNotConfigurable(object, "isNotConfigurable");
144     extras.isEnumerable(object, "isEnumerable");
145     extras.isNotEnumerable(object, "isNotEnumerable");
146 });
147
148 assert.strictEqual(extras.fail, assert.fail);
149 assert.strictEqual(extras.ok, assert.ok);
150 assert.strictEqual(extras.equal, assert.equal);
151 assert.strictEqual(extras.notEqual, assert.notEqual);
152 assert.strictEqual(extras.deepEqual, assert.deepEqual);
153 assert.strictEqual(extras.notDeepEqual, assert.notDeepEqual);
154 assert.strictEqual(extras.strictEqual, assert.strictEqual);
155 assert.strictEqual(extras.notStrictEqual, assert.notStrictEqual);
156 assert.strictEqual(extras.throws, assert.throws);
157 assert.strictEqual(extras.doesNotThrow, assert.doesNotThrow);
158
159 assert.throws(function () {
160     extras.isTypeOf(function () {}, "object");
161 }, assert.AssertionError);
162
163 assert.throws(function () {
164     extras.isNotTypeOf(function () {}, "function");
165 }, assert.AssertionError);
166
167 assert.throws(function () {
168     extras.isObject(function () {});
169 }, assert.AssertionError);
170
171 assert.throws(function () {
172     extras.isObject("");
173 }, assert.AssertionError);
174
175 assert.throws(function () {
176     extras.isFunction({});
177 }, assert.AssertionError);
178
179 assert.throws(function () {
180     extras.isFunction([]);
181 }, assert.AssertionError);
182
183 assert.throws(function () {
184     extras.isString({});
185 }, assert.AssertionError);
186
187 assert.throws(function () {
188     extras.isString(null);
189 }, assert.AssertionError);
190
191 assert.throws(function () {
192     extras.isString(undefined);
193 }, assert.AssertionError);
194
195 assert.throws(function () {
196     extras.isBoolean({});
197 }, assert.AssertionError);
198
199 assert.throws(function () {
200     extras.isBoolean(null);
201 }, assert.AssertionError);
202
203 assert.throws(function () {
204     extras.isBoolean(undefined);
205 }, assert.AssertionError);
206
207 assert.throws(function () {
208     extras.isBoolean(0);
209 }, assert.AssertionError);
210
211 assert.throws(function () {
212     extras.isBoolean("");
213 }, assert.AssertionError);
214
215 assert.throws(function () {
216     extras.isNumber({});
217 }, assert.AssertionError);
218
219 assert.throws(function () {
220     extras.isNumber(null);
221 }, assert.AssertionError);
222
223 assert.throws(function () {
224     extras.isNumber("");
225 }, assert.AssertionError);
226
227 assert.throws(function () {
228     extras.isUndefined({});
229 }, assert.AssertionError);
230
231 assert.throws(function () {
232     extras.isUndefined(null);
233 }, assert.AssertionError);
234
235 assert.throws(function () {
236     extras.isUndefined("");
237 }, assert.AssertionError);
238
239 assert.throws(function () {
240     extras.isUndefined(0);
241 }, assert.AssertionError);
242
243 assert.throws(function () {
244     extras.isNotUndefined(undefined);
245 }, assert.AssertionError);
246
247 assert.throws(function () {
248     extras.isArray(undefined);
249 }, assert.AssertionError);
250
251 assert.throws(function () {
252     extras.isArray({});
253 }, assert.AssertionError);
254
255 assert.throws(function () {
256     extras.isArray({ length: 1, "0": 42 });
257 }, assert.AssertionError);
258
259 assert.throws(function () {
260     extras.isNaN(3);
261 }, assert.AssertionError);
262
263 assert.throws(function () {
264     extras.isNaN("");
265 }, assert.AssertionError);
266
267 assert.throws(function () {
268     extras.isNaN(Infinity);
269 }, assert.AssertionError);
270
271 assert.throws(function () {
272     extras.isNotNaN("string");
273 }, assert.AssertionError);
274
275 assert.throws(function () {
276     extras.isNotNaN({});
277 }, assert.AssertionError);
278
279 assert.throws(function () {
280     extras.isNotNaN([{}]);
281 }, assert.AssertionError);
282
283 assert.throws(function () {
284     extras.match("hey", /HEY/);
285 }, assert.AssertionError);
286
287 assert.throws(function () {
288     extras.match("", /a/);
289 }, assert.AssertionError);
290
291 assert.throws(function () {
292     extras.match("text", /^tex$/);
293 }, assert.AssertionError);
294
295 assert.throws(function () {
296     extras.noMatch("text", /^text$/);
297 }, assert.AssertionError);
298
299 assert.throws(function () {
300     extras.noMatch("text", /^.*$/);
301 }, assert.AssertionError);
302
303 assert.throws(function () {
304     extras.isPrototypeOf({}, {});
305 }, assert.AssertionError);
306
307 assert.throws(function () {
308     extras.isPrototypeOf({}, Object.prototype);
309 }, assert.AssertionError);
310
311 assert.throws(function () {
312     extras.isNotPrototypeOf(Object.prototype, {});
313 }, assert.AssertionError);
314
315 assert.throws(function () {
316     extras.isNotPrototypeOf(Array.prototype, []);
317 }, assert.AssertionError);