diff --git a/unit/test-cmac-aes.c b/unit/test-cmac-aes.c
index 8ac79900..f8bdd31e 100644
--- a/unit/test-cmac-aes.c
+++ b/unit/test-cmac-aes.c
@@ -138,20 +138,22 @@ static const struct cmac_data example_4 = {
 	.tag_len	= sizeof(tag_4),
 };
 
+static bool test_precheck(const void *data)
+{
+	return l_checksum_cmac_aes_supported();
+}
+
+#define add_test(name, func, data) l_test_add_data_func_precheck(name, data, \
+							func, test_precheck, 0)
+
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
 
-	if (!l_checksum_cmac_aes_supported()) {
-		printf("AES-CMAC support missing, skipping...\n");
-		goto done;
-	}
+	add_test("/cmac-aes/Example 1", cmac_test, &example_1);
+	add_test("/cmac-aes/Example 2", cmac_test, &example_2);
+	add_test("/cmac-aes/Example 3", cmac_test, &example_3);
+	add_test("/cmac-aes/Example 4", cmac_test, &example_4);
 
-	l_test_add("/cmac-aes/Example 1", cmac_test, &example_1);
-	l_test_add("/cmac-aes/Example 2", cmac_test, &example_2);
-	l_test_add("/cmac-aes/Example 3", cmac_test, &example_3);
-	l_test_add("/cmac-aes/Example 4", cmac_test, &example_4);
-
-done:
 	return l_test_run();
 }
diff --git a/unit/test-crypto.c b/unit/test-crypto.c
index fec1c9c5..8267fd5a 100644
--- a/unit/test-crypto.c
+++ b/unit/test-crypto.c
@@ -403,40 +403,32 @@ static void aes_siv_test(const void *data)
 	assert(memcmp(decrypted, plaintext, sizeof(decrypted)) == 0);
 }
 
+static bool test_precheck(const void *data)
+{
+	return (l_cipher_is_supported(L_CIPHER_AES) &&
+		l_checksum_is_supported(L_CHECKSUM_SHA1, true));
+}
+
+#define add_test(name, func, data) l_test_add_data_func_precheck(name, data, \
+							func, test_precheck, 0)
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
 
-	if (!l_checksum_is_supported(L_CHECKSUM_SHA1, true)) {
-		printf("SHA1 support missing, skipping...\n");
-		goto done;
-	}
+	add_test("/Passphrase Generator/PSK Test Case 1",
+						psk_test, &psk_test_case_1);
+	add_test("/Passphrase Generator/PSK Test Case 2",
+						psk_test, &psk_test_case_2);
+	add_test("/Passphrase Generator/PSK Test Case 3",
+						psk_test, &psk_test_case_3);
 
-	if (!l_cipher_is_supported(L_CIPHER_AES)) {
-		printf("AES support missing, skipping...\n");
-		goto done;
-	}
+	add_test("/PTK Derivation/PTK Test Case 1", ptk_test, &ptk_test_1);
+	add_test("/PTK Derivation/PTK Test Case 2", ptk_test, &ptk_test_2);
+	add_test("/PTK Derivation/PTK Test Case 3", ptk_test, &ptk_test_3);
+	add_test("/PTK Derivation/PTK Test Case 4", ptk_test, &ptk_test_4);
 
-	l_test_add("/Passphrase Generator/PSK Test Case 1",
-			psk_test, &psk_test_case_1);
-	l_test_add("/Passphrase Generator/PSK Test Case 2",
-			psk_test, &psk_test_case_2);
-	l_test_add("/Passphrase Generator/PSK Test Case 3",
-			psk_test, &psk_test_case_3);
+	add_test("/AES Key-wrap/Wrap & unwrap", aes_wrap_test, NULL);
+	add_test("/AES-SIV", aes_siv_test, NULL);
 
-	l_test_add("/PTK Derivation/PTK Test Case 1",
-			ptk_test, &ptk_test_1);
-	l_test_add("/PTK Derivation/PTK Test Case 2",
-			ptk_test, &ptk_test_2);
-	l_test_add("/PTK Derivation/PTK Test Case 3",
-			ptk_test, &ptk_test_3);
-	l_test_add("/PTK Derivation/PTK Test Case 4",
-			ptk_test, &ptk_test_4);
-
-	l_test_add("/AES Key-wrap/Wrap & unwrap",
-			aes_wrap_test, NULL);
-	l_test_add("/AES-SIV", aes_siv_test, NULL);
-
-done:
 	return l_test_run();
 }
diff --git a/unit/test-dpp.c b/unit/test-dpp.c
index af2f5813..51329a64 100644
--- a/unit/test-dpp.c
+++ b/unit/test-dpp.c
@@ -577,22 +577,25 @@ static void test_pkex_key_derivation(const void *user_data)
 	CHECK_FROM_STR(vector->v, tmp, 32);
 }
 
