tabled 0.20.0

An easy to use library for pretty print tables of Rust `struct`s and `enum`s.
Documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
#![cfg(all(feature = "std", feature = "assert"))]

use tabled::{
    assert::test_table,
    grid::dimension::{DimensionPriority, PoolTableDimension},
    settings::{formatting::AlignmentStrategy, Alignment, Margin, Padding, Style},
    tables::{PoolTable, TableValue},
};

use crate::util::Matrix;

#[cfg(feature = "ansi")]
use tabled::{grid::ansi::ANSIStr, settings::PaddingColor};

test_table!(
    pool_table,
    PoolTable::new(Matrix::with_no_frame(3, 3).to_vec()),
    "+-----+-----+-----+"
    "| 0-0 | 0-1 | 0-2 |"
    "+-----+-----+-----+"
    "| 1-0 | 1-1 | 1-2 |"
    "+-----+-----+-----+"
    "| 2-0 | 2-1 | 2-2 |"
    "+-----+-----+-----+"
);

test_table!(
    pool_table_1,
    PoolTable::new([vec!["111111", "222"], vec!["111", "2233", "1", "2", "3"]]),
    "+-------------+----------+"
    "| 111111      | 222      |"
    "+-----+------++--+---+---+"
    "| 111 | 2233 | 1 | 2 | 3 |"
    "+-----+------+---+---+---+"
);

test_table!(
    pool_table_2,
    PoolTable::new([vec!["111", "2233", "1", "2", "3"], vec!["111111", "222"]]),
    "+-----+------+---+---+---+"
    "| 111 | 2233 | 1 | 2 | 3 |"
    "+-----+------++--+---+---+"
    "| 111111      | 222      |"
    "+-------------+----------+"
);

test_table!(
    pool_table_3,
    PoolTable::new([vec!["1\n11", "2\n2\n3\n3", "1", "\n2\n", "3"], vec!["11\n111\n1", "2\n2\n2"]]),
    "+----+---+---+---+---+"
    "| 1  | 2 | 1 |   | 3 |"
    "| 11 | 2 |   | 2 |   |"
    "|    | 3 |   |   |   |"
    "|    | 3 |   |   |   |"
    "+----+---+--++---+---+"
    "| 11        | 2      |"
    "| 111       | 2      |"
    "| 1         | 2      |"
    "+-----------+--------+"
);

test_table!(
    pool_table_4,
    PoolTable::new([vec!["11\n111\n1", "2\n2\n2"], vec!["1\n11", "2\n2\n3\n3", "1", "\n2\n", "3"]]),
    "+-----------+--------+"
    "| 11        | 2      |"
    "| 111       | 2      |"
    "| 1         | 2      |"
    "+----+---+--++---+---+"
    "| 1  | 2 | 1 |   | 3 |"
    "| 11 | 2 |   | 2 |   |"
    "|    | 3 |   |   |   |"
    "|    | 3 |   |   |   |"
    "+----+---+---+---+---+"
);

test_table!(
    pool_table_multiline,
    PoolTable::new([
        ["1", "2\n2", "3\n3\n3"],
        ["3\n3\n3", "2\n2", "1"],
        ["1", "3\n3\n3", "2\n2"]
    ]),
    "+---+---+---+"
    "| 1 | 2 | 3 |"
    "|   | 2 | 3 |"
    "|   |   | 3 |"
    "+---+---+---+"
    "| 3 | 2 | 1 |"
    "| 3 | 2 |   |"
    "| 3 |   |   |"
    "+---+---+---+"
    "| 1 | 3 | 2 |"
    "|   | 3 | 2 |"
    "|   | 3 |   |"
    "+---+---+---+"
);

test_table!(
    pool_table_value,
    PoolTable::from(TableValue::Row(vec![
        TableValue::Column(vec![TableValue::Cell(String::from("0-0")), TableValue::Cell(String::from("0-1")), TableValue::Cell(String::from("0-2"))]),
        TableValue::Column(vec![TableValue::Cell(String::from("1-0")), TableValue::Cell(String::from("1-1")), TableValue::Cell(String::from("1-2"))]),
        TableValue::Column(vec![TableValue::Cell(String::from("2-0")), TableValue::Cell(String::from("2-1")), TableValue::Cell(String::from("2-2"))]),
    ]))
    .with(Style::modern()),
    "┌─────┬─────┬─────┐"
    "│ 0-0 │ 1-0 │ 2-0 │"
    "├─────┼─────┼─────┤"
    "│ 0-1 │ 1-1 │ 2-1 │"
    "├─────┼─────┼─────┤"
    "│ 0-2 │ 1-2 │ 2-2 │"
    "└─────┴─────┴─────┘"
);

