SpellProcTest.cpp File Reference

#include "ProcEventInfoHelper.h"
#include "SpellInfoTestHelper.h"
#include "SpellMgr.h"
#include "WorldMock.h"
#include "gtest/gtest.h"
#include "gmock/gmock.h"

Go to the source code of this file.

Classes
class	SpellProcTest
	Test fixture for SpellMgr proc tests. More...

Functions
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_ProcFlagsMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_ProcFlagsNoMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_MultipleProcFlagsPartialMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_KillEventAlwaysProcs)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_KilledEventAlwaysProcs)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_DeathEventAlwaysProcs)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_HitMaskCriticalMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_HitMaskCriticalNoMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_HitMaskDefaultForDone)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_HitMaskDefaultForTaken)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_HitMaskMissNoMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_HitMaskDodge)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_HitMaskParry)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_HitMaskBlock)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SpellTypeMaskDamage)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SpellTypeMaskHeal)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SpellTypeMaskNoMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SpellPhaseMaskCast)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SpellPhaseMaskHit)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SpellPhaseMaskNoMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_CastPhaseWithExplicitHitMaskCrit)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_CastPhaseWithExplicitHitMaskNoCrit)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_CastPhaseWithDefaultHitMask)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_AllConditionsMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_OneConditionFails)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_ZeroProcFlags)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_PeriodicDamage)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_TakenDamage)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SpellFamilyNameMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SpellFamilyNameNoMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SpellFamilyFlagsMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SpellFamilyFlagsNoMatch)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SpellFamilyNameZeroAcceptsAll)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SpellFamilyFlagsZeroAcceptsAll)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_GenericFamilyIgnoresMask)
	TEST_F (SpellProcTest, SpellInfo_IsAffected_GenericBehavior)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_HotStreakScenario)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_IlluminationScenario)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SecondWindScenario)
	TEST_F (SpellProcTest, CanSpellTriggerProcOnEvent_SwordAndBoardScenario)

Function Documentation

TEST_F() [1/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_AllConditionsMatch
	)

{
    auto* spellInfo = CreateSpellInfo(1);
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_FIRE, SPELL_DIRECT_DAMAGE);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_CRITICAL)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_CRITICAL)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_CRITICAL, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_DAMAGE, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_FIRE, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), ProcEventInfoBuilder::WithSpellTypeMask(), SpellProcEntryBuilder::WithSpellTypeMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [2/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_CastPhaseWithDefaultHitMask
	)

{
    // CAST phase + HitMask=0 should skip HitMask check (old behavior)
    auto* spellInfo = CreateSpellInfo(1);
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_NATURE, SPELL_DIRECT_DAMAGE);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_CAST)
        .WithHitMask(0) // Default - no explicit HitMask
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_CAST)
        .WithHitMask(PROC_HIT_NORMAL) // Doesn't matter - HitMask check skipped
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_NORMAL, PROC_SPELL_PHASE_CAST, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NATURE, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [3/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_CastPhaseWithExplicitHitMaskCrit
	)

{
    // Nature's Grace scenario: CAST phase + explicit HitMask for crit
    // Crit is pre-calculated for travel-time spells
    auto* spellInfo = CreateSpellInfo(1);
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_NATURE, SPELL_DIRECT_DAMAGE);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_CAST)
        .WithHitMask(PROC_HIT_CRITICAL)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_CAST)
        .WithHitMask(PROC_HIT_CRITICAL)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_CRITICAL, PROC_SPELL_PHASE_CAST, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NATURE, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [4/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_CastPhaseWithExplicitHitMaskNoCrit
	)

{
    // CAST phase + explicit HitMask requires crit, but spell didn't crit
    auto* spellInfo = CreateSpellInfo(1);
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_NATURE, SPELL_DIRECT_DAMAGE);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_CAST)
        .WithHitMask(PROC_HIT_CRITICAL)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_CAST)
        .WithHitMask(PROC_HIT_NORMAL) // No crit
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_FALSE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_CRITICAL, PROC_HIT_NORMAL, PROC_SPELL_PHASE_CAST, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NATURE, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [5/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_DeathEventAlwaysProcs
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DEATH)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DEATH)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DEATH, sSpellMgr, SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [6/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_GenericFamilyIgnoresMask
	)

