SpellProcIntegrationTest.cpp File Reference

#include "AuraScriptTestFramework.h"
#include "SpellMgr.h"
#include "gtest/gtest.h"
#include "gmock/gmock.h"

Go to the source code of this file.

Classes
class	SpellProcIntegrationTest
	Integration tests for the proc system. More...

Functions
	TEST_F (SpellProcIntegrationTest, MeleeAutoAttackProc_NormalHit)
	TEST_F (SpellProcIntegrationTest, MeleeAutoAttackProc_CritOnly)
	TEST_F (SpellProcIntegrationTest, MeleeAutoAttackProc_Miss)
	TEST_F (SpellProcIntegrationTest, SpellDamageProc_OnHit)
	TEST_F (SpellProcIntegrationTest, SpellDamageProc_OnCast)
	TEST_F (SpellProcIntegrationTest, HealProc_OnHeal)
	TEST_F (SpellProcIntegrationTest, HealProc_CritHeal)
	TEST_F (SpellProcIntegrationTest, PeriodicDamageProc)
	TEST_F (SpellProcIntegrationTest, PeriodicHealProc)
	TEST_F (SpellProcIntegrationTest, KillProc)
	TEST_F (SpellProcIntegrationTest, DeathProc)
	TEST_F (SpellProcIntegrationTest, DodgeProc)
	TEST_F (SpellProcIntegrationTest, ParryProc)
	TEST_F (SpellProcIntegrationTest, BlockProc)
	TEST_F (SpellProcIntegrationTest, FullBlockProc)
	TEST_F (SpellProcIntegrationTest, AbsorbProc)
	TEST_F (SpellProcIntegrationTest, SpellFamilyMatch_SameFamily)
	TEST_F (SpellProcIntegrationTest, SpellFamilyMatch_DifferentFamily)
	TEST_F (SpellProcIntegrationTest, SpellFamilyMatch_NoFamilyFilter)
	TEST_F (SpellProcIntegrationTest, SpellFamilyMatch_FlagMismatch)
	TEST_F (SpellProcIntegrationTest, MultipleProcFlags_MeleeOrSpell)
	TEST_F (SpellProcIntegrationTest, MultipleHitMasks_CritOrNormal)
	TEST_F (SpellProcIntegrationTest, SchoolMaskFilter_FireOnly_FireDamage)
	TEST_F (SpellProcIntegrationTest, SchoolMaskFilter_FireOnly_FrostDamage)
	TEST_F (SpellProcIntegrationTest, SchoolMaskFilter_NoSchoolMask_AnySchoolTriggers)
	TEST_F (SpellProcIntegrationTest, EmptyProcFlags_NeverTriggers)
	TEST_F (SpellProcIntegrationTest, AllHitMasks_TriggersOnAny)

Function Documentation

TEST_F() [1/27]

