FlatMultimapAuraPatternTest.cpp File Reference

#include "gtest/gtest.h"
#include <boost/container/flat_map.hpp>
#include <cstdint>
#include <set>
#include <vector>

Go to the source code of this file.

Classes
struct	FakeAura

Typedefs
using	AuraMap = boost::container::flat_multimap< uint32_t, FakeAura * >

Functions
	TEST (FlatMultimapAuraPattern, SnapshotUpdate)
	TEST (FlatMultimapAuraPattern, EraseResetToBegin)
	TEST (FlatMultimapAuraPattern, LowerUpperBoundErase)
	TEST (FlatMultimapAuraPattern, SelectiveLowerBoundErase)
	TEST (FlatMultimapAuraPattern, EraseDuringSnapshot)
	TEST (FlatMultimapAuraPattern, InsertDuringSnapshot)
	TEST (FlatMultimapAuraPattern, PredicateRemovalResetBegin)
	TEST (FlatMultimapAuraPattern, PredicateRemovalInKeyRange)
	TEST (FlatMultimapAuraPattern, AuraStateMapErasePattern)
	TEST (FlatMultimapAuraPattern, EmptyMapPatterns)
	TEST (FlatMultimapAuraPattern, SingleElementPatterns)
	TEST (FlatMultimapAuraPattern, EraseAllViaResetBegin)
	TEST (FlatMultimapAuraPattern, DuplicateKeysInterleavedErase)
	TEST (FlatMultimapAuraPattern, DISABLED_StaleIteratorAfterCascade_AsanOnly)
	TEST (FlatMultimapAuraPattern, IteratorResetAfterCascade)

Typedef Documentation

AuraMap

using AuraMap = boost::container::flat_multimap<uint32_t, FakeAura*>

Function Documentation

TEST() [1/15]

TEST	(	FlatMultimapAuraPattern	,
		AuraStateMapErasePattern
	)

{
    // Uses an enum-like key (AuraStateType is an enum in the real code)
    using AuraStateMap = boost::container::flat_multimap<uint32_t, FakeAura*>;
 
    FakeAura a1(10), a2(20), a3(30), a4(40);
    AuraStateMap map;
    // State 1 has multiple entries
    map.emplace(1, &a1);
    map.emplace(1, &a2);
    map.emplace(1, &a3);
    // State 2 has one entry
    map.emplace(2, &a4);
 
    // Remove a2 from state 1 — mirrors _UnapplyAura pattern
    uint32_t auraState = 1;
    FakeAura* target = &a2;
    for (auto itr = map.lower_bound(auraState);
         itr != map.upper_bound(auraState);)
    {
        if (itr->second == target)
        {
            map.erase(itr);
            itr = map.lower_bound(auraState);
            continue;
        }
        ++itr;
    }
 
    EXPECT_EQ(map.count(1), 2u);
    EXPECT_EQ(map.count(2), 1u);
 
    // Verify a2 is gone, a1 and a3 remain
    std::set<FakeAura*> stateOnes;
    for (auto itr = map.lower_bound(1); itr != map.upper_bound(1); ++itr)
        stateOnes.insert(itr->second);
    EXPECT_TRUE(stateOnes.count(&a1));
    EXPECT_FALSE(stateOnes.count(&a2));
    EXPECT_TRUE(stateOnes.count(&a3));
}

TEST() [2/15]

TEST	(	FlatMultimapAuraPattern	,
		DISABLED_StaleIteratorAfterCascade_AsanOnly
	)

{
    FakeAura a1(100), a2(200), a3(300), cascade1(999), cascade2(998);
 
    AuraMap map;
    map.emplace(100, &a1);
    map.emplace(200, &a2);
    map.emplace(300, &a3);
    map.shrink_to_fit();
 
    // caller loop holds an iterator
    AuraMap::iterator iter = map.begin();
 
    // RemoveAura: erase + reset, then cascades grow past capacity -> realloc
    map.erase(iter);
    iter = map.begin();
    map.emplace(999, &cascade1);
    map.emplace(998, &cascade2);
 
    // resume with the pre-cascade iterator: heap-use-after-free under ASAN
    EXPECT_NE(iter->second->spellId, 0u);
}

TEST() [3/15]

TEST	(	FlatMultimapAuraPattern	,
		DuplicateKeysInterleavedErase
	)

