GCC Code Coverage Report
Directory: src/ Exec Total Coverage
File: src/unittests/gui/fonts/textchunklist.cc Lines: 352 352 100.0 %
Date: 2018-11-12 Branches: 995 2578 38.6 %

Line Branch Exec Source
1
/*
2
 *  The ManaPlus Client
3
 *  Copyright (C) 2013-2018  The ManaPlus Developers
4
 *
5
 *  This file is part of The ManaPlus Client.
6
 *
7
 *  This program is free software; you can redistribute it and/or modify
8
 *  it under the terms of the GNU General Public License as published by
9
 *  the Free Software Foundation; either version 2 of the License, or
10
 *  any later version.
11
 *
12
 *  This program is distributed in the hope that it will be useful,
13
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 *  GNU General Public License for more details.
16
 *
17
 *  You should have received a copy of the GNU General Public License
18
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
19
 */
20
21
#include "unittests/unittests.h"
22
23
#include "gui/fonts/font.h"
24
#include "gui/fonts/textchunk.h"
25
26
#include "debug.h"
27
28
3
TEST_CASE("TextChunkList empty", "TextChunkList")
29
{
30
2
    TextChunkList list;
31
32



4
    REQUIRE(0 == list.size);
33



4
    REQUIRE(nullptr == list.start);
34



4
    REQUIRE(nullptr == list.end);
35



4
    REQUIRE(list.search.empty());
36



4
    REQUIRE(list.searchWidth.empty());
37
1
}
38
39
3
TEST_CASE("TextChunkList add 1", "TextChunkList")
40
{
41
2
    TextChunkList list;
42
43
    TextChunk *const chunk = new TextChunk("test",
44

6
        Color(1, 2, 3, 255U), Color(2, 3, 4, 255U), nullptr);
45
46
1
    list.insertFirst(chunk);
47
48



4
    REQUIRE(1 == list.size);
49



4
    REQUIRE(chunk == list.start);
50



4
    REQUIRE(chunk == list.end);
51



4
    REQUIRE(nullptr == chunk->prev);
52



4
    REQUIRE(nullptr == chunk->next);
53
54



5
    REQUIRE(1 == list.search.size());
55




7
    REQUIRE(chunk == (*list.search.find(TextChunkSmall(
56
        chunk->text, chunk->color, chunk->color2))).second);
57
58



5
    REQUIRE(1 == list.searchWidth.size());
59



6
    REQUIRE(chunk == (*list.searchWidth.find(chunk->text)).second);
60
1
    delete chunk;
61
1
}
62
63
3
TEST_CASE("TextChunkList add 2", "TextChunkList")
64
{
65
2
    TextChunkList list;
66
67
    TextChunk *const chunk1 = new TextChunk("test",
68

6
        Color(1, 2, 3, 255U), Color(3, 4, 5, 255U), nullptr);
69
    TextChunk *const chunk2 = new TextChunk("test",
70

6
        Color(2, 3, 4, 255U), Color(4, 5, 6, 255U), nullptr);
71
72
1
    list.insertFirst(chunk2);
73
1
    list.insertFirst(chunk1);
74
75



4
    REQUIRE(2 == list.size);
76



4
    REQUIRE(chunk1 == list.start);
77



4
    REQUIRE(chunk2 == list.end);
78



4
    REQUIRE(nullptr == chunk1->prev);
79



4
    REQUIRE(chunk2 == chunk1->next);
80



4
    REQUIRE(chunk1 == chunk2->prev);
81



4
    REQUIRE(nullptr == chunk2->next);
82
83



5
    REQUIRE(2 == list.search.size());
84




7
    REQUIRE(chunk1 == (*list.search.find(TextChunkSmall(
85
        chunk1->text, chunk1->color, chunk1->color2))).second);
86




7
    REQUIRE(chunk2 == (*list.search.find(TextChunkSmall(
87
        chunk2->text, chunk2->color, chunk2->color2))).second);
88
89



5
    REQUIRE(1 == list.searchWidth.size());
90



6
    REQUIRE(chunk1 == (*list.searchWidth.find(chunk1->text)).second);
91
1
    delete chunk1;
92
1
    delete chunk2;
93
1
}
94
95
3
TEST_CASE("TextChunkList addRemoveBack 1", "TextChunkList")
96
{
97
2
    TextChunkList list;
98
99
    TextChunk *const chunk = new TextChunk("test",
100

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U), nullptr);
101
102
1
    list.insertFirst(chunk);
