test.lua

-- $Id$

--[=[
TODO:

More comments
More documentation
]=]

--local path = (... .. "/"):gsub("\\", "/") -- Needed for Cybeloras to run this properly
local path = ""

local function escape_char(c)
	return ("\\%03d"):format(c:byte())
end

local function table_len(t)
	for i = 1, #t do
		if t[i] == nil then
			return i-1
		end
	end
	return #t
end

function pprint(...)
	print(ptostring(...))
end

local function key_sort(alpha, bravo)
	local type_alpha, type_bravo = type(alpha), type(bravo)
	if type_alpha ~= type_bravo then
		return type_alpha < type_bravo
	end

	if type_alpha == "string" then
		return alpha:lower() < bravo:lower()
	elseif type_alpha == "number" then
		return alpha < bravo
	elseif type_alpha == "table" then
		return tostring(alpha) < tostring(bravo)
	else
		return false
	end
end

local preserved = {
	["nil"] = true,
	["true"] = true,
	["false"] = true,
}

local first_ptostring = true
function ptostring(...)
	local t = {}
	for i = 1, select('#', ...) do
		if i > 1 then
			t[#t+1] = ",\t"
		end
		local v = select(i, ...)
		if type(v) == "string" then
			t[#t+1] = (("%q"):format(v):gsub("\\\010", "\\n"):gsub("[\001-\031\128-\255]", escape_char))
		elseif type(v) == "table" then
			t[#t+1] = "{ "
			local keys = {}
			for a in pairs(v) do
				keys[#keys+1] = a
			end
			table.sort(keys, key_sort)
			local first = true
			for _,a in ipairs(keys) do
				local b = v[a]
				if first then
					first = nil
				else
					t[#t+1] = ", "
				end
				if type(a) ~= "number" or a < 1 or a > table_len(v) then
					if type(a) == "string" and a:match("^[a-zA-Z_][a-zA-Z_0-9]*$") and not preserved[a] then
						t[#t+1] = a
						t[#t+1] = " = "
					else
						t[#t+1] = "["
						t[#t+1] = ptostring(a)
						t[#t+1] = "] = "
					end
				end
				t[#t+1] = ptostring(b)
			end
			if first then
				t[#t] = "{}"
			else
				t[#t+1] = " }"
			end
		else
			t[#t+1] = tostring(v)
		end
	end
	return table.concat(t)
end

local function is_equal(alpha, bravo)
	if type(alpha) ~= type(bravo) then
		return false
	end

	if type(alpha) == "number" then
		return alpha == bravo or tostring(alpha) == tostring(bravo) or math.abs(alpha - bravo) < 1e-15
	elseif type(alpha) ~= "table" then
		return alpha == bravo
	end

	local num = 0
	for k,v in pairs(alpha) do
		num = num + 1
		if not is_equal(v, bravo[k]) then
			return false
		end
	end

	for k,v in pairs(bravo) do
		num = num - 1
	end
	if num ~= 0 then
		return false
	end
	return true
end

local errors_raised = 0
function geterrorhandler()
	return function(err)
		errors_raised = errors_raised + 1
		print(debug.traceback(err, 2))
		os.exit()
	end
end

function assert_equal(alpha, bravo)
	if not is_equal(alpha, bravo) then
		error(("Assertion failed: %s == %s"):format(ptostring(alpha), ptostring(bravo)), 2)
	end
end

if not DogTag_Test_SecondTime then
	local function CreateFontString(parent, name, layer)
		local fs = {
			[0] = newproxy(), -- fake userdata
		}
		function fs:GetObjectType()
			return "FontString"
		end
		local text
		function fs:SetText(x)
			text = x
		end
		function fs:GetText()
			return text
		end
		local alpha = 1
		function fs:SetAlpha(a)
			alpha = a
		end
		function fs:GetAlpha()
			return alpha
		end
		local fontObject
		function fs:SetFontObject(object)
			fontObject = object
		end
		function fs:GetFontObject()
			return fontObject
		end
		local fontName, fontSize, fontOutline = "Fritz", 14, ""
		function fs:GetFont()
			return fontName, fontSize, fontOutline
		end
		function fs:SetFont(a, b, c)
			fontName, fontSize, fontOutline = a, b, c or ''
		end
		return fs
	end
	local frames = {}
	local frameRegisteredEvents = {}
	local ALL_EVENTS = newproxy()
	function CreateFrame(frameType, ...)
		local frame = {
			[0] = newproxy(), -- fake userdata
		}
		frames[frame] = true
		function frame:GetObjectType()
			return frameType
		end
		function frame:GetFrameType()
			return frameType
		end
		local scripts = {}
		function frame:SetScript(script, func)
			scripts[script] = func
		end
		function frame:GetScript(script)
			return scripts[script]
		end
		local events = {}
		frameRegisteredEvents[frame] = events
		function frame:RegisterEvent(event)
			events[event] = true
		end
		function frame:UnregisterEvent(event)
			events[event] = nil
		end
		function frame:UnregisterAllEvents()
			for event in pairs(events) do
				events[event] = nil
			end
		end
		function frame:RegisterAllEvents()
			events[ALL_EVENTS] = true
		end
		function frame:CreateFontString(...)
			return CreateFontString(frame, ...)
		end
		local isShown = 1
		function frame:Show()
			isShown = 1
		end
		function frame:Hide()
			isShown = nil
		end
		function frame:IsShown()
			return isShown
		end
		if frameType == "GameTooltip" then
			local owner
			function frame:SetOwner(f)
				owner = f
			end
			function frame:IsOwned(f)
				return owner == f
			end
			local fsLeft, fsRight = {}, {}
			function frame:AddFontStrings(f1, f2)
				fsLeft[#fsLeft+1] = f1
				fsRight[#fsRight+1] = f2
			end
		end
		return frame
	end

	local currentTime = 1e5 -- initial time
	function GetTime()
		return math.floor(currentTime*1000 + 0.5) / 1000
	end

	function FireOnUpdate(elapsed)
		if not elapsed then
			elapsed = 1
		end
		currentTime = currentTime + elapsed
		for frame in pairs(frames) do
			local OnUpdate = frame:GetScript("OnUpdate")
			if OnUpdate and frame:IsShown() then
				OnUpdate(frame, elapsed)
			end
		end
	end

	function FireEvent(event, ...)
		for frame in pairs(frames) do
			if frameRegisteredEvents[frame][event] or frameRegisteredEvents[frame][ALL_EVENTS] then
				local OnEvent = frame:GetScript("OnEvent")
				if OnEvent then
					OnEvent(frame, event, ...)
				end
			end
		end
	end
end

RAID_CLASS_COLORS = {
	DRUID = { r = 1, g = 0.49, b = 0.04, },
	HUNTER = { r = 0.67, g = 0.83, b = 0.45 },
	MAGE = { r = 0.41, g = 0.8, b = 0.41 },
	PALADIN = { r = 0.96, g = 0.55, b = 0.73 },
	PRIEST = { r = 1, g = 1, b = 1 },
	ROGUE = { r = 1, g = 0.96, b = 0.41 },
	SHAMAN = { r = 0.14, g = 0.35, b = 1 },
	WARLOCK = { r = 0.58, g = 0.51, b = 0.79 },
	WARRIOR = { r = 0.78, g = 0.61, b = 0.43 },
	MONK = { r = 0.0, g = 1.00 , b = 0.59 },
}

local GetMouseFocus_data = nil
function GetMouseFocus()
	return GetMouseFocus_data
end

local IsAltKeyDown_data = nil
function IsAltKeyDown()
	return IsAltKeyDown_data
end

local IsShiftKeyDown_data = nil
function IsShiftKeyDown()
	return IsShiftKeyDown_data
end

local IsControlKeyDown_data = nil
function IsControlKeyDown()
	return IsControlKeyDown_data
end

function InCombatLockdown()
	return false
end

function LoadAddOn()
end

DogTag_DEBUG = true

DAYS = "Days";
--DAYS_P1 = "Days";
DAYS_ABBR = "%d Days";
--DAYS_ABBR_P1 = "Days";
DAY_ONELETTER_ABBR = "%d d";
HOURS = "Hours";
--HOURS_P1 = "Hours";
HOURS_ABBR = "%d Hr";
--HOURS_ABBR_P1 = "Hrs";
HOUR_ONELETTER_ABBR = "%d h";
MINUTES = "Minutes"; -- Minutes of time
--MINUTES_P1 = "Minutes";
MINUTES_ABBR = "%d Min";
--MINUTES_ABBR_P1 = "Mins";
MINUTE_ONELETTER_ABBR = "%d m";
SECONDS = "Seconds"; -- Seconds of time
--SECONDS_P1 = "Seconds";
SECONDS_ABBR = "%d Sec";
--SECONDS_ABBR_P1 = "Secs";
SECOND_ONELETTER_ABBR = "%d s";

dofile(path .. "LibStub/LibStub.lua")
dofile(path .. "Localization/enUS.lua")
dofile(path .. "Helpers.lua")
dofile(path .. "LibDogTag-3.0.lua")
dofile(path .. "Parser.lua")
dofile(path .. "Compiler.lua")
dofile(path .. "Events.lua")
dofile(path .. "Categories/Math.lua")
dofile(path .. "Categories/Misc.lua")
dofile(path .. "Categories/Operators.lua")
dofile(path .. "Categories/TextManip.lua")
dofile(path .. "Cleanup.lua")

local DogTag = LibStub("LibDogTag-3.0")
local getPoolNum, setPoolNum = DogTag.getPoolNum, DogTag.setPoolNum
local parse = DogTag.parse
local standardize = DogTag.standardize

local function assert_table_usage(func, tableChange)
	local previousPoolNum = getPoolNum()
	func()
	local afterPoolNum = getPoolNum()
	local actualChange = afterPoolNum-previousPoolNum
	if tableChange ~= actualChange then
--		error(("Unexpected table usage: %d instead of expected %d"):format(actualChange, tableChange), 2)
	end
end

local function countTables(t)
	if type(t) ~= "table" then
		return 0
	end
	local n = 1
	for k, v in pairs(t) do
		n = n + countTables(k) + countTables(v)
	end
	return n
end

local function deepCopy(t)
	if type(t) ~= "table" then
		return t
	end
	local x = {}
	for k,v in pairs(t) do
		x[k] = deepCopy(v)
	end
	return x
end

local old_parse = parse
function parse(arg)
	local start = DogTag.getPoolNum()
	local ret = old_parse(arg)
	local finish = DogTag.getPoolNum()
	local change = finish - start
	local num_tables = countTables(ret)
	if change ~= num_tables then
		error(("Unknown table usage: %d instead of %d"):format(change, num_tables), 2)
	end
	local r = deepCopy(ret)
	DogTag.deepDel(ret)
	return r
end

local old_standardize = standardize
function standardize(arg)
	local realStart = DogTag.getPoolNum()
	local start = realStart - countTables(arg)
	local ret = old_standardize(arg)
	local finish = DogTag.getPoolNum()
	local change = finish - start
	local num_tables = countTables(ret)
	if change ~= num_tables then
		error(("Unknown table usage: %d instead of %d"):format(change, num_tables), 2)
	end
	DogTag.setPoolNum(realStart)
	return ret
end

DogTag:Evaluate("")

local function tuple(...)
	local x = { ... }
	local n = select('#', ...)
	return function()
		return unpack(x, 1, n)
	end
end

local old_DogTag_Evaluate = DogTag.Evaluate
function DogTag:Evaluate(...)
	local start = DogTag.getPoolNum()
	local rets = tuple(old_DogTag_Evaluate(self, ...))
	local finish = DogTag.getPoolNum()
	local change = finish - start
	if change ~= 0 then
--		error(("Unknown table usage: %d instead of %d"):format(change, 0), 2)
	end
	return rets()
end

local old_DogTag_CleanCode = DogTag.CleanCode
function DogTag:CleanCode(...)
	local start = DogTag.getPoolNum()
	local ret = old_DogTag_CleanCode(self, ...)
	local finish = DogTag.getPoolNum()
	local change = finish - start
	if change ~= 0 then
		error(("Unknown table usage: %d instead of %d"):format(change, 0), 2)
	end
	return ret
end

DogTag:AddTag("Base", "One", {
	code = function() return 1 end,
	ret = "number",
	doc = "Return the number 1",
	example = '[One] => "1"',
	category = "Testing"
})

DogTag:AddTag("Base", "StaticOne", {
	code = function() return 1 end,
	ret = "number",
	static = true,
	doc = "Return the number 1",
	example = '[One] => "1"',
	category = "Testing"
})

DogTag:AddTag("Base", "Two", {
	code = function() return 2 end,
	ret = "number",
	doc = "Return the number 2",
	example = '[Two] => "2"',
	category = "Testing"
})

DogTag:AddTag("Base", "FakeOne", {
	code = function() return 100 end,
	ret = "number",
	doc = "Return the number 100",
	example = '[FakeOne] => "100"',
	category = "Testing"
})

DogTag:AddTag("Base", "PlusOne", {
	code = function(number)
		return number + 1
	end,
	arg = {
		'number', 'number', "@req"
	},
	ret = "number",
	static = true,
	doc = "Return the number 1",
	example = '[One] => "1"',
	category = "Testing"
})

DogTag:AddTag("Base", "Subtract", {
	code = function(left, right)
		return left - right
	end,
	arg = {
		'left', 'number', "@req",
		'right', 'number', "@req"
	},
	ret = "number",
	doc = "Subtract right from left",
	example = '[AddNumbers(1, 2)] => "-1"',
	category = "Testing"
})

DogTag:AddTag("Base", "SubtractFive", {
	alias = [=[Subtract(number, 5)]=],
	arg = {
		'number', 'number', '@req',
	},
	doc = "Subtract 5 from number",
	example = '[SubtractFive(10)] => "5"',
	category = "Testing",
})

DogTag:AddTag("Base", "SubtractFromFive", {
	alias = [=[Subtract(right=number, left=5)]=],
	arg = {
		'number', 'number', '@req',
	},
	doc = "Subtract number from 5",
	example = '[SubtractFromFive(10)] => "-5"; [SubtractFromFive] => "5"',
	category = "Testing",
})

DogTag:AddTag("Base", "ReverseSubtract", {
	alias = [=[Subtract(right, left)]=],
	arg = {
		'left', 'number', "@req",
		'right', 'number', "@req"
	},
	ret = "number",
	doc = "Subtract left from right",
	example = '[ReverseSubtract(1, 2)] => "1"',
	category = "Testing"
})

DogTag:AddTag("Base", "AbsAlias", {
	alias = [=[number < 0 ? -number ! number]=],
	arg = {
		'number', 'number', "@req",
	},
	ret = "number",
	doc = "Get the absolute value of number",
	example = '[AbsAlias(5)] => "5"; [AbsAlias(-5)] => "5"',
	category = "Testing"
})

local GlobalCheck_data = "Hello World"

DogTag:AddTag("Base", "GlobalCheck", {
	code = function()
		return GlobalCheck_data
	end,
	ret = "string;number;nil",
	doc = "Return the results of testfunc",
	example = '[GlobalCheck] => "Hello World"',
	category = "Testing"
})

local myfunc_num = 0
function _G.myfunc()
	myfunc_num = myfunc_num + 1
	return myfunc_num
end

DogTag:AddTag("Base", "FunctionNumberCheck", {
	code = function()
		myfunc_num = myfunc_num + 1
		return myfunc_num
	end,
	ret = "number;nil",
	doc = "Return the results of myfunc",
	example = '[FunctionNumberCheck] => "1"',
	category = "Testing"
})


DogTag:AddTag("Base", "AbsoluteValue", {
	code = function(number)
		return math.abs(number)
	end,
	arg = {
		'number', 'number', "@req",
	},
	ret = "number",
	doc = "Get the absolute value of number",
	example = '[AbsoluteValue(5)] => "5"; [AbsoluteValue(-5)] => "5"',
	category = "Testing"
})

DogTag:AddTag("Base", "CheckNumDefault", {
	code = function(value)
		return value
	end,
	arg = {
		'value', 'number', 50
	},
	ret = "number",
	doc = "Return the given argument or 50",
	example = '[CheckStrDefault(1)] => "1"; [CheckStrDefault] => "50"',
	category = "Testing"
})

DogTag:AddTag("Base", "CheckStrDefault", {
	code = function(value)
		return value
	end,
	arg = {
		'value', 'string', 'Value'
	},
	ret = "string",
	doc = "Return the given argument or value",
	example = '[CheckStrDefault(1)] => "1"; [CheckStrDefault] => "Value"',
	category = "Testing"
})

DogTag:AddTag("Base", "CheckNilDefault", {
	code = function(value)
		return value
	end,
	arg = {
		'value', 'nil;number', false
	},
	ret = "nil;number",
	doc = "Return the given argument or nil",
	example = '[CheckNilDefault(1)] => "1"; [CheckNilDefault] => ""',
	category = "Testing"
})

DogTag:AddTag("Base", "CheckNumTuple", {
	code = function(...)
		return ("-"):join(...)
	end,
	arg = {
		'...', 'tuple-number', false
	},
	ret = "string",
	doc = "Join ... separated by dashes",
	example = '[CheckNumTuple(1)] => "1"; [CheckNumTuple] => ""',
	category = "Testing"
})

DogTag:AddTag("Base", "CheckBooleanTuple", {
	code = function(...)
		local num = 0
		for i = 1, select('#', ...) do
			assert(type(select(i, ...)) == "boolean")
			if select(i, ...) then
				num = num + 2^(i - 1)
			end
		end
		return num
	end,
	arg = {
		'...', 'tuple-boolean', false
	},
	ret = "number",
	doc = "Return the integer formed by the bits of ...",
	example = '[CheckBooleanTuple(true, false, true)] => "5"; [CheckBooleanTuple] => "0"',
	category = "Testing"
})

DogTag:AddTag("Base", "CheckNilTuple", {
	code = function(...)
		for i = 1, select('#', ...) do
			assert(not select(i, ...))
		end
		return select('#', ...)
	end,
	arg = {
		'...', 'tuple-nil', false
	},
	ret = "number",
	doc = "Return the number of nils provided",
	example = '[CheckNilTuple(nil, nil, nil)] => "3"; [CheckNilTuple] => "0"',
	category = "Testing"
})

DogTag:AddTag("Base", "TupleAlias", {
	alias = [=[CheckNumTuple(5, ...)]=],
	arg = {
		'...', 'tuple-number', false
	},
	doc = "Join ... separated by dashes",
	example = '[TupleAlias(1)] => "1"; [TupleAlias] => ""',
	category = "Testing"
})

DogTag:AddTag("Base", "OtherTupleAlias", {
	alias = [=[Subtract(...)]=],
	arg = {
		'...', 'tuple-number', false
	},
	doc = "Subtract the values of ...",
	example = '[OtherTupleAlias(5, 2)] => "3"',
	category = "Testing"
})

DogTag:AddTag("Base", "CheckAnotherNumTuple", {
	code = function(...)
		return math.max(0, ...)
	end,
	arg = {
		'...', 'tuple-number', false
	},
	ret = "string",
	doc = "Return the largest number of ...",
	globals = 'math.max',
	example = '[CheckAnotherNumTuple(1)] => "1"; [CheckAnotherNumTuple] => "0"',
	category = "Testing"
})

DogTag:AddTag("Base", "CheckStrTuple", {
	code = function(...)
		local x = ''
		for i = 1, select('#', ...) do
			x = x .. select(i, ...):gsub('[aeiou]', 'y')
		end
		return x
	end,
	arg = {
		'...', 'tuple-string', false
	},
	ret = "string",
	doc = "Join ..., replacing vowels with 'y'",
	example = '[CheckStrTuple("Hello")] => "Hylly"; [CheckStrTuple] => ""',
	category = "Testing"
})

DogTag:AddTag("Base", "CheckAnyTuple", {
	code = function(...)
		local x = ''
		for i = 1, select('#', ...) do
			if i > 1 then
				x = x .. ";"
			end
			x = x .. type(select(i, ...)) .. ":" .. tostring(select(i, ...))
		end
		return x
	end,
	arg = {
		'...', 'tuple-string;number;nil', false
	},
	ret = "string",
})

DogTag:AddTag("Base", "Reverse", {
	code = function(value)
		return value:reverse()
	end,
	arg = {
		'value', 'string', '@req'
	},
	ret = "string",
	doc = "Reverse the characters in value",
	example = '[Reverse(Hello)] => "olleH"',
	category = "Testing",
})

DogTag:AddTag("Base", "OtherReverse", {
	code = function(value)
		if value ~= "Stuff" then
			return value:reverse()
		else
			return "ffutS"
		end
	end,
	arg = {
		'value', 'string', '@req'
	},
	ret = "string",
	doc = "Reverse the characters in value",
	example = '[OtherReverse(Hello)] => "olleH"',
	category = "Testing",
})

DogTag:AddTag("Base", "KwargAndTuple", {
	code = function(value, ...)
		local num = 0
		for i = 1, select('#', ...) do
			num = num + select(i, ...)
		end
		return value * num
	end,
	arg = {
		'value', 'number', '@req',
		'...', 'tuple-number', false
	},
	ret = 'number',
	globals = 'math.max';
	doc = "Return the maximum of ... multiplied by value",
	example = '[KwargAndTuple(5, 1, 2, 3)] => "15"',
	category = "Testing",
})

DogTag:AddTag("Base", "TupleAndKwarg", {
	code = function(value, ...)
		local num = 0
		for i = 1, select('#', ...) do
			num = num + select(i, ...)
		end
		return value * num
	end,
	arg = {
		'...', 'tuple-number', false,
		'value', 'number', '@req'
	},
	ret = 'number',
	globals = 'math.max';
	doc = "Return the maximum of ... multiplied by value",
	example = '[KwargAndTuple(5, 1, 2, 3)] => "15"',
	category = "Testing",
})

DogTag:AddTag("Base", "Type", {
	code = function(value)
		return type(value)
	end,
	arg = {
		'value', 'number;nil;string', '@req'
	},
	ret = 'string',
	doc = "Return the type of value",
	example = '[Type(nil)] => "nil"; [Type("Hello")] => "string"; [Type(5)] => "number"',
	category = "Testing",
})

DogTag:AddTag("Base", "BooleanToString", {
	code = function(value)
		return tostring(value)
	end,
	arg = {
		'value', 'boolean', false
	},
	ret = 'string',
	doc = "Return true or false",
	example = '[BooleanToString(nil)] => "false"; [BooleanToString("Hello")] => "true"; [BooleanToString(5)] => "true"',
	category = "Testing",
})

DogTag:AddTag("Base", "RetNil", {
	code = function()
		return nil
	end,
	arg = {
		'value', 'nil;number;string', false
	},
	ret = 'nil',
	doc = "Return nil",
	example = '[RetNil] => ""; [RetNil(Anything)] => ""',
	category = "Testing",
})

local GlobalCheckBoolean_data = true
DogTag:AddTag("Base", "GlobalCheckBoolean", {
	code = function()
		return GlobalCheckBoolean_data
	end,
	ret = 'boolean',
	doc = "Return True or blank",
	example = '[GlobalCheckBoolean] => ""; [GlobalCheckBoolean] => "True"',
	category = "Testing",
})

DogTag:AddTag("Base", "ToString", {
	code = function(value)
		return '`' .. tostring(value or ''):reverse():reverse() .. '`'
	end,
	arg = {
		'value', 'number;nil;string', '@req'
	},
	ret = 'string',
	doc = "Return value surrounded by tickmarks",
	example = '[ToString(nil)] => "``"; [ToString("Hello")] => "`Hello`"; [ToString(5)] => "`5`"',
	category = "Testing",
})

local RetSame_types
DogTag:AddTag("Base", "RetSame", {
	code = function(value)
		return value
	end,
	arg = {
		'value', 'number;nil;string', '@req'
	},
	ret = function(args)
		RetSame_types = args.value.types
		return args.value.types
	end
})

DogTag:AddTag("Base", "OtherRetSame", {
	code = function(value)
		return value
	end,
	arg = {
		'value', 'number;nil;string', '@req'
	},
	ret = 'number;nil;string'
})

DogTag:AddTag("Base", "DynamicCodeTest", {
	code = function(args)
		if args.value.isLiteral then
			local value = args.value.value
			return function()
				return "literal, " .. tostring(value)
			end
		else
			local value = args.value.value
			local tag = value[1] == "tag" and value[2] or value[1]
			return function()
				return "dynamic, " .. tag
			end
		end
	end,
	dynamicCode = true,
	arg = {
		'value', 'number;nil;string', '@req'
	},
	ret = "string",
})

local BlizzEventTest_num = 0
DogTag:AddTag("Base", "BlizzEventTest", {
	code = function(value)
		BlizzEventTest_num = BlizzEventTest_num + 1
		return BlizzEventTest_num
	end,
	arg = {
		'value', 'string', "@req"
	},
	ret = "number",
	events = "FAKE_BLIZZARD_EVENT#$value",
	doc = "Return the results of BlizzEventTest_num after incrementing",
	example = '[BlizzEventTest] => "1"',
	category = "Testing"
})
local OtherBlizzEventTest_num = 0
DogTag:AddTag("Base", "OtherBlizzEventTest", {
	code = function()
		OtherBlizzEventTest_num = OtherBlizzEventTest_num + 1
		return OtherBlizzEventTest_num
	end,
	ret = "number",
	events = "OTHER_FAKE_BLIZZARD_EVENT",
	doc = "Return the results of OtherBlizzEventTest_num after incrementing",
	example = '[OtherBlizzEventTest] => "1"',
	category = "Testing"
})

DoubleBlizzEventTest_num = 0
DogTag:AddTag("Base", "DoubleBlizzEventTest", {
	code = function(alpha, bravo)
		DoubleBlizzEventTest_num = DoubleBlizzEventTest_num + 1
		return DoubleBlizzEventTest_num
	end,
	arg = {
		'alpha', 'string', "@req",
		'bravo', 'string', "@req",
	},
	ret = "number",
	events = "DOUBLE_BLIZZARD_EVENT#$alpha;DOUBLE_BLIZZARD_EVENT#$bravo",
	doc = "Return the results of BlizzEventTest_num after incrementing",
	example = '[BlizzEventTest] => "1"',
	category = "Testing"
})

local OtherDoubleBlizzEventTest = 0
DogTag:AddTag("Base", "OtherDoubleBlizzEventTest", {
	code = function(value)
		OtherDoubleBlizzEventTest_num = OtherDoubleBlizzEventTest_num + 1
		return OtherDoubleBlizzEventTest_num
	end,
	arg = {
		'alpha', 'string', "@req",
		'bravo', 'string', "@req",
	},
	ret = "number",
	events = "OTHER_DOUBLE_BLIZZARD_EVENT#$alpha#$bravo",
	doc = "Return the results of OtherDoubleBlizzEventTest_num after incrementing",
	example = '[OtherDoubleBlizzEventTest("alpha", "bravo")] => "1"',
	category = "Testing"
})

local LibToProvideExtraFunctionality
DogTag:AddAddonFinder("Base", "LibStub", "LibToProvideExtraFunctionality", function(lib)
	LibToProvideExtraFunctionality = lib
end)

DogTag:AddTag("Base", "ExtraFunctionalityWithLib", {
	code = function(args)
		if LibToProvideExtraFunctionality then
			return function()
				return "True"
			end
		else
			return function()
				return nil
			end
		end
	end,
	dynamicCode = true,
	ret = function(args)
		if LibToProvideExtraFunctionality then
			return "string"
		else
			return "nil"
		end
	end,
	doc = "Return True if LibToProvideExtraFunctionality is present",
	example = '[ExtraFunctionalityWithLib] => ""; [ExtraFunctionalityWithLib] => "True"',
	category = "Testing",
})

DogTag:AddTag("Base", "Thingy", {
	code = function(value)
		return value
	end,
	arg = {
		'value', 'string', '@req',
	},
	ret = "string",
	events = "THINGY_EVENT#$value",
})

DogTag:AddTag("Base", "AliasOfThingy", {
	alias = "Thingy(value=myvalue)",
	arg = {
		'myvalue', 'string', '@req',
	},
})

DogTag:AddTag("Base", "OtherAliasOfThingy", {
	alias = "Thingy(value=myvalue:Repeat(2))",
	arg = {
		'myvalue', 'string', '@req',
	},
})


collectgarbage('collect')
collectgarbage('stop')
collectgarbage('collect')
local startMemory = collectgarbage('count')
local startTime = os.clock()

assert_equal(parse("[1 - 2]"), { "-", 1, 2 })
assert_equal(parse("[1-2]"), { "-", 1, 2 })
assert_equal(parse("[1- 2]"), { "-", 1, 2 })
assert_equal(parse("[1 -2]"), { "concat", 1, -2 })
assert_equal(parse("[50 1 - 2]"), { "concat", 50, { "-", 1, 2 } })
assert_equal(parse("[50 1-2]"), { "concat", 50, { "-", 1, 2 } })
assert_equal(parse("[50 1- 2]"), { "concat", 50, { "-", 1, 2 } })
assert_equal(parse("[50 1 -2]"), { "concat", 50, 1, -2 })
assert_equal(parse("[1 - 2 50]"), { "concat", { "-", 1, 2 }, 50 })
assert_equal(parse("[1-2 50]"), { "concat", { "-", 1, 2 }, 50 })
assert_equal(parse("[1- 2 50]"), { "concat", { "-", 1, 2 }, 50 })
assert_equal(parse("[1 -2 50]"), { "concat", 1, -2, 50 })
assert_equal(parse("[25 1 - 2 50]"), { "concat", 25, { "-", 1, 2 }, 50 })
assert_equal(parse("[25 1-2 50]"), { "concat", 25, { "-", 1, 2 }, 50 })
assert_equal(parse("[25 1- 2 50]"), { "concat", 25, { "-", 1, 2 }, 50 })
assert_equal(parse("[25 1 -2 50]"), { "concat", 25, 1, -2, 50 })

assert_equal(parse("[MyTag]"), { "tag", "MyTag" })
assert_equal(DogTag:CleanCode("[MyTag]"), "[MyTag]")
assert_equal(parse("Alpha [MyTag]"), {"concat", "Alpha ", { "tag", "MyTag" } })
assert_equal(DogTag:CleanCode("Alpha [MyTag]"), "Alpha [MyTag]")
assert_equal(parse("[MyTag] Bravo"), {"concat", { "tag", "MyTag" }, " Bravo" })
assert_equal(DogTag:CleanCode("[MyTag] Bravo"), "[MyTag] Bravo")
assert_equal(parse("Alpha [MyTag] Bravo"), {"concat", "Alpha ", { "tag", "MyTag" }, " Bravo" })
assert_equal(DogTag:CleanCode("Alpha [MyTag] Bravo"), "Alpha [MyTag] Bravo")
assert_equal(parse("[Alpha][Bravo]"), { "concat", { "tag", "Alpha" }, { "tag", "Bravo" } })
assert_equal(parse("[Alpha Bravo]"), { "concat", { "tag", "Alpha" }, { "tag", "Bravo" } })
assert_equal(DogTag:CleanCode("[One][Bravo]"), "[One Bravo]")
assert_equal(parse("[Alpha][Bravo][Charlie]"), { "concat", { "tag", "Alpha" }, { "tag", "Bravo" }, { "tag", "Charlie"} })
assert_equal(parse("[Alpha Bravo Charlie]"), { "concat", { "tag", "Alpha" }, { "tag", "Bravo" }, { "tag", "Charlie"} })
assert_equal(DogTag:CleanCode("[One][Bravo][Charlie]"), "[One Bravo Charlie]")
assert_equal(DogTag:CleanCode("Alpha [Bravo][Charlie] Delta"), "Alpha [Bravo Charlie] Delta")
assert_equal(DogTag:CleanCode("[Alpha] [Bravo] [Charlie]"), "[Alpha] [Bravo] [Charlie]")
assert_equal(DogTag:CleanCode("Alpha [Bravo] [Charlie] Delta"), "Alpha [Bravo] [Charlie] Delta")

assert_equal(parse("[Alpha(Bravo)]"), { "tag", "Alpha", { "tag", "Bravo" } })
assert_equal(DogTag:CleanCode("[Alpha(Bravo)]"), "[Alpha(Bravo)]")
assert_equal(parse("[Alpha(Bravo, Charlie)]"), { "tag", "Alpha", { "tag", "Bravo" }, { "tag", "Charlie"} })
assert_equal(DogTag:CleanCode("[Alpha(Bravo, Charlie)]"), "[Alpha(Bravo, Charlie)]")
assert_equal(parse("[Alpha:Delta]"), { "mod", "Delta", { "tag", "Alpha" } })
assert_equal(DogTag:CleanCode("[Alpha:Delta]"), "[Alpha:Delta]")
assert_equal(parse("[Alpha:Bravo:Charlie]"), { "mod", "Charlie", { "mod", "Bravo", { "tag", "Alpha" } } })
assert_equal(DogTag:CleanCode("[Alpha:Bravo:Charlie]"), "[Alpha:Bravo:Charlie]")
assert_equal(standardize(parse("[Alpha:Delta]")), { "tag", "Delta", { "tag", "Alpha" } })
assert_equal(standardize(parse("[Alpha:Bravo:Charlie]")), { "tag", "Charlie", { "tag", "Bravo", { "tag", "Alpha" } } })
assert_equal(parse("[Alpha:Delta(Echo)]"), { "mod", "Delta", { "tag", "Alpha" }, { "tag", "Echo" } })
assert_equal(DogTag:CleanCode("[Alpha:Delta(Echo)]"), "[Alpha:Delta(Echo)]")
assert_equal(parse("[Alpha(Bravo):Delta]"), { "mod", "Delta", { "tag", "Alpha", { "tag", "Bravo"} } })
assert_equal(DogTag:CleanCode("[Alpha(Bravo):Delta]"), "[Alpha(Bravo):Delta]")
assert_equal(parse("[Alpha(Bravo, Charlie):Delta(Echo, Foxtrot)]"), { "mod", "Delta", { "tag", "Alpha", { "tag", "Bravo"}, {"tag", "Charlie"} }, {"tag", "Echo"}, {"tag", "Foxtrot"} })
assert_equal(DogTag:CleanCode("[Alpha(Bravo, Charlie):Delta(Echo, Foxtrot)]"), "[Alpha(Bravo, Charlie):Delta(Echo, Foxtrot)]")
assert_equal(parse("[Alpha:~Delta]"), { "~", { "mod", "Delta", { "tag", "Alpha" } } })
assert_equal(standardize(parse("[Alpha:~Delta]")), { "not", { "tag", "Delta", { "tag", "Alpha" } } })
assert_equal(standardize(parse("[not Alpha:Delta]")), { "not", { "tag", "Delta", { "tag", "Alpha" } } })
assert_equal(DogTag:CleanCode("[Alpha:~Delta]"), "[Alpha:~Delta]")
assert_equal(parse("[Alpha(Bravo, Charlie):~Delta(Echo, Foxtrot)]"), { "~", { "mod", "Delta", { "tag", "Alpha", { "tag", "Bravo"}, {"tag", "Charlie"} }, {"tag", "Echo"}, {"tag", "Foxtrot"} } })
assert_equal(DogTag:CleanCode("[Alpha(Bravo, Charlie):~Delta(Echo, Foxtrot)]"), "[Alpha(Bravo, Charlie):~Delta(Echo, Foxtrot)]")
assert_equal(parse("[Func('Alpha')]"), { "tag", "Func", {"'", "Alpha"} })
assert_equal(DogTag:CleanCode("[Func('Alpha')]"), "[Func('Alpha')]")
assert_equal(parse([=[[Func('Alp"ha')]]=]), { "tag", "Func", {"'", 'Alp"ha'} })
assert_equal(DogTag:CleanCode([=[[Func('Alp"ha')]]=]), [=[[Func('Alp"ha')]]=])

assert_equal(parse(""), { "nil" })
assert_equal(parse("['']"), { "'", '' })
assert_equal(parse('[""]'), { '"', '' })
assert_equal(parse("[nil]"), { "nil" })
assert_equal(parse("[false]"), { "false" })
assert_equal(standardize(parse("[false]")), { "nil" })
assert_equal(parse("[true]"), { "true" })
assert_equal(standardize(parse("[true]")), "True")
assert_equal(DogTag:CleanCode("[nil]"), "")
assert_equal(DogTag:CleanCode("[nil nil]"), "[nil nil]")
assert_equal(DogTag:CleanCode("[false]"), "[false]")
assert_equal(DogTag:CleanCode("[false false]"), "[false false]")
assert_equal(DogTag:CleanCode("[true]"), "[true]")
assert_equal(DogTag:CleanCode("[true true]"), "[true true]")
assert_equal(parse("['Alpha']"), { "'", "Alpha" })
assert_equal(parse('["Alpha"]'), { '"', "Alpha" })
assert_equal(DogTag:CleanCode("['Alpha']"), "Alpha")
assert_equal(DogTag:CleanCode('["Alpha"]'), "Alpha")
assert_equal(parse("[1234]"), 1234)
assert_equal(parse("['1234']"), { "'", "1234" })
assert_equal(standardize(parse("['1234']")), '1234')
assert_equal(standardize(parse("['0x1234']")), '0x1234')
assert_equal(standardize(parse("['1.000']")), '1.000')
assert_equal(standardize(parse("['1.00']")), '1.00')
assert_equal(standardize(parse("['1.0']")), '1.0')
assert_equal(standardize(parse("['1.']")), '1.')
assert_equal(standardize(parse("['1']")), '1')
assert_equal(standardize(parse("['01']")), '01')
assert_equal(standardize(parse("['001']")), '001')
assert_equal(standardize(parse("['0001']")), '0001')
assert_equal(DogTag:CleanCode("[1234]"), "1234")
assert_equal(parse("[-1234]"), -1234)
assert_equal(DogTag:CleanCode("[-1234]"), "-1234")
assert_equal(parse("[1234.5678]"), 1234.5678)
assert_equal(DogTag:CleanCode("[-1234.5678]"), "-1234.5678")
assert_equal(parse("[-1234.5678]"), -1234.5678)
assert_equal(DogTag:CleanCode("[-1234.5678]"), "-1234.5678")
assert_equal(parse("[1234e5]"), 123400000)
assert_equal(DogTag:CleanCode("[1234e5]"), "123400000")
assert_equal(parse("[1234e-5]"), 0.01234)
assert_equal(DogTag:CleanCode("[1234e-5]"), "0.01234")
assert_equal(parse("[-1234e5]"), -123400000)
assert_equal(DogTag:CleanCode("[-1234e5]"), "-123400000")
assert_equal(parse("[-1234e-5]"), -0.01234)
assert_equal(DogTag:CleanCode("[-1234e-5]"), "-0.01234")
assert_equal(DogTag:CleanCode("[1234] [5678]"), "1234 5678")
assert_equal(DogTag:CleanCode("['hello' 'there']"), "['hello' 'there']")
assert_equal(DogTag:CleanCode("[1234][5678]"), "[1234 5678]")

assert_equal(parse("['Hello [One] There']"), {"'", 'Hello [One] There'})
assert_equal(standardize(parse("['Hello [One] There']")), 'Hello [One] There')
assert_equal(DogTag:CleanCode("['Hello [One] There']"), "['Hello [One] There']")
assert_equal(DogTag:CleanCode('["Hello [One] There"]'), "[\"Hello [One] There\"]")

assert_equal(parse("[1 + 2]"), { "+", 1, 2, })
assert_equal(DogTag:CleanCode("[1 + 2]"), "[1 + 2]")
assert_equal(parse("[1 - 2]"), { "-", 1, 2, })
assert_equal(DogTag:CleanCode("[1 - 2]"), "[1 - 2]")
assert_equal(parse("[1 * 2]"), { "*", 1, 2, })
assert_equal(DogTag:CleanCode("[1 * 2]"), "[1 * 2]")
assert_equal(parse("[1 / 2]"), { "/", 1, 2, })
assert_equal(DogTag:CleanCode("[1 / 2]"), "[1 / 2]")
assert_equal(parse("[1 ^ 2]"), { "^", 1, 2, })
assert_equal(DogTag:CleanCode("[1 ^ 2]"), "[1 ^ 2]")
assert_equal(parse("[1 % 2]"), { "%", 1, 2, })
assert_equal(DogTag:CleanCode("[1 % 2]"), "[1 % 2]")
assert_equal(parse("[1 < 2]"), { "<", 1, 2 })
assert_equal(DogTag:CleanCode("[1 < 2]"), "[1 < 2]")
assert_equal(parse("[1 > 2]"), { ">", 1, 2 })
assert_equal(DogTag:CleanCode("[1 > 2]"), "[1 > 2]")
assert_equal(parse("[1 <= 2]"), { "<=", 1, 2 })
assert_equal(DogTag:CleanCode("[1 <= 2]"), "[1 <= 2]")
assert_equal(parse("[1 >= 2]"), { ">=", 1, 2 })
assert_equal(DogTag:CleanCode("[1 >= 2]"), "[1 >= 2]")
assert_equal(parse("[1 = 2]"), { "=", 1, 2 })
assert_equal(DogTag:CleanCode("[1 = 2]"), "[1 = 2]")
assert_equal(parse("[1 ~= 2]"), { "~=", 1, 2 })
assert_equal(DogTag:CleanCode("[1 ~= 2]"), "[1 ~= 2]")
assert_equal(parse("[1 and 2]"), { "and", 1, 2 })
assert_equal(DogTag:CleanCode("[1 and 2]"), "[1 and 2]")
assert_equal(parse("[1 or 2]"), { "or", 1, 2 })
assert_equal(DogTag:CleanCode("[1 or 2]"), "[1 or 2]")
assert_equal(DogTag:CleanCode("[Thing][Tag or OtherTag]"), "[Thing (Tag or OtherTag)]")
assert_equal(DogTag:CleanCode("[Thing] [Tag or OtherTag]"), "[Thing] [Tag or OtherTag]")
assert_equal(parse("[1 & 2]"), { "&", 1, 2 })
assert_equal(DogTag:CleanCode("[1 & 2]"), "[1 & 2]")
assert_equal(parse("[1 | 2]"), { "|", 1, 2 })
assert_equal(parse("[1 || 2]"), { "|", 1, 2 })
assert_equal(DogTag:CleanCode("[1 | 2]"), "[1 || 2]")
assert_equal(DogTag:CleanCode("[1 || 2]"), "[1 || 2]")
assert_equal(parse("[Alpha Bravo]"), { "concat", { "tag", "Alpha" }, { "tag", "Bravo"}, })
assert_equal(parse("[~Alpha:~Bravo]"), { "~", { "~" , { "mod", "Bravo", { "tag", "Alpha"}, }, }, })
assert_equal(DogTag:CleanCode("[One Bravo]"), "[One Bravo]")
assert_equal(parse("[1 ? 2]"), { "?", 1, 2 })
assert_equal(DogTag:CleanCode("[1?2]"), "[1 ? 2]")
assert_equal(parse("[1 ? 2 ! 3]"), { "?", 1, 2, 3 })
assert_equal(DogTag:CleanCode("[1?2!3]"), "[1 ? 2 ! 3]")
assert_equal(parse("[1?2!3?4!5]"), { "?", 1, 2, { "?", 3, 4, 5 } })
assert_equal(parse("[if 1 then 2]"), { "if", 1, 2 })
assert_equal(parse("[if(1)then(2)]"), { "if", { "(", 1}, {"(", 2} })
assert_equal(parse("[ifabc then def]"), nil)
assert_equal(parse("[if 1 then 2 end]"), { "if", 1, 2 })
assert_equal(DogTag:CleanCode("[if 1 then 2]"), "[if 1 then\n    2\nend]")
assert_equal(DogTag:CleanCode("[if 1 then 2 end]"), "[if 1 then\n    2\nend]")
assert_equal(parse("[if 1 then 2 else 3]"), { "if", 1, 2, 3 })
assert_equal(parse("[if 1 then 2 else 3 end]"), { "if", 1, 2, 3 })
assert_equal(DogTag:CleanCode("[if 1 then 2 else 3]"), "[if 1 then\n    2\nelse\n    3\nend]")
assert_equal(DogTag:CleanCode("[if 1 then 2 else 3 end]"), "[if 1 then\n    2\nelse\n    3\nend]")
assert_equal(parse("[if 1 then 2 else if 3 then 4 else 5]"), { "if", 1, 2, { "if", 3, 4, 5 } })
assert_equal(parse("[if 1 then 2 elseif 3 then 4 else 5]"), { "if", 1, 2, { "if", 3, 4, 5 } })
assert_equal(parse("[if 1 then 2 else if 3 then 4 else 5 end]"), { "if", 1, 2, { "if", 3, 4, 5 } })
assert_equal(parse("[if 1 then 2 elseif 3 then 4 else 5 end]"), { "if", 1, 2, { "if", 3, 4, 5 } })
assert_equal(DogTag:CleanCode("[if 1 then 2 else if 3 then 4 else 5]"), "[if 1 then\n    2\nelseif 3 then\n    4\nelse\n    5\nend]")
assert_equal(DogTag:CleanCode("[if 1 then 2 elseif 3 then 4 else 5]"), "[if 1 then\n    2\nelseif 3 then\n    4\nelse\n    5\nend]")
assert_equal(DogTag:CleanCode("[if 1 then 2 else if 3 then 4 else 5 end]"), "[if 1 then\n    2\nelseif 3 then\n    4\nelse\n    5\nend]")
assert_equal(DogTag:CleanCode("[if 1 then 2 elseif 3 then 4 else 5 end]"), "[if 1 then\n    2\nelseif 3 then\n    4\nelse\n    5\nend]")

assert_equal(DogTag:CleanCode("[if 1 then if 2 then 3 else 4 elseif 5 then 6 else 7]"), [=[[if 1 then
    if 2 then
        3
    else
        4
    end
elseif 5 then
    6
else
    7
end]]=])

assert_equal(DogTag:CleanCode("[if 1 then if 2 then 3 else 4 else (if 5 then 6 else 7)]"), [=[[if 1 then
    if 2 then
        3
    else
        4
    end
else
    (if 5 then
        6
    else
        7
    end)
end]]=])

assert_equal(parse("[Func('Hello' 'There')]"), { "tag", "Func", {"concat", {"'", "Hello"}, {"'", "There"}} })
assert_equal(DogTag:CleanCode("[Func('Hello' 'There')]"), "[Func('Hello' 'There')]")

assert_equal(standardize(parse("[1 & 2]")), { "and", 1, 2 })
assert_equal(standardize(parse("[1 | 2]")), { "or", 1, 2 })
assert_equal(standardize(parse("[1 || 2]")), { "or", 1, 2 })
assert_equal(standardize(parse("[1 ? 2]")), { "if", 1, 2 })
assert_equal(standardize(parse("[1 ? 2 ! 3]")), { "if", 1, 2, 3 })

assert_equal(parse("[1+2]"), { "+", 1, 2, })
assert_equal(parse("[1-2]"), { "-", 1, 2, })
assert_equal(parse("[1*2]"), { "*", 1, 2, })
assert_equal(parse("[1/2]"), { "/", 1, 2, })
assert_equal(parse("[1^2]"), { "^", 1, 2, })
assert_equal(parse("[1%2]"), { "%", 1, 2, })
assert_equal(parse("[1<2]"), { "<", 1, 2 })
assert_equal(parse("[1>2]"), { ">", 1, 2 })
assert_equal(parse("[1<=2]"), { "<=", 1, 2 })
assert_equal(parse("[1>=2]"), { ">=", 1, 2 })
assert_equal(parse("[1=2]"), { "=", 1, 2 })
assert_equal(parse("[1~=2]"), { "~=", 1, 2 })
assert_equal(parse("[1&2]"), { "&", 1, 2 })
assert_equal(parse("[1|2]"), { "|", 1, 2 })
assert_equal(parse("[1||2]"), { "|", 1, 2 })
assert_equal(parse("[1?2]"), { "?", 1, 2 })
assert_equal(parse("[1?2!3]"), { "?", 1, 2, 3 })

assert_equal(parse("[1 and 2 or 3]"), { "or", { "and", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 and 2 or 3]"), "[(1 and 2) or 3]")
assert_equal(parse("[1 or 2 and 3]"), { "and", { "or", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 or 2 and 3]"), "[(1 or 2) and 3]")
assert_equal(parse("[1 + 2 - 3]"), { "-", { "+", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 + 2 - 3]"), "[1 + 2 - 3]")
assert_equal(parse("[1 - 2 + 3]"), { "+", { "-", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 - 2 + 3]"), "[1 - 2 + 3]")
assert_equal(parse("[1 * 2 / 3]"), { "/", { "*", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 * 2 / 3]"), "[1 * 2 / 3]")
assert_equal(parse("[1 / 2 * 3]"), { "*", { "/", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 / 2 * 3]"), "[1 / 2 * 3]")
assert_equal(parse("[1 * 2 % 3]"), { "%", { "*", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 * 2 % 3]"), "[1 * 2 % 3]")
assert_equal(parse("[1 % 2 * 3]"), { "*", { "%", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 % 2 * 3]"), "[1 % 2 * 3]")

assert_equal(parse("[1 ? 2 and 3]"), { "?", 1, { "and", 2, 3 } })
assert_equal(DogTag:CleanCode("[1 ? 2 and 3]"), "[1 ? 2 and 3]")
assert_equal(parse("[1 and 2 ? 3]"), { "?", { "and", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 and 2 ? 3]"), "[1 and 2 ? 3]")
assert_equal(parse("[1 ? 2 and 3 ! 4 or 5]"), { "?", 1, { "and", 2, 3 }, { "or", 4, 5 } })
assert_equal(DogTag:CleanCode("[1 ? 2 and 3 ! 4 or 5]"), "[1 ? 2 and 3 ! 4 or 5]")
assert_equal(parse("[1 and 2 ? 3 ! 4]"), { "?", { "and", 1, 2 }, 3, 4 })
assert_equal(DogTag:CleanCode("[1 and 2 ? 3 ! 4]"), "[1 and 2 ? 3 ! 4]")
assert_equal(parse("[1 and 2 < 3]"), { "<", { "and", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 and 2 < 3]"), "[1 and 2 < 3]")
assert_equal(parse("[1 < 2 and 3]"), { "<", 1, { "and", 2, 3 } })
assert_equal(DogTag:CleanCode("[1 < 2 and 3]"), "[1 < 2 and 3]")
assert_equal(parse("[1 + 2 and 3]"), { "and", { "+", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 + 2 and 3]"), "[1 + 2 and 3]")
assert_equal(parse("[1 and 2 + 3]"), { "and", 1, { "+", 2, 3 } })
assert_equal(DogTag:CleanCode("[1 and 2 + 3]"), "[1 and 2 + 3]")
assert_equal(parse("[1 + 2 * 3]"), { "+", 1, { "*", 2, 3 }, })
assert_equal(DogTag:CleanCode("[1 + 2 * 3]"), "[1 + 2 * 3]")
assert_equal(parse("[1 * 2 + 3]"), { "+", { "*", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 * 2 + 3]"), "[1 * 2 + 3]")
assert_equal(parse("[1 * 2 ^ 3]"), { "*", 1, { "^", 2, 3 }, })
assert_equal(DogTag:CleanCode("[1 * 2 ^ 3]"), "[1 * 2 ^ 3]")
assert_equal(parse("[1 ^ 2 * 3]"), { "*", { "^", 1, 2 }, 3 })
assert_equal(DogTag:CleanCode("[1 ^ 2 * 3]"), "[1 ^ 2 * 3]")

assert_equal(parse("[(1 ^ 2) * 3]"), { "*", { "(", { "^", 1, 2 } }, 3 })
assert_equal(parse("[[1 ^ 2] * 3]"), { "*", { "[", { "^", 1, 2 } }, 3 })
-- pointless parenthesization should stay
assert_equal(DogTag:CleanCode("[(1 ^ 2) * 3]"), "[(1 ^ 2) * 3]")
assert_equal(DogTag:CleanCode("[[1 ^ 2] * 3]"), "[[1 ^ 2] * 3]")

assert_equal(parse("[(1) * 3]"), { "*", { "(", 1 }, 3 })
assert_equal(parse("[[1] * 3]"), { "*", { "[", 1 }, 3 })

-- but parenthesization of a tag, number, or string should go away
assert_equal(DogTag:CleanCode("[(1) * 3]"), "[1 * 3]")
assert_equal(DogTag:CleanCode("[[1] * 3]"), "[1 * 3]")
assert_equal(DogTag:CleanCode("[1 * (3)]"), "[1 * 3]")
assert_equal(DogTag:CleanCode("[1 * [3]]"), "[1 * 3]")
assert_equal(DogTag:CleanCode("[Func(('Hello') 'There')]"), "[Func('Hello' 'There')]")
assert_equal(DogTag:CleanCode("[Func(['Hello'] 'There')]"), "[Func('Hello' 'There')]")
assert_equal(DogTag:CleanCode("[Func('Hello' ('There'))]"), "[Func('Hello' 'There')]")
assert_equal(DogTag:CleanCode("[Func('Hello' ['There'])]"), "[Func('Hello' 'There')]")
assert_equal(DogTag:CleanCode("[(Alpha) * Bravo]"), "[Alpha * Bravo]")
assert_equal(DogTag:CleanCode("[[Alpha] * Bravo]"), "[Alpha * Bravo]")
assert_equal(DogTag:CleanCode("[(Alpha) * Bravo]"), "[Alpha * Bravo]")
assert_equal(DogTag:CleanCode("[[Alpha] * Bravo]"), "[Alpha * Bravo]")

assert_equal(parse("[1 ^ (2 * 3)]"), { "^", 1, { "(", { "*", 2, 3 } } })
assert_equal(parse("[1 ^ [2 * 3]]"), { "^", 1, { "[", { "*", 2, 3 } } })
assert_equal(DogTag:CleanCode("[1 ^ (2 * 3)]"), "[1 ^ (2 * 3)]")
assert_equal(DogTag:CleanCode("[1 ^ [2 * 3]]"), "[1 ^ [2 * 3]]")
assert_equal(parse("[(1 + 2) * 3]"), { "*", { "(", { "+", 1, 2 } }, 3 })
assert_equal(DogTag:CleanCode("[(1 + 2) * 3]"), "[(1 + 2) * 3]")
assert_equal(parse("[1 + (2 ? 3)]"), { "+", 1, { "(", { "?", 2, 3 } } })
assert_equal(DogTag:CleanCode("[1 + (2 ? 3)]"), "[1 + (2 ? 3)]")
assert_equal(parse("[(2 ? 3 ! 4) + 1]"), { "+", { "(", { "?", 2, 3, 4 } }, 1 })
assert_equal(DogTag:CleanCode("[(2 ? 3 ! 4) + 1]"), "[(2 ? 3 ! 4) + 1]")
assert_equal(parse("[1 + (if 2 then 3)]"), { "+", 1, { "(", { "if", 2, 3 } } })
assert_equal(DogTag:CleanCode("[1 + (if 2 then 3)]"), "[1 + (if 2 then\n    3\nend)]")
assert_equal(parse("[(if 2 then 3 else 4) + 1]"), { "+", { "(", { "if", 2, 3, 4 } }, 1 })
assert_equal(DogTag:CleanCode("[(if 2 then 3 else 4) + 1]"), "[(if 2 then\n    3\nelse\n    4\nend) + 1]")

assert_equal(parse("[Alpha(Bravo + Charlie)]"), { "tag", "Alpha", { "+", {"tag", "Bravo"}, {"tag", "Charlie"} } })
assert_equal(DogTag:CleanCode("[Alpha(Bravo + Charlie)]"), "[Alpha(Bravo + Charlie)]")
assert_equal(parse("[Alpha (Bravo + Charlie)]"), { "concat", {"tag", "Alpha"}, { "(", { "+", {"tag", "Bravo"}, {"tag", "Charlie"} } } })
assert_equal(DogTag:CleanCode("[One (Bravo + Charlie)]"), "[One (Bravo + Charlie)]")

assert_equal(parse("[not Alpha]"), { "not", { "tag", "Alpha" }, })
assert_equal(DogTag:CleanCode("[not Alpha]"), "[not Alpha]")
assert_equal(parse("[not not Alpha]"), { "not", { "not", { "tag", "Alpha" }, }, })
assert_equal(DogTag:CleanCode("[not not Alpha]"), "[not not Alpha]")
assert_equal(parse("[~Alpha]"), { "~", { "tag", "Alpha" }, })
assert_equal(DogTag:CleanCode("[~Alpha]"), "[~Alpha]")
assert_equal(parse("[~(1 > 2)]"), { "~", { "(", { ">", 1, 2 } }, })
assert_equal(DogTag:CleanCode("[~(1 > 2)]"), "[~(1 > 2)]")
assert_equal(parse("[not(1 > 2)]"), { "not", { "(", { ">", 1, 2 } }, })
assert_equal(DogTag:CleanCode("[not(1 > 2)]"), "[not (1 > 2)]")
assert_equal(standardize(parse("[~Alpha]")), { "not", { "tag", "Alpha" }, })

assert_equal(standardize(parse("[Alpha(bravo=(Charlie+2))]")), { "tag", "Alpha", kwarg = { bravo = { "+", { "tag", "Charlie" }, 2 } } })

assert_equal(parse("[Alpha(key=Bravo)]"), { "tag", "Alpha", kwarg = { key = { "tag", "Bravo" } } })
assert_equal(DogTag:CleanCode("[Alpha(key=Bravo)]"), "[Alpha(key=Bravo)]")
assert_equal(parse("[Alpha(Bravo, key=Charlie)]"), { "tag", "Alpha", { "tag", "Bravo" }, kwarg = { key = { "tag", "Charlie" } } })
assert_equal(DogTag:CleanCode("[Alpha(Bravo, key=Charlie)]"), "[Alpha(Bravo, key=Charlie)]")
assert_equal(parse("[Alpha(bravo=Charlie, delta=Echo)]"), { "tag", "Alpha", kwarg = { bravo = { "tag", "Charlie" }, delta = { "tag", "Echo" } } })
assert_equal(DogTag:CleanCode("[Alpha(bravo=Charlie, delta=Echo)]"), "[Alpha(bravo=Charlie, delta=Echo)]")
assert_equal(DogTag:CleanCode("[Alpha(delta=Echo, bravo=Charlie)]"), "[Alpha(bravo=Charlie, delta=Echo)]")
assert_equal(parse("[Alpha((key=Bravo))]"), { "tag", "Alpha", { "(", { "=", { "tag", "key" }, { "tag", "Bravo" } } } })
assert_equal(DogTag:CleanCode("[Alpha(key = Bravo)]"), "[Alpha(key = Bravo)]")
assert_equal(DogTag:CleanCode("[Alpha((key=Bravo))]"), "[Alpha((key = Bravo))]")
assert_equal(parse("[Class(unit='mouseovertarget')]"), { "tag", "Class", kwarg = { unit = {"'", "mouseovertarget"} } })
assert_equal(parse("[Alpha(key=Bravo, Charlie)]"), nil)
assert_equal(parse("[Alpha(Bravo Charlie)]"), { "tag", "Alpha", { "concat", { "tag", "Bravo"}, { "tag", "Charlie" } } })
assert_equal(parse("[Alpha(Bravo ' ' Charlie)]"), { "tag", "Alpha", { "concat", { "tag", "Bravo"}, {"'", " "}, { "tag", "Charlie" } } })
assert_equal(DogTag:CleanCode("[Alpha(Bravo ' ' Charlie)]"), "[Alpha(Bravo ' ' Charlie)]")
assert_equal(DogTag:CleanCode("[Alpha(Bravo \" \" Charlie)]"), "[Alpha(Bravo \" \" Charlie)]")

assert_equal(parse("[Alpha:Bravo(key=Charlie)]"), { "mod", "Bravo", { "tag", "Alpha" }, kwarg = { key = { "tag", "Charlie" } } })
assert_equal(DogTag:CleanCode("[Alpha:Bravo(key=Charlie)]"), "[Alpha:Bravo(key=Charlie)]")
assert_equal(parse("[Alpha:Bravo(Charlie, key=Delta)]"), { "mod", "Bravo", { "tag", "Alpha" }, { "tag", "Charlie" }, kwarg = { key = { "tag", "Delta" } } })
assert_equal(DogTag:CleanCode("[Alpha:Bravo(Charlie, key=Delta)]"), "[Alpha:Bravo(Charlie, key=Delta)]")
assert_equal(parse("[Tag:Alpha(bravo=Charlie, delta=Echo)]"), { "mod", "Alpha", { "tag", "Tag" }, kwarg = { bravo = { "tag", "Charlie" }, delta = { "tag", "Echo" } } })
assert_equal(DogTag:CleanCode("[Tag:Alpha(bravo=Charlie, delta=Echo)]"), "[Tag:Alpha(bravo=Charlie, delta=Echo)]")
assert_equal(DogTag:CleanCode("[Tag:Alpha(delta=Echo, bravo=Charlie)]"), "[Tag:Alpha(bravo=Charlie, delta=Echo)]")
assert_equal(parse("[Tag:Alpha((key=Bravo))]"), { "mod", "Alpha", { "tag", "Tag" }, { "(", { "=", { "tag", "key" }, { "tag", "Bravo" } } } })
assert_equal(DogTag:CleanCode("[Tag:Alpha(key = Bravo)]"), "[Tag:Alpha(key = Bravo)]")
assert_equal(DogTag:CleanCode("[Tag:Alpha((key=Bravo))]"), "[Tag:Alpha((key = Bravo))]")
assert_equal(parse("[Class(unit='mouseovertarget'):ClassColor(unit='mouseovertarget')]"), { "mod", "ClassColor", { "tag", "Class", kwarg = { unit = {"'", "mouseovertarget"} } }, kwarg = { unit = {"'", "mouseovertarget"} } })

assert_equal(parse("[-MissingHP]"), { "unm", { "tag", "MissingHP" } })
assert_equal(DogTag:CleanCode("[-MissingHP]"), "[-MissingHP]")
assert_equal(parse("[-(-1)]"), { "unm", { "(", -1 } })
assert_equal(standardize(parse("[-(-1)]")), {"unm", -1})
assert_equal(standardize(parse("[-(-(-1))]")), { "unm", { "unm", -1}})
assert_equal(parse("[AbsoluteValue(-5)]"), { "tag", "AbsoluteValue", -5 })
assert_equal(parse("[(-5):AbsoluteValue]"), { "mod", "AbsoluteValue", { "(", -5 } })
assert_equal(parse("[-5:AbsoluteValue]"), { "mod", "AbsoluteValue", -5})
assert_equal(parse("[-5:AbsoluteValue:AbsoluteValue]"), { "mod", "AbsoluteValue", { "mod", "AbsoluteValue", -5} })
assert_equal(parse("[-MissingHP:AbsoluteValue]"), { "mod", "AbsoluteValue", { "unm", { "tag", "MissingHP" } } })

assert_equal(parse("[]"), nil)
assert_equal(parse("["), nil)
assert_equal(parse("hello []"), nil)
assert_equal(parse("hello ["), nil)
assert_equal(DogTag:CleanCode("[]"), "[]")
assert_equal(DogTag:CleanCode("["), "[")
assert_equal(DogTag:CleanCode("hello []"), "hello []")
assert_equal(DogTag:CleanCode("hello ["), "hello [")

assert_equal(DogTag:ColorizeCode("hello"), "|cffff7f7fhello|r")
assert_equal(DogTag:ColorizeCode("[or]"), "|cffffffff[|cffff7fffor|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[+]"), "|cffffffff[|cffff7fff+|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[~=]"), "|cffffffff[|cffff7fff~=|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[<=]"), "|cffffffff[|cffff7fff<=|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[>=]"), "|cffffffff[|cffff7fff>=|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[||]"), "|cffffffff[|cffff7fff|||cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[Tag]"), "|cffffffff[|cff00ffffTag|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("['Hello']"), "|cffffffff[|cffff7f7f'Hello'|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[Tag(Arg)]"), "|cffffffff[|cff00ffffTag|cffffffff(|cff00ffffArg|cffffffff)|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[Tag(Arg, Other)]"), "|cffffffff[|cff00ffffTag|cffffffff(|cff00ffffArg|cffffffff, |cff00ffffOther|cffffffff)|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[Tag(kw=Arg)]"), "|cffffffff[|cff00ffffTag|cffffffff(|cffff0000kw|cffff7fff=|cff00ffffArg|cffffffff)|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[Tag:Mod]"), "|cffffffff[|cff00ffffTag|cffff7fff:|cff00ff00Mod|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("hello [Tag:Mod] hello"), "|cffff7f7fhello |cffffffff[|cff00ffffTag|cffff7fff:|cff00ff00Mod|cffffffff]|cffff7f7f hello|r")
assert_equal(DogTag:ColorizeCode("[(Tag)]"), "|cffffffff[|cffffffff(|cff00ffffTag|cffffffff)|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[42]"), "|cffffffff[|cffff7f7f42|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[42.5]"), "|cffffffff[|cffff7f7f42.5|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[42e5]"), "|cffffffff[|cffff7f7f42e5|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[42.5e5]"), "|cffffffff[|cffff7f7f42.5e5|cffffffff]|r")
assert_equal(DogTag:ColorizeCode(("x"):rep(10000)), "|cffff7f7f" .. ("x"):rep(10000) .. "|r")
assert_equal(DogTag:ColorizeCode("[" .. ("x"):rep(10000) .. "]"), "|cffffffff[|cff00ffff" .. ("x"):rep(10000) .. "|cffffffff]|r")
assert_equal(DogTag:ColorizeCode("[" .. ("1"):rep(10000) .. "]"), "|cffffffff[|cffff7f7f" .. ("1"):rep(10000) .. "|cffffffff]|r")

old_DogTag_Evaluate(DogTag, "[Alpha(key=Bravo, Charlie)]")

assert_equal(DogTag:Evaluate("[Alpha(key=Bravo, Charlie)]"), "Syntax error")

assert_equal(DogTag:Evaluate("[StaticOne]"), 1)

assert_equal(DogTag:Evaluate("[One]"), 1)
assert_equal(DogTag:Evaluate("[One:PlusOne]"), 2)
assert_equal(DogTag:Evaluate("[PlusOne(One):PlusOne]"), 3)
assert_equal(DogTag:Evaluate("[PlusOne(number=One)]"), 2)
GlobalCheck_data = "Hello World"
assert_equal(DogTag:Evaluate("[GlobalCheck]"), "Hello World")
GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[One] [GlobalCheck] [Two]"), "1 2")
assert_equal(DogTag:Evaluate("[One]    [Two]"), "1    2")
assert_equal(DogTag:Evaluate("    [One]    [Two]    "), "    1    2    ")
assert_equal(DogTag:Evaluate("[GlobalCheck] Hello"), "Hello")
assert_equal(DogTag:Evaluate("[GlobalCheck] [GlobalCheck] Hello"), "Hello")
assert_equal(DogTag:Evaluate("Hello [GlobalCheck]"), "Hello")
assert_equal(DogTag:Evaluate("Hello [GlobalCheck] [GlobalCheck]"), "Hello")
assert_equal(DogTag:Evaluate("[GlobalCheck] [GlobalCheck] Hello [GlobalCheck] [GlobalCheck]"), "Hello")
assert_equal(DogTag:Evaluate("[GlobalCheck] [One] [Two]"), "1 2")

myfunc_num = 0
assert_equal(DogTag:Evaluate("[FunctionNumberCheck]"), 1)
assert_equal(DogTag:Evaluate("[FunctionNumberCheck]"), 2)
assert_equal(DogTag:Evaluate("[FunctionNumberCheck] [FunctionNumberCheck]"), "3 3") -- check caching

assert_equal(DogTag:Evaluate("[AbsoluteValue(5)]"), 5)
assert_equal(DogTag:Evaluate("[AbsoluteValue(-5)]"), 5)
assert_equal(DogTag:Evaluate("[5:AbsoluteValue]"), 5)
assert_equal(DogTag:Evaluate("[-5:AbsoluteValue]"), 5)

GlobalCheck_data = 2
assert_equal(DogTag:Evaluate("[GlobalCheck + One]"), 3)
assert_equal(DogTag:Evaluate("[One + GlobalCheck]"), 3)
assert_equal(DogTag:Evaluate("[GlobalCheck + GlobalCheck]"), 4)

assert_equal(DogTag:Evaluate("[PlusOne]"), [=[Arg #1 (number) req'd for PlusOne]=])
assert_equal(DogTag:Evaluate("[Unknown]"), [=[Unknown tag Unknown]=])
assert_equal(DogTag:Evaluate("[Subtract(Unknown, 2)]"), [=[Unknown tag Unknown]=])
assert_equal(DogTag:Evaluate("[Subtract]"), [=[Arg #1 (left) req'd for Subtract]=])
assert_equal(DogTag:Evaluate("[Subtract(1)]"), [=[Arg #2 (right) req'd for Subtract]=])
assert_equal(DogTag:Evaluate("[Subtract(right=2)]"), [=[Arg #1 (left) req'd for Subtract]=])
assert_equal(DogTag:Evaluate("[Subtract(left=1)]"), [=[Arg #2 (right) req'd for Subtract]=])
assert_equal(DogTag:Evaluate("[Subtract(1, 2, extra='Stuff')]"), -1)
assert_equal(DogTag:Evaluate("[Subtract(1, 2, 3)]"), [=[Too many args for Subtract]=])
assert_equal(DogTag:Evaluate("[CheckNumDefault(1)]"), 1)
assert_equal(DogTag:Evaluate("[CheckNumDefault]"), 50)
assert_equal(DogTag:Evaluate("[CheckNumDefault(50)]"), 50)
assert_equal(DogTag:Evaluate("[CheckNumDefault(One)]"), 1)
assert_equal(DogTag:Evaluate("[CheckNumDefault('Test')]"), 0)
assert_equal(DogTag:Evaluate("[CheckStrDefault(1)]"), 1)
assert_equal(DogTag:Evaluate("[CheckStrDefault]"), "Value")
assert_equal(DogTag:Evaluate("[CheckStrDefault(50)]"), 50)
assert_equal(DogTag:Evaluate("[CheckStrDefault(One)]"), 1)
assert_equal(DogTag:Evaluate("[CheckStrDefault('Test')]"), "Test")
assert_equal(DogTag:Evaluate("[CheckNilDefault(1)]"), 1)
assert_equal(DogTag:Evaluate("[CheckNilDefault]"), nil)
assert_equal(DogTag:Evaluate("[CheckNilDefault(50)]"), 50)
assert_equal(DogTag:Evaluate("[CheckNilDefault('Test')]"), nil)
assert_equal(DogTag:Evaluate("[CheckNilDefault(One)]"), 1)
assert_equal(DogTag:Evaluate(("x"):rep(10000)), ("x"):rep(10000))
assert_equal(DogTag:Evaluate("[" .. ("x"):rep(10000) .. "]"), "Unknown tag " .. ("x"):rep(10000))
assert_equal(DogTag:Evaluate("[" .. ("1"):rep(10000) .. "]"), math.huge)

assert_equal(DogTag:Evaluate("[1 + 2]"), 3)
assert_equal(DogTag:Evaluate("[1 - 2]"), -1)
assert_equal(DogTag:Evaluate("[1 * 2]"), 2)
assert_equal(DogTag:Evaluate("[1 / 2]"), 1/2)
assert_equal(DogTag:Evaluate("[0 / 0]"), 0) -- odd case, good for WoW
assert_equal(standardize(parse("[1 / 0]")), { "/", 1, 0 })
assert_equal(standardize(parse("[(1 / 0)]")), { "/", 1, 0 })
--[[ Parnic: 1/0 and -1/0 is not usually supported on PTRs, could go live that way
assert_equal(DogTag:Evaluate("[1 / 0]"), 1/0)
assert_equal(DogTag:Evaluate("[(1 / 0)]"), 1/0)
assert_equal(DogTag:Evaluate("[-1 / 0]"), -1/0)
assert_equal(DogTag:Evaluate("[-(1 / 0)]"), -1/0)
--]]
assert_equal(parse("[(1 / 0)]"), { "(", { "/", 1, 0 } })
assert_equal(DogTag:Evaluate("[5 % 3]"), 2)
assert_equal(DogTag:Evaluate("[5 ^ 3]"), 125)
assert_equal(DogTag:Evaluate("[5 < 3]"), nil)
assert_equal(DogTag:Evaluate("[3 < 5]"), 3)
assert_equal(DogTag:Evaluate("[3 < 3]"), nil)
assert_equal(DogTag:Evaluate("[5 > 3]"), 5)
assert_equal(DogTag:Evaluate("[3 > 5]"), nil)
assert_equal(DogTag:Evaluate("[3 > 3]"), nil)
assert_equal(DogTag:Evaluate("[5 <= 3]"), nil)
assert_equal(DogTag:Evaluate("[3 <= 5]"), 3)
assert_equal(DogTag:Evaluate("[3 <= 3]"), 3)
assert_equal(DogTag:Evaluate("[5 >= 3]"), 5)
assert_equal(DogTag:Evaluate("[3 >= 5]"), nil)
assert_equal(DogTag:Evaluate("[3 >= 3]"), 3)
assert_equal(DogTag:Evaluate("[1 = 1]"), 1)
assert_equal(DogTag:Evaluate("[1 = 2]"), nil)
assert_equal(DogTag:Evaluate("[1 ~= 1]"), nil)
assert_equal(DogTag:Evaluate("[1 ~= 2]"), 1)
assert_equal(DogTag:Evaluate("[1 and 2]"), 2)
assert_equal(DogTag:Evaluate("[1 or 2]"), 1)
assert_equal(DogTag:Evaluate("[(1 = 2) and 2]"), nil)
assert_equal(DogTag:Evaluate("[(1 = 2) or 2]"), 2)
assert_equal(DogTag:Evaluate("[1 & 2]"), 2)
assert_equal(DogTag:Evaluate("[1 | 2]"), 1)
assert_equal(DogTag:Evaluate("[1 || 2]"), 1)
assert_equal(DogTag:Evaluate("[(1 = 2) & 2]"), nil)
assert_equal(DogTag:Evaluate("[(1 = 2) | 2]"), 2)
assert_equal(DogTag:Evaluate("[(1 = 2) || 2]"), 2)
assert_equal(DogTag:Evaluate("[nil = 5]"), nil)
assert_equal(DogTag:Evaluate("[5 = nil]"), nil)
assert_equal(DogTag:Evaluate("[if 1 then 2]"), 2)
assert_equal(DogTag:Evaluate("[if 1 then 2 else 3]"), 2)
assert_equal(DogTag:Evaluate("[if 1 = 2 then 2]"), nil)
assert_equal(DogTag:Evaluate("[if 1 = 2 then 2 else 3]"), 3)
assert_equal(DogTag:Evaluate("[1 ? 2]"), 2)
assert_equal(DogTag:Evaluate("[1 ? 2 ! 3]"), 2)
assert_equal(DogTag:Evaluate("[1 = 2 ? 2]"), nil)
assert_equal(DogTag:Evaluate("[1 = 2 ? 2 ! 3]"), 3)
assert_equal(DogTag:Evaluate("['Hello' 'There']"), "HelloThere")
assert_equal(DogTag:Evaluate("[-(-1)]"), 1)
assert_equal(DogTag:Evaluate("[-One]"), -1)
assert_equal(DogTag:Evaluate("[not 'Hello']"), nil)
assert_equal(DogTag:Evaluate("[not not 'Hello']"), "True")
GlobalCheck_data = 'Hello World'
assert_equal(DogTag:Evaluate("[GlobalCheck]"), "Hello World")
assert_equal(DogTag:Evaluate("[not GlobalCheck]"), nil)
assert_equal(DogTag:Evaluate("[not not GlobalCheck]"), "True")
GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[GlobalCheck]"), nil)
assert_equal(DogTag:Evaluate("[not GlobalCheck]"), "True")
assert_equal(DogTag:Evaluate("[not not GlobalCheck]"), nil)
GlobalCheckBoolean_data = true
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean]"), "True")
assert_equal(DogTag:Evaluate("[not GlobalCheckBoolean]"), nil)
assert_equal(DogTag:Evaluate("[not not GlobalCheckBoolean]"), "True")
GlobalCheckBoolean_data = false
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean]"), nil)
assert_equal(DogTag:Evaluate("[not GlobalCheckBoolean]"), "True")
assert_equal(DogTag:Evaluate("[not not GlobalCheckBoolean]"), nil)
assert_equal(DogTag:Evaluate("[One + One]"), 2)
assert_equal(DogTag:Evaluate("[Subtract(1, 2)]"), -1)
assert_equal(DogTag:Evaluate("[Subtract(2, 1)]"), 1)
assert_equal(DogTag:Evaluate("[Subtract(1, right=2)]"), -1)
assert_equal(DogTag:Evaluate("[Subtract(2, right=1)]"), 1)
assert_equal(DogTag:Evaluate("[Subtract(left=1, right=2)]"), -1)
assert_equal(DogTag:Evaluate("[Subtract(right=1, left=2)]"), 1)
assert_equal(DogTag:Evaluate("[1:Subtract(2)]"), -1)
assert_equal(DogTag:Evaluate("[2:Subtract(1)]"), 1)
assert_equal(DogTag:Evaluate("[false]"), nil)
assert_equal(DogTag:Evaluate("[not false]"), "True")
assert_equal(DogTag:Evaluate("[true]"), "True")
assert_equal(DogTag:Evaluate("[not true]"), nil)
assert_equal(DogTag:Evaluate("[nil nil]"), nil)
assert_equal(DogTag:Evaluate("[false false]"), nil)
assert_equal(DogTag:Evaluate("[nil '' false]"), nil)
assert_equal(DogTag:Evaluate("[not nil not '' not false]"), "TrueTrueTrue")
assert_equal(DogTag:Evaluate("[nil 'Hello' nil]"), "Hello")
assert_equal(DogTag:Evaluate("[nil 1234 nil]"), 1234)
assert_equal(DogTag:Evaluate("[nil 1234 One nil]"), 12341)
GlobalCheck_data = 5
assert_equal(DogTag:Evaluate("[nil 1234 GlobalCheck nil]"), 12345)
GlobalCheck_data = 'Hello'
assert_equal(DogTag:Evaluate("[nil 1234 GlobalCheck nil]"), '1234Hello')
assert_equal(DogTag:Evaluate("['+' 1234]"), '+1234')

assert_equal(DogTag:Evaluate("Hello [Unknown#test]"), 'Syntax error')

myfunc_num = 0
assert_equal(DogTag:Evaluate("[FunctionNumberCheck]"), 1)
assert_equal(DogTag:Evaluate("[true and FunctionNumberCheck]"), 2)
assert_equal(DogTag:Evaluate("[false and FunctionNumberCheck]"), nil) -- shouldn't call FunctionNumberCheck
assert_equal(DogTag:Evaluate("[FunctionNumberCheck]"), 3)
assert_equal(DogTag:Evaluate("[true or FunctionNumberCheck]"), "True") -- shouldn't call FunctionNumberCheck
assert_equal(DogTag:Evaluate("[false or FunctionNumberCheck]"), 4)
assert_equal(DogTag:Evaluate("[if true then FunctionNumberCheck]"), 5)
assert_equal(DogTag:Evaluate("[if false then FunctionNumberCheck]"), nil)
assert_equal(DogTag:Evaluate("[FunctionNumberCheck]"), 6)
assert_equal(DogTag:Evaluate("[if true then 'True' else FunctionNumberCheck]"), 'True')
assert_equal(DogTag:Evaluate("[FunctionNumberCheck]"), 7)
assert_equal(DogTag:Evaluate("[if false then 'True' else FunctionNumberCheck]"), 8)

myfunc_num = 0
assert_equal(DogTag:Evaluate("[FunctionNumberCheck]"), 1)
GlobalCheck_data = "True"
assert_equal(DogTag:Evaluate("[GlobalCheck and FunctionNumberCheck]"), 2)
GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[GlobalCheck and FunctionNumberCheck]"), nil) -- shouldn't call FunctionNumberCheck
assert_equal(DogTag:Evaluate("[FunctionNumberCheck]"), 3)
GlobalCheck_data = "True"
assert_equal(DogTag:Evaluate("[GlobalCheck or FunctionNumberCheck]"), "True") -- shouldn't call FunctionNumberCheck
GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[GlobalCheck or FunctionNumberCheck]"), 4)
GlobalCheck_data = "True"
assert_equal(DogTag:Evaluate("[if GlobalCheck then FunctionNumberCheck]"), 5)
GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[if GlobalCheck then FunctionNumberCheck]"), nil)
assert_equal(DogTag:Evaluate("[FunctionNumberCheck]"), 6)
GlobalCheck_data = "True"
assert_equal(DogTag:Evaluate("[if GlobalCheck then 'True' else FunctionNumberCheck]"), 'True')
assert_equal(DogTag:Evaluate("[FunctionNumberCheck]"), 7)
GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[if GlobalCheck then 'True' else FunctionNumberCheck]"), 8)


assert_equal(DogTag:Evaluate("[Boolean('True' and nil:Short)]"), nil)
GlobalCheck_data = "True"
assert_equal(DogTag:Evaluate("[Boolean(GlobalCheck and nil:Short)]"), nil)
GlobalCheckBoolean_data = true
assert_equal(DogTag:Evaluate("[Boolean(GlobalCheckBoolean and nil:Short)]"), nil)
assert_equal(DogTag:Evaluate("[Boolean('True' and 0:Hide(0):Short)]"), nil)
GlobalCheck_data = "True"
assert_equal(DogTag:Evaluate("[Boolean(GlobalCheck and 0:Hide(0):Short)]"), nil)
assert_equal(DogTag:Evaluate("[Boolean(RetSame('True') and 0:Hide(0):Short)]"), nil)
GlobalCheckBoolean_data = true
assert_equal(DogTag:Evaluate("[Boolean(GlobalCheckBoolean and 0:Hide(0):Short)]"), nil)
assert_equal(DogTag:Evaluate("[Boolean(OtherRetSame('True') and (One - 1):Hide(0):Short)]"), nil)

assert_equal(DogTag:Evaluate("[Boolean(if 'True' then nil:Short)]"), nil)
GlobalCheck_data = "True"
assert_equal(DogTag:Evaluate("[Boolean(if GlobalCheck then nil:Short)]"), nil)
GlobalCheckBoolean_data = true
assert_equal(DogTag:Evaluate("[Boolean(if GlobalCheckBoolean then nil:Short)]"), nil)
assert_equal(DogTag:Evaluate("[Boolean(if 'True' then 0:Hide(0):Short)]"), nil)
GlobalCheck_data = "True"
assert_equal(DogTag:Evaluate("[Boolean(if GlobalCheck then 0:Hide(0):Short)]"), nil)
GlobalCheckBoolean_data = true
assert_equal(DogTag:Evaluate("[Boolean(if GlobalCheckBoolean then 0:Hide(0):Short)]"), nil)
assert_equal(DogTag:Evaluate("[Boolean(if OtherRetSame('True') then (One - 1):Hide(0):Short)]"), nil)


assert_equal(DogTag:Evaluate("[PlusOne(1 1)]"), 12)

assert_equal(DogTag:Evaluate("[CheckNumTuple(1)]"), 1)
assert_equal(DogTag:Evaluate("[CheckNumTuple(1, 2)]"), '1-2')
assert_equal(DogTag:Evaluate("[CheckNumTuple(1, 2, 3)]"), '1-2-3')
assert_equal(DogTag:Evaluate("[CheckNumTuple(1, 2, 3, 'Hello')]"), '1-2-3-0')
assert_equal(DogTag:Evaluate("[CheckNumTuple(1, 2, 3, One, 'Hello')]"), '1-2-3-1-0')
assert_equal(DogTag:Evaluate("[CheckNumTuple]"), nil)

assert_equal(DogTag:Evaluate("[CheckAnotherNumTuple(1)]"), 1)
assert_equal(DogTag:Evaluate("[CheckAnotherNumTuple(1, 2)]"), 2)
assert_equal(DogTag:Evaluate("[CheckAnotherNumTuple(1, 2, 3)]"), 3)
assert_equal(DogTag:Evaluate("[CheckAnotherNumTuple(1, -2, One:PlusOne, -3)]"), 2)
assert_equal(DogTag:Evaluate("[CheckAnotherNumTuple]"), 0) -- special cause it does math.max(0, ...), which should turn into math.max(0), not math.max(0, )

assert_equal(DogTag:Evaluate("[CheckStrTuple('Hello')]"), 'Hylly')
assert_equal(DogTag:Evaluate("[CheckStrTuple(1)]"), 1)
assert_equal(DogTag:Evaluate("[CheckStrTuple(One)]"), 1)
assert_equal(DogTag:Evaluate("[CheckStrTuple('Hello', \"There\", 'Friend')]"), 'HyllyThyryFryynd')
assert_equal(DogTag:Evaluate("[CheckStrTuple]"), nil)
assert_equal(DogTag:Evaluate("[CheckStrTuple('Hello', 52, 'Friend', One)]"), 'Hylly52Fryynd1')

assert_equal(DogTag:Evaluate("[CheckBooleanTuple]"), 0)
assert_equal(DogTag:Evaluate("[CheckBooleanTuple(true, false, true)]"), 5)
assert_equal(DogTag:Evaluate("[CheckBooleanTuple(true, true, false, true)]"), 11)

assert_equal(DogTag:Evaluate("[CheckNilTuple]"), 0)
assert_equal(DogTag:Evaluate("[CheckNilTuple(true, false, true)]"), 3)
assert_equal(DogTag:Evaluate("[CheckNilTuple(true, true, false, true)]"), 4)

assert_equal(DogTag:Evaluate("[CheckAnyTuple]"), nil)
assert_equal(DogTag:Evaluate("[CheckAnyTuple(true, false, true)]"), "string:True;nil:nil;string:True")
assert_equal(DogTag:Evaluate("[CheckAnyTuple(1, 'Hello', nil)]"), "number:1;string:Hello;nil:nil")
GlobalCheck_data = 'Hello'
GlobalCheckBoolean_data = false
assert_equal(DogTag:Evaluate("[CheckAnyTuple(One, GlobalCheck, GlobalCheckBoolean)]"), "number:1;string:Hello;nil:nil")
GlobalCheckBoolean_data = true
assert_equal(DogTag:Evaluate("[CheckAnyTuple(One, GlobalCheck, GlobalCheckBoolean)]"), "number:1;string:Hello;string:True")

assert_equal(DogTag:Evaluate("[Reverse('Hello')]"), "olleH")
assert_equal(DogTag:Evaluate("[Reverse('Hello'):Reverse]"), "Hello")
assert_equal(DogTag:Evaluate("[OtherReverse('Hello')]"), "olleH")
assert_equal(DogTag:Evaluate("[OtherReverse('Hello'):OtherReverse]"), "Hello")

old_DogTag_Evaluate(DogTag, "", nil, { left = 0, right = 0 })

assert_equal(DogTag:Evaluate("[Subtract]", nil, { left = 2, right = 1 }), 1)
assert_equal(DogTag:Evaluate("[Subtract]", nil, { left = 1, right = 2 }), -1)

old_DogTag_Evaluate(DogTag, "", nil, { number = 5 })

assert_equal(DogTag:Evaluate("[PlusOne]", nil, { number = 5 }), 6)
assert_equal(DogTag:Evaluate("[PlusOne]", nil, { number = 6 }), 7)
assert_equal(DogTag:Evaluate("[PlusOne]", nil, { number = 7 }), 8)

assert_equal(DogTag:Evaluate("[KwargAndTuple]"), [=[Arg #1 (value) req'd for KwargAndTuple]=])
assert_equal(DogTag:Evaluate("[KwargAndTuple(5, 1, 2, 3)]"), 30)
assert_equal(DogTag:Evaluate("[KwargAndTuple(0.5, 2, 3, 4)]"), 4.5)

assert_equal(DogTag:Evaluate("[TupleAndKwarg]"), [=[Keyword-Arg value req'd for TupleAndKwarg]=])
assert_equal(DogTag:Evaluate("[TupleAndKwarg(2, 3, 4, value=1/4)]"), 9/4)
assert_equal(DogTag:Evaluate("[TupleAndKwarg(2, 3, 4, value=0.5)]"), 9/2)

assert_equal(parse([=[['Alpha\'Bravo']]=]), {"'", "Alpha'Bravo"})
assert_equal(parse([=[["Alpha\"Bravo"]]=]), {'"', 'Alpha"Bravo'})
assert_equal(parse([=[['Alpha\'Bravo"Charlie']]=]), {"'", "Alpha'Bravo\"Charlie"})
assert_equal(parse([=[["Alpha\"Bravo'Charlie"]]=]), {'"', 'Alpha"Bravo\'Charlie'})
assert_equal(parse([=[["\1alpha"]]=]), {'"', '\001alpha' })
assert_equal(parse([=[["\12alpha"]]=]), {'"', '\012alpha' })
assert_equal(parse([=[["\123alpha"]]=]), {'"', '\123alpha' })
assert_equal(parse([=[["\124cffff0000"]]=]), {'"', '|cffff0000' })
assert_equal(parse([=[["\124\124cffff0000"]]=]), {'"', '||cffff0000' })
assert_equal(parse([=[["\123456"]]=]), {'"', '\123' .. '456' })

assert_equal(parse([=[[Func('Alpha\'Bravo')]]=]), { "tag", "Func", {"'", "Alpha'Bravo"} })
assert_equal(parse([=[[Func("Alpha\"Bravo")]]=]), { "tag", "Func", {'"', 'Alpha"Bravo'} })
assert_equal(parse([=[[Func('Alpha\'Bravo"Charlie')]]=]), { "tag", "Func", {"'", "Alpha'Bravo\"Charlie"} })
assert_equal(parse([=[[Func("Alpha\"Bravo'Charlie")]]=]), { "tag", "Func", {'"', 'Alpha"Bravo\'Charlie'} })
assert_equal(parse([=[[Func("\124cffff0000")]]=]), { "tag", "Func", {'"', '|cffff0000'} })
assert_equal(parse([=[[Func("\124\124cffff0000")]]=]), { "tag", "Func", {'"', '||cffff0000'} })
assert_equal(parse([=[[Func("\123456")]]=]), { "tag", "Func", {'"', '\123' .. '456'} })
assert_equal(parse([=[[Func("hey\nthere")]]=]), { "tag", "Func", {'"', 'hey\nthere' }})

assert_equal(DogTag:CleanCode([=[['Alpha\'Bravo']]=]), "Alpha'Bravo")
assert_equal(DogTag:CleanCode([=[["Alpha\"Bravo"]]=]), 'Alpha"Bravo')
assert_equal(DogTag:CleanCode([=[['Alpha\'Bravo"Charlie']]=]), "Alpha'Bravo\"Charlie")
assert_equal(DogTag:CleanCode([=[["Alpha\"Bravo'Charlie"]]=]), 'Alpha"Bravo\'Charlie')
assert_equal(DogTag:CleanCode([=[["\124cffff0000"]]=]), '|cffff0000')
assert_equal(DogTag:CleanCode([=[["\124\124cffff0000"]]=]), '||cffff0000')
assert_equal(DogTag:CleanCode([=[["\123456"]]=]), '\123' .. '456')
assert_equal(DogTag:CleanCode([=[["hey\nthere"]]=]), 'hey\nthere')

assert_equal(DogTag:CleanCode([=[[Func('Alpha\'Bravo')]]=]), [=[[Func("Alpha'Bravo")]]=])
assert_equal(DogTag:CleanCode([=[[Func("Alpha\"Bravo")]]=]), [=[[Func('Alpha"Bravo')]]=])
assert_equal(DogTag:CleanCode([=[[Func('Alpha\'Bravo"Charlie')]]=]), [=[[Func('Alpha\'Bravo"Charlie')]]=])
assert_equal(DogTag:CleanCode([=[[Func("Alpha\"Bravo'Charlie")]]=]), [=[[Func("Alpha\"Bravo'Charlie")]]=])
assert_equal(DogTag:CleanCode([=[[Func("\124cffff0000")]]=]), [=[[Func("\124cffff0000")]]=])
assert_equal(DogTag:CleanCode([=[[Func("\124\124cffff0000")]]=]), [=[[Func("||cffff0000")]]=])
assert_equal(DogTag:CleanCode([=[[Func('\124cffff0000')]]=]), [=[[Func('\124cffff0000')]]=])
assert_equal(DogTag:CleanCode([=[[Func('\124\124cffff0000')]]=]), [=[[Func('||cffff0000')]]=])
assert_equal(DogTag:CleanCode([=[[Func("\123456")]]=]), [=[[Func("{456")]]=])
assert_equal(DogTag:CleanCode([=[[Func('\123456')]]=]), [=[[Func('{456')]]=])
assert_equal(DogTag:CleanCode([=[[Func('hey\nthere')]]=]), [=[[Func('hey\nthere')]]=])

assert_equal(DogTag:CleanCode([=[[Alpha][Text]]=]), [=[[Alpha][Text]]=])
assert_equal(DogTag:CleanCode([=[[Outline][Text]]=]), [=[[Outline][Text]]=])
assert_equal(DogTag:CleanCode([=[[ThickOutline][Text]]=]), [=[[ThickOutline][Text]]=])
assert_equal(DogTag:CleanCode([=[[Alpha][Text][Text]]=]), [=[[Alpha][Text Text]]=])
assert_equal(DogTag:CleanCode([=[[Outline][Text][Text]]=]), [=[[Outline][Text Text]]=])
assert_equal(DogTag:CleanCode([=[[ThickOutline][Text][Text]]=]), [=[[ThickOutline][Text Text]]=])

assert_equal(DogTag:CleanCode([=[[One?Two!Three]]=]), [=[[One ? Two ! Three]]=])
assert_equal(DogTag:CleanCode([=[[One&Two&Three]]=]), [=[[One & Two & Three]]=])
assert_equal(DogTag:CleanCode([=[[One and Two and Three]]=]), [=[[One and Two and Three]]=])
assert_equal(DogTag:CleanCode([=[[One||Two||Three]]=]), [=[[One || Two || Three]]=])
assert_equal(DogTag:CleanCode([=[[One|Two|Three]]=]), [=[[One || Two || Three]]=])
assert_equal(DogTag:CleanCode([=[[One or Two or Three]]=]), [=[[One or Two or Three]]=])
assert_equal(DogTag:CleanCode([=[[One&Two||Three]]=]), [=[[(One & Two) || Three]]=])
assert_equal(DogTag:CleanCode([=[[One and Two or Three]]=]), [=[[(One and Two) or Three]]=])
assert_equal(DogTag:CleanCode([=[[One||Two&Three]]=]), [=[[(One || Two) & Three]]=])
assert_equal(DogTag:CleanCode([=[[One or Two and Three]]=]), [=[[(One or Two) and Three]]=])

assert_equal(DogTag:CleanCode([=[[One or Two and Three]]=]), [=[[(One or Two) and Three]]=])

assert_equal(DogTag:Evaluate("[Type(nil)]"), "nil")
assert_equal(DogTag:Evaluate("[Type('Hello')]"), "string")
assert_equal(DogTag:Evaluate("[Type(5)]"), "number")
assert_equal(DogTag:Evaluate("[Type(false)]"), "nil")
assert_equal(DogTag:Evaluate("[Type(true)]"), "string")
assert_equal(DogTag:Evaluate("[Type(nil nil)]"), "nil")
assert_equal(DogTag:Evaluate("[Type(5 10)]"), "number")
assert_equal(DogTag:Evaluate("[Type(5.5 10.5)]"), "string")

-- first argument is number, despite it returning a string, it should try to coerce to number
assert_equal(DogTag:Evaluate("[Type(5:Short)]"), "number")
assert_equal(DogTag:Evaluate("[Type(5:Concatenate(0))]"), "number")

GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[Type(GlobalCheck)]"), "nil")
GlobalCheck_data = "Hello"
assert_equal(DogTag:Evaluate("[Type(GlobalCheck)]"), "string")
GlobalCheck_data = 5
assert_equal(DogTag:Evaluate("[Type(GlobalCheck)]"), "number")

assert_equal(DogTag:Evaluate("[ToString(nil)]"), "``")
assert_equal(DogTag:Evaluate("[ToString('Hello')]"), "`Hello`")
assert_equal(DogTag:Evaluate("[ToString(5)]"), "`5`")
assert_equal(DogTag:Evaluate("[ToString(false)]"), "``")
assert_equal(DogTag:Evaluate("[ToString(true)]"), "`True`")

GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[ToString(GlobalCheck)]"), "``")
GlobalCheck_data = "Hello"
assert_equal(DogTag:Evaluate("[ToString(GlobalCheck)]"), "`Hello`")
GlobalCheck_data = 5
assert_equal(DogTag:Evaluate("[ToString(GlobalCheck)]"), "`5`")

assert_equal(DogTag:Evaluate("[RetSame(nil)]"), nil)
assert_equal(RetSame_types, "nil")
assert_equal(DogTag:Evaluate("[RetSame('Hello')]"), "Hello")
assert_equal(RetSame_types, "string")
assert_equal(DogTag:Evaluate("[RetSame(5)]"), 5)
assert_equal(RetSame_types, "number")
assert_equal(DogTag:Evaluate("[RetSame(false)]"), nil)
assert_equal(RetSame_types, "nil")
assert_equal(DogTag:Evaluate("[RetSame(true)]"), "True")
assert_equal(RetSame_types, "string")

GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[RetSame(GlobalCheck)]"), nil)
assert_equal(RetSame_types, "nil;number;string")
GlobalCheck_data = "Hello"
assert_equal(DogTag:Evaluate("[RetSame(GlobalCheck)]"), "Hello")
assert_equal(RetSame_types, "nil;number;string")
GlobalCheck_data = 5
assert_equal(DogTag:Evaluate("[RetSame(GlobalCheck)]"), 5)
assert_equal(RetSame_types, "nil;number;string")

assert_equal(DogTag:Evaluate("[RetSame(One)]"), 1)
assert_equal(RetSame_types, "number")
assert_equal(DogTag:Evaluate("[RetSame(CheckNilDefault(5))]"), 5)
assert_equal(RetSame_types, "nil;number")
assert_equal(DogTag:Evaluate("[RetSame(CheckNilDefault)]"), nil)
assert_equal(RetSame_types, "nil;number")

assert_equal(DogTag:Evaluate("[DynamicCodeTest(nil)]"), "literal, nil")
assert_equal(DogTag:Evaluate("[DynamicCodeTest(5)]"), "literal, 5")
assert_equal(DogTag:Evaluate("[DynamicCodeTest('Hello')]"), "literal, Hello")
assert_equal(DogTag:Evaluate("[DynamicCodeTest(false)]"), "literal, nil")
assert_equal(DogTag:Evaluate("[DynamicCodeTest(true)]"), "literal, True")
assert_equal(DogTag:Evaluate("[DynamicCodeTest(One)]"), "dynamic, One")
assert_equal(DogTag:Evaluate("[DynamicCodeTest(GlobalCheck)]"), "dynamic, GlobalCheck")
assert_equal(DogTag:Evaluate("[DynamicCodeTest(1 + One)]"), "dynamic, +")

local fired = false
local function func(code, nsList, kwargs)
	assert_equal(code, "[BlizzEventTest('player')]")
	assert_equal(kwargs, nil)
	fired = true
end
DogTag:AddCallback("[BlizzEventTest('player')]", func)
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
FireEvent("FAKE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, false)
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
FireEvent("FAKE_BLIZZARD_EVENT", 'player', 'focus')
assert_equal(fired, true)
fired = false
DogTag.clearCodes()
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
FireEvent("FAKE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, false)
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
DogTag:RemoveCallback("[BlizzEventTest('player')]", func)
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, false)

local fired = false
local function func(code, nsList, kwargs)
	assert_equal(code, "[BlizzEventTest]")
	assert_equal(kwargs, { value = "player" })
	fired = true
end
DogTag:AddCallback("[BlizzEventTest]", func, nil, { value = "player" })
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
FireEvent("FAKE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, false)
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
DogTag.clearCodes("Base")
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
FireEvent("FAKE_BLIZZARD_EVENT", 'player', 'focus')
assert_equal(fired, true)
fired = false
FireEvent("FAKE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, false)
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
DogTag:RemoveCallback("[BlizzEventTest]", func, nil, { value = "player" })
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, false)

local fired = false
local func; func = function(extra, code, nsList, kwargs)
	assert_equal(extra, "Hello")
	assert_equal(code, "[OtherBlizzEventTest]")
	assert_equal(kwargs, nil)
	fired = true
end
DogTag:AddCallback("[OtherBlizzEventTest]", func, nil, nil, "Hello")
FireEvent("OTHER_FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
FireEvent("OTHER_FAKE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, true)
fired = false
FireEvent("OTHER_FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
DogTag:RemoveCallback("[OtherBlizzEventTest]", func, nil, nil, "Hello")
FireEvent("OTHER_FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, false)

local fired = false
local function func(code, nsList, kwargs)
	assert_equal(code, "[BlizzEventTest(GlobalCheck)]")
	assert_equal(kwargs, nil)
	fired = true
end
DogTag:AddCallback("[BlizzEventTest(GlobalCheck)]", func)
GlobalCheck_data = 'player'
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
FireEvent("FAKE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, false)
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
GlobalCheck_data = 'pet'
FireEvent("FAKE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, true)
fired = false
FireEvent("FAKE_BLIZZARD_EVENT", 'player')
assert_equal(fired, false)
DogTag:RemoveCallback("[BlizzEventTest(GlobalCheck)]", func)
FireEvent("FAKE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, false)

local f = CreateFrame("Frame")
local fs = f:CreateFontString(nil, "ARTWORK")
assert_equal(fs:GetText(), nil)
DogTag:AddFontString(fs, f, "[One]")
assert_equal(fs:GetText(), 1)
DogTag:RemoveFontString(fs)
assert_equal(fs:GetText(), nil)

FireOnUpdate(1000)

OtherBlizzEventTest_num = 1
DogTag:AddFontString(fs, f, "[OtherBlizzEventTest]")
assert_equal(fs:GetText(), 2)
FireEvent("OTHER_FAKE_BLIZZARD_EVENT")
FireOnUpdate(0)
assert_equal(fs:GetText(), 2)
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 3)
FireOnUpdate(1000)
assert_equal(fs:GetText(), 3)
FireOnUpdate(1000)
FireEvent("OTHER_FAKE_BLIZZARD_EVENT")
FireOnUpdate(0.04)
assert_equal(fs:GetText(), 3)
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 4)
FireOnUpdate(0.01)
assert_equal(fs:GetText(), 4)
DogTag.clearCodes("Base")
FireOnUpdate(0)
assert_equal(fs:GetText(), 5)
FireEvent("OTHER_FAKE_BLIZZARD_EVENT")
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 6)
FireEvent("OTHER_FAKE_BLIZZARD_EVENT", 'player')
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 7)

BlizzEventTest_num = 1
GlobalCheck_data = 'player'
DogTag:AddFontString(fs, f, "[BlizzEventTest(GlobalCheck)]")
assert_equal(fs:GetText(), 2)
FireOnUpdate(1000)
assert_equal(fs:GetText(), 2)
FireEvent("OTHER_FAKE_BLIZZARD_EVENT")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 2)
FireEvent("FAKE_BLIZZARD_EVENT", "player")
assert_equal(fs:GetText(), 2)
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 3)
FireOnUpdate(1000)
assert_equal(fs:GetText(), 3)
FireEvent("FAKE_BLIZZARD_EVENT", "pet")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 3)
FireEvent("FAKE_BLIZZARD_EVENT", "player")
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 4)
GlobalCheck_data = 'pet'
FireEvent("FAKE_BLIZZARD_EVENT", "player")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 4)
FireEvent("FAKE_BLIZZARD_EVENT", "pet")
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 5)
GlobalCheck_data = 'player'
FireEvent("FAKE_BLIZZARD_EVENT", "player")
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 6)

BlizzEventTest_num = 1
DogTag:AddFontString(fs, f, "[BlizzEventTest]", nil, { value = 'player' })
assert_equal(fs:GetText(), 2)
FireOnUpdate(1000)
assert_equal(fs:GetText(), 2)
FireEvent("OTHER_FAKE_BLIZZARD_EVENT")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 2)
FireEvent("FAKE_BLIZZARD_EVENT", "player")
assert_equal(fs:GetText(), 2)
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 3)
FireOnUpdate(1000)
assert_equal(fs:GetText(), 3)
FireEvent("FAKE_BLIZZARD_EVENT", "pet")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 3)
FireEvent("FAKE_BLIZZARD_EVENT", "player")
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 4)
FireOnUpdate(1000)
assert_equal(fs:GetText(), 4)


local fired = false
local function func(code, nsList, kwargs)
	assert_equal(code, "[DoubleBlizzEventTest]")
	assert_equal(kwargs, { alpha = "player", bravo = "pet" })
	fired = true
end
DogTag:AddCallback("[DoubleBlizzEventTest]", func, nil, { alpha = "player", bravo = "pet" })
FireEvent("DOUBLE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
FireEvent("DOUBLE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, true)
fired = false
FireEvent("DOUBLE_BLIZZARD_EVENT", 'focus')
assert_equal(fired, false)
FireEvent("DOUBLE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
FireEvent("DOUBLE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, true)
fired = false
DogTag.clearCodes("Base")
FireEvent("DOUBLE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
FireEvent("DOUBLE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, true)
fired = false
FireEvent("DOUBLE_BLIZZARD_EVENT", 'focus')
assert_equal(fired, false)
FireEvent("DOUBLE_BLIZZARD_EVENT", 'player')
assert_equal(fired, true)
fired = false
FireEvent("DOUBLE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, true)
fired = false
DogTag:RemoveCallback("[DoubleBlizzEventTest]", func, nil, { alpha = "player", bravo = "pet" })
FireEvent("DOUBLE_BLIZZARD_EVENT", 'player')
assert_equal(fired, false)
FireEvent("DOUBLE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, false)

FireOnUpdate(1000)

DoubleBlizzEventTest_num = 0
DogTag:AddFontString(fs, f, "[DoubleBlizzEventTest]", nil, { alpha = "pet", bravo = "player" })
assert_equal(fs:GetText(), 1)
FireEvent("DOUBLE_BLIZZARD_EVENT", "player")
FireOnUpdate(0)
assert_equal(fs:GetText(), 1)
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 2)
FireOnUpdate(1000)
assert_equal(fs:GetText(), 2)
FireOnUpdate(1000)
FireEvent("DOUBLE_BLIZZARD_EVENT", "pet")
FireOnUpdate(0.04)
assert_equal(fs:GetText(), 2)
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 3)
FireOnUpdate(0.01)
assert_equal(fs:GetText(), 3)
FireEvent("DOUBLE_BLIZZARD_EVENT", "focus")
assert_equal(fs:GetText(), 3)
FireOnUpdate(1000)
assert_equal(fs:GetText(), 3)


local fired = false
local function func(code, nsList, kwargs)
	assert_equal(code, "[OtherDoubleBlizzEventTest]")
	assert_equal(kwargs, { alpha = "player", bravo = "pet" })
	fired = true
end
DogTag:AddCallback("[OtherDoubleBlizzEventTest]", func, nil, { alpha = "player", bravo = "pet" })
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'player')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'pet', 'pet')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'pet')
assert_equal(fired, true)
fired = false
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'pet', 'player')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'pet', 'player', 'something')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'pet', 'something')
assert_equal(fired, true)
fired = false
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'something', 'pet')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'something', 'player', 'pet')
assert_equal(fired, false)
DogTag:RemoveCallback("[OtherDoubleBlizzEventTest]", func, nil, { alpha = "player", bravo = "pet" })
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'pet')
assert_equal(fired, false)



local fired = false
local function func(code, nsList, kwargs)
	assert_equal(code, "[OtherDoubleBlizzEventTest(alpha='player', bravo='pet')]")
	assert_equal(kwargs, nil)
	fired = true
end
DogTag:AddCallback("[OtherDoubleBlizzEventTest(alpha='player', bravo='pet')]", func)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'player')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'pet', 'pet')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'pet')
assert_equal(fired, true)
fired = false
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'pet', 'player')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'pet', 'player', 'something')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'pet', 'something')
assert_equal(fired, true)
fired = false
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'something', 'pet')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'something', 'player', 'pet')
assert_equal(fired, false)
DogTag:RemoveCallback("[OtherDoubleBlizzEventTest(alpha='player', bravo='pet')]", func)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'pet')
assert_equal(fired, false)



local fired = false
local function func(code, nsList, kwargs)
	assert_equal(code, "[OtherDoubleBlizzEventTest(alpha='player', bravo='pet')] [OtherDoubleBlizzEventTest(alpha='focus', bravo='target')]")
	assert_equal(kwargs, nil)
	fired = true
end
DogTag:AddCallback("[OtherDoubleBlizzEventTest(alpha='player', bravo='pet')] [OtherDoubleBlizzEventTest(alpha='focus', bravo='target')]", func)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'pet')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'player')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'pet', 'pet')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'pet')
assert_equal(fired, true)
fired = false
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'pet', 'player')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'pet', 'player', 'something')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'pet', 'something')
assert_equal(fired, true)
fired = false
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'something', 'pet')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'something', 'player', 'pet')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'focus')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'target')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'focus', 'focus')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'target', 'target')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'focus', 'target')
assert_equal(fired, true)
fired = false
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'target', 'focus')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'target', 'focus', 'something')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'focus', 'target', 'something')
assert_equal(fired, true)
fired = false
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'focus', 'something', 'target')
assert_equal(fired, false)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'something', 'focus', 'target')
assert_equal(fired, false)
DogTag:RemoveCallback("[OtherDoubleBlizzEventTest(alpha='player', bravo='pet')] [OtherDoubleBlizzEventTest(alpha='focus', bravo='target')]", func)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", 'player', 'pet')
assert_equal(fired, false)



OtherDoubleBlizzEventTest_num = 0
DogTag:AddFontString(fs, f, "[OtherDoubleBlizzEventTest]", nil, { alpha = "pet", bravo = "player" })
assert_equal(fs:GetText(), 1)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", "player")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 1)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", "pet")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 1)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", "player", "pet")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 1)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", "pet", "player")
FireOnUpdate(0)
assert_equal(fs:GetText(), 1)
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 2)
FireOnUpdate(1000)
assert_equal(fs:GetText(), 2)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", "player", "pet")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 2)
FireEvent("OTHER_DOUBLE_BLIZZARD_EVENT", "pet", "player")
FireOnUpdate(0)
assert_equal(fs:GetText(), 2)
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 3)
FireOnUpdate(1000)
assert_equal(fs:GetText(), 3)

-- Test Math module
assert_equal(DogTag:Evaluate("[Round(0)]"), 0)
assert_equal(DogTag:Evaluate("[Round(0.5)]"), 0)
assert_equal(DogTag:Evaluate("[Round(0.500001)]"), 1)
assert_equal(DogTag:Evaluate("[Round(1)]"), 1)
assert_equal(DogTag:Evaluate("[Round(1.499999)]"), 1)
assert_equal(DogTag:Evaluate("[Round(1.5)]"), 2)

assert_equal(DogTag:Evaluate("[Floor(-0.0000000001)]"), -1)
assert_equal(DogTag:Evaluate("[Floor(0)]"), 0)
assert_equal(DogTag:Evaluate("[Floor(0.9999999999)]"), 0)
assert_equal(DogTag:Evaluate("[Floor(1)]"), 1)

assert_equal(DogTag:Evaluate("[Ceil(-0.9999999999)]"), 0)
assert_equal(DogTag:Evaluate("[Ceil(0)]"), 0)
assert_equal(DogTag:Evaluate("[Ceil(0.0000000001)]"), 1)
assert_equal(DogTag:Evaluate("[Ceil(1)]"), 1)

assert_equal(DogTag:Evaluate("[Abs(-5)]"), 5)
assert_equal(DogTag:Evaluate("[Abs(5)]"), 5)
assert_equal(DogTag:Evaluate("[Abs(0)]"), 0)

assert_equal(DogTag:Evaluate("[Sign(-5)]"), -1)
assert_equal(DogTag:Evaluate("[Sign(5)]"), 1)
assert_equal(DogTag:Evaluate("[Sign(0)]"), 0)

assert_equal(DogTag:Evaluate("[Max(1)]"), 1)
assert_equal(DogTag:Evaluate("[Max(1, 3, 4, 2)]"), 4)

assert_equal(DogTag:Evaluate("[Min(1)]"), 1)
assert_equal(DogTag:Evaluate("[Min(5, 3, 4, 2)]"), 2)

assert_equal(DogTag:Evaluate("[Pi]"), math.pi)

assert_equal(DogTag:Evaluate("[0:Deg]"), 0)
assert_equal(DogTag:Evaluate("[Deg(Pi/2)]"), 90)
assert_equal(DogTag:Evaluate("[Pi:Deg]"), 180)

assert_equal(DogTag:Evaluate("[0:Rad]"), 0)
assert_equal(DogTag:Evaluate("[90:Rad]"), math.pi/2)
assert_equal(DogTag:Evaluate("[180:Rad]"), math.pi)

assert_equal(DogTag:Evaluate("[0:Cos]"), 1)
assert_equal(DogTag:Evaluate("[(Pi/4):Cos]"), 0.5^0.5)
assert_equal(DogTag:Evaluate("[(Pi/2):Cos]"), 0)

assert_equal(DogTag:Evaluate("[0:Sin]"), 0)
assert_equal(DogTag:Evaluate("[(Pi/4):Sin]"), 0.5^0.5)
assert_equal(DogTag:Evaluate("[(Pi/2):Sin]"), 1)

assert_equal(DogTag:Evaluate("[E]"), math.exp(1))

assert_equal(DogTag:Evaluate("[1:Ln]"), 0)
assert_equal(DogTag:Evaluate("[E:Ln]"), 1)
assert_equal(DogTag:Evaluate("[[E^2]:Ln]"), 2)

assert_equal(DogTag:Evaluate("[1:Log]"), 0)
assert_equal(DogTag:Evaluate("[10:Log]"), 1)
assert_equal(DogTag:Evaluate("[100:Log]"), 2)

assert_equal(DogTag:Evaluate("[100:Percent]"), "100%")
assert_equal(DogTag:Evaluate("[50:Percent]"), "50%")
assert_equal(DogTag:Evaluate("[0:Percent]"), "0%")

assert_equal(DogTag:Evaluate("[100:Short]"), 100)
assert_equal(DogTag:Evaluate("[1000:Short]"), 1000)
assert_equal(DogTag:Evaluate("[10000:Short]"), '10.0k')
assert_equal(DogTag:Evaluate("[100000:Short]"), '100k')
assert_equal(DogTag:Evaluate("[1000000:Short]"), '1.00m')
assert_equal(DogTag:Evaluate("[10000000:Short]"), '10.0m')
assert_equal(DogTag:Evaluate("[100000000:Short]"), '100.0m')
assert_equal(DogTag:Evaluate("[-100:Short]"), -100)
assert_equal(DogTag:Evaluate("[-1000:Short]"), -1000)
assert_equal(DogTag:Evaluate("[-10000:Short]"), '-10.0k')
assert_equal(DogTag:Evaluate("[-100000:Short]"), '-100k')
assert_equal(DogTag:Evaluate("[-1000000:Short]"), '-1.00m')
assert_equal(DogTag:Evaluate("[-10000000:Short]"), '-10.0m')
assert_equal(DogTag:Evaluate("[-100000000:Short]"), '-100.0m')

assert_equal(DogTag:Evaluate("['100/1000':Short]"), '100/1000')
assert_equal(DogTag:Evaluate("['1000/10000':Short]"), '1000/10.0k')
assert_equal(DogTag:Evaluate("['10000/100000':Short]"), '10.0k/100k')
assert_equal(DogTag:Evaluate("['100000/1000000':Short]"), '100k/1.00m')
assert_equal(DogTag:Evaluate("['1000000/10000000':Short]"), '1.00m/10.0m')
assert_equal(DogTag:Evaluate("['10000000/100000000':Short]"), '10.0m/100.0m')

assert_equal(DogTag:Evaluate("[100:VeryShort]"), 100)
assert_equal(DogTag:Evaluate("[1000:VeryShort]"), '1k')
assert_equal(DogTag:Evaluate("[10000:VeryShort]"), '10k')
assert_equal(DogTag:Evaluate("[100000:VeryShort]"), '100k')
assert_equal(DogTag:Evaluate("[1000000:VeryShort]"), '1m')
assert_equal(DogTag:Evaluate("[10000000:VeryShort]"), '10m')
assert_equal(DogTag:Evaluate("[100000000:VeryShort]"), '100m')
assert_equal(DogTag:Evaluate("[-100:VeryShort]"), -100)
assert_equal(DogTag:Evaluate("[-1000:VeryShort]"), '-1k')
assert_equal(DogTag:Evaluate("[-10000:VeryShort]"), '-10k')
assert_equal(DogTag:Evaluate("[-100000:VeryShort]"), '-100k')
assert_equal(DogTag:Evaluate("[-1000000:VeryShort]"), '-1m')
assert_equal(DogTag:Evaluate("[-10000000:VeryShort]"), '-10m')
assert_equal(DogTag:Evaluate("[-100000000:VeryShort]"), '-100m')

assert_equal(DogTag:Evaluate("['100/1000':VeryShort]"), '100/1k')
assert_equal(DogTag:Evaluate("['1000/10000':VeryShort]"), '1k/10k')
assert_equal(DogTag:Evaluate("['10000/100000':VeryShort]"), '10k/100k')
assert_equal(DogTag:Evaluate("['100000/1000000':VeryShort]"), '100k/1m')
assert_equal(DogTag:Evaluate("['1000000/10000000':VeryShort]"), '1m/10m')
assert_equal(DogTag:Evaluate("['10000000/100000000':VeryShort]"), '10m/100m')

assert_equal(DogTag:Evaluate("['Hello':Upper]"), 'HELLO')
assert_equal(DogTag:Evaluate("['Hello':Lower]"), 'hello')

assert_equal(DogTag:Evaluate("['Hello':Bracket]"), '[Hello]')
assert_equal(DogTag:Evaluate("['Hello':Angle]"), '<Hello>')
assert_equal(DogTag:Evaluate("['Hello':Brace]"), '{Hello}')
assert_equal(DogTag:Evaluate("['Hello':Paren]"), '(Hello)')

assert_equal(DogTag:Evaluate("['Hello':Truncate(3)]"), 'Hel...')
assert_equal(DogTag:Evaluate("['Über':Truncate(3)]"), 'Übe...')
assert_equal(DogTag:Evaluate("['Hello':Truncate(4)]"), 'Hell...')
assert_equal(DogTag:Evaluate("['Hello':Truncate(4, true)]"), 'Hell...')
assert_equal(DogTag:Evaluate("['Hello':Truncate(4, ellipses=true)]"), 'Hell...')
assert_equal(DogTag:Evaluate("['Hello':Truncate(5)]"), 'Hello')
assert_equal(DogTag:Evaluate("['Hello':Truncate(3, ellipses=nil)]"), 'Hel')
assert_equal(DogTag:Evaluate("['Hello':Truncate(3, ellipses=false)]"), 'Hel')
assert_equal(DogTag:Evaluate("['Über':Truncate(3, nil)]"), 'Übe')
assert_equal(DogTag:Evaluate("['Hello':Truncate(4, nil)]"), 'Hell')
assert_equal(DogTag:Evaluate("['Hello':Truncate(5, ellipses=nil)]"), 'Hello')

assert_equal(DogTag:Evaluate("['Hello':Substring(3)]"), 'llo')
assert_equal(DogTag:Evaluate("['Über':Substring(3)]"), 'er')
assert_equal(DogTag:Evaluate("['Hello':Substring(2, 4)]"), 'ell')
assert_equal(DogTag:Evaluate("['Hello':Substring(2, 2)]"), 'e')
assert_equal(DogTag:Evaluate("['Über':Substring(2, 3)]"), 'be')
assert_equal(DogTag:Evaluate("['Über':Substring(3, 2)]"), nil)
assert_equal(DogTag:Evaluate("['Hello':Substring(-2)]"), 'lo')
assert_equal(DogTag:Evaluate("['Hello':Substring(-5)]"), 'Hello')
assert_equal(DogTag:Evaluate("['Hello':Substring(-10)]"), 'Hello')
assert_equal(DogTag:Evaluate("['Hello':Substring(-3, -2)]"), 'll')
assert_equal(DogTag:Evaluate("['Hello':Substring(2, -2)]"), 'ell')
assert_equal(DogTag:Evaluate("['Über':Substring(-2)]"), 'er')
assert_equal(DogTag:Evaluate("['Über':Substring(-4)]"), 'Über')
assert_equal(DogTag:Evaluate("['Über':Substring(-5)]"), 'Über')
assert_equal(DogTag:Evaluate("['Über':Substring(-3, -2)]"), 'be')
assert_equal(DogTag:Evaluate("['Über':Substring(2, -2)]"), 'be')

assert_equal(DogTag:Evaluate("['Hello':Repeat(0)]"), nil)
assert_equal(DogTag:Evaluate("['Hello':Repeat(1)]"), 'Hello')
assert_equal(DogTag:Evaluate("['Hello':Repeat(2)]"), 'HelloHello')
assert_equal(DogTag:Evaluate("['Hello':Repeat(2.5)]"), 'HelloHello')

assert_equal(DogTag:Evaluate("['Hello':Length]"), 5)
assert_equal(DogTag:Evaluate("['Über':Length]"), 4)

assert_equal(DogTag:Evaluate("[0:Romanize]"), "N")
assert_equal(DogTag:Evaluate("[1:Romanize]"), "I")
assert_equal(DogTag:Evaluate("[4:Romanize]"), "IV")
assert_equal(DogTag:Evaluate("[500:Romanize]"), "D")
assert_equal(DogTag:Evaluate("[1666:Romanize]"), "MDCLXVI")
assert_equal(DogTag:Evaluate("[1666666:Romanize]"), "(MDCLXV)MDCLXVI")
assert_equal(DogTag:Evaluate("[4999999:Romanize]"), "(MMMMCMXCIX)CMXCIX")
assert_equal(DogTag:Evaluate("[-1:Romanize]"), "-I")
assert_equal(DogTag:Evaluate("[-4:Romanize]"), "-IV")
assert_equal(DogTag:Evaluate("[-500:Romanize]"), "-D")
assert_equal(DogTag:Evaluate("[-1666:Romanize]"), "-MDCLXVI")
assert_equal(DogTag:Evaluate("[-1666666:Romanize]"), "-(MDCLXV)MDCLXVI")
assert_equal(DogTag:Evaluate("[-4999999:Romanize]"), "-(MMMMCMXCIX)CMXCIX")

assert_equal(DogTag:Evaluate("['%.3f':Format(1)]"), "1.000")
assert_equal(DogTag:Evaluate("['%03d':Format(1)]"), "001")
assert_equal(DogTag:Evaluate("['%.0f':Format(1.1234)]"), 1)
assert_equal(DogTag:Evaluate("['%s %s':Format('Hello', 'World')]"), "Hello World")
assert_equal(DogTag:Evaluate("['%d %d':Format('Hello', 'World')]"), "bad argument #2 to '?' (number expected, got string)")
assert_equal(DogTag:Evaluate("['%q %q':Format('Hello', 'World')]"), '"Hello" "World"')
assert_equal(DogTag:Evaluate("['%q %q %q':Format('Hello', 'World')]"), "bad argument #4 to '?' (string expected, got no value)")
assert_equal(DogTag:Evaluate("['%.1f':Format(CheckNilDefault(5))]"), "5.0")

assert_equal(DogTag:Evaluate("[0:FormatDuration('e')]"), "0 Sec")
assert_equal(DogTag:Evaluate("[0:FormatDuration('f')]"), "0s")
assert_equal(DogTag:Evaluate("[0:FormatDuration('s')]"), "0.0 Sec")
assert_equal(DogTag:Evaluate("[0:FormatDuration('c')]"), "0:00")
assert_equal(DogTag:Evaluate("[1:FormatDuration('e')]"), "1 Sec")
assert_equal(DogTag:Evaluate("[1:FormatDuration('f')]"), "1s")
assert_equal(DogTag:Evaluate("[1:FormatDuration('s')]"), "1.0 Sec")
assert_equal(DogTag:Evaluate("[1:FormatDuration('c')]"), '0:01')
assert_equal(DogTag:Evaluate("[10:FormatDuration('e')]"), "10 Sec")
assert_equal(DogTag:Evaluate("[10:FormatDuration('f')]"), "10s")
assert_equal(DogTag:Evaluate("[10:FormatDuration('s')]"), "10 Sec")
assert_equal(DogTag:Evaluate("[10:FormatDuration('c')]"), "0:10")
assert_equal(DogTag:Evaluate("[60:FormatDuration('e')]"), "1 Min")
assert_equal(DogTag:Evaluate("[60:FormatDuration('f')]"), "1m 00s")
assert_equal(DogTag:Evaluate("[60:FormatDuration('s')]"), "60 Sec")
assert_equal(DogTag:Evaluate("[60:FormatDuration('c')]"), "1:00")
assert_equal(DogTag:Evaluate("[100:FormatDuration('e')]"), "1 Min 40 Sec")
assert_equal(DogTag:Evaluate("[100:FormatDuration('f')]"), "1m 40s")
assert_equal(DogTag:Evaluate("[100:FormatDuration('s')]"), "100 Sec")
assert_equal(DogTag:Evaluate("[100:FormatDuration('c')]"), "1:40")
assert_equal(DogTag:Evaluate("[1000:FormatDuration('e')]"), "16 Min 40 Sec")
assert_equal(DogTag:Evaluate("[1000:FormatDuration('f')]"), "16m 40s")
assert_equal(DogTag:Evaluate("[1000:FormatDuration('s')]"), "16.7 Min")
assert_equal(DogTag:Evaluate("[1000:FormatDuration('c')]"), "16:40")
assert_equal(DogTag:Evaluate("[3600:FormatDuration('e')]"), "1 Hr")
assert_equal(DogTag:Evaluate("[3600:FormatDuration('f')]"), "1h 00m 00s")
assert_equal(DogTag:Evaluate("[3600:FormatDuration('s')]"), "60.0 Min")
assert_equal(DogTag:Evaluate("[3600:FormatDuration('c')]"), "1:00:00")
assert_equal(DogTag:Evaluate("[10000:FormatDuration('e')]"), "2 Hr 46 Min 40 Sec")
assert_equal(DogTag:Evaluate("[10000:FormatDuration('f')]"), "2h 46m 40s")
assert_equal(DogTag:Evaluate("[10000:FormatDuration('s')]"), "2.8 Hr")
assert_equal(DogTag:Evaluate("[10000:FormatDuration('c')]"), "2:46:40")
assert_equal(DogTag:Evaluate("[86400:FormatDuration('e')]"), "1 Days")
assert_equal(DogTag:Evaluate("[86400:FormatDuration('f')]"), "1d 00h 00m 00s")
assert_equal(DogTag:Evaluate("[86400:FormatDuration('s')]"), "24.0 Hr")
assert_equal(DogTag:Evaluate("[86400:FormatDuration('c')]"), "1d 0:00:00")
assert_equal(DogTag:Evaluate("[100000:FormatDuration('e')]"), "1 Days 3 Hr 46 Min 40 Sec")
assert_equal(DogTag:Evaluate("[100000:FormatDuration('f')]"), "1d 03h 46m 40s")
assert_equal(DogTag:Evaluate("[100000:FormatDuration('s')]"), "27.8 Hr")
assert_equal(DogTag:Evaluate("[100000:FormatDuration('c')]"), "1d 3:46:40")
assert_equal(DogTag:Evaluate("[1000000:FormatDuration('e')]"), "11 Days 13 Hr 46 Min 40 Sec")
assert_equal(DogTag:Evaluate("[1000000:FormatDuration('f')]"), "11d 13h 46m 40s")
assert_equal(DogTag:Evaluate("[1000000:FormatDuration('s')]"), "11.6 Days")
assert_equal(DogTag:Evaluate("[1000000:FormatDuration('c')]"), "11d 13:46:40")
assert_equal(DogTag:Evaluate("[100000000:FormatDuration('e')]"), "1157 Days 9 Hr 46 Min 40 Sec")
assert_equal(DogTag:Evaluate("[100000000:FormatDuration('f')]"), "1157d 09h 46m 40s")
assert_equal(DogTag:Evaluate("[100000000:FormatDuration('s')]"), "1157.4 Days")
assert_equal(DogTag:Evaluate("[100000000:FormatDuration('c')]"), "1157d 9:46:40")
assert_equal(DogTag:Evaluate("[100000000000:FormatDuration('e')]"), "1157407 Days 9 Hr 46 Min 40 Sec")
assert_equal(DogTag:Evaluate("[100000000000:FormatDuration('f')]"), "1157407d 09h 46m 40s")
assert_equal(DogTag:Evaluate("[100000000000:FormatDuration('s')]"), "1157407.4 Days")
assert_equal(DogTag:Evaluate("[100000000000:FormatDuration('c')]"), "1157407d 9:46:40")

assert_equal(DogTag:Evaluate("['Hello':Concatenate(' World')]"), "Hello World")
assert_equal(DogTag:Evaluate("['Hello':Concatenate(nil, ' World')]"), nil)
assert_equal(DogTag:Evaluate("[nil:Concatenate(' World')]"), nil)
GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[GlobalCheck:Concatenate(' World')]"), nil)
assert_equal(DogTag:Evaluate("[Concatenate(false, ' World')]"), nil)
assert_equal(DogTag:Evaluate("[Concatenate('Hello', nil)]"), nil)

assert_equal(DogTag:Evaluate("[Append('Hello', ' There')]"), "Hello There")
assert_equal(DogTag:Evaluate("[Prepend('There', 'Hello ')]"), "Hello There")
assert_equal(DogTag:Evaluate("[Append('Hello', nil)]"), "Hello")
assert_equal(DogTag:Evaluate("[Prepend('There', nil)]"), "There")

assert_equal(DogTag:Evaluate("[Replace('Hello', 'e', 'u')]"), "Hullo")
assert_equal(DogTag:Evaluate("[Replace('Hello', 'ell', '')]"), "Ho")
assert_equal(DogTag:Evaluate("[Replace('Hello', 'Hello', '')]"), nil)
assert_equal(DogTag:Evaluate("[Replace('Hello there, Hello', 'Hello', 'Stop')]"), "Stop there, Stop")

assert_equal(DogTag:Evaluate("[nil:Length]"), nil)
assert_equal(DogTag:Evaluate("[false:Length]"), nil)
assert_equal(DogTag:Evaluate("[GlobalCheck:Length]"), nil)
assert_equal(DogTag:Evaluate("[true:Length]"), 4)

assert_equal(DogTag:Evaluate("[nil:Short]"), nil)
assert_equal(DogTag:Evaluate("[false:Short]"), nil)
assert_equal(DogTag:Evaluate("[GlobalCheck:Short]"), nil)
assert_equal(DogTag:Evaluate("[nil:Color('ff7f7f')]"), nil)
assert_equal(DogTag:Evaluate("[false:Color('ff7f7f')]"), nil)

assert_equal(DogTag:Evaluate("[BooleanToString(nil)]"), "false")
assert_equal(DogTag:Evaluate("[BooleanToString(false)]"), "false")
assert_equal(DogTag:Evaluate("[BooleanToString(true)]"), "true")
assert_equal(DogTag:Evaluate("[BooleanToString('Hello')]"), "true")
assert_equal(DogTag:Evaluate("[BooleanToString(5)]"), "true")
GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[BooleanToString(GlobalCheck)]"), "false")
GlobalCheck_data = 'Hello'
assert_equal(DogTag:Evaluate("[BooleanToString(GlobalCheck)]"), "true")

GlobalCheckBoolean_data = true
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean]"), "True")
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean & 'Hello']"), "Hello")
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean ? 'Hello']"), "Hello")
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean | 'Hello']"), "True")
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean ? 'Hello' ! 'There']"), "Hello")
GlobalCheckBoolean_data = false
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean]"), nil)
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean & 'Hello']"), nil)
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean ? 'Hello']"), nil)
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean | 'Hello']"), "Hello")
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean ? 'Hello' ! 'There']"), "There")

GlobalCheckBoolean_data = true
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean:PlusOne]"), 2)
GlobalCheckBoolean_data = false
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean:PlusOne]"), nil)
GlobalCheckBoolean_data = true
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean:Concatenate('!')]"), "True!")
GlobalCheckBoolean_data = false
assert_equal(DogTag:Evaluate("[GlobalCheckBoolean:Concatenate('!')]"), nil)