{
    FakeAura a1(100), a2(100), a3(100), a4(200), a5(200);
    a2.expired = true;
    a5.expired = true;
 
    AuraMap map;
    map.emplace(100, &a1);
    map.emplace(100, &a2);
    map.emplace(100, &a3);
    map.emplace(200, &a4);
    map.emplace(200, &a5);
 
    // Global erase-reset-to-begin for expired entries
    for (auto i = map.begin(); i != map.end();)
    {
        if (i->second->IsExpired())
        {
            map.erase(i);
            i = map.begin();
        }
        else
            ++i;
    }
 
    EXPECT_EQ(map.size(), 3u);
    EXPECT_EQ(map.count(100), 2u);
    EXPECT_EQ(map.count(200), 1u);
}

References FakeAura::expired.

TEST() [4/15]

TEST	(	FlatMultimapAuraPattern	,
		EmptyMapPatterns
	)

{
    AuraMap map;
 
    // Snapshot of empty map
    std::vector<FakeAura*> snapshot;
    for (auto& [id, aura] : map)
        snapshot.push_back(aura);
    EXPECT_TRUE(snapshot.empty());
 
    // Erase-reset-to-begin on empty map
    for (auto i = map.begin(); i != map.end();)
    {
        map.erase(i);
        i = map.begin();
    }
    EXPECT_TRUE(map.empty());
 
    // lower_bound/upper_bound on empty map
    for (auto itr = map.lower_bound(100); itr != map.upper_bound(100);)
    {
        map.erase(itr);
        itr = map.lower_bound(100);
    }
    EXPECT_TRUE(map.empty());
}

TEST() [5/15]

TEST	(	FlatMultimapAuraPattern	,
		EraseAllViaResetBegin
	)

{
    constexpr int N = 50;
    std::vector<FakeAura> auras;
    auras.reserve(N);
 
    AuraMap map;
    for (int i = 0; i < N; ++i)
    {
        auras.emplace_back(static_cast<uint32_t>(i * 10));
        map.emplace(auras.back().spellId, &auras.back());
    }
 
    ASSERT_EQ(map.size(), static_cast<size_t>(N));
 
    // Remove everything — every entry triggers erase + reset
    for (auto i = map.begin(); i != map.end();)
    {
        map.erase(i);
        i = map.begin();
    }
 
    EXPECT_TRUE(map.empty());
}

TEST() [6/15]

TEST	(	FlatMultimapAuraPattern	,
		EraseDuringSnapshot
	)

{
    FakeAura a1(100), a2(200), a3(300), a4(400);
    AuraMap map;
    map.emplace(100, &a1);
    map.emplace(200, &a2);
    map.emplace(300, &a3);
    map.emplace(400, &a4);
 
    // Snapshot pointers
    std::vector<FakeAura*> snapshot;
    snapshot.reserve(map.size());
    for (auto& [id, aura] : map)
        snapshot.push_back(aura);
 
    // Process snapshot; during processing, erase entries from the map
    std::vector<uint32_t> processed;
    for (FakeAura* aura : snapshot)
    {
        if (aura->IsRemoved())
            continue;
 
        processed.push_back(aura->spellId);
 
        // Simulate cascading removal: processing a1 causes a3 to be
        // removed from the map and marked removed
        if (aura == &a1)
        {
            a3.removed = true;
            // Erase a3 from map by finding it
            for (auto it = map.begin(); it != map.end(); ++it)
            {
                if (it->second == &a3)
                {
                    map.erase(it);
                    break;
                }
            }
        }
    }
 
    // a1, a2, a4 processed; a3 skipped due to IsRemoved()
    ASSERT_EQ(processed.size(), 3u);
    EXPECT_EQ(processed[0], 100u);
    EXPECT_EQ(processed[1], 200u);
    EXPECT_EQ(processed[2], 400u);
 
    // Map should have 3 entries (a3 was erased)
    EXPECT_EQ(map.size(), 3u);
}

TEST() [7/15]

TEST	(	FlatMultimapAuraPattern	,
		EraseResetToBegin
	)

{
    FakeAura a1(100), a2(200), a3(300), a4(400), a5(500);
    a2.expired = true;
    a4.expired = true;
 
    AuraMap map;
    map.emplace(100, &a1);
    map.emplace(200, &a2);
    map.emplace(300, &a3);
    map.emplace(400, &a4);
    map.emplace(500, &a5);
 
    std::vector<FakeAura*> removed;
 
    // Mirrors the expire loop in _UpdateSpells / RemoveOwnedAuras
    for (AuraMap::iterator i = map.begin(); i != map.end();)
    {
        if (i->second->IsExpired())
        {
            FakeAura* aura = i->second;
            map.erase(i);
            i = map.begin();  // reset — flat_multimap invalidates all
            removed.push_back(aura);
        }
        else
            ++i;
    }
 
    // a2 and a4 should have been removed
    ASSERT_EQ(removed.size(), 2u);
    EXPECT_EQ(removed[0]->spellId, 200u);
    EXPECT_EQ(removed[1]->spellId, 400u);
 
    // Remaining entries
    ASSERT_EQ(map.size(), 3u);
    std::set<uint32_t> remaining;
    for (auto& [id, aura] : map)
        remaining.insert(id);
    EXPECT_TRUE(remaining.count(100));
    EXPECT_TRUE(remaining.count(300));
    EXPECT_TRUE(remaining.count(500));
}

