re-allow absolute paths

Fixes #252.

Author: sunshowers

README.md

@@ -57,9 +57,8 @@ datatest_stable::harness! {
     extra `Vec<u8>` parameter is specified, the contents of the file will be loaded and passed
     in as a `Vec<u8>` (erroring out if that failed).
 * `root` - The path to the root directory where the input files (fixtures)
-  live. This path is relative to the root of the crate (the directory where
-  the crate’s `Cargo.toml` is located). Absolute paths are not supported, and
-  will panic at runtime.
+  live. Relative paths are resolved relative to the crate root (the directory where the crate’s
+  `Cargo.toml` is located).
 
   `root` is an arbitrary expression that implements
   [`Display`](https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html), such as `&str`, or a function call that
@@ -80,17 +79,20 @@ datatest_stable::harness! {
 }
 ````
 
-### Relative paths
+### Relative and absolute paths
 
 The `pattern` argument is tested against the **relative** path of each file,
 **excluding** the `root` prefix – not the absolute path.
 
-The `Path` and `Utf8Path` passed into the test functions are **relative** to
-the root of the crate, obtained by joining `root` to the relative path of
-the file.
+The `Path` and `Utf8Path` passed into the test functions are created by
+joining `root` to the relative path of the file.
 
-For universality, all relative paths use `/` as the path separator,
-including on Windows.
+* If `root` is **relative**, the paths passed in are relative to the crate root.
+* If `root` is **absolute**, the paths passed in are absolute.
+
+For uniformity, all relative paths use `/` as the path separator,
+including on Windows, and all absolute paths use the platform’s native
+separator throughout.
 
 ### Examples
 
@@ -170,9 +172,9 @@ datatest_stable::harness! {
 }
 ````
 
-In this case, the passed-in `Path` and `Utf8Path` are **relative** to the
-root of the included directory. Like elsewhere in `datatest-stable`, these
-relative paths always use forward slashes as separators, including on
+In this case, the passed-in `Path` and `Utf8Path` are always **relative** to
+the root of the included directory. Like elsewhere in `datatest-stable`,
+these relative paths always use forward slashes as separators, including on
 Windows.
 
 Because the files don’t exist on disk, the test functions must accept their

src/data_source.rs

@@ -6,7 +6,7 @@ use camino::{Utf8Component, Utf8Path, Utf8PathBuf};
 #[derive(Debug)]
 #[doc(hidden)]
 pub enum DataSource {
-    // This is relative to the crate root, and stored with forward slashes.
+    // The path has had normalize_slashes applied to it.
     Directory(Utf8PathBuf),
     #[cfg(feature = "include-dir")]
     IncludeDir(std::borrow::Cow<'static, include_dir::Dir<'static>>),
@@ -40,7 +40,7 @@ impl DataSource {
         );
         match self {
             DataSource::Directory(path) => Some(TestEntry {
-                source: TestSource::Path(rel_path_to_forward_slashes(&path.join(&rel_path))),
+                source: TestSource::Path(normalize_slashes(&path.join(&rel_path))),
                 rel_path,
             }),
             #[cfg(feature = "include-dir")]
@@ -152,7 +152,7 @@ pub(crate) struct TestEntry {
 
 impl TestEntry {
     pub(crate) fn from_full_path(root: &Utf8Path, path: Utf8PathBuf) -> Self {
-        let path = rel_path_to_forward_slashes(&path);
+        let path = normalize_slashes(&path);
         let rel_path =
             rel_path_to_forward_slashes(path.strip_prefix(root).unwrap_or_else(|_| {
                 panic!("failed to strip root '{}' from path '{}'", root, path)
@@ -241,13 +241,29 @@ impl TestEntry {
     }
 }
 
+#[cfg(windows)]
+#[track_caller]
+fn normalize_slashes(path: &Utf8Path) -> Utf8PathBuf {
+    if is_truly_relative(path) {
+        rel_path_to_forward_slashes(path)
+    } else {
+        path.as_str().replace('/', "\\").into()
+    }
+}
+
 #[cfg(windows)]
 #[track_caller]
 fn rel_path_to_forward_slashes(path: &Utf8Path) -> Utf8PathBuf {
     assert!(is_truly_relative(path), "path {path} must be relative");
     path.as_str().replace('\\', "/").into()
 }
 
+#[cfg(not(windows))]
+#[track_caller]
+fn normalize_slashes(path: &Utf8Path) -> Utf8PathBuf {
+    path.to_owned()
+}
+
 #[cfg(not(windows))]
 #[track_caller]
 fn rel_path_to_forward_slashes(path: &Utf8Path) -> Utf8PathBuf {
@@ -309,11 +325,7 @@ pub mod data_source_kinds {
             let s = self.to_string();
             let path = Utf8Path::new(&s);
 
-            if !is_truly_relative(path) {
-                panic!("data source path must be relative: '{}'", s);
-            }
-
-            DataSource::Directory(rel_path_to_forward_slashes(path))
+            DataSource::Directory(normalize_slashes(path))
         }
     }
 
@@ -347,12 +359,6 @@ pub mod data_source_kinds {
 mod tests {
     use super::*;
 
-    #[test]
-    #[should_panic = "data source path must be relative: '/absolute/path'"]
-    fn data_source_absolute_path_panics() {
-        data_source_kinds::AsDirectory::resolve_data_source("/absolute/path");
-    }
-
     #[test]
     fn missing_test_name() {
         assert_eq!(derive_test_path("root".into(), "file", "test_name"), None);

src/lib.rs

@@ -51,9 +51,8 @@
 //!     in as a `Vec<u8>` (erroring out if that failed).
 //!
 //! * `root` - The path to the root directory where the input files (fixtures)
-//!   live. This path is relative to the root of the crate (the directory where
-//!   the crate's `Cargo.toml` is located). Absolute paths are not supported, and
-//!   will panic at runtime.
+//!   live. Relative paths are resolved relative to the crate root (the directory where the crate's
+//!   `Cargo.toml` is located).
 //!
 //!   `root` is an arbitrary expression that implements
 //!   [`Display`](std::fmt::Display), such as `&str`, or a function call that
@@ -74,17 +73,20 @@
 //! }
 //! ```
 //!
-//! ## Relative paths
+//! ## Relative and absolute paths
 //!
 //! The `pattern` argument is tested against the **relative** path of each file,
 //! **excluding** the `root` prefix -- not the absolute path.
 //!
-//! The `Path` and `Utf8Path` passed into the test functions are **relative** to
-//! the root of the crate, obtained by joining `root` to the relative path of
-//! the file.
+//! The `Path` and `Utf8Path` passed into the test functions are created by
+//! joining `root` to the relative path of the file.
 //!
-//! For universality, all relative paths use `/` as the path separator,
-//! including on Windows.
+//! * If `root` is **relative**, the paths passed in are relative to the crate root.
+//! * If `root` is **absolute**, the paths passed in are absolute.
+//!
+//! For uniformity, all relative paths use `/` as the path separator,
+//! including on Windows, and all absolute paths use the platform's native
+//! separator throughout.
 //!
 //! ## Examples
 //!
@@ -166,9 +168,9 @@
 //! }
 //! ```
 //!
-//! In this case, the passed-in `Path` and `Utf8Path` are **relative** to the
-//! root of the included directory. Like elsewhere in `datatest-stable`, these
-//! relative paths always use forward slashes as separators, including on
+//! In this case, the passed-in `Path` and `Utf8Path` are always **relative** to
+//! the root of the included directory. Like elsewhere in `datatest-stable`,
+//! these relative paths always use forward slashes as separators, including on
 //! Windows.
 //!
 //! Because the files don't exist on disk, the test functions must accept their

tests/example.rs

@@ -17,6 +17,23 @@ fn test_artifact_utf8(path: &Utf8Path) -> Result<()> {
     test_artifact(path.as_ref())
 }
 
+fn test_artifact_utf8_abs(path: &Utf8Path) -> Result<()> {
+    // path must be absolute
+    assert!(path.is_absolute(), "path must be absolute: {:?}", path);
+
+    // On Windows, the path must be normalized to use backslashes.
+    #[cfg(windows)]
+    {
+        assert!(
+            !path.as_str().contains('/'),
+            "path must not contain forward slashes: {:?}",
+            path
+        );
+    }
+
+    test_artifact(path.as_ref())
+}
+
 #[cfg(feature = "include-dir")]
 #[macro_use]
 mod with_contents {
@@ -132,6 +149,14 @@ static TESTS_FILES_MAIN_SEP: &str = "tests\\files";
 #[cfg(not(windows))]
 static TESTS_FILES_MAIN_SEP: &str = "tests/files";
 
+fn tests_files_abs() -> String {
+    std::env::current_dir()
+        .expect("current dir obtained")
+        .join("tests/files")
+        .to_string_lossy()
+        .into_owned()
+}
+
 datatest_stable::harness! {
     {
         test = test_artifact,
@@ -146,6 +171,16 @@ datatest_stable::harness! {
         // This regex pattern matches all files.
         pattern = r"^.*\.txt$",
     },
+    {
+        test = test_artifact_utf8_abs,
+        // Ensure that tests/files in an absolute path is normalized to
+        // tests\files on Windows.
+        root = tests_files_abs(),
+        // This regex matches exactly dir/a.txt, b.txt, and c.skip.txt -- this
+        // ensures that patterns are relative to the include dir and not the
+        // crate root.
+        pattern = r"^(dir/a|b|c\.skip)\.txt$",
+    },
     {
         test = with_contents::test_artifact_string,
         root = maybe_include_dir!(),

tests/integration.rs

@@ -5,6 +5,9 @@ static EXPECTED_LINES: &[&str] = &[
     "datatest-stable::example test_artifact_utf8::dir/a.txt",
     "datatest-stable::example test_artifact_utf8::b.txt",
     "datatest-stable::example test_artifact_utf8::c.skip.txt",
+    "datatest-stable::example test_artifact_utf8_abs::dir/a.txt",
+    "datatest-stable::example test_artifact_utf8_abs::b.txt",
+    "datatest-stable::example test_artifact_utf8_abs::c.skip.txt",
     "datatest-stable::example test_artifact::dir/a.txt",
     "datatest-stable::example test_artifact::b.txt",
     "datatest-stable::example with_contents::test_artifact_bytes::dir/a.txt",
@@ -43,7 +46,7 @@ fn run_example() {
     for line in EXPECTED_LINES
         .iter()
         .copied()
-        .chain(std::iter::once("17 tests run: 17 passed, 0 skipped"))
+        .chain(std::iter::once("20 tests run: 20 passed, 0 skipped"))
     {
         assert!(
             stderr.contains(line),
@@ -69,6 +72,9 @@ mod unix {
         "datatest-stable::example test_artifact_utf8::dir/a.txt",
         "datatest-stable::example test_artifact_utf8::b.txt",
         "datatest-stable::example test_artifact_utf8::c.skip.txt",
+        "datatest-stable::example test_artifact_utf8_abs::dir/a.txt",
+        "datatest-stable::example test_artifact_utf8_abs::b.txt",
+        "datatest-stable::example test_artifact_utf8_abs::c.skip.txt",
         "datatest-stable::example test_artifact::::colon::dir/::.txt",
         "datatest-stable::example test_artifact::::colon::dir/a.txt",
         "datatest-stable::example test_artifact::dir/a.txt",
@@ -135,7 +141,7 @@ mod unix {
             .iter()
             .chain(EXPECTED_UNIX_LINES.iter())
             .copied()
-            .chain(std::iter::once("27 tests run: 27 passed, 0 skipped"))
+            .chain(std::iter::once("30 tests run: 30 passed, 0 skipped"))
         {
             assert!(
                 stderr.contains(line),