From 5363f350887b1e5b5dd21a86f88c8af9d7fea6da Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:18:25 +0200 Subject: Merging upstream version 1.67.1+dfsg1. Signed-off-by: Daniel Baumann --- vendor/pretty_assertions/.cargo-checksum.json | 2 +- vendor/pretty_assertions/CHANGELOG.md | 38 -- vendor/pretty_assertions/Cargo.lock | 19 +- vendor/pretty_assertions/Cargo.toml | 42 +- vendor/pretty_assertions/README.md | 32 +- .../examples/standard_assertion.rs | 19 +- vendor/pretty_assertions/scripts/check | 9 - vendor/pretty_assertions/scripts/install | 6 - vendor/pretty_assertions/scripts/publish | 11 - vendor/pretty_assertions/src/lib.rs | 515 ++++++++++----------- vendor/pretty_assertions/src/printer.rs | 164 ++++++- vendor/pretty_assertions/tests/macros.rs | 392 ++++++++++++++++ 12 files changed, 865 insertions(+), 384 deletions(-) delete mode 100644 vendor/pretty_assertions/CHANGELOG.md delete mode 100755 vendor/pretty_assertions/scripts/check delete mode 100755 vendor/pretty_assertions/scripts/install delete mode 100755 vendor/pretty_assertions/scripts/publish create mode 100644 vendor/pretty_assertions/tests/macros.rs (limited to 'vendor/pretty_assertions') diff --git a/vendor/pretty_assertions/.cargo-checksum.json b/vendor/pretty_assertions/.cargo-checksum.json index 74431486b..18577e97d 100644 --- a/vendor/pretty_assertions/.cargo-checksum.json +++ b/vendor/pretty_assertions/.cargo-checksum.json @@ -1 +1 @@ -{"files":{"CHANGELOG.md":"b330969d16e38104c91ad0ff518af97b1b58137f40a6e834f6da3018d35ae988","Cargo.lock":"b154588bf85189f112a7c1506448f8813316772fe17550a847183db274e4a8b3","Cargo.toml":"35d70dee35b4d888e622d0f770231055a8780e95463b32473fda8023ff7ca047","LICENSE-APACHE":"c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08","LICENSE-MIT":"8c9612877aacfa1b42f5e80b679e6c3c93a7ba2bb99dfaf6e87e200dca4b4e6c","README.md":"6988c526027f6920587923a870b6b5f6d816bb9114abbd9c41f251af986eb11e","examples/pretty_assertion.png":"a9a43d098b548cd222056e8f7391cc071ccd07372e9c44d10e254c0a683c7562","examples/pretty_assertion.rs":"41d0527d286baebe09149e33a9359c3e30c7fbfddd41995db4facdee291fcd2c","examples/pretty_assertion_v0_6_1.png":"c07a7a8cd56ebeb840ae8095c024957ddac8a1d011288acf7928f79d85b39e3a","examples/standard_assertion.png":"be6f676deb51d06bcb33f36d194c82228d5585d91f58af590d9040012e38a0a8","examples/standard_assertion.rs":"b520df96e468ab2a6f8b692d12a548a5a6dcbb8a7fb02a91aaad06ec7f1f3a60","scripts/check":"f323d7c808c8d2cfd8d57ff00b453a9b7c7c95dc0f1a7dfcf3c4d2ead3243c72","scripts/install":"311dd0a011d7e91f9e7df497b2d3b8d77ab2c77b136b7168ad104c82794c5d69","scripts/publish":"bae69134256065f3cd35478c67873ae99af680fc7d2ce4506bd391beed8e35ae","src/lib.rs":"b9fc488ea96d9aa3a902e0bb10d7ca0f83d817b06bb8735f901044126835506a","src/printer.rs":"10cb18c1451c6101e778f7d8e1a51a1ec0208c0ef06cf67dbe30d4805cf02a45"},"package":"1cab0e7c02cf376875e9335e0ba1da535775beb5450d21e1dffca068818ed98b"} \ No newline at end of file +{"files":{"Cargo.lock":"dc0a795e41222bca707fa04af294f8f8184a13bf9689a5160fa347c246484560","Cargo.toml":"89a0781c41f5e1da912bb4c3c617fe9eadc2ef4c326eeef9fd629b86071d3886","LICENSE-APACHE":"c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08","LICENSE-MIT":"8c9612877aacfa1b42f5e80b679e6c3c93a7ba2bb99dfaf6e87e200dca4b4e6c","README.md":"151448d7f24d09a9615d1d9cf38b50e6f0c2c1d8273a447d88d2b70f37a6617f","examples/pretty_assertion.png":"a9a43d098b548cd222056e8f7391cc071ccd07372e9c44d10e254c0a683c7562","examples/pretty_assertion.rs":"41d0527d286baebe09149e33a9359c3e30c7fbfddd41995db4facdee291fcd2c","examples/pretty_assertion_v0_6_1.png":"c07a7a8cd56ebeb840ae8095c024957ddac8a1d011288acf7928f79d85b39e3a","examples/standard_assertion.png":"be6f676deb51d06bcb33f36d194c82228d5585d91f58af590d9040012e38a0a8","examples/standard_assertion.rs":"70180f493795da15c82c0002c26249ef2a1b9fa81f6d0c9a8e0bf4e09121e041","src/lib.rs":"f2362e53eda818ad2fc970ed9803099f07b6c27622ac2154871549a991cdc3bc","src/printer.rs":"3ea14e1542a47c9909bc06a7b413262a6d86dfd22ca15b220d6f6ea48ad35c8e","tests/macros.rs":"cadb699c6d1bab26bb7ba044b1094fdc8a1f4f670d70dc38b7defea1a4dd41fb"},"package":"a25e9bcb20aa780fd0bb16b72403a9064d6b3f22f026946029acb941a50af755"} \ No newline at end of file diff --git a/vendor/pretty_assertions/CHANGELOG.md b/vendor/pretty_assertions/CHANGELOG.md deleted file mode 100644 index a5c81b75b..000000000 --- a/vendor/pretty_assertions/CHANGELOG.md +++ /dev/null @@ -1,38 +0,0 @@ -# Unreleased - -# v0.7.2 - -- Fix macro hygiene for expansion in a `no_implicit_prelude` context ([#70](https://github.com/colin-kiegel/rust-pretty-assertions/issues/70), [@tommilligan](https://github.com/tommilligan)) - -# v0.7.1 - -- Fix a bug where multiline changes showed an unhelpful inline diff ([#66](https://github.com/colin-kiegel/rust-pretty-assertions/issues/66), [@tommilligan](https://github.com/tommilligan)) - -# v0.7.0 - -## Changed - -- Move from `difference` to `diff` for calculating diffs. The exact assertion messages generated may differ from previous versions. ([#52](https://github.com/colin-kiegel/rust-pretty-assertions/issues/52), [@tommilligan](https://github.com/tommilligan)) - -For example, the following assertion message from `v0.7.0`: - -![pretty assertion](https://raw.githubusercontent.com/colin-kiegel/rust-pretty-assertions/2d2357ff56d22c51a86b2f1cfe6efcee9f5a8081/examples/pretty_assertion.png) - -Was previously rendered like this in `v0.6.1`: - -![pretty assertion](https://raw.githubusercontent.com/colin-kiegel/rust-pretty-assertions/2d2357ff56d22c51a86b2f1cfe6efcee9f5a8081/examples/pretty_assertion_v0_6_1.png) - -## Added - -- Support for unsized values ([#42](https://github.com/colin-kiegel/rust-pretty-assertions/issues/42), [@stanislav-tkach](https://github.com/stanislav-tkach)) -- Document the `Comparison` struct, which was previously hidden. This can be used to generate a pretty diff of two values without panicking. ([#52](https://github.com/colin-kiegel/rust-pretty-assertions/issues/52), [@tommilligan](https://github.com/tommilligan)) - -## Fixed - -- Fix some unhygenic macro expansions ([#41](https://github.com/colin-kiegel/rust-pretty-assertions/issues/41), [@tommilligan](https://github.com/tommilligan)) - -## Internal - -- Test Windows targets in CI ([#46](https://github.com/colin-kiegel/rust-pretty-assertions/issues/46), [@tommilligan](https://github.com/tommilligan)) -- Bump `ansi_term` version to 0.12 ([#34](https://github.com/colin-kiegel/rust-pretty-assertions/issues/34), [@waywardmonkeys](https://github.com/waywardmonkeys)) -- Code health improvements ([#34](https://github.com/colin-kiegel/rust-pretty-assertions/issues/34), [@waywardmonkeys](https://github.com/waywardmonkeys)) diff --git a/vendor/pretty_assertions/Cargo.lock b/vendor/pretty_assertions/Cargo.lock index 8e433f023..baac97af0 100644 --- a/vendor/pretty_assertions/Cargo.lock +++ b/vendor/pretty_assertions/Cargo.lock @@ -1,14 +1,5 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. -[[package]] -name = "ansi_term" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2" -dependencies = [ - "winapi", -] - [[package]] name = "ctor" version = "0.1.19" @@ -36,12 +27,12 @@ dependencies = [ [[package]] name = "pretty_assertions" -version = "0.7.2" +version = "1.3.0" dependencies = [ - "ansi_term", "ctor", "diff", "output_vt100", + "yansi", ] [[package]] @@ -100,3 +91,9 @@ name = "winapi-x86_64-pc-windows-gnu" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "yansi" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec" diff --git a/vendor/pretty_assertions/Cargo.toml b/vendor/pretty_assertions/Cargo.toml index 3f4660d5a..f8370f7c3 100644 --- a/vendor/pretty_assertions/Cargo.toml +++ b/vendor/pretty_assertions/Cargo.toml @@ -3,34 +3,48 @@ # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies +# to registry (e.g., crates.io) dependencies. # -# If you believe there's an error in this file please file an -# issue against the rust-lang/cargo repository. If you're -# editing this file be aware that the upstream Cargo.toml -# will likely look very different (and much more reasonable) +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. [package] edition = "2018" name = "pretty_assertions" -version = "0.7.2" -authors = ["Colin Kiegel ", "Florent Fayolle ", "Tom Milligan "] +version = "1.3.0" +authors = [ + "Colin Kiegel ", + "Florent Fayolle ", + "Tom Milligan ", +] description = "Overwrite `assert_eq!` and `assert_ne!` with drop-in replacements, adding colorful diffs." documentation = "https://docs.rs/pretty_assertions" readme = "README.md" -keywords = ["assert", "diff", "pretty", "color"] +keywords = [ + "assert", + "diff", + "pretty", + "color", +] categories = ["development-tools"] -license = "MIT/Apache-2.0" -repository = "https://github.com/colin-kiegel/rust-pretty-assertions" -[dependencies.ansi_term] -version = "0.12.1" +license = "MIT OR Apache-2.0" +repository = "https://github.com/rust-pretty-assertions/rust-pretty-assertions" [dependencies.diff] version = "0.1.12" + +[dependencies.yansi] +version = "0.5" + +[features] +alloc = [] +default = ["std"] +std = [] +unstable = [] + [target."cfg(windows)".dependencies.ctor] version = "0.1.9" [target."cfg(windows)".dependencies.output_vt100] version = "0.1.2" -[badges.travis-ci] -repository = "colin-kiegel/rust-pretty-assertions" diff --git a/vendor/pretty_assertions/README.md b/vendor/pretty_assertions/README.md index cc9a6ef74..d9a5739b7 100644 --- a/vendor/pretty_assertions/README.md +++ b/vendor/pretty_assertions/README.md @@ -1,9 +1,13 @@ -[![Build status](https://travis-ci.org/colin-kiegel/rust-pretty-assertions.svg?branch=master)](https://travis-ci.org/colin-kiegel/rust-pretty-assertions) +# Pretty Assertions + [![Latest version](https://img.shields.io/crates/v/pretty-assertions.svg)](https://crates.io/crates/pretty-assertions) -[![All downloads](https://img.shields.io/crates/d/pretty-assertions.svg)](https://crates.io/crates/pretty-assertions) +[![docs.rs](https://img.shields.io/docsrs/pretty_assertions)](https://docs.rs/pretty_assertions) [![Downloads of latest version](https://img.shields.io/crates/dv/pretty-assertions.svg)](https://crates.io/crates/pretty-assertions) +[![All downloads](https://img.shields.io/crates/d/pretty-assertions.svg)](https://crates.io/crates/pretty-assertions) -# Pretty Assertions +Overwrite `assert_eq!` with a drop-in replacement, adding a colorful diff. + +## Usage When writing tests in Rust, you'll probably use `assert_eq!(a, b)` _a lot_. @@ -11,11 +15,11 @@ If such a test fails, it will present all the details of `a` and `b`. But you have to spot the differences yourself, which is not always straightforward, like here: -![standard assertion](https://raw.githubusercontent.com/colin-kiegel/rust-pretty-assertions/2d2357ff56d22c51a86b2f1cfe6efcee9f5a8081/examples/standard_assertion.png) +![standard assertion](https://raw.githubusercontent.com/rust-pretty-assertions/rust-pretty-assertions/2d2357ff56d22c51a86b2f1cfe6efcee9f5a8081/examples/standard_assertion.png) Wouldn't that task be _much_ easier with a colorful diff? -![pretty assertion](https://raw.githubusercontent.com/colin-kiegel/rust-pretty-assertions/2d2357ff56d22c51a86b2f1cfe6efcee9f5a8081/examples/pretty_assertion.png) +![pretty assertion](https://raw.githubusercontent.com/rust-pretty-assertions/rust-pretty-assertions/2d2357ff56d22c51a86b2f1cfe6efcee9f5a8081/examples/pretty_assertion.png) Yep — and you only need **one line of code** to make it happen: @@ -48,6 +52,13 @@ fn main() { +## Semantic Versioning + +The exact output of assertions is **not guaranteed** to be consistent over time, and may change between minor versions. +The output of this crate is designed to be read by a human. It is not suitable for exact comparison, for example in snapshot testing. + +This crate adheres to semantic versioning for publically exported crate items, **except** the `private` module, which may change between any version. + ## Tip Specify it as [`[dev-dependencies]`](http://doc.crates.io/specifying-dependencies.html#development-dependencies) @@ -61,7 +72,7 @@ Also add `#[cfg(test)]` to your `use` statements, like this: use pretty_assertions::{assert_eq, assert_ne}; ``` -## Note +## Notes - Since `Rust 2018` edition, you need to declare `use pretty_assertions::{assert_eq, assert_ne};` per module. @@ -74,6 +85,15 @@ use pretty_assertions::{assert_eq, assert_ne}; escape sequences, which may break display for certain use cases. - The minimum supported rust version (MSRV) is 1.35.0 +### `no_std` support + +For `no_std` support, disable the `std` feature and enable the `alloc` feature: + +```toml +# Cargo.toml +pretty_assertions = { version= "...", default-features = false, features = ["alloc"] } +``` + ## License Licensed under either of diff --git a/vendor/pretty_assertions/examples/standard_assertion.rs b/vendor/pretty_assertions/examples/standard_assertion.rs index fddd512f4..0a612c82e 100644 --- a/vendor/pretty_assertions/examples/standard_assertion.rs +++ b/vendor/pretty_assertions/examples/standard_assertion.rs @@ -1,11 +1,11 @@ -fn main() { - #[derive(Debug, PartialEq)] - struct Foo { - lorem: &'static str, - ipsum: u32, - dolor: Result, - } +#[derive(Debug, PartialEq)] +struct Foo { + lorem: &'static str, + ipsum: u32, + dolor: Result, +} +fn compare() { let x = Some(Foo { lorem: "Hello World!", ipsum: 42, @@ -19,3 +19,8 @@ fn main() { assert_eq!(x, y); } + +fn main() { + let result = std::panic::catch_unwind(compare); + assert!(result.is_err(), "example did not panic"); +} diff --git a/vendor/pretty_assertions/scripts/check b/vendor/pretty_assertions/scripts/check deleted file mode 100755 index 43fb3a9b3..000000000 --- a/vendor/pretty_assertions/scripts/check +++ /dev/null @@ -1,9 +0,0 @@ -#!/bin/bash - -set -exuo pipefail - -cargo fmt -- --check -cargo audit --deny warnings -cargo clippy --all-targets -- -D warnings -cargo test -cargo doc --no-deps diff --git a/vendor/pretty_assertions/scripts/install b/vendor/pretty_assertions/scripts/install deleted file mode 100755 index 92577640c..000000000 --- a/vendor/pretty_assertions/scripts/install +++ /dev/null @@ -1,6 +0,0 @@ -#!/bin/bash - -set -exuo pipefail - -rustup component add rustfmt clippy -cargo install cargo-audit cargo-tarpaulin diff --git a/vendor/pretty_assertions/scripts/publish b/vendor/pretty_assertions/scripts/publish deleted file mode 100755 index e904f03eb..000000000 --- a/vendor/pretty_assertions/scripts/publish +++ /dev/null @@ -1,11 +0,0 @@ -#!/bin/bash - -set -euxo pipefail - -# Don't log the cargo login token while authenticating -set +x -echo "cargo login ***********************************" -cargo login "${CARGO_LOGIN_TOKEN}" -set -x - -cargo publish diff --git a/vendor/pretty_assertions/src/lib.rs b/vendor/pretty_assertions/src/lib.rs index 5c1787533..aebe08776 100644 --- a/vendor/pretty_assertions/src/lib.rs +++ b/vendor/pretty_assertions/src/lib.rs @@ -6,11 +6,11 @@ //! But you have to spot the differences yourself, which is not always straightforward, //! like here: //! -//! ![standard assertion](https://raw.githubusercontent.com/colin-kiegel/rust-pretty-assertions/2d2357ff56d22c51a86b2f1cfe6efcee9f5a8081/examples/standard_assertion.png) +//! ![standard assertion](https://raw.githubusercontent.com/rust-pretty-assertions/rust-pretty-assertions/2d2357ff56d22c51a86b2f1cfe6efcee9f5a8081/examples/standard_assertion.png) //! //! Wouldn't that task be _much_ easier with a colorful diff? //! -//! ![pretty assertion](https://raw.githubusercontent.com/colin-kiegel/rust-pretty-assertions/2d2357ff56d22c51a86b2f1cfe6efcee9f5a8081/examples/pretty_assertion.png) +//! ![pretty assertion](https://raw.githubusercontent.com/rust-pretty-assertions/rust-pretty-assertions/2d2357ff56d22c51a86b2f1cfe6efcee9f5a8081/examples/pretty_assertion.png) //! //! Yep — and you only need **one line of code** to make it happen: //! @@ -62,11 +62,25 @@ //! you include. //! * `assert_ne` is also switched to multi-line presentation, but does _not_ show //! a diff. - +//! +//! ## Features +//! +//! Features provided by the crate are: +//! +//! - `std`: Use the Rust standard library. Enabled by default. +//! Exactly one of `std` and `alloc` is required. +//! - `alloc`: Use the `alloc` crate. +//! Exactly one of `std` and `alloc` is required. +//! - `unstable`: opt-in to unstable features that may not follow Semantic Versioning. +//! Implmenetion behind this feature is subject to change without warning between patch versions. + +#![cfg_attr(not(feature = "std"), no_std)] #![deny(clippy::all, missing_docs, unsafe_code)] -pub use ansi_term::Style; -use std::fmt::{self, Debug, Display}; +#[cfg(feature = "alloc")] +#[macro_use] +extern crate alloc; +use core::fmt::{self, Debug, Display}; mod printer; @@ -126,12 +140,82 @@ where } } +/// A comparison of two strings. +/// +/// In contrast to [`Comparison`], which uses the [`core::fmt::Debug`] representation, +/// `StrComparison` uses the string values directly, resulting in multi-line output for multiline strings. +/// +/// ``` +/// use pretty_assertions::StrComparison; +/// +/// print!("{}", StrComparison::new("foo\nbar", "foo\nbaz")); +/// ``` +/// +/// ## Value type bounds +/// +/// Any value that can be referenced as a [`str`] via [`AsRef`] may be used: +/// +/// ``` +/// use pretty_assertions::StrComparison; +/// +/// #[derive(PartialEq)] +/// struct MyString(String); +/// +/// impl AsRef for MyString { +/// fn as_ref(&self) -> &str { +/// &self.0 +/// } +/// } +/// +/// print!( +/// "{}", +/// StrComparison::new( +/// &MyString("foo\nbar".to_owned()), +/// &MyString("foo\nbaz".to_owned()), +/// ), +/// ); +/// ``` +/// +/// The values may have different types, although in practice they are usually the same. +pub struct StrComparison<'a, TLeft, TRight> +where + TLeft: ?Sized, + TRight: ?Sized, +{ + left: &'a TLeft, + right: &'a TRight, +} + +impl<'a, TLeft, TRight> StrComparison<'a, TLeft, TRight> +where + TLeft: AsRef + ?Sized, + TRight: AsRef + ?Sized, +{ + /// Store two values to be compared in future. + /// + /// Expensive diffing is deferred until calling `Debug::fmt`. + pub fn new(left: &'a TLeft, right: &'a TRight) -> StrComparison<'a, TLeft, TRight> { + StrComparison { left, right } + } +} + +impl<'a, TLeft, TRight> Display for StrComparison<'a, TLeft, TRight> +where + TLeft: AsRef + ?Sized, + TRight: AsRef + ?Sized, +{ + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + printer::write_header(f)?; + printer::write_lines(f, self.left.as_ref(), self.right.as_ref()) + } +} + /// Asserts that two expressions are equal to each other (using [`PartialEq`]). /// /// On panic, this macro will print a diff derived from [`Debug`] representation of /// each value. /// -/// This is a drop in replacement for [`std::assert_eq!`]. +/// This is a drop in replacement for [`core::assert_eq!`]. /// You can provide a custom panic message if desired. /// /// # Examples @@ -147,32 +231,70 @@ where /// ``` #[macro_export] macro_rules! assert_eq { - ($left:expr , $right:expr,) => ({ - $crate::assert_eq!($left, $right) + ($left:expr, $right:expr$(,)?) => ({ + $crate::assert_eq!(@ $left, $right, "", ""); + }); + ($left:expr, $right:expr, $($arg:tt)*) => ({ + $crate::assert_eq!(@ $left, $right, ": ", $($arg)+); }); - ($left:expr , $right:expr) => ({ + (@ $left:expr, $right:expr, $maybe_colon:expr, $($arg:tt)*) => ({ match (&($left), &($right)) { (left_val, right_val) => { if !(*left_val == *right_val) { - ::std::panic!("assertion failed: `(left == right)`\ - \n\ - \n{}\ - \n", - $crate::Comparison::new(left_val, right_val)) + use $crate::private::CreateComparison; + ::core::panic!("assertion failed: `(left == right)`{}{}\ + \n\ + \n{}\ + \n", + $maybe_colon, + format_args!($($arg)*), + (left_val, right_val).create_comparison() + ) } } } }); - ($left:expr , $right:expr, $($arg:tt)*) => ({ +} + +/// Asserts that two expressions are equal to each other (using [`PartialEq`]). +/// +/// On panic, this macro will print a diff derived from each value's [`str`] representation. +/// See [`StrComparison`] for further details. +/// +/// This is a drop in replacement for [`core::assert_eq!`]. +/// You can provide a custom panic message if desired. +/// +/// # Examples +/// +/// ``` +/// use pretty_assertions::assert_str_eq; +/// +/// let a = "foo\nbar"; +/// let b = ["foo", "bar"].join("\n"); +/// assert_str_eq!(a, b); +/// +/// assert_str_eq!(a, b, "we are testing concatenation with {} and {}", a, b); +/// ``` +#[macro_export] +macro_rules! assert_str_eq { + ($left:expr, $right:expr$(,)?) => ({ + $crate::assert_str_eq!(@ $left, $right, "", ""); + }); + ($left:expr, $right:expr, $($arg:tt)*) => ({ + $crate::assert_str_eq!(@ $left, $right, ": ", $($arg)+); + }); + (@ $left:expr, $right:expr, $maybe_colon:expr, $($arg:tt)*) => ({ match (&($left), &($right)) { (left_val, right_val) => { if !(*left_val == *right_val) { - ::std::panic!("assertion failed: `(left == right)`: {}\ - \n\ - \n{}\ - \n", - format_args!($($arg)*), - $crate::Comparison::new(left_val, right_val)) + ::core::panic!("assertion failed: `(left == right)`{}{}\ + \n\ + \n{}\ + \n", + $maybe_colon, + format_args!($($arg)*), + $crate::StrComparison::new(left_val, right_val) + ) } } } @@ -184,7 +306,7 @@ macro_rules! assert_eq { /// On panic, this macro will print the values of the expressions with their /// [`Debug`] representations. /// -/// This is a drop in replacement for [`std::assert_ne!`]. +/// This is a drop in replacement for [`core::assert_ne!`]. /// You can provide a custom panic message if desired. /// /// # Examples @@ -200,276 +322,145 @@ macro_rules! assert_eq { /// ``` #[macro_export] macro_rules! assert_ne { - ($left:expr, $right:expr) => ({ - $crate::assert_ne!(@ $left, $right, "", ""); - }); - ($left:expr, $right:expr,) => ({ + ($left:expr, $right:expr$(,)?) => ({ $crate::assert_ne!(@ $left, $right, "", ""); }); ($left:expr, $right:expr, $($arg:tt)+) => ({ $crate::assert_ne!(@ $left, $right, ": ", $($arg)+); }); - (@ $left:expr, $right:expr, $maybe_semicolon:expr, $($arg:tt)+) => ({ + (@ $left:expr, $right:expr, $maybe_colon:expr, $($arg:tt)+) => ({ match (&($left), &($right)) { (left_val, right_val) => { if *left_val == *right_val { - let left_dbg = ::std::format!("{:?}", &*left_val); - let right_dbg = ::std::format!("{:?}", &*right_val); - if left_dbg != right_dbg { - - ::std::panic!("assertion failed: `(left != right)`{}{}\ - \n\ - \n{}\ - \n{}: According to the `PartialEq` implementation, both of the values \ - are partially equivalent, even if the `Debug` outputs differ.\ - \n\ - \n", - $maybe_semicolon, - format_args!($($arg)+), - $crate::Comparison::new(left_val, right_val), - $crate::Style::new() - .bold() - .underline() - .paint("Note")) - } - - ::std::panic!("assertion failed: `(left != right)`{}{}\ + ::core::panic!("assertion failed: `(left != right)`{}{}\ \n\ - \n{}:\ + \nBoth sides:\ \n{:#?}\ \n\ \n", - $maybe_semicolon, - format_args!($($arg)+), - $crate::Style::new().bold().paint("Both sides"), - left_val) + $maybe_colon, + format_args!($($arg)+), + left_val + ) } } } }); } -#[cfg(test)] -#[allow(clippy::eq_op)] -#[no_implicit_prelude] -mod test { - mod assert_eq { - use ::std::string::{String, ToString}; - - #[test] - fn passes() { - let a = "some value"; - crate::assert_eq!(a, a); - } - - #[test] - fn passes_unsized() { - let a: &[u8] = b"e"; - crate::assert_eq!(*a, *a); - } - - #[test] - fn passes_comparable_types() { - let s0: &'static str = "foo"; - let s1: String = "foo".to_string(); - crate::assert_eq!(s0, s1); - } - - #[test] - #[should_panic(expected = r#"assertion failed: `(left == right)` - -Diff < left / right > : -<666 ->999 - -"#)] - fn fails() { - crate::assert_eq!(666, 999); - } - - #[test] - #[should_panic(expected = r#"assertion failed: `(left == right)` - -Diff < left / right > : -<666 ->999 - -"#)] - fn fails_trailing_comma() { - crate::assert_eq!(666, 999,); +/// Asserts that a value matches a pattern. +/// +/// On panic, this macro will print a diff derived from [`Debug`] representation of +/// the value, and a string representation of the pattern. +/// +/// This is a drop in replacement for [`core::assert_matches::assert_matches!`]. +/// You can provide a custom panic message if desired. +/// +/// # Examples +/// +/// ``` +/// use pretty_assertions::assert_matches; +/// +/// let a = Some(3); +/// assert_matches!(a, Some(_)); +/// +/// assert_matches!(a, Some(value) if value > 2, "we are testing {:?} with a pattern", a); +/// ``` +/// +/// # Features +/// +/// Requires the `unstable` feature to be enabled. +/// +/// **Please note:** implementation under the `unstable` feature may be changed between +/// patch versions without warning. +#[cfg(feature = "unstable")] +#[macro_export] +macro_rules! assert_matches { + ($left:expr, $( $pattern:pat )|+ $( if $guard: expr )? $(,)?) => ({ + match $left { + $( $pattern )|+ $( if $guard )? => {} + ref left_val => { + $crate::assert_matches!( + @ + left_val, + ::core::stringify!($($pattern)|+ $(if $guard)?), + "", + "" + ); + } } - - #[test] - #[should_panic(expected = r#"assertion failed: `(left == right)` - -Diff < left / right > : - [ - 101, -> 101, - ] - -"#)] - fn fails_unsized() { - let a: &[u8] = b"e"; - let b: &[u8] = b"ee"; - crate::assert_eq!(*a, *b); + }); + ($left:expr, $( $pattern:pat )|+ $( if $guard: expr )?, $($arg:tt)+) => ({ + match $left { + $( $pattern )|+ $( if $guard )? => {} + ref left_val => { + $crate::assert_matches!( + @ + left_val, + ::core::stringify!($($pattern)|+ $(if $guard)?), + ": ", + $($arg)+ + ); + } } - #[test] - #[should_panic( - expected = r#"assertion failed: `(left == right)`: custom panic message - -Diff < left / right > : -<666 ->999 + }); + (@ $left:expr, $right:expr, $maybe_colon:expr, $($arg:tt)*) => ({ + match (&($left), &($right)) { + (left_val, right_val) => { + // Use the Display implementation to display the pattern, + // as using Debug would add another layer of quotes to the output. + struct Pattern<'a>(&'a str); + impl ::core::fmt::Debug for Pattern<'_> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + ::core::fmt::Display::fmt(self.0, f) + } + } -"# - )] - fn fails_custom() { - crate::assert_eq!(666, 999, "custom panic message"); + ::core::panic!("assertion failed: `(left matches right)`{}{}\ + \n\ + \n{}\ + \n", + $maybe_colon, + format_args!($($arg)*), + $crate::Comparison::new(left_val, &Pattern(right_val)) + ) + } } + }); +} - #[test] - #[should_panic( - expected = r#"assertion failed: `(left == right)`: custom panic message +// Not public API. Used by the expansion of this crate's assert macros. +#[doc(hidden)] +pub mod private { + #[cfg(feature = "alloc")] + use alloc::string::String; -Diff < left / right > : -<666 ->999 + pub trait CompareAsStrByDefault: AsRef {} + impl CompareAsStrByDefault for str {} + impl CompareAsStrByDefault for String {} + impl CompareAsStrByDefault for &T {} -"# - )] - fn fails_custom_trailing_comma() { - crate::assert_eq!(666, 999, "custom panic message",); - } + pub trait CreateComparison { + type Comparison; + fn create_comparison(self) -> Self::Comparison; } - mod assert_ne { - use ::std::string::{String, ToString}; - - #[test] - fn passes() { - let a = "a"; - let b = "b"; - crate::assert_ne!(a, b); + impl<'a, T, U> CreateComparison for &'a (T, U) { + type Comparison = crate::Comparison<'a, T, U>; + fn create_comparison(self) -> Self::Comparison { + crate::Comparison::new(&self.0, &self.1) } + } - #[test] - fn passes_unsized() { - let a: &[u8] = b"e"; - let b: &[u8] = b"ee"; - crate::assert_ne!(*a, *b); - } - - #[test] - fn passes_comparable_types() { - let s0: &'static str = "foo"; - let s1: String = "bar".to_string(); - crate::assert_ne!(s0, s1); - } - - #[test] - #[should_panic(expected = r#"assertion failed: `(left != right)` - -Both sides: -666 -"#)] - fn fails() { - crate::assert_ne!(666, 666); - } - - #[test] - #[should_panic(expected = r#"assertion failed: `(left != right)` - -Both sides: -666 -"#)] - fn fails_trailing_comma() { - crate::assert_ne!(666, 666,); - } - - #[test] - #[should_panic(expected = r#"assertion failed: `(left != right)` - -Both sides: -[ - 101, -] - -"#)] - fn fails_unsized() { - let a: &[u8] = b"e"; - crate::assert_ne!(*a, *a); - } - - #[test] - #[should_panic( - expected = r#"assertion failed: `(left != right)`: custom panic message - -Both sides: -666 -"# - )] - fn fails_custom() { - crate::assert_ne!(666, 666, "custom panic message"); - } - - #[test] - #[should_panic( - expected = r#"assertion failed: `(left != right)`: custom panic message - -Both sides: -666 -"# - )] - fn fails_custom_trailing_comma() { - crate::assert_ne!(666, 666, "custom panic message",); - } - - // If the values are equal but their debug outputs are not - // show a specific warning - - #[test] - #[should_panic(expected = r#"assertion failed: `(left != right)` - -Diff < left / right > : -<-0.0 ->0.0 - -Note: According to the `PartialEq` implementation, both of the values are partially equivalent, even if the `Debug` outputs differ. - -"#)] - fn assert_ne_partial() { - // Workaround for https://github.com/rust-lang/rust/issues/47619 - // can be removed, when we require rust 1.25 or higher - struct Foo(f32); - - use ::std::fmt; - impl fmt::Debug for Foo { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - ::std::write!(f, "{:.1?}", self.0) - } - } - - impl ::std::cmp::PartialEq for Foo { - fn eq(&self, other: &Self) -> bool { - self.0 == other.0 - } - } - - crate::assert_ne!(Foo(-0.0), Foo(0.0)); - } - - // Regression tests - - #[test] - #[should_panic] - fn assert_ne_non_empty_return() { - fn not_zero(x: u32) -> u32 { - crate::assert_ne!(x, 0); - x - } - not_zero(0); + impl<'a, T, U> CreateComparison for (&'a T, &'a U) + where + T: CompareAsStrByDefault + ?Sized, + U: CompareAsStrByDefault + ?Sized, + { + type Comparison = crate::StrComparison<'a, T, U>; + fn create_comparison(self) -> Self::Comparison { + crate::StrComparison::new(self.0, self.1) } } } diff --git a/vendor/pretty_assertions/src/printer.rs b/vendor/pretty_assertions/src/printer.rs index 172b1ed6c..24c25f0b7 100644 --- a/vendor/pretty_assertions/src/printer.rs +++ b/vendor/pretty_assertions/src/printer.rs @@ -1,8 +1,10 @@ -use ansi_term::{ - Colour::{Fixed, Green, Red}, +#[cfg(feature = "alloc")] +use alloc::format; +use core::fmt; +use yansi::{ + Color::{Fixed, Green, Red, Unset}, Style, }; -use std::fmt; macro_rules! paint { ($f:expr, $colour:expr, $fmt:expr, $($args:tt)*) => ( @@ -18,7 +20,7 @@ pub(crate) fn write_header(f: &mut fmt::Formatter) -> fmt::Result { writeln!( f, "{} {} / {} :", - Style::new().bold().paint("Diff"), + Style::new(Unset).bold().paint("Diff"), Red.paint(format!("{} left", SIGN_LEFT)), Green.paint(format!("right {}", SIGN_RIGHT)) ) @@ -27,7 +29,7 @@ pub(crate) fn write_header(f: &mut fmt::Formatter) -> fmt::Result { /// Delay formatting this deleted chunk until later. /// /// It can be formatted as a whole chunk by calling `flush`, or the inner value -/// obtained with `take` for further processing. +/// obtained with `take` for further processing (such as an inline diff). #[derive(Default)] struct LatentDeletion<'a> { // The most recent deleted line we've seen @@ -45,7 +47,7 @@ impl<'a> LatentDeletion<'a> { /// Take the underlying chunk value, if it's suitable for inline diffing. /// - /// If there is no value of we've seen more than one line, return `None`. + /// If there is no value or we've seen more than one line, return `None`. fn take(&mut self) -> Option<&'a str> { if self.count == 1 { self.value.take() @@ -98,10 +100,6 @@ pub(crate) fn write_lines( previous_deletion.flush(f)?; previous_deletion.set(deleted); } - // Underlying diff library should never return this sequence - (::diff::Result::Right(_), Some(::diff::Result::Left(_))) => { - panic!("insertion followed by deletion"); - } // If we're being followed by more insertions, don't inline diff (::diff::Result::Right(inserted), Some(::diff::Result::Right(_))) => { previous_deletion.flush(f)?; @@ -141,7 +139,7 @@ where fn new(f: &'a mut Writer) -> Self { InlineWriter { f, - style: Style::new(), + style: Style::new(Unset), } } @@ -152,10 +150,11 @@ where write!(self.f, "{}", c)?; } else { // Close out previous style - write!(self.f, "{}", self.style.suffix())?; + self.style.fmt_suffix(self.f)?; // Store new style and start writing it - write!(self.f, "{}{}", style.prefix(), c)?; + style.fmt_prefix(self.f)?; + write!(self.f, "{}", c)?; self.style = style; } Ok(()) @@ -164,8 +163,9 @@ where /// Finish any existing style and reset to default state. fn finish(&mut self) -> fmt::Result { // Close out previous style - writeln!(self.f, "{}", self.style.suffix())?; - self.style = Default::default(); + self.style.fmt_suffix(self.f)?; + writeln!(self.f)?; + self.style = Style::new(Unset); Ok(()) } } @@ -180,8 +180,8 @@ fn write_inline_diff(f: &mut TWrite, left: &str, right: &str let mut writer = InlineWriter::new(f); // Print the left string on one line, with differences highlighted - let light = Red.into(); - let heavy = Red.on(Fixed(52)).bold(); + let light = Style::new(Red); + let heavy = Style::new(Red).bg(Fixed(52)).bold(); writer.write_with_style(&SIGN_LEFT, light)?; for change in diff.iter() { match change { @@ -193,8 +193,8 @@ fn write_inline_diff(f: &mut TWrite, left: &str, right: &str writer.finish()?; // Print the right string on one line, with differences highlighted - let light = Green.into(); - let heavy = Green.on(Fixed(22)).bold(); + let light = Style::new(Green); + let heavy = Style::new(Green).bg(Fixed(22)).bold(); writer.write_with_style(&SIGN_RIGHT, light)?; for change in diff.iter() { match change { @@ -210,6 +210,9 @@ fn write_inline_diff(f: &mut TWrite, left: &str, right: &str mod test { use super::*; + #[cfg(feature = "alloc")] + use alloc::string::String; + // ANSI terminal codes used in our outputs. // // Interpolate these into test strings to make expected values easier to read. @@ -230,6 +233,8 @@ mod test { let mut actual = String::new(); printer(&mut actual, left, right).expect("printer function failed"); + // Cannot use IO without stdlib + #[cfg(feature = "std")] println!( "## left ##\n\ {}\n\ @@ -471,4 +476,125 @@ Cabbage"#; check_printer(write_lines, left, right, &expected); } + + mod write_lines_edge_newlines { + use super::*; + + #[test] + fn both_trailing() { + let left = "fan\n"; + let right = "mug\n"; + // Note the additional space at the bottom is caused by a trailing newline + // adding an additional line with zero content to both sides of the diff + let expected = format!( + r#"{red_light}<{reset}{red_heavy}fan{reset} +{green_light}>{reset}{green_heavy}mug{reset} + +"#, + red_light = RED_LIGHT, + red_heavy = RED_HEAVY, + green_light = GREEN_LIGHT, + green_heavy = GREEN_HEAVY, + reset = RESET, + ); + + check_printer(write_lines, left, right, &expected); + } + + #[test] + fn both_leading() { + let left = "\nfan"; + let right = "\nmug"; + // Note the additional space at the top is caused by a leading newline + // adding an additional line with zero content to both sides of the diff + let expected = format!( + r#" +{red_light}<{reset}{red_heavy}fan{reset} +{green_light}>{reset}{green_heavy}mug{reset} +"#, + red_light = RED_LIGHT, + red_heavy = RED_HEAVY, + green_light = GREEN_LIGHT, + green_heavy = GREEN_HEAVY, + reset = RESET, + ); + + check_printer(write_lines, left, right, &expected); + } + + #[test] + fn leading_added() { + let left = "fan"; + let right = "\nmug"; + let expected = format!( + r#"{red_light}{reset} +{green_light}>mug{reset} +"#, + red_light = RED_LIGHT, + green_light = GREEN_LIGHT, + reset = RESET, + ); + + check_printer(write_lines, left, right, &expected); + } + + #[test] + fn leading_deleted() { + let left = "\nfan"; + let right = "mug"; + let expected = format!( + r#"{red_light}<{reset} +{red_light}mug{reset} +"#, + red_light = RED_LIGHT, + green_light = GREEN_LIGHT, + reset = RESET, + ); + + check_printer(write_lines, left, right, &expected); + } + + #[test] + fn trailing_added() { + let left = "fan"; + let right = "mug\n"; + let expected = format!( + r#"{red_light}mug{reset} +{green_light}>{reset} +"#, + red_light = RED_LIGHT, + green_light = GREEN_LIGHT, + reset = RESET, + ); + + check_printer(write_lines, left, right, &expected); + } + + /// Regression test for double abort + /// + /// See: https://github.com/rust-pretty-assertions/rust-pretty-assertions/issues/96 + #[test] + fn trailing_deleted() { + // The below inputs caused an abort via double panic + // we panicked at 'insertion followed by deletion' + let left = "fan\n"; + let right = "mug"; + let expected = format!( + r#"{red_light}<{reset}{red_heavy}fan{reset} +{green_light}>{reset}{green_heavy}mug{reset} +{red_light}<{reset} +"#, + red_light = RED_LIGHT, + red_heavy = RED_HEAVY, + green_light = GREEN_LIGHT, + green_heavy = GREEN_HEAVY, + reset = RESET, + ); + + check_printer(write_lines, left, right, &expected); + } + } } diff --git a/vendor/pretty_assertions/tests/macros.rs b/vendor/pretty_assertions/tests/macros.rs new file mode 100644 index 000000000..0ef251f14 --- /dev/null +++ b/vendor/pretty_assertions/tests/macros.rs @@ -0,0 +1,392 @@ +#![cfg_attr(not(feature = "std"), no_std)] +#![no_implicit_prelude] + +#[cfg(feature = "alloc")] +extern crate alloc; + +#[allow(clippy::eq_op)] +mod assert_str_eq { + use ::core::{cmp::PartialEq, convert::AsRef}; + + #[cfg(feature = "alloc")] + use ::alloc::string::{String, ToString}; + #[cfg(feature = "std")] + use ::std::string::{String, ToString}; + + #[test] + fn passes_str() { + let a = "some value"; + ::pretty_assertions::assert_str_eq!(a, a); + } + + #[test] + fn passes_string() { + let a: String = "some value".to_string(); + ::pretty_assertions::assert_str_eq!(a, a); + } + + #[test] + fn passes_comparable_types() { + let s0: &'static str = "foo"; + let s1: String = "foo".to_string(); + ::pretty_assertions::assert_str_eq!(s0, s1); + } + + #[derive(PartialEq)] + struct MyString(String); + + impl AsRef for MyString { + fn as_ref(&self) -> &str { + &self.0 + } + } + + impl PartialEq for MyString { + fn eq(&self, other: &String) -> bool { + &self.0 == other + } + } + + #[test] + fn passes_as_ref_types() { + let s0 = MyString("foo".to_string()); + let s1 = "foo".to_string(); + ::pretty_assertions::assert_str_eq!(s0, s1); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left == right)` + +Diff < left / right > : + foo +baz + +"#)] + fn fails_as_ref_types() { + let s0 = MyString("foo\nbar".to_string()); + let s1 = "foo\nbaz".to_string(); + ::pretty_assertions::assert_str_eq!(s0, s1); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left == right)` + +Diff < left / right > : + foo +baz + +"#)] + fn fails_foo() { + ::pretty_assertions::assert_str_eq!("foo\nbar", "foo\nbaz"); + } +} + +#[allow(clippy::eq_op)] +mod assert_eq { + #[cfg(feature = "alloc")] + use ::alloc::string::{String, ToString}; + #[cfg(feature = "std")] + use ::std::string::{String, ToString}; + + #[test] + fn passes() { + let a = "some value"; + ::pretty_assertions::assert_eq!(a, a); + } + + #[test] + fn passes_unsized() { + let a: &[u8] = b"e"; + ::pretty_assertions::assert_eq!(*a, *a); + } + + #[test] + fn passes_comparable_types() { + let s0: &'static str = "foo"; + let s1: String = "foo".to_string(); + ::pretty_assertions::assert_eq!(s0, s1); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left == right)` + +Diff < left / right > : +<666 +>999 + +"#)] + fn fails() { + ::pretty_assertions::assert_eq!(666, 999); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left == right)` + +Diff < left / right > : +<666 +>999 + +"#)] + fn fails_trailing_comma() { + ::pretty_assertions::assert_eq!(666, 999,); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left == right)` + +Diff < left / right > : + [ + 101, +> 101, + ] + +"#)] + fn fails_unsized() { + let a: &[u8] = b"e"; + let b: &[u8] = b"ee"; + ::pretty_assertions::assert_eq!(*a, *b); + } + + #[test] + #[should_panic( + expected = r#"assertion failed: `(left == right)`: custom panic message + +Diff < left / right > : +<666 +>999 + +"# + )] + fn fails_custom() { + ::pretty_assertions::assert_eq!(666, 999, "custom panic message"); + } + + #[test] + #[should_panic( + expected = r#"assertion failed: `(left == right)`: custom panic message + +Diff < left / right > : +<666 +>999 + +"# + )] + fn fails_custom_trailing_comma() { + ::pretty_assertions::assert_eq!(666, 999, "custom panic message",); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left == right)` + +Diff < left / right > : + foo +baz + +"#)] + fn fails_str() { + ::pretty_assertions::assert_eq!("foo\nbar", "foo\nbaz"); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left == right)` + +Diff < left / right > : + foo +baz + +"#)] + fn fails_string() { + ::pretty_assertions::assert_eq!("foo\nbar".to_string(), "foo\nbaz".to_string()); + } +} + +mod assert_ne { + #[cfg(feature = "alloc")] + use ::alloc::string::{String, ToString}; + #[cfg(feature = "std")] + use ::std::string::{String, ToString}; + + #[test] + fn passes() { + let a = "a"; + let b = "b"; + ::pretty_assertions::assert_ne!(a, b); + } + + #[test] + fn passes_unsized() { + let a: &[u8] = b"e"; + let b: &[u8] = b"ee"; + ::pretty_assertions::assert_ne!(*a, *b); + } + + #[test] + fn passes_comparable_types() { + let s0: &'static str = "foo"; + let s1: String = "bar".to_string(); + ::pretty_assertions::assert_ne!(s0, s1); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left != right)` + +Both sides: +666 +"#)] + fn fails() { + ::pretty_assertions::assert_ne!(666, 666); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left != right)` + +Both sides: +666 +"#)] + fn fails_trailing_comma() { + ::pretty_assertions::assert_ne!(666, 666,); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left != right)` + +Both sides: +[ + 101, +] + +"#)] + fn fails_unsized() { + let a: &[u8] = b"e"; + ::pretty_assertions::assert_ne!(*a, *a); + } + + #[test] + #[should_panic( + expected = r#"assertion failed: `(left != right)`: custom panic message + +Both sides: +666 +"# + )] + fn fails_custom() { + ::pretty_assertions::assert_ne!(666, 666, "custom panic message"); + } + + #[test] + #[should_panic( + expected = r#"assertion failed: `(left != right)`: custom panic message + +Both sides: +666 +"# + )] + fn fails_custom_trailing_comma() { + ::pretty_assertions::assert_ne!(666, 666, "custom panic message",); + } + + // If the values are equal but their debug outputs are not + // show a specific warning + + // Regression tests + + #[test] + #[should_panic] + fn assert_ne_non_empty_return() { + fn not_zero(x: u32) -> u32 { + ::pretty_assertions::assert_ne!(x, 0); + x + } + not_zero(0); + } +} + +#[cfg(feature = "unstable")] +mod assert_matches { + use ::core::option::Option::{None, Some}; + + #[test] + fn passes() { + let a = Some("some value"); + ::pretty_assertions::assert_matches!(a, Some(_)); + } + + #[test] + fn passes_unsized() { + let a: &[u8] = b"e"; + ::pretty_assertions::assert_matches!(*a, _); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left matches right)` + +Diff < left / right > : +<None +>Some(_) + +"#)] + fn fails() { + ::pretty_assertions::assert_matches!(None::, Some(_)); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left matches right)` + +Diff < left / right > : +Some(3) if 0 > 0 + +"#)] + fn fails_guard() { + ::pretty_assertions::assert_matches!(Some(3), Some(3) if 0 > 0,); + } + + #[test] + #[should_panic(expected = r#"assertion failed: `(left matches right)` + +Diff < left / right > : +<[ +< 101, +<] +>ref b if b == b"ee" + +"#)] + fn fails_unsized() { + let a: &[u8] = b"e"; + ::pretty_assertions::assert_matches!(*a, ref b if b == b"ee"); + } + + #[test] + #[should_panic( + expected = r#"assertion failed: `(left matches right)`: custom panic message + +Diff < left / right > : +<666 +>999 + +"# + )] + fn fails_custom() { + ::pretty_assertions::assert_matches!(666, 999, "custom panic message"); + } + + #[test] + #[should_panic( + expected = r#"assertion failed: `(left matches right)`: custom panic message + +Diff < left / right > : +<666 +>999 + +"# + )] + fn fails_custom_trailing_comma() { + ::pretty_assertions::assert_matches!(666, 999, "custom panic message",); + } +} -- cgit v1.2.3