dreyndev/JD2022-TU1
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
JD2022-TU1/main/extern/UbiServices/custom/testsIntegration/testPublicEnums.cpp

1146 lines
67 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
// (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 <ubiservices/core/configs/environment.h>
#include <ubiservices/core/JSON/jsonWriter.h>
#include <ubiservices/core/errors/errorCodes.h>
#include <../private/ubiservices/core/extensions/staticAssert.h>
#include <ubiservices/core/helpers/resultRange.h>
#include <ubiservices/core/log/outputFormat.h>
#include <../private/ubiservices/core/log/eventLogHelper.h>
#include <../private/ubiservices/core/types/containerspriv.h>
#include <ubiservices/facade.h>
#include <ubiservices/services/authentication/authenticationNotification.h>
#include <ubiservices/services/authentication/credentialsType.h>
#include <ubiservices/services/battlepass/battlepassNotification.h>
#include <ubiservices/services/event/eventClient.h>
#include <ubiservices/services/event/pushEventResult.h>
#include <ubiservices/services/event/subtitlesActivation.h>
#include <ubiservices/services/event/types/types.h>
#include <ubiservices/services/friend/friendInfoClub.h>
#include <ubiservices/services/http/httpMethod.h>
#include <ubiservices/services/club/badgeInfo.h>
#include <ubiservices/services/club/conditionInfo.h>
#include <ubiservices/services/club/challengeTypes.h>
#include <ubiservices/services/club/clubDisplayContext.h>
#include <ubiservices/services/club/clubDisplayDebugInfo.h>
#include <ubiservices/services/club/clubDisplayMode.h>
#include <ubiservices/services/club/clubNotification.h>
#include <ubiservices/services/club/rewardInfo.h>
#include <ubiservices/services/club/unitInfo.h>
#include <ubiservices/services/club/xpInfo.h>
#include <ubiservices/services/moderation/moderationInfo.h>
#include <ubiservices/services/notification/notificationUbiServices.h>
#include <ubiservices/services/parameters/featureSwitchId.h>
#include "ubiservices/services/parameters/parametersNotification.h"
#include <ubiservices/services/primaryStore/primaryStoreInventoryItem.h>
#include <ubiservices/services/profile/profileType.h>
#include <ubiservices/services/secondaryStore/offerElementReplacement.h>
#include <ubiservices/services/secondaryStore/secondaryStoreClient.h>
#include <ubiservices/services/secondaryStoreInstantiation/storeAttributeTypeConstants.h>
#include <ubiservices/services/stats/types.h>
#include <ubiservices/services/tLog/tLog.h>
#include <ubiservices/services/user/userInfoError.h>
#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 <ubiservices/services/websocket/websocketFrame.h>
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<uint64>(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<uint64>& enumSet, uint64 enumValue, const char* enumName)
{
return enumSet.insert(enumValue).second
? ::testing::AssertionSuccess()
: ::testing::AssertionFailure() << "Overlapping enum code: '" << enumName << "' value =" << hex << enumValue;
}
template<typename T>
static void TestEnumMatching(Set<uint64>& 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<uint64>(value), textExpected));
}
template<typename T, typename T2>
static void TestEnumMatching(Set<uint64>& 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<uint64>(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<uint64> 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<size_t>(Environment::ENUM_COUNT) == 4, "LOCAL_UbiServices needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_UbiServices)
{
Set<uint64> 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<size_t>(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<uint64> 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<uint64> 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<size_t>(FeatureSwitchId::ENUM_COUNT) == 51, "LOCAL_FeatureSwitch needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_FeatureSwitch)
{
Set<uint64> 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<size_t>(FeatureSwitchId::ENUM_COUNT), values.size());
}
TEST_F(PUBLIC_ENUMS, LOCAL_HttpMethod)
{
Set<uint64> 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<size_t>(HttpMethod::ENUM_COUNT), values.size());
}
TEST_F(PUBLIC_ENUMS, LOCAL_Logging)
{
{
Set<uint64> 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<size_t>(LogLevel::ENUM_COUNT), values.size());
}
{
Set<uint64> 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<size_t>(LogCategory::ENUM_COUNT), values.size());
}
{
Set<uint64> values;
VALIDATE_ENUM_CODE(values, EnableScope::NotDisablingOther);
VALIDATE_ENUM_CODE(values, EnableScope::DisablingOthers);
EXPECT_EQ(static_cast<size_t>(EnableScope::ENUM_COUNT), values.size());
}
{
Set<uint64> values;
VALIDATE_ENUM_CODE(values, DisableScope::NotEnablingOthers);
VALIDATE_ENUM_CODE(values, DisableScope::EnablingOthers);
EXPECT_EQ(static_cast<size_t>(DisableScope::ENUM_COUNT), values.size());
}
{
Set<uint64> 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<uint64> 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<uint64> 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<size_t>(ClubDisplayMode::ENUM_COUNT) == 3u, "LOCAL_WebBrowserDisplayMode needs to be updated");
#else
US_STATIC_ASSERT(static_cast<size_t>(ClubDisplayMode::ENUM_COUNT) == 2u, "LOCAL_WebBrowserDisplayMode needs to be updated");
#endif
TEST_F(PUBLIC_ENUMS, LOCAL_WebBrowserDisplayMode)
{
Set<uint64> 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<size_t>(ClubDisplayMode::ENUM_COUNT), values.size());
}
US_STATIC_ASSERT(static_cast<size_t>(ClubDisplayContext::ENUM_COUNT) == 2u, "LOCAL_ClubDisplayContext needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_ClubDisplayContext)
{
Set<uint64> clubDisplayContexts;
VALIDATE_ENUM_CODE(clubDisplayContexts, ClubDisplayContext::InGame);
VALIDATE_ENUM_CODE(clubDisplayContexts, ClubDisplayContext::TosReaccept);
EXPECT_EQ(static_cast<size_t>(ClubDisplayContext::ENUM_COUNT), clubDisplayContexts.size());
}
US_STATIC_ASSERT(static_cast<size_t>(ClubDisplayDebugInfo::ENUM_COUNT) == 2u, "LOCAL_ClubDisplayDebugInfo needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_ClubDisplayDebugInfo)
{
Set<uint64> clubDisplayDebugInfos;
VALIDATE_ENUM_CODE(clubDisplayDebugInfos, ClubDisplayDebugInfo::NoDebugInfo);
VALIDATE_ENUM_CODE(clubDisplayDebugInfos, ClubDisplayDebugInfo::ShowDebugInfo);
EXPECT_EQ(static_cast<size_t>(ClubDisplayDebugInfo::ENUM_COUNT), clubDisplayDebugInfos.size());
}
US_STATIC_ASSERT(static_cast<size_t>(ModerationSeverityType::ENUM_COUNT) == 5u, "LOCAL_ModerationSeverity needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_ModerationSeverity)
{
Set<uint64> 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<size_t>(ModerationSeverityType::ENUM_COUNT), types.size());
}
TEST_F(PUBLIC_ENUMS, LOCAL_User)
{
Set<uint64> 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<uint64> 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<size_t>(PushEventResult::ENUM_COUNT), pushEventResultSet.size());
}
TEST_F(PUBLIC_ENUMS, LOCAL_SubtitlesActivation)
{
Set<uint64> 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<uint32>(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<uint32>(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<uint32>(CredentialsType::ENUM_END) == 12u,
"LOCAL_CredentialsType needs to be updated");
#else
US_STATIC_ASSERT(static_cast<uint32>(CredentialsType::ENUM_END) == 11u,
"LOCAL_CredentialsType needs to be updated");
#endif
TEST_F(PUBLIC_ENUMS, LOCAL_CredentialsType)
{
Set<uint64> 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<size_t>(CredentialsType::ENUM_COUNT), credentialsTypes.size());
}
TEST_F(PUBLIC_ENUMS, LOCAL_Commerce)
{
Set<uint64> 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<uint64> 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<uint64> 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<size_t>(EventType::ENUM_COUNT) == 18u, "LOCAL_EventType needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_EventType)
{
Set<uint64> 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<size_t>(EventType::ENUM_COUNT), eventTypes.size());
}
US_STATIC_ASSERT(static_cast<size_t>(NotificationUbiServicesType::ENUM_COUNT) == 7u, "LOCAL_NotificationUbiservices needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_NotificationUbiservices)
{
Set<uint64> 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<size_t>(NotificationUbiServicesType::ENUM_COUNT), notificationTypes.size());
}
US_STATIC_ASSERT(static_cast<size_t>(AuthenticationNotificationType::ENUM_COUNT) == 5u, "LOCAL_NotificationUbiservices needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_AuthenticationNotification)
{
Set<uint64> 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<size_t>(AuthenticationNotificationType::ENUM_COUNT), notificationTypes.size());
}
US_STATIC_ASSERT(static_cast<size_t>(ParametersNotificationType::ENUM_COUNT) == 7u, "LOCAL_ConfigurationNotification needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_ConfigurationNotification)
{
Set<uint64> 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<size_t>(ParametersNotificationType::ENUM_COUNT), notificationTypes.size());
}
US_STATIC_ASSERT(static_cast<size_t>(StatFormatType::ENUM_COUNT) == 7u, "LOCAL_FormatType needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_FormatType)
{
Set<uint64> 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<size_t>(StatFormatType::ENUM_COUNT), formatTypes.size());
}
US_STATIC_ASSERT(static_cast<size_t>(StatSemanticType::ENUM_COUNT) == 3u, "LOCAL_SemanticType needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_SemanticType)
{
Set<uint64> semanticTypes;
VALIDATE_ENUM_CODE(semanticTypes, StatSemanticType::Cumulative);
VALIDATE_ENUM_CODE(semanticTypes, StatSemanticType::Tier);
VALIDATE_ENUM_CODE(semanticTypes, StatSemanticType::Best);
EXPECT_EQ(static_cast<size_t>(StatSemanticType::ENUM_COUNT), semanticTypes.size());
}
US_STATIC_ASSERT(static_cast<size_t>(StatSortType::ENUM_COUNT) == 2u, "LOCAL_SortType needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_SortType)
{
Set<uint64> sortTypes;
VALIDATE_ENUM_CODE(sortTypes, StatSortType::Ascending);
VALIDATE_ENUM_CODE(sortTypes, StatSortType::Decending);
EXPECT_EQ(static_cast<size_t>(StatSortType::ENUM_COUNT), sortTypes.size());
}
US_STATIC_ASSERT(static_cast<size_t>(ClubNotificationType::ENUM_COUNT) == 8u, "LOCAL_ClubNotificationType needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_ClubNotificationType)
{
Set<uint64> 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<size_t>(ClubNotificationType::ENUM_COUNT), notification.size());
}
US_STATIC_ASSERT(static_cast<size_t>(ClubNotificationCategory::ENUM_COUNT) == 3u, "LOCAL_ClubNotificationCategory needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_ClubNotificationCategory)
{
Set<uint64> notification;
VALIDATE_ENUM_CODE(notification, ClubNotificationCategory::Community);
VALIDATE_ENUM_CODE(notification, ClubNotificationCategory::Profile);
VALIDATE_ENUM_CODE(notification, ClubNotificationCategory::Season);
EXPECT_EQ(static_cast<size_t>(ClubNotificationCategory::ENUM_COUNT), notification.size());
}
US_STATIC_ASSERT(static_cast<size_t>(ChallengeType::ENUM_COUNT) == 3u, "LOCAL_ClubChallengeType needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_ClubChallengeType)
{
Set<uint64> type;
VALIDATE_ENUM_CODE(type, ChallengeType::Event);
VALIDATE_ENUM_CODE(type, ChallengeType::Premium);
VALIDATE_ENUM_CODE(type, ChallengeType::Regular);
EXPECT_EQ(static_cast<size_t>(ChallengeType::ENUM_COUNT), type.size());
}
US_STATIC_ASSERT(static_cast<size_t>(ChallengeOperationType::ENUM_COUNT) == 6u, "LOCAL_ClubChallengeOperationType needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_ClubChallengeOperationType)
{
Set<uint64> 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<size_t>(ChallengeOperationType::ENUM_COUNT), type.size());
}
US_STATIC_ASSERT(static_cast<size_t>(ChallengeProgressionType::ENUM_COUNT) == 3u, "LOCAL_ClubChallengeProgressionType needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_ClubChallengeProgressionType)
{
Set<uint64> type;
VALIDATE_ENUM_CODE(type, ChallengeProgressionType::Absolute);
VALIDATE_ENUM_CODE(type, ChallengeProgressionType::Percentage);
VALIDATE_ENUM_CODE(type, ChallengeProgressionType::Unknown);
EXPECT_EQ(static_cast<size_t>(ChallengeProgressionType::ENUM_COUNT), type.size());
}
US_STATIC_ASSERT(static_cast<size_t>(OfferElementReplacementType::ENUM_COUNT) == 2u, "LOCAL_OfferElementReplacementType needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_OfferElementReplacementType)
{
Set<uint64> type;
VALIDATE_ENUM_CODE(type, OfferElementReplacementType::AbsoluteQuantity);
VALIDATE_ENUM_CODE(type, OfferElementReplacementType::Percentage);
EXPECT_EQ(static_cast<size_t>(OfferElementReplacementType::ENUM_COUNT), type.size());
}
US_STATIC_ASSERT(static_cast<size_t>(SecondaryStoreClient::FieldsRequested::ENUM_COUNT) == 2u, "LOCAL_SecondaryStoreClientFieldsRequested needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_SecondaryStoreClientFieldsRequested)
{
Set<uint64> fieldsRequested;
VALIDATE_ENUM_CODE(fieldsRequested, SecondaryStoreClient::FieldsRequested::All);
VALIDATE_ENUM_CODE(fieldsRequested, SecondaryStoreClient::FieldsRequested::Metadata);
EXPECT_EQ(static_cast<size_t>(SecondaryStoreClient::FieldsRequested::ENUM_COUNT), fieldsRequested.size());
}
US_STATIC_ASSERT(static_cast<size_t>(StoreAttributeType::ENUM_COUNT) == 6u, "LOCAL_StoreAttributeType needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_StoreAttributeType)
{
Set<uint64> 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<size_t>(StoreAttributeType::ENUM_COUNT), storeAttributeTypes.size());
}
US_STATIC_ASSERT(static_cast<size_t>(TLogLevel::ENUM_COUNT) == 2u, "LOCAL_TLogLevel needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_TLogLevel)
{
Set<uint64> tlogLevel;
VALIDATE_ENUM_CODE(tlogLevel, TLogLevel::Important);
VALIDATE_ENUM_CODE(tlogLevel, TLogLevel::Unimportant);
EXPECT_EQ(static_cast<size_t>(TLogLevel::ENUM_COUNT), tlogLevel.size());
}
US_STATIC_ASSERT(static_cast<size_t>(ProfileType::ENUM_COUNT) == 12u, "LOCAL_ProfileType needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_ProfileType)
{
Set<uint64> 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<size_t>(ProfileType::ENUM_COUNT), fieldsRequested.size());
}
US_STATIC_ASSERT(static_cast<size_t>(BattlepassNotificationType::ENUM_COUNT) == 2u, "LOCAL_BattlepassNotificationType needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_BattlepassNotificationType)
{
Set<uint64> notification;
VALIDATE_ENUM_CODE(notification, BattlepassNotificationType::None);
VALIDATE_ENUM_CODE(notification, BattlepassNotificationType::TiersBanked);
EXPECT_EQ(static_cast<size_t>(BattlepassNotificationType::ENUM_COUNT), notification.size());
}
US_STATIC_ASSERT(static_cast<size_t>(UgcFavoriteStatus::ENUM_COUNT) == 2u, "LOCAL_UgcFavoriteStatus needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_UgcFavoriteStatus)
{
Set<uint64> favoriteStatus;
VALIDATE_ENUM_CODE(favoriteStatus, UgcFavoriteStatus::Favorite);
VALIDATE_ENUM_CODE(favoriteStatus, UgcFavoriteStatus::NotFavorite);
EXPECT_EQ(static_cast<size_t>(UgcFavoriteStatus::ENUM_COUNT), favoriteStatus.size());
}
TEST_F(PUBLIC_ENUMS, LOCAL_UgcRatingValue)
{
Set<uint64> 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<size_t>(UgcSortingBy::ENUM_COUNT) == 5u, "LOCAL_UgcSortingBy needs to be updated");
TEST_F(PUBLIC_ENUMS, LOCAL_UgcSortingBy)
{
Set<uint64> 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<size_t>(UgcSortingBy::ENUM_COUNT), sortingValues.size());
}
TEST_F(PUBLIC_ENUMS, LOCAL_UgcTypeId)
{
Set<uint64> types;
VALIDATE_ENUM_CODE(types, UgcTypeId::ExternalVideo);
VALIDATE_ENUM_CODE(types, UgcTypeId::UgcTypeId_InvalidValue);
EXPECT_EQ(2u, types.size());
}
};
Reference in a new issue View git blame Copy permalink