////////////////////////////////////////////////////////////////////////////////
// (c) Copyright, Ubisoft Entertainment Inc. ||  Created by Harbour Group     //
////////////////////////////////////////////////////////////////////////////////
#include "tests/common/helpers.h"
#include "tests/config.h"
#include "tests/fixture/authenticationFixture.h"
#include "tests/fixture/loginMockFixture.h"
#include "tests/mock/mockResultHelper.h"
#include "tests/mock/parametersMockHelper.h"
#include <ubiservices/core/types/dateTimeHelper.h>
#include <ubiservices/facade.h>
#include <ubiservices/services/http/request/httpGet.h>
#include <ubiservices/services/userGeneratedContents/ugcConfigs.h>
#include <ubiservices/services/userGeneratedContents/ugcContentId.h>
#include <ubiservices/services/userGeneratedContents/ugcFavorites.h>
#include "ubiservices/services/userGeneratedContents/ugcSortingBy.h"
#include <ubiservices/services/userGeneratedContents/ugcTypeId.h>
#include <ubiservices/services/userGeneratedContents/userGeneratedContentsClient.h>
#include <regex>

namespace US_NS {;

US_DEFINE_TEST(TestUserGeneratedContentsClient);

#if !defined(US_DLL)

#if defined(US_TARGET_WINDOWS)
/// Tests that are profileId related and not mocked use specifically ussdk001, on Windows, to avoid replicating the ugc setup on all test accounts.
template<uint32 facadesCount = 1, bool executeLogin = false>
class AuthenticationFixtureUgcLoginAsUssdk001 : public AuthenticationFixture < facadesCount, executeLogin >
{
public:
    AuthenticationFixtureUgcLoginAsUssdk001()
        : AuthenticationFixture<facadesCount, executeLogin>()
    {
    }

private:
    virtual void SetUp() override
    {
        AuthenticationFixture<facadesCount, executeLogin>::SetUp();

        const String commonTestUserEmail = "ussdk001@ubisoft.com";  // ussdk001 is used to avoid replicating the ugc setup on new PC test accounts.
        const String commonTestUserPassword = "a1234567";
        
        const PlayerCredentials credentials(commonTestUserEmail, commonTestUserPassword); 
        ASSERT_TRUE(AsyncHelper::waitSuccess(getFacade().createSession(credentials, {}, {})));
    }
};
#endif

using UGC = AuthenticationFixture<1>;
using UGC_NOLOGIN = AuthenticationFixture<1, false>;
using UGC_MOCK = LoginMockFixture<true>;
#if defined(US_TARGET_WINDOWS)
#if defined(US_SDK_TEST_CHINA)
using UGC_USSDK001 = AuthenticationFixture<1>;
#else
using UGC_USSDK001 = AuthenticationFixtureUgcLoginAsUssdk001<>;
#endif // US_SDK_TEST_CHINA
#endif // US_TARGET_WINDOWS

namespace TestUserGeneratedContentsClientUnit_BF
{
    Json getExternalVideos();
    void validateExternalVideo(const UgcExternalVideo& externalVideo);
    Json getUgcConfigs();
    void validateUgcConfigs(const Map<UgcTypeId, Map<UgcCategoryId, UgcMainCategory>>& config);
    Json getRatings();
    void validateRatings(const Map<UgcContentId, UgcRatingValue>& ratings);
    Json getFavorites();
    void validateFavorites(const Vector<UgcContentId>& favorites);
    extern const char* CONFIG_CATEGORY_ID_ONE;
    extern const char* CONFIG_CATEGORY_DISPLAY_NAME_ONE;
    extern const char* CONFIG_SUBCATEGORY_ID_ONE_ONE;
    extern const char* CONFIG_SUBCATEGORY_DISPLAY_NAME_ONE_ONE;
}

namespace TestUserGeneratedContentsClient_BF
{
    const uint16 SEARCH_FILTER_TITLE_MIN_LENGTH = 3;
    const uint16 MAX_GUIDS_IN_URL = 50;
    const char* DUMMY_GUID = "11111111-2222-3333-4444-555566667777";
    const char* CONTENT_ID_EXTERNAL_VIDEO = "09ec0d99-627f-4120-80f7-583d4fed1d0c"; 
    const char* CONTENT_ID_EXTERNAL_VIDEO_HIGHEST_RATING = "e9024fd4-8689-4195-94e9-13e9be304745";
    const char* CONTENT_ID_EXTERNAL_VIDEO_MOST_FAVORITES = "c040458c-2ae1-4897-a7be-df6a9a8d76d4";
    const char* CONTENT_ID_EXTERNAL_VIDEO_SPECIFIC_PROVIDER = "a4bba8cb-f3d4-48f7-84da-09e0f3f4b150";
}

///////  searchExternalVideos

# if defined(US_TARGET_WINDOWS) // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test Checks a simple search for external videos, real call to service
/// @note This test presumes at least one external video exists in the account used for testing.
TEST_F(UGC_USSDK001, US_MINRUN_UgcSearchExternalVideos)
{
    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos();
    ASSERT_TRUE(AsyncHelper::waitSuccess(result));
#if !defined(US_SDK_TEST_CHINA)
    ASSERT_GT(result.getResult().size(), 0u);
#endif
}

TEST_F(UGC_USSDK001, US_UgcSearchExternalVideosHighestRating)
{
    using namespace TestUserGeneratedContentsClient_BF;
    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    UgcSearchFilterExternalVideos searchFilter;
    searchFilter.m_order = UgcSortingBy::HighestRating;
    AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
    ASSERT_TRUE(AsyncHelper::waitSuccess(result));
    Vector<UgcExternalVideo> externalVideos = result.getResult();
    ASSERT_GT(externalVideos.size(), 0u);
    EXPECT_EQ(CONTENT_ID_EXTERNAL_VIDEO_HIGHEST_RATING, externalVideos.front().m_contentId);
}

TEST_F(UGC_USSDK001, US_UgcSearchExternalVideosMostFavorites)
{
    using namespace TestUserGeneratedContentsClient_BF;
    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    UgcSearchFilterExternalVideos searchFilter;
    searchFilter.m_order = UgcSortingBy::MostFavorites;
    AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
    ASSERT_TRUE(AsyncHelper::waitSuccess(result));
    Vector<UgcExternalVideo> externalVideos = result.getResult();
    ASSERT_GT(externalVideos.size(), 0u);
    EXPECT_EQ(CONTENT_ID_EXTERNAL_VIDEO_MOST_FAVORITES, externalVideos.front().m_contentId);
}
// note: sorting by MostRecent and MostViews are not tested as it's difficult to set up a  test environment for those.

TEST_F(UGC_USSDK001, US_UgcSearchExternalVideosSpecificProvider)
{
    using namespace TestUserGeneratedContentsClient_BF;
    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    UgcSearchFilterExternalVideos searchFilter;
    searchFilter.m_providers = { "specificprovider" };
    AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
    ASSERT_TRUE(AsyncHelper::waitSuccess(result));
    Vector<UgcExternalVideo> externalVideos = result.getResult();
    ASSERT_EQ(1, externalVideos.size());
    EXPECT_EQ(CONTENT_ID_EXTERNAL_VIDEO_SPECIFIC_PROVIDER, externalVideos.front().m_contentId);
}
#endif

/// @test Checks a simple search for external videos
TEST_F(UGC_MOCK, USNOT_UgcSearchExternalVideosValidJsonResponse)
{
    setupDebugLogging();
    using namespace TestUserGeneratedContentsClientUnit_BF;
    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();
    std::cout << "getExternalVideos: " << getExternalVideos().renderContent() << std::endl;
    {
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getExternalVideos().renderContent());
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos", mockResult);
    }

    AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos();
    ASSERT_TRUE(AsyncHelper::waitSuccess(result));

    Vector<UgcExternalVideo> externalVideos = result.getResult();
    EXPECT_EQ(1, externalVideos.size());
    validateExternalVideo(externalVideos.front());
}

/// @test Checks behavior when receiving invalid json
TEST_F(UGC_MOCK, USNOT_UgcSearchExternalVideosInvalidJsonResponse)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    const String invalidJsonResponse = getExternalVideos().renderContent() + "}";

    {
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(invalidJsonResponse);
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos", mockResult);
    }

    AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos();
    ASSERT_TRUE(AsyncHelper::waitFailure(result, Errors::CORE_INVALID_JSON_FORMAT));
}

/// @test Checks the behavior when title search filter is too short.
TEST_F(UGC_MOCK, USNOT_UgcSearchExternalVideosTitleTooShort)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    const String titleLongEnough = "aaa";
    const String titleTooShort = "aa";
    ASSERT_GE(titleLongEnough.getLength(), SEARCH_FILTER_TITLE_MIN_LENGTH);
    ASSERT_LT(titleTooShort.getLength(), SEARCH_FILTER_TITLE_MIN_LENGTH);

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();
    {
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getExternalVideos().renderContent());
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos", mockResult);
        UgcSearchFilterExternalVideos searchFilter;
        searchFilter.m_title = titleLongEnough;
        AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
        EXPECT_TRUE(AsyncHelper::waitSuccess(result));
    }
    {
        US_EXPECT_NO_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos");
        UgcSearchFilterExternalVideos searchFilter;
        searchFilter.m_title = titleTooShort;
        AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
        EXPECT_TRUE(AsyncHelper::waitFailure(result, Errors::UGC_TITLE_SEARCH_FILTER_TOO_SHORT));
    }
}