{
    // Generic family (0) should bypass family mask checks entirely
    auto* spellInfo = SpellInfoBuilder()
        .WithId(101)
        .WithSpellFamilyName(SPELLFAMILY_MAGE)
        .WithSpellFamilyFlags(0x1, 0, 0) // some mage flag
        .Build();
    _spellInfos.push_back(spellInfo);
 
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_FIRE, SPELL_DIRECT_DAMAGE);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellFamilyName(0) // generic family
        .WithSpellFamilyMask(flag96(0x2, 0, 0)) // does NOT match the spell's flags
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo))
        << "Generic family entries should ignore mask restrictions";
}

References ProcEventInfoBuilder::Build(), SpellInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_FIRE, SPELLFAMILY_MAGE, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellInfoBuilder::WithId(), SpellProcEntryBuilder::WithProcFlags(), SpellInfoBuilder::WithSpellFamilyFlags(), SpellProcEntryBuilder::WithSpellFamilyMask(), SpellProcEntryBuilder::WithSpellFamilyName(), SpellInfoBuilder::WithSpellFamilyName(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [7/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_HitMaskBlock
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_BLOCK)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_BLOCK)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK, PROC_HIT_BLOCK, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [8/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_HitMaskCriticalMatch
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_CRITICAL)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_CRITICAL)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_HIT_CRITICAL, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [9/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_HitMaskCriticalNoMatch
	)

{
    // Proc entry requires critical hit
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_CRITICAL)
        .Build();
 
    // Event is a normal hit
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_NORMAL)
        .Build();
 
    EXPECT_FALSE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_HIT_CRITICAL, PROC_HIT_NORMAL, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [10/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_HitMaskDefaultForDone
	)

{
    // When HitMask is 0, default for DONE procs is NORMAL | CRITICAL | ABSORB
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(0) // Default
        .Build();
 
    // Normal hit should work with default mask
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_NORMAL)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_HIT_NORMAL, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [11/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_HitMaskDefaultForTaken
	)

{
    // When HitMask is 0, default for TAKEN procs is NORMAL | CRITICAL
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(0) // Default
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_CRITICAL)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK, PROC_HIT_CRITICAL, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [12/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_HitMaskDodge
	)

{
    // Explicitly require dodge
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_DODGE)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_DODGE)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK, PROC_HIT_DODGE, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [13/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_HitMaskMissNoMatch
	)

{
    // Miss should not trigger default hit mask
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(0) // Default allows NORMAL | CRITICAL | ABSORB
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_MISS)
        .Build();
 
    EXPECT_FALSE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_HIT_MISS, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [14/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_HitMaskParry
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_PARRY)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_PARRY)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK, PROC_HIT_PARRY, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [15/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_HotStreakScenario
	)

{
    // Hot Streak: Proc on critical damage spell from Mage
    auto* fireballSpell = SpellInfoBuilder()
        .WithId(133)
        .WithSpellFamilyName(SPELLFAMILY_MAGE)
        .WithSpellFamilyFlags(0x00000001, 0, 0) // Fireball flag
        .Build();
    _spellInfos.push_back(fireballSpell);
 
    DamageInfo damageInfo(nullptr, nullptr, 1000, fireballSpell, SPELL_SCHOOL_MASK_FIRE, SPELL_DIRECT_DAMAGE);
 
    // Hot Streak proc entry - triggers on fire spell crits
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellFamilyName(SPELLFAMILY_MAGE)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_CRITICAL)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_CRITICAL)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_CRITICAL, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_DAMAGE, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_FIRE, SPELLFAMILY_MAGE, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellInfoBuilder::WithId(), SpellProcEntryBuilder::WithProcFlags(), SpellInfoBuilder::WithSpellFamilyFlags(), SpellProcEntryBuilder::WithSpellFamilyName(), SpellInfoBuilder::WithSpellFamilyName(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), ProcEventInfoBuilder::WithSpellTypeMask(), SpellProcEntryBuilder::WithSpellTypeMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [16/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_IlluminationScenario
	)