+static bool test_precheck(const void *data)
+{
+	return (l_getrandom_is_supported() &&
+		l_checksum_is_supported(L_CHECKSUM_SHA256, true));
+}
+
+#define add_test(name, func, data) l_test_add_data_func_precheck(name, data, \
+							func, test_precheck, 0)
+
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
 
-	if (l_checksum_is_supported(L_CHECKSUM_SHA256, true) &&
-						l_getrandom_is_supported()) {
-		l_test_add("DPP test responder-only key derivation",
-						test_key_derivation,
-						&responder_only_p256);
-		l_test_add("DPP test mutual key derivation",
-						test_key_derivation,
-						&mutual_p256);
-		l_test_add("DPP test PKEX key derivation",
-						test_pkex_key_derivation,
-						&pkex_vector);
-	}
+	add_test("DPP test responder-only key derivation", test_key_derivation,
+							&responder_only_p256);
+	add_test("DPP test mutual key derivation", test_key_derivation,
+							&mutual_p256);
+	add_test("DPP test PKEX key derivation", test_pkex_key_derivation,
+							&pkex_vector);
 
 	l_test_add("DPP URI parse", test_uri_parse, &all_values);
 	l_test_add("DPP URI no type", test_uri_parse, &no_type);
diff --git a/unit/test-eap-mschapv2.c b/unit/test-eap-mschapv2.c
index dbf77bd5..66f0fa1d 100644
--- a/unit/test-eap-mschapv2.c
+++ b/unit/test-eap-mschapv2.c
@@ -131,27 +131,23 @@ static void test_get_asym_key(const void *data)
 	assert(!memcmp(msk, m_session_key, sizeof(m_session_key)));
 }
 
+static bool test_precheck(const void *data)
+{
+	return l_checksum_is_supported(L_CHECKSUM_MD4, false);
+}
+
+#define add_test(name, func) l_test_add_func_precheck(name, func, \
+							test_precheck, 0)
 
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
 
-	if (!l_checksum_is_supported(L_CHECKSUM_MD4, false)) {
-		printf("MD4 support missing, skipping...\n");
-		goto done;
-	}
+	add_test("MSHAPv2 nt_password-hash", test_nt_password_hash);
+	add_test("MSHAPv2 generate_nt_response", test_generate_nt_response);
+	add_test("MSHAPv2 get_master_key", test_get_master_key);
+	add_test("MSHAPv2 get_asym_state_key", test_get_asym_key);
+	add_test("MSHAPv2 authenticator_response", test_authenticator_response);
 
-	l_test_add("MSHAPv2 nt_password-hash",
-			test_nt_password_hash, NULL);
-	l_test_add("MSHAPv2 generate_nt_response",
-			test_generate_nt_response, NULL);
-	l_test_add("MSHAPv2 get_master_key",
-			test_get_master_key, NULL);
-	l_test_add("MSHAPv2 get_asym_state_key",
-			test_get_asym_key, NULL);
-	l_test_add("MSHAPv2 authenticator_response",
-			test_authenticator_response, NULL);
-
-done:
 	return l_test_run();
 }
diff --git a/unit/test-eapol.c b/unit/test-eapol.c
index 0e01bfa5..58f3e054 100644
--- a/unit/test-eapol.c
+++ b/unit/test-eapol.c
@@ -3908,6 +3908,38 @@ static void eapol_ap_sta_handshake_ip_alloc_no_req_test(const void *data)
 #define _IS_ENABLED2(one_or_two_args) _IS_ENABLED3(one_or_two_args true, false)
 #define _IS_ENABLED3(ignore_this, val, ...) val
 
+static bool hash_precheck(const void *data)
+{
+	return (l_checksum_is_supported(L_CHECKSUM_MD5, true) &&
+		l_checksum_is_supported(L_CHECKSUM_SHA1, true));
+}
+
+static bool aes_precheck(const void *data)
+{
+	return (l_cipher_is_supported(L_CIPHER_AES) &&
+		l_checksum_is_supported(L_CHECKSUM_MD5, true) &&
+		l_checksum_is_supported(L_CHECKSUM_SHA1, true));
+}
+
+static bool pkcs8_precheck(const void *data)
+{
+	return (IS_ENABLED(HAVE_PKCS8_SUPPORT) &&
+		l_cipher_is_supported(L_CIPHER_AES) &&
+		l_cipher_is_supported(L_CIPHER_AES_CBC) &&
+		l_cipher_is_supported(L_CIPHER_DES3_EDE_CBC) &&
+		l_checksum_is_supported(L_CHECKSUM_MD5, true) &&
+		l_checksum_is_supported(L_CHECKSUM_SHA1, true) &&
+		l_key_is_supported(L_KEY_FEATURE_CRYPTO) &&
+		l_key_is_supported(L_KEY_FEATURE_RESTRICT));
+}
+
+#define add_hash_test(name, func, data) l_test_add_data_func_precheck(name, \
+						data, func, hash_precheck, 0)
+#define add_aes_test(name, func, data) l_test_add_data_func_precheck(name, \
+						data, func, aes_precheck, 0)
+#define add_pkcs8_test(name, func, data) l_test_add_data_func_precheck(name, \
+						data, func, pkcs8_precheck, 0)
+
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
@@ -3977,80 +4009,55 @@ int main(int argc, char *argv[])
 	l_test_add("/EAPoL Key/Key Frame 32",
 			eapol_key_test, &eapol_key_test_32);
 