test_table!(
    pool_table_value_1,
    PoolTable::from(TableValue::Row(vec![
        TableValue::Column(vec![TableValue::Cell(String::from("0-0")), TableValue::Cell(String::from("0-1")), TableValue::Cell(String::from("0-2"))]),
        TableValue::Column(vec![TableValue::Cell(String::from("1-0")), TableValue::Cell(String::from("1-1")), TableValue::Cell(String::from("1-2"))]),
        TableValue::Column(vec![
            TableValue::Column(vec![TableValue::Cell(String::from("2-01")), TableValue::Cell(String::from("2-02")), TableValue::Cell(String::from("2-03"))]),
            TableValue::Cell(String::from("2-1")),
            TableValue::Cell(String::from("2-2")),
        ]),
    ]))
    .with(Style::modern()),
    "┌─────┬─────┬──────┐"
    "│ 0-0 │ 1-0 │ 2-01 │"
    "│     │     ├──────┤"
    "│     │     │ 2-02 │"
    "├─────┼─────┼──────┤"
    "│ 0-1 │ 1-1 │ 2-03 │"
    "│     │     ├──────┤"
    "├─────┼─────┤ 2-1  │"
    "│ 0-2 │ 1-2 ├──────┤"
    "│     │     │ 2-2  │"
    "└─────┴─────┴──────┘"
);

test_table!(
    pool_table_value_2,
    PoolTable::from(TableValue::Row(vec![
        TableValue::Column(vec![TableValue::Cell(String::from("0-0")), TableValue::Cell(String::from("0-1")), TableValue::Cell(String::from("0-2"))]),
        TableValue::Column(vec![
            TableValue::Row(vec![TableValue::Cell(String::from("2-01")), TableValue::Cell(String::from("2-02")), TableValue::Cell(String::from("2-03"))]),
            TableValue::Column(vec![TableValue::Cell(String::from("2-01")), TableValue::Cell(String::from("2-02")), TableValue::Cell(String::from("2-03"))]),
            TableValue::Cell(String::from("1-1")),
            TableValue::Cell(String::from("1-2"))
        ]),
        TableValue::Column(vec![
            TableValue::Column(vec![TableValue::Cell(String::from("2-01")), TableValue::Cell(String::from("2-02")), TableValue::Cell(String::from("2-03"))]),
            TableValue::Cell(String::from("2-1")),
            TableValue::Cell(String::from("2-2"))
        ]),
    ]))
    .with(Style::modern()),
    "┌─────┬──────┬──────┬──────┬──────┐"
    "│ 0-0 │ 2-01 │ 2-02 │ 2-03 │ 2-01 │"
    "│     ├──────┴──────┴──────┤      │"
    "│     │ 2-01               ├──────┤"
    "├─────┼────────────────────┤ 2-02 │"
    "│ 0-1 │ 2-02               ├──────┤"
    "│     ├────────────────────┤ 2-03 │"
    "│     │ 2-03               ├──────┤"
    "├─────┼────────────────────┤ 2-1  │"
    "│ 0-2 │ 1-1                │      │"
    "│     ├────────────────────┼──────┤"
    "│     │ 1-2                │ 2-2  │"
    "└─────┴────────────────────┴──────┘"
);