/// @test Checks behavior when too many guids are used in searchFilter
TEST_F(UGC_MOCK, USNOT_UgcSearchExternalVideosTooManyGuids)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    {   // 50 contentIds
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getExternalVideos().renderContent());
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos", mockResult);

        UgcSearchFilterExternalVideos searchFilter;
        searchFilter.m_contentIds.resize(MAX_GUIDS_IN_URL);
        std::fill(searchFilter.m_contentIds.begin(), searchFilter.m_contentIds.end(), UgcContentId(DUMMY_GUID));

        AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
        EXPECT_TRUE(AsyncHelper::waitSuccess(result));
    }

    {   // 51 contentIds
        US_EXPECT_NO_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos");

        UgcSearchFilterExternalVideos searchFilter;
        searchFilter.m_contentIds.resize(MAX_GUIDS_IN_URL + 1);
        std::fill(searchFilter.m_contentIds.begin(), searchFilter.m_contentIds.end(), UgcContentId(DUMMY_GUID));

        AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
        EXPECT_TRUE(AsyncHelper::waitFailure(result, Errors::UGC_TOO_MANY_IDS));
    }

    {   // 50 profileIds
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getExternalVideos().renderContent());
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos", mockResult);

        UgcSearchFilterExternalVideos searchFilter;
        searchFilter.m_profilesIds.resize(MAX_GUIDS_IN_URL);
        std::fill(searchFilter.m_profilesIds.begin(), searchFilter.m_profilesIds.end(), ProfileId(DUMMY_GUID));

        AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
        EXPECT_TRUE(AsyncHelper::waitSuccess(result));
    }

    {   // 51 profileIds
        US_EXPECT_NO_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos");

        UgcSearchFilterExternalVideos searchFilter;
        searchFilter.m_profilesIds.resize(MAX_GUIDS_IN_URL + 1);
        std::fill(searchFilter.m_profilesIds.begin(), searchFilter.m_profilesIds.end(), ProfileId(DUMMY_GUID));

        AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
        EXPECT_TRUE(AsyncHelper::waitFailure(result, Errors::UGC_TOO_MANY_IDS));
    }

    const uint16 HALF_MAX_GUIDS_IN_URL = MAX_GUIDS_IN_URL / 2;
    ASSERT_EQ(MAX_GUIDS_IN_URL, HALF_MAX_GUIDS_IN_URL * 2);  // supposing MAX_GUIDS_IN_URL will probably always be even.

    {   // 25 contentIds + 25 profileIds
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getExternalVideos().renderContent());
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos", mockResult);

        UgcSearchFilterExternalVideos searchFilter;
        searchFilter.m_contentIds.resize(HALF_MAX_GUIDS_IN_URL);
        std::fill(searchFilter.m_contentIds.begin(), searchFilter.m_contentIds.end(), UgcContentId(DUMMY_GUID));
        searchFilter.m_profilesIds.resize(HALF_MAX_GUIDS_IN_URL);
        std::fill(searchFilter.m_profilesIds.begin(), searchFilter.m_profilesIds.end(), ProfileId(DUMMY_GUID));

        AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
        EXPECT_TRUE(AsyncHelper::waitSuccess(result));
    }

    {   // 25 contentIds + 26 profileIds
        US_EXPECT_NO_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos");
        
        UgcSearchFilterExternalVideos searchFilter;
        searchFilter.m_contentIds.resize(HALF_MAX_GUIDS_IN_URL);
        std::fill(searchFilter.m_contentIds.begin(), searchFilter.m_contentIds.end(), UgcContentId(DUMMY_GUID));
        searchFilter.m_profilesIds.resize(HALF_MAX_GUIDS_IN_URL + 1);
        std::fill(searchFilter.m_profilesIds.begin(), searchFilter.m_profilesIds.end(), ProfileId(DUMMY_GUID));

        AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
        EXPECT_TRUE(AsyncHelper::waitFailure(result, Errors::UGC_TOO_MANY_IDS));
    }
}

/// @test Checks behavior when limit is set too high in searchFilter
TEST_F(UGC_MOCK, USNOT_UgcSearchExternalVideosLimitTooHigh)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    const uint16 MAX_LIMIT = 50;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    {
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getExternalVideos().renderContent());
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos", mockResult);
        UgcSearchFilterExternalVideos searchFilter;
        searchFilter.m_resultRange.m_limit = MAX_LIMIT;
        AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
        EXPECT_TRUE(AsyncHelper::waitSuccess(result));
    }
    
    {
        US_EXPECT_NO_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos");
        UgcSearchFilterExternalVideos searchFilter;
        searchFilter.m_resultRange.m_limit = MAX_LIMIT + 1;
        AsyncResult<Vector<UgcExternalVideo>> result = client.searchExternalVideos(searchFilter);
        EXPECT_TRUE(AsyncHelper::waitFailure(result, Errors::UGC_INVALID_PARAM));
    }
}

///////  requestExternalVideos

# if defined(US_TARGET_WINDOWS)   // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test simple content request
TEST_F(UGC_USSDK001, US_MINRUN_UgcRequestExternalVideos)
{
    using namespace TestUserGeneratedContentsClient_BF;
    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    AsyncResult<Vector<UgcExternalVideo>> result = client.requestExternalVideos({ UgcContentId(CONTENT_ID_EXTERNAL_VIDEO) });
    ASSERT_TRUE(AsyncHelper::waitSuccess(result));

#if !defined(US_SDK_TEST_CHINA)
    const Vector<UgcExternalVideo>& contents = result.getResult();
    EXPECT_EQ(1, contents.size());
    EXPECT_EQ(CONTENT_ID_EXTERNAL_VIDEO, contents.front().m_contentId);
#endif
}
#endif