-	if (!l_checksum_is_supported(L_CHECKSUM_MD5, true) ||
-			!l_checksum_is_supported(L_CHECKSUM_SHA1, true))
-		goto done;
-
-	l_test_add("/EAPoL Key/MIC Test 1",
+	add_hash_test("/EAPoL Key/MIC Test 1",
 			eapol_key_mic_test, &eapol_key_mic_test_1);
-	l_test_add("/EAPoL Key/MIC Test 2",
+	add_hash_test("/EAPoL Key/MIC Test 2",
 			eapol_key_mic_test, &eapol_key_mic_test_2);
-
-	l_test_add("/EAPoL Key/Calculate MIC Test 1",
+	add_hash_test("/EAPoL Key/Calculate MIC Test 1",
 			eapol_calculate_mic_test, &eapol_calculate_mic_test_1);
 
-	if (!l_cipher_is_supported(L_CIPHER_AES))
-		goto done;
+	add_aes_test("EAPoL/WPA2 4-Way Handshake",
+				eapol_4way_test, NULL);
+	add_aes_test("EAPoL/WPA2 4-Way & GTK Handshake",
+				eapol_wpa2_handshake_test, NULL);
+	add_aes_test("EAPoL/WPA 4-Way & GTK Handshake",
+				eapol_wpa_handshake_test, NULL);
+	add_aes_test("EAPoL/WPA2 PTK State Machine",
+				eapol_sm_test_ptk, NULL);
+	add_aes_test("EAPoL IGTK & 4-Way Handshake",
+				eapol_sm_test_igtk, NULL);
+	add_aes_test("EAPoL/WPA2 PTK & GTK State Machine",
+				eapol_sm_test_wpa2_ptk_gtk, NULL);
+	add_aes_test("EAPoL/WPA PTK & GTK State Machine Test 1",
+				eapol_sm_test_wpa_ptk_gtk, NULL);
+	add_aes_test("EAPoL/WPA PTK & GTK State Machine Test 2",
+				eapol_sm_test_wpa_ptk_gtk_2, NULL);
+	add_aes_test("EAPoL/WPA2 Retransmit Test",
+				eapol_sm_wpa2_retransmit_test, NULL);
 
-	l_test_add("EAPoL/WPA2 4-Way Handshake",
-			&eapol_4way_test, NULL);
+	add_pkcs8_test("EAPoL/8021x EAP-TLS & 4-Way Handshake",
+				eapol_sm_test_eap_tls, NULL);
+	add_pkcs8_test("EAPoL/8021x EAP-TTLS+EAP-MD5 & 4-Way Handshake",
+				eapol_sm_test_eap_ttls_md5, NULL);
+	add_pkcs8_test("EAPoL/8021x EAP NAK",
+				eapol_sm_test_eap_nak, NULL);
+	add_pkcs8_test("EAPoL/8021x EAP-TLS subject name match",
+				eapol_sm_test_eap_tls_subject_good, NULL);
+	add_pkcs8_test("EAPoL/8021x EAP-TLS subject name mismatch",
+				eapol_sm_test_eap_tls_subject_bad, NULL);
+	add_pkcs8_test("EAPoL/8021x EAP-TLS embedded certs",
+				eapol_sm_test_eap_tls_embedded, NULL);
 
-	l_test_add("EAPoL/WPA2 4-Way & GTK Handshake",
-			&eapol_wpa2_handshake_test, NULL);
+	add_aes_test("EAPoL/FT-Using-PSK 4-Way Handshake",
+			eapol_ft_handshake_test, NULL);
+	add_aes_test("EAPoL/Supplicant+Authenticator 4-Way Handshake",
+			eapol_ap_sta_handshake_test, NULL);
+	add_aes_test("EAPoL/Supplicant+Authenticator 4-Way Handshake Bad PSK",
+			eapol_ap_sta_handshake_bad_psk_test, NULL);
+	add_aes_test("EAPoL/Supplicant+Authenticator IP Allocation OK",
+			eapol_ap_sta_handshake_ip_alloc_ok_test, NULL);
+	add_aes_test("EAPoL/Supplicant+Authenticator IP Allocation no request",
+			eapol_ap_sta_handshake_ip_alloc_no_req_test, NULL);
 
-	l_test_add("EAPoL/WPA 4-Way & GTK Handshake",
-			&eapol_wpa_handshake_test, NULL);
-
-	l_test_add("EAPoL/WPA2 PTK State Machine", &eapol_sm_test_ptk, NULL);
-
-	l_test_add("EAPoL IGTK & 4-Way Handshake",
-			&eapol_sm_test_igtk, NULL);
-
-	l_test_add("EAPoL/WPA2 PTK & GTK State Machine",
-			&eapol_sm_test_wpa2_ptk_gtk, NULL);
-
-	l_test_add("EAPoL/WPA PTK & GTK State Machine Test 1",
-			&eapol_sm_test_wpa_ptk_gtk, NULL);
-
-	l_test_add("EAPoL/WPA PTK & GTK State Machine Test 2",
-			&eapol_sm_test_wpa_ptk_gtk_2, NULL);
-
-	l_test_add("EAPoL/WPA2 Retransmit Test",
-			&eapol_sm_wpa2_retransmit_test, NULL);
-
-	if (IS_ENABLED(HAVE_PKCS8_SUPPORT) &&
-			l_cipher_is_supported(L_CIPHER_DES3_EDE_CBC) &&
-			l_cipher_is_supported(L_CIPHER_AES_CBC) &&
-			l_key_is_supported(L_KEY_FEATURE_RESTRICT |
-						L_KEY_FEATURE_CRYPTO)) {
-		l_test_add("EAPoL/8021x EAP-TLS & 4-Way Handshake",
-					&eapol_sm_test_eap_tls, NULL);
-
-		l_test_add("EAPoL/8021x EAP-TTLS+EAP-MD5 & 4-Way Handshake",
-					&eapol_sm_test_eap_ttls_md5, NULL);
-		l_test_add("EAPoL/8021x EAP NAK",
-				&eapol_sm_test_eap_nak, NULL);
-
-		l_test_add("EAPoL/8021x EAP-TLS subject name match",
-				&eapol_sm_test_eap_tls_subject_good, NULL);
-		l_test_add("EAPoL/8021x EAP-TLS subject name mismatch",
-				&eapol_sm_test_eap_tls_subject_bad, NULL);
-		l_test_add("EAPoL/8021x EAP-TLS embedded certs",
-				&eapol_sm_test_eap_tls_embedded, NULL);
-	}
-
-	l_test_add("EAPoL/FT-Using-PSK 4-Way Handshake",
-			&eapol_ft_handshake_test, NULL);
-
-	l_test_add("EAPoL/Supplicant+Authenticator 4-Way Handshake",
-			&eapol_ap_sta_handshake_test, NULL);
-	l_test_add("EAPoL/Supplicant+Authenticator 4-Way Handshake Bad PSK",
-			&eapol_ap_sta_handshake_bad_psk_test, NULL);
-	l_test_add("EAPoL/Supplicant+Authenticator IP Allocation OK",
-			&eapol_ap_sta_handshake_ip_alloc_ok_test, NULL);
-	l_test_add("EAPoL/Supplicant+Authenticator IP Allocation no request",
-			&eapol_ap_sta_handshake_ip_alloc_no_req_test, NULL);
-
-done:
 	return l_test_run();
 }
diff --git a/unit/test-hmac-md5.c b/unit/test-hmac-md5.c
index 8058327d..907754e4 100644
--- a/unit/test-hmac-md5.c
+++ b/unit/test-hmac-md5.c
@@ -81,18 +81,20 @@ static const struct hmac_data test_case_2 = {
 	.hmac		= "80070713463e7749b90c2dc24911e275",
 };
 
+static bool test_precheck(const void *data)
+{
+	return l_checksum_is_supported(L_CHECKSUM_MD5, true);
+}
+
+#define add_test(name, func, data) l_test_add_data_func_precheck(name, data, \
+							func, test_precheck, 0)
+
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
 
-	if (!l_checksum_is_supported(L_CHECKSUM_MD5, true)) {
-		printf("MD5 support missing, skipping...\n");
-		goto done;
-	}
+	add_test("/hmac-md5/Test case 1", hmac_test, &test_case_1);
+	add_test("/hmac-md5/Test case 2", hmac_test, &test_case_2);
 
-	l_test_add("/hmac-md5/Test case 1", hmac_test, &test_case_1);
-	l_test_add("/hmac-md5/Test case 2", hmac_test, &test_case_2);
-
-done:
 	return l_test_run();
 }
