html-to-markdown 2.27.2 → 2.27.3

data/rust-vendor/tokio/src/signal/windows.rs

@@ -16,9 +16,6 @@ use std::task::{Context, Poll};
 #[path = "windows/sys.rs"]
 mod imp;
 
-#[cfg(windows)]
-pub(crate) use self::imp::{OsExtraData, OsStorage};
-
 // For building documentation on Unix machines when the `docsrs` flag is set.
 #[cfg(not(windows))]
 #[path = "windows/stub.rs"]
@@ -72,7 +69,8 @@ pub struct CtrlC {
 impl CtrlC {
     /// Receives the next signal notification event.
     ///
-    /// `None` is returned if no more events can be received by the listener.
+    /// Although this returns `Option<()>`, it will never actually return `None`.
+    /// This was accidentally exposed and would be a breaking change to be removed.
     ///
     /// # Examples
     ///
@@ -93,13 +91,15 @@ impl CtrlC {
     /// }
     /// ```
     pub async fn recv(&mut self) -> Option<()> {
-        self.inner.recv().await
+        self.inner.recv().await;
+        Some(())
     }
 
     /// Polls to receive the next signal notification event, outside of an
     /// `async` context.
     ///
-    /// `None` is returned if no more events can be received.
+    /// Although this returns `Option<()>`, it will never actually return `None`.
+    /// This was accidentally exposed and would be a breaking change to be removed.
     ///
     /// # Examples
     ///
@@ -125,7 +125,7 @@ impl CtrlC {
     /// }
     /// ```
     pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        self.inner.poll_recv(cx)
+        self.inner.poll_recv(cx).map(Some)
     }
 }
 
@@ -149,7 +149,8 @@ pub struct CtrlBreak {
 impl CtrlBreak {
     /// Receives the next signal notification event.
     ///
-    /// `None` is returned if no more events can be received by this listener.
+    /// Although this returns `Option<()>`, it will never actually return `None`.
+    /// This was accidentally exposed and would be a breaking change to be removed.
     ///
     /// # Examples
     ///
@@ -169,13 +170,15 @@ impl CtrlBreak {
     /// }
     /// ```
     pub async fn recv(&mut self) -> Option<()> {
-        self.inner.recv().await
+        self.inner.recv().await;
+        Some(())
     }
 
     /// Polls to receive the next signal notification event, outside of an
     /// `async` context.
     ///
-    /// `None` is returned if no more events can be received by this listener.
+    /// Although this returns `Option<()>`, it will never actually return `None`.
+    /// This was accidentally exposed and would be a breaking change to be removed.
     ///
     /// # Examples
     ///
@@ -201,7 +204,7 @@ impl CtrlBreak {
     /// }
     /// ```
     pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        self.inner.poll_recv(cx)
+        self.inner.poll_recv(cx).map(Some)
     }
 }
 
@@ -275,7 +278,8 @@ pub struct CtrlClose {
 impl CtrlClose {
     /// Receives the next signal notification event.
     ///
-    /// `None` is returned if no more events can be received by this listener.
+    /// Although this returns `Option<()>`, it will never actually return `None`.
+    /// This was accidentally exposed and would be a breaking change to be removed.
     ///
     /// # Examples
     ///
@@ -295,13 +299,15 @@ impl CtrlClose {
     /// }
     /// ```
     pub async fn recv(&mut self) -> Option<()> {
-        self.inner.recv().await
+        self.inner.recv().await;
+        Some(())
     }
 
     /// Polls to receive the next signal notification event, outside of an
     /// `async` context.
     ///
-    /// `None` is returned if no more events can be received by this listener.
+    /// Although this returns `Option<()>`, it will never actually return `None`.
+    /// This was accidentally exposed and would be a breaking change to be removed.
     ///
     /// # Examples
     ///
@@ -327,7 +333,7 @@ impl CtrlClose {
     /// }
     /// ```
     pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        self.inner.poll_recv(cx)
+        self.inner.poll_recv(cx).map(Some)
     }
 }
 
@@ -372,7 +378,8 @@ pub struct CtrlShutdown {
 impl CtrlShutdown {
     /// Receives the next signal notification event.
     ///
-    /// `None` is returned if no more events can be received by this listener.
+    /// Although this returns `Option<()>`, it will never actually return `None`.
+    /// This was accidentally exposed and would be a breaking change to be removed.
     ///
     /// # Examples
     ///
@@ -392,13 +399,15 @@ impl CtrlShutdown {
     /// }
     /// ```
     pub async fn recv(&mut self) -> Option<()> {
-        self.inner.recv().await
+        self.inner.recv().await;
+        Some(())
     }
 
     /// Polls to receive the next signal notification event, outside of an
     /// `async` context.
     ///
-    /// `None` is returned if no more events can be received by this listener.
+    /// Although this returns `Option<()>`, it will never actually return `None`.
+    /// This was accidentally exposed and would be a breaking change to be removed.
     ///
     /// # Examples
     ///
@@ -424,7 +433,7 @@ impl CtrlShutdown {
     /// }
     /// ```
     pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        self.inner.poll_recv(cx)
+        self.inner.poll_recv(cx).map(Some)
     }
 }
 
@@ -469,7 +478,8 @@ pub struct CtrlLogoff {
 impl CtrlLogoff {
     /// Receives the next signal notification event.
     ///
-    /// `None` is returned if no more events can be received by this listener.
+    /// Although this returns `Option<()>`, it will never actually return `None`.
+    /// This was accidentally exposed and would be a breaking change to be removed.
     ///
     /// # Examples
     ///
@@ -489,13 +499,15 @@ impl CtrlLogoff {
     /// }
     /// ```
     pub async fn recv(&mut self) -> Option<()> {
-        self.inner.recv().await
+        self.inner.recv().await;
+        Some(())
     }
 
     /// Polls to receive the next signal notification event, outside of an
     /// `async` context.
     ///
-    /// `None` is returned if no more events can be received by this listener.
+    /// Although this returns `Option<()>`, it will never actually return `None`.
+    /// This was accidentally exposed and would be a breaking change to be removed.
     ///
     /// # Examples
     ///
@@ -521,6 +533,6 @@ impl CtrlLogoff {
     /// }
     /// ```
     pub fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        self.inner.poll_recv(cx)
+        self.inner.poll_recv(cx).map(Some)
     }
 }

data/rust-vendor/tokio/src/sync/mpsc/mod.rs

@@ -29,7 +29,9 @@
 //!
 //! When all [`Sender`] handles have been dropped, it is no longer
 //! possible to send values into the channel. This is considered the termination
-//! event of the stream. As such, `Receiver::poll` returns `Ok(Ready(None))`.
+//! event of the stream. Once all senders have been dropped and any remaining
+//! buffered values have been received, `Receiver::recv` returns `None`
+//! (and `Receiver::poll_recv` returns `Poll::Ready(None)`).
 //!
 //! If the [`Receiver`] handle is dropped, then messages can no longer
 //! be read out of the channel. In this case, all further attempts to send will

data/rust-vendor/tokio/src/sync/oneshot.rs

@@ -1391,6 +1391,19 @@ impl<T> Inner<T> {
             }
         }
 
+        if prev.is_rx_task_set() && !prev.is_complete() {
+            State::unset_rx_task(&self.state);
+            // SAFETY: The sender only accesses `rx_task` (via
+            // `wake_by_ref`) in `complete()` after successfully setting
+            // `VALUE_SENT`. But `set_complete` will not set `VALUE_SENT`
+            // if `CLOSED` is already set (its CAS loop breaks early).
+            // Since `prev` shows that `VALUE_SENT` was not set before we
+            // set `CLOSED`, the sender can no longer set `VALUE_SENT` and
+            // will never access `rx_task`. Therefore, we have exclusive
+            // access here.
+            unsafe { self.rx_task.drop_task() };
+        }
+
         prev
     }
 

data/rust-vendor/tokio/src/sync/rwlock.rs

@@ -41,11 +41,10 @@ const MAX_READS: u32 = 10;
 /// The priority policy of Tokio's read-write lock is _fair_ (or
 /// [_write-preferring_]), in order to ensure that readers cannot starve
 /// writers. Fairness is ensured using a first-in, first-out queue for the tasks
-/// awaiting the lock; if a task that wishes to acquire the write lock is at the
-/// head of the queue, read locks will not be given out until the write lock has
-/// been released. This is in contrast to the Rust standard library's
-/// `std::sync::RwLock`, where the priority policy is dependent on the
-/// operating system's implementation.
+/// awaiting the lock; a read lock will not be given out until all write lock
+/// requests that were queued before it have been acquired and released. This is
+/// in contrast to the Rust standard library's `std::sync::RwLock`, where the
+/// priority policy is dependent on the operating system's implementation.
 ///
 /// The type parameter `T` represents the data that this lock protects. It is
 /// required that `T` satisfies [`Send`] to be shared across threads. The RAII guards

data/rust-vendor/tokio/src/sync/tests/loom_oneshot.rs

@@ -3,6 +3,7 @@ use crate::sync::oneshot;
 use loom::future::block_on;
 use loom::thread;
 use std::future::poll_fn;
+use std::pin::Pin;
 use std::task::Poll::{Pending, Ready};
 
 #[test]
@@ -87,7 +88,6 @@ fn recv_closed() {
 // TODO: Move this into `oneshot` proper.
 
 use std::future::Future;
-use std::pin::Pin;
 use std::task::{Context, Poll};
 
 struct OnClose<'a> {
@@ -185,3 +185,29 @@ fn checking_tx_send_ok_not_drop() {
         tx_thread_join_handle.join().unwrap();
     });
 }
+
+#[test]
+fn drop_rx_after_poll() {
+    // Test that rx_task is properly deallocated when the receiver is dropped
+    // after being polled (which sets rx_task), while the sender is concurrently
+    // trying to send.
+    loom::model(|| {
+        let (tx, mut rx) = oneshot::channel::<i32>();
+
+        // Poll once to set rx_task before entering the parallel part of the
+        // test.
+        let _ = block_on(poll_fn(|cx| {
+            let _ = Pin::new(&mut rx).poll(cx);
+            Ready(())
+        }));
+
+        // Drop the receiver concurrently with the sender trying to send.
+        let rx_thread = thread::spawn(move || {
+            drop(rx);
+        });
+
+        let _ = tx.send(1);
+
+        rx_thread.join().unwrap();
+    });
+}

data/rust-vendor/tokio/src/task/blocking.rs

@@ -96,7 +96,7 @@ cfg_rt! {
     /// asynchronously.  When you run CPU-bound code using `spawn_blocking`, you
     /// should keep this large upper limit in mind. When running many CPU-bound
     /// computations, a semaphore or some other synchronization primitive should be
-    /// used to limit the number of computation executed in parallel. Specialized
+    /// used to limit the number of computations executed in parallel. Specialized
     /// CPU-bound executors, such as [rayon], may also be a good fit.
     ///
     /// This function is intended for non-async operations that eventually finish on
@@ -119,6 +119,21 @@ cfg_rt! {
     /// returns. It is possible for a blocking task to be cancelled if it has
     /// not yet started running, but this is not guaranteed.
     ///
+    /// # When to use `spawn_blocking` vs dedicated threads
+    ///
+    /// `spawn_blocking` is intended for *bounded* blocking work that eventually finishes.
+    /// Each call occupies a thread from the runtime's blocking thread pool for the duration
+    /// of the task. Long-lived tasks therefore reduce the pool's effective capacity, which
+    /// can delay other blocking operations once the pool is saturated and work is queued.
+    ///
+    /// For workloads that run indefinitely or for extended periods (for example,
+    /// background workers or persistent processing loops), prefer a dedicated thread created with
+    /// [`thread::spawn`].
+    ///
+    /// As a rule of thumb:
+    /// - Use `spawn_blocking` for short-lived blocking operations
+    /// - Use dedicated threads for long-lived or persistent blocking workloads
+    ///
     /// Note that if you are using the single threaded runtime, this function will
     /// still spawn additional threads for blocking operations. The current-thread
     /// scheduler's single thread is only used for asynchronous code.

data/rust-vendor/tokio/src/task/builder.rs

@@ -20,7 +20,7 @@ use std::{future::Future, io, mem};
 ///   the task
 ///
 /// There are three types of task that can be spawned from a Builder:
-/// - [`spawn_local`] for executing futures on the current thread
+/// - [`spawn_local`] for executing not [`Send`] futures
 /// - [`spawn`] for executing [`Send`] futures on the runtime
 /// - [`spawn_blocking`] for executing blocking code in the
 ///   blocking thread pool.
@@ -118,7 +118,7 @@ impl<'a> Builder<'a> {
         })
     }
 
-    /// Spawns `!Send` a task on the current [`LocalSet`] or [`LocalRuntime`] with
+    /// Spawns a `!Send` task on the current [`LocalSet`] or [`LocalRuntime`] with
     /// this builder's settings.
     ///
     /// The spawned future will be run on the same thread that called `spawn_local`.

data/rust-vendor/tokio/src/task/mod.rs

@@ -180,7 +180,7 @@
 //! #### `spawn_blocking`
 //!
 //! The `task::spawn_blocking` function is similar to the `task::spawn` function
-//! discussed in the previous section, but rather than spawning an
+//! discussed in the previous section, but rather than spawning a
 //! _non-blocking_ future on the Tokio runtime, it instead spawns a
 //! _blocking_ function on a dedicated thread pool for blocking tasks. For
 //! example:

data/rust-vendor/tokio/src/task/spawn.rs

@@ -6,16 +6,19 @@ use std::future::Future;
 
 cfg_rt! {
     /// Spawns a new asynchronous task, returning a
-    /// [`JoinHandle`](JoinHandle) for it.
+    /// [`JoinHandle`] for it.
     ///
     /// The provided future will start running in the background immediately
     /// when `spawn` is called, even if you don't await the returned
-    /// `JoinHandle`.
+    /// [`JoinHandle`].
     ///
     /// Spawning a task enables the task to execute concurrently to other tasks. The
     /// spawned task may execute on the current thread, or it may be sent to a
     /// different thread to be executed. The specifics depend on the current
-    /// [`Runtime`](crate::runtime::Runtime) configuration.
+    /// [`Runtime`](crate::runtime::Runtime) configuration. In a
+    /// [running runtime][running-runtime], the task will start immediately in the
+    /// background. On a blocked runtime, the user must drive the runtime forward (for
+    /// example, by calling [`Runtime::block_on`](crate::runtime::Runtime::block_on)).
     ///
     /// It is guaranteed that spawn will not synchronously poll the task being spawned.
     /// This means that calling spawn while holding a lock does not pose a risk of
@@ -29,6 +32,8 @@ cfg_rt! {
     /// the Tokio runtime are always inside its context, but you can also enter the context
     /// using the [`Runtime::enter`](crate::runtime::Runtime::enter()) method.
     ///
+    /// [running-runtime]: ../runtime/index.html#driving-the-runtime
+    ///
     /// # Examples
     ///
     /// In this example, a server is started and `spawn` is used to start a new task

data/rust-vendor/tokio/src/task/yield_now.rs

@@ -1,8 +1,7 @@
 use crate::runtime::context;
 
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{ready, Context, Poll};
+use std::future::poll_fn;
+use std::task::{ready, Poll};
 
 /// Yields execution back to the Tokio runtime.
 ///
@@ -37,28 +36,19 @@ use std::task::{ready, Context, Poll};
 /// [`tokio::select!`]: macro@crate::select
 #[cfg_attr(docsrs, doc(cfg(feature = "rt")))]
 pub async fn yield_now() {
-    /// Yield implementation
-    struct YieldNow {
-        yielded: bool,
-    }
+    let mut yielded = false;
+    poll_fn(|cx| {
+        ready!(crate::trace::trace_leaf(cx));
 
-    impl Future for YieldNow {
-        type Output = ();
-
-        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
-            ready!(crate::trace::trace_leaf(cx));
-
-            if self.yielded {
-                return Poll::Ready(());
-            }
-
-            self.yielded = true;
+        if yielded {
+            return Poll::Ready(());
+        }
 
-            context::defer(cx.waker());
+        yielded = true;
 
-            Poll::Pending
-        }
-    }
+        context::defer(cx.waker());
 
-    YieldNow { yielded: false }.await;
+        Poll::Pending
+    })
+    .await
 }

data/rust-vendor/tokio/src/time/clock.rs

@@ -124,8 +124,39 @@ cfg_test_util! {
     /// other timer-backed primitives can cause the runtime to advance the
     /// current time when awaited.
     ///
+    /// # Preventing auto-advance
+    ///
+    /// In some testing scenarios, you may want to keep the clock paused without
+    /// auto-advancing, even while waiting for I/O or other asynchronous operations.
+    /// This can be achieved by using [`spawn_blocking`] to wrap your I/O operations.
+    ///
+    /// When a blocking task is running, the clock's auto-advance is temporarily
+    /// inhibited. This allows you to wait for I/O to complete while keeping the
+    /// paused clock stationary:
+    ///
+    /// ```ignore
+    /// use tokio::time::{Duration, Instant};
+    /// use tokio::task;
+    ///
+    /// #[tokio::test(start_paused = true)]
+    /// async fn test_with_io() {
+    ///     let start = Instant::now();
+    ///
+    ///     // The clock will NOT auto-advance while this blocking task runs
+    ///     let result = task::spawn_blocking(|| {
+    ///         // Perform I/O operations here
+    ///         std::thread::sleep(std::time::Duration::from_millis(10));
+    ///         42
+    ///     }).await.unwrap();
+    ///
+    ///     // Time has not advanced
+    ///     assert_eq!(start.elapsed(), Duration::ZERO);
+    /// }
+    /// ```
+    ///
     /// [`Sleep`]: crate::time::Sleep
     /// [`advance`]: crate::time::advance
+    /// [`spawn_blocking`]: crate::task::spawn_blocking
     #[track_caller]
     pub fn pause() {
         with_clock(|maybe_clock| {
@@ -183,6 +214,37 @@ cfg_test_util! {
     /// `advance`. However if they don't, the runtime will poll the task again
     /// shortly.
     ///
+    /// # When to use `sleep` instead
+    ///
+    /// **Important:** `advance` is designed for testing scenarios where you want to
+    /// instantly jump forward in time. However, it has limitations that make it
+    /// unsuitable for certain use cases:
+    ///
+    /// - **Forcing timeouts:** If you want to reliably trigger a timeout, prefer
+    ///   using [`sleep`] with auto-advance rather than `advance`. The `advance`
+    ///   function jumps time forward but doesn't guarantee that all timers will be
+    ///   processed before your code continues.
+    ///
+    /// - **Simulating freezes:** If you're trying to simulate a scenario where the
+    ///   program freezes and then resumes, the batch behavior of `advance` may not
+    ///   produce the expected results. All timers that expire during the advance
+    ///   complete simultaneously.
+    ///
+    /// For most testing scenarios where you want to wait for a duration to pass
+    /// and have all timers fire in order, use [`sleep`] instead:
+    ///
+    /// ```ignore
+    /// use tokio::time::{self, Duration};
+    ///
+    /// #[tokio::test(start_paused = true)]
+    /// async fn test_timeout_reliable() {
+    ///     // Use sleep with auto-advance for reliable timeout testing
+    ///     time::sleep(Duration::from_secs(5)).await;
+    ///     // All timers that were scheduled to fire within 5 seconds
+    ///     // have now been processed in order
+    /// }
+    /// ```
+    ///
     /// # Panics
     ///
     /// Panics if any of the following conditions are met:

data/rust-vendor/tokio/src/util/memchr.rs

@@ -4,22 +4,50 @@
 //! that we only depend on libc on unix.
 
 #[cfg(not(all(unix, feature = "libc")))]
-pub(crate) fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {
+fn memchr_inner(needle: u8, haystack: &[u8]) -> Option<usize> {
     haystack.iter().position(|val| needle == *val)
 }
 
 #[cfg(all(unix, feature = "libc"))]
-pub(crate) fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {
+fn memchr_inner(needle: u8, haystack: &[u8]) -> Option<usize> {
     let start = haystack.as_ptr();
 
     // SAFETY: `start` is valid for `haystack.len()` bytes.
-    let ptr = unsafe { libc::memchr(start.cast(), needle as _, haystack.len()) };
+    let ptr = (unsafe { libc::memchr(start.cast(), needle as _, haystack.len()) })
+        .cast::<u8>()
+        .cast_const();
 
     if ptr.is_null() {
         None
     } else {
-        Some(ptr as usize - start as usize)
+        // SAFETY: `ptr` will always be in bounds, since libc guarantees that the ptr will either
+        //          be to an element inside the array or the ptr will be null
+        //          since the ptr is in bounds the offset must also always be non null
+        //          and there can't be more than isize::MAX elements inside an array
+        //          as rust guarantees that the maximum number of bytes a allocation
+        //          may occupy is isize::MAX
+        unsafe {
+            // TODO(MSRV 1.87): When bumping MSRV, switch to `ptr.byte_offset_from_unsigned(start)`.
+            Some(usize::try_from(ptr.offset_from(start)).unwrap_unchecked())
+        }
+    }
+}
+
+pub(crate) fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {
+    let index = memchr_inner(needle, haystack)?;
+
+    // SAFETY: `memchr_inner` returns Some(index) and in that case index must point to an element in haystack
+    //         or `memchr_inner` None which is guarded by the `?` operator above
+    //         therefore the index must **always** point to an element in the array
+    //         and so this indexing operation is safe
+    // TODO(MSRV 1.81): When bumping MSRV, switch to `std::hint::assert_unchecked(haystack.get(..=index).is_some());`
+    unsafe {
+        if haystack.get(..=index).is_none() {
+            std::hint::unreachable_unchecked()
+        }
     }
+
+    Some(index)
 }
 
 #[cfg(test)]

data/rust-vendor/tokio/src/util/sharded_list.rs

@@ -107,10 +107,12 @@ impl<L: ShardedListItem> ShardedList<L, L::Target> {
         self.count.load(Ordering::Relaxed)
     }
 
-    cfg_64bit_metrics! {
-        /// Gets the total number of elements added to this list.
-        pub(crate) fn added(&self) -> u64 {
-            self.added.load(Ordering::Relaxed)
+    cfg_unstable_metrics! {
+        cfg_64bit_metrics! {
+            /// Gets the total number of elements added to this list.
+            pub(crate) fn added(&self) -> u64 {
+                self.added.load(Ordering::Relaxed)
+            }
         }
     }
 

data/rust-vendor/tokio/tests/fs_link.rs

@@ -60,3 +60,57 @@ async fn test_symlink() {
     let symlink_meta = fs::symlink_metadata(dst.clone()).await.unwrap();
     assert!(symlink_meta.file_type().is_symlink());
 }
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `linkat` in miri.
+async fn test_hard_link_error_source_not_found() {
+    let dir = tempdir().unwrap();
+    let src = dir.path().join("nonexistent.txt");
+    let dst = dir.path().join("dst.txt");
+
+    let err = fs::hard_link(&src, &dst).await.unwrap_err();
+    assert_eq!(err.kind(), std::io::ErrorKind::NotFound);
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `linkat` in miri.
+async fn test_hard_link_error_destination_already_exists() {
+    let dir = tempdir().unwrap();
+    let src = dir.path().join("src.txt");
+    let dst = dir.path().join("dst.txt");
+
+    // Create source file
+    std::fs::write(&src, b"source content").unwrap();
+
+    // Create destination file
+    std::fs::write(&dst, b"destination content").unwrap();
+
+    // Attempt to create hard link when destination already exists
+    let err = fs::hard_link(&src, &dst).await.unwrap_err();
+    assert_eq!(err.kind(), std::io::ErrorKind::AlreadyExists);
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `linkat` in miri.
+async fn test_hard_link_error_source_is_directory() {
+    let dir = tempdir().unwrap();
+    let src_dir = dir.path().join("src_directory");
+    let dst = dir.path().join("dst.txt");
+
+    // Create source directory
+    fs::create_dir(&src_dir).await.unwrap();
+
+    // Attempt to create hard link from a directory
+    // On most systems, hard linking directories is not allowed
+    let err = fs::hard_link(&src_dir, &dst).await.unwrap_err();
+
+    // Different platforms return different error kinds
+    #[cfg(unix)]
+    assert!(
+        err.kind() == std::io::ErrorKind::PermissionDenied
+            || err.kind() == std::io::ErrorKind::Other
+    );
+
+    #[cfg(windows)]
+    assert_eq!(err.kind(), std::io::ErrorKind::PermissionDenied);
+}