1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/*
* Any copyright is dedicated to the Public Domain.
* http://creativecommons.org/licenses/publicdomain/
*/
/*
* Return true if both of these return true:
* - LENIENT_PRED applied to CODE
* - STRICT_PRED applied to CODE with a use strict directive added to the front
*
* Run STRICT_PRED first, for testing code that affects the global environment
* in loose mode, but fails in strict mode.
*/
function testLenientAndStrict(code, lenient_pred, strict_pred) {
return (strict_pred("'use strict'; " + code) &&
lenient_pred(code));
}
/*
* completesNormally(CODE) returns true if evaluating CODE (as eval
* code) completes normally (rather than throwing an exception).
*/
function completesNormally(code) {
try {
eval(code);
return true;
} catch (exception) {
return false;
}
}
/*
* returns(VALUE)(CODE) returns true if evaluating CODE (as eval code)
* completes normally (rather than throwing an exception), yielding a value
* strictly equal to VALUE.
*/
function returns(value) {
return function(code) {
try {
return eval(code) === value;
} catch (exception) {
return false;
}
}
}
/*
* returnsCopyOf(VALUE)(CODE) returns true if evaluating CODE (as eval code)
* completes normally (rather than throwing an exception), yielding a value
* that is deepEqual to VALUE.
*/
function returnsCopyOf(value) {
return function(code) {
try {
return deepEqual(eval(code), value);
} catch (exception) {
return false;
}
}
}
/*
* raisesException(EXCEPTION)(CODE) returns true if evaluating CODE (as
* eval code) throws an exception object that is an instance of EXCEPTION,
* and returns false if it throws any other error or evaluates
* successfully. For example: raises(TypeError)("0()") == true.
*/
function raisesException(exception) {
return function (code) {
try {
eval(code);
return false;
} catch (actual) {
return actual instanceof exception;
}
};
};
/*
* parsesSuccessfully(CODE) returns true if CODE parses as function
* code without an error.
*/
function parsesSuccessfully(code) {
try {
Function(code);
return true;
} catch (exception) {
return false;
}
};
/*
* parseRaisesException(EXCEPTION)(CODE) returns true if parsing CODE
* as function code raises EXCEPTION.
*/
function parseRaisesException(exception) {
return function (code) {
try {
Function(code);
return false;
} catch (actual) {
return actual instanceof exception;
}
};
};
/*
* Return the result of applying uneval to VAL, and replacing all runs
* of whitespace with a single horizontal space (poor man's
* tokenization).
*/
function clean_uneval(val) {
return uneval(val).replace(/\s+/g, ' ');
}
/*
* Return true if A is equal to B, where equality on arrays and objects
* means that they have the same set of enumerable properties, the values
* of each property are deep_equal, and their 'length' properties are
* equal. Equality on other types is ==.
*/
function deepEqual(a, b) {
if (typeof a != typeof b)
return false;
if (typeof a == 'object') {
var props = {};
// For every property of a, does b have that property with an equal value?
for (var prop in a) {
if (!deepEqual(a[prop], b[prop]))
return false;
props[prop] = true;
}
// Are all of b's properties present on a?
for (var prop in b)
if (!props[prop])
return false;
// length isn't enumerable, but we want to check it, too.
return a.length == b.length;
}
if (a === b) {
// Distinguish 0 from -0, even though they are ===.
return a !== 0 || 1/a === 1/b;
}
// Treat NaNs as equal, even though NaN !== NaN.
// NaNs are the only non-reflexive values, i.e., if a !== a, then a is a NaN.
// isNaN is broken: it converts its argument to number, so isNaN("foo") => true
return a !== a && b !== b;
}
|
