source: trip-planner-front/node_modules/function-bind/test/index.js@ 571e0df

Last change on this file since 571e0df was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 8.8 KB
Line 
1// jscs:disable requireUseStrict
2
3var test = require('tape');
4
5var functionBind = require('../implementation');
6var getCurrentContext = function () { return this; };
7
8test('functionBind is a function', function (t) {
9 t.equal(typeof functionBind, 'function');
10 t.end();
11});
12
13test('non-functions', function (t) {
14 var nonFunctions = [true, false, [], {}, 42, 'foo', NaN, /a/g];
15 t.plan(nonFunctions.length);
16 for (var i = 0; i < nonFunctions.length; ++i) {
17 try { functionBind.call(nonFunctions[i]); } catch (ex) {
18 t.ok(ex instanceof TypeError, 'throws when given ' + String(nonFunctions[i]));
19 }
20 }
21 t.end();
22});
23
24test('without a context', function (t) {
25 t.test('binds properly', function (st) {
26 var args, context;
27 var namespace = {
28 func: functionBind.call(function () {
29 args = Array.prototype.slice.call(arguments);
30 context = this;
31 })
32 };
33 namespace.func(1, 2, 3);
34 st.deepEqual(args, [1, 2, 3]);
35 st.equal(context, getCurrentContext.call());
36 st.end();
37 });
38
39 t.test('binds properly, and still supplies bound arguments', function (st) {
40 var args, context;
41 var namespace = {
42 func: functionBind.call(function () {
43 args = Array.prototype.slice.call(arguments);
44 context = this;
45 }, undefined, 1, 2, 3)
46 };
47 namespace.func(4, 5, 6);
48 st.deepEqual(args, [1, 2, 3, 4, 5, 6]);
49 st.equal(context, getCurrentContext.call());
50 st.end();
51 });
52
53 t.test('returns properly', function (st) {
54 var args;
55 var namespace = {
56 func: functionBind.call(function () {
57 args = Array.prototype.slice.call(arguments);
58 return this;
59 }, null)
60 };
61 var context = namespace.func(1, 2, 3);
62 st.equal(context, getCurrentContext.call(), 'returned context is namespaced context');
63 st.deepEqual(args, [1, 2, 3], 'passed arguments are correct');
64 st.end();
65 });
66
67 t.test('returns properly with bound arguments', function (st) {
68 var args;
69 var namespace = {
70 func: functionBind.call(function () {
71 args = Array.prototype.slice.call(arguments);
72 return this;
73 }, null, 1, 2, 3)
74 };
75 var context = namespace.func(4, 5, 6);
76 st.equal(context, getCurrentContext.call(), 'returned context is namespaced context');
77 st.deepEqual(args, [1, 2, 3, 4, 5, 6], 'passed arguments are correct');
78 st.end();
79 });
80
81 t.test('called as a constructor', function (st) {
82 var thunkify = function (value) {
83 return function () { return value; };
84 };
85 st.test('returns object value', function (sst) {
86 var expectedReturnValue = [1, 2, 3];
87 var Constructor = functionBind.call(thunkify(expectedReturnValue), null);
88 var result = new Constructor();
89 sst.equal(result, expectedReturnValue);
90 sst.end();
91 });
92
93 st.test('does not return primitive value', function (sst) {
94 var Constructor = functionBind.call(thunkify(42), null);
95 var result = new Constructor();
96 sst.notEqual(result, 42);
97 sst.end();
98 });
99
100 st.test('object from bound constructor is instance of original and bound constructor', function (sst) {
101 var A = function (x) {
102 this.name = x || 'A';
103 };
104 var B = functionBind.call(A, null, 'B');
105
106 var result = new B();
107 sst.ok(result instanceof B, 'result is instance of bound constructor');
108 sst.ok(result instanceof A, 'result is instance of original constructor');
109 sst.end();
110 });
111
112 st.end();
113 });
114
115 t.end();
116});
117
118test('with a context', function (t) {
119 t.test('with no bound arguments', function (st) {
120 var args, context;
121 var boundContext = {};
122 var namespace = {
123 func: functionBind.call(function () {
124 args = Array.prototype.slice.call(arguments);
125 context = this;
126 }, boundContext)
127 };
128 namespace.func(1, 2, 3);
129 st.equal(context, boundContext, 'binds a context properly');
130 st.deepEqual(args, [1, 2, 3], 'supplies passed arguments');
131 st.end();
132 });
133
134 t.test('with bound arguments', function (st) {
135 var args, context;
136 var boundContext = {};
137 var namespace = {
138 func: functionBind.call(function () {
139 args = Array.prototype.slice.call(arguments);
140 context = this;
141 }, boundContext, 1, 2, 3)
142 };
143 namespace.func(4, 5, 6);
144 st.equal(context, boundContext, 'binds a context properly');
145 st.deepEqual(args, [1, 2, 3, 4, 5, 6], 'supplies bound and passed arguments');
146 st.end();
147 });
148
149 t.test('returns properly', function (st) {
150 var boundContext = {};
151 var args;
152 var namespace = {
153 func: functionBind.call(function () {
154 args = Array.prototype.slice.call(arguments);
155 return this;
156 }, boundContext)
157 };
158 var context = namespace.func(1, 2, 3);
159 st.equal(context, boundContext, 'returned context is bound context');
160 st.notEqual(context, getCurrentContext.call(), 'returned context is not lexical context');
161 st.deepEqual(args, [1, 2, 3], 'passed arguments are correct');
162 st.end();
163 });
164
165 t.test('returns properly with bound arguments', function (st) {
166 var boundContext = {};
167 var args;
168 var namespace = {
169 func: functionBind.call(function () {
170 args = Array.prototype.slice.call(arguments);
171 return this;
172 }, boundContext, 1, 2, 3)
173 };
174 var context = namespace.func(4, 5, 6);
175 st.equal(context, boundContext, 'returned context is bound context');
176 st.notEqual(context, getCurrentContext.call(), 'returned context is not lexical context');
177 st.deepEqual(args, [1, 2, 3, 4, 5, 6], 'passed arguments are correct');
178 st.end();
179 });
180
181 t.test('passes the correct arguments when called as a constructor', function (st) {
182 var expected = { name: 'Correct' };
183 var namespace = {
184 Func: functionBind.call(function (arg) {
185 return arg;
186 }, { name: 'Incorrect' })
187 };
188 var returned = new namespace.Func(expected);
189 st.equal(returned, expected, 'returns the right arg when called as a constructor');
190 st.end();
191 });
192
193 t.test('has the new instance\'s context when called as a constructor', function (st) {
194 var actualContext;
195 var expectedContext = { foo: 'bar' };
196 var namespace = {
197 Func: functionBind.call(function () {
198 actualContext = this;
199 }, expectedContext)
200 };
201 var result = new namespace.Func();
202 st.equal(result instanceof namespace.Func, true);
203 st.notEqual(actualContext, expectedContext);
204 st.end();
205 });
206
207 t.end();
208});
209
210test('bound function length', function (t) {
211 t.test('sets a correct length without thisArg', function (st) {
212 var subject = functionBind.call(function (a, b, c) { return a + b + c; });
213 st.equal(subject.length, 3);
214 st.equal(subject(1, 2, 3), 6);
215 st.end();
216 });
217
218 t.test('sets a correct length with thisArg', function (st) {
219 var subject = functionBind.call(function (a, b, c) { return a + b + c; }, {});
220 st.equal(subject.length, 3);
221 st.equal(subject(1, 2, 3), 6);
222 st.end();
223 });
224
225 t.test('sets a correct length without thisArg and first argument', function (st) {
226 var subject = functionBind.call(function (a, b, c) { return a + b + c; }, undefined, 1);
227 st.equal(subject.length, 2);
228 st.equal(subject(2, 3), 6);
229 st.end();
230 });
231
232 t.test('sets a correct length with thisArg and first argument', function (st) {
233 var subject = functionBind.call(function (a, b, c) { return a + b + c; }, {}, 1);
234 st.equal(subject.length, 2);
235 st.equal(subject(2, 3), 6);
236 st.end();
237 });
238
239 t.test('sets a correct length without thisArg and too many arguments', function (st) {
240 var subject = functionBind.call(function (a, b, c) { return a + b + c; }, undefined, 1, 2, 3, 4);
241 st.equal(subject.length, 0);
242 st.equal(subject(), 6);
243 st.end();
244 });
245
246 t.test('sets a correct length with thisArg and too many arguments', function (st) {
247 var subject = functionBind.call(function (a, b, c) { return a + b + c; }, {}, 1, 2, 3, 4);
248 st.equal(subject.length, 0);
249 st.equal(subject(), 6);
250 st.end();
251 });
252});
Note: See TracBrowser for help on using the repository browser.