IsAltKeyDown_data = nil
assert_equal(DogTag:Evaluate("[Alt]"), nil)
IsAltKeyDown_data = 1
assert_equal(DogTag:Evaluate("[Alt]"), "True")
IsAltKeyDown_data = nil

IsShiftKeyDown_data = nil
assert_equal(DogTag:Evaluate("[Shift]"), nil)
IsShiftKeyDown_data = 1
assert_equal(DogTag:Evaluate("[Shift]"), "True")
IsShiftKeyDown_data = nil

IsControlKeyDown_data = nil
assert_equal(DogTag:Evaluate("[Ctrl]"), nil)
IsControlKeyDown_data = 1
assert_equal(DogTag:Evaluate("[Ctrl]"), "True")
IsControlKeyDown_data = nil

BlizzEventTest_num = 0
DogTag:AddFontString(fs, f, "[Alt ? BlizzEventTest('never')]")
assert_equal(fs:GetText(), nil)
IsAltKeyDown_data = 1
FireEvent("MODIFIER_STATE_CHANGED", "LALT")
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 1)
FireOnUpdate(1000)
assert_equal(fs:GetText(), 1)
FireEvent("MODIFIER_STATE_CHANGED", "LSHIFT")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 1)
FireEvent("MODIFIER_STATE_CHANGED", "LCTRL")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 1)
IsAltKeyDown_data = nil
FireEvent("MODIFIER_STATE_CHANGED", "LALT")
FireOnUpdate(0.05)
assert_equal(fs:GetText(), nil)
IsAltKeyDown_data = 1
FireEvent("MODIFIER_STATE_CHANGED", "RALT")
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 2)
FireOnUpdate(1000)
assert_equal(fs:GetText(), 2)
FireEvent("MODIFIER_STATE_CHANGED", "RSHIFT")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 2)
FireEvent("MODIFIER_STATE_CHANGED", "RCTRL")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 2)

