SpellProcPipelineTest.cpp File Reference

End-to-end integration tests for the full proc pipeline. More...

#include "ProcChanceTestHelper.h"
#include "ProcEventInfoHelper.h"
#include "AuraStub.h"
#include "UnitStub.h"
#include "gtest/gtest.h"

Go to the source code of this file.

Classes
class	SpellProcPipelineTest

Functions
	TEST_F (SpellProcPipelineTest, FullFlow_BasicProc_100Percent)
	TEST_F (SpellProcPipelineTest, FullFlow_BasicProc_0Percent)
	TEST_F (SpellProcPipelineTest, FullFlow_WithCooldown)
	TEST_F (SpellProcPipelineTest, FullFlow_WithCharges)
	TEST_F (SpellProcPipelineTest, FullFlow_WithStacks)
	TEST_F (SpellProcPipelineTest, Combined_ChargesAndCooldown)
	TEST_F (SpellProcPipelineTest, Combined_PPM_AndCooldown)
	TEST_F (SpellProcPipelineTest, Combined_Level60Reduction_WithCooldown)
	TEST_F (SpellProcPipelineTest, Scenario_OmenOfClarity)
	TEST_F (SpellProcPipelineTest, Scenario_LeaderOfThePack)
	TEST_F (SpellProcPipelineTest, Scenario_ArtOfWar)
	TEST_F (SpellProcPipelineTest, Scenario_LightningShield)
	TEST_F (SpellProcPipelineTest, Scenario_WanderingPlague)
	TEST_F (SpellProcPipelineTest, EdgeCase_NoAura_NoProcPossible)
	TEST_F (SpellProcPipelineTest, EdgeCase_ZeroCooldown_AllowsRapidProcs)
	TEST_F (SpellProcPipelineTest, EdgeCase_VeryLongCooldown)
	TEST_F (SpellProcPipelineTest, EdgeCase_ManyCharges)
	TEST_F (SpellProcPipelineTest, ActorLevel_AffectsProcChance)
	TEST_F (SpellProcPipelineTest, WeaponSpeed_AffectsPPMChance)

Detailed Description

End-to-end integration tests for the full proc pipeline.

Tests the complete proc execution flow:

1. Cooldown check (IsProcOnCooldown)
2. Chance calculation (CalcProcChance)
3. Roll check (rand_chance)
4. Cooldown application
5. Charge consumption (ConsumeProcCharges)

Definition in file SpellProcPipelineTest.cpp.

Function Documentation

TEST_F() [1/19]

TEST_F	(	SpellProcPipelineTest	,
		ActorLevel_AffectsProcChance
	)

{
    _scenario->WithAura(12345);
    _scenario->WithActorLevel(60);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(30.0f)
        .WithAttributesMask(PROC_ATTR_REDUCE_PROC_60)
        .Build();
 
    // At level 60, full 30% chance
    // Roll of 25 should pass
    EXPECT_TRUE(_scenario->SimulateProc(procEntry, 25.0f));
 
    // Reset
    _scenario->GetAura()->ResetProcCooldown();
 
    // Change to level 80
    _scenario->WithActorLevel(80);
 
    // At level 80, only 10% chance
    // Roll of 25 should fail
    EXPECT_FALSE(_scenario->SimulateProc(procEntry, 25.0f));
}

References SpellProcEntryBuilder::Build(), PROC_ATTR_REDUCE_PROC_60, SpellProcEntryBuilder::WithAttributesMask(), and SpellProcEntryBuilder::WithChance().

TEST_F() [2/19]

TEST_F	(	SpellProcPipelineTest	,
		Combined_ChargesAndCooldown
	)

{
    _scenario->WithAura(12345, 5);  // 5 charges
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .WithCooldown(500ms)
        .Build();
 
    // First proc at t=0
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    EXPECT_EQ(_scenario->GetAura()->GetCharges(), 4);
 
    // Blocked at t=0 (cooldown)
    EXPECT_FALSE(_scenario->SimulateProc(procEntry));
    EXPECT_EQ(_scenario->GetAura()->GetCharges(), 4);
 
    // Wait and proc again at t=600ms
    _scenario->AdvanceTime(600ms);
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    EXPECT_EQ(_scenario->GetAura()->GetCharges(), 3);
 
    // Blocked at t=600ms
    EXPECT_FALSE(_scenario->SimulateProc(procEntry));
    EXPECT_EQ(_scenario->GetAura()->GetCharges(), 3);
}

