sweet 0.4.2

A delightful cross-platform test runner
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use std::fmt::Display;

use super::*;

#[extend::ext(name=SweetString)]
pub impl<T, U> T
where
	T: IntoMaybeNotDisplay<U>,
	U: AsRef<str> + Display,
{
	/// Performs an assertion ensuring this string is equal to `expected`.
	///
	/// ## Example
	///
	/// ```
	/// # use sweet::prelude::*;
	/// "foo".xpect_str("foo");
	/// "foo".xnot().xpect_str("bar");
	/// ```
	///
	/// ## Panics
	///
	/// Panics if the value is not equal to `expected`.
	fn xpect_str(self, expected: impl AsRef<str>) -> U {
		let expected = expected.as_ref();
		let received = self.into_maybe_not();
		assert_ext::assert_diff(expected, received).into_inner()
	}

	/// Performs an assertion ensuring this string contains `expected`.
	///
	/// ## Example
	///
	/// ```
	/// # use sweet::prelude::*;
	/// "foobar".xpect_contains("bar");
	/// "foobar".xnot().xpect_contains("bazz");
	/// ```
	///
	/// ## Panics
	///
	/// Panics if the value does not contain `expected`.
	fn xpect_contains(self, expected: impl AsRef<str>) -> U {
		let expected = expected.as_ref();
		let received = self.into_maybe_not();
		let result = received.inner().as_ref().contains(expected);
		let expected = format!("to contain '{}'", expected);
		assert_ext::assert_result_expected_received_display(
			result, expected, received,
		)
		.into_inner()
	}

	/// Performs an assertion ensuring this string starts with `expected`.
	///
	/// ## Example
	///
	/// ```
	/// # use sweet::prelude::*;
	/// "foobar".xpect_starts_with("foo");
	/// "foobar".xnot().xpect_starts_with("bazz");
	/// ```
	///
	/// ## Panics
	///
	/// Panics if the value does not start with `expected`.
	fn xpect_starts_with(self, expected: impl AsRef<str>) -> U {
		let expected = expected.as_ref();
		let received = self.into_maybe_not();
		let result = received.inner().as_ref().starts_with(expected);
		let expected = format!("to start with '{}'", expected);
		assert_ext::assert_result_expected_received_display(
			result, expected, received,
		)
		.into_inner()
	}

	/// Performs an assertion ensuring this string ends with `expected`.
	///
	/// ## Example
	///
	/// ```
	/// # use sweet::prelude::*;
	/// "foobar".xpect_ends_with("bar");
	/// "foobar".xnot().xpect_ends_with("bazz");
	/// ```
	///
	/// ## Panics
	///
	/// Panics if the value does not end with `expected`.
	fn xpect_ends_with(self, expected: impl AsRef<str>) -> U {
		let expected = expected.as_ref();
		let received = self.into_maybe_not();
		let result = received.inner().as_ref().ends_with(expected);
		let expected = format!("to end with '{}'", expected);
		assert_ext::assert_result_expected_received_display(
			result, expected, received,
		)
		.into_inner()
	}
}

#[cfg(test)]
mod test {
	use crate::prelude::*;

	#[test]
	#[should_panic]
	fn err_xpect_contains() { "foobar".xpect_contains("bazz"); }
	#[test]
	#[should_panic]
	fn err_xpect_str() { "foobar".xpect_str("bazz"); }
	#[test]
	#[should_panic]
	fn err_xpect_not_str() { "foobar".xnot().xpect_str("foobar"); }

	#[test]
	fn str() {
		"foobar".xpect_contains("bar");
		"foobar".xnot().xpect_contains("bazz");

		"foobar".xnot().xpect_str("bazz");
		"foobar".xpect_str("foobar");

		"foobar".xpect_starts_with("foo");
		"foobar".xnot().xpect_starts_with("bar");

		"foobar".xpect_ends_with("bar");
		"foobar".xnot().xpect_ends_with("foo");
	}
}