local now = GetTime()
FireOnUpdate(1)
assert_equal(DogTag:Evaluate("[CurrentTime]"), now+1)
FireOnUpdate(1)
assert_equal(DogTag:Evaluate("[CurrentTime]"), now+2)

assert_equal(DogTag:Evaluate("[Alpha(1)]"), nil)
assert_equal(select(2, DogTag:Evaluate("[Alpha(1)]")), 1)
assert_equal(select(2, DogTag:Evaluate("[Alpha(0)]")), 0)
assert_equal(select(2, DogTag:Evaluate("[Alpha(0.5)]")), 0.5)
assert_equal(select(2, DogTag:Evaluate("[Alpha(2)]")), 1)
assert_equal(select(2, DogTag:Evaluate("[Alpha(-1)]")), 0)
assert_equal(select(2, DogTag:Evaluate("[One]")), nil)

DogTag:AddFontString(fs, f, "[Alpha(0.5)]")
assert_equal(fs:GetText(), nil)
assert_equal(fs:GetAlpha(), 0.5)
DogTag:RemoveFontString(fs)
fs:SetAlpha(1)

assert_equal(DogTag:Evaluate("[Outline] Hello"), "Hello")
assert_equal(DogTag:Evaluate("[ThickOutline] Hello"), "Hello")
assert_equal(select(3, DogTag:Evaluate("[Outline] Hello")), 'OUTLINE')
assert_equal(select(3, DogTag:Evaluate("Hello")), nil)
assert_equal(select(3, DogTag:Evaluate("[ThickOutline] Hello")), 'OUTLINE, THICKOUTLINE')
assert_equal(select(3, DogTag:Evaluate("Hello")), nil)