References SpellProcEntryBuilder::Build(), SpellProcEntryBuilder::WithChance(), and SpellProcEntryBuilder::WithCooldown().

TEST_F() [3/19]

TEST_F	(	SpellProcPipelineTest	,
		Combined_Level60Reduction_WithCooldown
	)

{
    _scenario->WithAura(12345);
    _scenario->WithActorLevel(80);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(30.0f)
        .WithAttributesMask(PROC_ATTR_REDUCE_PROC_60)
        .WithCooldown(1000ms)
        .Build();
 
    // Level 80: 30% * (1 - 20/30) = 10% effective chance
    // Roll of 5 should pass
    EXPECT_TRUE(_scenario->SimulateProc(procEntry, 5.0f));
 
    // Blocked by cooldown
    EXPECT_FALSE(_scenario->SimulateProc(procEntry, 5.0f));
 
    // Wait and try again
    _scenario->AdvanceTime(1100ms);
 
    // Roll of 15 should fail (10% chance)
    EXPECT_FALSE(_scenario->SimulateProc(procEntry, 15.0f));
}

References SpellProcEntryBuilder::Build(), PROC_ATTR_REDUCE_PROC_60, SpellProcEntryBuilder::WithAttributesMask(), SpellProcEntryBuilder::WithChance(), and SpellProcEntryBuilder::WithCooldown().

TEST_F() [4/19]

TEST_F	(	SpellProcPipelineTest	,
		Combined_PPM_AndCooldown
	)

{
    _scenario->WithAura(12345);
    _scenario->WithWeaponSpeed(0, 2500);  // BASE_ATTACK = 2500ms
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcsPerMinute(6.0f)  // 25% with 2500ms weapon
        .WithCooldown(1000ms)
        .Build();
 
    // First proc (roll 0 = always pass)
    EXPECT_TRUE(_scenario->SimulateProc(procEntry, 0.0f));
 
    // Blocked by cooldown even if roll would pass
    EXPECT_FALSE(_scenario->SimulateProc(procEntry, 0.0f));
 
    // Wait for cooldown
    _scenario->AdvanceTime(1100ms);
 
    // Can proc again
    EXPECT_TRUE(_scenario->SimulateProc(procEntry, 0.0f));
}

References SpellProcEntryBuilder::Build(), SpellProcEntryBuilder::WithCooldown(), and SpellProcEntryBuilder::WithProcsPerMinute().

TEST_F() [5/19]

TEST_F	(	SpellProcPipelineTest	,
		EdgeCase_ManyCharges
	)

{
    _scenario->WithAura(12345, 100);  // 100 charges
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .Build();
 
    // Consume all charges
    for (int i = 100; i > 0; --i)
    {
        EXPECT_EQ(_scenario->GetAura()->GetCharges(), i);
        EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    }
 
    EXPECT_TRUE(_scenario->GetAura()->IsRemoved());
}

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

TEST_F() [6/19]

TEST_F	(	SpellProcPipelineTest	,
		EdgeCase_NoAura_NoProcPossible
	)

{
    // Don't set up aura
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .Build();
 
    EXPECT_FALSE(_scenario->SimulateProc(procEntry));
}

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

TEST_F() [7/19]

TEST_F	(	SpellProcPipelineTest	,
		EdgeCase_VeryLongCooldown
	)

{
    _scenario->WithAura(12345);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .WithCooldown(300000ms)  // 5 minute cooldown
        .Build();
 
    // First proc
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
 
    // Blocked even after 4 minutes
    _scenario->AdvanceTime(240000ms);
    EXPECT_FALSE(_scenario->SimulateProc(procEntry));
 
    // Allowed after 5 minutes
    _scenario->AdvanceTime(60001ms);
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
}

References SpellProcEntryBuilder::Build(), SpellProcEntryBuilder::WithChance(), and SpellProcEntryBuilder::WithCooldown().

TEST_F() [8/19]