/// @test checks behavior when too many contentIds are passed in parameter
TEST_F(UGC_MOCK, US_UgcRequestExternalVideosTooManyGuids)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;
    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    {   // 50 contentIds
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getExternalVideos().renderContent());
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos", mockResult);

        Vector<UgcContentId> contentIds(MAX_GUIDS_IN_URL);
        std::fill(contentIds.begin(), contentIds.end(), UgcContentId(DUMMY_GUID));

        AsyncResult<Vector<UgcExternalVideo>> result = client.requestExternalVideos(contentIds);
        ASSERT_TRUE(AsyncHelper::waitSuccess(result));
    }

    {   // 51 contentIds
        US_EXPECT_NO_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/ugc/mock-externalvideos");

        Vector<UgcContentId> contentIds(MAX_GUIDS_IN_URL + 1);
        std::fill(contentIds.begin(), contentIds.end(), UgcContentId(DUMMY_GUID));

        AsyncResult<Vector<UgcExternalVideo>> result = client.requestExternalVideos(contentIds);
        ASSERT_TRUE(AsyncHelper::waitFailure(result, Errors::UGC_TOO_MANY_IDS));
    }
}

///////  requestConfigs

# if defined(US_TARGET_WINDOWS) // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test get configs without parameter, real call
TEST_F(UGC_USSDK001, US_MINRUN_UgcGetConfigsDefaultParam)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    AsyncResult<UgcConfigs> result = client.requestConfigs();
    EXPECT_TRUE(AsyncHelper::waitSuccess(result));

#if !defined(US_SDK_TEST_CHINA)
    const UgcConfigs& configs = result.getResult();
    auto typeIter = configs.find(UgcTypeId::ExternalVideo);
    ASSERT_TRUE(typeIter != configs.end());
    auto categoryIter = typeIter->second.find("travelsId");
    EXPECT_TRUE(categoryIter != typeIter->second.end());
#endif
}
# endif // if defined(US_TARGET_WINDOWS)

# if defined(US_TARGET_WINDOWS) // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test get configs specifying externalvideo type, real call
TEST_F(UGC_USSDK001, US_UgcGetConfigsParamTypeExternalVideos)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    AsyncResult<UgcConfigs> result = client.requestConfigs({ UgcTypeId::ExternalVideo });
    EXPECT_TRUE(AsyncHelper::waitSuccess(result));
    const UgcConfigs& configs = result.getResult();
    EXPECT_TRUE(configs.size() == 1);
    EXPECT_TRUE(configs.find(UgcTypeId::ExternalVideo) != configs.end());
}
# endif // if defined(US_TARGET_WINDOWS)

/// @test checks simple call and parsing
TEST_F(UGC_MOCK, US_UgcGetConfigsValidJsonResponse)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    {
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getUgcConfigs().renderContent());
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/spaces/" + getFacade().getWorkingSpaceId() + "/mock-configs/ugc", mockResult);
    }

    AsyncResult<UgcConfigs> result = client.requestConfigs();
    EXPECT_TRUE(AsyncHelper::waitSuccess(result));

    validateUgcConfigs(result.getResult());
}

/// @test Checks behavior when receiving invalid json
TEST_F(UGC_MOCK, US_UgcGetConfigsInvalidJsonResponse)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    const String invalidJsonResponse = getUgcConfigs().renderContent() + "}";

    {
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(invalidJsonResponse);
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/spaces/" + getFacade().getWorkingSpaceId() + "/mock-configs/ugc", mockResult);
    }

    AsyncResult<UgcConfigs> result = client.requestConfigs();
    EXPECT_TRUE(AsyncHelper::waitFailure(result, Errors::CORE_INVALID_JSON_FORMAT));
}

/// @test Checks the helper method to retrieve displayNames based on category and subCategory ids
TEST_F(UGC_MOCK, US_UgcGetCategoriesDisplayNames)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    {
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getUgcConfigs().renderContent());
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/spaces/" + getFacade().getWorkingSpaceId() + "/mock-configs/ugc", mockResult);
    }

    AsyncResult<UgcConfigs> result = client.requestConfigs();
    EXPECT_TRUE(AsyncHelper::waitSuccess(result));

    const UgcConfigs& configs = result.getResult();

    UgcCategoryIds categoryIds;
    categoryIds.m_mainCategoryId = CONFIG_CATEGORY_ID_ONE;
    categoryIds.m_subCategoryId = CONFIG_SUBCATEGORY_ID_ONE_ONE;

    UgcCategoryDisplayNames displaynames = client.getCategoryDisplayNames(UgcTypeId::ExternalVideo, categoryIds, configs);

    EXPECT_EQ(CONFIG_CATEGORY_DISPLAY_NAME_ONE, displaynames.m_mainCategoryDisplayName);
    EXPECT_EQ(CONFIG_SUBCATEGORY_DISPLAY_NAME_ONE_ONE, displaynames.m_subCategoryDisplayName);
}