diff --git a/unit/test-hmac-sha1.c b/unit/test-hmac-sha1.c
index d71f50e9..77d2af48 100644
--- a/unit/test-hmac-sha1.c
+++ b/unit/test-hmac-sha1.c
@@ -81,18 +81,20 @@ static const struct hmac_data test_case_2 = {
 	.hmac		= "de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9",
 };
 
+static bool test_precheck(const void *data)
+{
+	return l_checksum_is_supported(L_CHECKSUM_SHA1, true);
+}
+
+#define add_test(name, func, data) l_test_add_data_func_precheck(name, data, \
+							func, test_precheck, 0)
+
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
 
-	if (!l_checksum_is_supported(L_CHECKSUM_SHA1, true)) {
-		printf("SHA1 support missing, skipping...\n");
-		goto done;
-	}
+	add_test("/hmac-sha1/Test case 1", hmac_test, &test_case_1);
+	add_test("/hmac-sha1/Test case 2", hmac_test, &test_case_2);
 
-	l_test_add("/hmac-sha1/Test case 1", hmac_test, &test_case_1);
-	l_test_add("/hmac-sha1/Test case 2", hmac_test, &test_case_2);
-
-done:
 	return l_test_run();
 }
diff --git a/unit/test-hmac-sha256.c b/unit/test-hmac-sha256.c
index eb244996..8edcc8bd 100644
--- a/unit/test-hmac-sha256.c
+++ b/unit/test-hmac-sha256.c
@@ -83,18 +83,20 @@ static const struct hmac_data test_case_2 = {
 			  "ef4d59a14946175997479dbc2d1a3cd8",
 };
 
