CursiveTestFramework.lua

-- CursiveTestFramework.lua
-- In-game testing framework for Cursive DoT tracking addon
-- Usage: /cursivetest help

CursiveTest = CursiveTest or {}

-- ============================================
-- Test 1: Trinket Duration Test
-- ============================================
function CursiveTest:TestTrinketDuration()
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[CursiveTest]|r Eye of Dormant Corruption Test")
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    
    local testCases = {
        {spell = "Corruption", baseDuration = 18, trinketBonus = 3, expected = 21},
        {spell = "Shadow Word: Pain", baseDuration = 24, trinketBonus = 3, expected = 27},
    }
    
    for _, test in ipairs(testCases) do
        DEFAULT_CHAT_FRAME:AddMessage(string.format("  |cFFFFFF00%s:|r", test.spell))
        DEFAULT_CHAT_FRAME:AddMessage(string.format("    Base Duration: %d sec", test.baseDuration))
        DEFAULT_CHAT_FRAME:AddMessage(string.format("    With Trinket: %d sec expected", test.expected))
    end
    
    -- Check if trinket is equipped
    local hasTrinket = false
    for slot = 13, 14 do
        local link = GetInventoryItemLink("player", slot)
        if link then
            local _, _, itemId = string.find(link, "item:(%d+)")
            if itemId and tonumber(itemId) == 55111 then
                hasTrinket = true
                DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00Trinket EQUIPPED in slot " .. slot .. "|r")
            end
        end
    end
    
    if not hasTrinket then
        DEFAULT_CHAT_FRAME:AddMessage("|cFFFF0000Trinket NOT equipped|r")
    end
    
    DEFAULT_CHAT_FRAME:AddMessage("")
    DEFAULT_CHAT_FRAME:AddMessage("|cFFFF6600IMPORTANT:|r If DoT disappears at 3 sec instead of 0, the bug is present!")
end

-- ============================================
-- Test 2: Base Duration Verification
-- ============================================
function CursiveTest:TestBaseDurations()
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[CursiveTest]|r Base Duration Verification")
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    
    local expectedBase = {
        -- Warlock
        {name = "Corruption", expected = 18, class = "Warlock"},
        {name = "Curse of Agony", expected = 24, class = "Warlock"},
        {name = "Siphon Life", expected = 30, class = "Warlock"},
        {name = "Dark Harvest", expected = 8, class = "Warlock"},
        -- Priest
        {name = "Shadow Word: Pain", expected = 24, class = "Priest"},
        -- Druid
        {name = "Rip (5 CP)", expected = 18, class = "Druid"},
        {name = "Rake", expected = 9, class = "Druid"},
    }
    
    DEFAULT_CHAT_FRAME:AddMessage("Expected Base Durations (without modifiers):")
    DEFAULT_CHAT_FRAME:AddMessage("")
    
    local currentClass = "None"
    for _, spell in ipairs(expectedBase) do
        if spell.class ~= currentClass then
            currentClass = spell.class
            DEFAULT_CHAT_FRAME:AddMessage(string.format("|cFFFFFF00[%s]|r", currentClass))
        end
        DEFAULT_CHAT_FRAME:AddMessage(string.format("  %s: %d sec", spell.name, spell.expected))
    end
end

-- ============================================
-- Test 3: Rip Combo Point Duration Test
-- ============================================
function CursiveTest:TestRipDuration()
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[CursiveTest]|r Rip Duration Test (Turtle WoW)")
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    
    local expectedDurations = {
        [1] = 10,
        [2] = 12,
        [3] = 14,
        [4] = 16,
        [5] = 18,
    }
    
    DEFAULT_CHAT_FRAME:AddMessage("Rip Duration per Combo Point:")
    DEFAULT_CHAT_FRAME:AddMessage("Formula: Duration = 8 + (CP * 2)")
    DEFAULT_CHAT_FRAME:AddMessage("")
    
    for cp = 1, 5 do
        local calculated = 8 + (cp * 2)
        local expected = expectedDurations[cp]
        local status = (calculated == expected) and "|cFF00FF00OK|r" or "|cFFFF0000ERROR|r"
        DEFAULT_CHAT_FRAME:AddMessage(string.format("  %d CP: %d sec expected, %d sec calculated [%s]", 
            cp, expected, calculated, status))
    end
    
    DEFAULT_CHAT_FRAME:AddMessage("")
    local currentCP = GetComboPoints("player", "target") or 0
    DEFAULT_CHAT_FRAME:AddMessage("Current Combo Points: " .. currentCP)