test_table!(
    pool_table_value_3,
    PoolTable::from(TableValue::Row(vec![
        TableValue::Column(vec![TableValue::Cell(String::from("0-0")), TableValue::Cell(String::from("0-1")), TableValue::Cell(String::from("0-2"))]),
        TableValue::Column(vec![
            TableValue::Row(vec![TableValue::Cell(String::from("2-01")), TableValue::Cell(String::from("2-02")), TableValue::Cell(String::from("2-03"))]),
            TableValue::Column(vec![TableValue::Cell(String::from("2-01")), TableValue::Cell(String::from("2-02")), TableValue::Cell(String::from("2-03"))]),
            TableValue::Cell(String::from("1-1")),
            TableValue::Row(vec![TableValue::Cell(String::from("2-01")), TableValue::Cell(String::from("2-02")), TableValue::Cell(String::from("2-03"))]),
            TableValue::Cell(String::from("1-2"))
        ]),
        TableValue::Column(vec![
            TableValue::Column(vec![TableValue::Cell(String::from("2-\n0\n1")), TableValue::Cell(String::from("2\n-\n0\n2")), TableValue::Cell(String::from("2-03"))]),
            TableValue::Cell(String::from("2-1")),
            TableValue::Column(vec![TableValue::Cell(String::from("2-0\n1")), TableValue::Cell(String::from("2-02")), TableValue::Cell(String::from("2-03"))]),
            TableValue::Cell(String::from("2-2"))
        ]),
    ]))
    .with(Style::modern()),
    "┌─────┬──────┬──────┬──────┬──────┐"
    "│ 0-0 │ 2-01 │ 2-02 │ 2-03 │ 2-   │"
    "│     │      │      │      │ 0    │"
    "│     │      │      │      │ 1    │"
    "│     ├──────┴──────┴──────┼──────┤"
    "│     │ 2-01               │ 2    │"
    "│     │                    │ -    │"
    "│     ├────────────────────┤ 0    │"
    "├─────┤ 2-02               │ 2    │"
    "│ 0-1 │                    ├──────┤"
    "│     ├────────────────────┤ 2-03 │"
    "│     │ 2-03               ├──────┤"
    "│     ├────────────────────┤ 2-1  │"
    "│     │ 1-1                ├──────┤"
    "│     │                    │ 2-0  │"
    "├─────┤                    │ 1    │"
    "│ 0-2 ├──────┬──────┬──────┼──────┤"
    "│     │ 2-01 │ 2-02 │ 2-03 │ 2-02 │"
    "│     │      │      │      ├──────┤"
    "│     ├──────┴──────┴──────┤ 2-03 │"
    "│     │ 1-2                ├──────┤"
    "│     │                    │ 2-2  │"
    "└─────┴────────────────────┴──────┘"
);

test_table!(
    pool_table_example,
    {
        let data = vec![
            vec!["Hello World", "Hello World", "Hello World"],
            vec!["Hello", "", "Hello"],
            vec!["W", "o", "r", "l", "d"],
        ];

        let data = TableValue::Column(
            data.into_iter()
                .map(|row| {
                    TableValue::Row(
                        row.into_iter()
                            .map(|text| TableValue::Cell(text.to_owned()))
                            .collect(),
                    )
                })
                .collect(),
        );

        PoolTable::from(data)
            .with(Style::modern())
            .with(Alignment::center())
            .to_string()
    },
    "┌─────────────┬─────────────┬─────────────┐"
    "│ Hello World │ Hello World │ Hello World │"
    "├─────────────┴─┬──────────┬┴─────────────┤"
    "│     Hello     │          │    Hello     │"
    "├────────┬──────┴─┬───────┬┴──────┬───────┤"
    "│   W    │   o    │   r   │   l   │   d   │"
    "└────────┴────────┴───────┴───────┴───────┘"
);

test_table!(
    pool_table_value_empty_row,
    PoolTable::from(TableValue::Row(vec![]))
    .with(Style::modern()),
    "┌──┐"
    "│  │"
    "└──┘"
);

test_table!(
    pool_table_value_empty_column,
    PoolTable::from(TableValue::Column(vec![]))
    .with(Style::modern()),
    "┌──┐"
    "│  │"
    "└──┘"
);

test_table!(
    pool_table_value_empty_cell,
    PoolTable::from(TableValue::Cell(String::from("")))
    .with(Style::modern()),
    "┌──┐"
    "│  │"
    "└──┘"
);

test_table!(
    pool_table_padding,
    PoolTable::new(Matrix::with_no_frame(3, 3).to_vec()).with(Padding::new(1, 2, 3, 4)),
    "+------+------+------+"
    "|      |      |      |"
    "|      |      |      |"
    "|      |      |      |"
    "| 0-0  | 0-1  | 0-2  |"
    "|      |      |      |"
    "|      |      |      |"
    "|      |      |      |"
    "|      |      |      |"
    "+------+------+------+"
    "|      |      |      |"
    "|      |      |      |"
    "|      |      |      |"
    "| 1-0  | 1-1  | 1-2  |"
    "|      |      |      |"
    "|      |      |      |"
    "|      |      |      |"
    "|      |      |      |"
    "+------+------+------+"
    "|      |      |      |"
    "|      |      |      |"
    "|      |      |      |"
    "| 2-0  | 2-1  | 2-2  |"
    "|      |      |      |"
    "|      |      |      |"
    "|      |      |      |"
    "|      |      |      |"
    "+------+------+------+"
);

