Debian Codegraph @

packages/widgets/tests/src/boxengine.spec.ts

raw
1 // Copyright (c) Jupyter Development Team.
2 // Distributed under the terms of the Modified BSD License.
3 /*-----------------------------------------------------------------------------
4 | Copyright (c) 2014-2017, PhosphorJS Contributors
5 |
6 | Distributed under the terms of the BSD 3-Clause License.
7 |
8 | The full license is in the file LICENSE, distributed with this software.
9 |----------------------------------------------------------------------------*/
10 import { expect } from 'chai';
11
12 import { BoxEngine, BoxSizer } from '@lumino/widgets';
13
14 function createSizers(n: number): BoxSizer[] {
15 let sizers: BoxSizer[] = [];
16 for (let i = 0; i < n; ++i) {
17 sizers.push(new BoxSizer());
18 }
19 return sizers;
20 }
21
22 describe('@lumino/widgets', () => {
23 describe('BoxSizer', () => {
24 describe('#constructor()', () => {
25 it('should accept no arguments', () => {
26 let sizer = new BoxSizer();
27 expect(sizer).to.be.an.instanceof(BoxSizer);
28 });
29 });
30
31 describe('#sizeHint', () => {
32 it('should default to `0`', () => {
33 let sizer = new BoxSizer();
34 expect(sizer.sizeHint).to.equal(0);
35 });
36
37 it('should be writable', () => {
38 let sizer = new BoxSizer();
39 sizer.sizeHint = 42;
40 expect(sizer.sizeHint).to.equal(42);
41 });
42 });
43
44 describe('#minSize', () => {
45 it('should default to `0`', () => {
46 let sizer = new BoxSizer();
47 expect(sizer.minSize).to.equal(0);
48 });
49
50 it('should be writable', () => {
51 let sizer = new BoxSizer();
52 sizer.minSize = 42;
53 expect(sizer.minSize).to.equal(42);
54 });
55 });
56
57 describe('#maxSize', () => {
58 it('should default to `Infinity`', () => {
59 let sizer = new BoxSizer();
60 expect(sizer.maxSize).to.equal(Infinity);
61 });
62
63 it('should be writable', () => {
64 let sizer = new BoxSizer();
65 sizer.maxSize = 42;
66 expect(sizer.maxSize).to.equal(42);
67 });
68 });
69
70 describe('#stretch', () => {
71 it('should default to `1`', () => {
72 let sizer = new BoxSizer();
73 expect(sizer.stretch).to.equal(1);
74 });
75
76 it('should be writable', () => {
77 let sizer = new BoxSizer();
78 sizer.stretch = 42;
79 expect(sizer.stretch).to.equal(42);
80 });
81 });
82
83 describe('#size', () => {
84 it('should be the computed output', () => {
85 let sizer = new BoxSizer();
86 expect(typeof sizer.size).to.equal('number');
87 });
88
89 it('should be writable', () => {
90 let sizer = new BoxSizer();
91 sizer.size = 42;
92 expect(sizer.size).to.equal(42);
93 });
94 });
95 });
96
97 describe('BoxEngine', () => {
98 describe('calc()', () => {
99 it('should handle an empty sizers array', () => {
100 expect(() => BoxEngine.calc([], 100)).to.not.throw(Error);
101 });
102
103 it('should obey the min sizes', () => {
104 let sizers = createSizers(4);
105 sizers[0].minSize = 10;
106 sizers[1].minSize = 20;
107 sizers[2].minSize = 30;
108 sizers[3].minSize = 40;
109 BoxEngine.calc(sizers, 0);
110 expect(sizers[0].size).to.equal(10);
111 expect(sizers[1].size).to.equal(20);
112 expect(sizers[2].size).to.equal(30);
113 expect(sizers[3].size).to.equal(40);
114 });
115
116 it('should obey the max sizes', () => {
117 let sizers = createSizers(4);
118 sizers[0].maxSize = 10;
119 sizers[1].maxSize = 20;
120 sizers[2].maxSize = 30;
121 sizers[3].maxSize = 40;
122 BoxEngine.calc(sizers, 500);
123 expect(sizers[0].size).to.equal(10);
124 expect(sizers[1].size).to.equal(20);
125 expect(sizers[2].size).to.equal(30);
126 expect(sizers[3].size).to.equal(40);
127 });
128
129 it('should handle negative layout space', () => {
130 let sizers = createSizers(4);
131 sizers[0].minSize = 10;
132 sizers[1].minSize = 20;
133 sizers[2].minSize = 30;
134 BoxEngine.calc(sizers, -500);
135 expect(sizers[0].size).to.equal(10);
136 expect(sizers[1].size).to.equal(20);
137 expect(sizers[2].size).to.equal(30);
138 expect(sizers[3].size).to.equal(0);
139 });
140
141 it('should handle infinite layout space', () => {
142 let sizers = createSizers(4);
143 sizers[0].maxSize = 10;
144 sizers[1].maxSize = 20;
145 sizers[2].maxSize = 30;
146 BoxEngine.calc(sizers, Infinity);
147 expect(sizers[0].size).to.equal(10);
148 expect(sizers[1].size).to.equal(20);
149 expect(sizers[2].size).to.equal(30);
150 expect(sizers[3].size).to.equal(Infinity);
151 });
152
153 it('should maintain the size hints if possible', () => {
154 let sizers = createSizers(4);
155 sizers[0].sizeHint = 40;
156 sizers[1].sizeHint = 50;
157 sizers[2].sizeHint = 60;
158 sizers[3].sizeHint = 70;
159 BoxEngine.calc(sizers, 220);
160 expect(sizers[0].size).to.equal(40);
161 expect(sizers[1].size).to.equal(50);
162 expect(sizers[2].size).to.equal(60);
163 expect(sizers[3].size).to.equal(70);
164 });
165
166 it('should fairly distribute negative space', () => {
167 let sizers = createSizers(4);
168 sizers[0].sizeHint = 40;
169 sizers[1].sizeHint = 50;
170 sizers[2].sizeHint = 60;
171 sizers[3].sizeHint = 70;
172 BoxEngine.calc(sizers, 200);
173 expect(sizers[0].size).to.equal(35);
174 expect(sizers[1].size).to.equal(45);
175 expect(sizers[2].size).to.equal(55);
176 expect(sizers[3].size).to.equal(65);
177 });
178
179 it('should fairly distribute positive space', () => {
180 let sizers = createSizers(4);
181 sizers[0].sizeHint = 40;
182 sizers[1].sizeHint = 50;
183 sizers[2].sizeHint = 60;
184 sizers[3].sizeHint = 70;
185 BoxEngine.calc(sizers, 240);
186 expect(sizers[0].size).to.equal(45);
187 expect(sizers[1].size).to.equal(55);
188 expect(sizers[2].size).to.equal(65);
189 expect(sizers[3].size).to.equal(75);
190 });
191
192 it('should be callable multiple times for the same sizers', () => {
193 let sizers = createSizers(4);
194 sizers[0].sizeHint = 40;
195 sizers[1].sizeHint = 50;
196 sizers[2].sizeHint = 60;
197 sizers[3].sizeHint = 70;
198 BoxEngine.calc(sizers, 240);
199 expect(sizers[0].size).to.equal(45);
200 expect(sizers[1].size).to.equal(55);
201 expect(sizers[2].size).to.equal(65);
202 expect(sizers[3].size).to.equal(75);
203 BoxEngine.calc(sizers, 280);
204 expect(sizers[0].size).to.equal(55);
205 expect(sizers[1].size).to.equal(65);
206 expect(sizers[2].size).to.equal(75);
207 expect(sizers[3].size).to.equal(85);
208 BoxEngine.calc(sizers, 200);
209 expect(sizers[0].size).to.equal(35);
210 expect(sizers[1].size).to.equal(45);
211 expect(sizers[2].size).to.equal(55);
212 expect(sizers[3].size).to.equal(65);
213 });
214
215 it('should distribute negative space according to stretch factors', () => {
216 let sizers = createSizers(2);
217 sizers[0].sizeHint = 60;
218 sizers[1].sizeHint = 60;
219 sizers[0].stretch = 2;
220 sizers[1].stretch = 4;
221 BoxEngine.calc(sizers, 120);
222 expect(sizers[0].size).to.equal(60);
223 expect(sizers[1].size).to.equal(60);
224 BoxEngine.calc(sizers, 60);
225 expect(sizers[0].size).to.equal(40);
226 expect(sizers[1].size).to.equal(20);
227 });
228
229 it('should distribute positive space according to stretch factors', () => {
230 let sizers = createSizers(2);
231 sizers[0].sizeHint = 60;
232 sizers[1].sizeHint = 60;
233 sizers[0].stretch = 2;
234 sizers[1].stretch = 4;
235 BoxEngine.calc(sizers, 120);
236 expect(sizers[0].size).to.equal(60);
237 expect(sizers[1].size).to.equal(60);
238 BoxEngine.calc(sizers, 240);
239 expect(sizers[0].size).to.equal(100);
240 expect(sizers[1].size).to.equal(140);
241 });
242
243 it('should not shrink non-stretchable sizers', () => {
244 let sizers = createSizers(4);
245 sizers[0].sizeHint = 20;
246 sizers[1].sizeHint = 40;
247 sizers[2].sizeHint = 60;
248 sizers[3].sizeHint = 80;
249 sizers[0].stretch = 0;
250 sizers[2].stretch = 0;
251 BoxEngine.calc(sizers, 160);
252 expect(sizers[0].size).to.equal(20);
253 expect(sizers[1].size).to.equal(20);
254 expect(sizers[2].size).to.equal(60);
255 expect(sizers[3].size).to.equal(60);
256 });
257
258 it('should not expand non-stretchable sizers', () => {
259 let sizers = createSizers(4);
260 sizers[0].sizeHint = 20;
261 sizers[1].sizeHint = 40;
262 sizers[2].sizeHint = 60;
263 sizers[3].sizeHint = 80;
264 sizers[0].stretch = 0;
265 sizers[2].stretch = 0;
266 BoxEngine.calc(sizers, 260);
267 expect(sizers[0].size).to.equal(20);
268 expect(sizers[1].size).to.equal(70);
269 expect(sizers[2].size).to.equal(60);
270 expect(sizers[3].size).to.equal(110);
271 });
272
273 it('should shrink non-stretchable sizers if required', () => {
274 let sizers = createSizers(4);
275 sizers[0].sizeHint = 20;
276 sizers[1].sizeHint = 40;
277 sizers[2].sizeHint = 60;
278 sizers[3].sizeHint = 80;
279 sizers[0].stretch = 0;
280 sizers[2].stretch = 0;
281 sizers[1].minSize = 20;
282 sizers[2].minSize = 55;
283 sizers[3].minSize = 60;
284 BoxEngine.calc(sizers, 140);
285 expect(sizers[0].size).to.equal(5);
286 expect(sizers[1].size).to.equal(20);
287 expect(sizers[2].size).to.equal(55);
288 expect(sizers[3].size).to.equal(60);
289 });
290
291 it('should expand non-stretchable sizers if required', () => {
292 let sizers = createSizers(4);
293 sizers[0].sizeHint = 20;
294 sizers[1].sizeHint = 40;
295 sizers[2].sizeHint = 60;
296 sizers[3].sizeHint = 80;
297 sizers[0].stretch = 0;
298 sizers[2].stretch = 0;
299 sizers[1].maxSize = 60;
300 sizers[2].maxSize = 70;
301 sizers[3].maxSize = 100;
302 BoxEngine.calc(sizers, 280);
303 expect(sizers[0].size).to.equal(50);
304 expect(sizers[1].size).to.equal(60);
305 expect(sizers[2].size).to.equal(70);
306 expect(sizers[3].size).to.equal(100);
307 });
308 });
309
310 describe('adjust()', () => {
311 it('should adjust a sizer by a positive delta', () => {
312 let sizers = createSizers(5);
313 sizers[0].sizeHint = 50;
314 sizers[1].sizeHint = 50;
315 sizers[2].sizeHint = 50;
316 sizers[3].sizeHint = 50;
317 sizers[4].sizeHint = 50;
318 sizers[2].maxSize = 60;
319 sizers[3].minSize = 40;
320 BoxEngine.calc(sizers, 250);
321 expect(sizers[0].size).to.equal(50);
322 expect(sizers[1].size).to.equal(50);
323 expect(sizers[2].size).to.equal(50);
324 expect(sizers[3].size).to.equal(50);
325 expect(sizers[3].size).to.equal(50);
326 BoxEngine.adjust(sizers, 2, 30);
327 expect(sizers[0].sizeHint).to.equal(50);
328 expect(sizers[1].sizeHint).to.equal(70);
329 expect(sizers[2].sizeHint).to.equal(60);
330 expect(sizers[3].sizeHint).to.equal(40);
331 expect(sizers[4].sizeHint).to.equal(30);
332 });
333
334 it('should adjust a sizer by a negative delta', () => {
335 let sizers = createSizers(5);
336 sizers[0].sizeHint = 50;
337 sizers[1].sizeHint = 50;
338 sizers[2].sizeHint = 50;
339 sizers[3].sizeHint = 50;
340 sizers[4].sizeHint = 50;
341 sizers[1].minSize = 40;
342 sizers[2].minSize = 40;
343 BoxEngine.calc(sizers, 250);
344 expect(sizers[0].size).to.equal(50);
345 expect(sizers[1].size).to.equal(50);
346 expect(sizers[2].size).to.equal(50);
347 expect(sizers[3].size).to.equal(50);
348 expect(sizers[3].size).to.equal(50);
349 BoxEngine.adjust(sizers, 2, -30);
350 expect(sizers[0].sizeHint).to.equal(40);
351 expect(sizers[1].sizeHint).to.equal(40);
352 expect(sizers[2].sizeHint).to.equal(40);
353 expect(sizers[3].sizeHint).to.equal(80);
354 expect(sizers[4].sizeHint).to.equal(50);
355 });
356 });
357 });
358 });