#42 Tests clean up

resources/rstest/dump_debug.rs

@@ -1,4 +1,19 @@
-use rstest::rstest;
+use rstest::*;
+
+#[derive(Debug)]
+struct A {}
+
+#[fixture]
+fn fu32() -> u32 { 42 }
+#[fixture]
+fn fstring() -> String { "A String".to_string() }
+#[fixture]
+fn ftuple() -> (A, String, i32) { (A{}, "A String".to_string(), -12) }
+
+#[rstest(::trace)]
+fn single_fail(fu32: u32, fstring: String, ftuple: (A, String, i32)) {
+    assert!(false);
+}
 
 #[rstest(u, s, t,
     case(42, "str", ("ss", -12)),

resources/rstest/dump_exclude_some_fixtures.rs

@@ -1,13 +1,31 @@
-use rstest::rstest;
+use rstest::*;
 
 struct A;
+struct B;
 #[derive(Debug)]
 struct D;
 
-#[rstest(u,a,d,
-    case(42, A{}, D{})
-    ::trace::notrace(a))
+#[fixture]
+fn fu32() -> u32 { 42 }
+#[fixture]
+fn fb() -> B { B {} }
+#[fixture]
+fn fd() -> D { D {} }
+#[fixture]
+fn fa() -> A { A {} }
+
+
+#[rstest(
+::trace::notrace(fa,fb))
+]
+fn single_fail(fu32: u32, fa: A, fb: B, fd: D) {
+    assert!(false);
+}
+
+#[rstest(a,b,d,
+    case(A{}, B{}, D{})
+    ::trace::notrace(a,b))
 ]
-fn should_fail(u: u32, a: A, d: D) {
+fn should_fail(fu32: u32, a: A, b: B, d: D) {
     assert!(false);
 }

resources/rstest/dump_not_debug.rs

@@ -1,9 +1,15 @@
-use rstest::rstest;
+use rstest::*;
 
 struct S;
 
+#[fixture]
+fn fixture() -> S { S {} }
+
+#[rstest(::trace)]
+fn single(fixture: S) {}
+
 #[rstest(s,
-    case(Unwrap("S{}"))
+    case(S{})
     ::trace
 )]
-fn test_function(s: S) {}
+fn cases(s: S) {}

resources/rstest/generic.rs

@@ -1,4 +1,12 @@
-use rstest::rstest;
+use rstest::*;
+
+#[fixture]
+fn fixture() -> String { "str".to_owned() }
+
+#[rstest]
+fn simple<S: AsRef<str>>(fixture: S) {
+    assert_eq!(3, fixture.as_ref().len());
+}
 
 #[rstest(
     expected, input,

resources/rstest/impl_param.rs

@@ -1,4 +1,12 @@
-use rstest::rstest;
+use rstest::*;
+
+#[fixture]
+fn fixture() -> String { "str".to_owned() }
+
+#[rstest]
+fn simple(fixture: impl AsRef<str>) {
+    assert_eq!(3, fixture.as_ref().len());
+}
 
 #[rstest(
     expected, input,

resources/rstest/mut.rs

@@ -1,12 +1,29 @@
-use rstest::rstest;
+use rstest::*;
+
+#[fixture]
+pub fn fixture() -> u32 { 42 }
+
+#[rstest]
+fn should_success(mut fixture: u32) {
+    fixture += 1;
+    assert_eq!(fixture, 43);
+}
+
+#[rstest]
+fn should_fail(mut fixture: u32) {
+    fixture += 1;
+    assert_ne!(fixture, 43);
+}
 
 #[rstest(
     expected, val,
-    case(4, 3),
-    case(3, 2)
+    case(45, 1),
+    case(46, 2),
+    case(47, 2)
 )]
-fn add_test(expected: u32, mut val: u32) {
-    val += 1;
+fn add_test(mut fixture: u32, expected: u32, mut val: u32) {
+    fixture += 1;
+    val += fixture + 1;
 
     assert_eq!(expected, val);
 }

resources/rstest/panic.rs

@@ -1,4 +1,19 @@
-use rstest::rstest;
+use rstest::*;
+
+#[fixture]
+pub fn fixture() -> u32 { 42 }
+
+#[rstest]
+#[should_panic]
+fn should_success(fixture: u32) {
+    assert_ne!(fixture, 42);
+}
+
+#[rstest]
+#[should_panic]
+fn should_fail(fixture: u32) {
+    assert_eq!(fixture, 42);
+}
 
 #[rstest(
     expected, input,

resources/rstest/return_result.rs

@@ -1,5 +1,15 @@
 use rstest::rstest;
 
+#[rstest]
+fn should_success() -> Result<(), &'static str> {
+    Ok(())
+}
+
+#[rstest]
+fn should_fail() -> Result<(), &'static str> {
+    Err("Return Error")
+}
+
 #[rstest(ret,
     case::should_success(Ok(())),
     case::should_fail(Err("Return Error"))

tests/integration.rs

@@ -5,9 +5,6 @@ pub mod utils;
 /// Test Framework
 mod framework;
 
-/// Single's integration tests
-mod single;
-
 /// Rstest integration tests
 mod rstest;