assert_equal(DogTag:Evaluate("[Outline(1)]"), "Too many args for Outline")

DogTag:AddFontString(fs, f, "[Outline]")
assert_equal(fs:GetText(), nil)
assert_equal(fs:GetAlpha(), 1)
assert_equal(select(3, fs:GetFont()), "OUTLINE")
DogTag:RemoveFontString(fs)

DogTag:AddFontString(fs, f, "[ThickOutline]")
assert_equal(fs:GetText(), nil)
assert_equal(fs:GetAlpha(), 1)
assert_equal(select(3, fs:GetFont()), "OUTLINE, THICKOUTLINE")
DogTag:RemoveFontString(fs)

DogTag:AddFontString(fs, f, "[IsMouseOver]")
assert_equal(fs:GetText(), nil)
GetMouseFocus_data = f
assert_equal(fs:GetText(), nil)
FireOnUpdate(0)
assert_equal(fs:GetText(), "True")
FireOnUpdate(1000)
assert_equal(fs:GetText(), "True")
GetMouseFocus_data = nil
FireOnUpdate(0)
assert_equal(fs:GetText(), nil)
DogTag:RemoveFontString(fs)

assert_equal(select(3, fs:GetFont()), "")
assert_equal(fs:GetAlpha(), 1)

assert_equal(DogTag:Evaluate("['Hello':Color('ff0000')]"), "|cffff0000Hello|r")
assert_equal(DogTag:Evaluate("['There':Color('00ff00')]"), "|cff00ff00There|r")
assert_equal(DogTag:Evaluate("['Friend':Color(0, 0, 1)]"), "|cff0000ffFriend|r")
assert_equal(DogTag:Evaluate("['Broken':Color('00ff00a')]"), "|cffffffffBroken|r")
assert_equal(DogTag:Evaluate("['Large nums':Color(180, 255, -60)]"), "|cffffff00Large nums|r")