TEST() [8/15]

TEST	(	FlatMultimapAuraPattern	,
		InsertDuringSnapshot
	)

{
    FakeAura a1(100), a2(200);
    FakeAura a3(300);  // will be inserted during snapshot iteration
 
    AuraMap map;
    map.emplace(100, &a1);
    map.emplace(200, &a2);
 
    // Snapshot before iteration
    std::vector<FakeAura*> snapshot;
    snapshot.reserve(map.size());
    for (auto& [id, aura] : map)
        snapshot.push_back(aura);
 
    ASSERT_EQ(snapshot.size(), 2u);
 
    // During iteration, insert a new entry
    std::vector<uint32_t> processed;
    for (FakeAura* aura : snapshot)
    {
        if (!aura->IsRemoved())
        {
            processed.push_back(aura->spellId);
            aura->updated = true;
        }
 
        // Insert a3 while iterating the snapshot
        if (aura == &a1)
            map.emplace(300, &a3);
    }
 
    // Only the original 2 were processed
    ASSERT_EQ(processed.size(), 2u);
    EXPECT_EQ(processed[0], 100u);
    EXPECT_EQ(processed[1], 200u);
 
    // a3 was NOT processed (not in snapshot)
    EXPECT_FALSE(a3.updated);
 
    // But it IS in the map for future iterations
    EXPECT_EQ(map.size(), 3u);
    EXPECT_EQ(map.count(300), 1u);
}

References FakeAura::updated.

TEST() [9/15]

TEST	(	FlatMultimapAuraPattern	,
		IteratorResetAfterCascade
	)

{
    FakeAura a1(100), a2(200), a3(300), cascade1(999), cascade2(998);
 
    AuraMap map;
    map.emplace(100, &a1);
    map.emplace(200, &a2);
    map.emplace(300, &a3);
    map.shrink_to_fit();
 
    AuraMap::iterator iter = map.begin();
 
    map.erase(iter);
    map.emplace(999, &cascade1);
    map.emplace(998, &cascade2);
    iter = map.begin(); // reset AFTER the cascades
 
    std::set<uint32_t> seen;
    for (; iter != map.end(); ++iter)
        seen.insert(iter->second->spellId);
 
    EXPECT_EQ(seen.size(), 4u);
    EXPECT_FALSE(seen.count(100));  // removed
    EXPECT_TRUE(seen.count(200));
    EXPECT_TRUE(seen.count(300));
    EXPECT_TRUE(seen.count(999));   // cascade-applied
    EXPECT_TRUE(seen.count(998));
}

TEST() [10/15]

TEST	(	FlatMultimapAuraPattern	,
		LowerUpperBoundErase
	)

{
    FakeAura a1(100), a2(100), a3(100), a4(200), a5(200);
    AuraMap map;
    map.emplace(100, &a1);
    map.emplace(100, &a2);
    map.emplace(100, &a3);
    map.emplace(200, &a4);
    map.emplace(200, &a5);
 
    // Remove all entries with key 100 — mirrors RemoveOwnedAura(spellId)
    uint32_t targetKey = 100;
    for (auto itr = map.lower_bound(targetKey);
         itr != map.upper_bound(targetKey);)
    {
        map.erase(itr);
        itr = map.lower_bound(targetKey);  // reset after erase
    }
 
    // All key-100 entries gone
    EXPECT_EQ(map.count(100), 0u);
 
    // Key-200 entries untouched
    EXPECT_EQ(map.count(200), 2u);
    ASSERT_EQ(map.size(), 2u);
}

TEST() [11/15]

TEST	(	FlatMultimapAuraPattern	,
		PredicateRemovalInKeyRange
	)

{
    FakeAura a1(100), a2(100), a3(100), a4(100);
    a1.expired = false;
    a2.expired = true;
    a3.expired = false;
    a4.expired = true;
 
    AuraMap map;
    map.emplace(100, &a1);
    map.emplace(100, &a2);
    map.emplace(100, &a3);
    map.emplace(100, &a4);
    map.emplace(200, new FakeAura(200));  // different key, untouched
 
    uint32_t spellId = 100;
    for (auto iter = map.lower_bound(spellId);
         iter != map.upper_bound(spellId);)
    {
        if (iter->second->IsExpired())
        {
            map.erase(iter);
            iter = map.lower_bound(spellId);
            continue;
        }
        ++iter;
    }
 
    // 2 expired removed, 2 non-expired remain under key 100
    EXPECT_EQ(map.count(100), 2u);
    // Key 200 untouched
    EXPECT_EQ(map.count(200), 1u);
 
    // Clean up heap-allocated entry
    for (auto& [id, aura] : map)
        if (id == 200)
            delete aura;
}