103
1
    list.removeBack();
104
105



4
    REQUIRE(0 == list.size);
106



4
    REQUIRE(nullptr == list.start);
107



4
    REQUIRE(nullptr == list.end);
108



4
    REQUIRE(list.search.empty());
109



4
    REQUIRE(list.searchWidth.empty());
110
1
}
111
112
3
TEST_CASE("TextChunkList addRemoveBack 2", "TextChunkList")
113
{
114
2
    TextChunkList list;
115
116
    TextChunk *const chunk1 = new TextChunk("test",
117

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U), nullptr);
118
    TextChunk *const chunk2 = new TextChunk("test2",
119

6
        Color(1, 2, 4, 255U), Color(1, 2, 5, 255U), nullptr);
120
121
1
    list.insertFirst(chunk2);
122
1
    list.insertFirst(chunk1);
123
1
    list.removeBack();
124
125



4
    REQUIRE(1 == list.size);
126



4
    REQUIRE(chunk1 == list.start);
127



4
    REQUIRE(chunk1 == list.end);
128



4
    REQUIRE(nullptr == chunk1->prev);
129



4
    REQUIRE(nullptr == chunk1->next);
130
131



5
    REQUIRE(1 == list.search.size());
132




7
    REQUIRE(chunk1 == (*list.search.find(TextChunkSmall(
133
        chunk1->text, chunk1->color, chunk1->color2))).second);
134
135



5
    REQUIRE(1 == list.searchWidth.size());
136



6
    REQUIRE(chunk1 == (*list.searchWidth.find(chunk1->text)).second);
137
1
    delete chunk1;
138
1
}
139
140
3
TEST_CASE("TextChunkList addRemoveBack 3", "TextChunkList")
141
{
142
2
    TextChunkList list;
143
144
    TextChunk *const chunk1 = new TextChunk("test",
145

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U), nullptr);
146
    TextChunk *const chunk2 = new TextChunk("test2",
147

6
        Color(2, 3, 4, 255U), Color(2, 3, 4, 255U), nullptr);
148
149
1
    list.insertFirst(chunk2);
150
1
    list.insertFirst(chunk1);
151
1
    list.removeBack(2);
152
153



4
    REQUIRE(0 == list.size);
154



4
    REQUIRE(nullptr == list.start);
155



4
    REQUIRE(nullptr == list.end);
156
157



4
    REQUIRE(list.search.empty());
158



4
    REQUIRE(list.searchWidth.empty());
159
1
}
160
161
3
TEST_CASE("TextChunkList addRemoveBack 4", "TextChunkList")
162
{
163
2
    TextChunkList list;
164
165
    TextChunk *const chunk1 = new TextChunk("test",
166

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U), nullptr);
167
    TextChunk *const chunk2 = new TextChunk("test2",
168

6
        Color(2, 3, 4, 255U), Color(2, 3, 4, 255U), nullptr);
169
    TextChunk *const chunk3 = new TextChunk("test",
170

6
        Color(3, 4, 5, 255U), Color(3, 4, 5, 255U), nullptr);
171
172
1
    list.insertFirst(chunk3);
173
1
    list.insertFirst(chunk2);
174
1
    list.insertFirst(chunk1);
175
1
    list.removeBack();
176
1
    list.removeBack();
177
178



4
    REQUIRE(1 == list.size);
179



4
    REQUIRE(chunk1 == list.start);
180



4
    REQUIRE(chunk1 == list.end);
181



4
    REQUIRE(nullptr == chunk1->prev);
182



4
    REQUIRE(nullptr == chunk1->next);
183
184



5
    REQUIRE(1 == list.search.size());
185




7
    REQUIRE(chunk1 == (*list.search.find(TextChunkSmall(
186
        chunk1->text, chunk1->color, chunk1->color2))).second);
187
188