TEST_F	(	SpellProcIntegrationTest	,
		AbsorbProc
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithHitMask(PROC_HIT_ABSORB)
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnTakenSpellDamage()
        .WithAbsorb();
 
    EXPECT_PROC_TRIGGERS(procEntry, scenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnTakenSpellDamage(), PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG, PROC_HIT_ABSORB, ProcScenarioBuilder::WithAbsorb(), SpellProcEntryBuilder::WithHitMask(), and SpellProcEntryBuilder::WithProcFlags().

TEST_F() [2/27]

TEST_F	(	SpellProcIntegrationTest	,
		AllHitMasks_TriggersOnAny
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_MASK_ALL)
        .Build();
 
    // Should trigger on any hit type
    std::vector<uint32_t> hitTypes = {
        PROC_HIT_NORMAL, PROC_HIT_CRITICAL, PROC_HIT_MISS,
        PROC_HIT_DODGE, PROC_HIT_PARRY, PROC_HIT_BLOCK
    };
 
    for (uint32_t hitType : hitTypes)
    {
        auto eventInfo = ProcEventInfoBuilder()
            .WithTypeMask(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
            .WithHitMask(hitType)
            .Build();
 
        EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo))
            << "Failed for hit type: " << hitType;
    }
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_HIT_BLOCK, PROC_HIT_CRITICAL, PROC_HIT_DODGE, PROC_HIT_MASK_ALL, PROC_HIT_MISS, PROC_HIT_NORMAL, PROC_HIT_PARRY, sSpellMgr, ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [3/27]

TEST_F	(	SpellProcIntegrationTest	,
		BlockProc
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_BLOCK)
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnTakenMeleeAutoAttack()
        .WithBlock();
 
    EXPECT_PROC_TRIGGERS(procEntry, scenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnTakenMeleeAutoAttack(), PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK, PROC_HIT_BLOCK, ProcScenarioBuilder::WithBlock(), SpellProcEntryBuilder::WithHitMask(), and SpellProcEntryBuilder::WithProcFlags().

TEST_F() [4/27]

TEST_F	(	SpellProcIntegrationTest	,
		DeathProc
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DEATH)
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnDeath();
 
    EXPECT_PROC_TRIGGERS(procEntry, scenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnDeath(), PROC_FLAG_DEATH, and SpellProcEntryBuilder::WithProcFlags().

TEST_F() [5/27]

TEST_F	(	SpellProcIntegrationTest	,
		DodgeProc
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_DODGE)
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnTakenMeleeAutoAttack()
        .WithDodge();
 
    EXPECT_PROC_TRIGGERS(procEntry, scenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnTakenMeleeAutoAttack(), PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK, PROC_HIT_DODGE, ProcScenarioBuilder::WithDodge(), SpellProcEntryBuilder::WithHitMask(), and SpellProcEntryBuilder::WithProcFlags().

TEST_F() [6/27]

TEST_F	(	SpellProcIntegrationTest	,
		EmptyProcFlags_NeverTriggers
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_NONE) // No flags set
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnMeleeAutoAttack()
        .WithNormalHit();
 
    // Without PROC_FLAG_NONE special handling, this might still match
    // The actual behavior depends on implementation
    auto eventInfo = scenario.Build();
 
    // Event has flags but proc entry has none - should not trigger
    if (procEntry.ProcFlags == 0 && scenario.GetTypeMask() != 0)
    {
        EXPECT_FALSE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, eventInfo));
    }
}

References ProcScenarioBuilder::Build(), SpellProcEntryBuilder::Build(), ProcScenarioBuilder::OnMeleeAutoAttack(), PROC_FLAG_NONE, sSpellMgr, ProcScenarioBuilder::WithNormalHit(), and SpellProcEntryBuilder::WithProcFlags().

TEST_F() [7/27]

TEST_F	(	SpellProcIntegrationTest	,
		FullBlockProc
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_FULL_BLOCK)
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnTakenMeleeAutoAttack()
        .WithFullBlock();
 
    EXPECT_PROC_TRIGGERS(procEntry, scenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnTakenMeleeAutoAttack(), PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK, PROC_HIT_FULL_BLOCK, ProcScenarioBuilder::WithFullBlock(), SpellProcEntryBuilder::WithHitMask(), and SpellProcEntryBuilder::WithProcFlags().

TEST_F() [8/27]

TEST_F	(	SpellProcIntegrationTest	,
		HealProc_CritHeal
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellTypeMask(PROC_SPELL_TYPE_HEAL)
        .WithHitMask(PROC_HIT_CRITICAL)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    // Normal heal should NOT trigger crit-only proc
    auto normalScenario = ProcScenarioBuilder()
        .OnHeal()
        .WithNormalHit();
    EXPECT_PROC_DOES_NOT_TRIGGER(procEntry, normalScenario);
 
    // Crit heal should trigger
    auto critScenario = ProcScenarioBuilder()
        .OnHeal()
        .WithCrit();
    EXPECT_PROC_TRIGGERS(procEntry, critScenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_DOES_NOT_TRIGGER, EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnHeal(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS, PROC_HIT_CRITICAL, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_HEAL, ProcScenarioBuilder::WithCrit(), SpellProcEntryBuilder::WithHitMask(), ProcScenarioBuilder::WithNormalHit(), SpellProcEntryBuilder::WithProcFlags(), SpellProcEntryBuilder::WithSpellPhaseMask(), and SpellProcEntryBuilder::WithSpellTypeMask().

TEST_F() [9/27]

TEST_F	(	SpellProcIntegrationTest	,
		HealProc_OnHeal
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS)
        .WithSpellTypeMask(PROC_SPELL_TYPE_HEAL)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnHeal()
        .OnHit();
 
    EXPECT_PROC_TRIGGERS(procEntry, scenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnHeal(), ProcScenarioBuilder::OnHit(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_HEAL, SpellProcEntryBuilder::WithProcFlags(), SpellProcEntryBuilder::WithSpellPhaseMask(), and SpellProcEntryBuilder::WithSpellTypeMask().

TEST_F() [10/27]

TEST_F	(	SpellProcIntegrationTest	,
		KillProc
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_KILL)
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnKill();
 
    EXPECT_PROC_TRIGGERS(procEntry, scenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnKill(), PROC_FLAG_KILL, and SpellProcEntryBuilder::WithProcFlags().

TEST_F() [11/27]

TEST_F	(	SpellProcIntegrationTest	,
		MeleeAutoAttackProc_CritOnly
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_CRITICAL)
        .Build();
 
    // Normal hit should NOT trigger crit-only proc
    auto normalScenario = ProcScenarioBuilder()
        .OnMeleeAutoAttack()
        .WithNormalHit();
    EXPECT_PROC_DOES_NOT_TRIGGER(procEntry, normalScenario);
 
    // Critical hit should trigger
    auto critScenario = ProcScenarioBuilder()
        .OnMeleeAutoAttack()
        .WithCrit();
    EXPECT_PROC_TRIGGERS(procEntry, critScenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_DOES_NOT_TRIGGER, EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnMeleeAutoAttack(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_HIT_CRITICAL, ProcScenarioBuilder::WithCrit(), SpellProcEntryBuilder::WithHitMask(), ProcScenarioBuilder::WithNormalHit(), and SpellProcEntryBuilder::WithProcFlags().

TEST_F() [12/27]

TEST_F	(	SpellProcIntegrationTest	,
		MeleeAutoAttackProc_Miss
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_MISS)
        .Build();
 
    auto missScenario = ProcScenarioBuilder()
        .OnMeleeAutoAttack()
        .WithMiss();
 
    EXPECT_PROC_TRIGGERS(procEntry, missScenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnMeleeAutoAttack(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_HIT_MISS, SpellProcEntryBuilder::WithHitMask(), ProcScenarioBuilder::WithMiss(), and SpellProcEntryBuilder::WithProcFlags().

TEST_F() [13/27]

TEST_F	(	SpellProcIntegrationTest	,
		MeleeAutoAttackProc_NormalHit
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_NORMAL | PROC_HIT_CRITICAL)
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnMeleeAutoAttack()
        .WithNormalHit();
 
    EXPECT_PROC_TRIGGERS(procEntry, scenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnMeleeAutoAttack(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_HIT_CRITICAL, PROC_HIT_NORMAL, SpellProcEntryBuilder::WithHitMask(), ProcScenarioBuilder::WithNormalHit(), and SpellProcEntryBuilder::WithProcFlags().

TEST_F() [14/27]

TEST_F	(	SpellProcIntegrationTest	,
		MultipleHitMasks_CritOrNormal
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_NORMAL | PROC_HIT_CRITICAL)
        .Build();
 
    auto normalScenario = ProcScenarioBuilder()
        .OnMeleeAutoAttack()
        .WithNormalHit();
    EXPECT_PROC_TRIGGERS(procEntry, normalScenario);
 
    auto critScenario = ProcScenarioBuilder()
        .OnMeleeAutoAttack()
        .WithCrit();
    EXPECT_PROC_TRIGGERS(procEntry, critScenario);
 
    auto missScenario = ProcScenarioBuilder()
        .OnMeleeAutoAttack()
        .WithMiss();
    EXPECT_PROC_DOES_NOT_TRIGGER(procEntry, missScenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_DOES_NOT_TRIGGER, EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnMeleeAutoAttack(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_HIT_CRITICAL, PROC_HIT_NORMAL, ProcScenarioBuilder::WithCrit(), SpellProcEntryBuilder::WithHitMask(), ProcScenarioBuilder::WithMiss(), ProcScenarioBuilder::WithNormalHit(), and SpellProcEntryBuilder::WithProcFlags().

TEST_F() [15/27]

TEST_F	(	SpellProcIntegrationTest	,
		MultipleProcFlags_MeleeOrSpell
	)

{
    // Proc on melee OR spell damage
    // Note: Spell procs require SpellPhaseMask to be set, otherwise the check
    // (eventInfo.SpellPhaseMask & procEntry.SpellPhaseMask) fails when procEntry = 0
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_MELEE_AUTO_ATTACK | PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    // Melee test
    auto meleeEventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_NORMAL)
        .Build();
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, meleeEventInfo));
 
    // Spell test - needs matching SpellPhaseMask AND SpellInfo
    auto* spellInfo = CreateSpellInfo(100);
    DamageInfo damageInfo(nullptr, nullptr, 100, spellInfo, SPELL_SCHOOL_MASK_FIRE, SPELL_DIRECT_DAMAGE);
    auto spellEventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithDamageInfo(&damageInfo)
        .Build();
    EXPECT_TRUE(sSpellMgr->CanSpellTriggerProcOnEvent(procEntry, spellEventInfo));
}

References ProcEventInfoBuilder::Build(), SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_MELEE_AUTO_ATTACK, 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() [16/27]

TEST_F	(	SpellProcIntegrationTest	,
		ParryProc
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
        .WithHitMask(PROC_HIT_PARRY)
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnTakenMeleeAutoAttack()
        .WithParry();
 
    EXPECT_PROC_TRIGGERS(procEntry, scenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnTakenMeleeAutoAttack(), PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK, PROC_HIT_PARRY, SpellProcEntryBuilder::WithHitMask(), ProcScenarioBuilder::WithParry(), and SpellProcEntryBuilder::WithProcFlags().

TEST_F() [17/27]

TEST_F	(	SpellProcIntegrationTest	,
		PeriodicDamageProc
	)

{
    // Note: PROC_FLAG_DONE_PERIODIC is in REQ_SPELL_PHASE_PROC_FLAG_MASK,
    // so SpellPhaseMask must be set (can't be 0)
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_PERIODIC)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnPeriodicDamage()
        .WithNormalHit();
 
    EXPECT_PROC_TRIGGERS(procEntry, scenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnPeriodicDamage(), PROC_FLAG_DONE_PERIODIC, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_DAMAGE, ProcScenarioBuilder::WithNormalHit(), SpellProcEntryBuilder::WithProcFlags(), SpellProcEntryBuilder::WithSpellPhaseMask(), and SpellProcEntryBuilder::WithSpellTypeMask().

TEST_F() [18/27]

TEST_F	(	SpellProcIntegrationTest	,
		PeriodicHealProc
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_PERIODIC)
        .WithSpellTypeMask(PROC_SPELL_TYPE_HEAL)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnPeriodicHeal()
        .WithNormalHit();
 
    EXPECT_PROC_TRIGGERS(procEntry, scenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnPeriodicHeal(), PROC_FLAG_DONE_PERIODIC, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_HEAL, ProcScenarioBuilder::WithNormalHit(), SpellProcEntryBuilder::WithProcFlags(), SpellProcEntryBuilder::WithSpellPhaseMask(), and SpellProcEntryBuilder::WithSpellTypeMask().

TEST_F() [19/27]

TEST_F	(	SpellProcIntegrationTest	,
		SchoolMaskFilter_FireOnly_FireDamage
	)

{
    // Proc entry requires fire school damage
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSchoolMask(SPELL_SCHOOL_MASK_FIRE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    // Create fire spell and fire damage info
    auto* fireSpell = CreateSpellInfo(133, 3, 0); // Fireball
    DamageInfo fireDamageInfo(nullptr, nullptr, 100, fireSpell, SPELL_SCHOOL_MASK_FIRE, SPELL_DIRECT_DAMAGE);
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithDamageInfo(&fireDamageInfo)
        .Build();
 
    // Fire damage should trigger fire-only proc
    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(), SpellProcEntryBuilder::WithSchoolMask(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), ProcEventInfoBuilder::WithSpellTypeMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [20/27]

TEST_F	(	SpellProcIntegrationTest	,
		SchoolMaskFilter_FireOnly_FrostDamage
	)

{
    // Proc entry requires fire school damage
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSchoolMask(SPELL_SCHOOL_MASK_FIRE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    // Create frost spell and frost damage info
    auto* frostSpell = CreateSpellInfo(116, 3, 0); // Frostbolt
    DamageInfo frostDamageInfo(nullptr, nullptr, 100, frostSpell, SPELL_SCHOOL_MASK_FROST, SPELL_DIRECT_DAMAGE);
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithDamageInfo(&frostDamageInfo)
        .Build();
 
    // Frost damage should NOT trigger fire-only proc
    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_HIT, PROC_SPELL_TYPE_DAMAGE, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_FIRE, SPELL_SCHOOL_MASK_FROST, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), SpellProcEntryBuilder::WithSchoolMask(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), ProcEventInfoBuilder::WithSpellTypeMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [21/27]

TEST_F	(	SpellProcIntegrationTest	,
		SchoolMaskFilter_NoSchoolMask_AnySchoolTriggers
	)

{
    // Proc entry with no school mask filter (accepts all schools)
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSchoolMask(0) // No filter
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    // Test with shadow damage
    auto* shadowSpell = CreateSpellInfo(686, 5, 0); // Shadow Bolt
    DamageInfo shadowDamageInfo(nullptr, nullptr, 100, shadowSpell, SPELL_SCHOOL_MASK_SHADOW, SPELL_DIRECT_DAMAGE);
 
    auto eventInfo = ProcEventInfoBuilder()
        .WithTypeMask(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithHitMask(PROC_HIT_NORMAL)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .WithDamageInfo(&shadowDamageInfo)
        .Build();
 
    // Any school should trigger when no school mask filter is set
    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_SHADOW, sSpellMgr, ProcEventInfoBuilder::WithDamageInfo(), ProcEventInfoBuilder::WithHitMask(), SpellProcEntryBuilder::WithProcFlags(), SpellProcEntryBuilder::WithSchoolMask(), ProcEventInfoBuilder::WithSpellPhaseMask(), SpellProcEntryBuilder::WithSpellPhaseMask(), ProcEventInfoBuilder::WithSpellTypeMask(), and ProcEventInfoBuilder::WithTypeMask().

TEST_F() [22/27]

TEST_F	(	SpellProcIntegrationTest	,
		SpellDamageProc_OnCast
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_CAST)
        .Build();
 
    // Should trigger on cast phase
    auto castScenario = ProcScenarioBuilder()
        .OnSpellDamage()
        .OnCast();
    EXPECT_PROC_TRIGGERS(procEntry, castScenario);
 
    // Should NOT trigger on hit phase when configured for cast only
    auto hitScenario = ProcScenarioBuilder()
        .OnSpellDamage()
        .OnHit();
    EXPECT_PROC_DOES_NOT_TRIGGER(procEntry, hitScenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_DOES_NOT_TRIGGER, EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnCast(), ProcScenarioBuilder::OnHit(), ProcScenarioBuilder::OnSpellDamage(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_SPELL_PHASE_CAST, SpellProcEntryBuilder::WithProcFlags(), and SpellProcEntryBuilder::WithSpellPhaseMask().

TEST_F() [23/27]

TEST_F	(	SpellProcIntegrationTest	,
		SpellDamageProc_OnHit
	)

{
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellTypeMask(PROC_SPELL_TYPE_DAMAGE)
        .WithSpellPhaseMask(PROC_SPELL_PHASE_HIT)
        .Build();
 
    auto scenario = ProcScenarioBuilder()
        .OnSpellDamage()
        .OnHit()
        .WithNormalHit();
 
    EXPECT_PROC_TRIGGERS(procEntry, scenario);
}

References SpellProcEntryBuilder::Build(), EXPECT_PROC_TRIGGERS, ProcScenarioBuilder::OnHit(), ProcScenarioBuilder::OnSpellDamage(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_SPELL_PHASE_HIT, PROC_SPELL_TYPE_DAMAGE, ProcScenarioBuilder::WithNormalHit(), SpellProcEntryBuilder::WithProcFlags(), SpellProcEntryBuilder::WithSpellPhaseMask(), and SpellProcEntryBuilder::WithSpellTypeMask().

TEST_F() [24/27]

TEST_F	(	SpellProcIntegrationTest	,
		SpellFamilyMatch_DifferentFamily
	)

{
    // Create a Warrior spell (family 4)
    auto* triggerSpell = CreateSpellInfo(6343, 4, 0x00000001); // Thunder Clap
 
    auto procEntry = SpellProcEntryBuilder()
        .WithSpellFamilyName(3) // SPELLFAMILY_MAGE - should NOT match
        .WithSpellFamilyMask(flag96(0x00000001, 0, 0))
        .Build();
 
    EXPECT_FALSE(TestSpellFamilyMatch(procEntry.SpellFamilyName, procEntry.SpellFamilyMask, triggerSpell));
}

References SpellProcEntryBuilder::Build(), SpellProcEntryBuilder::WithSpellFamilyMask(), and SpellProcEntryBuilder::WithSpellFamilyName().

TEST_F() [25/27]

TEST_F	(	SpellProcIntegrationTest	,
		SpellFamilyMatch_FlagMismatch
	)

{
    // Create a Mage spell with specific flags
    auto* triggerSpell = CreateSpellInfo(133, 3, 0x00000001); // Fireball flag
 
    auto procEntry = SpellProcEntryBuilder()
        .WithSpellFamilyName(3) // SPELLFAMILY_MAGE
        .WithSpellFamilyMask(flag96(0x00000002, 0, 0)) // Different flag
        .Build();
 
    EXPECT_FALSE(TestSpellFamilyMatch(procEntry.SpellFamilyName, procEntry.SpellFamilyMask, triggerSpell));
}

References SpellProcEntryBuilder::Build(), SpellProcEntryBuilder::WithSpellFamilyMask(), and SpellProcEntryBuilder::WithSpellFamilyName().

TEST_F() [26/27]

TEST_F	(	SpellProcIntegrationTest	,
		SpellFamilyMatch_NoFamilyFilter
	)

{
    // Create any spell
    auto* triggerSpell = CreateSpellInfo(133, 3, 0x00000001);
 
    // Proc with no family filter should match any spell
    auto procEntry = SpellProcEntryBuilder()
        .WithSpellFamilyName(0) // No family filter
        .Build();
 
    EXPECT_TRUE(TestSpellFamilyMatch(procEntry.SpellFamilyName, procEntry.SpellFamilyMask, triggerSpell));
}

References SpellProcEntryBuilder::Build(), and SpellProcEntryBuilder::WithSpellFamilyName().

TEST_F() [27/27]

TEST_F	(	SpellProcIntegrationTest	,
		SpellFamilyMatch_SameFamily
	)

{
    // Create a Mage spell (family 3)
    auto* triggerSpell = CreateSpellInfo(133, 3, 0x00000001); // Fireball
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcFlags(PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG)
        .WithSpellFamilyName(3) // SPELLFAMILY_MAGE
        .WithSpellFamilyMask(flag96(0x00000001, 0, 0))
        .Build();
 
    // Test family match logic
    EXPECT_TRUE(TestSpellFamilyMatch(procEntry.SpellFamilyName, procEntry.SpellFamilyMask, triggerSpell));
}

References SpellProcEntryBuilder::Build(), PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, SpellProcEntryBuilder::WithProcFlags(), SpellProcEntryBuilder::WithSpellFamilyMask(), and SpellProcEntryBuilder::WithSpellFamilyName().