end

-- ============================================
-- Test 4: Rake Bleed Immunity Test
-- ============================================
function CursiveTest:TestRakeImmunity()
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[CursiveTest]|r Rake Bleed Immunity Test")
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    
    local immuneTypes = {"Elemental", "Undead", "Mechanical"}
    
    DEFAULT_CHAT_FRAME:AddMessage("Bleed-immune Creature Types:")
    for _, ctype in ipairs(immuneTypes) do
        DEFAULT_CHAT_FRAME:AddMessage("  - " .. ctype)
    end
    
    DEFAULT_CHAT_FRAME:AddMessage("")
    
    if UnitExists("target") then
        local targetType = UnitCreatureType("target") or "Unknown"
        local targetName = UnitName("target") or "No Target"
        DEFAULT_CHAT_FRAME:AddMessage(string.format("Current Target: |cFFFFFF00%s|r", targetName))
        DEFAULT_CHAT_FRAME:AddMessage(string.format("Creature Type: |cFFFFFF00%s|r", targetType))
        
        local isImmune = (targetType == "Elemental" or targetType == "Undead" or targetType == "Mechanical")
        if isImmune then
            DEFAULT_CHAT_FRAME:AddMessage("|cFFFF0000Bleed-Immune: YES - Rake bleed should NOT be tracked|r")
        else
            DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00Bleed-Immune: NO - Rake bleed can be tracked|r")
        end
    else
        DEFAULT_CHAT_FRAME:AddMessage("|cFFFF6600No target selected.|r")
    end
end

-- ============================================
-- Test 5: Current DoT Status
-- ============================================
function CursiveTest:TestCurrentDoTs()
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[CursiveTest]|r Current DoT Status")
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    
    if not Cursive or not Cursive.curses or not Cursive.curses.guids then
        DEFAULT_CHAT_FRAME:AddMessage("|cFFFF0000Cursive not loaded or no active DoTs|r")
        return
    end
    
    local hasDoTs = false
    for guid, curseData in pairs(Cursive.curses.guids) do
        for curseName, data in pairs(curseData) do
            hasDoTs = true
            local remaining = Cursive.curses:TimeRemaining(data)
            DEFAULT_CHAT_FRAME:AddMessage(string.format("  |cFFFFFF00%s|r on %s: %.1f sec remaining", 
                curseName, guid, remaining))
        end
    end
    
    if not hasDoTs then
        DEFAULT_CHAT_FRAME:AddMessage("No active DoTs being tracked.")
    end
end

-- ============================================
-- Debug: Talent Info
-- ============================================
function CursiveTest:DebugTalents()
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[CursiveTest]|r Talent Debug (Affliction Tree)")
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    
    for i = 1, 25 do
        local name, _, _, _, points = GetTalentInfo(1, i)
        if name then
            DEFAULT_CHAT_FRAME:AddMessage(string.format("  [%d] %s: %d points", i, name, points or 0))
        end
    end
end