+static bool test_precheck(const void *data)
+{
+	return l_checksum_is_supported(L_CHECKSUM_SHA256, true);
+}
+
+#define add_test(name, func, data) l_test_add_data_func_precheck(name, data, \
+							func, test_precheck, 0)
+
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
 
-	if (!l_checksum_is_supported(L_CHECKSUM_SHA256, true)) {
-		printf("SHA256 support missing, skipping...\n");
-		goto done;
-	}
+	add_test("/hmac-sha256/Test case 1", hmac_test, &test_case_1);
+	add_test("/hmac-sha256/Test case 2", hmac_test, &test_case_2);
 
-	l_test_add("/hmac-sha256/Test case 1", hmac_test, &test_case_1);
-	l_test_add("/hmac-sha256/Test case 2", hmac_test, &test_case_2);
-
-done:
 	return l_test_run();
 }
diff --git a/unit/test-kdf-sha256.c b/unit/test-kdf-sha256.c
index 6b3ef826..1150a33c 100644
--- a/unit/test-kdf-sha256.c
+++ b/unit/test-kdf-sha256.c
@@ -81,17 +81,19 @@ static const struct kdf_data test_case_1 = {
 			  "84f7d2291143d4d4",
 };
 
+static bool test_precheck(const void *data)
+{
+	return l_checksum_is_supported(L_CHECKSUM_SHA256, true);
+}
+
+#define add_test(name, func, data) l_test_add_data_func_precheck(name, data, \
+							func, test_precheck, 0)
+
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
 
-	if (!l_checksum_is_supported(L_CHECKSUM_SHA256, true)) {
-		printf("SHA256 support missing, skipping...\n");
-		goto done;
-	}
+	add_test("/kdf-sha256/Test case 1", kdf_test, &test_case_1);
 
-	l_test_add("/kdf-sha256/Test case 1", kdf_test, &test_case_1);
-
-done:
 	return l_test_run();
 }
diff --git a/unit/test-prf-sha1.c b/unit/test-prf-sha1.c
index 2a35708f..681d7e11 100644
--- a/unit/test-prf-sha1.c
+++ b/unit/test-prf-sha1.c
@@ -113,19 +113,21 @@ static const struct prf_data test_case_3 = {
 			  "f7b4abd43d87f0a68f1cbd9e2b6f7607",
 };
 
+static bool test_precheck(const void *data)
+{
+	return l_checksum_is_supported(L_CHECKSUM_SHA1, true);
+}
+
+#define add_test(name, func, data) l_test_add_data_func_precheck(name, data, \
+							func, test_precheck, 0)
+
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
 
-	if (!l_checksum_is_supported(L_CHECKSUM_SHA1, true)) {
-		printf("SHA1 support missing, skipping...\n");
-		goto done;
-	}
+	add_test("/prf-sha1/Test case 1", prf_test, &test_case_1);
+	add_test("/prf-sha1/Test case 2", prf_test, &test_case_2);
+	add_test("/prf-sha1/Test case 3", prf_test, &test_case_3);
 