assert_equal(DogTag:Evaluate("[nil:Color('ff0000')]"), nil)
assert_equal(DogTag:Evaluate("[nil:Color(0, 0, 1)]"), nil)
assert_equal(DogTag:Evaluate("[false:Color(0, 0, 1)]"), nil)
assert_equal(DogTag:Evaluate("[true:Color(0, 0, 1)]"), "|cff0000ffTrue|r")

assert_equal(DogTag:Evaluate("[Color]"), "|r")
assert_equal(DogTag:Evaluate("[Color('ff0000')]"), "|cffff0000")
assert_equal(DogTag:Evaluate("[Color('00ff00')]"), "|cff00ff00")
assert_equal(DogTag:Evaluate("[Color(0, 0, 1)]"), "|cff0000ff")
assert_equal(DogTag:Evaluate("[Color(red=0, green=0, blue=1)]"), "|cff0000ff")
assert_equal(DogTag:Evaluate("[Color(nil, red=0, green=0, blue=1)]"), nil)
assert_equal(DogTag:Evaluate("[Color('00ff00a')]"), "|cffffffff")
assert_equal(DogTag:Evaluate("[Color(180, 255, -60)]"), "|cffffff00")

for name, color in pairs({
	White = "ffffff",
	Red = "ff0000",
	Green = "00ff00",
	Blue = "0000ff",
	Cyan = "00ffff",
	Fuchsia = "ff00ff",
	Yellow = "ffff00",
	Gray = "afafaf",
}) do
	assert_equal(DogTag:Evaluate("['Hello':" .. name .. "]"), "|cff" .. color .. "Hello|r")
	assert_equal(DogTag:Evaluate("[" .. name .. " 'Hello']"), "|cff" .. color .. "Hello")
	assert_equal(DogTag:Evaluate("[nil:" .. name .. "]"), nil)
	assert_equal(DogTag:Evaluate("[false:" .. name .. "]"), nil)
	assert_equal(DogTag:Evaluate("[true:" .. name .. "]"), "|cff" .. color .. "True|r")