4
    REQUIRE(list.searchWidth.empty());
189
1
    delete chunk1;
190
1
}
191
192
3
TEST_CASE("TextChunkList moveToFirst 1", "TextChunkList")
193
{
194
2
    TextChunkList list;
195
196
    TextChunk *const chunk = new TextChunk("test",
197

6
        Color(1, 2, 3, 255U), Color(2, 3, 4, 255U), nullptr);
198
199
1
    list.insertFirst(chunk);
200
1
    list.moveToFirst(chunk);
201
202



4
    REQUIRE(1 == list.size);
203



4
    REQUIRE(chunk == list.start);
204



4
    REQUIRE(chunk == list.end);
205



4
    REQUIRE(nullptr == chunk->prev);
206



4
    REQUIRE(nullptr == chunk->next);
207
1
    delete chunk;
208
1
}
209
210
3
TEST_CASE("TextChunkList moveToFirst 2", "TextChunkList")
211
{
212
2
    TextChunkList list;
213
214
    TextChunk *const chunk1 = new TextChunk("test",
215

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U), nullptr);
216
    TextChunk *const chunk2 = new TextChunk("test",
217

6
        Color(2, 3, 4, 255U), Color(1, 2, 3, 255U), nullptr);
218
219
1
    list.insertFirst(chunk1);
220
1
    list.insertFirst(chunk2);
221
1
    list.moveToFirst(chunk1);
222
223



4
    REQUIRE(2 == list.size);
224



4
    REQUIRE(chunk1 == list.start);
225



4
    REQUIRE(chunk2 == list.end);
226



4
    REQUIRE(nullptr == chunk1->prev);
227



4
    REQUIRE(chunk2 == chunk1->next);
228



4
    REQUIRE(chunk1 == chunk2->prev);
229



4
    REQUIRE(nullptr == chunk2->next);
230
1
    delete chunk1;
231
1
    delete chunk2;
232
1
}
233
234
3
TEST_CASE("TextChunkList moveToFirst 3", "TextChunkList")
235
{
236
2
    TextChunkList list;
237
238
    TextChunk *const chunk1 = new TextChunk("test",
239

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U), nullptr);
240
    TextChunk *const chunk2 = new TextChunk("test",
241

6
        Color(1, 2, 4, 255U), Color(1, 2, 3, 255U), nullptr);
242
    TextChunk *const chunk3 = new TextChunk("test",
243

6
        Color(1, 2, 5, 255U), Color(1, 2, 3, 255U), nullptr);
244
245
1
    list.insertFirst(chunk3);
246
1
    list.insertFirst(chunk1);
247
1
    list.insertFirst(chunk2);
248
1
    list.moveToFirst(chunk1);
249
250



4
    REQUIRE(3 == list.size);
251



4
    REQUIRE(chunk1 == list.start);
252



4
    REQUIRE(chunk3 == list.end);
253



4
    REQUIRE(nullptr == chunk1->prev);
254



4
    REQUIRE(chunk2 == chunk1->next);
255



4
    REQUIRE(chunk1 == chunk2->prev);
256



4
    REQUIRE(chunk3 == chunk2->next);
257



4
    REQUIRE(chunk2 == chunk3->prev);
258



4
    REQUIRE(nullptr == chunk3->next);
259
1
    delete chunk1;
260
1
    delete chunk2;
261
1
    delete chunk3;