{
    // Illumination: Proc on critical heals from Paladin
    auto* holyLightSpell = SpellInfoBuilder()
        .WithId(635)
        .WithSpellFamilyName(SPELLFAMILY_PALADIN)
        .WithSpellFamilyFlags(0x80000000, 0, 0)
        .Build();
    _spellInfos.push_back(holyLightSpell);
 
    HealInfo healInfo(nullptr, nullptr, 2000, holyLightSpell, SPELL_SCHOOL_MASK_HOLY);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellFamilyName(SPELLFAMILY_PALADIN)
        .WithSpellTypeMask(PROC_SPELL_TYPE_HEAL)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_CRITICAL)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellTypeMask(PROC_SPELL_TYPE_HEAL)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_CRITICAL)
        .WithHealInfo(&healInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS, PROC_HIT_CRITICAL, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_HEAL, SPELL_SCHOOL_MASK_HOLY, SPELLFAMILY_PALADIN, sSpellMgr, ProcEventInfoBuilder::WithHealInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellInfoBuilder::WithId(), SpellProcEntryBuilder::WithProcFlags(), SpellInfoBuilder::WithSpellFamilyFlags(), SpellProcEntryBuilder::WithSpellFamilyName(), SpellInfoBuilder::WithSpellFamilyName(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), ProcEventInfoBuilder::WithSpellTypeMask(), SpellProcEntryBuilder::WithSpellTypeMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [17/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_KilledEventAlwaysProcs
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_KILLED)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_KILLED)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_KILLED, sSpellMgr, SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [18/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_KillEventAlwaysProcs
	)

{
    // Setup: Create a proc entry for kill events
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_KILL)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_KILL)
        .Build();
 
    // Kill events should always trigger
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_KILL, sSpellMgr, SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [19/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_MultipleProcFlagsPartialMatch
	)

{
    // Setup: Create a proc entry that triggers on melee OR ranged
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK | PROC_FLAG_DONE_RANGED_AUTO_ATTACK)
        .Build();
 
    // Create ProcEventInfo with only melee
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_NORMAL)
        .Build();
 
    // Should match (partial match is OK - it's an OR relationship)
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_FLAG_DONE_RANGED_AUTO_ATTACK, PROC_HIT_NORMAL, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [20/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_OneConditionFails
	)

{
    auto* spellInfo = CreateSpellInfo(1);
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_FIRE, SPELL_DIRECT_DAMAGE);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_CRITICAL) // Requires crit
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL) // But we got normal hit
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_FALSE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_CRITICAL, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_DAMAGE, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_FIRE, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), ProcEventInfoBuilder::WithSpellTypeMask(), SpellProcEntryBuilder::WithSpellTypeMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [21/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_PeriodicDamage
	)

{
    auto* spellInfo = CreateSpellInfo(1);
    DamageInfo damageInfo(nullptr, nullptr, 50, spellInfo, SPELL_SCHOOL_MASK_SHADOW, SPELL_DIRECT_DAMAGE);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_PERIODIC)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_PERIODIC)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_PERIODIC, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_DAMAGE, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_SHADOW, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), ProcEventInfoBuilder::WithSpellTypeMask(), SpellProcEntryBuilder::WithSpellTypeMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [22/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_ProcFlagsMatch
	)

{
    // Setup: Create a proc entry that triggers on melee auto attacks
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .Build();
 
    // Create ProcEventInfo with matching type mask
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_NORMAL)
        .Build();
 
    // Should match
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_HIT_NORMAL, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [23/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_ProcFlagsNoMatch
	)

{
    // Setup: Create a proc entry that triggers on melee auto attacks
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .Build();
 
    // Create ProcEventInfo with different type mask (ranged instead of melee)
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_RANGED_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_NORMAL)
        .Build();
 
    // Should not match
    EXPECT_FALSE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_FLAG_DONE_RANGED_AUTO_ATTACK, PROC_HIT_NORMAL, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [24/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SecondWindScenario
	)