end

assert_equal(DogTag:Evaluate("['Hello':Abbreviate]"), "Hello")
assert_equal(DogTag:Evaluate("['Hello World':Abbreviate]"), "HW")
assert_equal(DogTag:Evaluate("[nil:Abbreviate]"), nil)
assert_equal(DogTag:Evaluate("[false:Abbreviate]"), nil)
assert_equal(DogTag:Evaluate("[true:Abbreviate]"), "True")

assert_equal(DogTag:Evaluate("[SubtractFive(10)]"), 5)
assert_equal(DogTag:Evaluate("[SubtractFive(12)]"), 7)
assert_equal(DogTag:Evaluate("[SubtractFive(One)]"), -4)
assert_equal(DogTag:Evaluate("[SubtractFive]"), "Arg #1 (number) req'd for SubtractFive")
assert_equal(DogTag:Evaluate("[SubtractFive(number=10)]"), 5)
assert_equal(DogTag:Evaluate("[SubtractFive]", nil, { number = 10 }), 5)

assert_equal(DogTag:Evaluate("[SubtractFromFive(10)]"), -5)
assert_equal(DogTag:Evaluate("[SubtractFromFive(12)]"), -7)
assert_equal(DogTag:Evaluate("[SubtractFromFive(One)]"), 4)
assert_equal(DogTag:Evaluate("[SubtractFromFive]", nil, { number = 10 }), -5)

