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});
253