-- ============================================
-- Debug: Exact Duration Values
-- ============================================
function CursiveTest:DebugDuration()
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[CursiveTest]|r Exact Duration Debug")
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    
    if not Cursive or not Cursive.curses then
        DEFAULT_CHAT_FRAME:AddMessage("|cFFFF0000Cursive not loaded|r")
        return
    end
    
    -- Get tracked spell IDs for current class
    local trackedSpells = Cursive.curses.trackedCurseIds
    if not trackedSpells then
        DEFAULT_CHAT_FRAME:AddMessage("|cFFFF0000No tracked spells found|r")
        return
    end
    
    -- Key spells to check (Warlock Affliction)
    local spellsToCheck = {
        {id = 25311, name = "Corruption R7", base = 18},
        {id = 11713, name = "Curse of Agony R6", base = 24},
        {id = 18881, name = "Siphon Life R4", base = 30},
        {id = 52552, name = "Dark Harvest R3", base = 8},
    }
    
    DEFAULT_CHAT_FRAME:AddMessage("")
    DEFAULT_CHAT_FRAME:AddMessage("|cFFFFFF00Spell Durations (Base vs Calculated):|r")
    DEFAULT_CHAT_FRAME:AddMessage("")
    
    for _, spell in ipairs(spellsToCheck) do
        if trackedSpells[spell.id] then
            local calculatedDuration = Cursive.curses:GetCurseDuration(spell.id)
            local storedDuration = trackedSpells[spell.id].duration
            local diff = spell.base - calculatedDuration
            local diffPercent = (diff / spell.base) * 100
            
            DEFAULT_CHAT_FRAME:AddMessage(string.format("|cFFFFFF00%s:|r", spell.name))
            DEFAULT_CHAT_FRAME:AddMessage(string.format("  Base Duration:       %.2f sec", spell.base))
            DEFAULT_CHAT_FRAME:AddMessage(string.format("  Stored Duration:     %.2f sec", storedDuration))
            DEFAULT_CHAT_FRAME:AddMessage(string.format("  Calculated Duration: |cFF00FF00%.2f sec|r", calculatedDuration))
            DEFAULT_CHAT_FRAME:AddMessage(string.format("  Reduction:           %.2f sec (%.1f%%)", diff, diffPercent))
            DEFAULT_CHAT_FRAME:AddMessage("")
        end
    end
    
    -- Show Rapid Deterioration status
    local _, _, _, _, rdPoints = GetTalentInfo(1, 14)
    if rdPoints and rdPoints > 0 then
        local expectedReduction = rdPoints == 1 and 3 or 6
        DEFAULT_CHAT_FRAME:AddMessage(string.format("|cFFFF6600Rapid Deterioration:|r %d/2 points = %d%% reduction expected", rdPoints, expectedReduction))
    else
        DEFAULT_CHAT_FRAME:AddMessage("|cFFFF6600Rapid Deterioration:|r 0/2 points (no reduction)")
    end
end

-- ============================================
-- Slash Commands (updated)
-- ============================================
SLASH_CURSIVETEST1 = "/cursivetest"
SLASH_CURSIVETEST2 = "/ctest"

