IntegrationTestFixture Class Reference

#include "IntegrationTestFixture.h"

Inheritance diagram for IntegrationTestFixture:

Protected Member Functions
void	SetUp () override
void	TearDown () override
TestPlayer *	CreateTestPlayer (ObjectGuid::LowType guidLow=1, std::string const &name="TestPlayer", AccountTypes security=SEC_PLAYER)
TestCreature *	CreateTestCreature (ObjectGuid::LowType guidLow, uint32 entry, uint32 factionId)
NiceMock< WorldMock > *	GetWorldMock ()
TestMap *	GetTestMap ()

Static Private Member Functions
static void	EnsureFactionTemplates ()

Private Attributes
IWorld *	_originalWorld = nullptr
NiceMock< WorldMock > *	_worldMock = nullptr
TestMap *	_testMap = nullptr
std::vector< TestPlayer * >	_trackedPlayers
std::vector< TestCreature * >	_trackedCreatures
std::vector< CreatureTemplate * >	_ownedCreatureTemplates

Detailed Description

Member Function Documentation

CreateTestCreature()

TestCreature * IntegrationTestFixture::CreateTestCreature ( ObjectGuid::LowType  guidLow, uint32  entry, uint32  factionId  )

inlineprotected

    {
        // CreatureTemplate must be heap-allocated AFTER WorldMock is installed
        // because CreatureMovementData() constructor calls sWorld->getIntConfig()
        auto* tmpl = new CreatureTemplate();
        tmpl->Entry = entry;
        tmpl->faction = factionId;
        tmpl->minlevel = 80;
        tmpl->maxlevel = 80;
        tmpl->unit_class = CLASS_WARRIOR;
        tmpl->DamageModifier = 1.0f;
        tmpl->BaseAttackTime = 2000;
        tmpl->RangeAttackTime = 2000;
        tmpl->BaseVariance = 1.0f;
        tmpl->RangeVariance = 1.0f;
        tmpl->ModHealth = 1.0f;
        _ownedCreatureTemplates.push_back(tmpl);
 
        auto* creature = new TestCreature();
        creature->ForceInitValues(guidLow, entry);
        creature->SetTestMap(_testMap);
        creature->SetInWorld(true);
        creature->SetAlive(true);
        creature->SetPhase(1);
        creature->SetFaction(factionId);
        creature->SetLevel(80);
        creature->SetMaxHealth(10000);
        creature->SetHealth(10000);
        creature->InitializeThreatManager();
        _trackedCreatures.push_back(creature);
 
        return creature;
    }

References _ownedCreatureTemplates, _testMap, _trackedCreatures, and CLASS_WARRIOR.

CreateTestPlayer()

TestPlayer * IntegrationTestFixture::CreateTestPlayer ( ObjectGuid::LowType  guidLow = 1, std::string const &  name = "TestPlayer", AccountTypes  security = SEC_PLAYER  )

inlineprotected

    {
        auto* session = new WorldSession(guidLow, std::string(name), 0, nullptr, security,
            EXPANSION_WRATH_OF_THE_LICH_KING, 0, LOCALE_enUS, 0, false, false, 0);
        // Pre-allocate RBAC data so Player's ctor (which calls
        // GetSession()->HasPermission) doesn't try to load from DB.
        session->InitRBACDataForTest();
 
        auto* player = new TestPlayer(session);
        player->ForceInitValues(guidLow);
        session->SetPlayer(player);
        player->SetSession(session);
        player->SetMap(_testMap);
        player->AddToWorld();
        _trackedPlayers.push_back(player);
 
        return player;
    }

References _testMap, _trackedPlayers, EXPANSION_WRATH_OF_THE_LICH_KING, and LOCALE_enUS.

EnsureFactionTemplates()

static void IntegrationTestFixture::EnsureFactionTemplates ( )

inlinestaticprivate

    {
        static bool initialized = false;
        if (initialized)
            return;
        initialized = true;
 
        // Faction 90001: "player-like" — ourMask=1 (FACTION_MASK_PLAYER), hostile to monsters (hostileMask=8)
        auto* f1 = new FactionTemplateEntry();
        std::memset(f1, 0, sizeof(FactionTemplateEntry));
        f1->ID = TEST_FACTION_HOSTILE_TO_MONSTERS;
        f1->faction = TEST_FACTION_HOSTILE_TO_MONSTERS;
        f1->ourMask = 0x1;       // FACTION_MASK_PLAYER
        f1->friendlyMask = 0x1;  // friendly to players
        f1->hostileMask = 0x8;   // hostile to monsters
        sFactionTemplateStore.SetEntry(TEST_FACTION_HOSTILE_TO_MONSTERS, f1);
 
        // Faction 90002: "monster" — ourMask=8 (FACTION_MASK_MONSTER), hostile to players (hostileMask=1)
        auto* f2 = new FactionTemplateEntry();
        std::memset(f2, 0, sizeof(FactionTemplateEntry));
        f2->ID = TEST_FACTION_HOSTILE_TO_ALL;
        f2->faction = TEST_FACTION_HOSTILE_TO_ALL;
        f2->ourMask = 0x8;       // FACTION_MASK_MONSTER
        f2->friendlyMask = 0x0;  // friendly to none
        f2->hostileMask = 0x1;   // hostile to players
        sFactionTemplateStore.SetEntry(TEST_FACTION_HOSTILE_TO_ALL, f2);
    }

