git.iko.soy/bat
on master help sign in
Revert f8ed8aa7 (add test instrumentation to help understand failing tests) per PR feedback/owner request
92e9368Roy Ivy III
tests/integration_tests.rs+86−235
compare with master
unifiedsplit
@@ -25,14 +25,9 @@ fn bat() -> Command {
25
25
26#[test]
26#[test]
27fn basic() {
27fn basic() {
28− let assert = bat()
28+ bat()
29 .arg("test.txt")
29 .arg("test.txt")
30− .assert();
30+ .assert()
31− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
32− let stderr = String::from_utf8_lossy(&assert.get_output().stderr);
33− println!("stdout={:#?}", stdout);
34− println!("stderr={:#?}", stderr);
35− assert
36 .success()
31 .success()
37 .stdout("hello world\n")
32 .stdout("hello world\n")
38 .stderr("");
33 .stderr("");
@@ -40,216 +35,168 @@ fn basic() {
40
35
41#[test]
36#[test]
42fn stdin() {
37fn stdin() {
43− let assert = bat()
38+ bat()
44 .write_stdin("foo\nbar\n")
39 .write_stdin("foo\nbar\n")
45− .assert();
40+ .assert()
46− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
47− println!("stdout={:#?}", stdout);
48− assert
49 .success()
41 .success()
50 .stdout("foo\nbar\n");
42 .stdout("foo\nbar\n");
51}
43}
52
44
53#[test]
45#[test]
54fn concatenate() {
46fn concatenate() {
55− let assert = bat()
47+ bat()
56 .arg("test.txt")
48 .arg("test.txt")
57 .arg("test.txt")
49 .arg("test.txt")
58− .assert();
50+ .assert()
59− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
60− println!("stdout={:#?}", stdout);
61− assert
62 .success()
51 .success()
63 .stdout("hello world\nhello world\n");
52 .stdout("hello world\nhello world\n");
64}
53}
65
54
66#[test]
55#[test]
67fn concatenate_stdin() {
56fn concatenate_stdin() {
68− let assert = bat()
57+ bat()
69 .arg("test.txt")
58 .arg("test.txt")
70 .arg("-")
59 .arg("-")
71 .arg("test.txt")
60 .arg("test.txt")
72 .write_stdin("stdin\n")
61 .write_stdin("stdin\n")
73− .assert();
62+ .assert()
74− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
75− println!("stdout={:#?}", stdout);
76− assert
77 .success()
63 .success()
78 .stdout("hello world\nstdin\nhello world\n");
64 .stdout("hello world\nstdin\nhello world\n");
79}
65}
80
66
81#[test]
67#[test]
82fn concatenate_empty_first() {
68fn concatenate_empty_first() {
83− let assert = bat()
69+ bat()
84 .arg("empty.txt")
70 .arg("empty.txt")
85 .arg("test.txt")
71 .arg("test.txt")
86− .assert();
72+ .assert()
87− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
88− println!("stdout={:#?}", stdout);
89− assert
90 .success()
73 .success()
91 .stdout("hello world\n");
74 .stdout("hello world\n");
92}
75}
93
76
94#[test]
77#[test]
95fn concatenate_empty_last() {
78fn concatenate_empty_last() {
96− let assert = bat()
79+ bat()
97 .arg("test.txt")
80 .arg("test.txt")
98 .arg("empty.txt")
81 .arg("empty.txt")
99− .assert();
82+ .assert()
100− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
101− println!("stdout={:#?}", stdout);
102− assert
103 .success()
83 .success()
104 .stdout("hello world\n");
84 .stdout("hello world\n");
105}
85}
106
86
107#[test]
87#[test]
108fn concatenate_empty_both() {
88fn concatenate_empty_both() {
109− let assert = bat()
89+ bat()
110 .arg("empty.txt")
90 .arg("empty.txt")
111 .arg("empty.txt")
91 .arg("empty.txt")
112− .assert();
92+ .assert()
113− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
114− println!("stdout={:#?}", stdout);
115− assert
116 .success()
93 .success()
117 .stdout("");
94 .stdout("");
118}
95}
119
96
120#[test]
97#[test]
121fn concatenate_empty_between() {
98fn concatenate_empty_between() {
122− let assert = bat()
99+ bat()
123 .arg("test.txt")
100 .arg("test.txt")
124 .arg("empty.txt")
101 .arg("empty.txt")
125 .arg("test.txt")
102 .arg("test.txt")
126− .assert();
103+ .assert()
127− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
128− println!("stdout={:#?}", stdout);
129− assert
130 .success()
104 .success()
131 .stdout("hello world\nhello world\n");
105 .stdout("hello world\nhello world\n");
132}
106}
133
107
134#[test]
108#[test]
135fn concatenate_empty_first_and_last() {
109fn concatenate_empty_first_and_last() {
136− let assert = bat()
110+ bat()
137 .arg("empty.txt")
111 .arg("empty.txt")
138 .arg("test.txt")
112 .arg("test.txt")
139 .arg("empty.txt")
113 .arg("empty.txt")
140− .assert();
114+ .assert()
141− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
142− println!("stdout={:#?}", stdout);
143− assert
144 .success()
115 .success()
145 .stdout("hello world\n");
116 .stdout("hello world\n");
146}
117}
147
118
148#[test]
119#[test]
149fn concatenate_single_line() {
120fn concatenate_single_line() {
150− let assert = bat()
121+ bat()
151 .arg("single-line.txt")
122 .arg("single-line.txt")
152 .arg("single-line.txt")
123 .arg("single-line.txt")
153− .assert();
124+ .assert()
154− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
155− println!("stdout={:#?}", stdout);
156− assert
157 .success()
125 .success()
158 .stdout("Single LineSingle Line");
126 .stdout("Single LineSingle Line");
159}
127}
160
128
161#[test]
129#[test]
162fn concatenate_single_line_empty() {
130fn concatenate_single_line_empty() {
163− let assert = bat()
131+ bat()
164 .arg("single-line.txt")
132 .arg("single-line.txt")
165 .arg("empty.txt")
133 .arg("empty.txt")
166 .arg("single-line.txt")
134 .arg("single-line.txt")
167− .assert();
135+ .assert()
168− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
169− println!("stdout={:#?}", stdout);
170− assert
171 .success()
136 .success()
172 .stdout("Single LineSingle Line");
137 .stdout("Single LineSingle Line");
173}
138}
174
139
175#[test]
140#[test]
176fn line_numbers() {
141fn line_numbers() {
177− let assert = bat()
142+ bat()
178 .arg("multiline.txt")
143 .arg("multiline.txt")
179 .arg("--style=numbers")
144 .arg("--style=numbers")
180 .arg("--decorations=always")
145 .arg("--decorations=always")
181− .assert();
146+ .assert()
182− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
183− println!("stdout={:#?}", stdout);
184− assert
185 .success()
147 .success()
186 .stdout(" 1 line 1\n 2 line 2\n 3 line 3\n 4 line 4\n");
148 .stdout(" 1 line 1\n 2 line 2\n 3 line 3\n 4 line 4\n");
187}
149}
188
150
189#[test]
151#[test]
190fn line_range_2_3() {
152fn line_range_2_3() {
191− let assert = bat()
153+ bat()
192 .arg("multiline.txt")
154 .arg("multiline.txt")
193 .arg("--line-range=2:3")
155 .arg("--line-range=2:3")
194− .assert();
156+ .assert()
195− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
196− println!("stdout={:#?}", stdout);
197− assert
198 .success()
157 .success()
199 .stdout("line 2\nline 3\n");
158 .stdout("line 2\nline 3\n");
200}
159}
201
160
202#[test]
161#[test]
203fn line_range_first_two() {
162fn line_range_first_two() {
204− let assert = bat()
163+ bat()
205 .arg("multiline.txt")
164 .arg("multiline.txt")
206 .arg("--line-range=:2")
165 .arg("--line-range=:2")
207− .assert();
166+ .assert()
208− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
209− println!("stdout={:#?}", stdout);
210− assert
211 .success()
167 .success()
212 .stdout("line 1\nline 2\n");
168 .stdout("line 1\nline 2\n");
213}
169}
214
170
215#[test]
171#[test]
216fn line_range_last_3() {
172fn line_range_last_3() {
217− let assert = bat()
173+ bat()
218 .arg("multiline.txt")
174 .arg("multiline.txt")
219 .arg("--line-range=2:")
175 .arg("--line-range=2:")
220− .assert();
176+ .assert()
221− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
222− println!("stdout={:#?}", stdout);
223− assert
224 .success()
177 .success()
225 .stdout("line 2\nline 3\nline 4\n");
178 .stdout("line 2\nline 3\nline 4\n");
226}
179}
227
180
228#[test]
181#[test]
229fn line_range_multiple() {
182fn line_range_multiple() {
230− let assert = bat()
183+ bat()
231 .arg("multiline.txt")
184 .arg("multiline.txt")
232 .arg("--line-range=1:2")
185 .arg("--line-range=1:2")
233 .arg("--line-range=4:4")
186 .arg("--line-range=4:4")
234− .assert();
187+ .assert()
235− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
236− println!("stdout={:#?}", stdout);
237− assert
238 .success()
188 .success()
239 .stdout("line 1\nline 2\nline 4\n");
189 .stdout("line 1\nline 2\nline 4\n");
240}
190}
241
191
242#[test]
192#[test]
243fn tabs_numbers() {
193fn tabs_numbers() {
244− let assert = bat()
194+ bat()
245 .arg("tabs.txt")
195 .arg("tabs.txt")
246 .arg("--tabs=4")
196 .arg("--tabs=4")
247 .arg("--style=numbers")
197 .arg("--style=numbers")
248 .arg("--decorations=always")
198 .arg("--decorations=always")
249− .assert();
199+ .assert()
250− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
251− println!("stdout={:#?}", stdout);
252− assert
253 .success()
200 .success()
254 .stdout(
201 .stdout(
255 " 1 1 2 3 4
202 " 1 1 2 3 4
@@ -267,15 +214,12 @@ fn tabs_numbers() {
267
214
268#[test]
215#[test]
269fn tabs_passthrough_wrapped() {
216fn tabs_passthrough_wrapped() {
270− let assert = bat()
217+ bat()
271 .arg("tabs.txt")
218 .arg("tabs.txt")
272 .arg("--tabs=0")
219 .arg("--tabs=0")
273 .arg("--style=plain")
220 .arg("--style=plain")
274 .arg("--decorations=always")
221 .arg("--decorations=always")
275− .assert();
222+ .assert()
276− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
277− println!("stdout={:#?}", stdout);
278− assert
279 .success()
223 .success()
280 .stdout(
224 .stdout(
281 " 1 2 3 4
225 " 1 2 3 4
@@ -293,15 +237,12 @@ fn tabs_passthrough_wrapped() {
293
237
294#[test]
238#[test]
295fn tabs_4_wrapped() {
239fn tabs_4_wrapped() {
296− let assert = bat()
240+ bat()
297 .arg("tabs.txt")
241 .arg("tabs.txt")
298 .arg("--tabs=4")
242 .arg("--tabs=4")
299 .arg("--style=plain")
243 .arg("--style=plain")
300 .arg("--decorations=always")
244 .arg("--decorations=always")
301− .assert();
245+ .assert()
302− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
303− println!("stdout={:#?}", stdout);
304− assert
305 .success()
246 .success()
306 .stdout(
247 .stdout(
307 " 1 2 3 4
248 " 1 2 3 4
@@ -319,15 +260,12 @@ fn tabs_4_wrapped() {
319
260
320#[test]
261#[test]
321fn tabs_8_wrapped() {
262fn tabs_8_wrapped() {
322− let assert = bat()
263+ bat()
323 .arg("tabs.txt")
264 .arg("tabs.txt")
324 .arg("--tabs=8")
265 .arg("--tabs=8")
325 .arg("--style=plain")
266 .arg("--style=plain")
326 .arg("--decorations=always")
267 .arg("--decorations=always")
327− .assert();
268+ .assert()
328− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
329− println!("stdout={:#?}", stdout);
330− assert
331 .success()
269 .success()
332 .stdout(
270 .stdout(
333 " 1 2 3 4
271 " 1 2 3 4
@@ -345,15 +283,12 @@ fn tabs_8_wrapped() {
345
283
346#[test]
284#[test]
347fn tabs_passthrough() {
285fn tabs_passthrough() {
348− let assert = bat()
286+ bat()
349 .arg("tabs.txt")
287 .arg("tabs.txt")
350 .arg("--tabs=0")
288 .arg("--tabs=0")
351 .arg("--style=plain")
289 .arg("--style=plain")
352 .arg("--decorations=always")
290 .arg("--decorations=always")
353− .assert();
291+ .assert()
354− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
355− println!("stdout={:#?}", stdout);
356− assert
357 .success()
292 .success()
358 .stdout(
293 .stdout(
359 " 1 2 3 4
294 " 1 2 3 4
@@ -371,15 +306,12 @@ fn tabs_passthrough() {
371
306
372#[test]
307#[test]
373fn tabs_4() {
308fn tabs_4() {
374− let assert = bat()
309+ bat()
375 .arg("tabs.txt")
310 .arg("tabs.txt")
376 .arg("--tabs=4")
311 .arg("--tabs=4")
377 .arg("--style=plain")
312 .arg("--style=plain")
378 .arg("--decorations=always")
313 .arg("--decorations=always")
379− .assert();
314+ .assert()
380− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
381− println!("stdout={:#?}", stdout);
382− assert
383 .success()
315 .success()
384 .stdout(
316 .stdout(
385 " 1 2 3 4
317 " 1 2 3 4
@@ -397,15 +329,12 @@ fn tabs_4() {
397
329
398#[test]
330#[test]
399fn tabs_8() {
331fn tabs_8() {
400− let assert = bat()
332+ bat()
401 .arg("tabs.txt")
333 .arg("tabs.txt")
402 .arg("--tabs=8")
334 .arg("--tabs=8")
403 .arg("--style=plain")
335 .arg("--style=plain")
404 .arg("--decorations=always")
336 .arg("--decorations=always")
405− .assert();
337+ .assert()
406− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
407− println!("stdout={:#?}", stdout);
408− assert
409 .success()
338 .success()
410 .stdout(
339 .stdout(
411 " 1 2 3 4
340 " 1 2 3 4
@@ -433,83 +362,65 @@ fn fail_directory() {
433
362
434#[test]
363#[test]
435fn do_not_exit_directory() {
364fn do_not_exit_directory() {
436− let assert = bat()
365+ bat()
437 .arg("sub_directory")
366 .arg("sub_directory")
438 .arg("test.txt")
367 .arg("test.txt")
439− .assert();
368+ .assert()
440− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
441− println!("stdout={:#?}", stdout);
442− assert
443 .stdout("hello world\n")
369 .stdout("hello world\n")
444 .failure();
370 .failure();
445}
371}
446
372
447#[test]
373#[test]
448fn pager_basic() {
374fn pager_basic() {
449− let assert = bat()
375+ bat()
450 .env("PAGER", "echo pager-output")
376 .env("PAGER", "echo pager-output")
451 .arg("--paging=always")
377 .arg("--paging=always")
452 .arg("test.txt")
378 .arg("test.txt")
453− .assert();
379+ .assert()
454− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
455− println!("stdout={:#?}", stdout);
456− assert
457 .success()
380 .success()
458 .stdout(predicate::eq("pager-output\n").normalize());
381 .stdout(predicate::eq("pager-output\n").normalize());
459}
382}
460
383
461#[test]
384#[test]
462fn pager_overwrite() {
385fn pager_overwrite() {
463− let assert = bat()
386+ bat()
464 .env("PAGER", "echo other-pager")
387 .env("PAGER", "echo other-pager")
465 .env("BAT_PAGER", "echo pager-output")
388 .env("BAT_PAGER", "echo pager-output")
466 .arg("--paging=always")
389 .arg("--paging=always")
467 .arg("test.txt")
390 .arg("test.txt")
468− .assert();
391+ .assert()
469− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
470− println!("stdout={:#?}", stdout);
471− assert
472 .success()
392 .success()
473 .stdout(predicate::eq("pager-output\n").normalize());
393 .stdout(predicate::eq("pager-output\n").normalize());
474}
394}
475
395
476#[test]
396#[test]
477fn pager_disable() {
397fn pager_disable() {
478− let assert = bat()
398+ bat()
479 .env("PAGER", "echo other-pager")
399 .env("PAGER", "echo other-pager")
480 .env("BAT_PAGER", "")
400 .env("BAT_PAGER", "")
481 .arg("--paging=always")
401 .arg("--paging=always")
482 .arg("test.txt")
402 .arg("test.txt")
483− .assert();
403+ .assert()
484− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
485− println!("stdout={:#?}", stdout);
486− assert
487 .success()
404 .success()
488 .stdout(predicate::eq("hello world\n").normalize());
405 .stdout(predicate::eq("hello world\n").normalize());
489}
406}
490
407
491#[test]
408#[test]
492fn config_location_test() {
409fn config_location_test() {
493− let assert = bat_with_config()
410+ bat_with_config()
494 .env("BAT_CONFIG_PATH", "bat.conf")
411 .env("BAT_CONFIG_PATH", "bat.conf")
495 .arg("--config-file")
412 .arg("--config-file")
496− .assert();
413+ .assert()
497− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
498− println!("stdout={:#?}", stdout);
499− assert
500 .success()
414 .success()
501 .stdout("bat.conf\n");
415 .stdout("bat.conf\n");
502}
416}
503
417
504#[test]
418#[test]
505fn config_read_arguments_from_file() {
419fn config_read_arguments_from_file() {
506− let assert = bat_with_config()
420+ bat_with_config()
507 .env("BAT_CONFIG_PATH", "bat.conf")
421 .env("BAT_CONFIG_PATH", "bat.conf")
508 .arg("test.txt")
422 .arg("test.txt")
509− .assert();
423+ .assert()
510− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
511− println!("stdout={:#?}", stdout);
512− assert
513 .success()
424 .success()
514 .stdout(predicate::eq("dummy-pager-from-config\n").normalize());
425 .stdout(predicate::eq("dummy-pager-from-config\n").normalize());
515}
426}
@@ -517,28 +428,20 @@ fn config_read_arguments_from_file() {
517#[test]
428#[test]
518fn utf16() {
429fn utf16() {
519 // The output will be converted to UTF-8 with a leading UTF-8 BOM
430 // The output will be converted to UTF-8 with a leading UTF-8 BOM
520− let assert = bat()
431+ bat()
521 .arg("--plain")
432 .arg("--plain")
522 .arg("--decorations=always")
433 .arg("--decorations=always")
523 .arg("test_UTF-16LE.txt")
434 .arg("test_UTF-16LE.txt")
524− .assert();
435+ .assert()
525− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
526− println!("stdout={:#?}", stdout);
527− assert
528 .success()
436 .success()
529 .stdout(std::str::from_utf8(b"\xEF\xBB\xBFhello world\n").unwrap());
437 .stdout(std::str::from_utf8(b"\xEF\xBB\xBFhello world\n").unwrap());
530}
438}
531
439
532#[test]
440#[test]
533fn can_print_file_named_cache() {
441fn can_print_file_named_cache() {
534− let assert = bat_with_config()
442+ bat_with_config()
535 .arg("cache")
443 .arg("cache")
536− .assert();
444+ .assert()
537− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
538− let stderr = String::from_utf8_lossy(&assert.get_output().stderr);
539− println!("stdout={:#?}", stdout);
540− println!("stderr={:#?}", stderr);
541− assert
542 .success()
445 .success()
543 .stdout("test\n")
446 .stdout("test\n")
544 .stderr("");
447 .stderr("");
@@ -546,15 +449,10 @@ fn can_print_file_named_cache() {
546
449
547#[test]
450#[test]
548fn can_print_file_named_cache_with_additional_argument() {
451fn can_print_file_named_cache_with_additional_argument() {
549− let assert = bat_with_config()
452+ bat_with_config()
550 .arg("cache")
453 .arg("cache")
551 .arg("test.txt")
454 .arg("test.txt")
552− .assert();
455+ .assert()
553− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
554− let stderr = String::from_utf8_lossy(&assert.get_output().stderr);
555− println!("stdout={:#?}", stdout);
556− println!("stderr={:#?}", stderr);
557− assert
558 .success()
456 .success()
559 .stdout("test\nhello world\n")
457 .stdout("test\nhello world\n")
560 .stderr("");
458 .stderr("");
@@ -562,14 +460,9 @@ fn can_print_file_named_cache_with_additional_argument() {
562
460
563#[test]
461#[test]
564fn can_print_file_starting_with_cache() {
462fn can_print_file_starting_with_cache() {
565− let assert = bat_with_config()
463+ bat_with_config()
566 .arg("cache.c")
464 .arg("cache.c")
567− .assert();
465+ .assert()
568− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
569− let stderr = String::from_utf8_lossy(&assert.get_output().stderr);
570− println!("stdout={:#?}", stdout);
571− println!("stderr={:#?}", stderr);
572− assert
573 .success()
466 .success()
574 .stdout("test\n")
467 .stdout("test\n")
575 .stderr("");
468 .stderr("");
@@ -582,15 +475,12 @@ fn does_not_print_unwanted_file_named_cache() {
582
475
583#[test]
476#[test]
584fn unicode_wrap() {
477fn unicode_wrap() {
585− let assert = bat_with_config()
478+ bat_with_config()
586 .arg("unicode-wrap.txt")
479 .arg("unicode-wrap.txt")
587 .arg("--style=numbers,snip")
480 .arg("--style=numbers,snip")
588 .arg("--decorations=always")
481 .arg("--decorations=always")
589 .arg("--terminal-width=40")
482 .arg("--terminal-width=40")
590− .assert();
483+ .assert()
591− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
592− println!("stdout={:#?}", stdout);
593− assert
594 .success()
484 .success()
595 .stdout(
485 .stdout(
596 " 1 ビタミンA ビタミンD ビタミンE ビ
486 " 1 ビタミンA ビタミンD ビタミンE ビ
@@ -627,17 +517,14 @@ fn unicode_wrap() {
627
517
628#[test]
518#[test]
629fn snip() {
519fn snip() {
630− let assert = bat()
520+ bat()
631 .arg("multiline.txt")
521 .arg("multiline.txt")
632 .arg("--style=numbers,snip")
522 .arg("--style=numbers,snip")
633 .arg("--decorations=always")
523 .arg("--decorations=always")
634 .arg("--line-range=1:2")
524 .arg("--line-range=1:2")
635 .arg("--line-range=4:")
525 .arg("--line-range=4:")
636 .arg("--terminal-width=80")
526 .arg("--terminal-width=80")
637− .assert();
527+ .assert()
638− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
639− println!("stdout={:#?}", stdout);
640− assert
641 .success()
528 .success()
642 .stdout(
529 .stdout(
643 " 1 line 1
530 " 1 line 1
@@ -650,33 +537,25 @@ fn snip() {
650
537
651#[test]
538#[test]
652fn empty_file_leads_to_empty_output_with_grid_enabled() {
539fn empty_file_leads_to_empty_output_with_grid_enabled() {
653− let assert = bat()
540+ bat()
654 .arg("empty.txt")
541 .arg("empty.txt")
655 .arg("--style=grid")
542 .arg("--style=grid")
656 .arg("--decorations=always")
543 .arg("--decorations=always")
657 .arg("--terminal-width=80")
544 .arg("--terminal-width=80")
658− .assert();
545+ .assert()
659− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
660− println!("stdout={:#?}", stdout);
661− assert
662 .success()
546 .success()
663 .stdout("");
547 .stdout("");
664}
548}
665
549
666#[test]
550#[test]
667fn filename_basic() {
551fn filename_basic() {
668− let assert = bat()
552+ bat()
669 .arg("test.txt")
553 .arg("test.txt")
670 .arg("--decorations=always")
554 .arg("--decorations=always")
671 .arg("--style=header")
555 .arg("--style=header")
672 .arg("-r=0:0")
556 .arg("-r=0:0")
673 .arg("--file-name=foo")
557 .arg("--file-name=foo")
674− .assert();
558+ .assert()
675− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
676− let stderr = String::from_utf8_lossy(&assert.get_output().stderr);
677− println!("stdout={:#?}", stdout);
678− println!("stderr={:#?}", stderr);
679− assert
680 .success()
559 .success()
681 .stdout("File: foo\n")
560 .stdout("File: foo\n")
682 .stderr("");
561 .stderr("");
@@ -684,18 +563,13 @@ fn filename_basic() {
684
563
685#[test]
564#[test]
686fn filename_binary() {
565fn filename_binary() {
687− let assert = bat()
566+ bat()
688 .arg("test.binary")
567 .arg("test.binary")
689 .arg("--decorations=always")
568 .arg("--decorations=always")
690 .arg("--style=header")
569 .arg("--style=header")
691 .arg("-r=0:0")
570 .arg("-r=0:0")
692 .arg("--file-name=foo")
571 .arg("--file-name=foo")
693− .assert();
572+ .assert()
694− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
695− let stderr = String::from_utf8_lossy(&assert.get_output().stderr);
696− println!("stdout={:#?}", stdout);
697− println!("stderr={:#?}", stderr);
698− assert
699 .success()
573 .success()
700 .stdout("File: foo <BINARY>\n")
574 .stdout("File: foo <BINARY>\n")
701 .stderr("");
575 .stderr("");
@@ -703,19 +577,14 @@ fn filename_binary() {
703
577
704#[test]
578#[test]
705fn filename_stdin() {
579fn filename_stdin() {
706− let assert = bat()
580+ bat()
707 .arg("--decorations=always")
581 .arg("--decorations=always")
708 .arg("--style=header")
582 .arg("--style=header")
709 .arg("-r=0:0")
583 .arg("-r=0:0")
710 .arg("-")
584 .arg("-")
711 .write_stdin("stdin\n")
585 .write_stdin("stdin\n")
712 .arg("--file-name=foo")
586 .arg("--file-name=foo")
713− .assert();
587+ .assert()
714− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
715− let stderr = String::from_utf8_lossy(&assert.get_output().stderr);
716− println!("stdout={:#?}", stdout);
717− println!("stderr={:#?}", stderr);
718− assert
719 .success()
588 .success()
720 .stdout("File: foo\n")
589 .stdout("File: foo\n")
721 .stderr("");
590 .stderr("");
@@ -724,17 +593,12 @@ fn filename_stdin() {
724#[test]
593#[test]
725fn filename_stdin_binary() {
594fn filename_stdin_binary() {
726 let vec = vec![0; 1];
595 let vec = vec![0; 1];
727− let assert = bat_with_config()
596+ bat_with_config()
728 .arg("--decorations=always")
597 .arg("--decorations=always")
729 .arg("--style=header")
598 .arg("--style=header")
730 .write_stdin(vec)
599 .write_stdin(vec)
731 .arg("--file-name=foo")
600 .arg("--file-name=foo")
732− .assert();
601+ .assert()
733− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
734− let stderr = String::from_utf8_lossy(&assert.get_output().stderr);
735− println!("stdout={:#?}", stdout);
736− println!("stderr={:#?}", stderr);
737− assert
738 .success()
602 .success()
739 .stdout("File: foo <BINARY>\n")
603 .stdout("File: foo <BINARY>\n")
740 .stderr("");
604 .stderr("");
@@ -742,7 +606,7 @@ fn filename_stdin_binary() {
742
606
743#[test]
607#[test]
744fn filename_multiple_ok() {
608fn filename_multiple_ok() {
745− let assert = bat()
609+ bat()
746 .arg("--decorations=always")
610 .arg("--decorations=always")
747 .arg("--style=header")
611 .arg("--style=header")
748 .arg("-r=0:0")
612 .arg("-r=0:0")
@@ -750,12 +614,7 @@ fn filename_multiple_ok() {
750 .arg("--file-name=foo")
614 .arg("--file-name=foo")
751 .arg("single-line.txt")
615 .arg("single-line.txt")
752 .arg("--file-name=bar")
616 .arg("--file-name=bar")
753− .assert();
617+ .assert()
754− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
755− let stderr = String::from_utf8_lossy(&assert.get_output().stderr);
756− println!("stdout={:#?}", stdout);
757− println!("stderr={:#?}", stderr);
758− assert
759 .success()
618 .success()
760 .stdout("File: foo\n\nFile: bar\n")
619 .stdout("File: foo\n\nFile: bar\n")
761 .stderr("");
620 .stderr("");
@@ -776,17 +635,12 @@ fn filename_multiple_err() {
776
635
777#[test]
636#[test]
778fn header_padding() {
637fn header_padding() {
779− let assert = bat()
638+ bat()
780 .arg("--decorations=always")
639 .arg("--decorations=always")
781 .arg("--style=header")
640 .arg("--style=header")
782 .arg("test.txt")
641 .arg("test.txt")
783 .arg("single-line.txt")
642 .arg("single-line.txt")
784− .assert();
643+ .assert()
785− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
786− let stderr = String::from_utf8_lossy(&assert.get_output().stderr);
787− println!("stdout={:#?}", stdout);
788− println!("stderr={:#?}", stderr);
789− assert
790 .stdout("File: test.txt\nhello world\n\nFile: single-line.txt\nSingle Line\n")
644 .stdout("File: test.txt\nhello world\n\nFile: single-line.txt\nSingle Line\n")
791 .stderr("");
645 .stderr("");
792}
646}
@@ -810,12 +664,9 @@ fn file_with_invalid_utf8_filename() {
810 writeln!(file, "dummy content").expect("can write to file");
664 writeln!(file, "dummy content").expect("can write to file");
811 }
665 }
812
666
813− let assert = bat()
667+ bat()
814 .arg(file_path.as_os_str())
668 .arg(file_path.as_os_str())
815− .assert();
669+ .assert()
816− let stdout = String::from_utf8_lossy(&assert.get_output().stdout);
817− println!("stdout={:#?}", stdout);
818− assert
819 .success()
670 .success()
820 .stdout("dummy content\n");
671 .stdout("dummy content\n");
821}
672}