{
    // Second Wind: Proc when stunned/immobilized (taken hit with dodge/parry)
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK | PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS)
        .WithHitMask(PROC_HIT_DODGE | PROC_HIT_PARRY)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_DODGE)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK, PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS, PROC_HIT_DODGE, PROC_HIT_PARRY, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [25/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SpellFamilyFlagsMatch
	)

{
    // Create a Paladin Holy Light spell with specific family flags
    auto* spellInfo = SpellInfoBuilder()
        .WithId(635) // Holy Light
        .WithSpellFamilyName(SPELLFAMILY_PALADIN)
        .WithSpellFamilyFlags(0x80000000, 0, 0) // Example flag for Holy Light
        .Build();
    _spellInfos.push_back(spellInfo);
 
    HealInfo healInfo(nullptr, nullptr, 500, spellInfo, SPELL_SCHOOL_MASK_HOLY);
 
    // Proc entry requires specific Paladin family flag
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellFamilyName(SPELLFAMILY_PALADIN)
        .WithSpellFamilyMask(flag96(0x80000000, 0, 0))
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithHealInfo(&healInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, SPELL_SCHOOL_MASK_HOLY, SPELLFAMILY_PALADIN, sSpellMgr, ProcEventInfoBuilder::WithHealInfo(), ProcEventInfoBuilder::WithHitMask(), SpellInfoBuilder::WithId(), SpellProcEntryBuilder::WithProcFlags(), SpellInfoBuilder::WithSpellFamilyFlags(), SpellProcEntryBuilder::WithSpellFamilyMask(), SpellProcEntryBuilder::WithSpellFamilyName(), SpellInfoBuilder::WithSpellFamilyName(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [26/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SpellFamilyFlagsNoMatch
	)

{
    // Create a Paladin spell with different family flags
    auto* spellInfo = SpellInfoBuilder()
        .WithId(19750) // Flash of Light
        .WithSpellFamilyName(SPELLFAMILY_PALADIN)
        .WithSpellFamilyFlags(0x40000000, 0, 0) // Different flag
        .Build();
    _spellInfos.push_back(spellInfo);
 
    HealInfo healInfo(nullptr, nullptr, 300, spellInfo, SPELL_SCHOOL_MASK_HOLY);
 
    // Proc entry requires different family flag
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellFamilyName(SPELLFAMILY_PALADIN)
        .WithSpellFamilyMask(flag96(0x80000000, 0, 0)) // Wants Holy Light flag
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithHealInfo(&healInfo)
        .Build();
 
    EXPECT_FALSE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, SPELL_SCHOOL_MASK_HOLY, SPELLFAMILY_PALADIN, sSpellMgr, ProcEventInfoBuilder::WithHealInfo(), ProcEventInfoBuilder::WithHitMask(), SpellInfoBuilder::WithId(), SpellProcEntryBuilder::WithProcFlags(), SpellInfoBuilder::WithSpellFamilyFlags(), SpellProcEntryBuilder::WithSpellFamilyMask(), SpellProcEntryBuilder::WithSpellFamilyName(), SpellInfoBuilder::WithSpellFamilyName(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [27/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SpellFamilyFlagsZeroAcceptsAll
	)

{
    // When SpellFamilyMask is 0, it should accept any flags within the family
    auto* spellInfo = SpellInfoBuilder()
        .WithId(100)
        .WithSpellFamilyName(SPELLFAMILY_PRIEST)
        .WithSpellFamilyFlags(0x12345678, 0xABCDEF01, 0x87654321) // Any flags
        .Build();
    _spellInfos.push_back(spellInfo);
 
    HealInfo healInfo(nullptr, nullptr, 200, spellInfo, SPELL_SCHOOL_MASK_HOLY);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellFamilyName(SPELLFAMILY_PRIEST)
        .WithSpellFamilyMask(flag96(0, 0, 0)) // Accept any flags
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithHealInfo(&healInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, SPELL_SCHOOL_MASK_HOLY, SPELLFAMILY_PRIEST, sSpellMgr, ProcEventInfoBuilder::WithHealInfo(), ProcEventInfoBuilder::WithHitMask(), SpellInfoBuilder::WithId(), SpellProcEntryBuilder::WithProcFlags(), SpellInfoBuilder::WithSpellFamilyFlags(), SpellProcEntryBuilder::WithSpellFamilyMask(), SpellProcEntryBuilder::WithSpellFamilyName(), SpellInfoBuilder::WithSpellFamilyName(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [28/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SpellFamilyNameMatch
	)

{
    // Create a Mage spell (SpellFamilyName = SPELLFAMILY_MAGE = 3)
    auto* spellInfo = SpellInfoBuilder()
        .WithId(133) // Fireball
        .WithSpellFamilyName(SPELLFAMILY_MAGE)
        .Build();
    _spellInfos.push_back(spellInfo);
 
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_FIRE, SPELL_DIRECT_DAMAGE);
 
    // Proc entry requires Mage spells
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellFamilyName(SPELLFAMILY_MAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_FIRE, SPELLFAMILY_MAGE, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellInfoBuilder::WithId(), SpellProcEntryBuilder::WithProcFlags(), SpellProcEntryBuilder::WithSpellFamilyName(), SpellInfoBuilder::WithSpellFamilyName(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [29/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SpellFamilyNameNoMatch
	)

{
    // Create a Warlock spell but proc requires Mage
    auto* spellInfo = SpellInfoBuilder()
        .WithId(686) // Shadow Bolt
        .WithSpellFamilyName(SPELLFAMILY_WARLOCK)
        .Build();
    _spellInfos.push_back(spellInfo);
 
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_SHADOW, SPELL_DIRECT_DAMAGE);
 
    // Proc entry requires Mage spells
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellFamilyName(SPELLFAMILY_MAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_FALSE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_SHADOW, SPELLFAMILY_MAGE, SPELLFAMILY_WARLOCK, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellInfoBuilder::WithId(), SpellProcEntryBuilder::WithProcFlags(), SpellProcEntryBuilder::WithSpellFamilyName(), SpellInfoBuilder::WithSpellFamilyName(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [30/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SpellFamilyNameZeroAcceptsAll
	)

{
    // When SpellFamilyName is 0, it should accept any spell family
    auto* spellInfo = SpellInfoBuilder()
        .WithId(100)
        .WithSpellFamilyName(SPELLFAMILY_DRUID)
        .Build();
    _spellInfos.push_back(spellInfo);
 
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_NATURE, SPELL_DIRECT_DAMAGE);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellFamilyName(0) // Accept any family
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NATURE, SPELLFAMILY_DRUID, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellInfoBuilder::WithId(), SpellProcEntryBuilder::WithProcFlags(), SpellProcEntryBuilder::WithSpellFamilyName(), SpellInfoBuilder::WithSpellFamilyName(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [31/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SpellPhaseMaskCast
	)

{
    auto* spellInfo = CreateSpellInfo(1);
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_FIRE, SPELL_DIRECT_DAMAGE);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_CAST)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_CAST)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_SPELL_PHASE_CAST, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_FIRE, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), SpellProcEntryBuilder::WithProcFlags(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [32/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SpellPhaseMaskHit
	)

{
    auto* spellInfo = CreateSpellInfo(1);
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_FIRE, SPELL_DIRECT_DAMAGE);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_FIRE, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [33/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SpellPhaseMaskNoMatch
	)

{
    auto* spellInfo = CreateSpellInfo(1);
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_FIRE, SPELL_DIRECT_DAMAGE);
 
    // Proc requires cast phase
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_CAST)
        .Build();
 
    // Event is hit phase
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_FALSE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_NORMAL, PROC_SPELL_PHASE_CAST, PROC_SPELL_PHASE_HIT, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_FIRE, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [34/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SpellTypeMaskDamage
	)

{
    auto* spellInfo = CreateSpellInfo(1);
 
    // Create DamageInfo for the test
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_FIRE, SPELL_DIRECT_DAMAGE);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_DAMAGE, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_FIRE, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), ProcEventInfoBuilder::WithSpellTypeMask(), SpellProcEntryBuilder::WithSpellTypeMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [35/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SpellTypeMaskHeal
	)

{
    auto* spellInfo = CreateSpellInfo(1);
 
    // Create HealInfo with the spell info so GetSpellInfo() works
    HealInfo healInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_HOLY);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellTypeMask(PROC_SPELL_TYPE_HEAL)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellTypeMask(PROC_SPELL_TYPE_HEAL)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithHealInfo(&healInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_HEAL, SPELL_SCHOOL_MASK_HOLY, sSpellMgr, ProcEventInfoBuilder::WithHealInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), ProcEventInfoBuilder::WithSpellTypeMask(), SpellProcEntryBuilder::WithSpellTypeMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [36/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SpellTypeMaskNoMatch
	)

{
    // Proc requires heal but event is damage
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellTypeMask(PROC_SPELL_TYPE_HEAL)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE) // Mismatch
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .Build();
 
    EXPECT_FALSE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_DAMAGE, PROC_SPELL_TYPE_HEAL, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), ProcEventInfoBuilder::WithSpellTypeMask(), SpellProcEntryBuilder::WithSpellTypeMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [37/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_SwordAndBoardScenario
	)

{
    // Sword and Board: Proc on Devastate/Revenge (block effects)
    auto* devastateSpell = SpellInfoBuilder()
        .WithId(20243) // Devastate
        .WithSpellFamilyName(SPELLFAMILY_WARRIOR)
        .WithSpellFamilyFlags(0x00000000, 0x00000000, 0x00000100) // Devastate flag
        .Build();
    _spellInfos.push_back(devastateSpell);
 
    DamageInfo damageInfo(nullptr, nullptr, 500, devastateSpell, SPELL_SCHOOL_MASK_NORMAL, SPELL_DIRECT_DAMAGE);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS)
        .WithSpellFamilyName(SPELLFAMILY_WARRIOR)
        .WithSpellFamilyMask(flag96(0, 0, 0x100)) // Devastate flag
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithDamageInfo(&damageInfo)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS, PROC_HIT_NORMAL, PROC_SPELL_PHASE_HIT, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, SPELLFAMILY_WARRIOR, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellInfoBuilder::WithId(), SpellProcEntryBuilder::WithProcFlags(), SpellInfoBuilder::WithSpellFamilyFlags(), SpellProcEntryBuilder::WithSpellFamilyMask(), SpellProcEntryBuilder::WithSpellFamilyName(), SpellInfoBuilder::WithSpellFamilyName(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [38/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_TakenDamage
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_TAKEN_DAMAGE)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_TAKEN_DAMAGE)
        .WithHitMask(PROC_HIT_NORMAL)
        .Build();
 
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_TAKEN_DAMAGE, PROC_HIT_NORMAL, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [39/40]

TEST_F	(	SpellProcTest	,
		CanSpellTriggerProcOnEvent_ZeroProcFlags
	)

{
    // Zero proc flags should never match anything
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(0)
        .Build();
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_NORMAL)
        .Build();
 
    EXPECT_FALSE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_HIT_NORMAL, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [40/40]

TEST_F	(	SpellProcTest	,
		SpellInfo_IsAffected_GenericBehavior
	)

{
    auto* spellInfo = SpellInfoBuilder()
        .WithId(102)
        .WithSpellFamilyName(SPELLFAMILY_WARLOCK)
        .WithSpellFamilyFlags(0x4, 0, 0)
        .Build();
    _spellInfos.push_back(spellInfo);
 
    // generic family should return true regardless of mask
    EXPECT_TRUE(spellInfo->IsAffected(0, flag96(0x4, 0, 0)));
    EXPECT_TRUE(spellInfo->IsAffected(0, flag96(0x8, 0, 0)));
    // a non-generic family still respects mask
    EXPECT_FALSE(spellInfo->IsAffected(SPELLFAMILY_PALADIN, flag96(0x4, 0, 0)));
}

References SpellInfoBuilder::Build(), SPELLFAMILY_PALADIN, SPELLFAMILY_WARLOCK, SpellInfoBuilder::WithId(), SpellInfoBuilder::WithSpellFamilyFlags(), and SpellInfoBuilder::WithSpellFamilyName().