References sFactionTemplateStore, TEST_FACTION_HOSTILE_TO_ALL, and TEST_FACTION_HOSTILE_TO_MONSTERS.

Referenced by SetUp().

GetTestMap()

TestMap * IntegrationTestFixture::GetTestMap ( )

inlineprotected

{ return _testMap; }

References _testMap.

GetWorldMock()

NiceMock< WorldMock > * IntegrationTestFixture::GetWorldMock ( )

inlineprotected

{ return _worldMock; }

References _worldMock.

SetUp()

void IntegrationTestFixture::SetUp ( )

inlineoverrideprotected

    {
        TestMap::EnsureDBC();
        EnsureFactionTemplates();
 
        _originalWorld = sWorld.release();
        _worldMock = new NiceMock<WorldMock>();
        sWorld.reset(_worldMock);
 
        static std::string emptyString;
        ON_CALL(*_worldMock, GetDataPath()).WillByDefault(ReturnRef(emptyString));
        ON_CALL(*_worldMock, GetRealmName()).WillByDefault(ReturnRef(emptyString));
        ON_CALL(*_worldMock, GetDefaultDbcLocale()).WillByDefault(Return(LOCALE_enUS));
        ON_CALL(*_worldMock, getRate(_)).WillByDefault(Return(1.0f));
        ON_CALL(*_worldMock, getBoolConfig(_)).WillByDefault(Return(false));
        ON_CALL(*_worldMock, getIntConfig(_)).WillByDefault(Return(0));
        ON_CALL(*_worldMock, getFloatConfig(_)).WillByDefault(Return(0.0f));
        ON_CALL(*_worldMock, GetPlayerSecurityLimit()).WillByDefault(Return(SEC_PLAYER));
 
        _testMap = new TestMap();
    }

References _originalWorld, _testMap, _worldMock, TestMap::EnsureDBC(), EnsureFactionTemplates(), LOCALE_enUS, SEC_PLAYER, and sWorld.

TearDown()

void IntegrationTestFixture::TearDown ( )

inlineoverrideprotected

    {
        for (auto* creature : _trackedCreatures)
        {
            if (creature->IsInWorld())
                creature->RemoveFromWorld();
            delete creature;
        }
        _trackedCreatures.clear();
 
        for (auto* player : _trackedPlayers)
        {
            if (player->IsInWorld())
                player->RemoveFromWorld();
        }
        _trackedPlayers.clear();
 
        for (auto* tmpl : _ownedCreatureTemplates)
            delete tmpl;
        _ownedCreatureTemplates.clear();
 
        delete _testMap;
        _testMap = nullptr;
 
        IWorld* currentWorld = sWorld.release();
        delete currentWorld;
        _worldMock = nullptr;
 
        sWorld.reset(_originalWorld);
        _originalWorld = nullptr;
 
        // Intentional leaks of session/player to avoid database access in destructors
    }

References _originalWorld, _ownedCreatureTemplates, _testMap, _trackedCreatures, _trackedPlayers, _worldMock, and sWorld.

Member Data Documentation

_originalWorld

IWorld* IntegrationTestFixture::_originalWorld = nullptr

private

Referenced by SetUp(), and TearDown().

_ownedCreatureTemplates

std::vector<CreatureTemplate*> IntegrationTestFixture::_ownedCreatureTemplates

private

Referenced by CreateTestCreature(), and TearDown().

_testMap

TestMap* IntegrationTestFixture::_testMap = nullptr

private

Referenced by CreateTestCreature(), CreateTestPlayer(), GetTestMap(), SetUp(), and TearDown().

_trackedCreatures

std::vector<TestCreature*> IntegrationTestFixture::_trackedCreatures

private

Referenced by CreateTestCreature(), and TearDown().

_trackedPlayers

std::vector<TestPlayer*> IntegrationTestFixture::_trackedPlayers

private

Referenced by CreateTestPlayer(), and TearDown().

_worldMock

NiceMock<WorldMock>* IntegrationTestFixture::_worldMock = nullptr

private

Referenced by GetWorldMock(), SetUp(), and TearDown().

---

The documentation for this class was generated from the following file:

• azerothcore-wotlk/src/test/mocks/IntegrationTestFixture.h