TEST_F	(	SpellProcPipelineTest	,
		EdgeCase_ZeroCooldown_AllowsRapidProcs
	)

{
    _scenario->WithAura(12345);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .WithCooldown(0ms)
        .Build();
 
    // Multiple rapid procs should all succeed
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
}

References SpellProcEntryBuilder::Build(), SpellProcEntryBuilder::WithChance(), and SpellProcEntryBuilder::WithCooldown().

TEST_F() [9/19]

TEST_F	(	SpellProcPipelineTest	,
		FullFlow_BasicProc_0Percent
	)

{
    _scenario->WithAura(12345);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(0.0f)
        .Build();
 
    // 0% chance should never proc (when roll is > 0)
    EXPECT_FALSE(_scenario->SimulateProc(procEntry, 50.0f));
}

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

TEST_F() [10/19]

TEST_F	(	SpellProcPipelineTest	,
		FullFlow_BasicProc_100Percent
	)

{
    _scenario->WithAura(12345);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .Build();
 
    // 100% chance should always proc
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
}

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

TEST_F() [11/19]

TEST_F	(	SpellProcPipelineTest	,
		FullFlow_WithCharges
	)

{
    _scenario->WithAura(12345, 3);  // 3 charges
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .Build();
 
    // First proc - 3 -> 2 charges
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    EXPECT_EQ(_scenario->GetAura()->GetCharges(), 2);
 
    // Second proc - 2 -> 1 charges
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    EXPECT_EQ(_scenario->GetAura()->GetCharges(), 1);
 
    // Third proc - 1 -> 0 charges, aura removed
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    EXPECT_EQ(_scenario->GetAura()->GetCharges(), 0);
    EXPECT_TRUE(_scenario->GetAura()->IsRemoved());
}

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

TEST_F() [12/19]

TEST_F	(	SpellProcPipelineTest	,
		FullFlow_WithCooldown
	)

{
    _scenario->WithAura(12345);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .WithCooldown(1000ms)
        .Build();
 
    // First proc succeeds
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
 
    // Second proc blocked by cooldown
    EXPECT_FALSE(_scenario->SimulateProc(procEntry));
 
    // Wait for cooldown
    _scenario->AdvanceTime(1100ms);
 
    // Third proc succeeds
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
}

References SpellProcEntryBuilder::Build(), SpellProcEntryBuilder::WithChance(), and SpellProcEntryBuilder::WithCooldown().

TEST_F() [13/19]

TEST_F	(	SpellProcPipelineTest	,
		FullFlow_WithStacks
	)

{
    _scenario->WithAura(12345, 0, 5);  // 5 stacks, no charges
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .WithAttributesMask(PROC_ATTR_USE_STACKS_FOR_CHARGES)
        .Build();
 
    // Each proc consumes one stack
    for (int i = 5; i > 0; --i)
    {
        EXPECT_EQ(_scenario->GetAura()->GetStackAmount(), i);
        EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    }
 
    EXPECT_EQ(_scenario->GetAura()->GetStackAmount(), 0);
    EXPECT_TRUE(_scenario->GetAura()->IsRemoved());
}

References SpellProcEntryBuilder::Build(), PROC_ATTR_USE_STACKS_FOR_CHARGES, SpellProcEntryBuilder::WithAttributesMask(), and SpellProcEntryBuilder::WithChance().

TEST_F() [14/19]

TEST_F	(	SpellProcPipelineTest	,
		Scenario_ArtOfWar
	)

{
    // Art of War: 2 charges (typically)
    _scenario->WithAura(53486, 2);  // Art of War
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .Build();
 
    // First Exorcism - consumes charge
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    EXPECT_EQ(_scenario->GetAura()->GetCharges(), 1);
 
    // Second Exorcism - consumes last charge
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    EXPECT_EQ(_scenario->GetAura()->GetCharges(), 0);
    EXPECT_TRUE(_scenario->GetAura()->IsRemoved());
}

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

TEST_F() [15/19]

TEST_F	(	SpellProcPipelineTest	,
		Scenario_LeaderOfThePack
	)