SlashCmdList["CURSIVETEST"] = function(msg)
    msg = string.lower(msg or "")
    
    if msg == "" or msg == "help" then
        DEFAULT_CHAT_FRAME:AddMessage("===========================================")
        DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[CursiveTest]|r Available Tests:")
        DEFAULT_CHAT_FRAME:AddMessage("===========================================")
        DEFAULT_CHAT_FRAME:AddMessage("  /cursivetest all      - Run all tests")
        DEFAULT_CHAT_FRAME:AddMessage("  /cursivetest trinket  - Trinket Duration Test")
        DEFAULT_CHAT_FRAME:AddMessage("  /cursivetest base     - Base Duration Check")
        DEFAULT_CHAT_FRAME:AddMessage("  /cursivetest rip      - Rip Combo Point Test")
        DEFAULT_CHAT_FRAME:AddMessage("  /cursivetest rake     - Rake Immunity Test")
        DEFAULT_CHAT_FRAME:AddMessage("  /cursivetest dots     - Current DoT Status")
        DEFAULT_CHAT_FRAME:AddMessage("  /cursivetest talents  - Debug Talent Info")
        DEFAULT_CHAT_FRAME:AddMessage("  |cFF00FF00/cursivetest duration|r - |cFFFFFF00Exact duration values|r")
        DEFAULT_CHAT_FRAME:AddMessage("  |cFF00FF00/cursivetest perf|r - |cFFFFFF00Verify local-cache & pool optimizations|r")
        DEFAULT_CHAT_FRAME:AddMessage("")
    elseif msg == "all" then
        CursiveTest:TestTrinketDuration()
        DEFAULT_CHAT_FRAME:AddMessage("")
        CursiveTest:TestBaseDurations()
        DEFAULT_CHAT_FRAME:AddMessage("")
        CursiveTest:TestRipDuration()
        DEFAULT_CHAT_FRAME:AddMessage("")
        CursiveTest:TestRakeImmunity()
    elseif msg == "trinket" then
        CursiveTest:TestTrinketDuration()
    elseif msg == "base" then
        CursiveTest:TestBaseDurations()
    elseif msg == "rip" then
        CursiveTest:TestRipDuration()
    elseif msg == "rake" then
        CursiveTest:TestRakeImmunity()
    elseif msg == "dots" then
        CursiveTest:TestCurrentDoTs()
    elseif msg == "talents" then
        CursiveTest:DebugTalents()
    elseif msg == "duration" then
        CursiveTest:DebugDuration()
    elseif msg == "perf" then
        CursiveTest:TestPerfOptimizations()
    else
        DEFAULT_CHAT_FRAME:AddMessage("|cFFFF0000[CursiveTest]|r Unknown test. Use /cursivetest help")
    end
end