#[cfg(feature = "ansi")]
test_table!(
    pool_table_padding_2,
    PoolTable::new(Matrix::with_no_frame(3, 3).to_vec())
        .with(Padding::new(1, 2, 3, 4).fill('!', '@', '#', '$'))
        .with(PaddingColor::new(
            ANSIStr::new("\u{1b}[34m", "\u{1b}[39m"),
            ANSIStr::new("\u{1b}[34m", "\u{1b}[39m"),
            ANSIStr::new("\u{1b}[34m", "\u{1b}[39m"),
            ANSIStr::new("\u{1b}[34m", "\u{1b}[39m"),
        )),
    "+------+------+------+"
    "|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|"
    "|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|"
    "|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|"
    "|\u{1b}[34m!\u{1b}[39m0-0\u{1b}[34m@@\u{1b}[39m|\u{1b}[34m!\u{1b}[39m0-1\u{1b}[34m@@\u{1b}[39m|\u{1b}[34m!\u{1b}[39m0-2\u{1b}[34m@@\u{1b}[39m|"
    "|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|"
    "|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|"
    "|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|"
    "|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|"
    "+------+------+------+"
    "|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|"
    "|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|"
    "|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|"
    "|\u{1b}[34m!\u{1b}[39m1-0\u{1b}[34m@@\u{1b}[39m|\u{1b}[34m!\u{1b}[39m1-1\u{1b}[34m@@\u{1b}[39m|\u{1b}[34m!\u{1b}[39m1-2\u{1b}[34m@@\u{1b}[39m|"
    "|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|"
    "|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|"
    "|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|"
    "|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|"
    "+------+------+------+"
    "|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|"
    "|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|"
    "|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|\u{1b}[34m######\u{1b}[39m|"
    "|\u{1b}[34m!\u{1b}[39m2-0\u{1b}[34m@@\u{1b}[39m|\u{1b}[34m!\u{1b}[39m2-1\u{1b}[34m@@\u{1b}[39m|\u{1b}[34m!\u{1b}[39m2-2\u{1b}[34m@@\u{1b}[39m|"
    "|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|"
    "|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|"
    "|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|"
    "|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|\u{1b}[34m$$$$$$\u{1b}[39m|"
    "+------+------+------+"
);

test_table!(
    pool_table_margin,
    PoolTable::new(Matrix::with_no_frame(3, 3).to_vec()).with(Margin::new(1, 2, 3, 4).fill('!', '@', '#', '$')),
    "!###################@@"
    "!###################@@"
    "!###################@@"
    "!+-----+-----+-----+@@"
    "!| 0-0 | 0-1 | 0-2 |@@"
    "!+-----+-----+-----+@@"
    "!| 1-0 | 1-1 | 1-2 |@@"
    "!+-----+-----+-----+@@"
    "!| 2-0 | 2-1 | 2-2 |@@"
    "!+-----+-----+-----+@@"
    "!$$$$$$$$$$$$$$$$$$$@@"
    "!$$$$$$$$$$$$$$$$$$$@@"
    "!$$$$$$$$$$$$$$$$$$$@@"
    "!$$$$$$$$$$$$$$$$$$$@@"
);

test_table!(
    pool_table_alignment_bottom,
    PoolTable::new([
        ["1", "2\n2", "3\n3\n3"],
        ["3\n3\n3", "2\n2", "1"],
        ["1", "3\n3\n3", "2\n2"]
    ])
    .with(Alignment::bottom()),
    "+---+---+---+"
    "|   |   | 3 |"
    "|   | 2 | 3 |"
    "| 1 | 2 | 3 |"
    "+---+---+---+"
    "| 3 |   |   |"
    "| 3 | 2 |   |"
    "| 3 | 2 | 1 |"
    "+---+---+---+"
    "|   | 3 |   |"
    "|   | 3 | 2 |"
    "| 1 | 3 | 2 |"
    "+---+---+---+"
);

test_table!(
    pool_table_alignment_center_vertical,
    PoolTable::new([
        ["1", "2\n2", "3\n3\n3"],
        ["3\n3\n3", "2\n2", "1"],
        ["1", "3\n3\n3", "2\n2"]
    ])
    .with(Alignment::center_vertical()),
    "+---+---+---+"
    "|   | 2 | 3 |"
    "| 1 | 2 | 3 |"
    "|   |   | 3 |"
    "+---+---+---+"
    "| 3 | 2 |   |"
    "| 3 | 2 | 1 |"
    "| 3 |   |   |"
    "+---+---+---+"
    "|   | 3 | 2 |"
    "| 1 | 3 | 2 |"
    "|   | 3 |   |"
    "+---+---+---+"
);