262
1
}
263
264
3
TEST_CASE("TextChunkList moveToFirst 4", "TextChunkList")
265
{
266
2
    TextChunkList list;
267
268
    TextChunk *const chunk1 = new TextChunk("test",
269

6
        Color(), Color(), nullptr);
270
    TextChunk *const chunk2 = new TextChunk("test2",
271

6
        Color(), Color(), nullptr);
272
    TextChunk *const chunk3 = new TextChunk("test3",
273

6
        Color(), Color(), nullptr);
274
275
1
    list.insertFirst(chunk1);
276
1
    list.insertFirst(chunk3);
277
1
    list.insertFirst(chunk2);
278
1
    list.moveToFirst(chunk1);
279
280



4
    REQUIRE(3 == list.size);
281



4
    REQUIRE(chunk1 == list.start);
282



4
    REQUIRE(chunk3 == list.end);
283



4
    REQUIRE(nullptr == chunk1->prev);
284



4
    REQUIRE(chunk2 == chunk1->next);
285



4
    REQUIRE(chunk1 == chunk2->prev);
286



4
    REQUIRE(chunk3 == chunk2->next);
287



4
    REQUIRE(chunk2 == chunk3->prev);
288



4
    REQUIRE(nullptr == chunk3->next);
289
1
    delete chunk1;
290
1
    delete chunk2;
291
1
    delete chunk3;
292
1
}
293
294
3
TEST_CASE("TextChunkList clear 1", "TextChunkList")
295
{
296
2
    TextChunkList list;
297
1
    const int chunksLeft = textChunkCnt;
298
299
    TextChunk *const chunk = new TextChunk("test",
300

6
        Color(), Color(), nullptr);
301
302
1
    list.insertFirst(chunk);
303
1
    list.clear();
304
305



4
    REQUIRE(0 == list.size);
306



4
    REQUIRE(nullptr == list.start);
307



4
    REQUIRE(nullptr == list.end);
308



4
    REQUIRE(chunksLeft == textChunkCnt);
309



4
    REQUIRE(list.search.empty());
310



4
    REQUIRE(list.searchWidth.empty());
311
1
}
312
313
3
TEST_CASE("TextChunkList clear 2", "TextChunkList")
314
{
315
2
    TextChunkList list;
316
1
    const int chunksLeft = textChunkCnt;
317
318
    TextChunk *const chunk1 = new TextChunk("test",
319

6
        Color(1, 2, 3, 255U), Color(2, 0, 0, 255U), nullptr);
320
    TextChunk *const chunk2 = new TextChunk("test",
321

6
        Color(1, 2, 3, 255U), Color(2, 0, 1, 255U), nullptr);
322
    TextChunk *const chunk3 = new TextChunk("test",
323

6
        Color(1, 2, 3, 255U), Color(2, 0, 2, 255U), nullptr);
324
325
1
    list.insertFirst(chunk1);
326
1
    list.insertFirst(chunk2);
327
1
    list.insertFirst(chunk3);
328
1
    list.clear();
329
330



4
    REQUIRE(0 == list.size);
331



4
    REQUIRE(nullptr == list.start);
332



4
    REQUIRE(nullptr == list.end);
333



4
    REQUIRE(chunksLeft == textChunkCnt);
334



4
    REQUIRE(list.search.empty());
335



4
    REQUIRE(list.searchWidth.empty());
336
1
}
337
338
3
TEST_CASE("TextChunkList clear 3", "TextChunkList")
339
{
340
2
    TextChunkList list;
341
1
    const int chunksLeft = textChunkCnt;
342
343
    TextChunk *const chunk1 = new TextChunk("test",
344

6
        Color(1, 2, 3, 255U), Color(2, 0, 0, 255U), nullptr);
345
    TextChunk *const chunk2 = new TextChunk("test",
346

6
        Color(1, 2, 3, 255U), Color(2, 0, 1, 255U), nullptr);
347
    TextChunk *const chunk3 = new TextChunk("test",
348

6
        Color(1, 2, 3, 255U), Color(2, 0, 2, 255U), nullptr);
349
350
1
    list.insertFirst(chunk1);
351
1
    list.insertFirst(chunk2);
352
1
    list.insertFirst(chunk3);
353
1
    list.moveToFirst(chunk1);
354



4
    REQUIRE((chunksLeft + 3) == textChunkCnt);
355



5
    REQUIRE(3 == list.search.size());
356



5
    REQUIRE(1 == list.searchWidth.size());
357
358
1
    list.removeBack();
359



4
    REQUIRE((chunksLeft + 2) == textChunkCnt);
360



5
    REQUIRE(2 == list.search.size());
361



4
    REQUIRE(list.searchWidth.empty());
362
363
1
    list.clear();
364



4
    REQUIRE(chunksLeft == textChunkCnt);
365



4
    REQUIRE(list.search.empty());
366



4
    REQUIRE(list.searchWidth.empty());
367
1
}
368
369
3
TEST_CASE("TextChunkList clear 4", "TextChunkList")
370
{
371
2
    TextChunkList list;
372
1
    const int chunksLeft = textChunkCnt;
373
374
    TextChunk *const chunk1 = new TextChunk("test",
375

6
        Color(1, 2, 3, 255U), Color(2, 0, 0, 255U), nullptr);
376
    TextChunk *const chunk2 = new TextChunk("test",
377

6
        Color(1, 2, 3, 255U), Color(2, 0, 1, 255U), nullptr);
378
    TextChunk *const chunk3 = new TextChunk("test3",
379

6
        Color(1, 2, 3, 255U), Color(2, 0, 2, 255U), nullptr);
380
381
1
    list.insertFirst(chunk1);
382
1
    list.insertFirst(chunk2);
383
1
    list.insertFirst(chunk3);
384
1
    list.moveToFirst(chunk2);
385



4
    REQUIRE((chunksLeft + 3) == textChunkCnt);
386



5
    REQUIRE(3 == list.search.size());
387



5
    REQUIRE(2 == list.searchWidth.size());
388
389
1
    list.removeBack(2);
390



4
    REQUIRE((chunksLeft + 1) == textChunkCnt);
391



5
    REQUIRE(1 == list.search.size());
392



4
    REQUIRE(list.searchWidth.empty());
393
394
1
    list.clear();
395



4
    REQUIRE(chunksLeft == textChunkCnt);
396



4
    REQUIRE(list.search.empty());
397



4
    REQUIRE(list.searchWidth.empty());
398
1
}
399
400
3
TEST_CASE("TextChunkList remove 1", "TextChunkList")
401
{
402
2
    TextChunkList list;
403
1
    const int chunksLeft = textChunkCnt;
404
405
    TextChunk *const chunk = new TextChunk("test",
406

6
        Color(), Color(), nullptr);
407
408
1
    list.insertFirst(chunk);
409
1
    list.remove(chunk);
410
1
    delete chunk;
411
412



4
    REQUIRE(0 == list.size);
413



4
    REQUIRE(nullptr == list.start);
414



4
    REQUIRE(nullptr == list.end);
415



4
    REQUIRE(chunksLeft == textChunkCnt);
416



4
    REQUIRE(list.search.empty());
417



4
    REQUIRE(list.searchWidth.empty());
418
1
}
419
420
3
TEST_CASE("TextChunkList remove 2", "TextChunkList")
421
{
422
2
    TextChunkList list;
423
1
    const int chunksLeft = textChunkCnt;
424
425
    TextChunk *const chunk1 = new TextChunk("test1",
426

6
        Color(1, 2, 3, 255U), Color(2, 0, 0, 255U), nullptr);
427
    TextChunk *const chunk2 = new TextChunk("test2",
428

6
        Color(1, 2, 3, 255U), Color(2, 0, 1, 255U), nullptr);
429
    TextChunk *const chunk3 = new TextChunk("test3",
430

6
        Color(1, 2, 3, 255U), Color(2, 0, 2, 255U), nullptr);
431
432
1
    list.insertFirst(chunk1);
433
1
    list.insertFirst(chunk2);
434
1
    list.insertFirst(chunk3);
435
1
    list.remove(chunk1);
436
1
    delete chunk1;
437
438



4
    REQUIRE(2 == list.size);
439



4
    REQUIRE(chunk3 == list.start);
440



4
    REQUIRE(chunk2 == list.end);
441



4
    REQUIRE((chunksLeft + 2) == textChunkCnt);
442



5
    REQUIRE(2 == list.search.size());
443



5
    REQUIRE(2 == list.searchWidth.size());
444
1
    delete chunk2;
445
1
    delete chunk3;
446
1
}
447
448
3
TEST_CASE("TextChunkList remove 3", "TextChunkList")
449
{
450
2
    TextChunkList list;
451
1
    const int chunksLeft = textChunkCnt;
452
453
    TextChunk *const chunk1 = new TextChunk("test1",
454

6
        Color(1, 2, 3, 255U), Color(2, 0, 0, 255U), nullptr);
455
    TextChunk *const chunk2 = new TextChunk("test2",
456

6
        Color(1, 2, 3, 255U), Color(2, 0, 1, 255U), nullptr);
457
    TextChunk *const chunk3 = new TextChunk("test3",
458

6
        Color(1, 2, 3, 255U), Color(2, 0, 2, 255U), nullptr);
459
460
1
    list.insertFirst(chunk1);
461
1
    list.insertFirst(chunk2);
462
1
    list.insertFirst(chunk3);
463
1
    list.remove(chunk2);
464
1
    delete chunk2;
465
466



4
    REQUIRE(2 == list.size);
467



4
    REQUIRE(chunk3 == list.start);
468



4
    REQUIRE(chunk1 == list.end);
469



4
    REQUIRE((chunksLeft + 2) == textChunkCnt);
470



5
    REQUIRE(2 == list.search.size());
471



5
    REQUIRE(2 == list.searchWidth.size());
472
1
    delete chunk1;
473
1
    delete chunk3;
474
1
}
475
476
3
TEST_CASE("TextChunkList sort 1", "TextChunkList")
477
{
478
    TextChunkSmall item1("test line1",
479

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U));
480
    TextChunkSmall item2("test line1",
481

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U));
482
    TextChunkSmall item3("test line2",
483

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U));
484