-- ============================================
-- Performance Optimization Tests
-- Validates local-caching and pool reuse
-- ============================================
function CursiveTest:TestPerfOptimizations()
    local PASS = "|cFF00FF00PASS|r"
    local FAIL = "|cFFFF0000FAIL|r"
    local passed = 0
    local failed = 0
    local total = 0

    local function check(name, condition)
        total = total + 1
        if condition then
            passed = passed + 1
            DEFAULT_CHAT_FRAME:AddMessage("  " .. PASS .. " " .. name)
        else
            failed = failed + 1
            DEFAULT_CHAT_FRAME:AddMessage("  " .. FAIL .. " " .. name)
        end
    end

    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[CursiveTest]|r Performance Optimization Tests")
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")

    -- -----------------------------------------------
    -- Part 1: Verify Cursive loaded correctly
    -- -----------------------------------------------
    DEFAULT_CHAT_FRAME:AddMessage("|cFFFFFF00--- Addon Load Check ---|r")
    check("Cursive exists", Cursive ~= nil)
    check("Cursive.superwow", Cursive.superwow ~= nil)
    check("Cursive.curses loaded", Cursive.curses ~= nil)
    check("Cursive.filter loaded", Cursive.filter ~= nil)
    check("Cursive.ui loaded", Cursive.ui ~= nil)
    check("Cursive.core loaded", Cursive.core ~= nil)

    if not Cursive.superwow then
        DEFAULT_CHAT_FRAME:AddMessage("|cFFFF8800  SuperWoW not detected — hot-path files did early-return.|r")
        DEFAULT_CHAT_FRAME:AddMessage("|cFFFF8800  Local-cache tests skipped (they only exist inside those files).|r")
        DEFAULT_CHAT_FRAME:AddMessage(string.format("|cFFFFFF00Results: %d/%d passed, %d failed|r", passed, total, failed))
        return
    end

    -- -----------------------------------------------
    -- Part 2: Global API availability
    -- (If locals shadow globals correctly, calling
    --  the global name must still work everywhere)
    -- -----------------------------------------------
    DEFAULT_CHAT_FRAME:AddMessage("|cFFFFFF00--- Global API Integrity ---|r")

    check("GetTime() returns number", type(GetTime()) == "number")
    check("GetTime() > 0", GetTime() > 0)
    check("UnitExists('player')", UnitExists("player") == 1)
    check("UnitName('player') is string", type(UnitName("player")) == "string")
    check("UnitHealth('player') >= 0", (UnitHealth("player") or 0) >= 0)
    check("UnitHealthMax('player') > 0", (UnitHealthMax("player") or 0) > 0)
    check("UnitIsDead('player') is bool-ish", UnitIsDead("player") ~= nil or UnitIsDead("player") == nil)
    check("UnitIsUnit('player','player')", UnitIsUnit("player", "player") == 1)
    check("UnitClass('player') ok", UnitClass("player") ~= nil)

    -- math locals
    check("math.floor(3.7) == 3", math.floor(3.7) == 3)
    check("math.ceil(3.2) == 4", math.ceil(3.2) == 4)

    -- string locals
    check("string.find('hello','ell')", string.find("hello", "ell") == 2)
    check("string.lower('ABC')=='abc'", string.lower("ABC") == "abc")
    check("string.format('%.1f',3.14)=='3.1'", string.format("%.1f", 3.14) == "3.1")

    -- table locals
    local t = {}
    table.insert(t, "a")
    table.insert(t, "b")
    check("table.insert works", table.getn(t) == 2)
    table.sort(t, function(a, b) return a > b end)
    check("table.sort works (desc)", t[1] == "b" and t[2] == "a")

    -- pairs/ipairs
    local sum = 0
    for _, v in ipairs({10, 20, 30}) do sum = sum + v end
    check("ipairs iteration", sum == 60)
    local keys = 0
    for k in pairs({x = 1, y = 2}) do keys = keys + 1 end
    check("pairs iteration", keys == 2)

    -- -----------------------------------------------
    -- Part 3: Cursive functional checks
    -- -----------------------------------------------
    DEFAULT_CHAT_FRAME:AddMessage("|cFFFFFF00--- Cursive Functional ---|r")

    -- curses module
    check("curses.trackedCurseIds is table", type(Cursive.curses.trackedCurseIds) == "table")
    check("curses.sharedDebuffs is table", type(Cursive.curses.sharedDebuffs) == "table")
    check("curses.sharedDebuffGuids is table", type(Cursive.curses.sharedDebuffGuids) == "table")
    check("curses.guids is table", type(Cursive.curses.guids) == "table")

    -- TimeRemaining function
    local testCurseData = { start = GetTime() - 5, duration = 20 }
    local remaining = Cursive.curses:TimeRemaining(testCurseData)
    check("TimeRemaining returns number", type(remaining) == "number")
    check("TimeRemaining ~15 (14-16)", remaining >= 14 and remaining <= 16)

    -- filter module
    check("filter.alive('player')", Cursive.filter.alive("player") == true)
    check("filter.attackable('player') == false", Cursive.filter.attackable("player") == false)

    -- ShouldDisplayGuid with player (should be false — player is friendly)
    local _, playerGuid = UnitExists("player")
    if playerGuid then
        local shouldShow = Cursive:ShouldDisplayGuid(playerGuid)
        check("ShouldDisplayGuid(player) == false", shouldShow == false)
    end

    -- core.guids table
    check("core.guids is table", type(Cursive.core.guids) == "table")

    -- -----------------------------------------------
    -- Part 4: GetSortedCurses pool reuse
    -- -----------------------------------------------
    DEFAULT_CHAT_FRAME:AddMessage("|cFFFFFF00--- Pool Reuse Test ---|r")

    -- Build a mock guidCurses table
    local now = GetTime()
    local mockCurses = {
        ["Curse of Agony"] = { start = now - 10, duration = 24, spellID = 11713 },
        ["Corruption"]     = { start = now - 5,  duration = 18, spellID = 25311 },
        ["Siphon Life"]    = { start = now - 2,  duration = 30, spellID = 18265 },
    }

    -- We need the sort to work, so TimeRemaining must be callable
    -- Save original ordering, test "Order applied"
    local origOrdering = Cursive.db.profile.curseordering
    local L = AceLibrary("AceLocale-2.2"):new("Cursive")

    -- Test 1: Order applied (by start time)
    Cursive.db.profile.curseordering = L["Order applied"]
    local names1 = {}
    -- Access the internal pool function via DisplayGuid's closure
    -- We can't call GetSortedCurses directly (it's local), but we can
    -- test it indirectly by iterating a real guid's curses.
    -- Instead: replicate the pool logic inline to verify behavior
    local poolTest = {}
    -- Simulate wipe
    for i = table.getn(poolTest), 1, -1 do poolTest[i] = nil end
    check("Pool wipe on empty: size 0", table.getn(poolTest) == 0)

    -- Fill
    for key in pairs(mockCurses) do table.insert(poolTest, key) end
    check("Pool fill: size 3", table.getn(poolTest) == 3)

    -- Sort by start time
    table.sort(poolTest, function(a, b)
        return mockCurses[a].start < mockCurses[b].start
    end)
    check("Pool sort: oldest first", poolTest[1] == "Curse of Agony")
    check("Pool sort: newest last", poolTest[3] == "Siphon Life")

    -- Simulate reuse: wipe and refill with different data
    for i = table.getn(poolTest), 1, -1 do poolTest[i] = nil end
    check("Pool wipe: size 0 after clear", table.getn(poolTest) == 0)

    local mockCurses2 = {
        ["Immolate"] = { start = now - 1, duration = 15, spellID = 11668 },
        ["Doom"]     = { start = now - 20, duration = 60, spellID = 603 },
    }
    for key in pairs(mockCurses2) do table.insert(poolTest, key) end
    check("Pool refill: size 2 (no ghost entries)", table.getn(poolTest) == 2)

    -- Sort by start
    table.sort(poolTest, function(a, b)
        return mockCurses2[a].start < mockCurses2[b].start
    end)
    check("Pool reuse sort: Doom first (older)", poolTest[1] == "Doom")
    check("Pool reuse sort: Immolate second", poolTest[2] == "Immolate")

    -- Restore original ordering
    Cursive.db.profile.curseordering = origOrdering

    -- -----------------------------------------------
    -- Part 5: Live display check (if mobs tracked)
    -- -----------------------------------------------
    DEFAULT_CHAT_FRAME:AddMessage("|cFFFFFF00--- Live State ---|r")

    local guidCount = 0
    for _ in pairs(Cursive.core.guids) do guidCount = guidCount + 1 end
    DEFAULT_CHAT_FRAME:AddMessage("  Tracked GUIDs: " .. guidCount)

    local curseCount = 0
    for guid, curses in pairs(Cursive.curses.guids) do
        for name in pairs(curses) do curseCount = curseCount + 1 end
    end
    DEFAULT_CHAT_FRAME:AddMessage("  Active curses: " .. curseCount)

    local sharedCount = 0
    for key, guids in pairs(Cursive.curses.sharedDebuffGuids) do
        for guid in pairs(guids) do sharedCount = sharedCount + 1 end
    end
    DEFAULT_CHAT_FRAME:AddMessage("  Pending shared debuffs: " .. sharedCount)

    if Cursive.ui and Cursive.ui.unitFrames then
        local frameCount = 0
        for col, rows in pairs(Cursive.ui.unitFrames) do
            for row, f in pairs(rows) do
                if f and f:IsShown() then frameCount = frameCount + 1 end
            end
        end
        DEFAULT_CHAT_FRAME:AddMessage("  Visible unit frames: " .. frameCount)
    end

    -- -----------------------------------------------
    -- Summary
    -- -----------------------------------------------
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
    if failed == 0 then
        DEFAULT_CHAT_FRAME:AddMessage(string.format("|cFF00FF00ALL %d TESTS PASSED|r", total))
    else
        DEFAULT_CHAT_FRAME:AddMessage(string.format("|cFFFF0000%d/%d PASSED, %d FAILED|r", passed, total, failed))
    end
    DEFAULT_CHAT_FRAME:AddMessage("===========================================")
end

DEFAULT_CHAT_FRAME:AddMessage("|cFF00FF00[CursiveTest]|r Framework loaded. Use /cursivetest help")