Improve Serde test coverage

.github/workflows/coverage-documentation.yaml

@@ -139,7 +139,7 @@ jobs:
               objects+=(-object $file)
           done
           llvm-cov-18 show -show-instantiations=false -Xdemangler=rustfilt -output-dir coverage-output -format=html -instr-profile=coverage-input/coverage.profdata ${objects[@]} -sources src
-          llvm-cov-18 export -format=lcov -skip-functions -instr-profile=coverage-input/coverage.profdata ${objects[@]} -sources src > coverage-output/coverage.lcov
+          llvm-cov-18 export -format=lcov -instr-profile=coverage-input/coverage.profdata ${objects[@]} -sources src > coverage-output/coverage.lcov
           llvm-cov-18 export -format=text -summary-only -instr-profile=coverage-input/coverage.profdata ${objects[@]} -sources src | \
           printf '{ "coverage": "%.2f%%" }' $(jq '.data[0].totals.functions.percent') > coverage-output/coverage.json
       - name: Download Previous Coverage Report

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"] }
+bincode = "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 = [

tests/serde.rs

@@ -1,50 +1,159 @@
 #![cfg(test)]
-#![cfg(target_family = "wasm")]
+
+mod util;
 
 use std::time::{Duration, SystemTime as StdSystemTime};
 
-use wasm_bindgen_test::wasm_bindgen_test;
+use serde::Serialize;
 use web_time::SystemTime;
 
-wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
+#[derive(Default, Serialize)]
+struct TestField1 {
+	test: bool,
+}
+
+#[derive(Default, Serialize)]
+struct TestField2 {
+	secs_since_epoch: u64,
+}
+
+#[derive(Default, Serialize)]
+struct TestField3 {
+	nanos_since_epoch: u32,
+}
 
-/// 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);
+#[derive(Default, Serialize)]
+struct TestField4 {
+	secs_since_epoch: u64,
+	#[serde(rename = "secs_since_epoch")]
+	secs_since_epoch_2: u64,
 }
 
-/// 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);
+#[derive(Default, Serialize)]
+struct TestField5 {
+	nanos_since_epoch: u32,
+	#[serde(rename = "nanos_since_epoch")]
+	nanos_since_epoch_2: u32,
 }
 
-#[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()
-	);
+test! {
+	/// De/Serialization of [`SystemTime`] with [`serde_json`].
+	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`] with [`bincode`].
+	async fn system_bincode_bincode() {
+		let time = SystemTime::now();
+		let serialized = bincode::serialize(&time).unwrap();
+		let deserialized: SystemTime = bincode::deserialize(&serialized).unwrap();
+		assert_eq!(time, deserialized);
+	}
+
+	/// De/Serialization of [`SystemTime`] with
+	/// [`UNIX_EPOCH`](SystemTime::UNIX_EPOCH) with [`serde_json`].
+	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) with [`bincode`].
+	async fn unix_epoch_bincode() {
+		let time = SystemTime::UNIX_EPOCH;
+		let serialized = bincode::serialize(&time).unwrap();
+		let deserialized: SystemTime = bincode::deserialize(&serialized).unwrap();
+		assert_eq!(time, deserialized);
+	}
+
+	/// De/Serialization compatibility with [`std::time::SystemTime`] with [`serde_json`].
+	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()
+		);
+
+		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()
+		);
+	}
+
+	/// De/Serialization compatibility with [`std::time::SystemTime`] with [`bincode`].
+	async fn std_compatibility_bincode() {
+		let time = SystemTime::now();
+		let serialized = bincode::serialize(&time).unwrap();
+		let deserialized: StdSystemTime = bincode::deserialize(&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 = bincode::serialize(&time).unwrap();
+		let deserialized: SystemTime = bincode::deserialize(&serialized).unwrap();
+		assert_eq!(
+			time.duration_since(StdSystemTime::UNIX_EPOCH).unwrap(),
+			deserialized.duration_since(SystemTime::UNIX_EPOCH).unwrap()
+		);
+	}
+
+	/// Deserialization with wrong fields.
+	async fn failure_field() {
+		let serialized = serde_json::to_string(&TestField1::default()).unwrap();
+		let error = serde_json::from_str::<SystemTime>(&serialized).unwrap_err();
+
+		assert_eq!(
+			error.to_string(),
+			"unknown field `test`, expected `secs_since_epoch` or `nanos_since_epoch` at line 1 \
+			 column 7",
+		);
+
+		let serialized = serde_json::to_string(&TestField2::default()).unwrap();
+		let error = serde_json::from_str::<SystemTime>(&serialized).unwrap_err();
+
+		assert_eq!(
+			error.to_string(),
+			"missing field `nanos_since_epoch` at line 1 column 22",
+		);
+
+		let serialized = serde_json::to_string(&TestField3::default()).unwrap();
+		let error = serde_json::from_str::<SystemTime>(&serialized).unwrap_err();
+
+		assert_eq!(
+			error.to_string(),
+			"missing field `secs_since_epoch` at line 1 column 23",
+		);
+
+		let serialized = serde_json::to_string(&TestField4::default()).unwrap();
+		let error = serde_json::from_str::<SystemTime>(&serialized).unwrap_err();
+
+		assert_eq!(
+			error.to_string(),
+			"duplicate field `secs_since_epoch` at line 1 column 40",
+		);
+
+		let serialized = serde_json::to_string(&TestField5::default()).unwrap();
+		let error = serde_json::from_str::<SystemTime>(&serialized).unwrap_err();
+
+		assert_eq!(
+			error.to_string(),
+			"duplicate field `nanos_since_epoch` at line 1 column 42",
+		);
+	}
 }

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);

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(())

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 {