|
1 require("../env"); |
|
2 require("../../d3"); |
|
3 |
|
4 var vows = require("vows"), |
|
5 assert = require("assert"); |
|
6 |
|
7 var suite = vows.describe("d3.svg.area"); |
|
8 |
|
9 suite.addBatch({ |
|
10 "area": { |
|
11 topic: function() { |
|
12 return d3.svg.area; |
|
13 }, |
|
14 |
|
15 "x is an alias for setting x0 and x1": function(area) { |
|
16 var a = area().x(f); |
|
17 function f() {} |
|
18 assert.equal(a.x(), f); |
|
19 assert.equal(a.x0(), f); |
|
20 assert.equal(a.x1(), f); |
|
21 }, |
|
22 "x is an alias for getting x1": function(area) { |
|
23 var a = area().x1(f); |
|
24 function f() {} |
|
25 assert.equal(a.x(), f); |
|
26 }, |
|
27 |
|
28 "y is an alias for setting y0 and y1": function(area) { |
|
29 var a = area().y(f); |
|
30 function f() {} |
|
31 assert.equal(a.y(), f); |
|
32 assert.equal(a.y0(), f); |
|
33 assert.equal(a.y1(), f); |
|
34 }, |
|
35 "y is an alias for getting x1": function(area) { |
|
36 var a = area().y1(f); |
|
37 function f() {} |
|
38 assert.equal(a.y(), f); |
|
39 }, |
|
40 |
|
41 "x0 defaults to a function accessor": function(area) { |
|
42 var a = area(); |
|
43 assert.pathEqual(a([[1, 2], [4, 3]]), "M1,2L4,3L4,0L1,0Z"); |
|
44 assert.typeOf(a.x0(), "function"); |
|
45 }, |
|
46 "x0 can be defined as a constant": function(area) { |
|
47 var a = area().x0(0); |
|
48 assert.pathEqual(a([[1, 2], [4, 3]]), "M1,2L4,3L0,0L0,0Z"); |
|
49 assert.equal(a.x0(), 0); |
|
50 }, |
|
51 "x0 can be defined as a function": function(area) { |
|
52 var a = area().x0(f), t = {}, dd = [], ii = [], tt = []; |
|
53 function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return 0; } |
|
54 assert.pathEqual(a.call(t, [[1, 2], [4, 3]]), "M1,2L4,3L0,0L0,0Z"); |
|
55 assert.deepEqual(dd, [[1, 2], [4, 3]], "expected data, got {actual}"); |
|
56 assert.deepEqual(ii, [0, 1], "expected index, got {actual}"); |
|
57 assert.deepEqual(tt, [t, t], "expected this, got {actual}"); |
|
58 }, |
|
59 |
|
60 "x1 defaults to a function accessor": function(area) { |
|
61 var a = area(); |
|
62 assert.pathEqual(a([[1, 2], [4, 3]]), "M1,2L4,3L4,0L1,0Z"); |
|
63 assert.typeOf(a.x1(), "function"); |
|
64 }, |
|
65 "x1 can be defined as a constant": function(area) { |
|
66 var a = area().x1(0); |
|
67 assert.pathEqual(a([[1, 2], [4, 3]]), "M0,2L0,3L4,0L1,0Z"); |
|
68 assert.equal(a.x1(), 0); |
|
69 }, |
|
70 "x1 can be defined as a function": function(area) { |
|
71 var a = area().x1(f), t = {}, dd = [], ii = [], tt = []; |
|
72 function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return 0; } |
|
73 assert.pathEqual(a.call(t, [[1, 2], [4, 3]]), "M0,2L0,3L4,0L1,0Z"); |
|
74 assert.deepEqual(dd, [[1, 2], [4, 3]], "expected data, got {actual}"); |
|
75 assert.deepEqual(ii, [0, 1], "expected index, got {actual}"); |
|
76 assert.deepEqual(tt, [t, t], "expected this, got {actual}"); |
|
77 }, |
|
78 |
|
79 "y0 defaults to zero": function(area) { |
|
80 var a = area(); |
|
81 assert.pathEqual(a([[1, 2], [4, 3]]), "M1,2L4,3L4,0L1,0Z"); |
|
82 assert.equal(a.y0(), 0); |
|
83 }, |
|
84 "y0 can be defined as a constant": function(area) { |
|
85 var a = area().y0(1); |
|
86 assert.pathEqual(a([[1, 2], [4, 3]]), "M1,2L4,3L4,1L1,1Z"); |
|
87 assert.equal(a.y0(), 1); |
|
88 }, |
|
89 "y0 can be defined as a function": function(area) { |
|
90 var a = area().y0(f), t = {}, dd = [], ii = [], tt = []; |
|
91 function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return 1; } |
|
92 assert.pathEqual(a.call(t, [[1, 2], [4, 3]]), "M1,2L4,3L4,1L1,1Z"); |
|
93 assert.deepEqual(dd, [[1, 2], [4, 3]], "expected data, got {actual}"); |
|
94 assert.deepEqual(ii, [0, 1], "expected index, got {actual}"); |
|
95 assert.deepEqual(tt, [t, t], "expected this, got {actual}"); |
|
96 }, |
|
97 |
|
98 "y1 defaults to a function accessor": function(area) { |
|
99 var a = area(); |
|
100 assert.pathEqual(a([[1, 2], [4, 3]]), "M1,2L4,3L4,0L1,0Z"); |
|
101 assert.typeOf(a.y1(), "function"); |
|
102 }, |
|
103 "y1 can be defined as a constant": function(area) { |
|
104 var a = area().y1(1); |
|
105 assert.pathEqual(a([[1, 2], [4, 3]]), "M1,1L4,1L4,0L1,0Z"); |
|
106 assert.equal(a.y1(), 1); |
|
107 }, |
|
108 "y1 can be defined as a function": function(area) { |
|
109 var a = area().y1(f), t = {}, dd = [], ii = [], tt = []; |
|
110 function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return 1; } |
|
111 assert.pathEqual(a.call(t, [[1, 2], [4, 3]]), "M1,1L4,1L4,0L1,0Z"); |
|
112 assert.deepEqual(dd, [[1, 2], [4, 3]], "expected data, got {actual}"); |
|
113 assert.deepEqual(ii, [0, 1], "expected index, got {actual}"); |
|
114 assert.deepEqual(tt, [t, t], "expected this, got {actual}"); |
|
115 }, |
|
116 |
|
117 "if x0 === x1, x is only evaluated once per point": function(area) { |
|
118 var a = area().x(f), t = {}, dd = [], ii = [], tt = []; |
|
119 function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return 0; } |
|
120 assert.pathEqual(a.call(t, [[1, 2], [4, 3]]), "M0,2L0,3L0,0L0,0Z"); |
|
121 assert.deepEqual(dd, [[1, 2], [4, 3]], "expected data, got {actual}"); |
|
122 assert.deepEqual(ii, [0, 1], "expected index, got {actual}"); |
|
123 assert.deepEqual(tt, [t, t], "expected this, got {actual}"); |
|
124 }, |
|
125 "if y0 === y1, y is only evaluated once per point": function(area) { |
|
126 var a = area().y(f), t = {}, dd = [], ii = [], tt = []; |
|
127 function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return 1; } |
|
128 assert.pathEqual(a.call(t, [[1, 2], [4, 3]]), "M1,1L4,1L4,1L1,1Z"); |
|
129 assert.deepEqual(dd, [[1, 2], [4, 3]], "expected data, got {actual}"); |
|
130 assert.deepEqual(ii, [0, 1], "expected index, got {actual}"); |
|
131 assert.deepEqual(tt, [t, t], "expected this, got {actual}"); |
|
132 }, |
|
133 |
|
134 "interpolate defaults to linear": function(area) { |
|
135 assert.equal(area().interpolate(), "linear"); |
|
136 }, |
|
137 "interpolate can be defined as a constant": function(area) { |
|
138 var a = area().interpolate("step-before"); |
|
139 assert.pathEqual(a([[0, 0], [1, 1]]), "M0,0V1H1L1,0H0V0Z"); |
|
140 assert.equal(a.interpolate(), "step-before"); |
|
141 }, |
|
142 |
|
143 "tension defaults to .7": function(area) { |
|
144 assert.equal(area().tension(), .7); |
|
145 }, |
|
146 "tension can be specified as a constant": function(area) { |
|
147 var a = area().tension(.5); |
|
148 assert.equal(a.tension(), .5); |
|
149 }, |
|
150 |
|
151 "returns null if input points array is empty": function(area) { |
|
152 assert.isNull(area()([])); |
|
153 }, |
|
154 |
|
155 "interpolate(linear)": { |
|
156 "supports linear interpolation": testInterpolation("linear") |
|
157 }, |
|
158 |
|
159 "interpolate(step)": { |
|
160 "supports step-before interpolation": testInterpolation("step-before", "step-after"), |
|
161 "supports step-after interpolation": testInterpolation("step-after", "step-before") |
|
162 }, |
|
163 |
|
164 "interpolate(basis)": { |
|
165 "supports basis interpolation": testInterpolation("basis"), |
|
166 "supports basis-open interpolation": testInterpolation("basis-open") |
|
167 }, |
|
168 |
|
169 "interpolate(cardinal)": { |
|
170 "supports cardinal interpolation": testInterpolation("cardinal"), |
|
171 "supports cardinal-open interpolation": testInterpolation("cardinal-open") |
|
172 }, |
|
173 |
|
174 "interpolate(monotone)": { |
|
175 "supports monotone interpolation": testInterpolation("monotone") |
|
176 } |
|
177 } |
|
178 }); |
|
179 |
|
180 // An area is just two lines, with one reversed. |
|
181 function testInterpolation(i0, i1) { |
|
182 if (arguments.length < 2) i1 = i0; |
|
183 return function(area) { |
|
184 var a = area().interpolate(i0), |
|
185 d = [[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]], |
|
186 l0 = d3.svg.line().interpolate(i1).x(a.x0()).y(a.y0()), |
|
187 l1 = d3.svg.line().interpolate(i0).x(a.x1()).y(a.y1()); |
|
188 assert.pathEqual(a(d), l1(d) + "L" + l0(d.reverse()).substring(1) + "Z"); |
|
189 }; |
|
190 } |
|
191 |
|
192 suite.export(module); |