-	l_test_add("/prf-sha1/Test case 1", prf_test, &test_case_1);
-	l_test_add("/prf-sha1/Test case 2", prf_test, &test_case_2);
-	l_test_add("/prf-sha1/Test case 3", prf_test, &test_case_3);
-
-done:
 	return l_test_run();
 }
diff --git a/unit/test-sae.c b/unit/test-sae.c
index 2e564133..b4319f5e 100644
--- a/unit/test-sae.c
+++ b/unit/test-sae.c
@@ -871,32 +871,29 @@ static void test_pt_pwe(const void *data)
 	l_ecc_point_free(pt);
 }
 
+static bool test_precheck(const void *data)
+{
+	return (l_getrandom_is_supported() &&
+		l_checksum_is_supported(L_CHECKSUM_SHA256, true));
+}
+
+#define add_test(name, func) l_test_add_func_precheck(name, func, \
+							test_precheck, 0)
+
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
 
-	if (!l_getrandom_is_supported()) {
-		l_info("l_getrandom not supported, skipping...");
-		goto done;
-	}
+	add_test("SAE anti-clogging", test_clogging);
+	add_test("SAE early confirm", test_early_confirm);
+	add_test("SAE reflection", test_reflection);
+	add_test("SAE malformed commit", test_malformed_commit);
+	add_test("SAE malformed confirm", test_malformed_confirm);
+	add_test("SAE bad group", test_bad_group);
+	add_test("SAE bad confirm", test_bad_confirm);
+	add_test("SAE confirm after accept", test_confirm_after_accept);
+	add_test("SAE end-to-end", test_end_to_end);
+	add_test("SAE pt-pwe", test_pt_pwe);
 
-	if (!l_checksum_is_supported(L_CHECKSUM_SHA256, true)) {
-		l_info("SHA256/HMAC_SHA256 not supported, skipping...");
-		goto done;
-	}
-
-	l_test_add("SAE anti-clogging", test_clogging, NULL);
-	l_test_add("SAE early confirm", test_early_confirm, NULL);
-	l_test_add("SAE reflection", test_reflection, NULL);
-	l_test_add("SAE malformed commit", test_malformed_commit, NULL);
-	l_test_add("SAE malformed confirm", test_malformed_confirm, NULL);
-	l_test_add("SAE bad group", test_bad_group, NULL);
-	l_test_add("SAE bad confirm", test_bad_confirm, NULL);
-	l_test_add("SAE confirm after accept", test_confirm_after_accept, NULL);
-	l_test_add("SAE end-to-end", test_end_to_end, NULL);
-
-	l_test_add("SAE pt-pwe", test_pt_pwe, NULL);
-
-done:
 	return l_test_run();
 }
diff --git a/unit/test-wsc.c b/unit/test-wsc.c
index 8022ebf6..d59a2f38 100644
--- a/unit/test-wsc.c
+++ b/unit/test-wsc.c
@@ -2574,6 +2574,39 @@ struct wsc_credential wsc_r_test_open_cred = {
 	.encryption_type = WSC_ENCRYPTION_TYPE_NONE,
 };
 
