diff --git a/Cargo.toml b/Cargo.toml
index f256d3a..db3b8de 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,6 +23,9 @@ wasm-bindgen = { version = "0.2.70", default-features = false }
 opt-level = 1
 
 [dev-dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_test = "1"
+serde_json = "1"
 static_assertions = "1"
 
 [target.'cfg(not(target_family = "wasm"))'.dev-dependencies]
@@ -31,7 +34,6 @@ pollster = { version = "0.3", features = ["macro"] }
 [target.'cfg(target_family = "wasm")'.dev-dependencies]
 getrandom = { version = "0.2", features = ["js"] }
 rand = "0.8"
-serde_json = "1"
 wasm-bindgen-futures = "0.4"
 wasm-bindgen-test = "0.3"
 web-sys = { version = "0.3", features = [
diff --git a/tests/serde.rs b/tests/serde.rs
index f05dddc..92dedf8 100644
--- a/tests/serde.rs
+++ b/tests/serde.rs
@@ -1,50 +1,76 @@
 #![cfg(test)]
-#![cfg(target_family = "wasm")]
+
+mod util;
 
 use std::time::{Duration, SystemTime as StdSystemTime};
 
-use wasm_bindgen_test::wasm_bindgen_test;
+use serde_test::Token;
 use web_time::SystemTime;
 
-wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
+test! {
+	/// De/Serialization of [`SystemTime`].
+	async fn system_time_json() {
+		let time = SystemTime::now();
+		let serialized = serde_json::to_string(&time).unwrap();
+		let deserialized: SystemTime = serde_json::from_str(&serialized).unwrap();
+		assert_eq!(time, deserialized);
+	}
 
-/// De/Serialization of [`SystemTime`].
-#[wasm_bindgen_test]
-fn system_time() {
-	let time = SystemTime::now();
-	let serialized = serde_json::to_string(&time).unwrap();
-	let deserialized: SystemTime = serde_json::from_str(&serialized).unwrap();
-	assert_eq!(time, deserialized);
-}
+	/// De/Serialization of [`SystemTime`] with
+	/// [`UNIX_EPOCH`](SystemTime::UNIX_EPOCH).
+	async fn unix_epoch_json() {
+		let time = SystemTime::UNIX_EPOCH;
+		let serialized = serde_json::to_string(&time).unwrap();
+		let deserialized: SystemTime = serde_json::from_str(&serialized).unwrap();
+		assert_eq!(time, deserialized);
+	}
 
-/// De/Serialization of [`SystemTime`] with
-/// [`UNIX_EPOCH`](SystemTime::UNIX_EPOCH).
-#[wasm_bindgen_test]
-fn unix_epoch() {
-	let time = SystemTime::UNIX_EPOCH;
-	let serialized = serde_json::to_string(&time).unwrap();
-	let deserialized: SystemTime = serde_json::from_str(&serialized).unwrap();
-	assert_eq!(time, deserialized);
-}
+	/// De/Serialization compatibility with [`std::time::SystemTime`].
+	async fn std_compatibility_json() {
+		let time = SystemTime::now();
+		let serialized = serde_json::to_string(&time).unwrap();
+		let deserialized: StdSystemTime = serde_json::from_str(&serialized).unwrap();
+		assert_eq!(
+			time.duration_since(SystemTime::UNIX_EPOCH).unwrap(),
+			deserialized
+				.duration_since(StdSystemTime::UNIX_EPOCH)
+				.unwrap()
+		);
 
-#[wasm_bindgen_test]
-/// De/Serialization compatibility with [`std::time::SystemTime`].
-fn std_compatibility() {
-	let time = SystemTime::now();
-	let serialized = serde_json::to_string(&time).unwrap();
-	let deserialized: StdSystemTime = serde_json::from_str(&serialized).unwrap();
-	assert_eq!(
-		time.duration_since(SystemTime::UNIX_EPOCH).unwrap(),
-		deserialized
-			.duration_since(StdSystemTime::UNIX_EPOCH)
-			.unwrap()
-	);
+		let time = StdSystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
+		let serialized = serde_json::to_string(&time).unwrap();
+		let deserialized: SystemTime = serde_json::from_str(&serialized).unwrap();
+		assert_eq!(
+			time.duration_since(StdSystemTime::UNIX_EPOCH).unwrap(),
+			deserialized.duration_since(SystemTime::UNIX_EPOCH).unwrap()
+		);
+	}
+
+	/// Deserialization failures.
+	async fn failure() {
+		serde_test::assert_de_tokens_error::<SystemTime>(
+			&[
+				Token::Map { len: Some(3) },
+				Token::Bytes(b"secs_since_epoch"),
+				Token::U64(0),
+				Token::Bytes(b"nanos_since_epoch"),
+				Token::U32(0),
+				Token::Bytes(b"test"),
+			],
+			"unknown field `test`, expected `secs_since_epoch` or `nanos_since_epoch`",
+		);
+	}
+}
 
-	let time = StdSystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000);
-	let serialized = serde_json::to_string(&time).unwrap();
-	let deserialized: SystemTime = serde_json::from_str(&serialized).unwrap();
-	assert_eq!(
-		time.duration_since(StdSystemTime::UNIX_EPOCH).unwrap(),
-		deserialized.duration_since(SystemTime::UNIX_EPOCH).unwrap()
+/// Deserialization failures.
+fn asdasd() {
+	serde_test::assert_de_tokens_error::<SystemTime>(
+		&[
+			Token::Map { len: Some(1) },
+			Token::Bytes(b"secs_since_epoch"),
+			Token::I32(0),
+			Token::MapEnd,
+		],
+		"unknown field `x`, expected `a` or `b`",
 	);
 }
diff --git a/tests/util/mod.rs b/tests/util/mod.rs
index d4d820e..2a7b9a6 100644
--- a/tests/util/mod.rs
+++ b/tests/util/mod.rs
@@ -6,8 +6,10 @@ mod web;
 use web_time::Duration;
 
 #[cfg(not(target_family = "wasm"))]
+#[allow(unused)]
 pub(crate) use self::std::*;
 #[cfg(target_family = "wasm")]
+#[allow(unused)]
 pub(crate) use self::web::*;
 
 pub(crate) const DIFF: Duration = Duration::from_millis(50);
diff --git a/tests/util/std.rs b/tests/util/std.rs
index b82719a..624ac57 100644
--- a/tests/util/std.rs
+++ b/tests/util/std.rs
@@ -4,6 +4,7 @@ use std::thread;
 use web_time::Duration;
 
 /// Sleeps for the given [`Duration`].
+#[allow(unused)]
 pub(crate) fn sleep(duration: Duration) -> Ready<()> {
 	thread::sleep(duration);
 	future::ready(())
diff --git a/tests/util/web.rs b/tests/util/web.rs
index 24b3899..deee0f0 100644
--- a/tests/util/web.rs
+++ b/tests/util/web.rs
@@ -30,6 +30,7 @@ impl Future for Sleep {
 }
 
 /// Sleeps for the given [`Duration`].
+#[allow(unused)]
 pub(crate) fn sleep(duration: Duration) -> Sleep {
 	#[cfg(target_feature = "atomics")]
 	enum Global {