//////////////////////////////////////////////////////////////////////////////// // (c) Copyright, Ubisoft Entertainment Inc. || Created by Harbour // //////////////////////////////////////////////////////////////////////////////// #include "tests/config.h" #if defined(US_SDK_LIGHT_MOBILE) #error This file shall not be part of the solution #endif #include "tests/fixture/memoryCheckFixture.h" #include #include #include #include <../private/ubiservices/core/extensions/staticAssert.h> #include #include #include <../private/ubiservices/core/log/eventLogHelper.h> #include <../private/ubiservices/core/types/containerspriv.h> #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ubiservices/services/parameters/parametersNotification.h" #include #include #include #include #include #include #include #include #include "ubiservices/services/userGeneratedContents/ugcFavorites.h" #include "ubiservices/services/userGeneratedContents/ugcRatings.h" #include "ubiservices/services/userGeneratedContents/ugcSortingBy.h" #include "ubiservices/services/userGeneratedContents/ugcTypeId.h" #include namespace US_NS {; US_DEFINE_TEST(TestPublicEnums); typedef LeakCheckerNoScheduler PUBLIC_ENUMS; #define OBSOLETE_READY_TO_REMOVE #if defined(OBSOLETE_READY_TO_REMOVE) #define VALIDATE_ENUM_CODE(SET, ENUM_CODE) \ EXPECT_TRUE(TestPublicEnums_BF::validateEnumCode(SET, static_cast(ENUM_CODE), #ENUM_CODE)) #define VALIDATE_ENUM_SIZE(SETSIZE, ADDVAR, ADDSIZE, SECTION) \ do { \ ADDVAR += ADDSIZE;\ ASSERT_EQ(ADDVAR, SETSIZE) << "Missing value in the errorCode section : " << SECTION;\ } ONCE #endif namespace TestPublicEnums_BF { ::testing::AssertionResult validateEnumCode(Set& enumSet, uint64 enumValue, const char* enumName) { return enumSet.insert(enumValue).second ? ::testing::AssertionSuccess() : ::testing::AssertionFailure() << "Overlapping enum code: '" << enumName << "' value =" << hex << enumValue; } template static void TestEnumMatching(Set& enumSet, const char* textExpected, typename T::Enum value) { EXPECT_STREQ(textExpected, T::getString(value)); EXPECT_EQ(value, T::getEnumValue(textExpected)); EXPECT_TRUE(TestPublicEnums_BF::validateEnumCode(enumSet, static_cast(value), textExpected)); } template static void TestEnumMatching(Set& enumSet, const char* textExpected, T value) { EXPECT_STREQ(textExpected, T2::getString(value)); EXPECT_EQ(value, T2::getEnumValue(textExpected)); EXPECT_TRUE(TestPublicEnums_BF::validateEnumCode(enumSet, static_cast(value), textExpected)); } } #define STRF(x) #x #define APPEND(x, y) x ## y #define STRINGIFY(x) STRF(x) #define EXPECT_ENUM_MATCHING(_values, _e, _x) TestPublicEnums_BF::TestEnumMatching<_e>(_values, STRINGIFY(_x), _e::_x) #define EXPECT_ENUM_MATCHING2(_values, _e, _x) TestPublicEnums_BF::TestEnumMatching<_e, APPEND(_e, Ex)>(_values, STRINGIFY(_x), _e::_x) // *Important*: when you update these values, update the test LOCAL_ErrorCodes below // The guards are there to ensure that the test below is kept up to date. When a value is either added or removed from a section // the static assert will make the compilation fail until the value that the guard is compared to is updated. US_STATIC_ASSERT(Errors::CORE_END_SECTION_GUARD == 0x0D, "Test LOCAL_ErrorCodes need to be updated (CORE section is different)"); US_STATIC_ASSERT(Errors::HTTP_END_SECTION_GUARD == 0x90, "Test LOCAL_ErrorCodes need to be updated (HTTP section is different)"); US_STATIC_ASSERT(Errors::SSL_END_SECTION_GUARD == 0x127, "Test LOCAL_ErrorCodes need to be updated (TLS/SSL section is different)"); US_STATIC_ASSERT(Errors::AUTH_END_SECTION_GUARD == 0x15A, "Test LOCAL_ErrorCodes need to be updated (AUTEHNTIFICATION section is different)"); US_STATIC_ASSERT(Errors::APPLICATION_END_SECTION_GUARD == 0x193, "Test LOCAL_ErrorCodes need to be updated (APPLICATION section is different)"); US_STATIC_ASSERT(Errors::CLUB_END_SECTION_GUARD == 0x206, "Test LOCAL_ErrorCodes need to be updated (CLUB section is different)"); US_STATIC_ASSERT(Errors::FRIEND_END_SECTION_GUARD == 0x253, "Test LOCAL_ErrorCodes need to be updated (FRIEND section is different)"); US_STATIC_ASSERT(Errors::FRIEND_CONSOLE_END_SECTION_GUARD == 0x304, "Test LOCAL_ErrorCodes need to be updated (FRIEND section is different)"); US_STATIC_ASSERT(Errors::PARAMETERS_END_SECTION_GUARD == 0x354, "Test LOCAL_ErrorCodes need to be updated (PARAMETERS section is different)"); US_STATIC_ASSERT(Errors::CLUB_APPLICATION_END_SECTION_GUARD == 0x405, "Test LOCAL_ErrorCodes need to be updated (CLUB_APPLICATION section is different)"); US_STATIC_ASSERT(Errors::OVERLAY_END_SECTION_GUARD == 0x486, "Test LOCAL_ErrorCodes need to be updated (OVERLAY section is different)"); US_STATIC_ASSERT(Errors::ENTITIES_END_SECTION_GUARD == 0x50D, "Test LOCAL_ErrorCodes need to be updated (ENTITIES section is different)"); US_STATIC_ASSERT(Errors::PROFILES_END_SECTION_GUARD == 0x604, "Test LOCAL_ErrorCodes need to be updated (PROFILES section is different)"); US_STATIC_ASSERT(Errors::CONNECTION_END_SECTION_GUARD == 0x706, "Test LOCAL_ErrorCodes need to be updated (CONNECTION section is different)"); US_STATIC_ASSERT(Errors::NOTIFICATION_END_SECTION_GUARD == 0x807, "Test LOCAL_ErrorCodes need to be updated (MESSAGING section is different)"); US_STATIC_ASSERT(Errors::USERS_END_SECTION_GUARD == 0x90A, "Test LOCAL_ErrorCodes need to be updated (USERS section is different)"); US_STATIC_ASSERT(Errors::EVENTS_END_SECTION_GUARD == 0xA06, "Test LOCAL_ErrorCodes need to be updated (EVENTS section is different)"); US_STATIC_ASSERT(Errors::WEBSOCKET_END_SECTION_GUARD == 0xB06, "Test LOCAL_ErrorCodes need to be updated (WEBSOCKET section is different)"); US_STATIC_ASSERT(Errors::NEWS_END_SECTION_GUARD == 0xC02, "Test LOCAL_ErrorCodes need to be updated (NEWS section is different)"); US_STATIC_ASSERT(Errors::SECONDARYSTORE_END_SECTION_GUARD == 0xD0C, "Test LOCAL_ErrorCodes need to be updated (SECONDARYSTORE section is different)"); US_STATIC_ASSERT(Errors::REMOTELOGS_END_SECTION_GUARD == 0xE02, "Test LOCAL_ErrorCodes need to be updated (REMOTELOGS section is different)"); US_STATIC_ASSERT(Errors::STATS_END_SECTION_GUARD == 0x1003, "Test LOCAL_ErrorCodes need to be updated (STATS section is different)"); US_STATIC_ASSERT(Errors::LEADERBOARD_END_SECTION_GUARD == 0x1104, "Test LOCAL_ErrorCodes need to be updated (LEADERBOARD section is different)"); US_STATIC_ASSERT(Errors::PRIMARYSTORE_END_SECTION_GUARD == 0x1208, "Test LOCAL_ErrorCodes need to be updated (PRIMARYSTORE section is different)"); US_STATIC_ASSERT(Errors::FIRST_PARTY_END_SECTION_GUARD == 0x1305, "Test LOCAL_ErrorCodes need to be updated (FIRSTPARTY section is different)"); US_STATIC_ASSERT(Errors::TLOGS_END_SECTION_GUARD == 0x1406, "Test LOCAL_ErrorCodes need to be updated (TLOGS section is different)"); US_STATIC_ASSERT(Errors::SECONDARYSTOREINSTANTIATION_END_SECTION_GUARD == 0x1503, "Test LOCAL_ErrorCodes need to be updated (INSTANTIATION section is different)"); US_STATIC_ASSERT(Errors::BATTLEPASS_END_SECTION_GUARD == 0x1602, "Test LOCAL_ErrorCodes need to be updated (BATTLEPASS section is different)"); US_STATIC_ASSERT(Errors::MODERATION_END_SECTION_GUARD == 0x1705, "Test LOCAL_ErrorCodes need to be updated (MODERATION section is different)"); US_STATIC_ASSERT(Errors::UGC_END_SECTION_GUARD == 0x1804, "Test LOCAL_ErrorCodes need to be updated (UGC section is different)"); US_STATIC_ASSERT(Errors::ERROR_END_GUARD == 0x1805, "Test LOCAL_ErrorCodes need to be updated (A Section was added or removed)"); TEST_F(PUBLIC_ENUMS, LOCAL_ErrorCodes) { const uint32 SIZE_VARIA = 4; // SUCCESS + CANCELED + CANCELED_SUSPENDED_MODE + UNDEFINED const uint32 SIZE_CORE = Errors::CORE_END_SECTION_GUARD - Errors::GENERIC_FAILURE; const uint32 SIZE_SERVICE = Errors::SERVICE_END_SECTION_GUARD - Errors::SERVICE_INVALID_PARAMETER; const uint32 SIZE_HTTP = Errors::HTTP_END_SECTION_GUARD - Errors::HTTP_ENGINE_THREAD_FAILURE; const uint32 SIZE_SSL = Errors::SSL_END_SECTION_GUARD - Errors::SSL_GENERIC_FAILURE; const uint32 SIZE_AUTH = Errors::AUTH_END_SECTION_GUARD - Errors::AUTH_GENERIC_FAILURE; const uint32 SIZE_APPLICATION = Errors::APPLICATION_END_SECTION_GUARD - Errors::APPLICATION_GENERIC_FAILURE; const uint32 SIZE_CLUB = Errors::CLUB_END_SECTION_GUARD - Errors::CLUB_GENERIC_FAILURE; const uint32 SIZE_FRIEND = Errors::FRIEND_END_SECTION_GUARD - Errors::FRIEND_GENERIC_FAILURE; const uint32 SIZE_FRD_CONSOLE = Errors::FRIEND_CONSOLE_END_SECTION_GUARD - Errors::FRIEND_CONSOLE_GENERIC_FAILURE; const uint32 SIZE_PARAMETERS = Errors::PARAMETERS_END_SECTION_GUARD - Errors::PARAMETERS_GENERIC_FAILURE; const uint32 SIZE_CLUB_APPLICATION = Errors::CLUB_APPLICATION_END_SECTION_GUARD - Errors::CLUB_APPLICATION_GENERIC_FAILURE; const uint32 SIZE_OVERLAY = Errors::OVERLAY_END_SECTION_GUARD - Errors::OVERLAY_GENERIC_FAILURE; const uint32 SIZE_ENTITIES = Errors::ENTITIES_END_SECTION_GUARD - Errors::ENTITIES_GENERIC_FAILURE; const uint32 SIZE_PROFILES = Errors::PROFILES_END_SECTION_GUARD - Errors::PROFILES_GENERIC_FAILURE; const uint32 SIZE_CONNECTION = Errors::CONNECTION_END_SECTION_GUARD - Errors::CONNECTION_GENERIC_FAILURE; const uint32 SIZE_NOTIFICATION = Errors::NOTIFICATION_END_SECTION_GUARD - Errors::NOTIFICATION_GENERIC_FAILURE; const uint32 SIZE_EVENTS = Errors::EVENTS_END_SECTION_GUARD - Errors::EVENTS_GENERIC_FAILURE; const uint32 SIZE_WEBSOCKET = Errors::WEBSOCKET_END_SECTION_GUARD - Errors::WEBSOCKET_GENERIC_FAILURE; const uint32 SIZE_NEWS = Errors::NEWS_END_SECTION_GUARD - Errors::NEWS_GENERIC_FAILURE; const uint32 SIZE_SECONDARYSTORE = Errors::SECONDARYSTORE_END_SECTION_GUARD - Errors::SECONDARYSTORE_GENERIC_FAILURE; const uint32 SIZE_REMOTELOGS = Errors::REMOTELOGS_END_SECTION_GUARD - Errors::REMOTELOGS_GENERIC_FAILURE; const uint32 SIZE_USER = Errors::USERS_END_SECTION_GUARD - Errors::USERS_GENERIC_FAILURE; const uint32 SIZE_STATS = Errors::STATS_END_SECTION_GUARD - Errors::STATS_GENERIC_FAILURE; const uint32 SIZE_LEADERBOARD = Errors::LEADERBOARD_END_SECTION_GUARD - Errors::LEADERBOARD_GENERIC_FAILURE; const uint32 SIZE_PRIMARYSTORE = Errors::PRIMARYSTORE_END_SECTION_GUARD - Errors::PRIMARYSTORE_GENERIC_FAILURE; const uint32 SIZE_FIRSTPARTY = Errors::FIRST_PARTY_END_SECTION_GUARD - Errors::FIRST_PARTY_GENERIC_FAILURE; const uint32 SIZE_TLOGS = Errors::TLOGS_END_SECTION_GUARD - Errors::TLOGS_GENERIC_FAILURE; const uint32 SIZE_SECONDARYSTOREINSTANTIATION = Errors::SECONDARYSTOREINSTANTIATION_END_SECTION_GUARD - Errors::SECONDARYSTOREINSTANTIATION_GENERIC_FAILURE; const uint32 SIZE_BATTLEPASS = Errors::BATTLEPASS_END_SECTION_GUARD - Errors::BATTLEPASS_GENERIC_FAILURE; const uint32 SIZE_MODERATION = Errors::MODERATION_END_SECTION_GUARD - Errors::MODERATION_GENERIC_FAILURE; const uint32 SIZE_UGC = Errors::UGC_END_SECTION_GUARD - Errors::UGC_GENERIC_FAILURE; Set errors; uint32 incrementalSize = 0; { VALIDATE_ENUM_CODE(errors, Errors::SUCCESS); VALIDATE_ENUM_CODE(errors, Errors::CANCELED); VALIDATE_ENUM_CODE(errors, Errors::CANCELED_SUSPENDED_MODE); VALIDATE_ENUM_CODE(errors, Errors::UNDEFINED); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_VARIA, "Varia"); } { VALIDATE_ENUM_CODE(errors, Errors::GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::SKIPPED_FEATURESWITCH); VALIDATE_ENUM_CODE(errors, Errors::UBISERVICES_NOT_INITIALIZED); VALIDATE_ENUM_CODE(errors, Errors::INITIALIZATION_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::USER_CONTENT_NOT_ALLOWED); VALIDATE_ENUM_CODE(errors, Errors::UNSUPPORTED_ON_PLATFORM); VALIDATE_ENUM_CODE(errors, Errors::RESUME_INVALID_STATE); VALIDATE_ENUM_CODE(errors, Errors::SDK_STATE_TRANSITION_TO_INVALID); VALIDATE_ENUM_CODE(errors, Errors::PLATFORM_SUSPENDED); VALIDATE_ENUM_CODE(errors, Errors::PARALLEL_EXECUTION_PREVENTED); VALIDATE_ENUM_CODE(errors, Errors::CORE_INVALID_JSON_FORMAT); VALIDATE_ENUM_CODE(errors, Errors::CORE_TOO_MANY_JOBS_IN_PROGRESS); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_CORE, "Core"); } { VALIDATE_ENUM_CODE(errors, Errors::SERVICE_INVALID_PARAMETER); VALIDATE_ENUM_CODE(errors, Errors::SERVICE_INVALID_TICKET); VALIDATE_ENUM_CODE(errors, Errors::SERVICE_THROTTLED); VALIDATE_ENUM_CODE(errors, Errors::SERVICE_GATEWAY_TIMEOUT); VALIDATE_ENUM_CODE(errors, Errors::SERVICE_UNHANDLED_EXCEPTION); VALIDATE_ENUM_CODE(errors, Errors::SERVICE_GATEWAY_ERROR); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_SERVICE, "Service"); } VALIDATE_ENUM_CODE(errors, Errors::HTTP_ENGINE_THREAD_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::HTTP_REQUEST_TRANSFER_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::HTTP_REQUEST_LAUNCH_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::HTTP_REDIRECT_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::HTTP_TIMEOUT); VALIDATE_ENUM_CODE(errors, Errors::HTTP_TRANSFER_ENCODING_INVALID); VALIDATE_ENUM_CODE(errors, Errors::HTTP_STREAM_CONTEXT_INVALID); VALIDATE_ENUM_CODE(errors, Errors::HTTP_CONTENT_LENGTH_REJECTED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_USER_AGENT_REJECTED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_203_NON_AUTHORITATIVE_INFORMATION); VALIDATE_ENUM_CODE(errors, Errors::HTTP_204_NO_CONTENT); VALIDATE_ENUM_CODE(errors, Errors::HTTP_205_RESET_CONTENT); VALIDATE_ENUM_CODE(errors, Errors::HTTP_206_PARTIAL_CONTENT); VALIDATE_ENUM_CODE(errors, Errors::HTTP_226_IM_USED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_300_MULTIPLE_CHOICES); VALIDATE_ENUM_CODE(errors, Errors::HTTP_301_MOVED_PERMANENTLY); VALIDATE_ENUM_CODE(errors, Errors::HTTP_302_FOUND); VALIDATE_ENUM_CODE(errors, Errors::HTTP_303_SEE_OTHER); VALIDATE_ENUM_CODE(errors, Errors::HTTP_304_NOT_MODIFIED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_305_USE_PROXY); VALIDATE_ENUM_CODE(errors, Errors::HTTP_306_SWITCH_PROXY); VALIDATE_ENUM_CODE(errors, Errors::HTTP_307_TEMPORARY_REDIRECT); VALIDATE_ENUM_CODE(errors, Errors::HTTP_308_PERMANENT_REDIRECT); VALIDATE_ENUM_CODE(errors, Errors::HTTP_400_BAD_REQUEST); VALIDATE_ENUM_CODE(errors, Errors::HTTP_401_UNAUTHORIZED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_402_PAYMENT_REQUIRED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_403_FORBIDDEN); VALIDATE_ENUM_CODE(errors, Errors::HTTP_404_NOT_FOUND); VALIDATE_ENUM_CODE(errors, Errors::HTTP_405_NOT_ALLOWED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_406_NOT_ACCEPTABLE); VALIDATE_ENUM_CODE(errors, Errors::HTTP_407_PROXY_AUTHENTICATION_REQUIRED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_408_REQUEST_TIMEOUT); VALIDATE_ENUM_CODE(errors, Errors::HTTP_409_CONFLICT); VALIDATE_ENUM_CODE(errors, Errors::HTTP_410_GONE); VALIDATE_ENUM_CODE(errors, Errors::HTTP_411_LENGTH_REQUIRED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_412_PRECONDITION_FAILED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_413_PAYLOAD_TOO_LARGE); VALIDATE_ENUM_CODE(errors, Errors::HTTP_414_URL_TOO_LONG); VALIDATE_ENUM_CODE(errors, Errors::HTTP_415_UNSUPPORTED_MEDIA_TYPE); VALIDATE_ENUM_CODE(errors, Errors::HTTP_416_RANGE_NOT_SATISFIABLE); VALIDATE_ENUM_CODE(errors, Errors::HTTP_417_EXPECTATIONS_FAILED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_421_MISDIRECTED_REQUEST); VALIDATE_ENUM_CODE(errors, Errors::HTTP_422_UNPROCESSABLE_ENTITY); VALIDATE_ENUM_CODE(errors, Errors::HTTP_426_UPGRADE_REQUIRED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_428_PRECONDITION_REQUIRED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_429_TOO_MANY_REQUESTS); VALIDATE_ENUM_CODE(errors, Errors::HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE); VALIDATE_ENUM_CODE(errors, Errors::HTTP_444_NO_RESPONSE); VALIDATE_ENUM_CODE(errors, Errors::HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS); VALIDATE_ENUM_CODE(errors, Errors::HTTP_495_SSL_CERTIFICATE_ERROR); VALIDATE_ENUM_CODE(errors, Errors::HTTP_496_SSL_CERTIFICATE_REQUIRED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_497_HTTP_REQUEST_SENT_TO_HTTPS_PORT); VALIDATE_ENUM_CODE(errors, Errors::HTTP_499_CLIENT_CLOSED_REQUEST); VALIDATE_ENUM_CODE(errors, Errors::HTTP_500_INTERNAL_SERVER_ERROR); VALIDATE_ENUM_CODE(errors, Errors::HTTP_501_NOT_IMPLEMENTED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_502_BAD_GATEWAY); VALIDATE_ENUM_CODE(errors, Errors::HTTP_503_SERVICE_UNAVAILABLE); VALIDATE_ENUM_CODE(errors, Errors::HTTP_504_GATEWAY_TIMEOUT); VALIDATE_ENUM_CODE(errors, Errors::HTTP_505_VERSION_NOT_SUPPORTED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_506_VARIANT_ALSO_NEGOTIATES); VALIDATE_ENUM_CODE(errors, Errors::HTTP_510_NOT_EXTENDED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_511_NETWORK_AUTHENTICATION_REQUIRED); VALIDATE_ENUM_CODE(errors, Errors::HTTP_STATUS_CODE_ERROR); VALIDATE_ENUM_CODE(errors, Errors::HTTP_SIGNING_FAILURE); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_HTTP, "Http"); VALIDATE_ENUM_CODE(errors, Errors::SSL_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::SSL_CERTIFICATE_EMPTY); VALIDATE_ENUM_CODE(errors, Errors::SSL_CERTIFICATE_EXPIRED); VALIDATE_ENUM_CODE(errors, Errors::SSL_CERTIFICATE_INVALID); VALIDATE_ENUM_CODE(errors, Errors::SSL_CERTIFICATE_INVALID_SIGNATURE); VALIDATE_ENUM_CODE(errors, Errors::SSL_CERTIFICATE_INVALID_REJECTED); VALIDATE_ENUM_CODE(errors, Errors::SSL_CERTIFICATE_ULTERIOR); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_SSL, "Ssl"); VALIDATE_ENUM_CODE(errors, Errors::AUTH_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::AUTH_FETCH_CONSOLE_TICKET_TOKEN_FAILED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_SESSION_NOT_CREATED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_PLAYER_HAS_NO_UPLAY_ACCOUNT); VALIDATE_ENUM_CODE(errors, Errors::AUTH_MISSING_PARAMETER); VALIDATE_ENUM_CODE(errors, Errors::AUTH_INVALID_PARAMETER); VALIDATE_ENUM_CODE(errors, Errors::AUTH_UNAUTHORIZED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_FORBIDDEN); VALIDATE_ENUM_CODE(errors, Errors::AUTH_REDIRECT_WRONG_LOCATION); VALIDATE_ENUM_CODE(errors, Errors::AUTH_API_DEPRECATED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_INTERNAL_SERVER_ERROR); VALIDATE_ENUM_CODE(errors, Errors::AUTH_USER_THROTTLED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_IP_THROTTLED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_USER_IS_UNCONFIRMED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_USER_IS_DEACTIVATED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_USER_IS_BANNED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_USER_NEEDS_ACCEPT_LATEST_LEGAL_OPTINS); VALIDATE_ENUM_CODE(errors, Errors::AUTH_EMAIL_REQUIRED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_PASSWORD_REQUIRED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_SECURITY_CODE_NEEDED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_SECURITY_CHALLENGE_NEEDED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_FACADE_USED_BY_ANOTHER_PLAYER); VALIDATE_ENUM_CODE(errors, Errors::AUTH_SESSION_CREATION_IN_PROGRESS); VALIDATE_ENUM_CODE(errors, Errors::AUTH_ALREADY_AUTHENTICATED); VALIDATE_ENUM_CODE(errors, Errors::AUTH_REST_PERIOD); VALIDATE_ENUM_CODE(errors, Errors::AUTH_SILENT_LOGIN_UNAVAILABLE); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_AUTH, "Authentification"); VALIDATE_ENUM_CODE(errors, Errors::APPLICATION_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::APPLICATION_INVALID_PARAM); VALIDATE_ENUM_CODE(errors, Errors::APPLICATION_NOT_FOUND); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_APPLICATION, "Applications"); VALIDATE_ENUM_CODE(errors, Errors::BATTLEPASS_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::BATTLEPASS_INVALID_PARAM); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_BATTLEPASS, "Battlepass"); VALIDATE_ENUM_CODE(errors, Errors::CLUB_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::CLUB_UNKNOWN); VALIDATE_ENUM_CODE(errors, Errors::CLUB_FIELD_EMPTY); VALIDATE_ENUM_CODE(errors, Errors::CLUB_FIELD_VALUE_ALREADY_EXISTS); VALIDATE_ENUM_CODE(errors, Errors::CLUB_INVALID_PARAMETER); VALIDATE_ENUM_CODE(errors, Errors::CLUB_NOT_ENOUGH_UNITS); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_CLUB, "Club"); VALIDATE_ENUM_CODE(errors, Errors::FRIEND_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::FRIEND_REQUEST_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::FRIEND_INVALID_PARAM); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_FRIEND, "Friends"); VALIDATE_ENUM_CODE(errors, Errors::FRIEND_CONSOLE_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::FRIEND_CONSOLE_INVALID_CREDENTIALS); VALIDATE_ENUM_CODE(errors, Errors::FRIEND_CONSOLE_LOOKUP_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::FRIEND_CONSOLE_REQUEST_FAILURE); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_FRD_CONSOLE, "Friends console"); VALIDATE_ENUM_CODE(errors, Errors::PARAMETERS_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::PARAMETERS_MISMATCH_SPACEID); VALIDATE_ENUM_CODE(errors, Errors::PARAMETERS_MISMATCH_SPACEID_SESSION_TERMINATED); VALIDATE_ENUM_CODE(errors, Errors::PARAMETERS_INVALID_PARAMS); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_PARAMETERS, "Parameters"); VALIDATE_ENUM_CODE(errors, Errors::CLUB_APPLICATION_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::CLUB_APPLICATION_INVALID_PARAM); VALIDATE_ENUM_CODE(errors, Errors::CLUB_APPLICATION_NOT_INITIALIZED); VALIDATE_ENUM_CODE(errors, Errors::CLUB_APPLICATION_NOT_RUNNING); VALIDATE_ENUM_CODE(errors, Errors::CLUB_APPLICATION_ALREADY_CLOSED); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_CLUB_APPLICATION, "Club application"); VALIDATE_ENUM_CODE(errors, Errors::OVERLAY_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::OVERLAY_JOTUN_NOT_INITIALIZED); VALIDATE_ENUM_CODE(errors, Errors::OVERLAY_JOTUN_MISSING_CONTEXT); VALIDATE_ENUM_CODE(errors, Errors::OVERLAY_JOTUN_SESSION_NOT_INITIALIZED); VALIDATE_ENUM_CODE(errors, Errors::OVERLAY_JOTUN_SESSION_INIT_TIMEOUT); VALIDATE_ENUM_CODE(errors, Errors::OVERLAY_JOTUN_SESSION_INIT_FAILED); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_OVERLAY, "Overlay"); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_TOO_LARGE); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_OUT_OF_SYNC); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_INVALID_PARAM); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_EXTENDED_STORAGE_NOT_FOUND); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_EXTENDED_STORAGE_UNMATCHED); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_SPACE_MAX_COUNT_REACHED); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_CONFIGURATION_MISSING); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_TYPE_MISSING); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_CANNOT_EXCEED_MAX_TAGS_PER_ENTITY); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_INVALID_TAG); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_CANNOT_EXCEED_MAX_COUNT_PER_TYPE); VALIDATE_ENUM_CODE(errors, Errors::ENTITIES_CANNOT_BE_EDIT_BY_PLAYER); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_ENTITIES, "Entities"); VALIDATE_ENUM_CODE(errors, Errors::PROFILES_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::PROFILES_REQUEST_ID_FROM_UPLAY_GUID_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::PROFILES_INVALID_PARAM); VALIDATE_ENUM_CODE(errors, Errors::PROFILES_CANNOT_ACCESS_OTHER_PROFILETYPES); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_PROFILES, "Profiles"); VALIDATE_ENUM_CODE(errors, Errors::CONNECTION_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::CONNECTION_INVALID_PARAM); VALIDATE_ENUM_CODE(errors, Errors::CONNECTION_ALREADY_CONNECTED); VALIDATE_ENUM_CODE(errors, Errors::CONNECTION_SERVICE_UNAVAILABLE); VALIDATE_ENUM_CODE(errors, Errors::CONNECTION_CONNECTIONID_TIMEOUT); VALIDATE_ENUM_CODE(errors, Errors::CONNECTION_TOO_MANY_CONNECTIONS); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_CONNECTION, "Connection"); VALIDATE_ENUM_CODE(errors, Errors::NOTIFICATION_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::NOTIFICATION_NO_RECIPIENTS_SPECIFIED); VALIDATE_ENUM_CODE(errors, Errors::NOTIFICATION_SEND_FAILED); VALIDATE_ENUM_CODE(errors, Errors::NOTIFICATION_UNSUPPORTED_PROTOCOL); VALIDATE_ENUM_CODE(errors, Errors::NOTIFICATION_CHANNEL_DOES_NOT_EXIST); VALIDATE_ENUM_CODE(errors, Errors::NOTIFICATION_UNSUPPORTED_TYPE); VALIDATE_ENUM_CODE(errors, Errors::NOTIFICATION_INVALID_PARAMETER); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_NOTIFICATION, "Notification"); VALIDATE_ENUM_CODE(errors, Errors::USERS_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::USERS_UNABLE_TO_RENEW_CREDENTIALS); VALIDATE_ENUM_CODE(errors, Errors::USERS_PROFILE_ALREADY_LINKED); VALIDATE_ENUM_CODE(errors, Errors::USERS_INVALID_PARAM); VALIDATE_ENUM_CODE(errors, Errors::USERS_PASSWORD_FILLED_BUT_GENERATION_REQUESTED); VALIDATE_ENUM_CODE(errors, Errors::USERS_REQUEST_USERS_BATCH_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::USERS_OPT_IN_INVALID_KEY); VALIDATE_ENUM_CODE(errors, Errors::USERS_PROFILE_ALREADY_AUTHENTICATED); VALIDATE_ENUM_CODE(errors, Errors::USERS_THIRD_PARTY_SERVER_NOT_RESPONDING); VALIDATE_ENUM_CODE(errors, Errors::USERS_EXTERNAL_PROFILE_NOT_LINKED); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_USER, "User"); VALIDATE_ENUM_CODE(errors, Errors::EVENTS_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::EVENTS_INVALID_JSON); VALIDATE_ENUM_CODE(errors, Errors::EVENTS_MESSAGE_QUEUE_ERROR); VALIDATE_ENUM_CODE(errors, Errors::EVENTS_PAYLOAD_TOO_LARGE); VALIDATE_ENUM_CODE(errors, Errors::EVENTS_CONFIGURATION_ERROR); VALIDATE_ENUM_CODE(errors, Errors::EVENTS_POP_END_OF_GAME_CALLED); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_EVENTS, "Events"); VALIDATE_ENUM_CODE(errors, Errors::WEBSOCKET_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::WEBSOCKET_INVALID_CONNECTION); VALIDATE_ENUM_CODE(errors, Errors::WEBSOCKET_CONNECTION_FAILED); VALIDATE_ENUM_CODE(errors, Errors::WEBSOCKET_DISCONNECTED); VALIDATE_ENUM_CODE(errors, Errors::WEBSOCKET_WRITE_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::WEBSOCKET_READ_FAILURE); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_WEBSOCKET, "Websocket"); VALIDATE_ENUM_CODE(errors, Errors::NEWS_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::NEWS_INVALID_PARAM); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_NEWS, "News"); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTORE_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTORE_INVALID_PARAM); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTORE_TOO_MANY_IDS); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTORE_SOURCE_INSUFFICIENT_ITEMS); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTORE_TARGET_INSUFFICIENT_ITEMS); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTORE_RESOURCE_NOT_UP_TO_DATE); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTORE_CANNOT_EXCEED_INVENTORY_ITEM_LIMIT); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTORE_EXPECTED_TRANSACTION_MISMATCH); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTORE_OFFER_NOT_APPLICABLE); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTORE_TOO_MANY_FILTERS); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTORE_COMPRESSED_ITEMS_DIGEST_ERROR); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTORE_COMPRESSED_ITEMS_OUTDATED); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_SECONDARYSTORE, "SecondaryStore"); VALIDATE_ENUM_CODE(errors, Errors::REMOTELOGS_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::REMOTELOGS_INVALID_URL); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_REMOTELOGS, "RemoteLogs"); VALIDATE_ENUM_CODE(errors, Errors::STATS_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::STATS_INVALID_PARAM); VALIDATE_ENUM_CODE(errors, Errors::STATS_INVALID_PERIOD); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_STATS, "Stats"); VALIDATE_ENUM_CODE(errors, Errors::LEADERBOARD_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::LEADERBOARD_INVALID_PARAM); VALIDATE_ENUM_CODE(errors, Errors::LEADERBOARD_TOO_MANY_IDS); VALIDATE_ENUM_CODE(errors, Errors::LEADERBOARD_RESOURCE_NOT_FOUND); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_LEADERBOARD, "Leaderboard"); VALIDATE_ENUM_CODE(errors, Errors::PRIMARYSTORE_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::PRIMARYSTORE_GET_CATALOG_FAILED); VALIDATE_ENUM_CODE(errors, Errors::PRIMARYSTORE_GET_CATALOG_DETAILS_FAILED); VALIDATE_ENUM_CODE(errors, Errors::PRIMARYSTORE_GET_INVENTORY_FAILED); VALIDATE_ENUM_CODE(errors, Errors::PRIMARYSTORE_GET_INSTALLED_PACKAGES_FAILED); VALIDATE_ENUM_CODE(errors, Errors::PRIMARYSTORE_PRODUCT_ALREADY_IN_INVENTORY); VALIDATE_ENUM_CODE(errors, Errors::PRIMARYSTORE_SECONDARYSTORE_SYNC_FAILED); VALIDATE_ENUM_CODE(errors, Errors::PRIMARYSTORE_INVALID_PARAMS); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_PRIMARYSTORE, "PrimaryStore"); VALIDATE_ENUM_CODE(errors, Errors::FIRST_PARTY_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::FIRST_PARTY_NO_PLAYER_SIGNED_IN); VALIDATE_ENUM_CODE(errors, Errors::FIRST_PARTY_PLAYER_CONTEXT_INVALID); VALIDATE_ENUM_CODE(errors, Errors::FIRST_PARTY_STORED_CREDENTIAL_INVALID); VALIDATE_ENUM_CODE(errors, Errors::FIRST_PARTY_PRODUCT_ID_MISSING_IN_SDK_CONFIG); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_FIRSTPARTY, "FirstParty"); VALIDATE_ENUM_CODE(errors, Errors::TLOGS_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::TLOGS_INVALID_URL); VALIDATE_ENUM_CODE(errors, Errors::TLOGS_INVALID_JSON_IN_RESPONSE); VALIDATE_ENUM_CODE(errors, Errors::TLOGS_INVALID_APPLICATION_KEY); VALIDATE_ENUM_CODE(errors, Errors::TLOGS_INVALID_APPLICATION_ID); VALIDATE_ENUM_CODE(errors, Errors::TLOGS_INVALID_APPLICATION_NAME); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_TLOGS, "TLogs"); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTOREINSTANTIATION_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTOREINSTANTIATION_INVALID_PARAM); VALIDATE_ENUM_CODE(errors, Errors::SECONDARYSTOREINSTANTIATION_TOO_MANY_IDS); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_SECONDARYSTOREINSTANTIATION, "Secondary Store Instantiation"); VALIDATE_ENUM_CODE(errors, Errors::MODERATION_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::MODERATION_INVALID_PARAM); VALIDATE_ENUM_CODE(errors, Errors::MODERATION_METHOD_NOT_ALLOWED); VALIDATE_ENUM_CODE(errors, Errors::MODERATION_NO_CONFIGURATION_AVAILABLE); VALIDATE_ENUM_CODE(errors, Errors::MODERATION_PERMISSION_ERROR); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_MODERATION, "Moderation"); VALIDATE_ENUM_CODE(errors, Errors::UGC_GENERIC_FAILURE); VALIDATE_ENUM_CODE(errors, Errors::UGC_INVALID_PARAM); VALIDATE_ENUM_CODE(errors, Errors::UGC_TOO_MANY_IDS); VALIDATE_ENUM_CODE(errors, Errors::UGC_TITLE_SEARCH_FILTER_TOO_SHORT); VALIDATE_ENUM_SIZE(errors.size(), incrementalSize, SIZE_UGC, "Ugc"); EXPECT_EQ(Errors::UGC_END_SECTION_GUARD + 1, Errors::ERROR_END_GUARD) << "There might be a new section added after the previous section, Make sure it is available in this test."; } US_STATIC_ASSERT(static_cast(Environment::ENUM_COUNT) == 4, "LOCAL_UbiServices needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_UbiServices) { Set environments; VALIDATE_ENUM_CODE(environments, Environment::Dev); VALIDATE_ENUM_CODE(environments, Environment::Uat); VALIDATE_ENUM_CODE(environments, Environment::Cert2); VALIDATE_ENUM_CODE(environments, Environment::Prod); EXPECT_EQ(static_cast(Environment::ENUM_COUNT), environments.size()); } US_STATIC_ASSERT(Json::ENUM_COUNT == 2, "LOCAL_Json needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_Json) { Set types; VALIDATE_ENUM_CODE(types, Json::Unformatted); VALIDATE_ENUM_CODE(types, Json::Formatted); EXPECT_EQ(Json::ENUM_COUNT, types.size()); } US_STATIC_ASSERT(JsonWriter::ENUM_COUNT == 2, "LOCAL_JsonWriter needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_JsonWriter) { Set types; VALIDATE_ENUM_CODE(types, JsonWriter::Unformatted); VALIDATE_ENUM_CODE(types, JsonWriter::Formatted); EXPECT_EQ(JsonWriter::ENUM_COUNT, types.size()); } US_STATIC_ASSERT(static_cast(FeatureSwitchId::ENUM_COUNT) == 51, "LOCAL_FeatureSwitch needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_FeatureSwitch) { Set values; EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, ApplicationInformation); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, ApplicationUsed); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, Battlepass); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, ClubApplication); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, ClubDynamicPanel); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, ClubService); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, ConfigurationUpdateOnResumingFromSuspended); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, CreateSession); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, EntitiesProfile); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, EntitiesSpace); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, Event); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, ExtendSession); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, FirstPartyAccessToMultiplayerInformation); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, FriendsLookup); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, FriendsRequest); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, FriendsUplayProfile); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, HttpClient); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, LeaderboardMe); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, LeaderboardProfiles); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, LeaderboardSpaces); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, Moderation); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, News); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, NotificationDynamicUpdate); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, NotificationRequestConnections); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, NotificationSend); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, NotificationSendBatch); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, NotificationSendNoBroker); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, NotificationWebsocket); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, NotificationRemoteLogReceivedData); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, Parameters); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, Populations); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, PopulationsAutomaticUpdate); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, PrimarySecondaryStoreForceSyncAtLogin); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, PrimaryStore); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, PrimaryStoreAutomaticFetch); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, PrimaryStoreCatalogGetGameMediaType); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, PrimaryStoreSendEvent); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, Profiles); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, SecondaryStore); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, SecondaryStoreInstantiation); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, SecondaryStoreTransactions); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, SessionTicket); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, Stats); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, SyncOnResumeToForegroundForNintendoSwitch); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, TerminateSessionOnConfigurationUpdateMismatchSpaceId); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, TLog); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, Ugc); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, Users); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, UsersCreateAndLink); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, UsersLegalOptins); EXPECT_ENUM_MATCHING2(values, FeatureSwitchId, WebSocketClient); EXPECT_EQ(static_cast(FeatureSwitchId::ENUM_COUNT), values.size()); } TEST_F(PUBLIC_ENUMS, LOCAL_HttpMethod) { Set values; VALIDATE_ENUM_CODE(values, HttpMethod::HTTP_GET); VALIDATE_ENUM_CODE(values, HttpMethod::HTTP_POST); VALIDATE_ENUM_CODE(values, HttpMethod::HTTP_PUT); VALIDATE_ENUM_CODE(values, HttpMethod::HTTP_HEAD); VALIDATE_ENUM_CODE(values, HttpMethod::HTTP_DELETE); VALIDATE_ENUM_CODE(values, HttpMethod::HTTP_PATCH); EXPECT_EQ(static_cast(HttpMethod::ENUM_COUNT), values.size()); } TEST_F(PUBLIC_ENUMS, LOCAL_Logging) { { Set values; EXPECT_ENUM_MATCHING2(values, LogLevel, Debug); EXPECT_ENUM_MATCHING2(values, LogLevel, Info); EXPECT_ENUM_MATCHING2(values, LogLevel, Warning); EXPECT_ENUM_MATCHING2(values, LogLevel, Error); EXPECT_ENUM_MATCHING2(values, LogLevel, Critical); EXPECT_ENUM_MATCHING2(values, LogLevel, Always); EXPECT_EQ(static_cast(LogLevel::ENUM_COUNT), values.size()); } { Set values; EXPECT_ENUM_MATCHING2(values, LogCategory, Async); EXPECT_ENUM_MATCHING2(values, LogCategory, ApplicationInformation); EXPECT_ENUM_MATCHING2(values, LogCategory, ApplicationUsed); EXPECT_ENUM_MATCHING2(values, LogCategory, Authentication); EXPECT_ENUM_MATCHING2(values, LogCategory, Battlepass); EXPECT_ENUM_MATCHING2(values, LogCategory, Club); EXPECT_ENUM_MATCHING2(values, LogCategory, Connection); EXPECT_ENUM_MATCHING2(values, LogCategory, Core); EXPECT_ENUM_MATCHING2(values, LogCategory, CoreNotification); EXPECT_ENUM_MATCHING2(values, LogCategory, Entity); EXPECT_ENUM_MATCHING2(values, LogCategory, Event); EXPECT_ENUM_MATCHING2(values, LogCategory, Friend); EXPECT_ENUM_MATCHING2(values, LogCategory, Http); EXPECT_ENUM_MATCHING2(values, LogCategory, HttpEngine); EXPECT_ENUM_MATCHING2(values, LogCategory, Job); EXPECT_ENUM_MATCHING2(values, LogCategory, Leaderboard); EXPECT_ENUM_MATCHING2(values, LogCategory, Localization); EXPECT_ENUM_MATCHING2(values, LogCategory, Moderation); EXPECT_ENUM_MATCHING2(values, LogCategory, News); EXPECT_ENUM_MATCHING2(values, LogCategory, Notification); EXPECT_ENUM_MATCHING2(values, LogCategory, Overlay); EXPECT_ENUM_MATCHING2(values, LogCategory, Parameters); EXPECT_ENUM_MATCHING2(values, LogCategory, Population); EXPECT_ENUM_MATCHING2(values, LogCategory, PrimaryStore); EXPECT_ENUM_MATCHING2(values, LogCategory, Profile); EXPECT_ENUM_MATCHING2(values, LogCategory, RemoteLog); EXPECT_ENUM_MATCHING2(values, LogCategory, Scheduler); EXPECT_ENUM_MATCHING2(values, LogCategory, SecondaryStore); EXPECT_ENUM_MATCHING2(values, LogCategory, SecondaryStoreInstantiation); EXPECT_ENUM_MATCHING2(values, LogCategory, Task); EXPECT_ENUM_MATCHING2(values, LogCategory, Test); EXPECT_ENUM_MATCHING2(values, LogCategory, TLog); EXPECT_ENUM_MATCHING2(values, LogCategory, User); EXPECT_ENUM_MATCHING2(values, LogCategory, UserContent); EXPECT_ENUM_MATCHING2(values, LogCategory, Ugc); EXPECT_ENUM_MATCHING2(values, LogCategory, Websocket); EXPECT_ENUM_MATCHING2(values, LogCategory, Stats); EXPECT_EQ(static_cast(LogCategory::ENUM_COUNT), values.size()); } { Set values; VALIDATE_ENUM_CODE(values, EnableScope::NotDisablingOther); VALIDATE_ENUM_CODE(values, EnableScope::DisablingOthers); EXPECT_EQ(static_cast(EnableScope::ENUM_COUNT), values.size()); } { Set values; VALIDATE_ENUM_CODE(values, DisableScope::NotEnablingOthers); VALIDATE_ENUM_CODE(values, DisableScope::EnablingOthers); EXPECT_EQ(static_cast(DisableScope::ENUM_COUNT), values.size()); } { Set values; VALIDATE_ENUM_CODE(values, OutputFormat::TraceCount); VALIDATE_ENUM_CODE(values, OutputFormat::ThreadId); VALIDATE_ENUM_CODE(values, OutputFormat::Time); VALIDATE_ENUM_CODE(values, OutputFormat::ProfileId); EXPECT_EQ(OutputFormat::ENUM_COUNT, values.size()); } } US_STATIC_ASSERT(ResultRange::DEFAULT_SIZE == 20, ""); TEST_F(PUBLIC_ENUMS, LOCAL_Friends) { { Set values; VALIDATE_ENUM_CODE(values, FriendInfoClub::NoRelationship); VALIDATE_ENUM_CODE(values, FriendInfoClub::PendingSentInvite); VALIDATE_ENUM_CODE(values, FriendInfoClub::PendingReceivedInvite); VALIDATE_ENUM_CODE(values, FriendInfoClub::Friends); VALIDATE_ENUM_CODE(values, FriendInfoClub::Unknown); EXPECT_EQ(FriendInfoClub::ENUM_COUNT, values.size()); } } TEST_F(PUBLIC_ENUMS, LOCAL_ClubProfile) { Set values; VALIDATE_ENUM_CODE(values, RewardInfo::Downloadable); VALIDATE_ENUM_CODE(values, RewardInfo::Unlockable); VALIDATE_ENUM_CODE(values, RewardInfo::UnlockableSecondaryStore); EXPECT_EQ(RewardInfo::ENUM_COUNT, values.size()); } #if !defined(US_TARGET_XONE) && !defined(US_TARGET_MANJARO) US_STATIC_ASSERT(static_cast(ClubDisplayMode::ENUM_COUNT) == 3u, "LOCAL_WebBrowserDisplayMode needs to be updated"); #else US_STATIC_ASSERT(static_cast(ClubDisplayMode::ENUM_COUNT) == 2u, "LOCAL_WebBrowserDisplayMode needs to be updated"); #endif TEST_F(PUBLIC_ENUMS, LOCAL_WebBrowserDisplayMode) { Set values; VALIDATE_ENUM_CODE(values, ClubDisplayMode::Default); VALIDATE_ENUM_CODE(values, ClubDisplayMode::FullScreen); #if !defined(US_TARGET_XONE) && !defined(US_TARGET_MANJARO) VALIDATE_ENUM_CODE(values, ClubDisplayMode::Smart); #endif EXPECT_EQ(static_cast(ClubDisplayMode::ENUM_COUNT), values.size()); } US_STATIC_ASSERT(static_cast(ClubDisplayContext::ENUM_COUNT) == 2u, "LOCAL_ClubDisplayContext needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_ClubDisplayContext) { Set clubDisplayContexts; VALIDATE_ENUM_CODE(clubDisplayContexts, ClubDisplayContext::InGame); VALIDATE_ENUM_CODE(clubDisplayContexts, ClubDisplayContext::TosReaccept); EXPECT_EQ(static_cast(ClubDisplayContext::ENUM_COUNT), clubDisplayContexts.size()); } US_STATIC_ASSERT(static_cast(ClubDisplayDebugInfo::ENUM_COUNT) == 2u, "LOCAL_ClubDisplayDebugInfo needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_ClubDisplayDebugInfo) { Set clubDisplayDebugInfos; VALIDATE_ENUM_CODE(clubDisplayDebugInfos, ClubDisplayDebugInfo::NoDebugInfo); VALIDATE_ENUM_CODE(clubDisplayDebugInfos, ClubDisplayDebugInfo::ShowDebugInfo); EXPECT_EQ(static_cast(ClubDisplayDebugInfo::ENUM_COUNT), clubDisplayDebugInfos.size()); } US_STATIC_ASSERT(static_cast(ModerationSeverityType::ENUM_COUNT) == 5u, "LOCAL_ModerationSeverity needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_ModerationSeverity) { Set types; VALIDATE_ENUM_CODE(types, ModerationSeverityType::Undefined); VALIDATE_ENUM_CODE(types, ModerationSeverityType::Mild); VALIDATE_ENUM_CODE(types, ModerationSeverityType::Medium); VALIDATE_ENUM_CODE(types, ModerationSeverityType::High); VALIDATE_ENUM_CODE(types, ModerationSeverityType::Severe); EXPECT_EQ(static_cast(ModerationSeverityType::ENUM_COUNT), types.size()); } TEST_F(PUBLIC_ENUMS, LOCAL_User) { Set codes; VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::MissingParameter); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::InvalidParameter); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::Unauthorized); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::Forbidden); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::ApiDeprecated); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::CannotFulFillRequest); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::InternalServerError); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::EmailRequired); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::EmailWrongFormat); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::EmailNotAvailable); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::PasswordRequired); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::PasswordWrongFormat); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::CountryRequired); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::CountryWrongFormat); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::AgeInformationRequired); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::DateOfBirthInvalid); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::NameOnPlatformWrongFormat); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::NameOnPlatformNotAvailable); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::NameOnPlatformWithinPassword); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::UseOfRestrictedWord); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::FirstNameWrongFormat); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::LastNameWrongFormat); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::UserUnderAge); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::LanguageWrongFormat); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::PasswordTooWeak); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::UserThrottled); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::IPThrottled); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::UserIsUnconfirmed); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::UserIsDeactivated); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::UserIsBanned); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::UserNeedsToAcceptLatestLegalOptins); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::AccountIsAlreadyActivated); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::LegalOptinsKeyRequired); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::LegalOptinsKeyInvalid); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::ProfileNotLinked); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::SecurityCodeNeeded); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::SecurityChallengeNeeded); VALIDATE_ENUM_CODE(codes, UserInfoErrorCode::PasswordFilledButGenerationRequested); EXPECT_EQ(38u, codes.size()); } TEST_F(PUBLIC_ENUMS, LOCAL_PushEventResult) { Set pushEventResultSet; VALIDATE_ENUM_CODE(pushEventResultSet, PushEventResult::Success); VALIDATE_ENUM_CODE(pushEventResultSet, PushEventResult::ContextCreationInvalid); VALIDATE_ENUM_CODE(pushEventResultSet, PushEventResult::ContextCreationButAlreadyExist); VALIDATE_ENUM_CODE(pushEventResultSet, PushEventResult::ContextDeletionButDoesNotExist); VALIDATE_ENUM_CODE(pushEventResultSet, PushEventResult::PopEndOfGameCalled); EXPECT_EQ(static_cast(PushEventResult::ENUM_COUNT), pushEventResultSet.size()); } TEST_F(PUBLIC_ENUMS, LOCAL_SubtitlesActivation) { Set subtitlesActivationResultSet; VALIDATE_ENUM_CODE(subtitlesActivationResultSet, SubtitlesActivation::Enabled); VALIDATE_ENUM_CODE(subtitlesActivationResultSet, SubtitlesActivation::Disabled); EXPECT_EQ(2u, subtitlesActivationResultSet.size()); } #if defined(US_STEAM_AUTHENTICATION) && defined(US_SDK_TEST_CHINA) US_STATIC_ASSERT(static_cast(CredentialsType::ENUM_END) == 13u, "LOCAL_CredentialsType needs to be updated"); #elif defined(US_STEAM_AUTHENTICATION) && !defined(US_SDK_TEST_CHINA) US_STATIC_ASSERT(static_cast(CredentialsType::ENUM_END) == 12u, "LOCAL_CredentialsType needs to be updated"); #elif defined(US_SDK_TEST_CHINA) && !defined(US_STEAM_AUTHENTICATION) US_STATIC_ASSERT(static_cast(CredentialsType::ENUM_END) == 12u, "LOCAL_CredentialsType needs to be updated"); #else US_STATIC_ASSERT(static_cast(CredentialsType::ENUM_END) == 11u, "LOCAL_CredentialsType needs to be updated"); #endif TEST_F(PUBLIC_ENUMS, LOCAL_CredentialsType) { Set credentialsTypes; VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::NotApplicable); VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::Facebook); VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::UbiMobile); VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::UbiServices); VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::UplayPC); VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::XblXtoken); VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::PsnAccessToken); VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::PsnAuthorizationCode); VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::RememberMe); VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::GameCenter); VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::GoogleGames); #if defined(US_STEAM_AUTHENTICATION) VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::Steam); #endif #if defined(US_SDK_TEST_CHINA) VALIDATE_ENUM_CODE(credentialsTypes, CredentialsType::WeGame); #endif EXPECT_EQ(static_cast(CredentialsType::ENUM_COUNT), credentialsTypes.size()); } TEST_F(PUBLIC_ENUMS, LOCAL_Commerce) { Set installationInfos; VALIDATE_ENUM_CODE(installationInfos, PrimaryStoreInventoryItem::InventoryItemState::Undefined); VALIDATE_ENUM_CODE(installationInfos, PrimaryStoreInventoryItem::InventoryItemState::ReadyToUse); VALIDATE_ENUM_CODE(installationInfos, PrimaryStoreInventoryItem::InventoryItemState::DownloadRequired); VALIDATE_ENUM_CODE(installationInfos, PrimaryStoreInventoryItem::InventoryItemState::LicenceRequired); EXPECT_EQ(4u, installationInfos.size()); Set itemTypes; VALIDATE_ENUM_CODE(itemTypes, PrimaryStoreItemType::Undefined); VALIDATE_ENUM_CODE(itemTypes, PrimaryStoreItemType::Consumable); VALIDATE_ENUM_CODE(itemTypes, PrimaryStoreItemType::Durable); EXPECT_EQ(3u, itemTypes.size()); } TEST_F(PUBLIC_ENUMS, LOCAL_WebSocketFrame) { Set socketFrames; VALIDATE_ENUM_CODE(socketFrames, WebSocketFrame::Text); VALIDATE_ENUM_CODE(socketFrames, WebSocketFrame::Binary); VALIDATE_ENUM_CODE(socketFrames, WebSocketFrame::CustomFrame_1); VALIDATE_ENUM_CODE(socketFrames, WebSocketFrame::CustomFrame_2); VALIDATE_ENUM_CODE(socketFrames, WebSocketFrame::CustomFrame_3); VALIDATE_ENUM_CODE(socketFrames, WebSocketFrame::CustomFrame_4); VALIDATE_ENUM_CODE(socketFrames, WebSocketFrame::CustomFrame_5); EXPECT_EQ(7u, socketFrames.size()); } US_STATIC_ASSERT(static_cast(EventType::ENUM_COUNT) == 18u, "LOCAL_EventType needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_EventType) { Set eventTypes; VALIDATE_ENUM_CODE(eventTypes, EventType::PlayerAchievement); VALIDATE_ENUM_CODE(eventTypes, EventType::GameStart); VALIDATE_ENUM_CODE(eventTypes, EventType::GameSuspendedStart); VALIDATE_ENUM_CODE(eventTypes, EventType::GameSuspendedStop); VALIDATE_ENUM_CODE(eventTypes, EventType::HardwareSpecs); VALIDATE_ENUM_CODE(eventTypes, EventType::PlayerStart); VALIDATE_ENUM_CODE(eventTypes, EventType::PlayerStop); VALIDATE_ENUM_CODE(eventTypes, EventType::ContextStart); VALIDATE_ENUM_CODE(eventTypes, EventType::ContextStop); VALIDATE_ENUM_CODE(eventTypes, EventType::GameLocalization); VALIDATE_ENUM_CODE(eventTypes, EventType::PlayerProgression); VALIDATE_ENUM_CODE(eventTypes, EventType::PlayerPosition); VALIDATE_ENUM_CODE(eventTypes, EventType::PlayerPrimaryStore); VALIDATE_ENUM_CODE(eventTypes, EventType::PlayerNewsAction); VALIDATE_ENUM_CODE(eventTypes, EventType::PlayerNewsImpression); VALIDATE_ENUM_CODE(eventTypes, EventType::PlayerStatsPlayTime); VALIDATE_ENUM_CODE(eventTypes, EventType::Custom); VALIDATE_ENUM_CODE(eventTypes, EventType::Service); EXPECT_EQ(static_cast(EventType::ENUM_COUNT), eventTypes.size()); } US_STATIC_ASSERT(static_cast(NotificationUbiServicesType::ENUM_COUNT) == 7u, "LOCAL_NotificationUbiservices needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_NotificationUbiservices) { Set notificationTypes; VALIDATE_ENUM_CODE(notificationTypes, NotificationUbiServicesType::None); VALIDATE_ENUM_CODE(notificationTypes, NotificationUbiServicesType::Unknown); VALIDATE_ENUM_CODE(notificationTypes, NotificationUbiServicesType::NotificationConnect); VALIDATE_ENUM_CODE(notificationTypes, NotificationUbiServicesType::NotificationDisconnect); VALIDATE_ENUM_CODE(notificationTypes, NotificationUbiServicesType::NotificationMaintenancePending); VALIDATE_ENUM_CODE(notificationTypes, NotificationUbiServicesType::NotificationMaintenanceStart); VALIDATE_ENUM_CODE(notificationTypes, NotificationUbiServicesType::NotificationMaintenanceEnd); EXPECT_EQ(static_cast(NotificationUbiServicesType::ENUM_COUNT), notificationTypes.size()); } US_STATIC_ASSERT(static_cast(AuthenticationNotificationType::ENUM_COUNT) == 5u, "LOCAL_NotificationUbiservices needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_AuthenticationNotification) { Set notificationTypes; VALIDATE_ENUM_CODE(notificationTypes, AuthenticationNotificationType::None); VALIDATE_ENUM_CODE(notificationTypes, AuthenticationNotificationType::Unknown); VALIDATE_ENUM_CODE(notificationTypes, AuthenticationNotificationType::SessionInfoChanged); VALIDATE_ENUM_CODE(notificationTypes, AuthenticationNotificationType::SessionExtensionFailed); VALIDATE_ENUM_CODE(notificationTypes, AuthenticationNotificationType::SessionConfigurationUpdateMismatchSpaceIDSessionTerminated); EXPECT_EQ(static_cast(AuthenticationNotificationType::ENUM_COUNT), notificationTypes.size()); } US_STATIC_ASSERT(static_cast(ParametersNotificationType::ENUM_COUNT) == 7u, "LOCAL_ConfigurationNotification needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_ConfigurationNotification) { Set notificationTypes; VALIDATE_ENUM_CODE(notificationTypes, ParametersNotificationType::None); VALIDATE_ENUM_CODE(notificationTypes, ParametersNotificationType::Unknown); VALIDATE_ENUM_CODE(notificationTypes, ParametersNotificationType::ApplicationParametersUpdated); VALIDATE_ENUM_CODE(notificationTypes, ParametersNotificationType::ApplicationParametersUpdatedPartially); VALIDATE_ENUM_CODE(notificationTypes, ParametersNotificationType::SpaceParametersUpdated); VALIDATE_ENUM_CODE(notificationTypes, ParametersNotificationType::ApplicationParametersGroupUpdated); VALIDATE_ENUM_CODE(notificationTypes, ParametersNotificationType::SpaceParametersGroupUpdated); EXPECT_EQ(static_cast(ParametersNotificationType::ENUM_COUNT), notificationTypes.size()); } US_STATIC_ASSERT(static_cast(StatFormatType::ENUM_COUNT) == 7u, "LOCAL_FormatType needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_FormatType) { Set formatTypes; VALIDATE_ENUM_CODE(formatTypes, StatFormatType::String); VALIDATE_ENUM_CODE(formatTypes, StatFormatType::Integer); VALIDATE_ENUM_CODE(formatTypes, StatFormatType::Decimal); VALIDATE_ENUM_CODE(formatTypes, StatFormatType::Currency); VALIDATE_ENUM_CODE(formatTypes, StatFormatType::Percentage); VALIDATE_ENUM_CODE(formatTypes, StatFormatType::ShortTimespan); VALIDATE_ENUM_CODE(formatTypes, StatFormatType::LongTimespan); EXPECT_EQ(static_cast(StatFormatType::ENUM_COUNT), formatTypes.size()); } US_STATIC_ASSERT(static_cast(StatSemanticType::ENUM_COUNT) == 3u, "LOCAL_SemanticType needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_SemanticType) { Set semanticTypes; VALIDATE_ENUM_CODE(semanticTypes, StatSemanticType::Cumulative); VALIDATE_ENUM_CODE(semanticTypes, StatSemanticType::Tier); VALIDATE_ENUM_CODE(semanticTypes, StatSemanticType::Best); EXPECT_EQ(static_cast(StatSemanticType::ENUM_COUNT), semanticTypes.size()); } US_STATIC_ASSERT(static_cast(StatSortType::ENUM_COUNT) == 2u, "LOCAL_SortType needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_SortType) { Set sortTypes; VALIDATE_ENUM_CODE(sortTypes, StatSortType::Ascending); VALIDATE_ENUM_CODE(sortTypes, StatSortType::Decending); EXPECT_EQ(static_cast(StatSortType::ENUM_COUNT), sortTypes.size()); } US_STATIC_ASSERT(static_cast(ClubNotificationType::ENUM_COUNT) == 8u, "LOCAL_ClubNotificationType needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_ClubNotificationType) { Set notification; VALIDATE_ENUM_CODE(notification, ClubNotificationType::None); VALIDATE_ENUM_CODE(notification, ClubNotificationType::BadgeAquired); VALIDATE_ENUM_CODE(notification, ClubNotificationType::ChallengeBanked); VALIDATE_ENUM_CODE(notification, ClubNotificationType::ChallengeCompleted); VALIDATE_ENUM_CODE(notification, ClubNotificationType::ChallengeParticipationStarted); VALIDATE_ENUM_CODE(notification, ClubNotificationType::ChallengeThresholdReached); VALIDATE_ENUM_CODE(notification, ClubNotificationType::ActionCompleted); VALIDATE_ENUM_CODE(notification, ClubNotificationType::RewardPurchased); EXPECT_EQ(static_cast(ClubNotificationType::ENUM_COUNT), notification.size()); } US_STATIC_ASSERT(static_cast(ClubNotificationCategory::ENUM_COUNT) == 3u, "LOCAL_ClubNotificationCategory needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_ClubNotificationCategory) { Set notification; VALIDATE_ENUM_CODE(notification, ClubNotificationCategory::Community); VALIDATE_ENUM_CODE(notification, ClubNotificationCategory::Profile); VALIDATE_ENUM_CODE(notification, ClubNotificationCategory::Season); EXPECT_EQ(static_cast(ClubNotificationCategory::ENUM_COUNT), notification.size()); } US_STATIC_ASSERT(static_cast(ChallengeType::ENUM_COUNT) == 3u, "LOCAL_ClubChallengeType needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_ClubChallengeType) { Set type; VALIDATE_ENUM_CODE(type, ChallengeType::Event); VALIDATE_ENUM_CODE(type, ChallengeType::Premium); VALIDATE_ENUM_CODE(type, ChallengeType::Regular); EXPECT_EQ(static_cast(ChallengeType::ENUM_COUNT), type.size()); } US_STATIC_ASSERT(static_cast(ChallengeOperationType::ENUM_COUNT) == 6u, "LOCAL_ClubChallengeOperationType needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_ClubChallengeOperationType) { Set type; VALIDATE_ENUM_CODE(type, ChallengeOperationType::EQ); VALIDATE_ENUM_CODE(type, ChallengeOperationType::GT); VALIDATE_ENUM_CODE(type, ChallengeOperationType::GTE); VALIDATE_ENUM_CODE(type, ChallengeOperationType::LT); VALIDATE_ENUM_CODE(type, ChallengeOperationType::LTE); VALIDATE_ENUM_CODE(type, ChallengeOperationType::Unexpected); EXPECT_EQ(static_cast(ChallengeOperationType::ENUM_COUNT), type.size()); } US_STATIC_ASSERT(static_cast(ChallengeProgressionType::ENUM_COUNT) == 3u, "LOCAL_ClubChallengeProgressionType needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_ClubChallengeProgressionType) { Set type; VALIDATE_ENUM_CODE(type, ChallengeProgressionType::Absolute); VALIDATE_ENUM_CODE(type, ChallengeProgressionType::Percentage); VALIDATE_ENUM_CODE(type, ChallengeProgressionType::Unknown); EXPECT_EQ(static_cast(ChallengeProgressionType::ENUM_COUNT), type.size()); } US_STATIC_ASSERT(static_cast(OfferElementReplacementType::ENUM_COUNT) == 2u, "LOCAL_OfferElementReplacementType needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_OfferElementReplacementType) { Set type; VALIDATE_ENUM_CODE(type, OfferElementReplacementType::AbsoluteQuantity); VALIDATE_ENUM_CODE(type, OfferElementReplacementType::Percentage); EXPECT_EQ(static_cast(OfferElementReplacementType::ENUM_COUNT), type.size()); } US_STATIC_ASSERT(static_cast(SecondaryStoreClient::FieldsRequested::ENUM_COUNT) == 2u, "LOCAL_SecondaryStoreClientFieldsRequested needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_SecondaryStoreClientFieldsRequested) { Set fieldsRequested; VALIDATE_ENUM_CODE(fieldsRequested, SecondaryStoreClient::FieldsRequested::All); VALIDATE_ENUM_CODE(fieldsRequested, SecondaryStoreClient::FieldsRequested::Metadata); EXPECT_EQ(static_cast(SecondaryStoreClient::FieldsRequested::ENUM_COUNT), fieldsRequested.size()); } US_STATIC_ASSERT(static_cast(StoreAttributeType::ENUM_COUNT) == 6u, "LOCAL_StoreAttributeType needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_StoreAttributeType) { Set storeAttributeTypes; VALIDATE_ENUM_CODE(storeAttributeTypes, StoreAttributeType::All); VALIDATE_ENUM_CODE(storeAttributeTypes, StoreAttributeType::Boolean); VALIDATE_ENUM_CODE(storeAttributeTypes, StoreAttributeType::FloatRange); VALIDATE_ENUM_CODE(storeAttributeTypes, StoreAttributeType::IntegerRange); VALIDATE_ENUM_CODE(storeAttributeTypes, StoreAttributeType::PickFromList); VALIDATE_ENUM_CODE(storeAttributeTypes, StoreAttributeType::Static); EXPECT_EQ(static_cast(StoreAttributeType::ENUM_COUNT), storeAttributeTypes.size()); } US_STATIC_ASSERT(static_cast(TLogLevel::ENUM_COUNT) == 2u, "LOCAL_TLogLevel needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_TLogLevel) { Set tlogLevel; VALIDATE_ENUM_CODE(tlogLevel, TLogLevel::Important); VALIDATE_ENUM_CODE(tlogLevel, TLogLevel::Unimportant); EXPECT_EQ(static_cast(TLogLevel::ENUM_COUNT), tlogLevel.size()); } US_STATIC_ASSERT(static_cast(ProfileType::ENUM_COUNT) == 12u, "LOCAL_ProfileType needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_ProfileType) { Set fieldsRequested; VALIDATE_ENUM_CODE(fieldsRequested, ProfileType::GameCenter); VALIDATE_ENUM_CODE(fieldsRequested, ProfileType::GoogleGames); VALIDATE_ENUM_CODE(fieldsRequested, ProfileType::GoogleStream); VALIDATE_ENUM_CODE(fieldsRequested, ProfileType::NintendoSwitchOnline); VALIDATE_ENUM_CODE(fieldsRequested, ProfileType::Oculus); VALIDATE_ENUM_CODE(fieldsRequested, ProfileType::Owlient); VALIDATE_ENUM_CODE(fieldsRequested, ProfileType::PlaystationNetwork); VALIDATE_ENUM_CODE(fieldsRequested, ProfileType::Steam); VALIDATE_ENUM_CODE(fieldsRequested, ProfileType::Ubimobile); VALIDATE_ENUM_CODE(fieldsRequested, ProfileType::Uplay); VALIDATE_ENUM_CODE(fieldsRequested, ProfileType::Wiiu); VALIDATE_ENUM_CODE(fieldsRequested, ProfileType::XboxLive); EXPECT_EQ(static_cast(ProfileType::ENUM_COUNT), fieldsRequested.size()); } US_STATIC_ASSERT(static_cast(BattlepassNotificationType::ENUM_COUNT) == 2u, "LOCAL_BattlepassNotificationType needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_BattlepassNotificationType) { Set notification; VALIDATE_ENUM_CODE(notification, BattlepassNotificationType::None); VALIDATE_ENUM_CODE(notification, BattlepassNotificationType::TiersBanked); EXPECT_EQ(static_cast(BattlepassNotificationType::ENUM_COUNT), notification.size()); } US_STATIC_ASSERT(static_cast(UgcFavoriteStatus::ENUM_COUNT) == 2u, "LOCAL_UgcFavoriteStatus needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_UgcFavoriteStatus) { Set favoriteStatus; VALIDATE_ENUM_CODE(favoriteStatus, UgcFavoriteStatus::Favorite); VALIDATE_ENUM_CODE(favoriteStatus, UgcFavoriteStatus::NotFavorite); EXPECT_EQ(static_cast(UgcFavoriteStatus::ENUM_COUNT), favoriteStatus.size()); } TEST_F(PUBLIC_ENUMS, LOCAL_UgcRatingValue) { Set ratingValues; VALIDATE_ENUM_CODE(ratingValues, UgcRatingValue::NoRating); VALIDATE_ENUM_CODE(ratingValues, UgcRatingValue::Like); VALIDATE_ENUM_CODE(ratingValues, UgcRatingValue::Dislike); VALIDATE_ENUM_CODE(ratingValues, UgcRatingValue::UgcRating_InvalidValue); EXPECT_EQ(4u, ratingValues.size()); } US_STATIC_ASSERT(static_cast(UgcSortingBy::ENUM_COUNT) == 5u, "LOCAL_UgcSortingBy needs to be updated"); TEST_F(PUBLIC_ENUMS, LOCAL_UgcSortingBy) { Set sortingValues; VALIDATE_ENUM_CODE(sortingValues, UgcSortingBy::SortingOrderNotSet); VALIDATE_ENUM_CODE(sortingValues, UgcSortingBy::MostRecent); VALIDATE_ENUM_CODE(sortingValues, UgcSortingBy::MostFavorites); VALIDATE_ENUM_CODE(sortingValues, UgcSortingBy::HighestRating); VALIDATE_ENUM_CODE(sortingValues, UgcSortingBy::MostViews); EXPECT_EQ(static_cast(UgcSortingBy::ENUM_COUNT), sortingValues.size()); } TEST_F(PUBLIC_ENUMS, LOCAL_UgcTypeId) { Set types; VALIDATE_ENUM_CODE(types, UgcTypeId::ExternalVideo); VALIDATE_ENUM_CODE(types, UgcTypeId::UgcTypeId_InvalidValue); EXPECT_EQ(2u, types.size()); } };