4
    REQUIRE(false == (item1 < item2));
485




4
    REQUIRE(false == (item2 < item1));
486



4
    REQUIRE(item1 < item3);
487




4
    REQUIRE(false == (item3 < item1));
488
1
}
489
490
3
TEST_CASE("TextChunkList sort 2", "TextChunkList")
491
{
492
    TextChunkSmall item1("test line1",
493

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U));
494
    TextChunkSmall item2("test line1",
495

6
        Color(2, 3, 4, 255U), Color(1, 2, 3, 255U));
496



4
    REQUIRE(item1 < item2);
497




4
    REQUIRE(false == (item2 < item1));
498
1
}
499
500
3
TEST_CASE("TextChunkList sort 3", "TextChunkList")
501
{
502
    TextChunkSmall item1("test line1",
503

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U));
504
    TextChunkSmall item2("test line1",
505

6
        Color(1, 3, 4, 255U), Color(1, 2, 3, 255U));
506



4
    REQUIRE(item1 < item2);
507




4
    REQUIRE(false == (item2 < item1));
508
1
}
509
510
3
TEST_CASE("TextChunkList sort 4", "TextChunkList")
511
{
512
    TextChunkSmall item1("test line1",
513

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U));
514
    TextChunkSmall item2("test line1",
515

6
        Color(1, 2, 4, 255U), Color(1, 2, 3, 255U));