assert_equal(DogTag:Evaluate("[ReverseSubtract(4, 2)]"), -2)
assert_equal(DogTag:Evaluate("[ReverseSubtract(2, 4)]"), 2)
assert_equal(DogTag:Evaluate("[2:ReverseSubtract(4)]"), 2)
assert_equal(DogTag:Evaluate("[ReverseSubtract(1)]"), "Arg #2 (right) req'd for ReverseSubtract")
assert_equal(DogTag:Evaluate("[ReverseSubtract]"), "Arg #1 (left) req'd for ReverseSubtract")

assert_equal(DogTag:Evaluate("[AbsAlias(10)]"), 10)
assert_equal(DogTag:Evaluate("[AbsAlias(-10)]"), 10)

assert_equal(DogTag:Evaluate("[TupleAlias]"), 5)
assert_equal(DogTag:Evaluate("[TupleAlias(1)]"), "5-1")
assert_equal(DogTag:Evaluate("[TupleAlias(1, 2, 3)]"), "5-1-2-3")

assert_equal(DogTag:Evaluate("[OtherTupleAlias(5, 2)]"), 3)
assert_equal(DogTag:Evaluate("[OtherTupleAlias(2, 5)]"), -3)
assert_equal(DogTag:Evaluate("[OtherTupleAlias(5, 6, 7)]"), "Too many args for Subtract")
assert_equal(DogTag:Evaluate("[OtherTupleAlias(5)]"), "Arg #2 (right) req'd for Subtract")

assert_equal(DogTag:Evaluate("[5:IsIn]"), nil)
assert_equal(DogTag:Evaluate("[5:IsIn(6, 7, 8)]"), nil)
assert_equal(DogTag:Evaluate("[5:IsIn(1, 2, 3, 4, 5)]"), 5)

assert_equal(DogTag:Evaluate("[not One:RetNil]"), 1)

assert_equal(DogTag:Evaluate("[Boolean(nil)]"), nil)
assert_equal(DogTag:Evaluate("[Boolean(1)]"), "True")
assert_equal(DogTag:Evaluate("[Boolean(One)]"), "True")
assert_equal(DogTag:Evaluate("[Boolean('Hello')]"), "True")
GlobalCheck_data = 'Hello'
assert_equal(DogTag:Evaluate("[Boolean(GlobalCheck)]"), "True")
GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[Boolean(GlobalCheck)]"), nil)

assert_equal(DogTag:Evaluate("[One:Hide(6, 7, 8)]"), 1)
assert_equal(DogTag:Evaluate("[One:Hide(1, 6, 7, 8)]"), nil)
assert_equal(DogTag:Evaluate("[One:Hide(2):Hide(3)]"), 1)
assert_equal(DogTag:Evaluate("[One:Hide(2):Hide(3):Hide(1)]"), nil)

GlobalCheck_data = 1
assert_equal(DogTag:Evaluate("[GlobalCheck:Hide(6, 7, 8)]"), 1)
assert_equal(DogTag:Evaluate("[GlobalCheck:Hide(1, 6, 7, 8)]"), nil)
assert_equal(DogTag:Evaluate("[GlobalCheck:Hide(2):Hide(3)]"), 1)
assert_equal(DogTag:Evaluate("[GlobalCheck:Hide(2):Hide(1):Hide(3)]"), nil)
assert_equal(DogTag:Evaluate("[5:Hide(6, 7, 8)]"), 5)
assert_equal(DogTag:Evaluate("[5:Hide(1, 2, 3, 4, 5)]"), nil)

assert_equal(DogTag:Evaluate("[One:IsIn(nil)]"), nil)
assert_equal(DogTag:Evaluate("[One:IsIn(Unknown)]"), "Unknown tag Unknown")
assert_equal(DogTag:Evaluate("[not One:IsIn(nil)]"), 1)
assert_equal(DogTag:Evaluate("[not One:IsIn(Unknown)]"), "Unknown tag Unknown")
assert_equal(DogTag:Evaluate("[One:Hide(nil)]"), 1)
assert_equal(DogTag:Evaluate("[One:Hide(Unknown)]"), "Unknown tag Unknown")