test_table!(
    pool_table_alignment_right,
    PoolTable::new([
        ["1                     ", "2\n2       ", "3\n3\n3"],
        ["3\n3\n3", "2\n2", "1"],
        ["1", "3\n3\n3                   ", "2\n2"]
    ])
    .with(Alignment::right()),
    "+------------------------+----------+---+"
    "| 1                      | 2        | 3 |"
    "|                        | 2        | 3 |"
    "|                        |          | 3 |"
    "+-------------+----------+-+--------+---+"
    "|           3 |          2 |          1 |"
    "|           3 |          2 |            |"
    "|           3 |            |            |"
    "+------+------+------------+-----+------+"
    "|    1 |    3                    |    2 |"
    "|      |    3                    |    2 |"
    "|      |    3                    |      |"
    "+------+-------------------------+------+"
);

test_table!(
    pool_table_alignment_right_per_line,
    PoolTable::new([
        ["1                     ", "2\n2       ", "3\n3\n3"],
        ["3\n3\n3", "2\n2", "1"],
        ["1", "3\n3\n3                   ", "2\n2"]
    ])
    .with(Alignment::right())
    .with(AlignmentStrategy::PerLine),
    "+------------------------+----------+---+"
    "| 1                      |        2 | 3 |"
    "|                        | 2        | 3 |"
    "|                        |          | 3 |"
    "+-------------+----------+-+--------+---+"
    "|           3 |          2 |          1 |"
    "|           3 |          2 |            |"
    "|           3 |            |            |"
    "+------+------+------------+-----+------+"
    "|    1 |                       3 |    2 |"
    "|      |                       3 |    2 |"
    "|      |    3                    |      |"
    "+------+-------------------------+------+"
);

test_table!(
    pool_table_alignment_center_horizontal,
    PoolTable::new([
        ["1                     ", "2\n2       ", "3\n3\n3"],
        ["3\n3\n3", "2\n2", "1"],
        ["1", "3\n3\n3                   ", "2\n2"]
    ])
    .with(Alignment::center()),
    "+------------------------+----------+---+"
    "| 1                      | 2        | 3 |"
    "|                        | 2        | 3 |"
    "|                        |          | 3 |"
    "+-------------+----------+-+--------+---+"
    "|      3      |     2      |     1      |"
    "|      3      |     2      |            |"
    "|      3      |            |            |"
    "+------+------+------------+-----+------+"
    "|  1   |  3                      |  2   |"
    "|      |  3                      |  2   |"
    "|      |  3                      |      |"
    "+------+-------------------------+------+"
);

test_table!(
    pool_table_alignment_center_horizontal_line_strategy,
    PoolTable::new([
        ["1                     ", "2\n22222", "3\n3\n3"],
        ["3\n3\n3", "2\n2", "1"],
        ["1", "3\n3\n3                   ", "2\n2"]
    ])
    .with(Alignment::center())
    .with(AlignmentStrategy::PerLine),
    "+------------------------+-------+---+"
    "| 1                      |   2   | 3 |"
    "|                        | 22222 | 3 |"
    "|                        |       | 3 |"
    "+------------+-----------+-------+---+"
    "|     3      |     2     |     1     |"
    "|     3      |     2     |           |"
    "|     3      |           |           |"
    "+-----+------+-----------+-----+-----+"
    "|  1  |           3            |  2  |"
    "|     |           3            |  2  |"
    "|     |  3                     |     |"
    "+-----+------------------------+-----+"
);

test_table!(
    pool_table_style_empty,
    PoolTable::new(Matrix::with_no_frame(3, 3).to_vec()).with(Style::empty()),
    " 0-0  0-1  0-2 "
    " 1-0  1-1  1-2 "
    " 2-0  2-1  2-2 "
);

test_table!(
    pool_table_style_markdown,
    PoolTable::new(Matrix::with_no_frame(3, 3).to_vec()).with(Style::markdown()),
    "| 0-0 | 0-1 | 0-2 |"
    "| 1-0 | 1-1 | 1-2 |"
    "| 2-0 | 2-1 | 2-2 |"
);