///////  requestRatings

# if defined(US_TARGET_WINDOWS) // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test checks that the request succeeds with default params
TEST_F(UGC_USSDK001, US_MINRUN_UgcRequestRatingsDefaultParams)
{
    using namespace TestUserGeneratedContentsClient_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    AsyncResult<Map<UgcContentId, UgcRatingValue>> result = client.requestRatings();
    EXPECT_TRUE(AsyncHelper::waitSuccess(result));

#if !defined(US_SDK_TEST_CHINA)
    const Map<UgcContentId, UgcRatingValue>& ratings = result.getResult();
    EXPECT_GT(ratings.size(), 0);
    const auto& iterRatings = ratings.find(UgcContentId(CONTENT_ID_EXTERNAL_VIDEO_HIGHEST_RATING));
    EXPECT_TRUE(iterRatings != ratings.end());
    EXPECT_EQ(UgcRatingValue::Like, iterRatings->second);
#endif
}
# endif // if defined(US_TARGET_WINDOWS)

# if defined(US_TARGET_WINDOWS) // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test checks that the request succeeds when requesting rating for a specific UgcContentId
TEST_F(UGC_USSDK001, US_UgcRequestRatingsForSpecificUgcContentId)
{
    using namespace TestUserGeneratedContentsClient_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    AsyncResult<Map<UgcContentId, UgcRatingValue>> result = client.requestRatings({UgcContentId(CONTENT_ID_EXTERNAL_VIDEO_HIGHEST_RATING)});
    EXPECT_TRUE(AsyncHelper::waitSuccess(result));

    const Map<UgcContentId, UgcRatingValue>& ratings = result.getResult();
    EXPECT_EQ(1, ratings.size());
    const auto& iterRatings = ratings.find(UgcContentId(CONTENT_ID_EXTERNAL_VIDEO_HIGHEST_RATING));
    EXPECT_TRUE(iterRatings != ratings.end());
    EXPECT_EQ(UgcRatingValue::Like, iterRatings->second);
}
# endif // if defined(US_TARGET_WINDOWS)

# if defined(US_TARGET_WINDOWS) // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test checks that the request succeeds when giving a specific ProfileId
TEST_F(UGC_USSDK001, US_UgcRequestRatingsForSpecificProfileId)
{
    using namespace TestUserGeneratedContentsClient_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();
    const ProfileId& profileId = getFacade().getAuthenticationClient().getSessionInfo().getProfileId();

    AsyncResult<Map<UgcContentId, UgcRatingValue>> result = client.requestRatings({}, profileId);
    EXPECT_TRUE(AsyncHelper::waitSuccess(result));

    const Map<UgcContentId, UgcRatingValue>& ratings = result.getResult();
    EXPECT_GT(ratings.size(), 0);
    const auto& iterRatings = ratings.find(UgcContentId(CONTENT_ID_EXTERNAL_VIDEO_HIGHEST_RATING));
    EXPECT_TRUE(iterRatings != ratings.end());
    EXPECT_EQ(UgcRatingValue::Like, iterRatings->second);
}
# endif // if defined(US_TARGET_WINDOWS)

/// @test Checks the parsing for a valid json response
TEST_F(UGC_MOCK, US_UgcRequestRatingsValidJsonResponse)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    {
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getRatings().renderContent());
        const ProfileId& profileId = getFacade().getAuthenticationClient().getSessionInfo().getProfileId();
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/" + profileId + "/ugc/mock-ratings", mockResult);
    }

    AsyncResult<Map<UgcContentId, UgcRatingValue>> result = client.requestRatings();
    EXPECT_TRUE(AsyncHelper::waitSuccess(result));

    const Map<UgcContentId, UgcRatingValue>& ratings = result.getResult();
    validateRatings(ratings);
}

/// @test Checks the parsing for an invalid json response
TEST_F(UGC_MOCK, US_UgcRequestRatingsInvalidJsonResponse)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    {
        const MockAsyncResult invalidMockResult = MockResultHelper::createSuccessResult(getRatings().renderContent() + "}");
        const ProfileId& profileId = getFacade().getAuthenticationClient().getSessionInfo().getProfileId();
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/" + profileId + "/ugc/mock-ratings", invalidMockResult);
    }

    AsyncResult<Map<UgcContentId, UgcRatingValue>> result = client.requestRatings();
    EXPECT_TRUE(AsyncHelper::waitFailure(result, Errors::CORE_INVALID_JSON_FORMAT));
}

