Fix Jenkins tests classification

Change-Id: I7d1b72a9f5f8f44cd74ad1907781eb804bb0735b

diff --git a/tests/client-request-test.cpp b/tests/client-request-test.cpp
index 8a03786053163a243114dbed4aa4bd46ace56e66..7f352b54761359a6523880eb2abefad0c021029e 100644 (file)
--- a/tests/client-request-test.cpp
+++ b/tests/client-request-test.cpp
@@ -225,7 +225,7 @@ protected:
     }
 };
 
-TEST_F(ClientRequestTest, client_request_child_constructor_P)
+TEST_F(ClientRequestTest, client_request_child_constructor_Positive)
 {
     int ret = 0;
     try{
@@ -239,7 +239,7 @@ TEST_F(ClientRequestTest, client_request_child_constructor_P)
 
 
 
-TEST_F(ClientRequestTest, invalid_interface_N)
+TEST_F(ClientRequestTest, invalid_interface_Negative)
 {
     int ret = 0;
     try{
@@ -253,7 +253,7 @@ TEST_F(ClientRequestTest, invalid_interface_N)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(ClientRequestTest, send_failed_N)
+TEST_F(ClientRequestTest, send_failed_Negative)
 {
     int ret = 0;
     try{
@@ -268,7 +268,7 @@ TEST_F(ClientRequestTest, send_failed_N)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(ClientRequestTest, request_to_not_supported_server_N)
+TEST_F(ClientRequestTest, request_to_not_supported_server_Negative)
 {
     int ret = 1;
     WA::SocketManager manager;
@@ -321,7 +321,7 @@ TEST_F(ClientRequestTest, request_to_not_supported_server_N)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(ClientRequestTest, MC_with_LD_and_not_call_QR_callback_P)
+TEST_F(ClientRequestTest, MC_with_LD_and_not_call_QR_callback_Positive)
 {
     int ret = 1;
     WA::SocketManager manager;
@@ -375,7 +375,7 @@ TEST_F(ClientRequestTest, MC_with_LD_and_not_call_QR_callback_P)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(ClientRequestTest, MC_without_LD_and_call_QR_callback_P)
+TEST_F(ClientRequestTest, MC_without_LD_and_call_QR_callback_Positive)
 {
     int ret = 1;
     WA::SocketManager manager;
@@ -432,7 +432,7 @@ TEST_F(ClientRequestTest, MC_without_LD_and_call_QR_callback_P)
 }
 
 
-TEST_F(ClientRequestTest, GA_with_LD_and_not_call_QR_callback_P)
+TEST_F(ClientRequestTest, GA_with_LD_and_not_call_QR_callback_Positive)
 {
     int ret = 1;
     WA::SocketManager manager;
@@ -488,7 +488,7 @@ TEST_F(ClientRequestTest, GA_with_LD_and_not_call_QR_callback_P)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(ClientRequestTest, GA_without_LD_and_call_QR_callback_P)
+TEST_F(ClientRequestTest, GA_without_LD_and_call_QR_callback_Positive)
 {
     int ret = 1;
     WA::SocketManager manager;
@@ -544,7 +544,7 @@ TEST_F(ClientRequestTest, GA_without_LD_and_call_QR_callback_P)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(ClientRequestTest, not_allowed_N)
+TEST_F(ClientRequestTest, not_allowed_Negative)
 {
     int ret = 1;
     WA::SocketManager manager;
@@ -640,7 +640,7 @@ TEST_F(ClientRequestTest, not_allowed_N)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(ClientRequestTest, cancel_P)
+TEST_F(ClientRequestTest, cancel_Positive)
 {
     int ret = 1;
     WA::SocketManager manager;

diff --git a/tests/dl-loader-test.cpp b/tests/dl-loader-test.cpp
index 5c7805d3d183ab3ea1fe4750b6d75324213317c8..9598418643a6ead56350756f7e99171b4d946460 100644 (file)
--- a/tests/dl-loader-test.cpp
+++ b/tests/dl-loader-test.cpp
@@ -39,7 +39,7 @@ protected:
     }
 };
 
-TEST_F(DLLoaderTest, DLLoader_P)
+TEST_F(DLLoaderTest, DLLoader_Positive)
 {
     int ret = 0;
     try{
@@ -53,7 +53,7 @@ TEST_F(DLLoaderTest, DLLoader_P)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(DLLoaderTest, DLLoader_empty_path_N)
+TEST_F(DLLoaderTest, DLLoader_empty_path_Negative)
 {
     int ret = 0;
     try{
@@ -67,7 +67,7 @@ TEST_F(DLLoaderTest, DLLoader_empty_path_N)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(DLLoaderTest, DLLoader_invalid_path_N)
+TEST_F(DLLoaderTest, DLLoader_invalid_path_Negative)
 {
     int ret = 0;
     try{
@@ -81,7 +81,7 @@ TEST_F(DLLoaderTest, DLLoader_invalid_path_N)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(DLLoaderTest, Invoke_P)
+TEST_F(DLLoaderTest, Invoke_Positive)
 {
     int ret = 0;
     try{
@@ -96,7 +96,7 @@ TEST_F(DLLoaderTest, Invoke_P)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(DLLoaderTest, Invoke_N)
+TEST_F(DLLoaderTest, Invoke_Negative)
 {
     int ret = 0;
     try{

diff --git a/tests/file-lock-test.cpp b/tests/file-lock-test.cpp
index 4fb66114d17fd457b806c8f6a377b93fb1ea8d4a..6b1830e5644a3c21c3e580a13cd5ac8b3984157b 100644 (file)
--- a/tests/file-lock-test.cpp
+++ b/tests/file-lock-test.cpp
@@ -36,7 +36,7 @@ protected:
     }
 };
 
-TEST_F(FileLockerTest, lock_and_unlock_P)
+TEST_F(FileLockerTest, lock_and_unlock_Positive)
 {
     int ret = 0;
     try{
@@ -52,7 +52,7 @@ TEST_F(FileLockerTest, lock_and_unlock_P)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(FileLockerTest, lock_after_unlock_P)
+TEST_F(FileLockerTest, lock_after_unlock_Positive)
 {
     int ret = 0;
     try{
@@ -72,7 +72,7 @@ TEST_F(FileLockerTest, lock_after_unlock_P)
     EXPECT_EQ(ret, 0);
 }
 
-TEST_F(FileLockerTest, lock_empty_path_N)
+TEST_F(FileLockerTest, lock_empty_path_Negative)
 {
     int ret = 0;
     try{
@@ -88,7 +88,7 @@ TEST_F(FileLockerTest, lock_empty_path_N)
     EXPECT_EQ(ret, 1);
 }
 
-TEST_F(FileLockerTest, lock_invalid_path_N)
+TEST_F(FileLockerTest, lock_invalid_path_Negative)
 {
     int ret = 0;
     try{
@@ -104,7 +104,7 @@ TEST_F(FileLockerTest, lock_invalid_path_N)
     EXPECT_EQ(ret, 1);
 }
 
-TEST_F(FileLockerTest, try_to_locked_path_N)
+TEST_F(FileLockerTest, try_to_locked_path_Negative)
 {
     int ret = 0;
     try{

diff --git a/tests/privilege-tests.cpp b/tests/privilege-tests.cpp
index 8000e13ac4f55acdd27027820d468831099ef128..8490a06770b34427b1de675c9b6432e3ea25a2c5 100644 (file)
--- a/tests/privilege-tests.cpp
+++ b/tests/privilege-tests.cpp
@@ -220,7 +220,7 @@ wauthn_ga_callbacks_s ga_callbacks{
 
 } // namespace
 
-TEST(PrivilegeTest, NoPrivileges)
+TEST(PrivilegeTest, NoPrivileges_Negative)
 {
     ScopedProcessLabel label(TEST_LABEL);
     unsigned supported;
@@ -243,7 +243,7 @@ TEST(PrivilegeTest, NoPrivileges)
     EXPECT_EQ(ret, WAUTHN_ERROR_PERMISSION_DENIED);
 }
 
-TEST(PrivilegeTest, AllDenied)
+TEST(PrivilegeTest, AllDenied_Negative)
 {
     const ScopedCynaraPolicy DENY_ALL({
         {PRIV_INTERNET, CYNARA_ADMIN_DENY},
@@ -271,7 +271,7 @@ TEST(PrivilegeTest, AllDenied)
     EXPECT_EQ(ret, WAUTHN_ERROR_PERMISSION_DENIED);
 }
 
-TEST(PrivilegeTest, SinglePrivilege)
+TEST(PrivilegeTest, SinglePrivilege_Negative)
 {
     const ScopedCynaraPolicy ALLOW_ONE({
         {PRIV_INTERNET, CYNARA_ADMIN_ALLOW},
@@ -299,7 +299,7 @@ TEST(PrivilegeTest, SinglePrivilege)
     EXPECT_EQ(ret, WAUTHN_ERROR_PERMISSION_DENIED);
 }
 
-TEST(PrivilegeTest, AllPrivileges)
+TEST(PrivilegeTest, AllPrivileges_Positive)
 {
     const ScopedCynaraPolicy ALLOW_ALL({
         {PRIV_INTERNET, CYNARA_ADMIN_ALLOW},

diff --git a/tests/serialization-test.cpp b/tests/serialization-test.cpp
index 27ca36b11d6238acbac420a31a3a8aa048355d21..534d8cd630b459651cb79eef1921a97ca4be33f8 100644 (file)
--- a/tests/serialization-test.cpp
+++ b/tests/serialization-test.cpp
@@ -138,7 +138,7 @@ bool __compareCstring(const char *expected, const char *actual)
         return false;
     return (strcmp(expected, actual) == 0);
 }
-TEST_F(WAuthnSerializationTest, wauthn_const_buffer_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_const_buffer_s_Positive)
 {
     unsigned char TestCommonData[26] = {0x01, 0x02, 0x03, 0x04, };
     wauthn_const_buffer_s buffer = {TestCommonData, sizeof(TestCommonData)};
@@ -156,7 +156,7 @@ TEST_F(WAuthnSerializationTest, wauthn_const_buffer_s_P)
     ConstBufferDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnBuffers);
 }
-TEST_F(WAuthnSerializationTest, wauthn_const_buffer_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_const_buffer_s_1_Negative)
 {// serialize: for too large length
     unsigned char TestCommonData[26] = {0x01, 0x02, 0x03, 0x04, };
     wauthn_const_buffer_s data = {TestCommonData, MAX_BUFFER_SIZE + 1};
@@ -169,7 +169,7 @@ TEST_F(WAuthnSerializationTest, wauthn_const_buffer_s_N1)
     } catch(SerializationException::InvalidStreamData &) {
     }
 }
-TEST_F(WAuthnSerializationTest, wauthn_const_buffer_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_const_buffer_s_2_Negative)
 {// serialize: for inconsistent pointer & length
     unsigned char TestCommonData[26] = {0x01, 0x02, 0x03, 0x04, };
     wauthn_const_buffer_s data = {nullptr, sizeof(TestCommonData)};
@@ -182,7 +182,7 @@ TEST_F(WAuthnSerializationTest, wauthn_const_buffer_s_N2)
     } catch(SerializationException::InvalidStreamData &) {
     }
 }
-TEST_F(WAuthnSerializationTest, wauthn_const_buffer_s_N3)
+TEST_F(WAuthnSerializationTest, wauthn_const_buffer_s_3_Negative)
 {// deserialize: for too large length
     ConstBufferDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
@@ -213,7 +213,7 @@ bool __compareWAuthnAuthenticatorAttestationResponseS(
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_authenticator_attestation_response_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_authenticator_attestation_response_s_Positive)
 {
     AuthenticatorAttestationResponseSerializer data1(
         &TestCommonData::authenticatorAttestationResponse);
@@ -229,7 +229,7 @@ TEST_F(WAuthnSerializationTest, wauthn_authenticator_attestation_response_s_P)
     AuthenticatorAttestationResponseDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnAuthenticatorAttestationResponseS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_bwauthn_authenticator_attestation_response_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_bwauthn_authenticator_attestation_response_s_1_Negative)
 {// deserialize: for too large length
     AuthenticatorAttestationResponseDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
@@ -258,7 +258,7 @@ bool __compareWAuthnAuthenticatorAssertionResponseS(
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_authenticator_assertion_response_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_authenticator_assertion_response_s_Positive)
 {
     AuthenticatorAssertionResponseSerializer data1(&TestCommonData::authenticatorAssertionResponse);
     AuthenticatorAssertionResponseDeserializer deserializer1;
@@ -273,7 +273,7 @@ TEST_F(WAuthnSerializationTest, wauthn_authenticator_assertion_response_s_P)
     AuthenticatorAssertionResponseDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnAuthenticatorAssertionResponseS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_authenticator_assertion_response_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_authenticator_assertion_response_s_1_Negative)
 {// deserialize: for too large length
     AuthenticatorAssertionResponseDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
@@ -295,7 +295,7 @@ bool __compareWAuthnRpEntityS(const wauthn_rp_entity_s *expected,
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_rp_entity_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_rp_entity_s_Positive)
 {
     RpEntitySerializer data1(&TestCommonData::rpEntity);
     RpEntityDeserializer deserializer1;
@@ -309,7 +309,7 @@ TEST_F(WAuthnSerializationTest, wauthn_rp_entity_s_P)
     RpEntityDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnRpEntityS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_rp_entity_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_rp_entity_s_1_Negative)
 {// deserialize: for too large length
     RpEntityDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
@@ -333,7 +333,7 @@ bool __compareWAuthnUserEntityS(const wauthn_user_entity_s *expected,
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_user_entity_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_user_entity_s_Positive)
 {
     UserEntitySerializer data1(&TestCommonData::userEntity);
     UserEntityDeserializer deserializer1;
@@ -347,7 +347,7 @@ TEST_F(WAuthnSerializationTest, wauthn_user_entity_s_P)
     UserEntityDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnUserEntityS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_user_entity_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_user_entity_s_1_Negative)
 {// deserialize: for too large length
     UserEntityDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
@@ -369,7 +369,7 @@ bool __compareWAuthnPubkeyCredParamS(const wauthn_pubkey_cred_param_s *expected,
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_param_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_param_s_Positive)
 {
     wauthn_pubkey_cred_param_s param1 = {WAUTHN_PUBKEY_CRED_TYPE_PUBLIC_KEY,
                                         WAUTHN_COSE_ALGORITHM_ECDSA_P256_WITH_SHA256};
@@ -388,7 +388,7 @@ TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_param_s_P)
     PubkeyCredParamDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnPubkeyCredParamS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_param_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_param_s_1_Negative)
 {// serialize: invalid member
     wauthn_pubkey_cred_param_s param1 = {static_cast<wauthn_pubkey_cred_type_e>(0),
                                         WAUTHN_COSE_ALGORITHM_ECDSA_P256_WITH_SHA256};
@@ -400,14 +400,14 @@ TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_param_s_N1)
     PubkeyCredParamSerializer data2(&param2);
     __testSerializeForInvalidMember(data2);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_param_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_param_s_2_Negative)
 {// deserialize: for invalid type
     wauthn_pubkey_cred_param_s param1 = {static_cast<wauthn_pubkey_cred_type_e>(0),
                                             WAUTHN_COSE_ALGORITHM_ECDSA_P256_WITH_SHA256};
     __testDeserializeForInvalidMember<wauthn_pubkey_cred_param_s,
                                       PubkeyCredParamDeserializer>(param1);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_param_s_N3)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_param_s_3_Negative)
 {// deserialize: for too large length
     PubkeyCredParamDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
@@ -431,7 +431,7 @@ bool __compareWAuthnPubkeyCredParamsS(const wauthn_pubkey_cred_params_s *expecte
     }
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_params_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_params_s_Positive)
 {
     PubkeyCredParamsSerializer data1(&TestCommonData::pubkeyCredParams1);
     PubkeyCredParamsDeserializer deserializer1;
@@ -449,18 +449,18 @@ TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_params_s_P)
     PubkeyCredParamsDeserializer deserializer4;
     __testSerialization(data4, deserializer4, __compareWAuthnPubkeyCredParamsS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_params_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_params_s_1_Negative)
 {// deserialize: for too large length
     PubkeyCredParamsDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_params_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_params_s_2_Negative)
 {// deserialize: for too large array count
     wauthn_pubkey_cred_params_s param = {MAX_ARRAY_COUNT + 1, TestCommonData::pubkeyCredParam2};
     __testDeserializeForInvalidMember<wauthn_pubkey_cred_params_s,
                                       PubkeyCredParamsDeserializer>(param);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_params_s_N3)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_params_s_3_Negative)
 {// deserialize: for invalid array count
     wauthn_pubkey_cred_params_s param = {3, nullptr};
     __testDeserializeForInvalidMember<wauthn_pubkey_cred_params_s,
@@ -485,7 +485,7 @@ bool __compareWAuthnPubkeyCredDescriptorS(const wauthn_pubkey_cred_descriptor_s
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptor_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptor_s_Positive)
 {
     PubkeyCredDescriptorSerializer data1(&TestCommonData::pubkeyCredDescriptor);
     PubkeyCredDescriptorDeserializer deserializer1;
@@ -499,19 +499,19 @@ TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptor_s_P)
     PubkeyCredDescriptorDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnPubkeyCredDescriptorS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptor_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptor_s_1_Negative)
 {// serialize: invalid member
     wauthn_pubkey_cred_descriptor_s data = TestCommonData::pubkeyCredDescriptor;
     data.type = static_cast<wauthn_pubkey_cred_type_e>(0);
     __testDeserializeForInvalidMember<wauthn_pubkey_cred_descriptor_s,
                                       PubkeyCredDescriptorDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptor_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptor_s_2_Negative)
 {// deserialize: for too large length
     PubkeyCredDescriptorDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptor_s_N3)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptor_s_3_Negative)
 {// deserialize: for invalid type
     wauthn_pubkey_cred_descriptor_s data = {static_cast<wauthn_pubkey_cred_type_e>(0),
                                             &TestCommonData::clientDataJson, 3};
@@ -537,7 +537,7 @@ bool __compareWAuthnPubkeyCredDescriptorsS(const wauthn_pubkey_cred_descriptors_
             return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptors_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptors_s_Positive)
 {
     PubkeyCredDescriptorsSerializer data1(&TestCommonData::pubkeyCredDescriptors1);
     PubkeyCredDescriptorsDeserializer deserializer1;
@@ -555,19 +555,19 @@ TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptors_s_P)
     PubkeyCredDescriptorsDeserializer deserializer4;
     __testSerialization(data4, deserializer4, __compareWAuthnPubkeyCredDescriptorsS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptors_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptors_s_1_Negative)
 {// deserialize: for too large length
     PubkeyCredDescriptorsDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptors_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptors_s_2_Negative)
 {// deserialize: for too large array count
     wauthn_pubkey_cred_descriptors_s data = {MAX_ARRAY_COUNT + 1,
                                              TestCommonData::pubkeyCredDescriptor2};
     __testDeserializeForInvalidMember<wauthn_pubkey_cred_descriptors_s,
                                       PubkeyCredDescriptorsDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptors_s_N3)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_descriptors_s_3_Negative)
 {// deserialize: for inconsistent pointer & size
     wauthn_pubkey_cred_descriptors_s data = {3, nullptr};
     __testDeserializeForInvalidMember<wauthn_pubkey_cred_descriptors_s,
@@ -590,7 +590,7 @@ bool __compareWAuthnAuthenticationExtS(const wauthn_authentication_ext_s *expect
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_authentication_ext_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_authentication_ext_s_Positive)
 {
     AuthenticationExtSerializer data1(&TestCommonData::authenticationExt);
     AuthenticationExtDeserializer deserializer1;
@@ -604,7 +604,7 @@ TEST_F(WAuthnSerializationTest, wauthn_authentication_ext_s_P)
     AuthenticationExtDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnAuthenticationExtS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_authentication_ext_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_authentication_ext_s_1_Negative)
 {// deserialize: for too large length
     AuthenticationExtDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
@@ -628,7 +628,7 @@ bool __compareWAuthnAuthenticationExtsS(const wauthn_authentication_exts_s *expe
             return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_authentication_exts_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_authentication_exts_s_Positive)
 {
     AuthenticationExtsSerializer data1(&TestCommonData::authenticationExts1);
     AuthenticationExtsDeserializer deserializer1;
@@ -646,19 +646,19 @@ TEST_F(WAuthnSerializationTest, wauthn_authentication_exts_s_P)
     AuthenticationExtsDeserializer deserializer4;
     __testSerialization(data4, deserializer4, __compareWAuthnAuthenticationExtsS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_authentication_exts_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_authentication_exts_s_1_Negative)
 {// deserialize: for too large length
     AuthenticationExtsDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
 }
-TEST_F(WAuthnSerializationTest, wauthn_authentication_exts_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_authentication_exts_s_2_Negative)
 {// deserialize: for too large array count
     wauthn_authentication_exts_s data = {MAX_ARRAY_COUNT + 1,
                                          TestCommonData::authenticationExtArr2};
     __testDeserializeForInvalidMember<wauthn_authentication_exts_s,
                                       AuthenticationExtsDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_authentication_exts_s_N3)
+TEST_F(WAuthnSerializationTest, wauthn_authentication_exts_s_3_Negative)
 {// deserialize: for inconsistent pointer & size
     wauthn_authentication_exts_s data = {3, nullptr};
     __testDeserializeForInvalidMember<wauthn_authentication_exts_s,
@@ -685,7 +685,7 @@ bool __compareWAuthnAuthenticatorSelCriS(const wauthn_authenticator_sel_cri_s *e
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_Positive)
 {
     AuthenticatorSelCriSerializer data1(&TestCommonData::authenticatorSelCri);
     AuthenticatorSelCriDeserializer deserializer1;
@@ -695,7 +695,7 @@ TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_P)
     AuthenticatorSelCriDeserializer deserializer2;
     __testSerialization(data2, deserializer2, __compareWAuthnAuthenticatorSelCriS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_1_Negative)
 {// serialize: invalid member
     wauthn_authenticator_sel_cri_s data1 = TestCommonData::authenticatorSelCri;
     data1.attachment = static_cast<wauthn_authenticator_attachment_e>(3);
@@ -712,7 +712,7 @@ TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_N1)
     __testDeserializeForInvalidMember<wauthn_authenticator_sel_cri_s,
                                       AuthenticatorSelCriDeserializer>(data3);
 }
-TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_2_Negative)
 {// deserialize: for invalid attachment
     wauthn_authenticator_sel_cri_s data = {static_cast<wauthn_authenticator_attachment_e>(3),
                                 WAUTHN_RESIDENT_KEY_REQUIREMENT_DISCOURAGED,
@@ -721,7 +721,7 @@ TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_N2)
     __testDeserializeForInvalidMember<wauthn_authenticator_sel_cri_s,
                                       AuthenticatorSelCriDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_N3)
+TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_3_Negative)
 {// deserialize: for invalid resident_key
     wauthn_authenticator_sel_cri_s data = {WAUTHN_AUTHENTICATOR_ATTACHMENT_CROSS_PLATFORM,
                                 static_cast<wauthn_resident_key_requirement_e>(4),
@@ -730,7 +730,7 @@ TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_N3)
     __testDeserializeForInvalidMember<wauthn_authenticator_sel_cri_s,
                                       AuthenticatorSelCriDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_N4)
+TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_4_Negative)
 {// deserialize: for invalid user_verification
     wauthn_authenticator_sel_cri_s data = {WAUTHN_AUTHENTICATOR_ATTACHMENT_CROSS_PLATFORM,
                                 WAUTHN_RESIDENT_KEY_REQUIREMENT_DISCOURAGED,
@@ -739,7 +739,7 @@ TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_N4)
     __testDeserializeForInvalidMember<wauthn_authenticator_sel_cri_s,
                                       AuthenticatorSelCriDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_N5)
+TEST_F(WAuthnSerializationTest, wauthn_authenticator_sel_cri_s_5_Negative)
 {// deserialize: for too large length
     AuthenticatorSelCriDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
@@ -775,7 +775,7 @@ bool __compareWAuthnPubkeyCredHintsE(const wauthn_pubkey_cred_hints_s *expected,
             return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_hints_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_hints_s_Positive)
 {
     PubkeyCredHintsSerializer data1(&TestCommonData::pubkeyCredHints1);
     PubkeyCredHintsDeserializer deserializer1;
@@ -793,18 +793,18 @@ TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_hints_s_P)
     PubkeyCredHintsDeserializer deserializer4;
     __testSerialization(data4, deserializer4, __compareWAuthnPubkeyCredHintsE);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_hints_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_hints_s_1_Negative)
 {// deserialize: for too large length
     PubkeyCredHintsDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_hints_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_hints_s_2_Negative)
 {// deserialize: for too large array count
     wauthn_pubkey_cred_hints_s data = {MAX_ARRAY_COUNT + 1, TestCommonData::pubkeyCredHint2};
     __testDeserializeForInvalidMember<wauthn_pubkey_cred_hints_s,
                                       PubkeyCredHintsDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_hints_s_N3)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_hints_s_3_Negative)
 {// deserialize: for inconsistent pointer & size
     wauthn_pubkey_cred_hints_s data = {3, nullptr};
     __testDeserializeForInvalidMember<wauthn_pubkey_cred_hints_s,
@@ -840,7 +840,7 @@ bool __compareWAuthnHybridLinkedDataS(const wauthn_hybrid_linked_data_s *expecte
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_hybrid_linked_data_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_hybrid_linked_data_s_Positive)
 {
     HybridLinkedDataSerializer data1(&TestCommonData::hybridLinkedData);
     HybridLinkedDataDeserializer deserializer1;
@@ -854,7 +854,7 @@ TEST_F(WAuthnSerializationTest, wauthn_hybrid_linked_data_s_P)
     HybridLinkedDataDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnHybridLinkedDataS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_hybrid_linked_data_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_hybrid_linked_data_s_1_Negative)
 {// deserialize: for too large length
     HybridLinkedDataDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
@@ -878,7 +878,7 @@ bool __compareWAuthnAttestationFormatsS(const wauthn_attestation_formats_s *expe
             return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_attestation_formats_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_attestation_formats_s_Positive)
 {
     AttestationFormatsSerializer data1(&TestCommonData::attestationFormats1);
     AttestationFormatsDeserializer deserializer1;
@@ -896,18 +896,18 @@ TEST_F(WAuthnSerializationTest, wauthn_attestation_formats_s_P)
     AttestationFormatsDeserializer deserializer4;
     __testSerialization(data4, deserializer4, __compareWAuthnAttestationFormatsS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_attestation_formats_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_attestation_formats_s_1_Negative)
 {// deserialize: for too large length
     AttestationFormatsDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
 }
-TEST_F(WAuthnSerializationTest, wauthn_attestation_formats_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_attestation_formats_s_2_Negative)
 {// deserialize: for too large array count
     wauthn_attestation_formats_s data = {MAX_ARRAY_COUNT + 1, TestCommonData::attestationFormat2};
     __testDeserializeForInvalidMember<wauthn_attestation_formats_s,
                                       AttestationFormatsDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_attestation_formats_s_N3)
+TEST_F(WAuthnSerializationTest, wauthn_attestation_formats_s_3_Negative)
 {// deserialize: for inconsistent pointer & size
     wauthn_attestation_formats_s data = {3, nullptr};
     __testDeserializeForInvalidMember<wauthn_attestation_formats_s,
@@ -951,7 +951,7 @@ bool __compareWAuthnPubkeyCredCreationOptionsS(const wauthn_pubkey_cred_creation
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_creation_options_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_creation_options_s_Positive)
 {
     PubKeyCredCreationOptionsSerializer data1(&TestCommonData::pubkeyCredCreationOptions);
     PubKeyCredCreationOptionsDeserializer deserializer1;
@@ -965,12 +965,12 @@ TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_creation_options_s_P)
     PubKeyCredCreationOptionsDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnPubkeyCredCreationOptionsS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_creation_options_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_creation_options_s_1_Negative)
 {// deserialize: for too large length
     PubKeyCredCreationOptionsDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_creation_options_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_creation_options_s_2_Negative)
 {// serialize: invalid member
     wauthn_pubkey_cred_creation_options_s data = TestCommonData::pubkeyCredCreationOptions;
     data.attestation = static_cast<wauthn_attestation_pref_e>(4);
@@ -1010,7 +1010,7 @@ bool __compareWAuthnPubkeyCredRequestOptionsS(const wauthn_pubkey_cred_request_o
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_request_options_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_request_options_s_Positive)
 {
     PubKeyCredRequestOptionsSerializer data1(&TestCommonData::pubkeyCredRequestOptions);
     PubKeyCredRequestOptionsDeserializer deserializer1;
@@ -1024,21 +1024,21 @@ TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_request_options_s_P)
     PubKeyCredRequestOptionsDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnPubkeyCredRequestOptionsS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_request_options_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_request_options_s_1_Negative)
 {// serialize: invalid member
     wauthn_pubkey_cred_request_options_s data = TestCommonData::pubkeyCredRequestOptions;
     data.user_verification = static_cast<wauthn_user_verification_requirement_e>(4);
     __testDeserializeForInvalidMember<wauthn_pubkey_cred_request_options_s,
                                       PubKeyCredRequestOptionsDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_request_options_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_request_options_s_2_Negative)
 {// serialize: invalid member
     wauthn_pubkey_cred_request_options_s data = TestCommonData::pubkeyCredRequestOptions;
     data.attestation = static_cast<wauthn_attestation_pref_e>(4);
     __testDeserializeForInvalidMember<wauthn_pubkey_cred_request_options_s,
                                       PubKeyCredRequestOptionsDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_request_options_s_N3)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_cred_request_options_s_3_Negative)
 {// deserialize: for too large length
     PubKeyCredRequestOptionsDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
@@ -1072,7 +1072,7 @@ bool __compareWAuthnPubkeyCredentialAttestationS(
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_attestation_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_attestation_s_Positive)
 {
     PubkeyCredentialAttestationSerializer data1(&TestCommonData::pubkeyCredentialAttestation);
     PubkeyCredentialAttestationDeserializer deserializer1;
@@ -1086,19 +1086,19 @@ TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_attestation_s_P)
     PubkeyCredentialAttestationDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnPubkeyCredentialAttestationS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_attestation_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_attestation_s_1_Negative)
 {// deserialize: for too large length
     PubkeyCredentialAttestationDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_attestation_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_attestation_s_2_Negative)
 {// deserialize: for invalid type
     wauthn_pubkey_credential_attestation_s data = TestCommonData::pubkeyCredentialAttestation;
     data.type = static_cast<wauthn_pubkey_cred_type_e>(0);
     __testDeserializeForInvalidMember<wauthn_pubkey_credential_attestation_s,
                                       PubkeyCredentialAttestationDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_attestation_s_N3)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_attestation_s_3_Negative)
 {// deserialize: for invalid authenticator_attachment
     wauthn_pubkey_credential_attestation_s data = TestCommonData::pubkeyCredentialAttestation;
     data.authenticator_attachment = static_cast<wauthn_authenticator_attachment_e>(3);
@@ -1134,7 +1134,7 @@ bool __compareWAuthnPubkeyCredentialAssertionS(const wauthn_pubkey_credential_as
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_assertion_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_assertion_s_Positive)
 {
     PubkeyCredentialAssertionSerializer data1(&TestCommonData::pubkeyCredentialAssertion);
     PubkeyCredentialAssertionDeserializer deserializer1;
@@ -1148,19 +1148,19 @@ TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_assertion_s_P)
     PubkeyCredentialAssertionDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnPubkeyCredentialAssertionS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_assertion_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_assertion_s_1_Negative)
 {// deserialize: for too large length
     PubkeyCredentialAssertionDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_assertion_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_assertion_s_2_Negative)
 {// deserialize: for invalid type
     wauthn_pubkey_credential_assertion_s data = TestCommonData::pubkeyCredentialAssertion;
     data.type = static_cast<wauthn_pubkey_cred_type_e>(0);
     __testDeserializeForInvalidMember<wauthn_pubkey_credential_assertion_s,
                                       PubkeyCredentialAssertionDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_assertion_s_N3)
+TEST_F(WAuthnSerializationTest, wauthn_pubkey_credential_assertion_s_3_Negative)
 {// deserialize: for invalid authenticator_attachment
     wauthn_pubkey_credential_assertion_s data = TestCommonData::pubkeyCredentialAssertion;
     data.authenticator_attachment = static_cast<wauthn_authenticator_attachment_e>(3);
@@ -1184,7 +1184,7 @@ bool __compareWAuthnClientDataS(const wauthn_client_data_s *expected,
         return false;
     return true;
 }
-TEST_F(WAuthnSerializationTest, wauthn_client_data_s_P)
+TEST_F(WAuthnSerializationTest, wauthn_client_data_s_Positive)
 {
     ClientDataSerializer data1(&TestCommonData::clientData);
     ClientDataDeserializer deserializer1;
@@ -1198,13 +1198,13 @@ TEST_F(WAuthnSerializationTest, wauthn_client_data_s_P)
     ClientDataDeserializer deserializer3;
     __testSerialization(data3, deserializer3, __compareWAuthnClientDataS);
 }
-TEST_F(WAuthnSerializationTest, wauthn_client_data_s_N1)
+TEST_F(WAuthnSerializationTest, wauthn_client_data_s_1_Negative)
 {// serialize: invalid member
     wauthn_client_data_s data = TestCommonData::clientData;
     data.hash_alg = static_cast<wauthn_hash_algorithm_e>(0);
     __testDeserializeForInvalidMember<wauthn_client_data_s, ClientDataDeserializer>(data);
 }
-TEST_F(WAuthnSerializationTest, wauthn_client_data_s_N2)
+TEST_F(WAuthnSerializationTest, wauthn_client_data_s_2_Negative)
 {// deserialize: for too large length
     ClientDataDeserializer deserializer;
     __testDeserializeForTooLongLength(deserializer);
@@ -1248,7 +1248,7 @@ void __testMultipleSerializationWAuthErrorE(S1& serializer1, wauthn_error_e seri
     EXPECT_EQ(__compareWAuthErrorE(serializer2, deserializer2), true);
 }
 
-TEST_F(WAuthnSerializationTest, multiple_serialization_mc_req_P)
+TEST_F(WAuthnSerializationTest, multiple_serialization_mc_req_Positive)
 {
     ClientDataSerializer clientData(&TestCommonData::clientData);
     PubKeyCredCreationOptionsSerializer options(&TestCommonData::pubkeyCredCreationOptions);
@@ -1262,7 +1262,7 @@ TEST_F(WAuthnSerializationTest, multiple_serialization_mc_req_P)
     );
 }
 
-TEST_F(WAuthnSerializationTest, multiple_serialization_ga_req_P)
+TEST_F(WAuthnSerializationTest, multiple_serialization_ga_req_Positive)
 {
     ClientDataSerializer clientData(&TestCommonData::clientData);
     PubKeyCredRequestOptionsSerializer options(&TestCommonData::pubkeyCredRequestOptions);
@@ -1275,7 +1275,7 @@ TEST_F(WAuthnSerializationTest, multiple_serialization_ga_req_P)
             __compareWAuthnClientDataS, __compareWAuthnPubkeyCredRequestOptionsS);
 }
 
-TEST_F(WAuthnSerializationTest, multiple_serialization_mc_res_P)
+TEST_F(WAuthnSerializationTest, multiple_serialization_mc_res_Positive)
 {
     PubkeyCredentialAttestationSerializer pubkeyCred(&TestCommonData::pubkeyCredentialAttestation);
     wauthn_error_e result = WAUTHN_ERROR_PERMISSION_DENIED;
@@ -1288,7 +1288,7 @@ TEST_F(WAuthnSerializationTest, multiple_serialization_mc_res_P)
             __compareWAuthnPubkeyCredentialAttestationS);
 }
 
-TEST_F(WAuthnSerializationTest, multiple_serialization_ga_res_P)
+TEST_F(WAuthnSerializationTest, multiple_serialization_ga_res_Positive)
 {
     PubkeyCredentialAssertionSerializer pubkeyCred(&TestCommonData::pubkeyCredentialAssertion);
     wauthn_error_e result = WAUTHN_ERROR_CANCELED;

diff --git a/tests/socket-manager-test.cpp b/tests/socket-manager-test.cpp
index 9ab86f6f78aedc3c1bab90fda0ab96e9b5a5bd56..59c77d1bb15ed87985a77bde6d572e56e343e5fc 100644 (file)
--- a/tests/socket-manager-test.cpp
+++ b/tests/socket-manager-test.cpp
@@ -83,7 +83,7 @@ private:
 };
 
 
-TEST_F(SocketManagerTest, mainloop_P)
+TEST_F(SocketManagerTest, mainloop_Positive)
 {
     int ret = 1;
     WA::SocketManager manager;

diff --git a/tests/utils-tests.cpp b/tests/utils-tests.cpp
index 048714f386ed65e2c1c6c9db2764e92d99d2c16e..7a73f37229e121050d2c272b8dc06184e53e9f8f 100644 (file)
--- a/tests/utils-tests.cpp
+++ b/tests/utils-tests.cpp
@@ -52,7 +52,7 @@ protected:
     }
 };
 
-TEST_F(UtilsTest, handle_exceptions_by_try_catch_functions_P)
+TEST_F(UtilsTest, handle_exceptions_by_try_catch_functions_Positive)
 {
     int ret = try_catch([&]() -> int {
         Throw(SerializationException::InvalidStreamData);
@@ -115,7 +115,7 @@ TEST_F(UtilsTest, handle_exceptions_by_try_catch_functions_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_invalid_blank_str_N)
+TEST_F(UtilsTest, check_parameter_invalid_blank_str_Negative)
 {
     const char str[] = "";
     int ret = try_catch([&]() -> int {
@@ -125,7 +125,7 @@ TEST_F(UtilsTest, check_parameter_invalid_blank_str_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_invalid_str_skip_P)
+TEST_F(UtilsTest, check_parameter_invalid_str_skip_Positive)
 {
     const char str[] = "";
     int ret = try_catch([&]() -> int {
@@ -151,7 +151,7 @@ TEST_F(UtilsTest, check_parameter_invalid_str_skip_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_clientdatajson_null_N)
+TEST_F(UtilsTest, check_parameter_clientdatajson_null_Negative)
 {
     auto clientData = TestCommonData::clientData;
     auto backupData = clientData.client_data_json;
@@ -164,7 +164,7 @@ TEST_F(UtilsTest, check_parameter_clientdatajson_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_clientdatajson_buffer_null_N)
+TEST_F(UtilsTest, check_parameter_clientdatajson_buffer_null_Negative)
 {
     auto clientData = TestCommonData::clientData;
     auto backupData = clientData.client_data_json->data;
@@ -177,7 +177,7 @@ TEST_F(UtilsTest, check_parameter_clientdatajson_buffer_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_clientdatajson_buffer_size_zero_N)
+TEST_F(UtilsTest, check_parameter_clientdatajson_buffer_size_zero_Negative)
 {
     auto clientData = TestCommonData::clientData;
     auto backupData = clientData.client_data_json->size;
@@ -190,7 +190,7 @@ TEST_F(UtilsTest, check_parameter_clientdatajson_buffer_size_zero_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_clientdata_invalid_hash_N)
+TEST_F(UtilsTest, check_parameter_clientdata_invalid_hash_Negative)
 {
     auto clientData = TestCommonData::clientData;
     auto backupData = clientData.hash_alg;
@@ -203,7 +203,7 @@ TEST_F(UtilsTest, check_parameter_clientdata_invalid_hash_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_rp_id_null_N)
+TEST_F(UtilsTest, check_parameter_options_rp_id_null_Negative)
 {
     auto rpData = TestCommonData::rpEntity;
     auto backupData = rpData.id;
@@ -216,7 +216,7 @@ TEST_F(UtilsTest, check_parameter_options_rp_id_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_rp_name_null_N)
+TEST_F(UtilsTest, check_parameter_options_rp_name_null_Negative)
 {
     auto rpData = TestCommonData::rpEntity;
     auto backupData = rpData.name;
@@ -230,7 +230,7 @@ TEST_F(UtilsTest, check_parameter_options_rp_name_null_N)
 }
 
 
-TEST_F(UtilsTest, check_parameter_options_user_id_null_N)
+TEST_F(UtilsTest, check_parameter_options_user_id_null_Negative)
 {
     auto userData = TestCommonData::userEntity;
     auto backupData = userData.id;
@@ -243,7 +243,7 @@ TEST_F(UtilsTest, check_parameter_options_user_id_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_user_name_null_N)
+TEST_F(UtilsTest, check_parameter_options_user_name_null_Negative)
 {
     auto userData = TestCommonData::userEntity;
     auto backupData = userData.name;
@@ -257,7 +257,7 @@ TEST_F(UtilsTest, check_parameter_options_user_name_null_N)
 }
 
 
-TEST_F(UtilsTest, check_parameter_options_user_displayname_null_N)
+TEST_F(UtilsTest, check_parameter_options_user_displayname_null_Negative)
 {
     auto userData = TestCommonData::userEntity;
     auto backupData = userData.display_name;
@@ -270,7 +270,7 @@ TEST_F(UtilsTest, check_parameter_options_user_displayname_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_user_id_data_null_N)
+TEST_F(UtilsTest, check_parameter_options_user_id_data_null_Negative)
 {
     auto userData = TestCommonData::userEntity;
     auto backupData = userData.id->data;
@@ -283,7 +283,7 @@ TEST_F(UtilsTest, check_parameter_options_user_id_data_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_user_id_size_zero_N)
+TEST_F(UtilsTest, check_parameter_options_user_id_size_zero_Negative)
 {
     auto userData = TestCommonData::userEntity;
     auto backupData = userData.id->size;
@@ -296,7 +296,7 @@ TEST_F(UtilsTest, check_parameter_options_user_id_size_zero_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_pubkey_cred_params_params_null_N)
+TEST_F(UtilsTest, check_parameter_options_pubkey_cred_params_params_null_Negative)
 {
     auto credParams = TestCommonData::pubkeyCredParams2;
     auto backupData = credParams.params;
@@ -309,7 +309,7 @@ TEST_F(UtilsTest, check_parameter_options_pubkey_cred_params_params_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_pubkey_cred_params_size_zero_N)
+TEST_F(UtilsTest, check_parameter_options_pubkey_cred_params_size_zero_Negative)
 {
     auto credParams = TestCommonData::pubkeyCredParams2;
     auto backupData = credParams.size;
@@ -322,7 +322,7 @@ TEST_F(UtilsTest, check_parameter_options_pubkey_cred_params_size_zero_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_pubkey_cred_params_ignore_invalid_type_P)
+TEST_F(UtilsTest, check_parameter_options_pubkey_cred_params_ignore_invalid_type_Positive)
 {
     auto credParams = TestCommonData::pubkeyCredParams2;
     for (size_t i = 0; i < credParams.size; ++i)
@@ -339,7 +339,7 @@ TEST_F(UtilsTest, check_parameter_options_pubkey_cred_params_ignore_invalid_type
     }
 }
 
-TEST_F(UtilsTest, check_parameter_options_pubkey_cred_params_invalid_alg_N)
+TEST_F(UtilsTest, check_parameter_options_pubkey_cred_params_invalid_alg_Negative)
 {
     auto credParams = TestCommonData::pubkeyCredParams2;
     for (size_t i = 0; i < credParams.size; ++i)
@@ -356,7 +356,7 @@ TEST_F(UtilsTest, check_parameter_options_pubkey_cred_params_invalid_alg_N)
     }
 }
 
-TEST_F(UtilsTest, check_parameter_options_cred_descriptors_descs_null_N)
+TEST_F(UtilsTest, check_parameter_options_cred_descriptors_descs_null_Negative)
 {
     auto credDescs = TestCommonData::pubkeyCredDescriptors2;
     auto backupData = credDescs.descriptors;
@@ -369,7 +369,7 @@ TEST_F(UtilsTest, check_parameter_options_cred_descriptors_descs_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_cred_descriptors_desc_size_zero_N)
+TEST_F(UtilsTest, check_parameter_options_cred_descriptors_desc_size_zero_Negative)
 {
     auto credDescs = TestCommonData::pubkeyCredDescriptors2;
     auto backupData = credDescs.size;
@@ -382,7 +382,7 @@ TEST_F(UtilsTest, check_parameter_options_cred_descriptors_desc_size_zero_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_cred_descriptors_ignore_invalid_type_P)
+TEST_F(UtilsTest, check_parameter_options_cred_descriptors_ignore_invalid_type_Positive)
 {
     auto credDescs = TestCommonData::pubkeyCredDescriptors2;
     for (size_t i = 0; i < credDescs.size; ++i)
@@ -399,7 +399,7 @@ TEST_F(UtilsTest, check_parameter_options_cred_descriptors_ignore_invalid_type_P
     }
 }
 
-TEST_F(UtilsTest, check_parameter_options_cred_descriptors_invalid_id_N)
+TEST_F(UtilsTest, check_parameter_options_cred_descriptors_invalid_id_Negative)
 {
     auto credDescs = TestCommonData::pubkeyCredDescriptors2;
     for (size_t i = 0; i < credDescs.size; ++i)
@@ -434,7 +434,7 @@ TEST_F(UtilsTest, check_parameter_options_cred_descriptors_invalid_id_N)
     }
 }
 
-TEST_F(UtilsTest, check_parameter_options_cred_descriptors_ignore_invalid_transports_P)
+TEST_F(UtilsTest, check_parameter_options_cred_descriptors_ignore_invalid_transports_Positive)
 {
     auto credDescs = TestCommonData::pubkeyCredDescriptors2;
     for (size_t i = 0; i < credDescs.size; ++i)
@@ -451,7 +451,7 @@ TEST_F(UtilsTest, check_parameter_options_cred_descriptors_ignore_invalid_transp
     }
 }
 
-TEST_F(UtilsTest, check_parameter_options_authenticator_selection_ignore_invalid_attachment_P)
+TEST_F(UtilsTest, check_parameter_options_authenticator_selection_ignore_invalid_attachment_Positive)
 {
     auto authSel = TestCommonData::authenticatorSelCri;
     auto backupData = authSel.attachment;
@@ -464,7 +464,7 @@ TEST_F(UtilsTest, check_parameter_options_authenticator_selection_ignore_invalid
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_options_authenticator_selection_ignore_invalid_resident_key_P)
+TEST_F(UtilsTest, check_parameter_options_authenticator_selection_ignore_invalid_resident_key_Positive)
 {
     auto authSel = TestCommonData::authenticatorSelCri;
     auto backupData = authSel.resident_key;
@@ -477,7 +477,7 @@ TEST_F(UtilsTest, check_parameter_options_authenticator_selection_ignore_invalid
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_options_authenticator_selection_ignore_invalid_user_verification_P)
+TEST_F(UtilsTest, check_parameter_options_authenticator_selection_ignore_invalid_user_verification_Positive)
 {
     auto authSel = TestCommonData::authenticatorSelCri;
     auto backupData = authSel.user_verification;
@@ -490,7 +490,7 @@ TEST_F(UtilsTest, check_parameter_options_authenticator_selection_ignore_invalid
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_options_authenticator_selection_invalid_resident_key_pair_N)
+TEST_F(UtilsTest, check_parameter_options_authenticator_selection_invalid_resident_key_pair_Negative)
 {
     auto authSel = TestCommonData::authenticatorSelCri;
     auto backupRequiredResidentKey = authSel.require_resident_key;
@@ -506,7 +506,7 @@ TEST_F(UtilsTest, check_parameter_options_authenticator_selection_invalid_reside
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_hints_hints_null_N)
+TEST_F(UtilsTest, check_parameter_options_hints_hints_null_Negative)
 {
     auto hints = TestCommonData::pubkeyCredHints2;
     auto backupData = hints.hints;
@@ -519,7 +519,7 @@ TEST_F(UtilsTest, check_parameter_options_hints_hints_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_hints_size_zero_N)
+TEST_F(UtilsTest, check_parameter_options_hints_size_zero_Negative)
 {
     auto hints = TestCommonData::pubkeyCredHints2;
     auto backupData = hints.size;
@@ -532,7 +532,7 @@ TEST_F(UtilsTest, check_parameter_options_hints_size_zero_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_hints_invalid_value_P)
+TEST_F(UtilsTest, check_parameter_options_hints_invalid_value_Positive)
 {
     auto hints = TestCommonData::pubkeyCredHints2;
     for (size_t i = 0; i < hints.size; ++i)
@@ -549,7 +549,7 @@ TEST_F(UtilsTest, check_parameter_options_hints_invalid_value_P)
     }
 }
 
-TEST_F(UtilsTest, check_parameter_options_attestation_formats_formats_null_N)
+TEST_F(UtilsTest, check_parameter_options_attestation_formats_formats_null_Negative)
 {
     auto formats = TestCommonData::attestationFormats2;
     auto backupData = formats.attestation_formats;
@@ -562,7 +562,7 @@ TEST_F(UtilsTest, check_parameter_options_attestation_formats_formats_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_attestation_formats_size_zero_N)
+TEST_F(UtilsTest, check_parameter_options_attestation_formats_size_zero_Negative)
 {
     auto formats = TestCommonData::attestationFormats2;
     auto backupData = formats.size;
@@ -575,7 +575,7 @@ TEST_F(UtilsTest, check_parameter_options_attestation_formats_size_zero_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_attestation_formats_invalid_value_N)
+TEST_F(UtilsTest, check_parameter_options_attestation_formats_invalid_value_Negative)
 {
     auto formats = TestCommonData::attestationFormats2;
     for (size_t i = 0; i < formats.size; ++i)
@@ -601,7 +601,7 @@ TEST_F(UtilsTest, check_parameter_options_attestation_formats_invalid_value_N)
     }
 }
 
-TEST_F(UtilsTest, check_parameter_options_extensions_extensions_null_N)
+TEST_F(UtilsTest, check_parameter_options_extensions_extensions_null_Negative)
 {
     auto authExts = TestCommonData::authenticationExts2;
     auto backupData = authExts.extensions;
@@ -614,7 +614,7 @@ TEST_F(UtilsTest, check_parameter_options_extensions_extensions_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_extensions_size_zero_N)
+TEST_F(UtilsTest, check_parameter_options_extensions_size_zero_Negative)
 {
     auto authExts = TestCommonData::authenticationExts2;
     auto backupData = authExts.size;
@@ -627,7 +627,7 @@ TEST_F(UtilsTest, check_parameter_options_extensions_size_zero_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_extensions_invalid_id_N)
+TEST_F(UtilsTest, check_parameter_options_extensions_invalid_id_Negative)
 {
     auto authExts = TestCommonData::authenticationExts2;
     for (size_t i = 0; i < authExts.size; ++i)
@@ -662,7 +662,7 @@ TEST_F(UtilsTest, check_parameter_options_extensions_invalid_id_N)
     }
 }
 
-TEST_F(UtilsTest, check_parameter_options_extensions_invalid_value_N)
+TEST_F(UtilsTest, check_parameter_options_extensions_invalid_value_Negative)
 {
     auto authExts = TestCommonData::authenticationExts2;
     for (size_t i = 0; i < authExts.size; ++i)
@@ -697,7 +697,7 @@ TEST_F(UtilsTest, check_parameter_options_extensions_invalid_value_N)
     }
 }
 
-TEST_F(UtilsTest, check_parameter_options_linked_device_P)
+TEST_F(UtilsTest, check_parameter_options_linked_device_Positive)
 {
     auto linkedData = TestCommonData::hybridLinkedData;
     int ret = try_catch([&]() -> int {
@@ -707,7 +707,7 @@ TEST_F(UtilsTest, check_parameter_options_linked_device_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_options_linked_device_contact_id_null_N)
+TEST_F(UtilsTest, check_parameter_options_linked_device_contact_id_null_Negative)
 {
     auto linkedData = TestCommonData::hybridLinkedData;
     auto backupData = linkedData.contact_id;
@@ -738,7 +738,7 @@ TEST_F(UtilsTest, check_parameter_options_linked_device_contact_id_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_linked_device_link_id_null_N)
+TEST_F(UtilsTest, check_parameter_options_linked_device_link_id_null_Negative)
 {
     auto linkedData = TestCommonData::hybridLinkedData;
     auto backupData = linkedData.link_id;
@@ -769,7 +769,7 @@ TEST_F(UtilsTest, check_parameter_options_linked_device_link_id_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_linked_device_link_secret_null_N)
+TEST_F(UtilsTest, check_parameter_options_linked_device_link_secret_null_Negative)
 {
     auto linkedData = TestCommonData::hybridLinkedData;
     auto backupData = linkedData.link_secret;
@@ -800,7 +800,7 @@ TEST_F(UtilsTest, check_parameter_options_linked_device_link_secret_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_linked_device_authenticator_pubkey_null_N)
+TEST_F(UtilsTest, check_parameter_options_linked_device_authenticator_pubkey_null_Negative)
 {
     auto linkedData = TestCommonData::hybridLinkedData;
     auto backupData = linkedData.authenticator_pubkey;
@@ -831,7 +831,7 @@ TEST_F(UtilsTest, check_parameter_options_linked_device_authenticator_pubkey_nul
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_linked_device_authenticator_name_null_N)
+TEST_F(UtilsTest, check_parameter_options_linked_device_authenticator_name_null_Negative)
 {
     auto linkedData = TestCommonData::hybridLinkedData;
     auto backupData = linkedData.authenticator_name;
@@ -862,7 +862,7 @@ TEST_F(UtilsTest, check_parameter_options_linked_device_authenticator_name_null_
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_linked_device_signature_null_N)
+TEST_F(UtilsTest, check_parameter_options_linked_device_signature_null_Negative)
 {
     auto linkedData = TestCommonData::hybridLinkedData;
     auto backupData = linkedData.signature;
@@ -893,7 +893,7 @@ TEST_F(UtilsTest, check_parameter_options_linked_device_signature_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_linked_device_tunnel_server_domain_null_N)
+TEST_F(UtilsTest, check_parameter_options_linked_device_tunnel_server_domain_null_Negative)
 {
     auto linkedData = TestCommonData::hybridLinkedData;
     auto backupData = linkedData.tunnel_server_domain;
@@ -924,7 +924,7 @@ TEST_F(UtilsTest, check_parameter_options_linked_device_tunnel_server_domain_nul
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_options_linked_device_identity_key_null_N)
+TEST_F(UtilsTest, check_parameter_options_linked_device_identity_key_null_Negative)
 {
     auto linkedData = TestCommonData::hybridLinkedData;
     auto backupData = linkedData.identity_key;
@@ -955,7 +955,7 @@ TEST_F(UtilsTest, check_parameter_options_linked_device_identity_key_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_options_rp_null_N)
+TEST_F(UtilsTest, check_parameter_MC_options_rp_null_Negative)
 {
     auto options = TestCommonData::pubkeyCredCreationOptions;
     auto backupData = options.rp;
@@ -968,7 +968,7 @@ TEST_F(UtilsTest, check_parameter_MC_options_rp_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_options_user_null_N)
+TEST_F(UtilsTest, check_parameter_MC_options_user_null_Negative)
 {
     auto options = TestCommonData::pubkeyCredCreationOptions;
     auto backupData = options.user;
@@ -981,7 +981,7 @@ TEST_F(UtilsTest, check_parameter_MC_options_user_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_options_pubkey_cred_params_null_N)
+TEST_F(UtilsTest, check_parameter_MC_options_pubkey_cred_params_null_Negative)
 {
     auto options = TestCommonData::pubkeyCredCreationOptions;
     auto backupData = options.pubkey_cred_params;
@@ -994,7 +994,7 @@ TEST_F(UtilsTest, check_parameter_MC_options_pubkey_cred_params_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_options_exclude_credentials_null_P)
+TEST_F(UtilsTest, check_parameter_MC_options_exclude_credentials_null_Positive)
 {
     auto options = TestCommonData::pubkeyCredCreationOptions;
     auto backupData = options.exclude_credentials;
@@ -1007,7 +1007,7 @@ TEST_F(UtilsTest, check_parameter_MC_options_exclude_credentials_null_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_options_authenticator_selection_null_P)
+TEST_F(UtilsTest, check_parameter_MC_options_authenticator_selection_null_Positive)
 {
     auto options = TestCommonData::pubkeyCredCreationOptions;
     auto backupData = options.authenticator_selection;
@@ -1020,7 +1020,7 @@ TEST_F(UtilsTest, check_parameter_MC_options_authenticator_selection_null_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_options_hints_null_P)
+TEST_F(UtilsTest, check_parameter_MC_options_hints_null_Positive)
 {
     auto options = TestCommonData::pubkeyCredCreationOptions;
     auto backupData = options.hints;
@@ -1033,7 +1033,7 @@ TEST_F(UtilsTest, check_parameter_MC_options_hints_null_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_options_ignore_invalid_attestation_P)
+TEST_F(UtilsTest, check_parameter_MC_options_ignore_invalid_attestation_Positive)
 {
     auto options = TestCommonData::pubkeyCredCreationOptions;
     auto backupData = options.attestation;
@@ -1046,7 +1046,7 @@ TEST_F(UtilsTest, check_parameter_MC_options_ignore_invalid_attestation_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_options_attestation_formats_null_P)
+TEST_F(UtilsTest, check_parameter_MC_options_attestation_formats_null_Positive)
 {
     auto options = TestCommonData::pubkeyCredCreationOptions;
     auto backupData = options.attestation_formats;
@@ -1059,7 +1059,7 @@ TEST_F(UtilsTest, check_parameter_MC_options_attestation_formats_null_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_options_extensions_null_P)
+TEST_F(UtilsTest, check_parameter_MC_options_extensions_null_Positive)
 {
     auto options = TestCommonData::pubkeyCredCreationOptions;
     auto backupData = options.extensions;
@@ -1072,7 +1072,7 @@ TEST_F(UtilsTest, check_parameter_MC_options_extensions_null_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_options_linked_device_null_P)
+TEST_F(UtilsTest, check_parameter_MC_options_linked_device_null_Positive)
 {
     auto options = TestCommonData::pubkeyCredCreationOptions;
     auto backupData = options.linked_device;
@@ -1085,7 +1085,7 @@ TEST_F(UtilsTest, check_parameter_MC_options_linked_device_null_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_GA_options_rp_id_null_N)
+TEST_F(UtilsTest, check_parameter_GA_options_rp_id_null_Negative)
 {
     auto options = TestCommonData::pubkeyCredRequestOptions;
     auto backupData = options.rpId;
@@ -1098,7 +1098,7 @@ TEST_F(UtilsTest, check_parameter_GA_options_rp_id_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_GA_options_allow_credentials_null_P)
+TEST_F(UtilsTest, check_parameter_GA_options_allow_credentials_null_Positive)
 {
     auto options = TestCommonData::pubkeyCredRequestOptions;
     auto backupData = options.allow_credentials;
@@ -1111,7 +1111,7 @@ TEST_F(UtilsTest, check_parameter_GA_options_allow_credentials_null_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_GA_options_invalid_user_verification_P)
+TEST_F(UtilsTest, check_parameter_GA_options_invalid_user_verification_Positive)
 {
     auto options = TestCommonData::pubkeyCredRequestOptions;
     auto backupData = options.user_verification;
@@ -1124,7 +1124,7 @@ TEST_F(UtilsTest, check_parameter_GA_options_invalid_user_verification_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_GA_options_hints_null_P)
+TEST_F(UtilsTest, check_parameter_GA_options_hints_null_Positive)
 {
     auto options = TestCommonData::pubkeyCredRequestOptions;
     auto backupData = options.hints;
@@ -1138,7 +1138,7 @@ TEST_F(UtilsTest, check_parameter_GA_options_hints_null_P)
 }
 
 
-TEST_F(UtilsTest, check_parameter_GA_options_ignore_invalid_attestation_P)
+TEST_F(UtilsTest, check_parameter_GA_options_ignore_invalid_attestation_Positive)
 {
     auto options = TestCommonData::pubkeyCredRequestOptions;
     auto backupData = options.attestation;
@@ -1152,7 +1152,7 @@ TEST_F(UtilsTest, check_parameter_GA_options_ignore_invalid_attestation_P)
 }
 
 
-TEST_F(UtilsTest, check_parameter_GA_options_attestation_formats_null_P)
+TEST_F(UtilsTest, check_parameter_GA_options_attestation_formats_null_Positive)
 {
     auto options = TestCommonData::pubkeyCredRequestOptions;
     auto backupData = options.attestation_formats;
@@ -1165,7 +1165,7 @@ TEST_F(UtilsTest, check_parameter_GA_options_attestation_formats_null_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_GA_options_extensions_null_P)
+TEST_F(UtilsTest, check_parameter_GA_options_extensions_null_Positive)
 {
     auto options = TestCommonData::pubkeyCredRequestOptions;
     auto backupData = options.extensions;
@@ -1178,7 +1178,7 @@ TEST_F(UtilsTest, check_parameter_GA_options_extensions_null_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_GA_options_linked_device_null_P)
+TEST_F(UtilsTest, check_parameter_GA_options_linked_device_null_Positive)
 {
     auto options = TestCommonData::pubkeyCredRequestOptions;
     auto backupData = options.linked_device;
@@ -1191,7 +1191,7 @@ TEST_F(UtilsTest, check_parameter_GA_options_linked_device_null_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_clientdata_null_N)
+TEST_F(UtilsTest, check_parameter_MC_clientdata_null_Negative)
 {
     wauthn_mc_callbacks_s callbacks = {test_cb_display_qrcode,
                                        test_cb_mc_response,
@@ -1204,7 +1204,7 @@ TEST_F(UtilsTest, check_parameter_MC_clientdata_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_options_null_N)
+TEST_F(UtilsTest, check_parameter_MC_options_null_Negative)
 {
     wauthn_mc_callbacks_s callbacks = {test_cb_display_qrcode,
                                        test_cb_mc_response,
@@ -1217,7 +1217,7 @@ TEST_F(UtilsTest, check_parameter_MC_options_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_callbacks_null_N)
+TEST_F(UtilsTest, check_parameter_MC_callbacks_null_Negative)
 {
     int ret = try_catch([&]() -> int {
         CheckParameters(&TestCommonData::clientData, &TestCommonData::pubkeyCredCreationOptions,
@@ -1249,7 +1249,7 @@ TEST_F(UtilsTest, check_parameter_MC_callbacks_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_qr_callback_null_without_linkeddata_N)
+TEST_F(UtilsTest, check_parameter_MC_qr_callback_null_without_linkeddata_Negative)
 {
     wauthn_mc_callbacks_s callbacks = {nullptr,
                                        test_cb_mc_response,
@@ -1267,7 +1267,7 @@ TEST_F(UtilsTest, check_parameter_MC_qr_callback_null_without_linkeddata_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_GA_clientdata_null_N)
+TEST_F(UtilsTest, check_parameter_GA_clientdata_null_Negative)
 {
     wauthn_ga_callbacks_s callbacks = {test_cb_display_qrcode,
                                        test_cb_ga_response,
@@ -1280,7 +1280,7 @@ TEST_F(UtilsTest, check_parameter_GA_clientdata_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_GA_options_null_N)
+TEST_F(UtilsTest, check_parameter_GA_options_null_Negative)
 {
     wauthn_ga_callbacks_s callbacks = {test_cb_display_qrcode,
                                        test_cb_ga_response,
@@ -1293,7 +1293,7 @@ TEST_F(UtilsTest, check_parameter_GA_options_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_GA_callbacks_null_N)
+TEST_F(UtilsTest, check_parameter_GA_callbacks_null_Negative)
 {
     int ret = try_catch([&]() -> int {
         CheckParameters(&TestCommonData::clientData, &TestCommonData::pubkeyCredRequestOptions,
@@ -1325,7 +1325,7 @@ TEST_F(UtilsTest, check_parameter_GA_callbacks_null_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_GA_qr_callback_null_without_linkeddata_N)
+TEST_F(UtilsTest, check_parameter_GA_qr_callback_null_without_linkeddata_Negative)
 {
     wauthn_ga_callbacks_s callbacks = {nullptr,
                                        test_cb_ga_response,
@@ -1343,7 +1343,7 @@ TEST_F(UtilsTest, check_parameter_GA_qr_callback_null_without_linkeddata_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(UtilsTest, check_parameter_MC_P)
+TEST_F(UtilsTest, check_parameter_MC_Positive)
 {
     wauthn_mc_callbacks_s callbacks = {test_cb_display_qrcode,
                                        test_cb_mc_response,
@@ -1357,7 +1357,7 @@ TEST_F(UtilsTest, check_parameter_MC_P)
     EXPECT_EQ(ret, WAUTHN_ERROR_NONE);
 }
 
-TEST_F(UtilsTest, check_parameter_GA_P)
+TEST_F(UtilsTest, check_parameter_GA_Positive)
 {
     wauthn_ga_callbacks_s callbacks = {test_cb_display_qrcode,
                                        test_cb_ga_response,

diff --git a/tests/webauthn-client-test.cpp b/tests/webauthn-client-test.cpp
index 74b27e51b226014c51b74fa2f6ad6f8783bded8d..6f0b4882384eb797ca20bb3043cd214b2f2c29ed 100644 (file)
--- a/tests/webauthn-client-test.cpp
+++ b/tests/webauthn-client-test.cpp
@@ -39,7 +39,7 @@ protected:
     }
 };
 
-TEST_F(WebAuthnAPITest, invalid_client_data_N)
+TEST_F(WebAuthnAPITest, invalid_client_data_Negative)
 {
     int ret = WAUTHN_ERROR_NONE;
     wauthn_mc_callbacks_s mc_callbacks = {test_cb_display_qrcode,
@@ -62,7 +62,7 @@ TEST_F(WebAuthnAPITest, invalid_client_data_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(WebAuthnAPITest, invalid_options_N)
+TEST_F(WebAuthnAPITest, invalid_options_Negative)
 {
     int ret = WAUTHN_ERROR_NONE;
     wauthn_mc_callbacks_s mc_callbacks = {test_cb_display_qrcode,
@@ -85,7 +85,7 @@ TEST_F(WebAuthnAPITest, invalid_options_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(WebAuthnAPITest, invalid_callbacks_N)
+TEST_F(WebAuthnAPITest, invalid_callbacks_Negative)
 {
     int ret = WAUTHN_ERROR_NONE;
     ret = wauthn_make_credential(&TestCommonData::clientData,
@@ -100,7 +100,7 @@ TEST_F(WebAuthnAPITest, invalid_callbacks_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(WebAuthnAPITest, miss_qr_callback_without_linked_data_N)
+TEST_F(WebAuthnAPITest, miss_qr_callback_without_linked_data_Negative)
 {
     int ret = WAUTHN_ERROR_NONE;
     wauthn_mc_callbacks_s mc_callbacks = {nullptr,
@@ -123,7 +123,7 @@ TEST_F(WebAuthnAPITest, miss_qr_callback_without_linked_data_N)
     EXPECT_EQ(ret, WAUTHN_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(WebAuthnAPITest, cancel_not_allowed_N)
+TEST_F(WebAuthnAPITest, cancel_not_allowed_Negative)
 {
     int ret = WAUTHN_ERROR_NONE;
     ret = wauthn_cancel();
@@ -131,7 +131,7 @@ TEST_F(WebAuthnAPITest, cancel_not_allowed_N)
 }
 
 #ifndef EMULATOR_BUILD
-TEST_F(WebAuthnAPITest, MC_valid_request_and_cancel_P)
+TEST_F(WebAuthnAPITest, MC_valid_request_and_cancel_Positive)
 {
     sleep(3); // wait 3 secs for make interval
     int ret = WAUTHN_ERROR_NONE;
@@ -150,7 +150,7 @@ TEST_F(WebAuthnAPITest, MC_valid_request_and_cancel_P)
     sleep(3); // wait 3 secs for make interval
 }
 
-TEST_F(WebAuthnAPITest, GA_valid_request_and_cancel_P)
+TEST_F(WebAuthnAPITest, GA_valid_request_and_cancel_Positive)
 {
     sleep(3); // wait 3 secs for make interval
     int ret = WAUTHN_ERROR_NONE;