assert_equal(DogTag:Evaluate("['Hello':Contains('There')]"), nil)
assert_equal(DogTag:Evaluate("['Hello':Contains('ello')]"), "Hello")
assert_equal(DogTag:Evaluate("['Hello':~Contains('There')]"), "Hello")
assert_equal(DogTag:Evaluate("['Hello':~Contains('ello')]"), nil)

GlobalCheck_data = "True"
assert_equal(DogTag:Evaluate("[GlobalCheck ? 'Hello' One ! 'There' Two]"), 'Hello1')
GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[GlobalCheck ? 'Hello' One ! 'There' Two]"), 'There2')
GlobalCheck_data = "True"
assert_equal(DogTag:Evaluate("[(GlobalCheck ? 'Hello' One ! 'There' Two) 'Buddy']"), 'Hello1Buddy')
GlobalCheck_data = nil
assert_equal(DogTag:Evaluate("[(GlobalCheck ? 'Hello' One ! 'There' Two) 'Buddy']"), 'There2Buddy')

assert_equal(DogTag:Evaluate("[FakeOne]"), 100)

DogTag:RemoveFontString(fs)

local function fix(ast)
	if type(ast) == "table" and ast[1] == "tag" then
	 	if ast[2] == "FakeOne" then
			ast[2] = "One"
		end
		assert(#ast == 2) -- don't show normal args, just kwargs
	end
	if type(ast) == "table" then
		for i = 2, #ast do
			fix(ast[i])
		end
		if ast.kwarg then
			for _,v in pairs(ast.kwarg) do
				fix(v)
			end
		end
	end
end
local function func(ast, kwargTypes)
	fix(ast)
	return ast
end
DogTag:AddCompilationStep("Base", "pre", func)
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("[FakeOne]"), 1)
DogTag:RemoveCompilationStep("Base", "pre", func)
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("[FakeOne]"), 100)
DogTag:AddCompilationStep("Base", "pre", func)
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("[FakeOne]"), 1)
DogTag:RemoveAllCompilationSteps("Base", "pre")
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("[FakeOne]"), 100)
DogTag:AddCompilationStep("Base", "pre", func)
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("[FakeOne]"), 1)
DogTag:RemoveAllCompilationSteps("Base")
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("[FakeOne]"), 100)
DogTag:AddCompilationStep("Base", "pre", func)
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("[PlusOne(number=FakeOne)]"), 2)
assert_equal(DogTag:Evaluate("[PlusOne(FakeOne)]"), 2)
DogTag:RemoveAllCompilationSteps("Base")
FireOnUpdate(0)

local function func(t, ast, kwargTypes, extraKwargs)
	t[#t+1] = [=[result = '`' .. tostring(result) .. '`']=]
end
DogTag:AddCompilationStep("Base", "finish", func)
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("Hello"), '`Hello`')
DogTag:RemoveCompilationStep("Base", "finish", func)
FireOnUpdate(0)

local function func(t, ast, kwargTypes, extraKwargs)
	t[#t+1] = [=[result = '`' .. tostring(result) .. '`']=]
end
assert_equal(DogTag:Evaluate("Hello"), 'Hello')
DogTag:AddCompilationStep("Base", "finish", func)
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("Hello"), '`Hello`')
DogTag:RemoveCompilationStep("Base", "finish", func)
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("Hello"), 'Hello')

local function func(t, ast, kwargTypes, extraKwargs)
	t[#t+1] = [=[do assert(result == nil) return 'omgpants' end;]=]
end
assert_equal(DogTag:Evaluate("Hello"), 'Hello')
DogTag:AddCompilationStep("Base", "start", func)
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("Hello"), 'omgpants')
DogTag:RemoveCompilationStep("Base", "start", func)
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("Hello"), 'Hello')

local function func(ast, t, tag, tagData, kwargs, extraKwargs, compiledKwargs)
	if kwargs.number then
		t[#t+1] = [=[if ]=]
		t[#t+1] = compiledKwargs.number[1]
		t[#t+1] = [=[ < 10 then return ("Bad number: %d"):format(]=]
		t[#t+1] = compiledKwargs.number[1]
		t[#t+1] = [=[), nil;end;]=]
	end
end
assert_equal(DogTag:Evaluate("[PlusOne(One)]"), 2)
DogTag:AddCompilationStep("Base", "tag", func)
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("[PlusOne(One)]"), "Bad number: 1")
assert_equal(DogTag:Evaluate("[PlusOne(1)]"), "Bad number: 1")
assert_equal(DogTag:Evaluate("[PlusOne(10)]"), 11)
assert_equal(DogTag:Evaluate("[PlusOne(One * 10)]"), 11)
assert_equal(DogTag:Evaluate("[PlusOne(4 * 2)]"), "Bad number: 8")
DogTag:RemoveCompilationStep("Base", "tag", func)
FireOnUpdate(0)
assert_equal(DogTag:Evaluate("[PlusOne(One)]"), 2)

local function func(ast, t, u, tag, tagData, kwargs, extraKwargs, compiledKwargs, events, returns)
	if kwargs.number then
		events["SOME_EVENT"] = true
	end
end

DogTag:AddCompilationStep("Base", "tagevents", func)
FireOnUpdate(0)
BlizzEventTest_num = 0
DogTag:AddFontString(fs, f, "[BlizzEventTest('never')]")
assert_equal(fs:GetText(), 1)
FireEvent("SOME_EVENT")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 1)
DogTag:AddFontString(fs, f, "[BlizzEventTest('never') + PlusOne(-1)]")
assert_equal(fs:GetText(), 2)
FireEvent("SOME_EVENT")
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 3)
DogTag:RemoveCompilationStep("Base", "tagevents", func)
FireOnUpdate(0)
assert_equal(fs:GetText(), 4)
FireEvent("SOME_EVENT")
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 4)

local function func(ast, t, u, tag, tagData, kwargs, extraKwargs, compiledKwargs, events, returns)
	events["FastUpdate"] = true
end
DogTag:AddCompilationStep("Base", "tagevents", func)
BlizzEventTest_num = 0
DogTag:AddFontString(fs, f, "[BlizzEventTest('never')]")
assert_equal(fs:GetText(), 1)
for i = 2, 100 do
	FireOnUpdate(0.05)
	assert_equal(fs:GetText(), i)
end
DogTag:RemoveCompilationStep("Base", "tagevents", func)

--FireOnUpdate(0.05)

local function func(ast, t, u, tag, tagData, kwargs, extraKwargs, compiledKwargs, events, returns)
	events["Update"] = true
end
DogTag:AddCompilationStep("Base", "tagevents", func)
BlizzEventTest_num = 0
DogTag:RemoveFontString(fs)
DogTag:AddFontString(fs, f, "[BlizzEventTest('never')]")
assert_equal(fs:GetText(), 1)
for i = 2, 100 do
	for j = 1, 3 do
		FireOnUpdate(0.05)
		local x = fs:GetText()
		if x ~= i and x ~= i-1 then
			error(("Bad value %d %d %d"):format(i, j, x))
		end
	end
end
DogTag:RemoveCompilationStep("Base", "tagevents", func)

local function func(ast, t, u, tag, tagData, kwargs, extraKwargs, compiledKwargs, events, returns)
	events["SlowUpdate"] = true
end
DogTag:AddCompilationStep("Base", "tagevents", func)
FireOnUpdate(0)
BlizzEventTest_num = 0
DogTag:RemoveFontString(fs)
DogTag:AddFontString(fs, f, "[BlizzEventTest('never')]")
assert_equal(fs:GetText(), 1)
for i = 2, 100 do
	for j = 1, 200 do
		FireOnUpdate(0.05)
		local x = fs:GetText()
		if x ~= i and x ~= i-1 then
			error(("Bad value %d %d %d"):format(i, j, x))
		end
	end
end
DogTag:RemoveCompilationStep("Base", "tagevents", func)

local fired = false
DogTag:AddAddonFinder("Base", "_G", "MyAddonToBeFound", function(MyAddonToBeFound)
	assert_equal(MyAddonToBeFound, _G.MyAddonToBeFound)
	fired = true
end)
assert_equal(fired, false)
FireEvent("ADDON_LOADED")
assert_equal(fired, false)
_G.MyAddonToBeFound = {}
FireEvent("ADDON_LOADED")
assert_equal(fired, true)

local fired = false
DogTag:AddAddonFinder("Base", "LibStub", "MyLibToBeFound", function(MyLibToBeFound)
	assert_equal(MyLibToBeFound, LibStub("MyLibToBeFound"))
	fired = true
end)
assert_equal(fired, false)
FireEvent("ADDON_LOADED")
assert_equal(fired, false)
LibStub:NewLibrary("MyLibToBeFound", 1)
FireEvent("ADDON_LOADED")
assert_equal(fired, true)

DogTag:AddFontString(fs, f, "[ExtraFunctionalityWithLib]")
assert_equal(fs:GetText(), nil)
assert_equal(DogTag:Evaluate("[ExtraFunctionalityWithLib]"), nil)
LibStub:NewLibrary("LibToProvideExtraFunctionality", 1)
FireEvent("ADDON_LOADED")
FireOnUpdate(0)
assert_equal(fs:GetText(), "True")
assert_equal(DogTag:Evaluate("[ExtraFunctionalityWithLib]"), "True")

local fired = false
local expectedArg = nil
local expectedNumArgs = 0
local function func(event, ...)
	assert_equal(event, "MY_EVENT")
	assert_equal(..., expectedArg)
	assert_equal(select('#', ...), expectedNumArgs)

	fired = true
end
DogTag:AddEventHandler("Base", "MY_EVENT", func)
FireEvent("MY_EVENT")
assert_equal(fired, true)
fired = false
expectedArg = 'alpha'
expectedNumArgs = 2
FireEvent("MY_EVENT", 'alpha', 'bravo')
assert_equal(fired, true)
fired = false
expectedArg = nil
expectedNumArgs = 0
DogTag:FireEvent("MY_EVENT")
assert_equal(fired, true)
fired = false
expectedArg = 'alpha'
expectedNumArgs = 2
DogTag:FireEvent("MY_EVENT", 'alpha', 'bravo')
assert_equal(fired, true)
fired = false
DogTag:RemoveEventHandler("Base", "MY_EVENT", func)
FireEvent("MY_EVENT")
FireEvent("MY_EVENT", 'alpha', 'bravo')
DogTag:FireEvent("MY_EVENT")
DogTag:FireEvent("MY_EVENT", 'alpha', 'bravo')
assert_equal(fired, false)

assert_equal(DogTag:Evaluate("[Thingy('hey')]"), "hey")
assert_equal(DogTag:Evaluate("[Thingy]", nil, { value = 'hey' }), "hey")
assert_equal(DogTag:Evaluate("[AliasOfThingy('hey')]"), "hey")
assert_equal(DogTag:Evaluate("[AliasOfThingy]", nil, { myvalue = 'hey' }), "hey")
assert_equal(DogTag:Evaluate("[OtherAliasOfThingy('hey')]"), "heyhey")
assert_equal(DogTag:Evaluate("[OtherAliasOfThingy]", nil, { myvalue = 'hey' }), "heyhey")

GlobalCheck_data = 1
DogTag:AddFontString(fs, f, "[Thingy('hey')] [GlobalCheck]")
assert_equal(fs:GetText(), 'hey 1')
GlobalCheck_data = 2
FireEvent("THINGY_EVENT", "Something")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 'hey 1')
FireEvent("THINGY_EVENT", "hey")
FireOnUpdate(0)
assert_equal(fs:GetText(), 'hey 1')
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 'hey 2')

GlobalCheck_data = 1
DogTag:AddFontString(fs, f, "[AliasOfThingy('hey')] [GlobalCheck]")
assert_equal(fs:GetText(), 'hey 1')
GlobalCheck_data = 2
FireEvent("THINGY_EVENT", "Something")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 'hey 1')
FireEvent("THINGY_EVENT", "hey")
FireOnUpdate(0)
assert_equal(fs:GetText(), 'hey 1')
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 'hey 2')

GlobalCheck_data = 1
DogTag:AddFontString(fs, f, "[OtherAliasOfThingy('hey')] [GlobalCheck]")
assert_equal(fs:GetText(), 'heyhey 1')
GlobalCheck_data = 2
FireEvent("THINGY_EVENT", "Something")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 'heyhey 1')
FireEvent("THINGY_EVENT", "heyhey")
FireOnUpdate(0)
assert_equal(fs:GetText(), 'heyhey 1')
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 'heyhey 2')

GlobalCheck_data = 1
DogTag:AddFontString(fs, f, "[Thingy] [GlobalCheck]", nil, { value = 'hey' })
assert_equal(fs:GetText(), 'hey 1')
GlobalCheck_data = 2
FireEvent("THINGY_EVENT", "Something")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 'hey 1')
FireEvent("THINGY_EVENT", "hey")
FireOnUpdate(0)
assert_equal(fs:GetText(), 'hey 1')
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 'hey 2')

GlobalCheck_data = 1
DogTag:AddFontString(fs, f, "[AliasOfThingy] [GlobalCheck]", nil, { myvalue = 'hey' })
assert_equal(fs:GetText(), 'hey 1')
GlobalCheck_data = 2
FireEvent("THINGY_EVENT", "Something")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 'hey 1')
FireEvent("THINGY_EVENT", "hey")
FireOnUpdate(0)
assert_equal(fs:GetText(), 'hey 1')
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 'hey 2')

GlobalCheck_data = 1
DogTag:AddFontString(fs, f, "[OtherAliasOfThingy] [GlobalCheck]", nil, { myvalue = 'hey' })
assert_equal(fs:GetText(), 'heyhey 1')
GlobalCheck_data = 2
FireEvent("THINGY_EVENT", "Something")
FireOnUpdate(1000)
assert_equal(fs:GetText(), 'heyhey 1')
FireEvent("THINGY_EVENT", "heyhey")
FireOnUpdate(0)
assert_equal(fs:GetText(), 'heyhey 1')
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 'heyhey 2')

assert_equal(DogTag:Evaluate("[(Two One) ? One]"), 1)
assert_equal(DogTag:Evaluate("[Two (One ? One)]"), 21)

assert_equal(DogTag:Evaluate("[One:Color(\"95e495\")]"), "|cff95e4951|r")
assert_equal(DogTag:Evaluate("[One:Color(\"999999\")]"), "|cff9999991|r")

assert_equal(DogTag:Evaluate("[OtherRetSame('good') ? 'hi'] ['test']"), "hi test")
assert_equal(DogTag:Evaluate("[OtherRetSame(nil) ? 'hi'] ['test']"), "test")
assert_equal(DogTag:Evaluate("[OtherRetSame('good') or nil] ['test']"), "good test")
assert_equal(DogTag:Evaluate("[OtherRetSame(nil) or 'hi'] ['test']"), "hi test")
assert_equal(DogTag:Evaluate("[OtherRetSame('good') and 'hi'] ['test']"), "hi test")
assert_equal(DogTag:Evaluate("[OtherRetSame(nil) and 'hi'] ['test']"), "test")

assert_equal(parse("[Red][Name] [Realm]"), { "concat", { "tag", "Red" }, { "tag", "Name", }, " ", { "tag", "Realm" } })
assert_equal(DogTag:CleanCode("[Red][Name] [Realm]"), "[Red Name] [Realm]")

local finalMemory = collectgarbage('count')
local finalTime = os.clock()
collectgarbage('collect')
local finalMemoryAfterCollect = collectgarbage('count')
print("Memory:", finalMemory*1024)
print("Memory after collect:", finalMemoryAfterCollect*1024)
print("Time:", finalTime)

print("LibDogTag-3.0: Tests succeeded")

if DogTag_Test_SecondTime then
	return
end

_G.MyAddonToBeFound = nil
LibStub.libs.MyLibToBeFound = nil
LibStub.minors.MyLibToBeFound = nil
LibStub.libs.LibToProvideExtraFunctionality = nil
LibStub.minors.LibToProvideExtraFunctionality = nil
DogTag_Test_SecondTime = true
LibStub.minors["LibDogTag-3.0"] = 1 -- reset version

local SpecialTag_data = nil
DogTag:AddTag("Special", "SpecialTag", {
	code = function()
		return SpecialTag_data
	end,
	ret = 'string;number;nil',
})

local SpecialEventTag_num = 0
DogTag:AddTag("Special", "SpecialEventTag", {
	code = function()
		SpecialEventTag_num = SpecialEventTag_num + 1
		return SpecialEventTag_num
	end,
	ret = 'number',
	events = "SPECIAL_EVENT"
})

DogTag:AddTag("Base", "ChangingTag", {
	code = function()
		return "Hello"
	end,
	ret = 'string',
})

SpecialAddonFinder_fired = false
DogTag:AddAddonFinder("Special", "_G", "SpecialGlobal", function()
	assert_equal(SpecialAddonFinder_fired, false)
	SpecialAddonFinder_fired = true
end)

SpecialTag_data = nil
assert_equal(DogTag:Evaluate("[SpecialTag]", "Special"), nil)
SpecialTag_data = 'hey'
assert_equal(DogTag:Evaluate("[SpecialTag]", "Special"), 'hey')
SpecialTag_data = 52
assert_equal(DogTag:Evaluate("[SpecialTag]", "Special"), 52)

assert_equal(DogTag:Evaluate("[ChangingTag]"), "Hello")

DogTag:AddFontString(fs, f, "[SpecialEventTag]", "Special")
assert_equal(fs:GetText(), 1)
FireEvent("SPECIAL_EVENT")
assert_equal(fs:GetText(), 1)
FireOnUpdate(0.05)
assert_equal(fs:GetText(), 2)

local SpecialEventTag_Callback_fired = false
DogTag:AddCallback("[SpecialEventTag]", function(code, kwargs)
	assert_equal(code, "[SpecialEventTag]")
	assert_equal(kwargs, nil)
	SpecialEventTag_Callback_fired = true
end, "Special")

FireEvent("SPECIAL_EVENT")
assert_equal(SpecialEventTag_Callback_fired, true)

local SPECIAL_EVENT_CHECK_fired = false
DogTag:AddEventHandler("Base", "SPECIAL_EVENT_CHECK", function(event, ...)
	assert_equal(SPECIAL_EVENT_CHECK_fired, false)
	SPECIAL_EVENT_CHECK_fired = true
	assert(event == "SPECIAL_EVENT_CHECK")
	assert((...) == "Good")
end)

FireEvent("SPECIAL_EVENT_CHECK", "Good")
assert_equal(SPECIAL_EVENT_CHECK_fired, true)
SPECIAL_EVENT_CHECK_fired = false

local SPECIAL_TIMER_fired = false
DogTag:AddTimerHandler("Base", function(currentTime, num)
	SPECIAL_TIMER_fired = true
end)

FireOnUpdate(0.05)
assert_equal(SPECIAL_TIMER_fired, true)
SPECIAL_TIMER_fired = false

dofile('test.lua')

DogTag:AddTag("Base", "ChangingTag", {
	code = function()
		return "There"
	end,
	ret = 'string',
})

SpecialTag_data = nil
assert_equal(DogTag:Evaluate("[SpecialTag]", "Special"), nil)
SpecialTag_data = 'hey'
assert_equal(DogTag:Evaluate("[SpecialTag]", "Special"), 'hey')
SpecialTag_data = 52
assert_equal(DogTag:Evaluate("[SpecialTag]", "Special"), 52)

assert_equal(DogTag:Evaluate("[ChangingTag]"), "There")

FireEvent("ADDON_LOADED")
assert_equal(SpecialAddonFinder_fired, false)
_G.SpecialGlobal = {}
FireEvent("ADDON_LOADED")
assert_equal(SpecialAddonFinder_fired, true)

local num = fs:GetText()
assert_equal(fs:GetText(), num)
FireEvent("SPECIAL_EVENT")
assert_equal(fs:GetText(), num)
FireOnUpdate(0.05)
assert_equal(fs:GetText(), num+1)

FireEvent("SPECIAL_EVENT_CHECK", "Good")
assert_equal(SPECIAL_EVENT_CHECK_fired, true)
SPECIAL_EVENT_CHECK_fired = false

SPECIAL_TIMER_fired = false
FireOnUpdate(0.05)
assert_equal(SPECIAL_TIMER_fired, true)
SPECIAL_TIMER_fired = false

SpecialEventTag_Callback_fired = false
FireEvent("SPECIAL_EVENT")
assert_equal(SpecialEventTag_Callback_fired, true)

DogTag:ClearNamespace("Special")
FireOnUpdate(0)

SpecialEventTag_Callback_fired = false
FireEvent("SPECIAL_EVENT")
assert_equal(SpecialEventTag_Callback_fired, false)

SpecialTag_data = nil
assert_equal(DogTag:Evaluate("[SpecialTag]", "Special"), "Unknown tag SpecialTag")