/// @test checks behavior when too many contentIds are passed in parameter
TEST_F(UGC_MOCK, US_UgcRequestRatingsTooManyGuids)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();
    const ProfileId& profileId = getFacade().getAuthenticationClient().getSessionInfo().getProfileId();

    {   // 50 contentIds
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getRatings().renderContent());
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/" + profileId + "/ugc/mock-ratings", mockResult);

        Vector<UgcContentId> contentIds(MAX_GUIDS_IN_URL);
        std::fill(contentIds.begin(), contentIds.end(), UgcContentId(DUMMY_GUID));

        AsyncResult<Map<UgcContentId, UgcRatingValue>> result = client.requestRatings(contentIds);
        EXPECT_TRUE(AsyncHelper::waitSuccess(result));
    }

    {   // 51 contentIds    
        US_EXPECT_NO_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/" + profileId + "/ugc/mock-ratings");
        
        Vector<UgcContentId> contentIds(MAX_GUIDS_IN_URL + 1);
        std::fill(contentIds.begin(), contentIds.end(), UgcContentId(DUMMY_GUID));

        AsyncResult<Map<UgcContentId, UgcRatingValue>> result = client.requestRatings(contentIds);
        EXPECT_TRUE(AsyncHelper::waitFailure(result, Errors::UGC_TOO_MANY_IDS));
    }
}

///////  updateRating

# if defined(US_TARGET_WINDOWS) // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test checks that the update succeeds with each value
TEST_F(UGC_USSDK001, US_UgcUpdateRating)
{
    using namespace TestUserGeneratedContentsClient_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();
    const UgcContentId contentId(CONTENT_ID_EXTERNAL_VIDEO);
    
    {
        const UgcRatingValue ratingValue = UgcRatingValue::NoRating;

        AsyncResult<Empty> resultUpdateRating = client.updateRating(contentId, ratingValue);
        EXPECT_TRUE(AsyncHelper::waitSuccess(resultUpdateRating));

        AsyncResult<Map<UgcContentId, UgcRatingValue>> resultRequestRatings = client.requestRatings({contentId});
        EXPECT_TRUE(AsyncHelper::waitSuccess(resultRequestRatings));
        const Map<UgcContentId, UgcRatingValue>& ratings = resultRequestRatings.getResult();
        EXPECT_TRUE(ratings.empty());
    }

    {
        const UgcRatingValue ratingValue = UgcRatingValue::Dislike;

        AsyncResult<Empty> resultUpdateRating = client.updateRating(contentId, ratingValue);
        EXPECT_TRUE(AsyncHelper::waitSuccess(resultUpdateRating));

        AsyncResult<Map<UgcContentId, UgcRatingValue>> resultRequestRatings = client.requestRatings({ contentId });
        EXPECT_TRUE(AsyncHelper::waitSuccess(resultRequestRatings));
        const Map<UgcContentId, UgcRatingValue>& ratings = resultRequestRatings.getResult();
        const auto iterContentId = ratings.find(contentId);
        EXPECT_TRUE(iterContentId != ratings.end());
        EXPECT_TRUE(iterContentId->second == ratingValue);
    }

    {
        const UgcRatingValue ratingValue = UgcRatingValue::Like;

        AsyncResult<Empty> resultUpdateRating = client.updateRating(contentId, ratingValue);
        EXPECT_TRUE(AsyncHelper::waitSuccess(resultUpdateRating));

        AsyncResult<Map<UgcContentId, UgcRatingValue>> resultRequestRatings = client.requestRatings({ contentId });
        EXPECT_TRUE(AsyncHelper::waitSuccess(resultRequestRatings));
        const Map<UgcContentId, UgcRatingValue>& ratings = resultRequestRatings.getResult();
        const auto iterContentId = ratings.find(contentId);
        EXPECT_TRUE(iterContentId != ratings.end());
        EXPECT_TRUE(iterContentId->second == ratingValue);
    }

    {
        const UgcRatingValue ratingValue = UgcRatingValue::NoRating;

        AsyncResult<Empty> resultUpdateRating = client.updateRating(contentId, ratingValue);
        EXPECT_TRUE(AsyncHelper::waitSuccess(resultUpdateRating));

        AsyncResult<Map<UgcContentId, UgcRatingValue>> resultRequestRatings = client.requestRatings({ contentId });
        EXPECT_TRUE(AsyncHelper::waitSuccess(resultRequestRatings));
        const Map<UgcContentId, UgcRatingValue>& ratings = resultRequestRatings.getResult();
        EXPECT_TRUE(ratings.empty());
    }
}
# endif // if defined(US_TARGET_WINDOWS)

///////  requestFavorites

# if defined(US_TARGET_WINDOWS) // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test checks a simple request without params
TEST_F(UGC_USSDK001, US_MINRUN_UgcRequestFavoritesDefaultParams)
{
    using namespace TestUserGeneratedContentsClient_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();
    const AsyncResult<Vector<UgcContentId>> result = client.requestFavorites();
    AsyncHelper::waitSuccess(result);

#if !defined(US_SDK_TEST_CHINA)
    const Vector<UgcContentId>& favorites = result.getResult();
    EXPECT_GT(favorites.size(), 0);

    const UgcContentId contentIdMostFavorites = UgcContentId(CONTENT_ID_EXTERNAL_VIDEO_MOST_FAVORITES);
    EXPECT_TRUE(std::any_of(favorites.begin(), favorites.end(), [&contentIdMostFavorites](const UgcContentId& contentId) {return contentId == contentIdMostFavorites; }));
#endif
}
# endif // if defined(US_TARGET_WINDOWS)

