mirror of
https://github.com/uutils/coreutils
synced 2024-11-16 17:58:06 +00:00
347 lines
10 KiB
Rust
347 lines
10 KiB
Rust
extern crate unindent;
|
|
|
|
use common::util::*;
|
|
use std::path::Path;
|
|
use std::env;
|
|
use std::io::Write;
|
|
use std::fs::File;
|
|
use std::fs::remove_file;
|
|
use self::unindent::*;
|
|
|
|
|
|
// octal dump of 'abcdefghijklmnopqrstuvwxyz\n'
|
|
static ALPHA_OUT: &'static str = "
|
|
0000000 061141 062143 063145 064147 065151 066153 067155 070157
|
|
0000020 071161 072163 073165 074167 075171 000012
|
|
0000033
|
|
";
|
|
|
|
// XXX We could do a better job of ensuring that we have a fresh temp dir to ourself,
|
|
// not a general one ful of other proc's leftovers.
|
|
|
|
// Test that od can read one file and dump with default format
|
|
#[test]
|
|
fn test_file() {
|
|
use std::env;
|
|
let temp = env::temp_dir();
|
|
let tmpdir = Path::new(&temp);
|
|
let file = tmpdir.join("test");
|
|
|
|
{
|
|
let mut f = File::create(&file).unwrap();
|
|
match f.write_all(b"abcdefghijklmnopqrstuvwxyz\n") {
|
|
Err(_) => panic!("Test setup failed - could not write file"),
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
let result = new_ucmd!().arg("--endian=little").arg(file.as_os_str()).run();
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, unindent(ALPHA_OUT));
|
|
|
|
let _ = remove_file(file);
|
|
}
|
|
|
|
// Test that od can read 2 files and concatenate the contents
|
|
#[test]
|
|
fn test_2files() {
|
|
let temp = env::temp_dir();
|
|
let tmpdir = Path::new(&temp);
|
|
let file1 = tmpdir.join("test1");
|
|
let file2 = tmpdir.join("test2");
|
|
|
|
for &(n,a) in [(1,"a"), (2,"b")].iter() {
|
|
println!("number: {} letter:{}", n, a);
|
|
}
|
|
|
|
for &(path,data)in &[(&file1, "abcdefghijklmnop"),(&file2, "qrstuvwxyz\n")] {
|
|
let mut f = File::create(&path).unwrap();
|
|
match f.write_all(data.as_bytes()) {
|
|
Err(_) => panic!("Test setup failed - could not write file"),
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
let result = new_ucmd!().arg("--endian=little").arg(file1.as_os_str()).arg(file2.as_os_str()).run();
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, unindent(ALPHA_OUT));
|
|
|
|
let _ = remove_file(file1);
|
|
let _ = remove_file(file2);
|
|
}
|
|
|
|
// Test that od gives non-0 exit val for filename that dosen't exist.
|
|
#[test]
|
|
fn test_no_file() {
|
|
let temp = env::temp_dir();
|
|
let tmpdir = Path::new(&temp);
|
|
let file = tmpdir.join("}surely'none'would'thus'a'file'name");
|
|
|
|
let result = new_ucmd!().arg(file.as_os_str()).run();
|
|
|
|
assert!(!result.success);
|
|
}
|
|
|
|
// Test that od reads from stdin instead of a file
|
|
#[test]
|
|
fn test_from_stdin() {
|
|
|
|
let input = "abcdefghijklmnopqrstuvwxyz\n";
|
|
let result = new_ucmd!().arg("--endian=little").run_piped_stdin(input.as_bytes());
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, unindent(ALPHA_OUT));
|
|
|
|
}
|
|
|
|
// Test that od reads from stdin and also from files
|
|
#[test]
|
|
fn test_from_mixed() {
|
|
|
|
let temp = env::temp_dir();
|
|
let tmpdir = Path::new(&temp);
|
|
let file1 = tmpdir.join("test-1");
|
|
let file3 = tmpdir.join("test-3");
|
|
|
|
let (data1, data2, data3) = ("abcdefg","hijklmnop","qrstuvwxyz\n");
|
|
for &(path,data)in &[(&file1, data1),(&file3, data3)] {
|
|
let mut f = File::create(&path).unwrap();
|
|
match f.write_all(data.as_bytes()) {
|
|
Err(_) => panic!("Test setup failed - could not write file"),
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
let result = new_ucmd!().arg("--endian=little").arg(file1.as_os_str()).arg("--").arg(file3.as_os_str()).run_piped_stdin(data2.as_bytes());
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, unindent(ALPHA_OUT));
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn test_multiple_formats() {
|
|
|
|
let input = "abcdefghijklmnopqrstuvwxyz\n";
|
|
let result = new_ucmd!().arg("-c").arg("-b").run_piped_stdin(input.as_bytes());
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, unindent("
|
|
0000000 a b c d e f g h i j k l m n o p
|
|
141 142 143 144 145 146 147 150 151 152 153 154 155 156 157 160
|
|
0000020 q r s t u v w x y z \\n
|
|
161 162 163 164 165 166 167 170 171 172 012
|
|
0000033
|
|
"));
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn test_dec() {
|
|
|
|
let input = [
|
|
0u8, 0u8,
|
|
1u8, 0u8,
|
|
2u8, 0u8,
|
|
3u8, 0u8,
|
|
0xffu8,0x7fu8,
|
|
0x00u8,0x80u8,
|
|
0x01u8,0x80u8,];
|
|
let expected_output = unindent("
|
|
0000000 0 1 2 3 32767 -32768 -32767
|
|
0000016
|
|
");
|
|
let result = new_ucmd!().arg("--endian=little").arg("-i").run_piped_stdin(&input[..]);
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, expected_output);
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn test_hex16(){
|
|
|
|
let input : [u8; 9] = [
|
|
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xff];
|
|
let expected_output = unindent("
|
|
0000000 2301 6745 ab89 efcd 00ff
|
|
0000011
|
|
");
|
|
let result = new_ucmd!().arg("--endian=little").arg("-x").run_piped_stdin(&input[..]);
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, expected_output);
|
|
}
|
|
|
|
#[test]
|
|
fn test_hex32(){
|
|
|
|
let input : [u8; 9] = [
|
|
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xff];
|
|
let expected_output = unindent("
|
|
0000000 67452301 efcdab89 000000ff
|
|
0000011
|
|
");
|
|
let result = new_ucmd!().arg("--endian=little").arg("-X").run_piped_stdin(&input[..]);
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, expected_output);
|
|
}
|
|
|
|
#[test]
|
|
fn test_f32(){
|
|
|
|
let input : [u8; 28] = [
|
|
0x52, 0x06, 0x9e, 0xbf, // 0xbf9e0652 -1.2345679
|
|
0x4e, 0x61, 0x3c, 0x4b, // 0x4b3c614e 12345678
|
|
0x0f, 0x9b, 0x94, 0xfe, // 0xfe949b0f -9.876543E37
|
|
0x00, 0x00, 0x00, 0x80, // 0x80000000 -0.0
|
|
0xff, 0xff, 0xff, 0x7f, // 0x7fffffff NaN
|
|
0xc2, 0x16, 0x01, 0x00, // 0x000116c2 1e-40
|
|
0x00, 0x00, 0x7f, 0x80];// 0x807f0000 -1.1663108E-38
|
|
let expected_output = unindent("
|
|
0000000 -1.2345679 12345678 -9.8765427e37 -0
|
|
0000020 NaN 1e-40 -1.1663108e-38
|
|
0000034
|
|
");
|
|
let result = new_ucmd!().arg("--endian=little").arg("-f").run_piped_stdin(&input[..]);
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, expected_output);
|
|
}
|
|
|
|
#[test]
|
|
fn test_f64(){
|
|
|
|
let input : [u8; 40] = [
|
|
0x27, 0x6b, 0x0a, 0x2f, 0x2a, 0xee, 0x45, 0x43, // 0x4345EE2A2F0A6B27 12345678912345678
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000000 0
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x80, // 0x8010000000000000 -2.2250738585072014e-308
|
|
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000001 5e-324 (subnormal)
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0];// 0xc000000000000000 -2
|
|
let expected_output = unindent("
|
|
0000000 12345678912345678 0
|
|
0000020 -2.2250738585072014e-308 5e-324
|
|
0000040 -2.0000000000000000
|
|
0000050
|
|
");
|
|
let result = new_ucmd!().arg("--endian=little").arg("-F").run_piped_stdin(&input[..]);
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, expected_output);
|
|
}
|
|
|
|
// We don't support multibyte chars, so big NEIN to this
|
|
/*
|
|
#[test]
|
|
fn mit_die_umlauten_getesten() {
|
|
let result = new_ucmd!()
|
|
.run_piped_stdin("Universität Tübingen".as_bytes());
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout,
|
|
"0000000 U n i v e r s i t ä ** t T ü **\n0000020 b i n g e n\n0000026")
|
|
}
|
|
*/
|
|
|
|
#[test]
|
|
fn test_width(){
|
|
|
|
let input : [u8; 8] = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
|
|
let expected_output = unindent("
|
|
0000000 000000 000000
|
|
0000004 000000 000000
|
|
0000010
|
|
");
|
|
|
|
let result = new_ucmd!().arg("-w4").arg("-v").run_piped_stdin(&input[..]);
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, expected_output);
|
|
}
|
|
|
|
#[test]
|
|
fn test_invalid_width(){
|
|
|
|
let input : [u8; 4] = [0x00, 0x00, 0x00, 0x00];
|
|
let expected_output = unindent("
|
|
0000000 000000
|
|
0000002 000000
|
|
0000004
|
|
");
|
|
|
|
let result = new_ucmd!().arg("-w5").arg("-v").run_piped_stdin(&input[..]);
|
|
|
|
assert_eq!(result.stderr, "od: warning: invalid width 5; using 2 instead\n");
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, expected_output);
|
|
}
|
|
|
|
#[test]
|
|
fn test_width_without_value(){
|
|
|
|
let input : [u8; 40] = [0 ; 40];
|
|
let expected_output = unindent("
|
|
0000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000 000000
|
|
0000040 000000 000000 000000 000000
|
|
0000050
|
|
");
|
|
|
|
let result = new_ucmd!().arg("-w").run_piped_stdin(&input[..]);
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, expected_output);
|
|
}
|
|
|
|
#[test]
|
|
fn test_suppress_duplicates(){
|
|
|
|
let input = [0u8 ; 41];
|
|
let expected_output = unindent("
|
|
0000000 000000000000
|
|
0000 0000
|
|
*
|
|
0000050 000000000000
|
|
0000
|
|
0000051
|
|
");
|
|
|
|
let result = new_ucmd!().arg("-w4").arg("-O").arg("-x").run_piped_stdin(&input[..]);
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, expected_output);
|
|
}
|
|
|
|
#[test]
|
|
fn test_big_endian() {
|
|
|
|
let input : [u8; 8] = [
|
|
0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];// 0xc000000000000000 -2
|
|
let expected_output = unindent("
|
|
0000000 -2.0000000000000000
|
|
-2.0000000 0
|
|
c0000000 00000000
|
|
c000 0000 0000 0000
|
|
0000010
|
|
");
|
|
let result = new_ucmd!().arg("--endian=big").arg("-F").arg("-f").arg("-X").arg("-x").run_piped_stdin(&input[..]);
|
|
|
|
assert_empty_stderr!(result);
|
|
assert!(result.success);
|
|
assert_eq!(result.stdout, expected_output);
|
|
}
|