+static bool getrandom_precheck(const void *data)
+{
+	return l_getrandom_is_supported();
+}
+
+static bool aes_cbc_precheck(const void *data)
+{
+	return l_cipher_is_supported(L_CIPHER_AES_CBC);
+}
+
+static bool key_crypto_precheck(const void *data)
+{
+	return (l_key_is_supported(L_KEY_FEATURE_CRYPTO) &&
+		l_checksum_is_supported(L_CHECKSUM_SHA256, true));
+}
+
+static bool key_dh_precheck(const void *data)
+{
+	return (l_key_is_supported(L_KEY_FEATURE_DH) &&
+		l_key_is_supported(L_KEY_FEATURE_CRYPTO) &&
+		l_checksum_is_supported(L_CHECKSUM_SHA256, true));
+}
+
+#define add_aes_cbc_test(name, func, data) l_test_add_data_func_precheck(name, \
+							data, func, \
+							aes_cbc_precheck, 0)
+#define add_crypto_test(name, func, data) l_test_add_data_func_precheck(name, \
+							data, func, \
+							key_crypto_precheck, 0)
+#define add_dh_test(name, func, data) l_test_add_data_func_precheck(name, \
+							data, func, \
+							key_dh_precheck, 0)
+
 int main(int argc, char *argv[])
 {
 	l_test_init(&argc, &argv);
@@ -2595,8 +2628,8 @@ int main(int argc, char *argv[])
 	l_test_add("/wsc/pin/valid pin", wsc_test_pin_valid, NULL);
 	l_test_add("/wsc/pin/valid checksum", wsc_test_pin_checksum, NULL);
 
-	if (l_getrandom_is_supported())
-		l_test_add("/wsc/pin/generate", wsc_test_pin_generate, NULL);
+	l_test_add_func_precheck("/wsc/pin/generate", wsc_test_pin_generate,
+							getrandom_precheck, 0);
 
 	l_test_add("/wsc/gen_uuid/1", wsc_test_uuid_from_addr,
 					&uuid_from_addr_data_1);
@@ -2607,96 +2640,77 @@ int main(int argc, char *argv[])
 	l_test_add("/wsc/build/m1 1", wsc_test_build_m1, &m1_data_1);
 	l_test_add("/wsc/build/m1 2", wsc_test_build_m1, &m1_data_2);
 
-	if (!l_checksum_is_supported(L_CHECKSUM_SHA256, true)) {
-		printf("SHA256 support missing, skipping other tests...\n");
-		goto done;
-	}
+	add_dh_test("/wsc/parse/m2 1", wsc_test_parse_m2, &m2_data_1);
+	add_dh_test("/wsc/parse/m2 2", wsc_test_parse_m2, &m2_data_2);
 
-	if (!l_key_is_supported(L_KEY_FEATURE_CRYPTO)) {
-		printf("Key crypto not supported, skipping other tests...\n");
-		goto done;
-	}
+	add_crypto_test("/wsc/build/m2 1", wsc_test_build_m2, &m2_data_1);
 
-	if (l_key_is_supported(L_KEY_FEATURE_DH)) {
-		l_test_add("/wsc/parse/m2 1", wsc_test_parse_m2, &m2_data_1);
-		l_test_add("/wsc/parse/m2 2", wsc_test_parse_m2, &m2_data_2);
-	}
+	add_crypto_test("/wsc/parse/m3 1", wsc_test_parse_m3, &m3_data_1);
+	add_crypto_test("/wsc/build/m3 1", wsc_test_build_m3, &m3_data_1);
 
-	l_test_add("/wsc/build/m2 1", wsc_test_build_m2, &m2_data_1);
+	add_crypto_test("/wsc/parse/m4 1", wsc_test_parse_m4, &m4_data_1);
+	add_crypto_test("/wsc/build/m4 1", wsc_test_build_m4, &m4_data_1);
 
-	l_test_add("/wsc/parse/m3 1", wsc_test_parse_m3, &m3_data_1);
-	l_test_add("/wsc/build/m3 1", wsc_test_build_m3, &m3_data_1);
+	add_crypto_test("/wsc/parse/m4 encrypted settings 1",
+					wsc_test_parse_m4_encrypted_settings,
+					&m4_encrypted_settings_data_1);
+	add_crypto_test("/wsc/build/m4 encrypted settings 1",
+					wsc_test_build_m4_encrypted_settings,
+					&m4_encrypted_settings_data_1);
 
-	l_test_add("/wsc/parse/m4 1", wsc_test_parse_m4, &m4_data_1);
-	l_test_add("/wsc/build/m4 1", wsc_test_build_m4, &m4_data_1);
+	add_crypto_test("/wsc/parse/m5 1", wsc_test_parse_m5, &m5_data_1);
+	add_crypto_test("/wsc/build/m5 1", wsc_test_build_m5, &m5_data_1);
 
-	l_test_add("/wsc/parse/m4 encrypted settings 1",
-			wsc_test_parse_m4_encrypted_settings,
-			&m4_encrypted_settings_data_1);
-	l_test_add("/wsc/build/m4 encrypted settings 1",
-			wsc_test_build_m4_encrypted_settings,
-			&m4_encrypted_settings_data_1);
+	add_crypto_test("/wsc/parse/m6 1", wsc_test_parse_m6, &m6_data_1);
+	add_crypto_test("/wsc/build/m6 1", wsc_test_build_m6, &m6_data_1);
 
-	l_test_add("/wsc/parse/m5 1", wsc_test_parse_m5, &m5_data_1);
-	l_test_add("/wsc/build/m5 1", wsc_test_build_m5, &m5_data_1);
+	add_crypto_test("/wsc/parse/m6 encrypted settings 1",
+					wsc_test_parse_m6_encrypted_settings,
+					&m6_encrypted_settings_data_1);
+	add_crypto_test("/wsc/build/m6 encrypted settings 1",
+					wsc_test_build_m6_encrypted_settings,
+					&m6_encrypted_settings_data_1);
 
-	l_test_add("/wsc/parse/m6 1", wsc_test_parse_m6, &m6_data_1);
-	l_test_add("/wsc/build/m6 1", wsc_test_build_m6, &m6_data_1);
+	add_crypto_test("/wsc/parse/m7 1", wsc_test_parse_m7, &m7_data_1);
+	add_crypto_test("/wsc/build/m7 1", wsc_test_build_m7, &m7_data_1);
 
-	l_test_add("/wsc/parse/m6 encrypted settings 1",
-			wsc_test_parse_m6_encrypted_settings,
-			&m6_encrypted_settings_data_1);
-	l_test_add("/wsc/build/m6 encrypted settings 1",
-			wsc_test_build_m6_encrypted_settings,
-			&m6_encrypted_settings_data_1);
+	add_crypto_test("/wsc/parse/m8 1", wsc_test_parse_m8, &m8_data_1);
+	add_crypto_test("/wsc/build/m8 1", wsc_test_build_m8, &m8_data_1);
 
-	l_test_add("/wsc/parse/m7 1", wsc_test_parse_m7, &m7_data_1);
-	l_test_add("/wsc/build/m7 1", wsc_test_build_m7, &m7_data_1);
+	add_crypto_test("/wsc/parse/m8 encrypted settings 1",
+					wsc_test_parse_m8_encrypted_settings,
+					&m8_encrypted_settings_data_1);
+	add_crypto_test("/wsc/build/m8 encrypted settings 1",
+					wsc_test_build_m8_encrypted_settings,
+					&m8_encrypted_settings_data_1);
 
-	l_test_add("/wsc/parse/m8 1", wsc_test_parse_m8, &m8_data_1);
-	l_test_add("/wsc/build/m8 1", wsc_test_build_m8, &m8_data_1);
-
-	l_test_add("/wsc/parse/m8 encrypted settings 1",
-			wsc_test_parse_m8_encrypted_settings,
-			&m8_encrypted_settings_data_1);
-	l_test_add("/wsc/build/m8 encrypted settings 1",
-			wsc_test_build_m8_encrypted_settings,
-			&m8_encrypted_settings_data_1);
-
-	l_test_add("/wsc/parse/wsc_done 1", wsc_test_parse_wsc_done,
+	add_crypto_test("/wsc/parse/wsc_done 1", wsc_test_parse_wsc_done,
 							&wsc_done_data_1);
-	l_test_add("/wsc/build/wsc_done 1", wsc_test_build_wsc_done,
+	add_crypto_test("/wsc/build/wsc_done 1", wsc_test_build_wsc_done,
 							&wsc_done_data_1);
 
-	if (!l_key_is_supported(L_KEY_FEATURE_DH))
-		goto done;
-
-	l_test_add("/wsc/diffie-hellman/generate pubkey 1",
+	add_dh_test("/wsc/diffie-hellman/generate pubkey 1",
 					wsc_test_dh_generate_pubkey,
 					&dh_generate_pubkey_test_data_1);
-	l_test_add("/wsc/diffie-hellman/generate pubkey 2",
+	add_dh_test("/wsc/diffie-hellman/generate pubkey 2",
 					wsc_test_dh_generate_pubkey,
 					&dh_generate_pubkey_test_data_2);
 
-	if (!l_cipher_is_supported(L_CIPHER_AES_CBC))
-		goto done;
-
-	l_test_add("/wsc/handshake/PBC Handshake Test",
+	add_aes_cbc_test("/wsc/handshake/PBC Handshake Test",
 						wsc_test_pbc_handshake, NULL);
 
-	l_test_add("/wsc/retransmission/no fragmentation",
+	add_aes_cbc_test("/wsc/retransmission/no fragmentation",
 				wsc_test_retransmission_no_fragmentation, NULL);
 
-	l_test_add("/wsc-r/handshake/PBC Handshake WPA2 passphrase test",
-				wsc_r_test_pbc_handshake,
-				&wsc_r_test_wpa2_cred_passphrase);
-	l_test_add("/wsc-r/handshake/PBC Handshake WPA2 PSK test",
-				wsc_r_test_pbc_handshake,
-				&wsc_r_test_wpa2_cred_psk);
-	l_test_add("/wsc-r/handshake/PBC Handshake Open test",
-				wsc_r_test_pbc_handshake,
-				&wsc_r_test_open_cred);
+	add_aes_cbc_test("/wsc-r/handshake/PBC Handshake WPA2 passphrase test",
+					wsc_r_test_pbc_handshake,
+					&wsc_r_test_wpa2_cred_passphrase);
+	add_aes_cbc_test("/wsc-r/handshake/PBC Handshake WPA2 PSK test",
+					wsc_r_test_pbc_handshake,
+					&wsc_r_test_wpa2_cred_psk);
+	add_aes_cbc_test("/wsc-r/handshake/PBC Handshake Open test",
+					wsc_r_test_pbc_handshake,
+					&wsc_r_test_open_cred);
 
-done:
 	return l_test_run();
 }