# if defined(US_TARGET_WINDOWS) // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test checks success when specifying a contentId
TEST_F(UGC_USSDK001, US_UgcRequestFavoritesSpecificUgcContentId)
{
    using namespace TestUserGeneratedContentsClient_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    const UgcContentId contentIdMostFavorites = UgcContentId(CONTENT_ID_EXTERNAL_VIDEO_MOST_FAVORITES);

    const AsyncResult<Vector<UgcContentId>> result = client.requestFavorites({ contentIdMostFavorites });
    ASSERT_TRUE(AsyncHelper::waitSuccess(result));

    const Vector<UgcContentId>& favorites = result.getResult();
    EXPECT_EQ(1, favorites.size());
    EXPECT_EQ(contentIdMostFavorites, favorites.front());
}
# endif // if defined(US_TARGET_WINDOWS)

/// @test Checks the parsing for a valid json response
TEST_F(UGC_MOCK, US_UgcRequestFavoritesValidJsonResponse)
{
    setupDebugLogging();
    
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    {
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getFavorites().renderContent());
        const ProfileId& profileId = getFacade().getAuthenticationClient().getSessionInfo().getProfileId();
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/" + profileId + "/ugc/mock-favorites", mockResult);
    }

    AsyncResult<Vector<UgcContentId>> result = client.requestFavorites();
    EXPECT_TRUE(AsyncHelper::waitSuccess(result));

    const Vector<UgcContentId>& favorites = result.getResult();
    EXPECT_EQ(1, favorites.size());
    validateFavorites(favorites);
}

/// @test Checks the behavior when receiving an invalid json response
TEST_F(UGC_MOCK, US_UgcRequestFavoritesInvalidJsonResponse)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    String invalidJson = getFavorites().renderContent() + "}";

    {
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(invalidJson);
        const ProfileId& profileId = getFacade().getAuthenticationClient().getSessionInfo().getProfileId();
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/" + profileId + "/ugc/mock-favorites", mockResult);
    }

    AsyncResult<Vector<UgcContentId>> result = client.requestFavorites();
    EXPECT_TRUE(AsyncHelper::waitFailure(result, Errors::CORE_INVALID_JSON_FORMAT));
}

