assert_eq.rs

#![allow(clippy::eq_op)]

#[allow(unused_imports)]
use pretty_assertions::{assert_eq, assert_ne};
extern crate difference;

#[test]
#[should_panic(expected = r#"assertion failed: `(left == right)`

Diff < left / right > :
 Some(
     Foo {
<        lorem: "Hello World!",
>        lorem: "Hello Wrold!",
         ipsum: 42,
         dolor: Ok(
<            "hey",
>            "hey ho!",
         ),
     },
 )

"#)]
fn assert_eq() {
    #[derive(Debug, PartialEq)]
    struct Foo {
        lorem: &'static str,
        ipsum: u32,
        dolor: Result<String, String>,
    }

    let x = Some(Foo {
        lorem: "Hello World!",
        ipsum: 42,
        dolor: Ok("hey".to_string()),
    });
    let y = Some(Foo {
        lorem: "Hello Wrold!",
        ipsum: 42,
        dolor: Ok("hey ho!".to_string()),
    });

    assert_eq!(x, y);
}

#[test]
#[should_panic(
    expected = r#"assertion failed: `(left == right)`: custom panic message

Diff < left / right > :
 Some(
     Foo {
<        lorem: "Hello World!",
>        lorem: "Hello Wrold!",
         ipsum: 42,
         dolor: Ok(
<            "hey",
>            "hey ho!",
         ),
     },
 )

"#
)]
fn assert_eq_custom() {
    #[derive(Debug, PartialEq)]
    struct Foo {
        lorem: &'static str,
        ipsum: u32,
        dolor: Result<String, String>,
    }

    let x = Some(Foo {
        lorem: "Hello World!",
        ipsum: 42,
        dolor: Ok("hey".to_string()),
    });
    let y = Some(Foo {
        lorem: "Hello Wrold!",
        ipsum: 42,
        dolor: Ok("hey ho!".to_string()),
    });

    assert_eq!(x, y, "custom panic message");
}

#[test]
fn assert_eq_with_comparable_types() {
    let s0: &'static str = "foo";
    let s1: String = "foo".to_string();
    assert_eq!(s0, s1);
}

#[test]
#[should_panic(expected = r#"assertion failed: `(left == right)`

Diff < left / right > :
 [
<    0,
<    0,
<    0,
<    128,
<    10,
<    191,
<    5,
>    84,
>    248,
>    45,
     64,
 ]

"#)]
fn issue12() {
    let left = vec![0, 0, 0, 128, 10, 191, 5, 64];
    let right = vec![84, 248, 45, 64];
    assert_eq!(left, right);
}

#[test]
#[should_panic(expected = r#"assertion failed: `(left == right)`

Diff < left / right > :
 Some(
     Foo {
<        lorem: "Hello World!",
>        lorem: "Hello Wrold!",
         ipsum: 42,
         dolor: Ok(
<            "hey",
>            "hey ho!",
         ),
     },
 )

"#)]
fn assert_eq_trailing_comma() {
    #[derive(Debug, PartialEq)]
    struct Foo {
        lorem: &'static str,
        ipsum: u32,
        dolor: Result<String, String>,
    }

    let x = Some(Foo {
        lorem: "Hello World!",
        ipsum: 42,
        dolor: Ok("hey".to_string()),
    });
    let y = Some(Foo {
        lorem: "Hello Wrold!",
        ipsum: 42,
        dolor: Ok("hey ho!".to_string()),
    });

    assert_eq!(x, y,);
}

#[test]
#[should_panic(
    expected = r#"assertion failed: `(left == right)`: custom panic message

Diff < left / right > :
 Some(
     Foo {
<        lorem: "Hello World!",
>        lorem: "Hello Wrold!",
         ipsum: 42,
         dolor: Ok(
<            "hey",
>            "hey ho!",
         ),
     },
 )

"#
)]
fn assert_eq_custom_trailing_comma() {
    #[derive(Debug, PartialEq)]
    struct Foo {
        lorem: &'static str,
        ipsum: u32,
        dolor: Result<String, String>,
    }

    let x = Some(Foo {
        lorem: "Hello World!",
        ipsum: 42,
        dolor: Ok("hey".to_string()),
    });
    let y = Some(Foo {
        lorem: "Hello Wrold!",
        ipsum: 42,
        dolor: Ok("hey ho!".to_string()),
    });

    assert_eq!(x, y, "custom panic message",);
}

#[test]
fn assert_eq_unsized() {
    let a: &[u8] = b"e";
    assert_eq!(*a, *a);
}

#[test]
#[should_panic(expected = r#"assertion failed: `(left == right)`

Diff < left / right > :
 [
     101,
>    101,
 ]

"#)]
fn assert_eq_unsized_panic() {
    let a: &[u8] = b"e";
    let b: &[u8] = b"ee";
    assert_eq!(*a, *b);
}