{
    // Leader of the Pack: 6 second ICD
    _scenario->WithAura(24932);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .WithCooldown(6000ms)
        .Build();
 
    // First crit - procs
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
 
    // Second crit at 1 second - blocked
    _scenario->AdvanceTime(1000ms);
    EXPECT_FALSE(_scenario->SimulateProc(procEntry));
 
    // Third crit at 5 seconds - blocked
    _scenario->AdvanceTime(4000ms);
    EXPECT_FALSE(_scenario->SimulateProc(procEntry));
 
    // Fourth crit at 6.1 seconds - allowed
    _scenario->AdvanceTime(1100ms);
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
}

References SpellProcEntryBuilder::Build(), SpellProcEntryBuilder::WithChance(), and SpellProcEntryBuilder::WithCooldown().

TEST_F() [16/19]

TEST_F	(	SpellProcPipelineTest	,
		Scenario_LightningShield
	)

{
    // Lightning Shield: 3 charges (orbs)
    _scenario->WithAura(324, 3);  // Lightning Shield Rank 1
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .Build();
 
    // First hit - uses orb
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    EXPECT_EQ(_scenario->GetAura()->GetCharges(), 2);
 
    // Second hit - uses orb
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    EXPECT_EQ(_scenario->GetAura()->GetCharges(), 1);
 
    // Third hit - last orb, aura removed
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
    EXPECT_TRUE(_scenario->GetAura()->IsRemoved());
}

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

TEST_F() [17/19]

TEST_F	(	SpellProcPipelineTest	,
		Scenario_OmenOfClarity
	)

{
    // Omen of Clarity: 6 PPM, no cooldown, no charges
    _scenario->WithAura(16864);  // Omen of Clarity
    _scenario->WithWeaponSpeed(0, 2500);  // Staff
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcsPerMinute(6.0f)  // 25% with 2500ms
        .Build();
 
    // Simulate multiple hits
    int procCount = 0;
    for (int i = 0; i < 10; ++i)
    {
        // Roll values simulating ~25% success rate
        float roll = (i % 4 == 0) ? 10.0f : 50.0f;
        if (_scenario->SimulateProc(procEntry, roll))
            procCount++;
    }
 
    // With deterministic rolls, should have 3 procs (indexes 0, 4, 8)
    // But our test is roll > chance check, so roll 10 fails against 25% chance
    // Actually roll 0 always passes, non-zero rolls check roll > chance
}

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

TEST_F() [18/19]

TEST_F	(	SpellProcPipelineTest	,
		Scenario_WanderingPlague
	)

{
    // Wandering Plague: 1 second ICD
    _scenario->WithAura(49217);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithChance(100.0f)
        .WithCooldown(1000ms)
        .Build();
 
    // First tick procs
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
 
    // Rapid ticks blocked
    _scenario->AdvanceTime(200ms);
    EXPECT_FALSE(_scenario->SimulateProc(procEntry));
 
    _scenario->AdvanceTime(200ms);
    EXPECT_FALSE(_scenario->SimulateProc(procEntry));
 
    _scenario->AdvanceTime(200ms);
    EXPECT_FALSE(_scenario->SimulateProc(procEntry));
 
    // After 1 second total, can proc again
    _scenario->AdvanceTime(600ms);
    EXPECT_TRUE(_scenario->SimulateProc(procEntry));
}

References SpellProcEntryBuilder::Build(), SpellProcEntryBuilder::WithChance(), and SpellProcEntryBuilder::WithCooldown().

TEST_F() [19/19]

TEST_F	(	SpellProcPipelineTest	,
		WeaponSpeed_AffectsPPMChance
	)

{
    _scenario->WithAura(12345);
 
    auto procEntry = SpellProcEntryBuilder()
        .WithProcsPerMinute(6.0f)
        .Build();
 
    // Fast dagger (1400ms): 14% chance
    _scenario->WithWeaponSpeed(0, 1400);
    // Roll of 10 should pass (< 14%)
    EXPECT_TRUE(_scenario->SimulateProc(procEntry, 10.0f));
 
    // Reset cooldown
    _scenario->GetAura()->ResetProcCooldown();
 
    // Slow 2H (3300ms): 33% chance
    _scenario->WithWeaponSpeed(0, 3300);
    // Roll of 30 should pass (< 33%)
    EXPECT_TRUE(_scenario->SimulateProc(procEntry, 30.0f));
}

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