References FakeAura::expired.

TEST() [12/15]

TEST	(	FlatMultimapAuraPattern	,
		PredicateRemovalResetBegin
	)

{
    FakeAura a1(100), a2(200), a3(300), a4(400), a5(500);
    // Remove even-numbered spell IDs
    AuraMap map;
    map.emplace(100, &a1);
    map.emplace(200, &a2);
    map.emplace(300, &a3);
    map.emplace(400, &a4);
    map.emplace(500, &a5);
 
    auto shouldRemove = [](FakeAura const* a) {
        return (a->spellId % 200) == 0;
    };
 
    for (AuraMap::iterator iter = map.begin(); iter != map.end();)
    {
        if (shouldRemove(iter->second))
        {
            map.erase(iter);
            iter = map.begin();  // reset — mirrors RemoveOwnedAuras
            continue;
        }
        ++iter;
    }
 
    ASSERT_EQ(map.size(), 3u);
    EXPECT_EQ(map.count(100), 1u);
    EXPECT_EQ(map.count(200), 0u);
    EXPECT_EQ(map.count(300), 1u);
    EXPECT_EQ(map.count(400), 0u);
    EXPECT_EQ(map.count(500), 1u);
}

TEST() [13/15]

TEST	(	FlatMultimapAuraPattern	,
		SelectiveLowerBoundErase
	)

{
    FakeAura a1(100), a2(100), a3(100);
    // Only remove entries whose spellId matches AND which are expired
    a1.expired = false;
    a2.expired = true;
    a3.expired = false;
 
    AuraMap map;
    map.emplace(100, &a1);
    map.emplace(100, &a2);
    map.emplace(100, &a3);
 
    uint32_t targetKey = 100;
    for (auto itr = map.lower_bound(targetKey);
         itr != map.upper_bound(targetKey);)
    {
        if (itr->second->IsExpired())
        {
            map.erase(itr);
            itr = map.lower_bound(targetKey);
        }
        else
            ++itr;
    }
 
    // Only a2 removed
    EXPECT_EQ(map.count(100), 2u);
 
    // Verify the right ones survived
    std::set<FakeAura*> survivors;
    for (auto itr = map.lower_bound(100); itr != map.upper_bound(100); ++itr)
        survivors.insert(itr->second);
    EXPECT_TRUE(survivors.count(&a1));
    EXPECT_FALSE(survivors.count(&a2));
    EXPECT_TRUE(survivors.count(&a3));
}

References FakeAura::expired.

TEST() [14/15]

TEST	(	FlatMultimapAuraPattern	,
		SingleElementPatterns
	)

{
    FakeAura a1(100);
    a1.expired = true;
 
    AuraMap map;
    map.emplace(100, &a1);
 
    // Erase-reset-to-begin with single element
    for (auto i = map.begin(); i != map.end();)
    {
        if (i->second->IsExpired())
        {
            map.erase(i);
            i = map.begin();
        }
        else
            ++i;
    }
 
    EXPECT_TRUE(map.empty());
}

References FakeAura::expired.

TEST() [15/15]

TEST	(	FlatMultimapAuraPattern	,
		SnapshotUpdate
	)

{
    FakeAura a1(100), a2(100), a3(200), a4(300);
    AuraMap map;
    map.emplace(100, &a1);
    map.emplace(100, &a2);
    map.emplace(200, &a3);
    map.emplace(300, &a4);
 
    // Snapshot pointers (mirrors Unit::_UpdateSpells)
    std::vector<FakeAura*> snapshot;
    snapshot.reserve(map.size());
    for (auto& [id, aura] : map)
        snapshot.push_back(aura);
 
    ASSERT_EQ(snapshot.size(), 4u);
 
    // Mark a2 as removed mid-iteration (simulates cascading removal)
    a2.removed = true;
 
    // Process snapshot — skip removed entries
    for (FakeAura* aura : snapshot)
    {
        if (!aura->IsRemoved())
            aura->updated = true;
    }
 
    EXPECT_TRUE(a1.updated);
    EXPECT_FALSE(a2.updated);  // skipped — was removed
    EXPECT_TRUE(a3.updated);
    EXPECT_TRUE(a4.updated);
}

References FakeAura::updated.