test_table!(
    pool_table_style_rounded,
    PoolTable::new(Matrix::with_no_frame(3, 3).to_vec()).with(Style::rounded()),
    "╭─────┬─────┬─────╮"
    "│ 0-0 │ 0-1 │ 0-2 │"
    " ───── ───── ───── "
    "│ 1-0 │ 1-1 │ 1-2 │"
    " ───── ───── ───── "
    "│ 2-0 │ 2-1 │ 2-2 │"
    "╰─────┴─────┴─────╯"
);

test_table!(
    pool_table_dim_ctrl_0,
    PoolTable::from(TableValue::Row(vec![
        TableValue::Column(vec![TableValue::Cell(String::from("0-0")), TableValue::Cell(String::from("0-1")), TableValue::Cell(String::from("0-2"))]),
        TableValue::Column(vec![TableValue::Cell(String::from("1-0")), TableValue::Cell(String::from("1-1")), TableValue::Cell(String::from("1-2"))]),
        TableValue::Column(vec![
            TableValue::Column(vec![TableValue::Cell(String::from("2-01")), TableValue::Cell(String::from("2-02")), TableValue::Cell(String::from("2-03"))]),
            TableValue::Cell(String::from("2-1")),
            TableValue::Cell(String::from("2-2")),
        ]),
    ]))
    .with(PoolTableDimension::new(DimensionPriority::Last, DimensionPriority::Last)),
    "+-----+-----+------+"
    "| 0-0 | 1-0 | 2-01 |"
    "+-----+-----+------+"
    "| 0-1 | 1-1 | 2-02 |"
    "+-----+-----+------+"
    "| 0-2 | 1-2 | 2-03 |"
    "|     |     +------+"
    "|     |     | 2-1  |"
    "|     |     +------+"
    "|     |     | 2-2  |"
    "+-----+-----+------+"
);

test_table!(
    pool_table_dim_ctrl_1,
    PoolTable::new([
        ["1                     ", "2\n2       ", "3\n3\n3"],
        ["3\n3\n3", "2\n2", "1"],
        ["1", "3\n3\n3                   ", "2\n2"]
    ])
    .with(PoolTableDimension::new(DimensionPriority::List, DimensionPriority::List)),
    "+------------------------+----------+---+"
    "| 1                      | 2        | 3 |"
    "|                        | 2        | 3 |"
    "|                        |          | 3 |"
    "+-------------+----------+-+--------+---+"
    "| 3           | 2          | 1          |"
    "| 3           | 2          |            |"
    "| 3           |            |            |"
    "+------+------+------------+-----+------+"
    "| 1    | 3                       | 2    |"
    "|      | 3                       | 2    |"
    "|      | 3                       |      |"
    "+------+-------------------------+------+"
);

test_table!(
    pool_table_2_columns_1_cell,
    PoolTable::from(TableValue::Row(vec![
        TableValue::Column(vec![
            TableValue::Cell(String::from("0-0")),
            TableValue::Cell(String::from("0-1")),
            TableValue::Cell(String::from("0-2")),
            TableValue::Cell(String::from("0-3")),
            TableValue::Cell(String::from("0-4")),
            TableValue::Cell(String::from("0-5")),
        ]),
        TableValue::Column(vec![
            TableValue::Cell(String::from("1-0")),
            TableValue::Cell(String::from("1-1")),
            TableValue::Cell(String::from("1-2")),
            TableValue::Cell(String::from("1-3")),
            TableValue::Cell(String::from("1-4")),
            TableValue::Cell(String::from("1-6")),
            TableValue::Cell(String::from("1-7")),
            TableValue::Cell(String::from("1-8")),
            TableValue::Cell(String::from("1-9")),
        ]),
        TableValue::Cell(String::from("2-0")),
    ]))
    .with(PoolTableDimension::new(DimensionPriority::Last, DimensionPriority::Last)),
    "+-----+-----+-----+"
    "| 0-0 | 1-0 | 2-0 |"
    "+-----+-----+     |"
    "| 0-1 | 1-1 |     |"
    "+-----+-----+     |"
    "| 0-2 | 1-2 |     |"
    "+-----+-----+     |"
    "| 0-3 | 1-3 |     |"
    "+-----+-----+     |"
    "| 0-4 | 1-4 |     |"
    "+-----+-----+     |"
    "| 0-5 | 1-6 |     |"
    "|     +-----+     |"
    "|     | 1-7 |     |"
    "|     +-----+     |"
    "|     | 1-8 |     |"
    "|     +-----+     |"
    "|     | 1-9 |     |"
    "+-----+-----+-----+"
);