/// @test checks behavior when too many contentIds are passed in parameter
TEST_F(UGC_MOCK, US_UgcRequestFavoritesTooManyGuids)
{
    using namespace TestUserGeneratedContentsClient_BF;
    using namespace TestUserGeneratedContentsClientUnit_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();
    const ProfileId& profileId = getFacade().getAuthenticationClient().getSessionInfo().getProfileId();

    {   // 50 contentIds
        const MockAsyncResult mockResult = MockResultHelper::createSuccessResult(getFavorites().renderContent());
        US_EXPECT_CALL_HTTP_SIMPLE(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/" + profileId + "/ugc/mock-favorites", mockResult);

        Vector<UgcContentId> contentIds(MAX_GUIDS_IN_URL);
        std::fill(contentIds.begin(), contentIds.end(), UgcContentId(DUMMY_GUID));

        AsyncResult<Vector<UgcContentId>> result = client.requestFavorites(contentIds);
        EXPECT_TRUE(AsyncHelper::waitSuccess(result));
    }

    {   // 51 contentIds    
        US_EXPECT_NO_CALL_HTTP(getMockHttpClientImpl(), HttpMethod::HTTP_GET, "/profiles/" + profileId + "/ugc/mock-favorites");

        Vector<UgcContentId> contentIds(MAX_GUIDS_IN_URL + 1);
        std::fill(contentIds.begin(), contentIds.end(), UgcContentId(DUMMY_GUID));

        AsyncResult<Vector<UgcContentId>> result = client.requestFavorites(contentIds);
        EXPECT_TRUE(AsyncHelper::waitFailure(result, Errors::UGC_TOO_MANY_IDS));
    }
}

///////  updateFavoriteStatus

# if defined(US_TARGET_WINDOWS) // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test checks behavior when specifying a contentId
TEST_F(UGC_USSDK001, US_UgcUpdateFavoriteStatusAllValues)
{
    using namespace TestUserGeneratedContentsClient_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    {
        const AsyncResult<Empty> result = client.updateFavoriteStatus(UgcContentId(CONTENT_ID_EXTERNAL_VIDEO), UgcFavoriteStatus::Favorite);
        ASSERT_TRUE(AsyncHelper::waitSuccess(result));
    }

    {
        const AsyncResult<Empty> result = client.updateFavoriteStatus(UgcContentId(CONTENT_ID_EXTERNAL_VIDEO), UgcFavoriteStatus::NotFavorite);
        ASSERT_TRUE(AsyncHelper::waitSuccess(result));
    }

    {
        const AsyncResult<Empty> result = client.updateFavoriteStatus(UgcContentId(CONTENT_ID_EXTERNAL_VIDEO), UgcFavoriteStatus::NotFavorite);
        ASSERT_TRUE(AsyncHelper::waitSuccess(result));
    }
}
# endif // if defined(US_TARGET_WINDOWS)

# if defined(US_TARGET_WINDOWS) // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test checks correct behavior with several cases of updateFavorites 
TEST_F(UGC_USSDK001, US_UgcRequestAndUpdateFavorites)
{
    using namespace TestUserGeneratedContentsClient_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    {   // Setting an external video as favorite
        const AsyncResult<Empty> result = client.updateFavoriteStatus(UgcContentId(CONTENT_ID_EXTERNAL_VIDEO), UgcFavoriteStatus::Favorite);
        ASSERT_TRUE(AsyncHelper::waitSuccess(result));
    }

    {   // requesting favorites specifying the previous contentId, the result should contain just this content.
        const AsyncResult<Vector<UgcContentId>> result = client.requestFavorites({ UgcContentId(CONTENT_ID_EXTERNAL_VIDEO) });
        ASSERT_TRUE(AsyncHelper::waitSuccess(result));
        const Vector<UgcContentId>& favorites = result.getResult();
        EXPECT_EQ(1, favorites.size());
        EXPECT_EQ(UgcContentId(CONTENT_ID_EXTERNAL_VIDEO), favorites[0]);
    }

    {   // requesting favorites specifying a dummy contentId, the result shouldn't contain the external video that has just been added to favorites.
        const AsyncResult<Vector<UgcContentId>> result = client.requestFavorites({ UgcContentId(DUMMY_GUID) });
        ASSERT_TRUE(AsyncHelper::waitSuccess(result));
        const Vector<UgcContentId>& favorites = result.getResult();
        EXPECT_TRUE(favorites.empty());
    }

    {   // Setting the external video back to NotFavorite
        const AsyncResult<Empty> result = client.updateFavoriteStatus(UgcContentId(CONTENT_ID_EXTERNAL_VIDEO), UgcFavoriteStatus::NotFavorite);
        ASSERT_TRUE(AsyncHelper::waitSuccess(result));
    }

    {   // requesting favorites specifying the first contentId, the result shouldn't contain anything as the content has been removed from favorites.
        const AsyncResult<Vector<UgcContentId>> result = client.requestFavorites({ UgcContentId(CONTENT_ID_EXTERNAL_VIDEO) });
        ASSERT_TRUE(AsyncHelper::waitSuccess(result));
        const Vector<UgcContentId>& favorites = result.getResult();
        EXPECT_TRUE(favorites.empty());
    }
}
# endif // if defined(US_TARGET_WINDOWS)

///////  incrementViews

# if defined(US_TARGET_WINDOWS) // tests that are profileId related are run only on Windows, to be able to use the setup of one unique PC user.
/// @test checks the incrementation of a content views counter
/// @note There is a throttling on the views count incrementation, server-side. Therefore this test succeeds only if 15 minutes have passed since the last test.
// TODO: when the sdk will support the creation of a content, the test should be changed to create a content, increment, check incrementation, then destroy the content.
TEST_F(UGC_USSDK001, DISABLED_MANUAL_US_UgcIncrementViewsCheckIncrementation)
{
    using namespace TestUserGeneratedContentsClient_BF;

    UserGeneratedContentsClient& client = getFacade().getUserGeneratedContentsClient();

    uint32 viewsCount;

    {
        const AsyncResult<Vector<UgcExternalVideo>> result = client.requestExternalVideos({ UgcContentId(CONTENT_ID_EXTERNAL_VIDEO) });
        EXPECT_TRUE(AsyncHelper::waitSuccess(result));

        const Vector<UgcExternalVideo>& contents = result.getResult();
        EXPECT_EQ(1, contents.size());

        const UgcExternalVideo& externalVideo = contents.front();
        EXPECT_EQ(CONTENT_ID_EXTERNAL_VIDEO, externalVideo.m_contentId);

        viewsCount = externalVideo.m_viewsCount;
    }

    {
        const AsyncResult<Empty> result = client.incrementViews(UgcContentId(CONTENT_ID_EXTERNAL_VIDEO));
        EXPECT_TRUE(AsyncHelper::waitSuccess(result));
    }

    {
        const AsyncResult<Vector<UgcExternalVideo>> result = client.requestExternalVideos({ UgcContentId(CONTENT_ID_EXTERNAL_VIDEO) });
        EXPECT_TRUE(AsyncHelper::waitSuccess(result));

        const Vector<UgcExternalVideo>& contents = result.getResult();
        EXPECT_EQ(1, contents.size());

        const UgcExternalVideo& externalVideo = contents.front();
        EXPECT_EQ(CONTENT_ID_EXTERNAL_VIDEO, externalVideo.m_contentId);

        EXPECT_EQ(viewsCount + 1, externalVideo.m_viewsCount);
    }

}
# endif // if defined(US_TARGET_WINDOWS)

# endif //US_DLL

}; // namespace US_NS