516



4
    REQUIRE(item1 < item2);
517




4
    REQUIRE(false == (item2 < item1));
518
1
}
519
520
3
TEST_CASE("TextChunkList sort 5", "TextChunkList")
521
{
522
    TextChunkSmall item1("test line1",
523

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U));
524
    TextChunkSmall item2("test line1",
525

6
        Color(1, 2, 3, 255U), Color(2, 2, 3, 255U));
526



4
    REQUIRE(item1 < item2);
527




4
    REQUIRE(false == (item2 < item1));
528
1
}
529
530
3
TEST_CASE("TextChunkList sort 6", "TextChunkList")
531
{
532
    TextChunkSmall item1("test line1",
533

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U));
534
    TextChunkSmall item2("test line1",
535

6
        Color(1, 2, 3, 255U), Color(1, 3, 3, 255U));
536



4
    REQUIRE(item1 < item2);
537




4
    REQUIRE(false == (item2 < item1));
538
1
}
539
540
3
TEST_CASE("TextChunkList sort 7", "TextChunkList")
541
{
542
    TextChunkSmall item1("test line1",
543

6
        Color(1, 2, 3, 255U), Color(1, 2, 3, 255U));
544
    TextChunkSmall item2("test line1",
545

6
        Color(1, 2, 3, 255U), Color(1, 2, 4, 255U));
546



4
    REQUIRE(item1 < item2);
547




4
    REQUIRE(false == (item2 < item1));
548

4
}