Add tests for gix_testtools::Env

The `nonoverlapping` test, which fortunately is what most closely
resembles existing known usage (and most likely all current usage
in gitoxide's own test suite), already passes.

The other tests test the situation where the same environment
variable is affected by multiple `set` or `unset` calls (or both a
`set` and an `unset` call). These do not pass yet, because while
the assertions about the immediate effect on the environment of
each such call all pass, the assertions about the effect after
drop fail.

This is because, on drop, `Env` currently restores the state of a
variable that was most recently saved, i.e., it puts it back to
whatever it was just before the most recent modification it made to
it.

This goes against the intuitive expectation that `Env` will reset
things to the way they were before the `Env` object was created and
used (so long as all changes were by `set` and `unset` calls).

Author: EliahKagan

Cargo.lock

@@ -48,6 +48,9 @@ xz2 = { version = "0.1.6", optional = true }
 
 document-features = { version = "0.2.1", optional = true }
 
+[dev-dependencies]
+serial_test = { version = "3.1.0", default-features = false }
+
 [package.metadata.docs.rs]
 all-features = true
 features = ["document-features"]

tests/tools/Cargo.toml

@@ -883,4 +883,98 @@ mod tests {
     fn parse_version_with_trailing_newline() {
         assert_eq!(git_version_from_bytes(b"git version 2.37.2\n").unwrap(), (2, 37, 2));
     }
+
+    mod env {
+        use super::Env;
+        use serial_test::serial;
+
+        // We rely on these not already existing, to test `Env` without using or rewriting it.
+        static VAR1: &str = "VAR_03FC4045_6043_4A61_9D15_852236CB632B";
+        static VAR2: &str = "VAR_8C135840_05DB_4F3A_BFDD_FC755EC35B89";
+        static VAR3: &str = "VAR_9B23A2BE_E20B_4670_93E2_3A6A8D47F274";
+
+        struct TestEnv;
+
+        impl TestEnv {
+            fn new() -> Self {
+                assert_eq!(std::env::var_os(VAR1), None);
+                assert_eq!(std::env::var_os(VAR2), None);
+                assert_eq!(std::env::var_os(VAR3), None);
+                Self
+            }
+        }
+
+        impl Drop for TestEnv {
+            fn drop(&mut self) {
+                std::env::remove_var(VAR1);
+                std::env::remove_var(VAR2);
+                std::env::remove_var(VAR3);
+            }
+        }
+
+        #[test]
+        #[serial]
+        fn nonoverlapping() {
+            let _meta = TestEnv::new();
+            std::env::set_var(VAR1, "old1");
+            std::env::set_var(VAR2, "old2");
+            {
+                let _env = Env::new().set(VAR1, "new1").unset(VAR2).set(VAR3, "new3");
+                assert_eq!(std::env::var_os(VAR1), Some("new1".into()));
+                assert_eq!(std::env::var_os(VAR2), None);
+                assert_eq!(std::env::var_os(VAR3), Some("new3".into()));
+            }
+            assert_eq!(std::env::var_os(VAR1), Some("old1".into()));
+            assert_eq!(std::env::var_os(VAR2), Some("old2".into()));
+            assert_eq!(std::env::var_os(VAR3), None);
+        }
+
+        #[test]
+        #[serial]
+        fn overlapping_reset() {
+            let _meta = TestEnv::new();
+            {
+                let _env = Env::new().set(VAR1, "new1A").set(VAR1, "new1B");
+                assert_eq!(std::env::var_os(VAR1), Some("new1B".into()));
+            }
+            assert_eq!(std::env::var_os(VAR1), None);
+        }
+
+        #[test]
+        #[serial]
+        fn overlapping_unset() {
+            let _meta = TestEnv::new();
+            std::env::set_var(VAR1, "old1");
+            {
+                let _env = Env::new().unset(VAR1).unset(VAR1);
+                assert_eq!(std::env::var_os(VAR1), None);
+            }
+            assert_eq!(std::env::var_os(VAR1), Some("old1".into()));
+        }
+
+        #[test]
+        #[serial]
+        fn overlapping_combo() {
+            let _meta = TestEnv::new();
+            std::env::set_var(VAR1, "old1");
+            std::env::set_var(VAR2, "old2");
+            {
+                let _env = Env::new()
+                    .set(VAR1, "new1A")
+                    .unset(VAR2)
+                    .set(VAR1, "new1B")
+                    .unset(VAR3)
+                    .set(VAR2, "new2")
+                    .set(VAR3, "new3")
+                    .unset(VAR1)
+                    .unset(VAR3);
+                assert_eq!(std::env::var_os(VAR1), None);
+                assert_eq!(std::env::var_os(VAR2), Some("new2".into()));
+                assert_eq!(std::env::var_os(VAR3), None);
+            }
+            assert_eq!(std::env::var_os(VAR1), Some("old1".into()));
+            assert_eq!(std::env::var_os(VAR2), Some("old2".into()));
+            assert_eq!(std::env::var_os(VAR3), None);
+        }
+    }
 }