diff --git a/tests/error/nightly/derives_for_enums_with_backtrace.rs b/tests/error/nightly/derives_for_enums_with_backtrace.rs
deleted file mode 100644
index c4ff4817..00000000
--- a/tests/error/nightly/derives_for_enums_with_backtrace.rs
+++ /dev/null
@@ -1,272 +0,0 @@
-use super::*;
-
-derive_display!(TestErr);
-#[derive(Debug, Error)]
-enum TestErr {
-    Unit,
-    NamedImplicitNoBacktrace {
-        field: i32,
-    },
-    NamedImplicitBacktraceByFieldName {
-        backtrace: MyBacktrace,
-        field: i32,
-    },
-    NamedImplicitBacktraceByFieldType {
-        implicit_backtrace: Backtrace,
-        field: i32,
-    },
-    NamedExplicitNoBacktraceByFieldName {
-        #[error(not(backtrace))]
-        backtrace: MyBacktrace,
-        field: i32,
-    },
-    NamedExplicitNoBacktraceByFieldType {
-        #[error(not(backtrace))]
-        implicit_backtrace: Backtrace,
-        field: i32,
-    },
-    NamedExplicitBacktrace {
-        #[error(backtrace)]
-        explicit_backtrace: MyBacktrace,
-        field: i32,
-    },
-    NamedExplicitNoBacktraceRedundant {
-        #[error(not(backtrace))]
-        not_backtrace: MyBacktrace,
-        #[error(not(backtrace))]
-        field: i32,
-    },
-    NamedExplicitBacktraceByFieldNameRedundant {
-        #[error(backtrace)]
-        backtrace: MyBacktrace,
-        field: i32,
-    },
-    NamedExplicitBacktraceByFieldTypeRedundant {
-        #[error(backtrace)]
-        implicit_backtrace: Backtrace,
-        field: i32,
-    },
-    NamedExplicitSupressesImplicit {
-        #[error(backtrace)]
-        not_backtrace: MyBacktrace,
-        backtrace: Backtrace,
-        field: i32,
-    },
-    UnnamedImplicitNoBacktrace(i32, i32),
-    UnnamedImplicitBacktrace(Backtrace, i32, i32),
-    UnnamedExplicitNoBacktrace(#[error(not(backtrace))] Backtrace, i32),
-    UnnamedExplicitBacktrace(#[error(backtrace)] MyBacktrace, i32, i32),
-    UnnamedExplicitNoBacktraceRedundant(
-        #[error(not(backtrace))] MyBacktrace,
-        #[error(not(backtrace))] i32,
-    ),
-    UnnamedExplicitBacktraceRedundant(#[error(backtrace)] Backtrace, i32, i32),
-    UnnamedExplicitSupressesImplicit(#[error(backtrace)] MyBacktrace, Backtrace, i32),
-}
-
-impl TestErr {
-    fn get_stored_backtrace(&self) -> &Backtrace {
-        match self {
-            Self::NamedImplicitBacktraceByFieldName { backtrace, .. } => backtrace,
-            Self::NamedImplicitBacktraceByFieldType {
-                implicit_backtrace, ..
-            } => implicit_backtrace,
-            Self::NamedExplicitBacktrace {
-                explicit_backtrace, ..
-            } => explicit_backtrace,
-            Self::NamedExplicitBacktraceByFieldNameRedundant { backtrace, .. } => {
-                backtrace
-            }
-            Self::NamedExplicitBacktraceByFieldTypeRedundant {
-                implicit_backtrace,
-                ..
-            } => implicit_backtrace,
-            Self::NamedExplicitSupressesImplicit { not_backtrace, .. } => not_backtrace,
-            Self::UnnamedImplicitBacktrace(backtrace, _, _) => backtrace,
-            Self::UnnamedExplicitBacktrace(backtrace, _, _) => backtrace,
-            Self::UnnamedExplicitBacktraceRedundant(backtrace, _, _) => backtrace,
-            Self::UnnamedExplicitSupressesImplicit(backtrace, _, _) => backtrace,
-            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
-        }
-    }
-
-    fn get_unused_backtrace(&self) -> &Backtrace {
-        match self {
-            Self::NamedExplicitSupressesImplicit { backtrace, .. } => backtrace,
-            Self::UnnamedExplicitSupressesImplicit(_, backtrace, _) => backtrace,
-            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
-        }
-    }
-}
-
-type MyBacktrace = Backtrace;
-
-#[test]
-fn unit() {
-    assert!(TestErr::Unit.backtrace().is_none());
-}
-
-#[test]
-fn named_implicit_no_backtrace() {
-    let err = TestErr::NamedImplicitNoBacktrace { field: 0 };
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn named_implicit_backtrace_by_field_name() {
-    let err = TestErr::NamedImplicitBacktraceByFieldName {
-        backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn named_implicit_backtrace_by_field_type() {
-    let err = TestErr::NamedImplicitBacktraceByFieldType {
-        implicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn named_explicit_no_backtrace_by_field_name() {
-    let err = TestErr::NamedExplicitNoBacktraceByFieldName {
-        backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn named_explicit_no_backtrace_by_field_type() {
-    let err = TestErr::NamedExplicitNoBacktraceByFieldType {
-        implicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn named_explicit_backtrace() {
-    let err = TestErr::NamedExplicitBacktrace {
-        explicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn named_explicit_no_backtrace_redundant() {
-    let err = TestErr::NamedExplicitNoBacktraceRedundant {
-        not_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn named_explicit_backtrace_by_field_name_redundant() {
-    let err = TestErr::NamedExplicitBacktraceByFieldNameRedundant {
-        backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn named_explicit_backtrace_by_field_type_redundant() {
-    let err = TestErr::NamedExplicitBacktraceByFieldTypeRedundant {
-        implicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn named_explicit_supresses_implicit() {
-    let err = TestErr::NamedExplicitSupressesImplicit {
-        not_backtrace: Backtrace::force_capture(),
-        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-    assert_bt!(!=, err, .get_unused_backtrace);
-}
-
-#[test]
-fn unnamed_implicit_no_backtrace() {
-    let err = TestErr::UnnamedImplicitNoBacktrace(0, 0);
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn unnamed_implicit_backtrace() {
-    let err = TestErr::UnnamedImplicitBacktrace(Backtrace::force_capture(), 0, 0);
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn unnamed_explicit_no_backtrace() {
-    let err = TestErr::UnnamedExplicitNoBacktrace(Backtrace::force_capture(), 0);
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn unnamed_explicit_backtrace() {
-    let err = TestErr::UnnamedExplicitBacktrace(Backtrace::force_capture(), 0, 0);
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn unnamed_explicit_no_backtrace_redundant() {
-    let err =
-        TestErr::UnnamedExplicitNoBacktraceRedundant(Backtrace::force_capture(), 0);
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn unnamed_explicit_backtrace_redundant() {
-    let err =
-        TestErr::UnnamedExplicitBacktraceRedundant(Backtrace::force_capture(), 0, 0);
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn unnamed_explicit_supresses_implicit() {
-    let err = TestErr::UnnamedExplicitSupressesImplicit(
-        Backtrace::force_capture(),
-        (|| Backtrace::force_capture())(), // ensure backtraces are different
-        0,
-    );
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-    assert_bt!(!=, err, .get_unused_backtrace);
-}
diff --git a/tests/error/nightly/derives_for_generic_enums_with_backtrace.rs b/tests/error/nightly/derives_for_generic_enums_with_backtrace.rs
deleted file mode 100644
index 8574751d..00000000
--- a/tests/error/nightly/derives_for_generic_enums_with_backtrace.rs
+++ /dev/null
@@ -1,272 +0,0 @@
-use super::*;
-
-derive_display!(TestErr, T);
-#[derive(Debug, Error)]
-enum TestErr<T> {
-    Unit,
-    NamedImplicitNoBacktrace {
-        field: T,
-    },
-    NamedImplicitBacktraceByFieldName {
-        backtrace: MyBacktrace,
-        field: T,
-    },
-    NamedImplicitBacktraceByFieldType {
-        implicit_backtrace: Backtrace,
-        field: T,
-    },
-    NamedExplicitNoBacktraceByFieldName {
-        #[error(not(backtrace))]
-        backtrace: MyBacktrace,
-        field: T,
-    },
-    NamedExplicitNoBacktraceByFieldType {
-        #[error(not(backtrace))]
-        implicit_backtrace: Backtrace,
-        field: T,
-    },
-    NamedExplicitBacktrace {
-        #[error(backtrace)]
-        explicit_backtrace: MyBacktrace,
-        field: T,
-    },
-    NamedExplicitNoBacktraceRedundant {
-        #[error(not(backtrace))]
-        not_backtrace: MyBacktrace,
-        #[error(not(backtrace))]
-        field: T,
-    },
-    NamedExplicitBacktraceByFieldNameRedundant {
-        #[error(backtrace)]
-        backtrace: MyBacktrace,
-        field: T,
-    },
-    NamedExplicitBacktraceByFieldTypeRedundant {
-        #[error(backtrace)]
-        implicit_backtrace: Backtrace,
-        field: T,
-    },
-    NamedExplicitSupressesImplicit {
-        #[error(backtrace)]
-        not_backtrace: MyBacktrace,
-        backtrace: Backtrace,
-        field: T,
-    },
-    UnnamedImplicitNoBacktrace(T, T),
-    UnnamedImplicitBacktrace(Backtrace, T, T),
-    UnnamedExplicitNoBacktrace(#[error(not(backtrace))] Backtrace, T),
-    UnnamedExplicitBacktrace(#[error(backtrace)] MyBacktrace, T, T),
-    UnnamedExplicitNoBacktraceRedundant(
-        #[error(not(backtrace))] MyBacktrace,
-        #[error(not(backtrace))] T,
-    ),
-    UnnamedExplicitBacktraceRedundant(#[error(backtrace)] Backtrace, T, T),
-    UnnamedExplicitSupressesImplicit(#[error(backtrace)] MyBacktrace, Backtrace, T),
-}
-
-impl<T> TestErr<T> {
-    fn get_stored_backtrace(&self) -> &Backtrace {
-        match self {
-            Self::NamedImplicitBacktraceByFieldName { backtrace, .. } => backtrace,
-            Self::NamedImplicitBacktraceByFieldType {
-                implicit_backtrace, ..
-            } => implicit_backtrace,
-            Self::NamedExplicitBacktrace {
-                explicit_backtrace, ..
-            } => explicit_backtrace,
-            Self::NamedExplicitBacktraceByFieldNameRedundant { backtrace, .. } => {
-                backtrace
-            }
-            Self::NamedExplicitBacktraceByFieldTypeRedundant {
-                implicit_backtrace,
-                ..
-            } => implicit_backtrace,
-            Self::NamedExplicitSupressesImplicit { not_backtrace, .. } => not_backtrace,
-            Self::UnnamedImplicitBacktrace(backtrace, _, _) => backtrace,
-            Self::UnnamedExplicitBacktrace(backtrace, _, _) => backtrace,
-            Self::UnnamedExplicitBacktraceRedundant(backtrace, _, _) => backtrace,
-            Self::UnnamedExplicitSupressesImplicit(backtrace, _, _) => backtrace,
-            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
-        }
-    }
-
-    fn get_unused_backtrace(&self) -> &Backtrace {
-        match self {
-            Self::NamedExplicitSupressesImplicit { backtrace, .. } => backtrace,
-            Self::UnnamedExplicitSupressesImplicit(_, backtrace, _) => backtrace,
-            _ => panic!("ERROR IN TEST IMPLEMENTATION"),
-        }
-    }
-}
-
-type MyBacktrace = Backtrace;
-
-#[test]
-fn unit() {
-    assert!(TestErr::<i32>::Unit.backtrace().is_none());
-}
-
-#[test]
-fn named_implicit_no_backtrace() {
-    let err = TestErr::NamedImplicitNoBacktrace { field: 0 };
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn named_implicit_backtrace_by_field_name() {
-    let err = TestErr::NamedImplicitBacktraceByFieldName {
-        backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn named_implicit_backtrace_by_field_type() {
-    let err = TestErr::NamedImplicitBacktraceByFieldType {
-        implicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn named_explicit_no_backtrace_by_field_name() {
-    let err = TestErr::NamedExplicitNoBacktraceByFieldName {
-        backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn named_explicit_no_backtrace_by_field_type() {
-    let err = TestErr::NamedExplicitNoBacktraceByFieldType {
-        implicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn named_explicit_backtrace() {
-    let err = TestErr::NamedExplicitBacktrace {
-        explicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn named_explicit_no_backtrace_redundant() {
-    let err = TestErr::NamedExplicitNoBacktraceRedundant {
-        not_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn named_explicit_backtrace_by_field_name_redundant() {
-    let err = TestErr::NamedExplicitBacktraceByFieldNameRedundant {
-        backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn named_explicit_backtrace_by_field_type_redundant() {
-    let err = TestErr::NamedExplicitBacktraceByFieldTypeRedundant {
-        implicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn named_explicit_supresses_implicit() {
-    let err = TestErr::NamedExplicitSupressesImplicit {
-        not_backtrace: Backtrace::force_capture(),
-        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-    assert_bt!(!=, err, .get_unused_backtrace);
-}
-
-#[test]
-fn unnamed_implicit_no_backtrace() {
-    let err = TestErr::UnnamedImplicitNoBacktrace(0, 0);
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn unnamed_implicit_backtrace() {
-    let err = TestErr::UnnamedImplicitBacktrace(Backtrace::force_capture(), 0, 0);
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn unnamed_explicit_no_backtrace() {
-    let err = TestErr::UnnamedExplicitNoBacktrace(Backtrace::force_capture(), 0);
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn unnamed_explicit_backtrace() {
-    let err = TestErr::UnnamedExplicitBacktrace(Backtrace::force_capture(), 0, 0);
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn unnamed_explicit_no_backtrace_redundant() {
-    let err =
-        TestErr::UnnamedExplicitNoBacktraceRedundant(Backtrace::force_capture(), 0);
-
-    assert!(err.backtrace().is_none());
-}
-
-#[test]
-fn unnamed_explicit_backtrace_redundant() {
-    let err =
-        TestErr::UnnamedExplicitBacktraceRedundant(Backtrace::force_capture(), 0, 0);
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-}
-
-#[test]
-fn unnamed_explicit_supresses_implicit() {
-    let err = TestErr::UnnamedExplicitSupressesImplicit(
-        Backtrace::force_capture(),
-        (|| Backtrace::force_capture())(), // ensure backtraces are different
-        0,
-    );
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, .get_stored_backtrace);
-    assert_bt!(!=, err, .get_unused_backtrace);
-}
diff --git a/tests/error/nightly/derives_for_generic_structs_with_backtrace.rs b/tests/error/nightly/derives_for_generic_structs_with_backtrace.rs
deleted file mode 100644
index 91df87c8..00000000
--- a/tests/error/nightly/derives_for_generic_structs_with_backtrace.rs
+++ /dev/null
@@ -1,275 +0,0 @@
-use super::*;
-
-#[test]
-fn named_implicit_no_backtrace() {
-    derive_display!(TestErr, T);
-    #[derive(Default, Debug, Error)]
-    struct TestErr<T> {
-        field: T,
-    }
-
-    assert!(TestErr::<i32>::default().backtrace().is_none());
-}
-
-#[test]
-fn named_implicit_backtrace_by_field_name() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T> {
-        backtrace: MyBacktrace,
-        field: T,
-    }
-
-    type MyBacktrace = Backtrace;
-
-    let err = TestErr {
-        backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err);
-}
-
-#[test]
-fn named_implicit_backtrace_by_field_type() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T> {
-        implicit_backtrace: Backtrace,
-        field: T,
-    }
-
-    let err = TestErr {
-        implicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, implicit_backtrace);
-}
-
-#[test]
-fn named_explicit_no_backtrace_by_field_name() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T> {
-        #[error(not(backtrace))]
-        backtrace: MyBacktrace,
-        field: T,
-    }
-
-    type MyBacktrace = Backtrace;
-
-    assert!(TestErr {
-        backtrace: Backtrace::force_capture(),
-        field: 0
-    }
-    .backtrace()
-    .is_none());
-}
-
-#[test]
-fn named_explicit_no_backtrace_by_field_type() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T> {
-        #[error(not(backtrace))]
-        implicit_backtrace: Backtrace,
-        field: T,
-    }
-
-    assert!(TestErr {
-        implicit_backtrace: Backtrace::force_capture(),
-        field: 0
-    }
-    .backtrace()
-    .is_none());
-}
-
-#[test]
-fn named_explicit_backtrace() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T> {
-        #[error(backtrace)]
-        explicit_backtrace: MyBacktrace,
-        field: T,
-    }
-
-    type MyBacktrace = Backtrace;
-
-    let err = TestErr {
-        explicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, explicit_backtrace);
-}
-
-#[test]
-fn named_explicit_no_backtrace_redundant() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T> {
-        #[error(not(backtrace))]
-        not_backtrace: MyBacktrace,
-        #[error(not(backtrace))]
-        field: T,
-    }
-
-    type MyBacktrace = Backtrace;
-
-    assert!(TestErr {
-        not_backtrace: Backtrace::force_capture(),
-        field: 0
-    }
-    .backtrace()
-    .is_none());
-}
-
-#[test]
-fn named_explicit_backtrace_by_field_name_redundant() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T> {
-        #[error(backtrace)]
-        backtrace: MyBacktrace,
-        field: T,
-    }
-
-    type MyBacktrace = Backtrace;
-
-    let err = TestErr {
-        backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err);
-}
-
-#[test]
-fn named_explicit_backtrace_by_field_type_redundant() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T> {
-        #[error(backtrace)]
-        implicit_backtrace: Backtrace,
-        field: T,
-    }
-
-    let err = TestErr {
-        implicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, implicit_backtrace);
-}
-
-#[test]
-fn named_explicit_supresses_implicit() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T> {
-        #[error(backtrace)]
-        not_backtrace: MyBacktrace,
-        backtrace: Backtrace,
-        field: T,
-    }
-
-    type MyBacktrace = Backtrace;
-
-    let err = TestErr {
-        not_backtrace: Backtrace::force_capture(),
-        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, not_backtrace);
-    assert_bt!(!=, err);
-}
-
-#[test]
-fn unnamed_implicit_no_backtrace() {
-    derive_display!(TestErr, T);
-    #[derive(Default, Debug, Error)]
-    struct TestErr<T>(T, T);
-
-    assert!(TestErr::<i32>::default().backtrace().is_none());
-}
-
-#[test]
-fn unnamed_implicit_backtrace() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T>(Backtrace, T, T);
-
-    let err = TestErr(Backtrace::force_capture(), 0, 0);
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, 0);
-}
-
-#[test]
-fn unnamed_explicit_no_backtrace() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T>(#[error(not(backtrace))] Backtrace, T);
-
-    assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none());
-}
-
-#[test]
-fn unnamed_explicit_backtrace() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T>(#[error(backtrace)] MyBacktrace, T, T);
-
-    type MyBacktrace = Backtrace;
-
-    let err = TestErr(Backtrace::force_capture(), 0, 0);
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, 0);
-}
-
-#[test]
-fn unnamed_explicit_no_backtrace_redundant() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T>(
-        #[error(not(backtrace))] MyBacktrace,
-        #[error(not(backtrace))] T,
-    );
-
-    type MyBacktrace = Backtrace;
-
-    assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none());
-}
-
-#[test]
-fn unnamed_explicit_backtrace_redundant() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T>(#[error(backtrace)] Backtrace, T, T);
-
-    let err = TestErr(Backtrace::force_capture(), 0, 0);
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, 0);
-}
-
-#[test]
-fn unnamed_explicit_supresses_implicit() {
-    derive_display!(TestErr, T);
-    #[derive(Debug, Error)]
-    struct TestErr<T>(#[error(backtrace)] MyBacktrace, Backtrace, T);
-
-    type MyBacktrace = Backtrace;
-
-    let err = TestErr(
-        Backtrace::force_capture(),
-        (|| Backtrace::force_capture())(), // ensure backtraces are different
-        0,
-    );
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, 0);
-    assert_bt!(!=, err, 1);
-}
diff --git a/tests/error/nightly/derives_for_structs_with_backtrace.rs b/tests/error/nightly/derives_for_structs_with_backtrace.rs
deleted file mode 100644
index 18e268f8..00000000
--- a/tests/error/nightly/derives_for_structs_with_backtrace.rs
+++ /dev/null
@@ -1,280 +0,0 @@
-use super::*;
-
-#[test]
-fn unit() {
-    assert!(SimpleErr.backtrace().is_none());
-}
-
-#[test]
-fn named_implicit_no_backtrace() {
-    derive_display!(TestErr);
-    #[derive(Default, Debug, Error)]
-    struct TestErr {
-        field: i32,
-    }
-
-    assert!(TestErr::default().backtrace().is_none());
-}
-
-#[test]
-fn named_implicit_backtrace_by_field_name() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr {
-        backtrace: MyBacktrace,
-        field: i32,
-    }
-
-    type MyBacktrace = Backtrace;
-
-    let err = TestErr {
-        backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err);
-}
-
-#[test]
-fn named_implicit_backtrace_by_field_type() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr {
-        implicit_backtrace: Backtrace,
-        field: i32,
-    }
-
-    let err = TestErr {
-        implicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, implicit_backtrace);
-}
-
-#[test]
-fn named_explicit_no_backtrace_by_field_name() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr {
-        #[error(not(backtrace))]
-        backtrace: MyBacktrace,
-        field: i32,
-    }
-
-    type MyBacktrace = Backtrace;
-
-    assert!(TestErr {
-        backtrace: Backtrace::force_capture(),
-        field: 0
-    }
-    .backtrace()
-    .is_none());
-}
-
-#[test]
-fn named_explicit_no_backtrace_by_field_type() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr {
-        #[error(not(backtrace))]
-        implicit_backtrace: Backtrace,
-        field: i32,
-    }
-
-    assert!(TestErr {
-        implicit_backtrace: Backtrace::force_capture(),
-        field: 0
-    }
-    .backtrace()
-    .is_none());
-}
-
-#[test]
-fn named_explicit_backtrace() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr {
-        #[error(backtrace)]
-        explicit_backtrace: MyBacktrace,
-        field: i32,
-    }
-
-    type MyBacktrace = Backtrace;
-
-    let err = TestErr {
-        explicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, explicit_backtrace);
-}
-
-#[test]
-fn named_explicit_no_backtrace_redundant() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr {
-        #[error(not(backtrace))]
-        not_backtrace: MyBacktrace,
-        #[error(not(backtrace))]
-        field: i32,
-    }
-
-    type MyBacktrace = Backtrace;
-
-    assert!(TestErr {
-        not_backtrace: Backtrace::force_capture(),
-        field: 0
-    }
-    .backtrace()
-    .is_none());
-}
-
-#[test]
-fn named_explicit_backtrace_by_field_name_redundant() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr {
-        #[error(backtrace)]
-        backtrace: MyBacktrace,
-        field: i32,
-    }
-
-    type MyBacktrace = Backtrace;
-
-    let err = TestErr {
-        backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err);
-}
-
-#[test]
-fn named_explicit_backtrace_by_field_type_redundant() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr {
-        #[error(backtrace)]
-        implicit_backtrace: Backtrace,
-        field: i32,
-    }
-
-    let err = TestErr {
-        implicit_backtrace: Backtrace::force_capture(),
-        field: 0,
-    };
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, implicit_backtrace);
-}
-
-#[test]
-fn named_explicit_supresses_implicit() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr {
-        #[error(backtrace)]
-        not_backtrace: MyBacktrace,
-        backtrace: Backtrace,
-        field: i32,
-    }
-
-    type MyBacktrace = Backtrace;
-
-    let err = TestErr {
-        not_backtrace: Backtrace::force_capture(),
-        backtrace: (|| Backtrace::force_capture())(), // ensure backtraces are different
-        field: 0,
-    };
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, not_backtrace);
-    assert_bt!(!=, err);
-}
-
-#[test]
-fn unnamed_implicit_no_backtrace() {
-    derive_display!(TestErr);
-    #[derive(Default, Debug, Error)]
-    struct TestErr(i32, i32);
-
-    assert!(TestErr::default().backtrace().is_none());
-}
-
-#[test]
-fn unnamed_implicit_backtrace() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr(Backtrace, i32, i32);
-
-    let err = TestErr(Backtrace::force_capture(), 0, 0);
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, 0);
-}
-
-#[test]
-fn unnamed_explicit_no_backtrace() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr(#[error(not(backtrace))] Backtrace, i32);
-
-    assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none());
-}
-
-#[test]
-fn unnamed_explicit_backtrace() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr(#[error(backtrace)] MyBacktrace, i32, i32);
-
-    type MyBacktrace = Backtrace;
-
-    let err = TestErr(Backtrace::force_capture(), 0, 0);
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, 0);
-}
-
-#[test]
-fn unnamed_explicit_no_backtrace_redundant() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr(
-        #[error(not(backtrace))] MyBacktrace,
-        #[error(not(backtrace))] i32,
-    );
-
-    type MyBacktrace = Backtrace;
-
-    assert!(TestErr(Backtrace::force_capture(), 0).backtrace().is_none());
-}
-
-#[test]
-fn unnamed_explicit_backtrace_redundant() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr(#[error(backtrace)] Backtrace, i32, i32);
-
-    let err = TestErr(Backtrace::force_capture(), 0, 0);
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, 0);
-}
-
-#[test]
-fn unnamed_explicit_supresses_implicit() {
-    derive_display!(TestErr);
-    #[derive(Debug, Error)]
-    struct TestErr(#[error(backtrace)] MyBacktrace, Backtrace, i32);
-
-    type MyBacktrace = Backtrace;
-
-    let err = TestErr(
-        Backtrace::force_capture(),
-        (|| Backtrace::force_capture())(), // ensure backtraces are different
-        0,
-    );
-
-    assert!(err.backtrace().is_some());
-    assert_bt!(==, err, 0);
-    assert_bt!(!=, err, 1);
-}
diff --git a/tests/error/nightly/mod.rs b/tests/error/nightly/mod.rs
deleted file mode 100644
index 57de7ba2..00000000
--- a/tests/error/nightly/mod.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-use std::backtrace::Backtrace;
-
-use super::*;
-
-/// Asserts that backtrace returned by `Error::backtrace` method equals/not-equals
-/// backtrace stored in object itself.
-///
-/// Comparison is done by converting backtraces to strings
-/// and then comparing these strings.
-///
-/// ## Syntax
-///
-/// * Equals: `assert_bt!(==, ...)`
-/// * Not-equals: `assert_bt!(!=, ...)`
-///
-/// ### Backtrace Access
-///
-/// Shortcut for named-structs with `backtrace` field.
-/// Access backtrace as `error.backtrace`.
-///
-/// ```
-/// assert_bt!(==, error);
-/// ```
-///
-/// Full form for named- and tuple-structs.
-/// Access backtrace as `error.some_other_field` and `error.1` respectively.
-///
-/// ```
-/// assert_bt!(!=, error, some_other_field);
-/// assert_bt!(==, error, 1);
-/// ```
-///
-/// Access as a method call.
-/// Useful for enums (i.e., you can define a method that will match on enum variants
-/// and return backtrace for each variant).
-/// Access backtrace as `error.get_stored_backtrace_method()`.
-///
-/// ```
-/// assert_bt!(!=, error, .get_stored_backtrace_method);
-/// ```
-macro_rules! assert_bt {
-    (@impl $macro:ident, $error:expr, $backtrace:expr) => {
-        $macro!($error.backtrace().unwrap().to_string(), $backtrace.to_string());
-    };
-    (@expand $macro:ident, $error:expr, .$backtrace:ident) => {
-        assert_bt!(@impl $macro, $error, $error.$backtrace())
-    };
-    (@expand $macro:ident, $error:expr, $backtrace:tt) => {
-        assert_bt!(@impl $macro, $error, $error.$backtrace)
-    };
-    (@expand $macro:ident, $error:expr) => {
-        assert_bt!(@expand $macro, $error, backtrace)
-    };
-    (==, $($args:tt)*) => {
-        assert_bt!(@expand assert_eq, $($args)*)
-    };
-    (!=, $($args:tt)*) => {
-        assert_bt!(@expand assert_ne, $($args)*)
-    };
-}
-
-mod derives_for_enums_with_backtrace;
-mod derives_for_generic_enums_with_backtrace;
-mod derives_for_generic_structs_with_backtrace;
-mod derives_for_structs_with_backtrace;
-
-derive_display!(BacktraceErr);
-#[derive(Debug)]
-struct BacktraceErr {
-    backtrace: Backtrace,
-}
-
-impl Default for BacktraceErr {
-    fn default() -> Self {
-        Self {
-            backtrace: Backtrace::force_capture(),
-        }
-    }
-}
-
-impl Error for BacktraceErr {
-    fn backtrace(&self) -> Option<&Backtrace> {
-        Some(&self.backtrace)
-    }
-}