CommandLineToolkit

1
import Foundation
2
import XCTest
3
import InlineSnapshotTesting
4
import Logging
5
@testable import Console
6

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