|
1 require("../env"); |
|
2 require("../../d3"); |
|
3 require("../../d3.layout"); |
|
4 |
|
5 var vows = require("vows"), |
|
6 assert = require("assert"); |
|
7 |
|
8 var suite = vows.describe("d3.layout.treemap"); |
|
9 |
|
10 suite.addBatch({ |
|
11 "treemap": { |
|
12 topic: function() { |
|
13 return d3.layout.treemap; |
|
14 }, |
|
15 "outputs a squarified treemap": function(treemap) { |
|
16 var t = treemap().size([1000, 1000]).sort(null); |
|
17 assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [ |
|
18 {x: 0, y: 0, dx: 1000, dy: 1000}, |
|
19 {x: 0, y: 833, dx: 1000, dy: 167}, |
|
20 {x: 600, y: 0, dx: 400, dy: 833}, |
|
21 {x: 0, y: 0, dx: 600, dy: 833}, |
|
22 {x: 0, y: 555, dx: 600, dy: 278}, |
|
23 {x: 0, y: 0, dx: 600, dy: 555} |
|
24 ]); |
|
25 }, |
|
26 "sorts by value by default": function(treemap) { |
|
27 var t = treemap().size([1000, 1000]); |
|
28 assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [ |
|
29 {x: 0, y: 0, dx: 1000, dy: 1000}, |
|
30 {x: 0, y: 0, dx: 333, dy: 500}, |
|
31 {x: 333, y: 0, dx: 667, dy: 500}, |
|
32 {x: 0, y: 500, dx: 1000, dy: 500}, |
|
33 {x: 0, y: 500, dx: 333, dy: 500}, |
|
34 {x: 333, y: 500, dx: 667, dy: 500} |
|
35 ]); |
|
36 }, |
|
37 "ignores zero values": function(treemap) { |
|
38 var t = treemap().size([1000, 1000]).sort(null); |
|
39 assert.deepEqual(t.nodes({children: [{value: 1}, {value: 0}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [ |
|
40 {x: 0, y: 0, dx: 1000, dy: 1000}, |
|
41 {x: 0, y: 833, dx: 1000, dy: 167}, |
|
42 {x: 1000, y: 0, dx: 0, dy: 833}, |
|
43 {x: 600, y: 0, dx: 400, dy: 833}, |
|
44 {x: 0, y: 0, dx: 600, dy: 833}, |
|
45 {x: 0, y: 555, dx: 600, dy: 278}, |
|
46 {x: 0, y: 0, dx: 600, dy: 555} |
|
47 ]); |
|
48 }, |
|
49 "ignores NaN values": function(treemap) { |
|
50 var t = treemap().size([1000, 1000]).sort(null); |
|
51 assert.deepEqual(t.nodes({children: [{value: 1}, {value: NaN}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [ |
|
52 {x: 0, y: 0, dx: 1000, dy: 1000}, |
|
53 {x: 0, y: 833, dx: 1000, dy: 167}, |
|
54 {x: 1000, y: 0, dx: 0, dy: 833}, |
|
55 {x: 600, y: 0, dx: 400, dy: 833}, |
|
56 {x: 0, y: 0, dx: 600, dy: 833}, |
|
57 {x: 0, y: 555, dx: 600, dy: 278}, |
|
58 {x: 0, y: 0, dx: 600, dy: 555} |
|
59 ]); |
|
60 }, |
|
61 "does not overflow empty size": function(treemap) { |
|
62 var t = treemap().size([0, 0]).sort(null); |
|
63 assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [ |
|
64 {x: 0, y: 0, dx: 0, dy: 0}, |
|
65 {x: 0, y: 0, dx: 0, dy: 0}, |
|
66 {x: 0, y: 0, dx: 0, dy: 0}, |
|
67 {x: 0, y: 0, dx: 0, dy: 0}, |
|
68 {x: 0, y: 0, dx: 0, dy: 0}, |
|
69 {x: 0, y: 0, dx: 0, dy: 0} |
|
70 ]); |
|
71 }, |
|
72 "can specify padding as a number": function(treemap) { |
|
73 var t = treemap().size([1000, 1000]).sort(null).padding(1); |
|
74 assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [ |
|
75 {x: 0, y: 0, dx: 1000, dy: 1000}, |
|
76 {x: 1, y: 833, dx: 998, dy: 166}, |
|
77 {x: 600, y: 1, dx: 399, dy: 832}, |
|
78 {x: 1, y: 1, dx: 599, dy: 832}, |
|
79 {x: 2, y: 555, dx: 597, dy: 277}, |
|
80 {x: 2, y: 2, dx: 597, dy: 553} |
|
81 ]); |
|
82 }, |
|
83 "can specify padding as an array": function(treemap) { |
|
84 var t = treemap().size([1000, 1000]).sort(null).padding([1,2,3,4]); |
|
85 assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [ |
|
86 {x: 0, y: 0, dx: 1000, dy: 1000}, |
|
87 {x: 4, y: 831, dx: 994, dy: 166}, |
|
88 {x: 600, y: 1, dx: 398, dy: 830}, |
|
89 {x: 4, y: 1, dx: 596, dy: 830}, |
|
90 {x: 8, y: 553, dx: 590, dy: 275}, |
|
91 {x: 8, y: 2, dx: 590, dy: 551} |
|
92 ]); |
|
93 }, |
|
94 "can specify padding as null": function(treemap) { |
|
95 var t = treemap().size([1000, 1000]).sort(null).padding(null); |
|
96 assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [ |
|
97 {x: 0, y: 0, dx: 1000, dy: 1000}, |
|
98 {x: 0, y: 833, dx: 1000, dy: 167}, |
|
99 {x: 600, y: 0, dx: 400, dy: 833}, |
|
100 {x: 0, y: 0, dx: 600, dy: 833}, |
|
101 {x: 0, y: 555, dx: 600, dy: 278}, |
|
102 {x: 0, y: 0, dx: 600, dy: 555} |
|
103 ]); |
|
104 }, |
|
105 "can specify padding as a function that returns a number": function(treemap) { |
|
106 var t = treemap().size([1000, 1000]).sort(null).padding(function(d) { return d.depth; }); |
|
107 assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [ |
|
108 {x: 0, y: 0, dx: 1000, dy: 1000}, |
|
109 {x: 0, y: 833, dx: 1000, dy: 167}, |
|
110 {x: 600, y: 0, dx: 400, dy: 833}, |
|
111 {x: 0, y: 0, dx: 600, dy: 833}, |
|
112 {x: 1, y: 555, dx: 598, dy: 277}, |
|
113 {x: 1, y: 1, dx: 598, dy: 554} |
|
114 ]); |
|
115 }, |
|
116 "can specify padding as a function that returns an array": function(treemap) { |
|
117 var t = treemap().size([1000, 1000]).sort(null).padding(function(d) { return [d.depth,2,3,4]; }); |
|
118 assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [ |
|
119 {x: 0, y: 0, dx: 1000, dy: 1000}, |
|
120 {x: 4, y: 831, dx: 994, dy: 166}, |
|
121 {x: 600, y: 0, dx: 398, dy: 831}, |
|
122 {x: 4, y: 0, dx: 596, dy: 831}, |
|
123 {x: 8, y: 552, dx: 590, dy: 276}, |
|
124 {x: 8, y: 1, dx: 590, dy: 551} |
|
125 ]); |
|
126 }, |
|
127 "can specify padding as a function that returns null": function(treemap) { |
|
128 var t = treemap().size([1000, 1000]).sort(null).padding(function(d) { return d.depth & 1 ? null : 1; }); |
|
129 assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [ |
|
130 {x: 0, y: 0, dx: 1000, dy: 1000}, |
|
131 {x: 1, y: 833, dx: 998, dy: 166}, |
|
132 {x: 600, y: 1, dx: 399, dy: 832}, |
|
133 {x: 1, y: 1, dx: 599, dy: 832}, |
|
134 {x: 1, y: 556, dx: 599, dy: 277}, |
|
135 {x: 1, y: 1, dx: 599, dy: 555} |
|
136 ]); |
|
137 }, |
|
138 "no negatively sized rectangles": function(treemap) { |
|
139 var t = treemap().size([615, 500]).sort(function(a, b) { return a.value - b.value; }).padding(29), |
|
140 nodes = t.nodes({"children": [ |
|
141 {"value": 1}, |
|
142 {"value": 9}, |
|
143 {"value": 3}, |
|
144 {"value": 15}, |
|
145 {"value": 44}, |
|
146 {"value": 28}, |
|
147 {"value": 32}, |
|
148 {"value": 41}, |
|
149 {"value": 50}, |
|
150 {"value": 60}, |
|
151 {"value": 64}, |
|
152 {"value": 75}, |
|
153 {"value": 76}, |
|
154 {"value": 84}, |
|
155 {"value": 88}, |
|
156 {"value": 100}, |
|
157 {"value": 140}, |
|
158 {"value": 142}, |
|
159 {"value": 363}, |
|
160 {"value": 657}, |
|
161 {"value": 670}, |
|
162 {"value": 822}, |
|
163 {"value": 1173}, |
|
164 {"value": 1189} |
|
165 ]}).map(layout); |
|
166 assert.equal(nodes.filter(function(n) { return n.dx < 0 || n.dy < 0; }).length, 0); |
|
167 }, |
|
168 "can handle an empty children array": function(treemap) { |
|
169 assert.deepEqual(treemap().nodes({children: []}).map(layout), [ |
|
170 {x: 0, y: 0, dx: 1, dy: 1} |
|
171 ]); |
|
172 assert.deepEqual(treemap().nodes({children: [{children: []}, {value: 1}]}).map(layout), [ |
|
173 {x: 0, y: 0, dx: 1, dy: 1}, |
|
174 {x: 0, y: 0, dx: 0, dy: 1}, |
|
175 {x: 0, y: 0, dx: 1, dy: 1} |
|
176 ]); |
|
177 } |
|
178 } |
|
179 }); |
|
180 |
|
181 function layout(node) { |
|
182 return { |
|
183 x: node.x, |
|
184 y: node.y, |
|
185 dx: node.dx, |
|
186 dy: node.dy |
|
187 }; |
|
188 } |
|
189 |
|
190 suite.export(module); |