diff --git a/Cargo.lock b/Cargo.lock index b2fa9e8b..72978580 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -20,12 +20,56 @@ dependencies = [ "libc", ] +[[package]] +name = "anstream" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + [[package]] name = "anstyle" version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" +[[package]] +name = "anstyle-parse" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d" +dependencies = [ + "anstyle", + "once_cell_polyfill", + "windows-sys", +] + [[package]] name = "anyhow" version = "1.0.104" @@ -41,21 +85,6 @@ dependencies = [ "num-traits", ] -[[package]] -name = "assert_cmd" -version = "2.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2aa3a22042e45de04255c7bf3626e239f450200fd0493c1e382263544b20aea6" -dependencies = [ - "anstyle", - "bstr", - "libc", - "predicates", - "predicates-core", - "predicates-tree", - "wait-timeout", -] - [[package]] name = "autocfg" version = "1.5.1" @@ -68,17 +97,6 @@ version = "2.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" -[[package]] -name = "bstr" -version = "1.13.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6bb31b46c14244e20ee9984b11bf5c992b91fb6939fea616e3512c8baecdbe5f" -dependencies = [ - "memchr", - "regex-automata", - "serde_core", -] - [[package]] name = "bumpalo" version = "3.20.3" @@ -146,8 +164,10 @@ version = "4.6.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" dependencies = [ + "anstream", "anstyle", "clap_lex", + "strsim", "terminal_size", ] @@ -198,7 +218,7 @@ dependencies = [ "proc-macro-crate", "proc-macro2", "quote", - "syn", + "syn 2.0.119", ] [[package]] @@ -216,6 +236,12 @@ dependencies = [ "regex-lite", ] +[[package]] +name = "colorchoice" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570" + [[package]] name = "colored" version = "3.1.1" @@ -247,33 +273,55 @@ dependencies = [ ] [[package]] -name = "diff" -version = "0.1.13" +name = "ctor" +version = "1.0.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8" +checksum = "914a755b7c2d4af2bdcff7ce1739e2db9a1b81a9b07123d8015786ae03c0980d" +dependencies = [ + "link-section", + "linktime-proc-macro", +] [[package]] -name = "difflib" -version = "0.4.0" +name = "deranged" +version = "0.5.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8" +checksum = "9e9de72ce2ad1f90dc62fa25f0f430ef85eb4b0d8fa0be4f30373bc40a21d28e" + +[[package]] +name = "diff" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8" [[package]] name = "diffutils" version = "0.6.0" dependencies = [ - "assert_cmd", "chrono", "codspeed-divan-compat", + "ctor", "diff", "itoa", - "predicates", "pretty_assertions", "rand", "regex", + "rstest", "same-file", "tempfile", "unicode-width", + "uutests", +] + +[[package]] +name = "displaydoc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", ] [[package]] @@ -284,7 +332,19 @@ checksum = "8dc51d98e636f5e3b0759a39257458b22619cac7e96d932da6eeb052891bb67c" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.119", +] + +[[package]] +name = "dns-lookup" +version = "4.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "263c0ccfc6b3b6a93e959edad4f985779e76c0b36dbb2e13e3d27c690974adf1" +dependencies = [ + "cfg-if", + "libc", + "socket2", + "windows-sys", ] [[package]] @@ -322,12 +382,48 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1c66915cc5391097de7a2b0b972e8505aa33c0df401fd3a6811dbdb32881ba48" [[package]] -name = "float-cmp" -version = "0.10.0" +name = "fluent" +version = "0.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b09cf3155332e944990140d967ff5eceb70df778b34f77d8075db46e4704e6d8" +checksum = "8137a6d5a2c50d6b0ebfcb9aaa91a28154e0a70605f112d30cb0cd4a78670477" dependencies = [ - "num-traits", + "fluent-bundle", + "unic-langid", +] + +[[package]] +name = "fluent-bundle" +version = "0.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01203cb8918f5711e73891b347816d932046f95f54207710bda99beaeb423bf4" +dependencies = [ + "fluent-langneg", + "fluent-syntax", + "intl-memoizer", + "intl_pluralrules", + "rustc-hash", + "self_cell", + "smallvec", + "unic-langid", +] + +[[package]] +name = "fluent-langneg" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7eebbe59450baee8282d71676f3bfed5689aeab00b27545e83e5f14b1195e8b0" +dependencies = [ + "unic-langid", +] + +[[package]] +name = "fluent-syntax" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "54f0d287c53ffd184d04d8677f590f4ac5379785529e5e08b1c8083acdd5c198" +dependencies = [ + "memchr", + "thiserror", ] [[package]] @@ -342,6 +438,12 @@ version = "0.3.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd" +[[package]] +name = "futures-timer" +version = "3.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af43fadb8a98512d547e37b4e92e0ced13e205c061b87b4623eff01d918d6968" + [[package]] name = "futures-util" version = "0.3.34" @@ -412,6 +514,31 @@ dependencies = [ "hashbrown", ] +[[package]] +name = "intl-memoizer" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "310da2e345f5eb861e7a07ee182262e94975051db9e4223e909ba90f392f163f" +dependencies = [ + "type-map", + "unic-langid", +] + +[[package]] +name = "intl_pluralrules" +version = "7.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "078ea7b7c29a2b4df841a7f6ac8775ff6074020c6776d48491ce2268e068f972" +dependencies = [ + "unic-langid", +] + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695" + [[package]] name = "itertools" version = "0.14.0" @@ -427,6 +554,58 @@ version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" +[[package]] +name = "jiff" +version = "0.2.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fefca06093eeaed707a905795e68206da0edca4edef23d2a3997a3ddbee462aa" +dependencies = [ + "jiff-core", + "jiff-static", + "jiff-tzdb-platform", + "log", + "portable-atomic", + "portable-atomic-util", + "serde_core", + "windows-link", +] + +[[package]] +name = "jiff-core" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77a24020db0ee88d1c681d677681bd31f9f4ea189a455425223d52ce4f1508aa" +dependencies = [ + "log", +] + +[[package]] +name = "jiff-static" +version = "0.2.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d3213549742662eea1a18e6c5af9be5dfbabeb7611ab71356a54928ec398f0" +dependencies = [ + "jiff-core", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "jiff-tzdb" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa8377070c6bae868759445e5a77f66d84f0b72f3a054bfb00e6d038b8282da7" + +[[package]] +name = "jiff-tzdb-platform" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8" +dependencies = [ + "jiff-tzdb", +] + [[package]] name = "js-sys" version = "0.3.104" @@ -444,6 +623,18 @@ version = "0.2.191" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a" +[[package]] +name = "link-section" +version = "0.19.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39c29a617ce3df32c08497bdc1ab6e2376e0b17948ac166a2fbe5977c5954cd9" + +[[package]] +name = "linktime-proc-macro" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e57c38c1e860fd37c604281cdfb1dd2216977fd76a50f85ba2f388ef3219616" + [[package]] name = "linux-raw-sys" version = "0.12.1" @@ -475,10 +666,10 @@ dependencies = [ ] [[package]] -name = "normalize-line-endings" -version = "0.3.0" +name = "num-conv" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be" +checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441" [[package]] name = "num-traits" @@ -489,6 +680,15 @@ dependencies = [ "autocfg", ] +[[package]] +name = "num_threads" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cabcc654086861f9e1bc5115258de62ef92c79b20f4615a1b0cc57c4e82027d4" +dependencies = [ + "libc", +] + [[package]] name = "once_cell" version = "1.21.4" @@ -496,41 +696,47 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" [[package]] -name = "pin-project-lite" -version = "0.2.17" +name = "once_cell_polyfill" +version = "1.70.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" +checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe" [[package]] -name = "predicates" -version = "3.1.4" +name = "os_display" +version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ada8f2932f28a27ee7b70dd6c1c39ea0675c55a36879ab92f3a715eaa1e63cfe" +checksum = "ad5fd71b79026fb918650dde6d125000a233764f1c2f1659a1c71118e33ea08f" dependencies = [ - "anstyle", - "difflib", - "float-cmp", - "normalize-line-endings", - "predicates-core", - "regex", + "unicode-width", ] [[package]] -name = "predicates-core" -version = "1.0.10" +name = "pin-project-lite" +version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cad38746f3166b4031b1a0d39ad9f954dd291e7854fcc0eed52ee41a0b50d144" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" [[package]] -name = "predicates-tree" -version = "1.0.13" +name = "portable-atomic" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85" + +[[package]] +name = "portable-atomic-util" +version = "0.2.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d0de1b847b39c8131db0467e9df1ff60e6d0562ab8e9a16e568ad0fdb372e2f2" +checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715" dependencies = [ - "predicates-core", - "termtree", + "portable-atomic", ] +[[package]] +name = "powerfmt" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a6394b9e965e73d0a289ee54f589087e2c676aedf60885baf52c76b771e4958" + [[package]] name = "pretty_assertions" version = "1.4.1" @@ -626,6 +832,65 @@ version = "0.8.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" +[[package]] +name = "relative-path" +version = "1.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2" + +[[package]] +name = "rlimit" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f35ee2729c56bb610f6dba436bf78135f728b7373bdffae2ec815b2d3eb98cc3" +dependencies = [ + "libc", +] + +[[package]] +name = "rstest" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b376e512f30a7686a8dbc6aeaace99b3ade1c26c1c63473473a817ade226dafc" +dependencies = [ + "futures-timer", + "futures-util", + "rstest_macros", +] + +[[package]] +name = "rstest_macros" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88512dbfb5b73a0dfa38aef7bc73b5657035fce477b923faf12d332dd83051ea" +dependencies = [ + "cfg-if", + "glob", + "proc-macro-crate", + "proc-macro2", + "quote", + "regex", + "relative-path", + "rustc_version", + "syn 2.0.119", + "unicode-ident", +] + +[[package]] +name = "rustc-hash" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d" + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + [[package]] name = "rustix" version = "1.1.5" @@ -654,6 +919,18 @@ dependencies = [ "winapi-util", ] +[[package]] +name = "self_cell" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ab42ca02749e120097e328d91d415325bdf43b1c72c4c8badf37375fe40a813" + +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" + [[package]] name = "serde" version = "1.0.228" @@ -681,7 +958,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.119", ] [[package]] @@ -709,6 +986,22 @@ version = "0.4.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" +[[package]] +name = "smallvec" +version = "1.16.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "149309498a5f7334b12ddae0cad8aba81ce785fe91755068867e017cf98fee46" + +[[package]] +name = "socket2" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4" +dependencies = [ + "libc", + "windows-sys", +] + [[package]] name = "statrs" version = "0.18.0" @@ -719,6 +1012,12 @@ dependencies = [ "num-traits", ] +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + [[package]] name = "syn" version = "2.0.119" @@ -730,6 +1029,17 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "syn" +version = "3.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ae9ccbea3a7b0b09443036490c8f34a8b1b760fd345e5c0dae0aac718faea79" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + [[package]] name = "tempfile" version = "3.27.0" @@ -754,10 +1064,67 @@ dependencies = [ ] [[package]] -name = "termtree" -version = "0.5.1" +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", +] + +[[package]] +name = "time" +version = "0.3.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134" +dependencies = [ + "deranged", + "libc", + "num-conv", + "num_threads", + "powerfmt", + "serde_core", + "time-core", + "time-macros", +] + +[[package]] +name = "time-core" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683" +checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109" + +[[package]] +name = "time-macros" +version = "0.2.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85" +dependencies = [ + "num-conv", + "time-core", +] + +[[package]] +name = "tinystr" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abc840c238154d58f9e86b2792261edfde565a17696e1cda1a449de27979801a" +dependencies = [ + "displaydoc", + "serde_core", + "zerovec", +] [[package]] name = "toml_datetime" @@ -789,6 +1156,33 @@ dependencies = [ "winnow", ] +[[package]] +name = "type-map" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb30dbbd9036155e74adad6812e9898d03ec374946234fbcebd5dfc7b9187b90" +dependencies = [ + "rustc-hash", +] + +[[package]] +name = "unic-langid" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a28ba52c9b05311f4f6e62d5d9d46f094bd6e84cb8df7b3ef952748d752a7d05" +dependencies = [ + "unic-langid-impl", +] + +[[package]] +name = "unic-langid-impl" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dce1bf08044d4b7a94028c93786f8566047edc11110595914de93362559bc658" +dependencies = [ + "tinystr", +] + [[package]] name = "unicode-ident" version = "1.0.27" @@ -802,12 +1196,62 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ca718471876992059f251e33aafc334346ada08042b7661dd1fe313a9bced557" [[package]] -name = "wait-timeout" -version = "0.2.1" +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "uucore" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f24a5910ebbf2c0baf486a9125705f8e026a8f7741a3ea8cf5eca3c9257c9bdf" +dependencies = [ + "clap", + "dns-lookup", + "fluent", + "fluent-syntax", + "jiff", + "libc", + "nix", + "os_display", + "rustc-hash", + "rustix", + "thiserror", + "time", + "unic-langid", + "unicode-width", + "uucore_procs", + "wild", + "windows-sys", +] + +[[package]] +name = "uucore_procs" +version = "0.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11" +checksum = "50aa1f3bba55168888ae6f1f2714ce58897d8020d742d21f474f01e86468fedd" dependencies = [ + "proc-macro2", + "quote", +] + +[[package]] +name = "uutests" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c47cf53a889f65f0c96eb4fcaaf29cc3a61ae1cef00860e0ca94e0ed4952ef7" +dependencies = [ + "ctor", "libc", + "nix", + "pretty_assertions", + "rand", + "regex", + "rlimit", + "tempfile", + "uucore", + "xattr", ] [[package]] @@ -842,7 +1286,7 @@ dependencies = [ "bumpalo", "proc-macro2", "quote", - "syn", + "syn 2.0.119", "wasm-bindgen-shared", ] @@ -855,6 +1299,15 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "wild" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3131afc8c575281e1e80f36ed6a092aa502c08b18ed7524e86fbbb12bb410e1" +dependencies = [ + "glob", +] + [[package]] name = "winapi-util" version = "0.1.11" @@ -885,7 +1338,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.119", ] [[package]] @@ -896,7 +1349,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.119", ] [[package]] @@ -941,12 +1394,38 @@ dependencies = [ "memchr", ] +[[package]] +name = "xattr" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156" +dependencies = [ + "libc", + "rustix", +] + [[package]] name = "yansi" version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049" +[[package]] +name = "zerofrom" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272" + +[[package]] +name = "zerovec" +version = "0.11.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f58a2799cfe9a1670c7ea8edbd52ef8edb93cb37a7f83bf31ba9e35d9dae6a40" +dependencies = [ + "serde", + "zerofrom", +] + [[package]] name = "zmij" version = "1.0.23" diff --git a/Cargo.toml b/Cargo.toml index 719a3118..5a433257 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,6 +5,8 @@ edition = "2021" description = "A CLI app for generating diff files" license = "MIT OR Apache-2.0" repository = "https://github.com/uutils/diffutils" +# test_common.rs and by-util/ are modules of tests/tests.rs +autotests = false [lib] name = "diffutilslib" @@ -23,12 +25,13 @@ same-file = "1.0.6" unicode-width = "0.2.0" [dev-dependencies] -assert_cmd = "2.0.14" +ctor = "1.0" divan = { version = "6.0.0", package = "codspeed-divan-compat" } pretty_assertions = "1.4.0" -predicates = "3.1.0" rand = "0.10.0" +rstest = "0.28.0" tempfile = "3.26.0" +uutests = "0.12.0" [profile.release] lto = "thin" @@ -39,6 +42,10 @@ panic = "abort" [profile.dist] inherits = "release" +[[test]] +name = "tests" +path = "tests/tests.rs" + [[bench]] name = "bench_diffutils" path = "benches/bench-diffutils.rs" diff --git a/tests/by-util/test_cmp.rs b/tests/by-util/test_cmp.rs index fd96a1ee..d7ad3a1f 100644 --- a/tests/by-util/test_cmp.rs +++ b/tests/by-util/test_cmp.rs @@ -3,588 +3,235 @@ // For the full copyright and license information, please view the LICENSE-* // files that was distributed with this source code. -use assert_cmd::cargo::cargo_bin_cmd; -use predicates::prelude::*; -use std::fs::File; +use rstest::rstest; #[cfg(not(windows))] use std::fs::OpenOptions; -use std::io::Write; -use tempfile::{tempdir, NamedTempFile}; +use uutests::{at_and_ts, new_ucmd}; // A file whose metadata length is 0 but which still yields bytes (/dev/zero) // collapses the offset column to two characters, so the padding subtraction // underflowed once the running offset reached three digits. #[test] #[cfg(unix)] -fn cmp_verbose_zero_length_metadata() -> Result<(), Box> { - let mut file = NamedTempFile::new()?; - file.write_all(&[0xffu8; 150])?; - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp") - .arg("--verbose") - .arg("/dev/zero") - .arg(file.path()); - cmd.assert() - .code(predicate::eq(1)) - .stdout(predicate::str::contains("150 0 377")); - Ok(()) +fn cmp_verbose_zero_length_metadata() { + let (at, ts) = at_and_ts!(); + at.write_bytes("file", &[0xffu8; 150]); + + ts.ucmd() + .args(&["--verbose", "/dev/zero", "file"]) + .fails_with_code(1) + .stdout_contains("150 0 377"); } // The offset column is as wide as the bytes left after the skips, as in GNU // cmp: 9 bytes are compared here, so the offsets take one column. #[test] -fn cmp_verbose_offset_width_after_skip() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let a_path = tmp_dir.path().join("a"); - let b_path = tmp_dir.path().join("b"); - File::create(&a_path)?.write_all(b"0123456789abcdefghijklmnopqrstuvwxyz")?; - File::create(&b_path)?.write_all(b"0123456789abcdefghijklmnopqrstuvwxyz")?; - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp") - .arg("-l") - .arg("--ignore-initial=27:26") - .arg(&a_path) - .arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .stdout(predicate::str::starts_with("1 162 161\n2 163 162\n")) - .stderr(predicate::str::ends_with(" after byte 9\n")); - Ok(()) +fn cmp_verbose_offset_width_after_skip() { + let (at, ts) = at_and_ts!(); + at.write("a", "0123456789abcdefghijklmnopqrstuvwxyz"); + at.write("b", "0123456789abcdefghijklmnopqrstuvwxyz"); + + ts.ucmd() + .args(&["-l", "--ignore-initial=27:26", "a", "b"]) + .fails_with_code(1) + .stdout_str_check(|s| s.starts_with("1 162 161\n2 163 162\n")) + .stderr_str_check(|s| s.ends_with(" after byte 9\n")); } #[test] -fn cmp_incompatible_params() -> Result<(), Box> { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg("-l"); - cmd.arg("-s"); - cmd.arg("/etc/passwd").arg("/etc/group"); - cmd.assert() - .code(predicate::eq(2)) - .failure() - .stderr(predicate::str::ends_with( - ": options -l and -s are incompatible\n", - )); - - Ok(()) +fn cmp_incompatible_params() { + new_ucmd!() + .args(&["-l", "-s", "/etc/passwd", "/etc/group"]) + .fails_with_code(2) + .stderr_str_check(|s| s.ends_with(": options -l and -s are incompatible\n")); } -#[test] -fn cmp_stdin() -> Result<(), Box> { - let tmp_dir = tempdir()?; - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(b"a\n").unwrap(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg(&a_path); - cmd.write_stdin("a\n"); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::is_empty()); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg(&a_path); - cmd.write_stdin("b\n"); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::ends_with(" - differ: char 1, line 1\n")); - - Ok(()) +#[rstest] +#[case::equal("a\n", 0, "")] +#[case::different("b\n", 1, "a - differ: char 1, line 1\n")] +fn cmp_stdin(#[case] input: &str, #[case] code: i32, #[case] expected: &str) { + let (at, ts) = at_and_ts!(); + at.write("a", "a\n"); + + ts.ucmd() + .arg("a") + .pipe_in(input) + .run() + .code_is(code) + .stdout_only(expected); } #[test] -fn cmp_equal_files() -> Result<(), Box> { - let tmp_dir = tempdir()?; - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(b"a\n").unwrap(); - - let b_path = tmp_dir.path().join("b"); - let mut b = File::create(&b_path).unwrap(); - b.write_all(b"a\n").unwrap(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::is_empty()); - - Ok(()) -} +fn cmp_equal_files() { + let (at, ts) = at_and_ts!(); + at.write("a", "a\n"); + at.write("b", "a\n"); -#[test] -fn cmp_one_file_empty() -> Result<(), Box> { - let tmp_dir = tempdir()?; - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(b"a\n").unwrap(); - - let b_path = tmp_dir.path().join("b"); - let _ = File::create(&b_path).unwrap(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::contains(" EOF on ")) - .stderr(predicate::str::ends_with(" which is empty\n")); - - Ok(()) + ts.ucmd().args(&["a", "b"]).succeeds().no_output(); } #[test] -fn cmp_immediate_difference() -> Result<(), Box> { - let tmp_dir = tempdir()?; - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(b"abc\n").unwrap(); - - let b_path = tmp_dir.path().join("b"); - let mut b = File::create(&b_path).unwrap(); - b.write_all(b"bcd\n").unwrap(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stdout(predicate::str::ends_with(" differ: char 1, line 1\n")); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg("-b"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::ends_with( - " differ: byte 1, line 1 is 141 a 142 b\n", - )); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg("-l"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::eq("1 141 142\n2 142 143\n3 143 144\n")); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg("-l"); - cmd.arg("-b"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::eq( - "1 141 a 142 b\n2 142 b 143 c\n3 143 c 144 d\n", - )); - - Ok(()) +fn cmp_one_file_empty() { + let (at, ts) = at_and_ts!(); + at.write("a", "a\n"); + at.touch("b"); + + ts.ucmd() + .args(&["a", "b"]) + .fails_with_code(1) + .stderr_contains(" EOF on ") + .stderr_str_check(|s| s.ends_with(" which is empty\n")); } -#[test] -fn cmp_newline_difference() -> Result<(), Box> { - let tmp_dir = tempdir()?; - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(b"abc\ndefg").unwrap(); - - let b_path = tmp_dir.path().join("b"); - let mut b = File::create(&b_path).unwrap(); - b.write_all(b"abc\ndef\ng").unwrap(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::ends_with(" differ: char 8, line 2\n")); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg("-b"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::ends_with( - " differ: byte 8, line 2 is 147 g 12 ^J\n", - )); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg("-l"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stdout(predicate::str::starts_with("8 147 12\n")) - .stderr(predicate::str::contains(" EOF on")) - .stderr(predicate::str::ends_with(" after byte 8\n")); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg("-b"); - cmd.arg("-l"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stdout(predicate::str::starts_with("8 147 g 12 ^J\n")) - .stderr(predicate::str::contains(" EOF on")) - .stderr(predicate::str::ends_with(" after byte 8\n")); - - Ok(()) +#[rstest] +#[case::default(&[], "a b differ: char 1, line 1\n")] +#[case::print_bytes(&["-b"], "a b differ: byte 1, line 1 is 141 a 142 b\n")] +#[case::verbose(&["-l"], "1 141 142\n2 142 143\n3 143 144\n")] +#[case::verbose_print_bytes( + &["-l", "-b"], + "1 141 a 142 b\n2 142 b 143 c\n3 143 c 144 d\n" +)] +fn cmp_immediate_difference(#[case] options: &[&str], #[case] expected: &str) { + let (at, ts) = at_and_ts!(); + at.write("a", "abc\n"); + at.write("b", "bcd\n"); + + ts.ucmd() + .args(options) + .args(&["a", "b"]) + .fails_with_code(1) + .stdout_only(expected); } -#[test] -fn cmp_max_bytes() -> Result<(), Box> { - let tmp_dir = tempdir()?; - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(b"abc efg ijkl\n").unwrap(); - - let b_path = tmp_dir.path().join("b"); - let mut b = File::create(&b_path).unwrap(); - b.write_all(b"abcdefghijkl\n").unwrap(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg("-l"); - cmd.arg("-b"); - cmd.arg("-n"); - cmd.arg("3"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::is_empty()); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg("-l"); - cmd.arg("-b"); - cmd.arg("-n"); - cmd.arg("4"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::eq("4 40 144 d\n")); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg("-l"); - cmd.arg("-b"); - cmd.arg("-n"); - cmd.arg("13"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::eq(" 4 40 144 d\n 8 40 150 h\n")); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg("-l"); - cmd.arg("-b"); - cmd.arg("-n"); - cmd.arg("1K"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::eq(" 4 40 144 d\n 8 40 150 h\n")); - Ok(()) +#[rstest] +#[case::default(&[], "a b differ: char 8, line 2\n", None)] +#[case::print_bytes(&["-b"], "a b differ: byte 8, line 2 is 147 g 12 ^J\n", None)] +#[case::verbose(&["-l"], "8 147 12\n", Some(" after byte 8\n"))] +#[case::verbose_print_bytes(&["-b", "-l"], "8 147 g 12 ^J\n", Some(" after byte 8\n"))] +fn cmp_newline_difference( + #[case] options: &[&str], + #[case] expected: &str, + #[case] eof: Option<&str>, +) { + let (at, ts) = at_and_ts!(); + at.write("a", "abc\ndefg"); + at.write("b", "abc\ndef\ng"); + + let result = ts.ucmd().args(options).args(&["a", "b"]).fails_with_code(1); + result.stdout_is(expected); + match eof { + Some(eof) => result + .stderr_contains(" EOF on") + .stderr_str_check(|s| s.ends_with(eof)), + None => result.no_stderr(), + }; } -#[test] -fn cmp_skip_args_parsing() -> Result<(), Box> { - let tmp_dir = tempdir()?; - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(b"---abc\n").unwrap(); - - let b_path = tmp_dir.path().join("b"); - let mut b = File::create(&b_path).unwrap(); - b.write_all(b"###abc\n").unwrap(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg("-i"); - cmd.arg("3"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::is_empty()); - - // A smaller positional skip does not override -i - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg("-i"); - cmd.arg("3"); - cmd.arg(&a_path).arg(&b_path); - cmd.arg("1").arg("1"); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::is_empty()); - - // Single positional argument should only affect first file. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg(&a_path).arg(&b_path); - cmd.arg("3"); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::ends_with(" differ: char 1, line 1\n")); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg(&a_path).arg(&b_path); - cmd.arg("3"); - cmd.arg("3"); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::is_empty()); - - Ok(()) +// -n limits the comparison, -i skips the start of both files. +#[rstest] +#[case::max_bytes_before_difference(&["-l", "-b", "-n", "3"], 0, "")] +#[case::max_bytes_at_difference(&["-l", "-b", "-n", "4"], 1, "4 40 144 d\n")] +#[case::max_bytes(&["-l", "-b", "-n", "13"], 1, " 4 40 144 d\n 8 40 150 h\n")] +#[case::max_bytes_suffix(&["-l", "-b", "-n", "1K"], 1, " 4 40 144 d\n 8 40 150 h\n")] +#[case::skip_past_differences(&["-l", "-b", "-i", "8"], 0, "")] +#[case::skip(&["-b", "-i", "4"], 1, "a b differ: byte 4, line 1 is 40 150 h\n")] +fn cmp_max_bytes_and_skip(#[case] options: &[&str], #[case] code: i32, #[case] expected: &str) { + let (at, ts) = at_and_ts!(); + at.write("a", "abc efg ijkl\n"); + at.write("b", "abcdefghijkl\n"); + + ts.ucmd() + .args(options) + .args(&["a", "b"]) + .run() + .code_is(code) + .stdout_only(expected); } -#[test] -fn cmp_skip_uses_larger_of_option_and_positional() -> Result<(), Box> { - let tmp_dir = tempdir()?; - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(b"12345xyz\n").unwrap(); - - let b_path = tmp_dir.path().join("b"); - let mut b = File::create(&b_path).unwrap(); - b.write_all(b"abcdexyz\n").unwrap(); - - // Like GNU cmp, the larger of -i and the positional skip wins. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg("-i"); - cmd.arg("1"); - cmd.arg(&a_path).arg(&b_path); - cmd.arg("5").arg("5"); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::is_empty()); - - // The same applies when -i is given more than once. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg("-i"); - cmd.arg("5"); - cmd.arg("--ignore-initial=1"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::is_empty()); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("LC_ALL", "C"); - cmd.arg("cmp"); - cmd.arg("-i"); - cmd.arg("1"); - cmd.arg(&a_path).arg(&b_path); - cmd.arg("2").arg("2"); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::ends_with(" differ: char 1, line 1\n")); - - Ok(()) +#[rstest] +#[case::option(&["-i", "3", "a", "b"], 0)] +// A smaller positional skip does not override -i +#[case::smaller_positional(&["-i", "3", "a", "b", "1", "1"], 0)] +// Single positional argument should only affect first file. +#[case::single_positional(&["a", "b", "3"], 1)] +#[case::positionals(&["a", "b", "3", "3"], 0)] +fn cmp_skip_args_parsing(#[case] args: &[&str], #[case] code: i32) { + let (at, ts) = at_and_ts!(); + at.write("a", "---abc\n"); + at.write("b", "###abc\n"); + + let expected = if code == 0 { + "" + } else { + "a b differ: char 1, line 1\n" + }; + ts.ucmd() + .args(args) + .run() + .code_is(code) + .stdout_only(expected); } -#[test] -fn cmp_skip_suffix_parsing() -> Result<(), Box> { - let tmp_dir = tempdir()?; - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - writeln!(a, "{}c", "a".repeat(1024)).unwrap(); - a.flush().unwrap(); - - let b_path = tmp_dir.path().join("b"); - let mut b = File::create(&b_path).unwrap(); - writeln!(b, "{}c", "b".repeat(1024)).unwrap(); - b.flush().unwrap(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg("--ignore-initial=1K"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::is_empty()); - - Ok(()) +// Like GNU cmp, the larger of -i and the positional skip wins. +#[rstest] +#[case::larger_positional(&["-i", "1", "a", "b", "5", "5"], 0)] +// The same applies when -i is given more than once. +#[case::repeated_option(&["-i", "5", "--ignore-initial=1", "a", "b"], 0)] +#[case::both_too_small(&["-i", "1", "a", "b", "2", "2"], 1)] +fn cmp_skip_uses_larger_of_option_and_positional(#[case] args: &[&str], #[case] code: i32) { + let (at, ts) = at_and_ts!(); + at.write("a", "12345xyz\n"); + at.write("b", "abcdexyz\n"); + + let expected = if code == 0 { + "" + } else { + "a b differ: char 1, line 1\n" + }; + ts.ucmd() + .args(args) + .run() + .code_is(code) + .stdout_only(expected); } #[test] -fn cmp_skip() -> Result<(), Box> { - let tmp_dir = tempdir()?; - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(b"abc efg ijkl\n").unwrap(); - - let b_path = tmp_dir.path().join("b"); - let mut b = File::create(&b_path).unwrap(); - b.write_all(b"abcdefghijkl\n").unwrap(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg("-l"); - cmd.arg("-b"); - cmd.arg("-i"); - cmd.arg("8"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::is_empty()); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg("-b"); - cmd.arg("-i"); - cmd.arg("4"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::ends_with( - " differ: byte 4, line 1 is 40 150 h\n", - )); - - Ok(()) +fn cmp_skip_suffix_parsing() { + let (at, ts) = at_and_ts!(); + at.write("a", &format!("{}c\n", "a".repeat(1024))); + at.write("b", &format!("{}c\n", "b".repeat(1024))); + + ts.ucmd() + .args(&["--ignore-initial=1K", "a", "b"]) + .succeeds() + .no_output(); } #[test] -fn cmp_print_bytes_high_byte() -> Result<(), Box> { - let tmp_dir = tempdir()?; - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(b"a").unwrap(); - - let b_path = tmp_dir.path().join("b"); - let mut b = File::create(&b_path).unwrap(); - b.write_all(&[0xC3]).unwrap(); +fn cmp_print_bytes_high_byte() { + let (at, ts) = at_and_ts!(); + at.write("a", "a"); + at.write_bytes("b", &[0xC3]); // GNU cmp does not pad the printed bytes, whatever the second byte is. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg("-b"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::ends_with( - " differ: byte 1, line 1 is 141 a 303 M-C\n", - )); - - Ok(()) + ts.ucmd() + .args(&["-b", "a", "b"]) + .fails_with_code(1) + .stdout_only("a b differ: byte 1, line 1 is 141 a 303 M-C\n"); } #[test] -fn cmp_binary() -> Result<(), Box> { - let tmp_dir = tempdir()?; - +fn cmp_binary() { + let (at, ts) = at_and_ts!(); let mut bytes = vec![0, 15, 31, 32, 33, 40, 64, 126, 127, 128, 129, 200, 254, 255]; - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(&bytes).unwrap(); - + at.write_bytes("a", &bytes); bytes.reverse(); + at.write_bytes("b", &bytes); - let b_path = tmp_dir.path().join("b"); - let mut b = File::create(&b_path).unwrap(); - b.write_all(&bytes).unwrap(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg("-l"); - cmd.arg("-b"); - cmd.arg(&a_path).arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stdout(predicate::eq(concat!( + ts.ucmd() + .args(&["-l", "-b", "a", "b"]) + .fails_with_code(1) + .stdout_is(concat!( " 1 0 ^@ 377 M-^?\n", " 2 17 ^O 376 M-~\n", " 3 37 ^_ 310 M-H\n", @@ -599,65 +246,50 @@ fn cmp_binary() -> Result<(), Box> { "12 310 M-H 37 ^_\n", "13 376 M-~ 17 ^O\n", "14 377 M-^? 0 ^@\n" - ))); - - Ok(()) + )); } #[test] #[cfg(not(windows))] -fn cmp_fast_paths() -> Result<(), Box> { - let tmp_dir = tempdir()?; +fn cmp_fast_paths() { + // Bound the runtime to a very short time that still allows for some resource + // constraint to slow it down while also allowing very fast systems to exit as + // early as possible. + const MAX_TRIES: u8 = 50; + + let (at, ts) = at_and_ts!(); // This test mimics one found in the GNU cmp test suite. It is used for // validating the /dev/null optimization. - let a_path = tmp_dir.path().join("a"); - let a = File::create(&a_path).unwrap(); - a.set_len(14 * 1024 * 1024 * 1024 * 1024).unwrap(); - - let b_path = tmp_dir.path().join("b"); - let b = File::create(&b_path).unwrap(); - b.set_len(15 * 1024 * 1024 * 1024 * 1024).unwrap(); + at.make_file("a") + .set_len(14 * 1024 * 1024 * 1024 * 1024) + .unwrap(); + at.make_file("b") + .set_len(15 * 1024 * 1024 * 1024 * 1024) + .unwrap(); let dev_null = OpenOptions::new().write(true).open("/dev/null").unwrap(); - let mut child = std::process::Command::new(assert_cmd::cargo::cargo_bin!("diffutils")) - .arg("cmp") - .arg(&a_path) - .arg(&b_path) - .stdout(dev_null) - .spawn() - .unwrap(); + let mut child = ts + .ucmd() + .args(&["a", "b"]) + .set_stdout(dev_null) + .run_no_wait(); - // Bound the runtime to a very short time that still allows for some resource - // constraint to slow it down while also allowing very fast systems to exit as - // early as possible. - const MAX_TRIES: u8 = 50; for tries in 0..=MAX_TRIES { - if tries == MAX_TRIES { - panic!("cmp took too long to run, /dev/null optimization probably not working") - } - match child.try_wait() { - Ok(Some(status)) => { - assert_eq!(status.code(), Some(1)); - break; - } - Ok(None) => (), - Err(e) => panic!("{e:#?}"), + assert!( + tries < MAX_TRIES, + "cmp took too long to run, /dev/null optimization probably not working" + ); + if !child.is_alive() { + break; } std::thread::sleep(std::time::Duration::from_millis(10)); } + child.wait().unwrap().code_is(1); // Two stdins should be equal - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg("-"); - cmd.arg("-"); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stdout(predicate::str::is_empty()) - .stderr(predicate::str::is_empty()); + ts.ucmd().args(&["-", "-"]).succeeds().no_output(); // Files with longer than block size equal segments should still report // the correct line number for the difference. Assumes 8KB block size (see @@ -666,70 +298,41 @@ fn cmp_fast_paths() -> Result<(), Box> { let mut bytes = " ".repeat(4095); bytes.push('\n'); bytes.push_str(&" ".repeat(4096)); - let bytes = bytes.repeat(3); - let bytes = bytes.as_bytes(); - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(bytes).unwrap(); - a.write_all(b"A").unwrap(); - - let b_path = tmp_dir.path().join("b"); - let mut b = File::create(&b_path).unwrap(); - b.write_all(bytes).unwrap(); - b.write_all(b"B").unwrap(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("cmp"); - cmd.arg(&a_path).arg(&b_path); - cmd.env("LC_ALL", "en_US"); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stdout(predicate::str::ends_with(" differ: byte 24577, line 4\n")); - - Ok(()) + + at.write("a", &format!("{bytes}A")); + at.write("b", &format!("{bytes}B")); + + ts.ucmd() + .args(&["a", "b"]) + .env("LC_ALL", "en_US") + .fails_with_code(1) + .stdout_str_check(|s| s.ends_with(" differ: byte 24577, line 4\n")); } -#[test] -fn cmp_difference_term_follows_messages_locale() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let a_path = tmp_dir.path().join("a"); - let b_path = tmp_dir.path().join("b"); - std::fs::write(&a_path, "abc\n")?; - std::fs::write(&b_path, "bcd\n")?; - - // LC_ALL overrides LC_MESSAGES, which overrides LANG; empty values are unset. - for (variables, term) in [ - (&[][..], "char"), - ( - &[("LC_ALL", "C"), ("LC_MESSAGES", "en_US.UTF-8")][..], - "char", - ), - (&[("LC_ALL", "en_US.UTF-8"), ("LC_MESSAGES", "C")], "byte"), - (&[("LC_MESSAGES", "POSIX"), ("LANG", "en_US.UTF-8")], "char"), - (&[("LC_MESSAGES", "en_US.UTF-8"), ("LANG", "C")], "byte"), - (&[("LC_ALL", ""), ("LANG", "en_US.UTF-8")], "byte"), - ( - &[("LC_ALL", ""), ("LC_MESSAGES", ""), ("LANG", "C")], - "char", - ), - ] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env_remove("LC_ALL") - .env_remove("LC_MESSAGES") - .env_remove("LANG") - .envs(variables.iter().copied()) - .arg("cmp") - .arg(&a_path) - .arg(&b_path); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stdout(predicate::str::ends_with(format!( - " differ: {term} 1, line 1\n" - ))); - } - Ok(()) +// LC_ALL overrides LC_MESSAGES, which overrides LANG; empty values are unset. +#[rstest] +#[case::nothing_set(&[], "char")] +#[case::lc_all_c(&[("LC_ALL", "C"), ("LC_MESSAGES", "en_US.UTF-8")], "char")] +#[case::lc_all_utf8(&[("LC_ALL", "en_US.UTF-8"), ("LC_MESSAGES", "C")], "byte")] +#[case::lc_messages_posix(&[("LC_MESSAGES", "POSIX"), ("LANG", "en_US.UTF-8")], "char")] +#[case::lc_messages_utf8(&[("LC_MESSAGES", "en_US.UTF-8"), ("LANG", "C")], "byte")] +#[case::lang_utf8(&[("LC_ALL", ""), ("LANG", "en_US.UTF-8")], "byte")] +#[case::lang_c(&[("LC_ALL", ""), ("LC_MESSAGES", ""), ("LANG", "C")], "char")] +fn cmp_difference_term_follows_messages_locale( + #[case] variables: &[(&str, &str)], + #[case] term: &str, +) { + let (at, ts) = at_and_ts!(); + at.write("a", "abc\n"); + at.write("b", "bcd\n"); + + // The command starts with a cleared environment except for the + // LC_ALL=C default, which an empty value unsets. + ts.ucmd() + .env("LC_ALL", "") + .envs(variables.iter().copied()) + .args(&["a", "b"]) + .fails_with_code(1) + .stdout_is(format!("a b differ: {term} 1, line 1\n")); } diff --git a/tests/by-util/test_diff.rs b/tests/by-util/test_diff.rs index 10fc0a10..3b6007b8 100644 --- a/tests/by-util/test_diff.rs +++ b/tests/by-util/test_diff.rs @@ -5,1295 +5,850 @@ use diffutilslib::assert_diff_eq; -#[cfg(any(target_os = "linux", target_os = "android"))] -use assert_cmd::assert::OutputAssertExt; -use assert_cmd::cargo::cargo_bin_cmd; -use predicates::prelude::*; +use rstest::rstest; use std::fs::File; -use std::io::Write; -use tempfile::{tempdir, NamedTempFile}; - -#[test] -fn no_differences() -> Result<(), Box> { - let file = NamedTempFile::new()?; - for option in ["", "-u", "-c", "-e"] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - if !option.is_empty() { - cmd.arg(option); - } - cmd.arg(file.path()).arg(file.path()); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stdout(predicate::str::is_empty()); - } - Ok(()) +use uutests::{at_and_ts, new_ucmd}; + +#[rstest] +fn no_differences(#[values(&[][..], &["-u"], &["-c"], &["-e"])] format: &[&str]) { + let (at, ts) = at_and_ts!(); + at.touch("file"); + ts.ucmd() + .args(format) + .args(&["file", "file"]) + .succeeds() + .no_stdout(); } -#[test] -fn no_differences_report_identical_files() -> Result<(), Box> { - // same file - let mut file1 = NamedTempFile::new()?; - file1.write_all("foo\n".as_bytes())?; - for option in ["", "-u", "-c", "-e"] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - if !option.is_empty() { - cmd.arg(option); - } - cmd.arg("-s").arg(file1.path()).arg(file1.path()); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stdout(predicate::eq(format!( - "Files {} and {} are identical\n", - file1.path().to_string_lossy(), - file1.path().to_string_lossy(), - ))); - } - // two files with the same content - let mut file2 = NamedTempFile::new()?; - file2.write_all("foo\n".as_bytes())?; - for option in ["", "-u", "-c", "-e"] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - if !option.is_empty() { - cmd.arg(option); - } - cmd.arg("-s").arg(file1.path()).arg(file2.path()); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stdout(predicate::eq(format!( - "Files {} and {} are identical\n", - file1.path().to_string_lossy(), - file2.path().to_string_lossy(), - ))); - } - Ok(()) +// The same file, then two files with the same content. +#[rstest] +fn no_differences_report_identical_files( + #[values(&[][..], &["-u"], &["-c"], &["-e"])] format: &[&str], + #[values("file1", "file2")] second: &str, +) { + let (at, ts) = at_and_ts!(); + at.write("file1", "foo\n"); + at.write("file2", "foo\n"); + ts.ucmd() + .args(format) + .args(&["-s", "file1", second]) + .succeeds() + .stdout_is(format!("Files file1 and {second} are identical\n")); } -#[test] -fn differences() -> Result<(), Box> { - let mut file1 = NamedTempFile::new()?; - file1.write_all("foo\n".as_bytes())?; - let mut file2 = NamedTempFile::new()?; - file2.write_all("bar\n".as_bytes())?; - for option in ["", "-u", "-c", "-e"] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - if !option.is_empty() { - cmd.arg(option); - } - cmd.arg(file1.path()).arg(file2.path()); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stdout(predicate::str::is_empty().not()); - } - Ok(()) +#[rstest] +fn differences(#[values(&[][..], &["-u"], &["-c"], &["-e"])] format: &[&str]) { + let (at, ts) = at_and_ts!(); + at.write("file1", "foo\n"); + at.write("file2", "bar\n"); + ts.ucmd() + .args(format) + .args(&["file1", "file2"]) + .fails_with_code(1) + .stdout_check(|s| !s.is_empty()); } -#[test] -fn differences_brief() -> Result<(), Box> { - let mut file1 = NamedTempFile::new()?; - file1.write_all("foo\n".as_bytes())?; - let mut file2 = NamedTempFile::new()?; - file2.write_all("bar\n".as_bytes())?; - for option in ["", "-u", "-c", "-e"] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - if !option.is_empty() { - cmd.arg(option); - } - cmd.arg("-q").arg(file1.path()).arg(file2.path()); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stdout(predicate::eq(format!( - "Files {} and {} differ\n", - file1.path().to_string_lossy(), - file2.path().to_string_lossy() - ))); - } - Ok(()) +#[rstest] +fn differences_brief(#[values(&[][..], &["-u"], &["-c"], &["-e"])] format: &[&str]) { + let (at, ts) = at_and_ts!(); + at.write("file1", "foo\n"); + at.write("file2", "bar\n"); + ts.ucmd() + .args(format) + .args(&["-q", "file1", "file2"]) + .fails_with_code(1) + .stdout_is("Files file1 and file2 differ\n"); } #[test] -fn missing_newline() -> Result<(), Box> { - let mut file1 = NamedTempFile::new()?; - file1.write_all("foo".as_bytes())?; - let mut file2 = NamedTempFile::new()?; - file2.write_all("bar".as_bytes())?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - cmd.arg("-e").arg(file1.path()).arg(file2.path()); - cmd.assert() - .code(predicate::eq(2)) - .failure() - .stderr(predicate::str::starts_with("No newline at end of file")); - Ok(()) +fn missing_newline() { + let (at, ts) = at_and_ts!(); + at.write("file1", "foo"); + at.write("file2", "bar"); + ts.ucmd() + .args(&["-e", "file1", "file2"]) + .fails_with_code(2) + .stderr_str_check(|s| s.starts_with("No newline at end of file")); } -#[test] -fn read_from_stdin() -> Result<(), Box> { - let mut file1 = NamedTempFile::new()?; - file1.write_all("foo\n".as_bytes())?; - let mut file2 = NamedTempFile::new()?; - file2.write_all("bar\n".as_bytes())?; - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - cmd.arg("-u") - .arg(file1.path()) - .arg("-") - .write_stdin("bar\n"); - cmd.assert().code(predicate::eq(1)).failure(); - - let output = cmd.output().unwrap().stdout; +#[rstest] +#[case::second(&["file1", "-"], "bar\n", "--- file1\tTIMESTAMP\n+++ -\tTIMESTAMP\n")] +#[case::first(&["-", "file2"], "foo\n", "--- -\tTIMESTAMP\n+++ file2\tTIMESTAMP\n")] +fn read_from_stdin(#[case] operands: &[&str], #[case] input: &str, #[case] headers: &str) { + let (at, ts) = at_and_ts!(); + at.write("file1", "foo\n"); + at.write("file2", "bar\n"); + + let result = ts + .ucmd() + .arg("-u") + .args(operands) + .pipe_in(input) + .fails_with_code(1); assert_diff_eq!( - output, - format!( - "--- {}\tTIMESTAMP\n+++ -\tTIMESTAMP\n@@ -1 +1 @@\n-foo\n+bar\n", - file1.path().to_string_lossy() - ) + result.stdout(), + format!("{headers}@@ -1 +1 @@\n-foo\n+bar\n") ); +} - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - cmd.arg("-u") - .arg("-") - .arg(file2.path()) - .write_stdin("foo\n"); - cmd.assert().code(predicate::eq(1)).failure(); - - let output = cmd.output().unwrap().stdout; +#[cfg(unix)] +#[test] +fn read_from_dev_stdin() { + let (at, ts) = at_and_ts!(); + at.write("file1", "foo\n"); + + let result = ts + .ucmd() + .args(&["-u", "file1", "/dev/stdin"]) + .pipe_in("bar\n") + .fails_with_code(1); assert_diff_eq!( - output, - format!( - "--- -\tTIMESTAMP\n+++ {}\tTIMESTAMP\n@@ -1 +1 @@\n-foo\n+bar\n", - file2.path().to_string_lossy() - ) + result.stdout(), + "--- file1\tTIMESTAMP\n+++ /dev/stdin\tTIMESTAMP\n@@ -1 +1 @@\n-foo\n+bar\n" ); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - cmd.arg("-u").arg("-").arg("-"); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stdout(predicate::str::is_empty()); - - #[cfg(unix)] - { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - cmd.arg("-u") - .arg(file1.path()) - .arg("/dev/stdin") - .write_stdin("bar\n"); - cmd.assert().code(predicate::eq(1)).failure(); - - let output = cmd.output().unwrap().stdout; - assert_diff_eq!( - output, - format!( - "--- {}\tTIMESTAMP\n+++ /dev/stdin\tTIMESTAMP\n@@ -1 +1 @@\n-foo\n+bar\n", - file1.path().to_string_lossy() - ) - ); - } - - Ok(()) } #[test] -fn missing_file_as_empty() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let present = tmp_dir.path().join("present"); - let absent = tmp_dir.path().join("absent"); - std::fs::write(&present, "kiwi\nmango\n")?; - - for option in ["-N", "--new-file", "--unidirectional-new-file"] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg(option).arg(&absent).arg(&present); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stdout("0a1,2\n> kiwi\n> mango\n"); - } +fn both_from_stdin() { + new_ucmd!().args(&["-u", "-", "-"]).succeeds().no_stdout(); +} - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("-N").arg(&present).arg(&absent); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stdout("1,2d0\n< kiwi\n< mango\n"); - - // Only a missing first operand is accepted here. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("--unidirectional-new-file") - .arg(&present) - .arg(&absent); - cmd.assert().code(predicate::eq(2)).failure(); - - // Without the option, a missing file is trouble. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg(&absent).arg(&present); - cmd.assert().code(predicate::eq(2)).failure(); - Ok(()) +#[rstest] +fn missing_file_as_empty(#[values("-N", "--new-file", "--unidirectional-new-file")] option: &str) { + let (at, ts) = at_and_ts!(); + at.write("present", "kiwi\nmango\n"); + + ts.ucmd() + .args(&[option, "absent", "present"]) + .fails_with_code(1) + .stdout_is("0a1,2\n> kiwi\n> mango\n"); +} + +#[rstest] +#[case::new_file(&["-N", "present", "absent"], 1, "1,2d0\n< kiwi\n< mango\n")] +// Only a missing first operand is accepted here. +#[case::unidirectional(&["--unidirectional-new-file", "present", "absent"], 2, "")] +// Without the option, a missing file is trouble. +#[case::no_option(&["absent", "present"], 2, "")] +fn missing_second_file(#[case] args: &[&str], #[case] code: i32, #[case] expected: &str) { + let (at, ts) = at_and_ts!(); + at.write("present", "kiwi\nmango\n"); + + ts.ucmd().args(args).run().code_is(code).stdout_is(expected); } // TZ is not honored on Windows. #[cfg(unix)] -#[test] -fn missing_file_header_timestamp() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let left = tmp_dir.path().join("left"); - let right = tmp_dir.path().join("right"); - std::fs::create_dir(&left)?; - std::fs::create_dir_all(right.join("nested"))?; - let absent = left.join("nested/file"); - let present = right.join("nested/file"); - std::fs::write(&present, "kiwi\n")?; +#[rstest] +#[case::unified_c( + "-u", + "C", + ["---", "+++"], + "1970-01-01 00:00:00.000000000 +0000", + "2009-02-13 23:31:30.250000000 +0000" +)] +#[case::context_utf8( + "-c", + "en_US.UTF-8", + ["***", "---"], + "1970-01-01 00:00:00.000000000 +0000", + "2009-02-13 23:31:30.250000000 +0000" +)] +#[case::context_c( + "-c", + "C", + ["***", "---"], + "Thu Jan 1 00:00:00 1970", + "Fri Feb 13 23:31:30 2009" +)] +fn missing_file_header_timestamp( + #[case] format: &str, + #[case] locale: &str, + #[case] markers: [&str; 2], + #[case] epoch: &str, + #[case] timestamp: &str, + // --unidirectional-new-file only accepts a missing first operand. + #[values( + ("-N", false), + ("--new-file", false), + ("--unidirectional-new-file", false), + ("-N", true), + ("--new-file", true) + )] + option_and_reverse: (&str, bool), + #[values(false, true)] recursive: bool, +) { + let (option, reverse) = option_and_reverse; + let (at, ts) = at_and_ts!(); + at.mkdir("left"); + at.mkdir_all("right/nested"); + at.write("right/nested/file", "kiwi\n"); let mtime = std::time::UNIX_EPOCH + std::time::Duration::from_millis(1_234_567_890_250); File::options() .write(true) - .open(&present)? - .set_modified(mtime)?; - - for (format, locale, markers, epoch, timestamp) in [ - ( - "-u", - "C", - ["---", "+++"], - "1970-01-01 00:00:00.000000000 +0000", - "2009-02-13 23:31:30.250000000 +0000", - ), - ( - "-c", - "en_US.UTF-8", - ["***", "---"], - "1970-01-01 00:00:00.000000000 +0000", - "2009-02-13 23:31:30.250000000 +0000", - ), - ( - "-c", - "C", - ["***", "---"], - "Thu Jan 1 00:00:00 1970", - "Fri Feb 13 23:31:30 2009", - ), - ] { - for option in ["-N", "--new-file", "--unidirectional-new-file"] { - for reverse in [false, true] { - if reverse && option == "--unidirectional-new-file" { - continue; - } - let headers = if reverse { - format!( - "{} {}\t{timestamp}\n{} {}\t{epoch}\n", - markers[0], - present.display(), - markers[1], - absent.display() - ) - } else { - format!( - "{} {}\t{epoch}\n{} {}\t{timestamp}\n", - markers[0], - absent.display(), - markers[1], - present.display() - ) - }; - for recursive in [false, true] { - let (from, to) = if recursive { - (&left, &right) - } else { - (&absent, &present) - }; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("TZ", "UTC0") - .env("LC_ALL", locale) - .arg("diff") - .arg(format) - .arg(option); - if recursive { - cmd.arg("-r"); - } - cmd.arg(if reverse { to } else { from }) - .arg(if reverse { from } else { to }); - cmd.assert() - .code(predicate::eq(1)) - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::contains(&headers)); - } - } - } + .open(at.plus("right/nested/file")) + .unwrap() + .set_modified(mtime) + .unwrap(); + let absent = "left/nested/file"; + let present = "right/nested/file"; + + let headers = if reverse { + format!( + "{} {present}\t{timestamp}\n{} {absent}\t{epoch}\n", + markers[0], markers[1] + ) + } else { + format!( + "{} {absent}\t{epoch}\n{} {present}\t{timestamp}\n", + markers[0], markers[1] + ) + }; + let (from, to) = if recursive { + ("left", "right") + } else { + (absent, present) + }; + let mut cmd = ts.ucmd(); + cmd.env("TZ", "UTC0") + .env("LC_ALL", locale) + .arg(format) + .arg(option); + if recursive { + cmd.arg("-r"); } - Ok(()) + cmd.arg(if reverse { to } else { from }) + .arg(if reverse { from } else { to }) + .fails_with_code(1) + .no_stderr() + .stdout_contains(&headers); } -#[test] -fn missing_file_as_empty_keeps_stdin_timestamp() -> Result<(), Box> { - let mut file = NamedTempFile::new()?; - file.write_all(b"file\n")?; - - let stdin = std::ffi::OsStr::new("-"); - let file = file.path().as_os_str(); - for format in ["-u", "-c"] { - for (from, to) in [(stdin, file), (file, stdin)] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("TZ", "UTC0") - .env("LC_ALL", "C") - .arg("diff") - .arg(format) - .arg("-N") - .arg(from) - .arg(to) - .write_stdin("stdin\n"); - cmd.assert() - .code(predicate::eq(1)) - .stderr(predicate::str::is_empty()) - .stdout(predicate::str::contains("1970").not()); - } - } - Ok(()) +#[rstest] +fn missing_file_as_empty_keeps_stdin_timestamp( + #[values("-u", "-c")] format: &str, + #[values(["-", "file"], ["file", "-"])] operands: [&str; 2], +) { + let (at, ts) = at_and_ts!(); + at.write("file", "file\n"); + + ts.ucmd() + .args(&[format, "-N"]) + .args(&operands) + .pipe_in("stdin\n") + .fails_with_code(1) + .no_stderr() + .stdout_does_not_contain("1970"); } #[test] -fn binary_files() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let left = tmp_dir.path().join("left.bin"); - let right = tmp_dir.path().join("right.bin"); - std::fs::write(&left, b"header\x00\x7fpayload-one\n")?; - std::fs::write(&right, b"header\x00\x7fpayload-two\n")?; - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg(&left).arg(&right); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(format!( - "Binary files {} and {} differ\n", - left.display(), - right.display() - )); +fn binary_files() { + let (at, ts) = at_and_ts!(); + at.write_bytes("left.bin", b"header\x00\x7fpayload-one\n"); + at.write_bytes("right.bin", b"header\x00\x7fpayload-two\n"); + + ts.ucmd() + .args(&["left.bin", "right.bin"]) + .fails_with_code(1) + .stdout_only("Binary files left.bin and right.bin differ\n"); // Identical binary inputs are not reported. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg(&left).arg("-"); - cmd.write_stdin(b"header\x00\x7fpayload-one\n".to_vec()); - cmd.assert().code(predicate::eq(0)).success().stdout(""); + ts.ucmd() + .args(&["left.bin", "-"]) + .pipe_in(b"header\x00\x7fpayload-one\n".to_vec()) + .succeeds() + .no_stdout(); // -q keeps its usual wording. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("-q").arg(&left).arg(&right); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stderr(predicate::str::is_empty()) - .stdout(format!( - "Files {} and {} differ\n", - left.display(), - right.display() - )); + ts.ucmd() + .args(&["-q", "left.bin", "right.bin"]) + .fails_with_code(1) + .stdout_only("Files left.bin and right.bin differ\n"); +} - // -a and --text force a line-by-line comparison. - for option in ["-a", "--text"] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg(option).arg(&left).arg(&right); - cmd.assert() - .code(predicate::eq(1)) - .failure() - .stdout(predicate::str::starts_with("1c1\n")); - } - Ok(()) +// -a and --text force a line-by-line comparison. +#[rstest] +fn binary_files_as_text(#[values("-a", "--text")] option: &str) { + let (at, ts) = at_and_ts!(); + at.write_bytes("left.bin", b"header\x00\x7fpayload-one\n"); + at.write_bytes("right.bin", b"header\x00\x7fpayload-two\n"); + + ts.ucmd() + .args(&[option, "left.bin", "right.bin"]) + .fails_with_code(1) + .stdout_str_check(|s| s.starts_with("1c1\n")); } #[cfg(any(target_os = "linux", target_os = "android"))] #[test] -fn stdin_is_directory() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let dir = tmp_dir.path().join("dir"); - std::fs::create_dir(&dir)?; - std::fs::write(dir.join("notes"), "alpha\n")?; - let notes = tmp_dir.path().join("notes"); - std::fs::write(¬es, "beta\n")?; +fn stdin_is_directory() { + let (at, ts) = at_and_ts!(); + at.mkdir("dir"); + at.write("dir/notes", "alpha\n"); + at.write("notes", "beta\n"); // The directory itself must be standard input, not its contents. - let output = std::process::Command::new(assert_cmd::cargo::cargo_bin!("diffutils")) - .arg("diff") - .arg("-") - .arg(¬es) - .stdin(File::open(&dir)?) - .output()?; - output - .assert() - .code(predicate::eq(1)) - .failure() - .stdout("1c1\n< alpha\n---\n> beta\n"); - Ok(()) + ts.ucmd() + .args(&["-", "notes"]) + .set_stdin(File::open(at.plus("dir")).unwrap()) + .fails_with_code(1) + .stdout_is("1c1\n< alpha\n---\n> beta\n"); } -#[test] -fn color() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let old = tmp_dir.path().join("old"); - let new = tmp_dir.path().join("new"); - std::fs::write(&old, "sun\nrain\n")?; - std::fs::write(&new, "sun\nsnow\n")?; - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("--color=always").arg(&old).arg(&new); - cmd.assert() - .code(predicate::eq(1)) - .stdout("\x1b[36m2c2\x1b[0m\n\x1b[31m< rain\x1b[0m\n---\n\x1b[32m> snow\x1b[0m\n"); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("--color=always") - .arg("--palette=de=4:ad=7") - .arg(&old) - .arg(&new); - cmd.assert() - .code(predicate::eq(1)) - .stdout("\x1b[36m2c2\x1b[0m\n\x1b[4m< rain\x1b[0m\n---\n\x1b[7m> snow\x1b[0m\n"); - - // Standard output is not a terminal here, and TERM=dumb never gets colors. - for args in [&["--color"][..], &["--color=auto", "---presume-output-tty"]] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("TERM", "dumb") - .arg("diff") - .args(args) - .arg(&old) - .arg(&new); - cmd.assert() - .code(predicate::eq(1)) - .stdout("2c2\n< rain\n---\n> snow\n"); +const PLAIN: &str = "2c2\n< rain\n---\n> snow\n"; +const COLORED: &str = "\x1b[36m2c2\x1b[0m\n\x1b[31m< rain\x1b[0m\n---\n\x1b[32m> snow\x1b[0m\n"; + +#[rstest] +#[case::always(&["--color=always"], None, COLORED)] +#[case::palette( + &["--color=always", "--palette=de=4:ad=7"], + None, + "\x1b[36m2c2\x1b[0m\n\x1b[4m< rain\x1b[0m\n---\n\x1b[7m> snow\x1b[0m\n" +)] +#[case::palette_before_color( + &["--palette", "ln=1", "--color=always"], + None, + "\x1b[1m2c2\x1b[0m\n\x1b[31m< rain\x1b[0m\n---\n\x1b[32m> snow\x1b[0m\n" +)] +// Standard output is not a terminal here, and TERM=dumb never gets colors. +#[case::auto_not_a_terminal(&["--color"], Some("dumb"), PLAIN)] +#[case::auto_dumb_terminal(&["--color=auto", "---presume-output-tty"], Some("dumb"), PLAIN)] +// Like GNU diff, an unset TERM does not disable --color=auto on a terminal. +#[case::auto_unset_term(&["--color=auto", "---presume-output-tty"], None, COLORED)] +fn color(#[case] options: &[&str], #[case] term: Option<&str>, #[case] expected: &str) { + let (at, ts) = at_and_ts!(); + at.write("old", "sun\nrain\n"); + at.write("new", "sun\nsnow\n"); + + // The environment of the command is cleared, so TERM is only set here. + let mut cmd = ts.ucmd(); + if let Some(term) = term { + cmd.env("TERM", term); } + cmd.args(options) + .args(&["old", "new"]) + .fails_with_code(1) + .stdout_only(expected); +} + +// An invalid palette is reported and disables colors. +#[test] +fn color_invalid_palette() { + let (at, ts) = at_and_ts!(); + at.write("old", "sun\nrain\n"); + at.write("new", "sun\nsnow\n"); + + ts.ucmd() + .args(&["--color=always", "--palette=up=1", "old", "new"]) + .fails_with_code(1) + .stdout_is(PLAIN) + .stderr_contains("unrecognized prefix: up"); +} - // Like GNU diff, an unset TERM does not disable --color=auto on a terminal. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env_remove("TERM") - .arg("diff") - .arg("--color=auto") - .arg("---presume-output-tty") - .arg(&old) - .arg(&new); - cmd.assert() - .code(predicate::eq(1)) - .stdout("\x1b[36m2c2\x1b[0m\n\x1b[31m< rain\x1b[0m\n---\n\x1b[32m> snow\x1b[0m\n"); - - // An invalid palette is reported and disables colors. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("--color=always") - .arg("--palette=up=1") - .arg(&old) - .arg(&new); - cmd.assert() - .code(predicate::eq(1)) - .stdout("2c2\n< rain\n---\n> snow\n") - .stderr(predicate::str::contains("unrecognized prefix: up")); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("--color=sometimes").arg(&old).arg(&new); - cmd.assert() - .code(predicate::eq(2)) - .stderr(predicate::str::contains("invalid color 'sometimes'")); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("--colour").arg(&old).arg(&new); - cmd.assert() - .code(predicate::eq(2)) - .stderr(predicate::str::contains("unrecognized option '--colour'")); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("--palette") - .arg("ln=1") - .arg("--color=always") - .arg(&old) - .arg(&new); - cmd.assert() - .code(predicate::eq(1)) - .stdout("\x1b[1m2c2\x1b[0m\n\x1b[31m< rain\x1b[0m\n---\n\x1b[32m> snow\x1b[0m\n"); - Ok(()) +#[rstest] +#[case::invalid_value("--color=sometimes", "invalid color 'sometimes'")] +#[case::misspelled("--colour", "unrecognized option '--colour'")] +fn color_bad_option(#[case] option: &str, #[case] error: &str) { + let (at, ts) = at_and_ts!(); + at.write("old", "sun\nrain\n"); + at.write("new", "sun\nsnow\n"); + + ts.ucmd() + .args(&[option, "old", "new"]) + .fails_with_code(2) + .stderr_contains(error); } #[cfg(target_os = "linux")] #[test] -fn write_error() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let old = tmp_dir.path().join("old"); - let new = tmp_dir.path().join("new"); - std::fs::write(&old, "left\n")?; - std::fs::write(&new, "right\n")?; - - let output = std::process::Command::new(assert_cmd::cargo::cargo_bin!("diffutils")) - .arg("diff") - .arg(&old) - .arg(&new) - .stdout(File::create("/dev/full")?) - .output()?; - output - .assert() - .code(predicate::eq(2)) - .stderr("diff: standard output: No space left on device\n"); - Ok(()) +fn write_error() { + let (at, ts) = at_and_ts!(); + at.write("old", "left\n"); + at.write("new", "right\n"); + + ts.ucmd() + .args(&["old", "new"]) + .set_stdout(File::create("/dev/full").unwrap()) + .fails_with_code(2) + .stderr_is("diff: standard output: No space left on device\n"); } +const TRADITIONAL: &str = "Fri Feb 13 23:31:30 2009"; +const ISO: &str = "2009-02-13 23:31:30.250000000 +0000"; + +// LC_ALL overrides LC_TIME, which overrides LANG; empty values are unset. // TZ is not honored on Windows. #[cfg(unix)] -#[test] -fn context_timestamp_follows_time_locale() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let old = tmp_dir.path().join("old"); - let new = tmp_dir.path().join("new"); - std::fs::write(&old, "left\n")?; - std::fs::write(&new, "right\n")?; +#[rstest] +#[case::lc_all_c(&[("LC_ALL", "C")], TRADITIONAL)] +#[case::lc_all_posix(&[("LC_ALL", "POSIX"), ("LC_TIME", "en_US.UTF-8")], TRADITIONAL)] +#[case::lc_all_utf8(&[("LC_ALL", "en_US.UTF-8"), ("LC_TIME", "C")], ISO)] +#[case::lc_time_c(&[("LC_TIME", "C"), ("LANG", "en_US.UTF-8")], TRADITIONAL)] +#[case::lc_time_utf8(&[("LC_TIME", "en_US.UTF-8"), ("LANG", "C")], ISO)] +#[case::lang_posix(&[("LC_ALL", ""), ("LC_TIME", ""), ("LANG", "POSIX")], TRADITIONAL)] +#[case::lang_utf8(&[("LANG", "fr_FR.UTF-8")], ISO)] +fn context_timestamp_follows_time_locale( + #[case] variables: &[(&str, &str)], + #[case] timestamp: &str, +) { + let (at, ts) = at_and_ts!(); + at.write("old", "left\n"); + at.write("new", "right\n"); // 2009-02-13 23:31:30.25 UTC let mtime = std::time::UNIX_EPOCH + std::time::Duration::from_millis(1_234_567_890_250); - for path in [&old, &new] { + for path in ["old", "new"] { File::options() .write(true) - .open(path)? - .set_modified(mtime)?; + .open(at.plus(path)) + .unwrap() + .set_modified(mtime) + .unwrap(); } - let traditional = "Fri Feb 13 23:31:30 2009"; - let iso = "2009-02-13 23:31:30.250000000 +0000"; - // LC_ALL overrides LC_TIME, which overrides LANG; empty values are unset. - for (variables, timestamp) in [ - (&[("LC_ALL", "C")][..], traditional), - ( - &[("LC_ALL", "POSIX"), ("LC_TIME", "en_US.UTF-8")], - traditional, - ), - (&[("LC_ALL", "en_US.UTF-8"), ("LC_TIME", "C")], iso), - (&[("LC_TIME", "C"), ("LANG", "en_US.UTF-8")], traditional), - (&[("LC_TIME", "en_US.UTF-8"), ("LANG", "C")], iso), - ( - &[("LC_ALL", ""), ("LC_TIME", ""), ("LANG", "POSIX")], - traditional, - ), - (&[("LANG", "fr_FR.UTF-8")], iso), - ] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("TZ", "UTC0") - .env_remove("LC_ALL") - .env_remove("LC_TIME") - .env_remove("LANG") - .envs(variables.iter().copied()) - .arg("diff") - .arg("-c") - .arg(&old) - .arg(&new); - cmd.assert() - .code(predicate::eq(1)) - .stdout(predicate::str::starts_with(format!( - "*** {}\t{timestamp}\n--- {}\t{timestamp}\n", - old.display(), - new.display() - ))); - } - Ok(()) + let expected = format!("*** old\t{timestamp}\n--- new\t{timestamp}\n"); + // The command starts with a cleared environment except for the + // LC_ALL=C default, which an empty value unsets. + ts.ucmd() + .env("TZ", "UTC0") + .env("LC_ALL", "") + .envs(variables.iter().copied()) + .args(&["-c", "old", "new"]) + .fails_with_code(1) + .stdout_str_check(|s| s.starts_with(&expected)); } #[test] -fn compare_directories() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let left = tmp_dir.path().join("left"); - let right = tmp_dir.path().join("right"); - for dir in [&left, &right] { - std::fs::create_dir_all(dir.join("nested/inner"))?; - std::fs::write(dir.join("equal"), "same\n")?; +fn compare_directories() { + let (at, ts) = at_and_ts!(); + let left = "left"; + let right = "right"; + for dir in [left, right] { + at.mkdir_all(&format!("{dir}/nested/inner")); + at.write(&format!("{dir}/equal"), "same\n"); } - std::fs::write(left.join("changed"), "old\n")?; - std::fs::write(right.join("changed"), "new\n")?; - std::fs::write(left.join("nested/inner/deep"), "one\n")?; - std::fs::write(right.join("nested/inner/deep"), "two\n")?; - std::fs::write(left.join("gone"), "bye\n")?; - std::fs::write(right.join("added"), "hi\n")?; - std::fs::write(left.join("kind"), "file\n")?; - std::fs::create_dir(right.join("kind"))?; - let left = left.to_str().unwrap(); - let right = right.to_str().unwrap(); + at.write("left/changed", "old\n"); + at.write("right/changed", "new\n"); + at.write("left/nested/inner/deep", "one\n"); + at.write("right/nested/inner/deep", "two\n"); + at.write("left/gone", "bye\n"); + at.write("right/added", "hi\n"); + at.write("left/kind", "file\n"); + at.mkdir("right/kind"); // Entry names are joined to the directories with the native separator. let s = std::path::MAIN_SEPARATOR; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg(left).arg(right); - cmd.assert().code(predicate::eq(1)).stdout(format!( - "Only in {right}: added\n\ - diff {left}{s}changed {right}{s}changed\n1c1\n< old\n---\n> new\n\ - Only in {left}: gone\n\ - File {left}{s}kind is a regular file while file {right}{s}kind is a directory\n\ - Common subdirectories: {left}{s}nested and {right}{s}nested\n" - )); + ts.ucmd() + .args(&[left, right]) + .fails_with_code(1) + .stdout_is(format!( + "Only in {right}: added\n\ + diff {left}{s}changed {right}{s}changed\n1c1\n< old\n---\n> new\n\ + Only in {left}: gone\n\ + File {left}{s}kind is a regular file while file {right}{s}kind is a directory\n\ + Common subdirectories: {left}{s}nested and {right}{s}nested\n" + )); // Options are repeated as given in the headers, and trailing slashes // do not end up in the compared paths. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-r") - .arg("-q") - .arg(format!("{left}/")) - .arg(right); - cmd.assert().code(predicate::eq(1)).stdout(format!( - "Only in {right}: added\n\ - Files {left}{s}changed and {right}{s}changed differ\n\ - Only in {left}/: gone\n\ - File {left}{s}kind is a regular file while file {right}{s}kind is a directory\n\ - Files {left}{s}nested{s}inner{s}deep and {right}{s}nested{s}inner{s}deep differ\n" - )); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-N") - .arg("-r") - .arg("-e") - .arg(left) - .arg(right); - cmd.assert().code(predicate::eq(1)).stdout(format!( - "diff -N -r -e {left}{s}added {right}{s}added\n0a\nhi\n.\n\ - diff -N -r -e {left}{s}changed {right}{s}changed\n1c\nnew\n.\n\ - diff -N -r -e {left}{s}gone {right}{s}gone\n1d\n\ - File {left}{s}kind is a regular file while file {right}{s}kind is a directory\n\ - diff -N -r -e {left}{s}nested{s}inner{s}deep {right}{s}nested{s}inner{s}deep\n1c\ntwo\n.\n" - )); + ts.ucmd() + .args(&["-r", "-q", &format!("{left}/"), right]) + .fails_with_code(1) + .stdout_is(format!( + "Only in {right}: added\n\ + Files {left}{s}changed and {right}{s}changed differ\n\ + Only in {left}/: gone\n\ + File {left}{s}kind is a regular file while file {right}{s}kind is a directory\n\ + Files {left}{s}nested{s}inner{s}deep and {right}{s}nested{s}inner{s}deep differ\n" + )); + + ts.ucmd() + .args(&["-N", "-r", "-e", left, right]) + .fails_with_code(1) + .stdout_is(format!( + "diff -N -r -e {left}{s}added {right}{s}added\n0a\nhi\n.\n\ + diff -N -r -e {left}{s}changed {right}{s}changed\n1c\nnew\n.\n\ + diff -N -r -e {left}{s}gone {right}{s}gone\n1d\n\ + File {left}{s}kind is a regular file while file {right}{s}kind is a directory\n\ + diff -N -r -e {left}{s}nested{s}inner{s}deep {right}{s}nested{s}inner{s}deep\n1c\ntwo\n.\n" + )); // -s reports the identical files, but a directory is not compared with // itself. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("-r").arg("-s").arg(left).arg(left); - cmd.assert().code(predicate::eq(0)).stdout(""); - - let copy = tmp_dir.path().join("copy"); - std::fs::create_dir_all(copy.join("nested/inner"))?; - std::fs::write(copy.join("changed"), "old\n")?; - std::fs::write(copy.join("equal"), "same\n")?; - std::fs::write(copy.join("nested/inner/deep"), "one\n")?; - let copy = copy.to_str().unwrap(); - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("-r").arg("-s").arg(left).arg(copy); - cmd.assert().code(predicate::eq(1)).stdout(format!( - "Files {left}{s}changed and {copy}{s}changed are identical\n\ - Files {left}{s}equal and {copy}{s}equal are identical\n\ - Only in {left}: gone\n\ - Only in {left}: kind\n\ - Files {left}{s}nested{s}inner{s}deep and {copy}{s}nested{s}inner{s}deep are identical\n" - )); - Ok(()) + ts.ucmd() + .args(&["-r", "-s", left, left]) + .succeeds() + .no_stdout(); + + let copy = "copy"; + at.mkdir_all("copy/nested/inner"); + at.write("copy/changed", "old\n"); + at.write("copy/equal", "same\n"); + at.write("copy/nested/inner/deep", "one\n"); + ts.ucmd() + .args(&["-r", "-s", left, copy]) + .fails_with_code(1) + .stdout_is(format!( + "Files {left}{s}changed and {copy}{s}changed are identical\n\ + Files {left}{s}equal and {copy}{s}equal are identical\n\ + Only in {left}: gone\n\ + Only in {left}: kind\n\ + Files {left}{s}nested{s}inner{s}deep and {copy}{s}nested{s}inner{s}deep are identical\n" + )); } #[cfg(unix)] #[test] -fn compare_directories_special_entries() -> Result<(), Box> { - let tmp_dir = tempdir()?; +fn compare_directories_special_entries() { + let (at, ts) = at_and_ts!(); for dir in ["one", "two"] { - std::fs::create_dir_all(tmp_dir.path().join(dir).join("tools/bin"))?; + at.mkdir_all(&format!("{dir}/tools/bin")); // Links to the same directory are not compared. - std::os::unix::fs::symlink("..", tmp_dir.path().join(dir).join("parent"))?; - let status = std::process::Command::new("mkfifo") - .arg(tmp_dir.path().join(dir).join("queue")) - .status()?; - assert!(status.success()); + at.relative_symlink_dir("..", &format!("{dir}/parent")); + at.mkfifo(&format!("{dir}/queue")); } - std::fs::write(tmp_dir.path().join("one/tools/bin/run"), "go\n")?; - std::fs::remove_dir_all(tmp_dir.path().join("two/tools"))?; - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.current_dir(tmp_dir.path()) - .arg("diff") - .arg("-N") - .arg("one") - .arg("two"); - cmd.assert().code(predicate::eq(1)).stdout( - "File one/queue is a fifo while file two/queue is a fifo\n\ - Common subdirectories: one/tools and two/tools\n", - ); + at.write("one/tools/bin/run", "go\n"); + std::fs::remove_dir_all(at.plus("two/tools")).unwrap(); + + ts.ucmd() + .args(&["-N", "one", "two"]) + .fails_with_code(1) + .stdout_is( + "File one/queue is a fifo while file two/queue is a fifo\n\ + Common subdirectories: one/tools and two/tools\n", + ); - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.current_dir(tmp_dir.path()) - .arg("diff") - .arg("-r") - .arg("-N") - .arg("one") - .arg("two"); - cmd.assert().code(predicate::eq(1)).stdout( - "File one/queue is a fifo while file two/queue is a fifo\n\ - diff -r -N one/tools/bin/run two/tools/bin/run\n1d0\n< go\n", - ); + ts.ucmd() + .args(&["-r", "-N", "one", "two"]) + .fails_with_code(1) + .stdout_is( + "File one/queue is a fifo while file two/queue is a fifo\n\ + diff -r -N one/tools/bin/run two/tools/bin/run\n1d0\n< go\n", + ); // A link back to a directory being compared is reported. - std::os::unix::fs::symlink("..", tmp_dir.path().join("one/tools/again"))?; - std::fs::create_dir(tmp_dir.path().join("two/tools"))?; - std::os::unix::fs::symlink("..", tmp_dir.path().join("two/tools/again"))?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.current_dir(tmp_dir.path()) - .arg("diff") - .arg("-r") - .arg("one") - .arg("two"); - cmd.assert() - .code(predicate::eq(2)) - .stdout(predicate::str::contains("Only in one/tools: bin\n")) - .stderr("diff: one/tools/again: recursive directory loop\n"); - Ok(()) + at.relative_symlink_dir("..", "one/tools/again"); + at.mkdir("two/tools"); + at.relative_symlink_dir("..", "two/tools/again"); + ts.ucmd() + .args(&["-r", "one", "two"]) + .fails_with_code(2) + .stdout_contains("Only in one/tools: bin\n") + .stderr_is("diff: one/tools/again: recursive directory loop\n"); } #[test] -fn directory_name_matching() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let left = tmp_dir.path().join("left"); - let right = tmp_dir.path().join("right"); - std::fs::create_dir_all(left.join("lib"))?; - std::fs::create_dir_all(right.join("lib"))?; +fn directory_name_matching() { + let (at, ts) = at_and_ts!(); + let left = "left"; + let right = "right"; + at.mkdir_all("left/lib"); + at.mkdir_all("right/lib"); for name in ["Readme", "notes", "lib/early"] { - std::fs::write(left.join(name), "v1\n")?; + at.write(&format!("{left}/{name}"), "v1\n"); } for name in ["readme", "Notes", "Todo", "lib/EARLY"] { - std::fs::write(right.join(name), "v1\n")?; + at.write(&format!("{right}/{name}"), "v1\n"); } // Names differing only by case can only coexist on case-sensitive file // systems; there, they pair in byte order. - std::fs::write(left.join("README"), "v1\n")?; - let case_sensitive = std::fs::read_dir(&left)?.count() == 4; + at.write("left/README", "v1\n"); + let case_sensitive = std::fs::read_dir(at.plus(left)).unwrap().count() == 4; let unpaired_readme = if case_sensitive { - format!("Only in {}: Readme\n", left.display()) + format!("Only in {left}: Readme\n") } else { String::new() }; - let left = left.to_str().unwrap(); - let right = right.to_str().unwrap(); let s = std::path::MAIN_SEPARATOR; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-r") - .arg("--ignore-file-name-case") - .arg(left) - .arg(right); - cmd.assert() - .code(predicate::eq(1)) - .stdout(format!("{unpaired_readme}Only in {right}: Todo\n")); + ts.ucmd() + .args(&["-r", "--ignore-file-name-case", left, right]) + .fails_with_code(1) + .stdout_is(format!("{unpaired_readme}Only in {right}: Todo\n")); // -S only skips names at the top level. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-r") - .arg("-S") - .arg("l") - .arg(left) - .arg(right); - cmd.assert().code(predicate::eq(1)).stdout(format!( - "Only in {right}{s}lib: EARLY\nOnly in {left}{s}lib: early\n\ - Only in {left}: notes\nOnly in {right}: readme\n" - )); + ts.ucmd() + .args(&["-r", "-S", "l", left, right]) + .fails_with_code(1) + .stdout_is(format!( + "Only in {right}{s}lib: EARLY\nOnly in {left}{s}lib: early\n\ + Only in {left}: notes\nOnly in {right}: readme\n" + )); // The starting name is matched regardless of case too. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("--starting-file=NOTES") - .arg("--ignore-file-name-case") - .arg(left) - .arg(right); - cmd.assert() - .code(predicate::eq(1)) - .stdout(format!("{unpaired_readme}Only in {right}: Todo\n")); + ts.ucmd() + .args(&[ + "--starting-file=NOTES", + "--ignore-file-name-case", + left, + right, + ]) + .fails_with_code(1) + .stdout_is(format!("{unpaired_readme}Only in {right}: Todo\n")); // A file compared with a directory finds its counterpart regardless of case. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("--ignore-file-name-case") - .arg(format!("{left}{s}notes")) - .arg(right); - cmd.assert().code(predicate::eq(0)).stdout(""); - Ok(()) + ts.ucmd() + .args(&["--ignore-file-name-case", &format!("{left}{s}notes"), right]) + .succeeds() + .no_stdout(); } #[cfg(unix)] #[test] -fn no_dereference() -> Result<(), Box> { - use std::os::unix::fs::symlink; - - let tmp_dir = tempdir()?; - let dir = tmp_dir.path(); - std::fs::write(dir.join("plain"), "text\n")?; - std::fs::write(dir.join("other"), "text\n")?; - symlink("plain", dir.join("to-plain"))?; - symlink("plain", dir.join("also-to-plain"))?; - symlink("other", dir.join("to-other"))?; - let path = |name: &str| dir.join(name).to_str().unwrap().to_string(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg(path("plain")).arg(path("to-other")); - cmd.assert().code(predicate::eq(0)).stdout(""); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("--no-dereference") - .arg(path("plain")) - .arg(path("to-other")); - cmd.assert().code(predicate::eq(1)).stdout(format!( - "File {} is a regular file while file {} is a symbolic link\n", - path("plain"), - path("to-other") - )); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("--no-dereference") - .arg(path("to-plain")) - .arg(path("also-to-plain")); - cmd.assert().code(predicate::eq(0)).stdout(""); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("--no-dereference") - .arg(path("to-plain")) - .arg(path("to-other")); - cmd.assert().code(predicate::eq(1)).stdout(format!( - "Symbolic links '{}' -> 'plain' and '{}' -> 'other' differ\n", - path("to-plain"), - path("to-other") - )); +fn no_dereference() { + let (at, ts) = at_and_ts!(); + at.write("plain", "text\n"); + at.write("other", "text\n"); + at.relative_symlink_file("plain", "to-plain"); + at.relative_symlink_file("plain", "also-to-plain"); + at.relative_symlink_file("other", "to-other"); + + ts.ucmd() + .args(&["plain", "to-other"]) + .succeeds() + .no_stdout(); + + ts.ucmd() + .args(&["--no-dereference", "plain", "to-other"]) + .fails_with_code(1) + .stdout_is("File plain is a regular file while file to-other is a symbolic link\n"); + + ts.ucmd() + .args(&["--no-dereference", "to-plain", "also-to-plain"]) + .succeeds() + .no_stdout(); + + ts.ucmd() + .args(&["--no-dereference", "to-plain", "to-other"]) + .fails_with_code(1) + .stdout_is("Symbolic links 'to-plain' -> 'plain' and 'to-other' -> 'other' differ\n"); // In directories, dangling links are entries like any other. - std::fs::create_dir(dir.join("left"))?; - std::fs::create_dir(dir.join("right"))?; - symlink("missing", dir.join("left/dangling"))?; - symlink("../plain", dir.join("right/dangling"))?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-r") - .arg("--no-dereference") - .arg(path("left")) - .arg(path("right")); - cmd.assert().code(predicate::eq(1)).stdout(format!( - "Symbolic links '{0}/dangling' -> 'missing' and '{1}/dangling' -> '../plain' differ\n", - path("left"), - path("right") - )); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-r") - .arg(path("left")) - .arg(path("right")); - cmd.assert() - .code(predicate::eq(2)) - .stderr(predicate::str::contains( - "dangling: No such file or directory", - )); + at.mkdir("left"); + at.mkdir("right"); + at.relative_symlink_file("missing", "left/dangling"); + at.relative_symlink_file("../plain", "right/dangling"); + ts.ucmd() + .args(&["-r", "--no-dereference", "left", "right"]) + .fails_with_code(1) + .stdout_is( + "Symbolic links 'left/dangling' -> 'missing' and 'right/dangling' -> '../plain' differ\n", + ); + + ts.ucmd() + .args(&["-r", "left", "right"]) + .fails_with_code(2) + .stderr_contains("dangling: No such file or directory"); // Links with the same target are identical files. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-s") - .arg("--no-dereference") - .arg(path("to-plain")) - .arg(path("also-to-plain")); - cmd.assert().code(predicate::eq(0)).stdout(format!( - "Files {} and {} are identical\n", - path("to-plain"), - path("also-to-plain") - )); + ts.ucmd() + .args(&["-s", "--no-dereference", "to-plain", "also-to-plain"]) + .succeeds() + .stdout_is("Files to-plain and also-to-plain are identical\n"); // A file compared with a directory is looked up in it, and that entry is // not followed either. - std::fs::write(dir.join("left/plain"), "text\n")?; - symlink("../other", dir.join("left/to-other"))?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("--no-dereference") - .arg(path("plain")) - .arg(path("left")); - cmd.assert().code(predicate::eq(0)).stdout(""); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("--no-dereference") - .arg(path("left")) - .arg(path("to-other")); - cmd.assert().code(predicate::eq(1)).stdout(format!( - "Symbolic links '{}/to-other' -> '../other' and '{}' -> 'other' differ\n", - path("left"), - path("to-other") - )); - Ok(()) + at.write("left/plain", "text\n"); + at.relative_symlink_file("../other", "left/to-other"); + ts.ucmd() + .args(&["--no-dereference", "plain", "left"]) + .succeeds() + .no_stdout(); + + ts.ucmd() + .args(&["--no-dereference", "left", "to-other"]) + .fails_with_code(1) + .stdout_is( + "Symbolic links 'left/to-other' -> '../other' and 'to-other' -> 'other' differ\n", + ); } #[test] -fn compare_file_to_directory() -> Result<(), Box> { - let tmp_dir = tempdir()?; - - let directory = tmp_dir.path().join("d"); - let _ = std::fs::create_dir(&directory); - - let a_path = tmp_dir.path().join("a"); - let mut a = File::create(&a_path).unwrap(); - a.write_all(b"a\n").unwrap(); - - let da_path = directory.join("a"); - let mut da = File::create(&da_path).unwrap(); - da.write_all(b"da\n").unwrap(); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - cmd.arg("-u").arg(&directory).arg(&a_path); - cmd.assert().code(predicate::eq(1)).failure(); - - let output = cmd.output().unwrap().stdout; +fn compare_file_to_directory() { + let (at, ts) = at_and_ts!(); + at.mkdir("d"); + at.write("a", "a\n"); + at.write("d/a", "da\n"); + // The name is joined to the directory with the native separator. + let da = format!("d{}a", std::path::MAIN_SEPARATOR); + + let result = ts.ucmd().args(&["-u", "d", "a"]).fails_with_code(1); assert_diff_eq!( - output, - format!( - "--- {}\tTIMESTAMP\n+++ {}\tTIMESTAMP\n@@ -1 +1 @@\n-da\n+a\n", - da_path.display(), - a_path.display() - ) + result.stdout(), + format!("--- {da}\tTIMESTAMP\n+++ a\tTIMESTAMP\n@@ -1 +1 @@\n-da\n+a\n") ); - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - cmd.arg("-u").arg(&a_path).arg(&directory); - cmd.assert().code(predicate::eq(1)).failure(); - - let output = cmd.output().unwrap().stdout; + let result = ts.ucmd().args(&["-u", "a", "d"]).fails_with_code(1); assert_diff_eq!( - output, - format!( - "--- {}\tTIMESTAMP\n+++ {}\tTIMESTAMP\n@@ -1 +1 @@\n-a\n+da\n", - a_path.display(), - da_path.display() - ) + result.stdout(), + format!("--- a\tTIMESTAMP\n+++ {da}\tTIMESTAMP\n@@ -1 +1 @@\n-a\n+da\n") ); - - Ok(()) } // Regression for #269: the `-y` gutter marker must sit at the middle of the gutter. -#[test] -fn sdiff_gutter_marker_column() -> Result<(), Box> { - let mut file1 = NamedTempFile::new()?; - file1.write_all("aa\n".as_bytes())?; - let mut file2 = NamedTempFile::new()?; - file2.write_all("bb\n".as_bytes())?; - - // --expand-tabs: padding is spaces. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-y") - .arg("--width=40") - .arg("--expand-tabs") - .arg(file1.path()) - .arg(file2.path()); - let output = cmd.output().unwrap().stdout; - assert_eq!( - output, - b"aa <\n > bb\n" - ); - - // Default (expand_tabs: false): padding goes through the tab path. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-y") - .arg("--width=40") - .arg(file1.path()) - .arg(file2.path()); - let output = cmd.output().unwrap().stdout; - assert_eq!(output, b"aa\t\t <\n\t\t >\tbb\n"); - - Ok(()) +#[rstest] +// --expand-tabs: padding is spaces. +#[case::expand_tabs(&["--expand-tabs"], "aa <\n > bb\n")] +// Default (expand_tabs: false): padding goes through the tab path. +#[case::tabs(&[], "aa\t\t <\n\t\t >\tbb\n")] +fn sdiff_gutter_marker_column(#[case] options: &[&str], #[case] expected: &str) { + let (at, ts) = at_and_ts!(); + at.write("file1", "aa\n"); + at.write("file2", "bb\n"); + + ts.ucmd() + .args(&["-y", "--width=40"]) + .args(options) + .args(&["file1", "file2"]) + .run() + .stdout_is(expected); } -#[test] -fn normal_format_single_line_ranges() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let old = tmp_dir.path().join("old"); - let new = tmp_dir.path().join("new"); - std::fs::write(&old, "north\neast\nsouth\nwest\n")?; - std::fs::write(&new, "north\nsouth\nwest\nup\ndown\n")?; - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg(&old).arg(&new); - cmd.assert() - .code(predicate::eq(1)) - .stdout("2d1\n< east\n4a4,5\n> up\n> down\n"); - - let empty = tmp_dir.path().join("empty"); - std::fs::write(&empty, "")?; - std::fs::write(&new, "north\n")?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg(&empty).arg(&new); - cmd.assert().code(predicate::eq(1)).stdout("0a1\n> north\n"); - - std::fs::write(&new, "north\neast\nsouth\nwest\nup\n")?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg(&old).arg(&new); - cmd.assert().code(predicate::eq(1)).stdout("4a5\n> up\n"); - Ok(()) -} - -#[test] -fn ed_format_single_line_deletions() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let old = tmp_dir.path().join("old"); - let new = tmp_dir.path().join("new"); - std::fs::write(&old, "red\norange\nyellow\ngreen\nblue\n")?; - std::fs::write(&new, "red\norange\nyellow\nblue\n")?; - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("-e").arg(&old).arg(&new); - cmd.assert().code(predicate::eq(1)).stdout("4d\n"); - - std::fs::write(&new, "red\nblue\n")?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("-e").arg(&old).arg(&new); - cmd.assert().code(predicate::eq(1)).stdout("2,4d\n"); - Ok(()) -} - -#[test] -fn ed_format_writes_hunks_last_to_first() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let old = tmp_dir.path().join("old"); - let new = tmp_dir.path().join("new"); - - // GNU diff starts from the end of the file, so every command uses the - // line numbers of the original file. - std::fs::write(&old, "a\nb\nc\nd\ne\n")?; - std::fs::write(&new, "b\nd\n")?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("-e").arg(&old).arg(&new); - cmd.assert().code(predicate::eq(1)).stdout("5d\n3d\n1d\n"); - - std::fs::write(&old, "a\nb\n")?; - std::fs::write(&new, "X\na\nb\nY\n")?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("-e").arg(&old).arg(&new); - cmd.assert() - .code(predicate::eq(1)) - .stdout("2a\nY\n.\n0a\nX\n.\n"); - - std::fs::write(&old, "a\nb\nc\nd\n")?; - std::fs::write(&new, "a\nX\nY\nc\n")?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("-e").arg(&old).arg(&new); - cmd.assert() - .code(predicate::eq(1)) - .stdout("4d\n2c\nX\nY\n.\n"); - Ok(()) +#[rstest] +#[case::delete_and_append( + "north\neast\nsouth\nwest\n", + "north\nsouth\nwest\nup\ndown\n", + "2d1\n< east\n4a4,5\n> up\n> down\n" +)] +#[case::append_to_empty("", "north\n", "0a1\n> north\n")] +#[case::append_one( + "north\neast\nsouth\nwest\n", + "north\neast\nsouth\nwest\nup\n", + "4a5\n> up\n" +)] +fn normal_format_single_line_ranges(#[case] old: &str, #[case] new: &str, #[case] expected: &str) { + let (at, ts) = at_and_ts!(); + at.write("old", old); + at.write("new", new); + + ts.ucmd() + .args(&["old", "new"]) + .fails_with_code(1) + .stdout_is(expected); } -#[test] -fn ed_format_dot_line_ends_text_once() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let old = tmp_dir.path().join("old"); - let new = tmp_dir.path().join("new"); - std::fs::write(&old, "a\nb\n")?; - - // A "." line is written as "..", then s/.// fixes it. Like GNU diff, no - // empty "a" command follows when it is the last line of the hunk. - for (contents, expected) in [ - ("a\nb\n.\n", "2a\n..\n.\ns/.//\n"), - (".\n.\nb\n", "1c\n..\n.\ns/.//\na\n..\n.\ns/.//\n"), - ("a\n.\nc\n", "2c\n..\n.\ns/.//\na\nc\n.\n"), - ] { - std::fs::write(&new, contents)?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("-e").arg(&old).arg(&new); - cmd.assert().code(predicate::eq(1)).stdout(expected); - } - Ok(()) +#[rstest] +#[case::single_line_deletion( + "red\norange\nyellow\ngreen\nblue\n", + "red\norange\nyellow\nblue\n", + "4d\n" +)] +#[case::range_deletion("red\norange\nyellow\ngreen\nblue\n", "red\nblue\n", "2,4d\n")] +// GNU diff starts from the end of the file, so every command uses the line +// numbers of the original file. +#[case::deletions_last_to_first("a\nb\nc\nd\ne\n", "b\nd\n", "5d\n3d\n1d\n")] +#[case::appends_last_to_first("a\nb\n", "X\na\nb\nY\n", "2a\nY\n.\n0a\nX\n.\n")] +#[case::change_after_deletion("a\nb\nc\nd\n", "a\nX\nY\nc\n", "4d\n2c\nX\nY\n.\n")] +// A "." line is written as "..", then s/.// fixes it. Like GNU diff, no empty +// "a" command follows when it is the last line of the hunk. +#[case::dot_line_appended("a\nb\n", "a\nb\n.\n", "2a\n..\n.\ns/.//\n")] +#[case::dot_lines_changed("a\nb\n", ".\n.\nb\n", "1c\n..\n.\ns/.//\na\n..\n.\ns/.//\n")] +#[case::dot_line_in_change("a\nb\n", "a\n.\nc\n", "2c\n..\n.\ns/.//\na\nc\n.\n")] +fn ed_format(#[case] old: &str, #[case] new: &str, #[case] expected: &str) { + let (at, ts) = at_and_ts!(); + at.write("old", old); + at.write("new", new); + + ts.ucmd() + .args(&["-e", "old", "new"]) + .fails_with_code(1) + .stdout_is(expected); } #[test] -fn function_lines() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let old = tmp_dir.path().join("old.c"); - let new = tmp_dir.path().join("new.c"); - std::fs::write( - &old, +fn function_lines() { + let (at, ts) = at_and_ts!(); + at.write( + "old.c", "int zero;\nstatic int twice(int n)\n{\n int r;\n r = n * 2;\n return r;\n}\n", - )?; - std::fs::write( - &new, + ); + at.write( + "new.c", "int zero;\nstatic int twice(int n)\n{\n int r;\n r = n + n;\n return r;\n}\n", - )?; + ); // -p defaults to the context format and shows the enclosing C function. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg("-p").arg("-C1").arg(&old).arg(&new); - cmd.assert() - .code(predicate::eq(1)) - .stdout(predicate::str::contains( - "\n*************** static int twice(int n)\n*** 4,6 ****\n", - )); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-U0") - .arg("-F") - .arg("^int") - .arg(&old) - .arg(&new); - cmd.assert() - .code(predicate::eq(1)) - .stdout(predicate::str::ends_with( - "@@ -5 +5 @@ int zero;\n- r = n * 2;\n+ r = n + n;\n", - )); - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-u") - .arg("-F") - .arg("\\(") - .arg(&old) - .arg(&new); - cmd.assert() - .code(predicate::eq(2)) - .stderr("'\\(': Unmatched ( or \\(\n"); - Ok(()) + ts.ucmd() + .args(&["-p", "-C1", "old.c", "new.c"]) + .fails_with_code(1) + .stdout_contains("\n*************** static int twice(int n)\n*** 4,6 ****\n"); + + ts.ucmd() + .args(&["-U0", "-F", "^int", "old.c", "new.c"]) + .fails_with_code(1) + .stdout_str_check(|s| s.ends_with("@@ -5 +5 @@ int zero;\n- r = n * 2;\n+ r = n + n;\n")); + + ts.ucmd() + .args(&["-u", "-F", "\\(", "old.c", "new.c"]) + .fails_with_code(2) + .stderr_is("'\\(': Unmatched ( or \\(\n"); } #[cfg(unix)] #[test] -fn quoted_file_names() -> Result<(), Box> { - let tmp_dir = tempdir()?; - let dir = tmp_dir.path().to_str().unwrap(); - std::fs::write(tmp_dir.path().join("my notes"), "draft\n")?; - std::fs::write(tmp_dir.path().join("final\tv2"), "done\n")?; - std::fs::write(tmp_dir.path().join("plain$name"), "done\n")?; - - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.env("TZ", "UTC0") - .arg("diff") - .arg("-u") - .arg(format!("{dir}/my notes")) - .arg(format!("{dir}/final\tv2")); - cmd.assert() - .code(predicate::eq(1)) - .stdout(predicate::str::is_match(format!( - "^--- \"{dir}/my notes\"\t[^\n]*\n\\+\\+\\+ \"{dir}/final\\\\tv2\"\t" - ))?); +fn quoted_file_names() { + let (at, ts) = at_and_ts!(); + at.write("my notes", "draft\n"); + at.write("final\tv2", "done\n"); + at.write("plain$name", "done\n"); + + ts.ucmd() + .args(&["-u", "my notes", "final\tv2"]) + .fails_with_code(1) + .stdout_matches( + ®ex::Regex::new("^--- \"my notes\"\t[^\n]*\n\\+\\+\\+ \"final\\\\tv2\"\t").unwrap(), + ); // Names without special characters are left alone. - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-c") - .arg(format!("{dir}/my notes")) - .arg(format!("{dir}/plain$name")); - cmd.assert() - .code(predicate::eq(1)) - .stdout(predicate::str::contains(format!( - "\n--- {dir}/plain$name\t" - ))); + ts.ucmd() + .args(&["-c", "my notes", "plain$name"]) + .fails_with_code(1) + .stdout_contains("\n--- plain$name\t"); // The diff -r header quotes the options for the shell and the names as // in the other headers. for (side, content) in [("one", "a\n"), ("two", "b\n")] { - std::fs::create_dir(tmp_dir.path().join(side))?; - std::fs::write(tmp_dir.path().join(side).join("my file"), content)?; + at.mkdir(side); + at.write(&format!("{side}/my file"), content); } - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.current_dir(&tmp_dir) - .arg("diff") - .arg("-r") - .arg("-F") - .arg("my func") - .arg("one") - .arg("two"); - cmd.assert() - .code(predicate::eq(1)) - .stdout("diff -r -F 'my func' \"one/my file\" \"two/my file\"\n1c1\n< a\n---\n> b\n"); - Ok(()) -} - -#[test] -fn extra_operand_after_double_dash() -> Result<(), Box> { - let mut old = NamedTempFile::new()?; - old.write_all(b"a\nb\n")?; - let mut new = NamedTempFile::new()?; - new.write_all(b"a\nc\n")?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("--") - .arg(old.path()) - .arg(new.path()) - .arg("extra"); - cmd.assert() - .code(predicate::eq(2)) - .stdout(predicate::str::is_empty()) - .stderr(predicate::str::contains("extra operand 'extra'")); - Ok(()) + ts.ucmd() + .args(&["-r", "-F", "my func", "one", "two"]) + .fails_with_code(1) + .stdout_is("diff -r -F 'my func' \"one/my file\" \"two/my file\"\n1c1\n< a\n---\n> b\n"); } -#[test] -fn extra_operand_without_double_dash() -> Result<(), Box> { - let mut old = NamedTempFile::new()?; - old.write_all(b"a\nb\n")?; - let mut new = NamedTempFile::new()?; - new.write_all(b"a\nc\n")?; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff").arg(old.path()).arg(new.path()).arg("extra"); - cmd.assert() - .code(predicate::eq(2)) - .stdout(predicate::str::is_empty()) - .stderr("diff: extra operand 'extra'\ndiff: Try 'diff --help' for more information.\n"); - Ok(()) +#[rstest] +#[case::after_double_dash(&["--", "old", "new", "extra"])] +#[case::without_double_dash(&["old", "new", "extra"])] +fn extra_operand(#[case] args: &[&str]) { + let (at, ts) = at_and_ts!(); + at.write("old", "a\nb\n"); + at.write("new", "a\nc\n"); + ts.ucmd() + .args(args) + .fails_with_code(2) + .no_stdout() + .stderr_is("diff: extra operand 'extra'\ndiff: Try 'diff --help' for more information.\n"); } -#[test] -fn trailing_context_without_final_newlines() -> Result<(), Box> { - let mut file1 = NamedTempFile::new()?; - file1.write_all(b"1\n2\n3\n4\n5\n6\n7\n8")?; - let mut file2 = NamedTempFile::new()?; - file2.write_all(b"1\nX\n3\n4\n5\n6\n7\n8")?; - - for (format, hunk) in [ - ("-u", "@@ -1,5 +1,5 @@\n 1\n-2\n+X\n 3\n 4\n 5\n"), - ( - "-c", - "*** 1,5 ****\n 1\n! 2\n 3\n 4\n 5\n--- 1,5 ----\n 1\n! X\n 3\n 4\n 5\n", - ), - ] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg(format) - .arg(file1.path()) - .arg(file2.path()); - cmd.assert() - .code(predicate::eq(1)) - .stdout(predicate::str::ends_with(hunk)); - } - - // the last line is still shown when it is within the trailing context - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-U5") - .arg(file1.path()) - .arg(file2.path()); - cmd.assert() - .code(predicate::eq(1)) - .stdout(predicate::str::ends_with( - "@@ -1,7 +1,7 @@\n 1\n-2\n+X\n 3\n 4\n 5\n 6\n 7\n", - )); - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff") - .arg("-U6") - .arg(file1.path()) - .arg(file2.path()); - cmd.assert() - .code(predicate::eq(1)) - .stdout(predicate::str::ends_with( - "@@ -1,8 +1,8 @@\n 1\n-2\n+X\n 3\n 4\n 5\n 6\n 7\n 8\n\\ No newline at end of file\n", - )); - Ok(()) +#[rstest] +#[case::unified("-u", "@@ -1,5 +1,5 @@\n 1\n-2\n+X\n 3\n 4\n 5\n")] +#[case::context( + "-c", + "*** 1,5 ****\n 1\n! 2\n 3\n 4\n 5\n--- 1,5 ----\n 1\n! X\n 3\n 4\n 5\n" +)] +// the last line is still shown when it is within the trailing context +#[case::up_to_last_line("-U5", "@@ -1,7 +1,7 @@\n 1\n-2\n+X\n 3\n 4\n 5\n 6\n 7\n")] +#[case::last_line( + "-U6", + "@@ -1,8 +1,8 @@\n 1\n-2\n+X\n 3\n 4\n 5\n 6\n 7\n 8\n\\ No newline at end of file\n" +)] +fn trailing_context_without_final_newlines(#[case] format: &str, #[case] hunk: &str) { + let (at, ts) = at_and_ts!(); + at.write("file1", "1\n2\n3\n4\n5\n6\n7\n8"); + at.write("file2", "1\nX\n3\n4\n5\n6\n7\n8"); + + ts.ucmd() + .args(&[format, "file1", "file2"]) + .fails_with_code(1) + .stdout_str_check(|s| s.ends_with(hunk)); } diff --git a/tests/test_common.rs b/tests/test_common.rs index fcaeb719..e42138f4 100644 --- a/tests/test_common.rs +++ b/tests/test_common.rs @@ -3,86 +3,61 @@ // For the full copyright and license information, please view the LICENSE-* // files that was distributed with this source code. -use assert_cmd::cargo::cargo_bin_cmd; -use predicates::prelude::*; -use tempfile::NamedTempFile; +use rstest::rstest; +use uutests::util::TestScenario; -#[test] -fn unknown_param() -> Result<(), Box> { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("patch"); - cmd.assert() - .code(predicate::eq(2)) - .failure() - .stderr(predicate::eq("patch: utility not supported\n")); +use crate::TESTS_BINARY; - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.assert() - .code(predicate::eq(0)) - .success() - .stderr(predicate::str::starts_with( - "Expected utility name as second argument, got nothing.\n", - )); +#[cfg(not(windows))] +const NOT_FOUND: &str = "No such file or directory"; +#[cfg(windows)] +const NOT_FOUND: &str = "The system cannot find the file specified."; - for subcmd in ["diff", "cmp", "uu-diff", "uucmp"] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg(subcmd); - cmd.arg("--foobar"); - cmd.assert() - .code(predicate::eq(2)) - .failure() - .stderr(predicate::str::contains("unrecognized option '--foobar'")); - } - Ok(()) +#[test] +fn unsupported_utility() { + TestScenario::new("patch") + .ucmd() + .fails_with_code(2) + .stderr_is("patch: utility not supported\n"); } #[test] -fn cannot_read_files() -> Result<(), Box> { - let file = NamedTempFile::new()?; - - let nofile = NamedTempFile::new()?; - let nopath = nofile.into_temp_path(); - std::fs::remove_file(&nopath)?; - - #[cfg(not(windows))] - let error_message = "No such file or directory"; - #[cfg(windows)] - let error_message = "The system cannot find the file specified."; - - for subcmd in ["diff", "cmp"] { - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg(subcmd); - cmd.arg(&nopath).arg(file.path()); - cmd.assert() - .code(predicate::eq(2)) - .failure() - .stderr(predicate::str::ends_with(format!( - ": {}: {error_message}\n", - &nopath.as_os_str().to_string_lossy() - ))); +fn missing_utility() { + let ts = TestScenario::new("diffutils"); + ts.cmd(TESTS_BINARY).succeeds().stderr_str_check(|s| { + s.starts_with("Expected utility name as second argument, got nothing.\n") + }); +} - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg(subcmd); - cmd.arg(file.path()).arg(&nopath); - cmd.assert() - .code(predicate::eq(2)) - .failure() - .stderr(predicate::str::ends_with(format!( - ": {}: {error_message}\n", - &nopath.as_os_str().to_string_lossy() - ))); - } +#[rstest] +fn unknown_param(#[values("diff", "cmp", "uu-diff", "uucmp")] utility: &str) { + TestScenario::new(utility) + .ucmd() + .arg("--foobar") + .fails_with_code(2) + .stderr_contains("unrecognized option '--foobar'"); +} - let mut cmd = cargo_bin_cmd!("diffutils"); - cmd.arg("diff"); - cmd.arg(&nopath).arg(&nopath); - cmd.assert().code(predicate::eq(2)).failure().stderr( - predicate::str::contains(format!( - ": {}: {error_message}\n", - &nopath.as_os_str().to_string_lossy() - )) - .count(2), - ); +#[rstest] +fn cannot_read_files( + #[values("diff", "cmp")] utility: &str, + #[values(["nofile", "file"], ["file", "nofile"])] operands: [&str; 2], +) { + let ts = TestScenario::new(utility); + ts.fixtures.touch("file"); + + ts.ucmd() + .args(&operands) + .fails_with_code(2) + .stderr_str_check(|s| s.ends_with(&format!(": nofile: {NOT_FOUND}\n"))); +} - Ok(()) +#[test] +fn cannot_read_both_files() { + let expected = format!(": nofile: {NOT_FOUND}\n"); + TestScenario::new("diff") + .ucmd() + .args(&["nofile", "nofile"]) + .fails_with_code(2) + .stderr_str_check(|s| s.matches(&expected).count() == 2); } diff --git a/tests/tests.rs b/tests/tests.rs index 43b1de17..2a1076f6 100644 --- a/tests/tests.rs +++ b/tests/tests.rs @@ -3,6 +3,17 @@ // For the full copyright and license information, please view the LICENSE-* // files that was distributed with this source code. +use std::env; + +pub const TESTS_BINARY: &str = env!("CARGO_BIN_EXE_diffutils"); + +// uutests runs the binary named by UUTESTS_BINARY_PATH, with the utility name +// as its first argument. +#[ctor::ctor(unsafe)] +fn init() { + env::set_var("UUTESTS_BINARY_PATH", TESTS_BINARY); +} + #[path = "test_common.rs"] mod test_common;