448 lines
18 KiB
Lua
448 lines
18 KiB
Lua
local ftext = require("MDK.ftext")
|
|
|
|
describe("ftext:", function()
|
|
describe("ftext.fText:", function()
|
|
local fText = ftext.fText
|
|
|
|
it("Should properly center text", function()
|
|
local expected = " some text "
|
|
local actual = fText("some text", {width = 20})
|
|
assert.equals(expected, actual)
|
|
assert.equals(20, actual:len())
|
|
end)
|
|
|
|
it("Should properly pad left aligned text", function()
|
|
local expected = "some text "
|
|
local actual = fText("some text", {width = 20, alignment = "left"})
|
|
assert.equals(expected, actual)
|
|
assert.equals(20, actual:len())
|
|
end)
|
|
|
|
it("Should properly pad right aligned text", function()
|
|
local expected = " some text"
|
|
local actual = fText("some text", {width = 20, alignment = "right"})
|
|
assert.equals(expected, actual)
|
|
assert.equals(20, actual:len())
|
|
end)
|
|
|
|
it("Should wrap lines to the correct length", function()
|
|
local str = "This is a test of the emergency broadcast system. This is only a test"
|
|
local options = {width = 10, alignment = "centered"}
|
|
local actual = fText(str, options)
|
|
for _, line in ipairs(actual:split("\n")) do
|
|
assert.equals(line:len(), 10)
|
|
end
|
|
options.width = 15
|
|
actual = fText(str, options)
|
|
for _, line in ipairs(actual:split("\n")) do
|
|
assert.equals(line:len(), 15)
|
|
end
|
|
end)
|
|
|
|
describe("non-space spacer character:", function()
|
|
local str = "some text"
|
|
local options = {width = "20", alignment = "left", spacer = "="}
|
|
it("Should work with left align", function()
|
|
local expected = "some text =========="
|
|
local actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
assert.equals(20, actual:len())
|
|
end)
|
|
|
|
it("Should work with right align", function()
|
|
local expected = "========== some text"
|
|
options.alignment = "right"
|
|
local actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
assert.equals(20, actual:len())
|
|
end)
|
|
|
|
it("Should work with center align", function()
|
|
local expected = ("==== some text =====")
|
|
options.alignment = "center"
|
|
local actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
assert.equals(20, actual:len())
|
|
end)
|
|
end)
|
|
|
|
describe("nogap option:", function()
|
|
local str = "some text"
|
|
local options = {width = "20", alignment = "left", spacer = "=", nogap = true}
|
|
|
|
it("Should work with left align", function()
|
|
local expected = "some text==========="
|
|
local actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
assert.equals(20, actual:len())
|
|
end)
|
|
|
|
it("Should work with right align", function()
|
|
local expected = "===========some text"
|
|
options.alignment = "right"
|
|
local actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
assert.equals(20, actual:len())
|
|
end)
|
|
|
|
it("Should work with center align", function()
|
|
local expected = "=====some text======"
|
|
options.alignment = "center"
|
|
local actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
assert.equals(20, actual:len())
|
|
end)
|
|
end)
|
|
|
|
describe("cap functionality", function()
|
|
local str = "some text"
|
|
local options = {width = 20, spacer = "=", cap = "|"}
|
|
|
|
it("Should place the spacer outside the cap by default", function()
|
|
local expected = "===| some text |===="
|
|
local actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
assert.equals(20, actual:len())
|
|
end)
|
|
|
|
it("Should place it inside the cap if inside option is true", function()
|
|
local expected = "|=== some text ====|"
|
|
options.inside = true
|
|
local actual = fText(str, options)
|
|
options.inside = nil
|
|
assert.equals(expected, actual)
|
|
assert.equals(20, actual:len())
|
|
end)
|
|
|
|
it("Should mirror certain characters with their opposites", function()
|
|
local expected = "===[ some text ]===="
|
|
options.mirror = true
|
|
options.cap = "["
|
|
local actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
options.inside = true
|
|
expected = "[=== some text ====]"
|
|
actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
options.inside = nil
|
|
options.cap = "<"
|
|
expected = "===< some text >===="
|
|
actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
options.cap = "{"
|
|
expected = "==={ some text }===="
|
|
actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
options.cap = "("
|
|
expected = "===( some text )===="
|
|
actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
options.cap = "|"
|
|
expected = "===| some text |===="
|
|
actual = fText(str, options)
|
|
assert.equals(expected, actual)
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe("ftext.cfText", function()
|
|
local cfText = ftext.cfText
|
|
local str = "some text"
|
|
local options = {
|
|
width = 20,
|
|
spacer = "=",
|
|
cap = "[",
|
|
inside = true,
|
|
mirror = true,
|
|
capColor = "<purple>",
|
|
spacerColor = "<green>",
|
|
textColor = "<red>",
|
|
}
|
|
it("Should handle cecho colored text", function()
|
|
local expectedStripped = "[=== some text ====]"
|
|
local expected = "<purple>[<reset><green>===<reset><red> some text <reset><green>====<reset><purple>]<reset>"
|
|
local actual = cfText(str, options)
|
|
local actualStripped = cecho2string(actual)
|
|
assert.equals(expected, actual)
|
|
assert.equals(expectedStripped, actualStripped)
|
|
assert.equals(20, actualStripped:len())
|
|
expectedStripped = "===[ some text ]===="
|
|
expected = "<green>===<reset><purple>[<reset><red> some text <reset><purple>]<reset><green>====<reset>"
|
|
options.inside = false
|
|
actual = cfText(str, options)
|
|
actualStripped = cecho2string(actual)
|
|
assert.equals(expected, actual)
|
|
assert.equals(expectedStripped, actualStripped)
|
|
assert.equals(20, actualStripped:len())
|
|
end)
|
|
|
|
it("Should wrap cecho lines to the correct length", function()
|
|
local str = "This is a test of the emergency broadcast system. This is only a test"
|
|
local options = {width = 10, alignment = "centered"}
|
|
local actual = cfText(str, options)
|
|
for _, line in ipairs(actual:split("\n")) do
|
|
assert.equals(cecho2string(line):len(), 10)
|
|
end
|
|
options.width = 15
|
|
actual = cfText(str, options)
|
|
for _, line in ipairs(actual:split("\n")) do
|
|
assert.equals(cecho2string(line):len(), 15)
|
|
end
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("ftext.dfText", function()
|
|
local dfText = ftext.dfText
|
|
local str = "some text"
|
|
local options = {
|
|
width = 20,
|
|
spacer = "=",
|
|
cap = "[",
|
|
inside = true,
|
|
mirror = true,
|
|
capColor = "<160,32,240>",
|
|
spacerColor = "<0,255,0>",
|
|
textColor = "<255,0,0>",
|
|
}
|
|
it("Should handle decho colored text", function()
|
|
local expectedStripped = "[=== some text ====]"
|
|
local expected = "<160,32,240>[<r><0,255,0>===<r><255,0,0> some text <r><0,255,0>====<r><160,32,240>]<r>"
|
|
local actual = dfText(str, options)
|
|
local actualStripped = decho2string(actual)
|
|
assert.equals(expected, actual)
|
|
assert.equals(expectedStripped, actualStripped)
|
|
assert.equals(20, actualStripped:len())
|
|
expectedStripped = "===[ some text ]===="
|
|
expected = "<0,255,0>===<r><160,32,240>[<r><255,0,0> some text <r><160,32,240>]<r><0,255,0>====<r>"
|
|
options.inside = false
|
|
actual = dfText(str, options)
|
|
actualStripped = decho2string(actual)
|
|
assert.equals(expected, actual)
|
|
assert.equals(expectedStripped, actualStripped)
|
|
assert.equals(20, actualStripped:len())
|
|
end)
|
|
|
|
it("Should wrap decho lines to the correct length", function()
|
|
local str = "This is a test of the emergency broadcast system. This is only a test"
|
|
local options = {width = 10, alignment = "centered"}
|
|
local actual = dfText(str, options)
|
|
for _, line in ipairs(actual:split("\n")) do
|
|
assert.equals(decho2string(line):len(), 10)
|
|
end
|
|
options.width = 15
|
|
actual = dfText(str, options)
|
|
for _, line in ipairs(actual:split("\n")) do
|
|
assert.equals(decho2string(line):len(), 15)
|
|
end
|
|
end)
|
|
end)
|
|
|
|
describe("ftext.hfText", function()
|
|
local hfText = ftext.hfText
|
|
local str = "some text"
|
|
local options = {
|
|
width = 20,
|
|
spacer = "=",
|
|
cap = "[",
|
|
inside = true,
|
|
mirror = true,
|
|
capColor = "#a020f0",
|
|
spacerColor = "#00ff00",
|
|
textColor = "#ff0000",
|
|
}
|
|
it("Should handle hecho colored text", function()
|
|
local expectedStripped = "[=== some text ====]"
|
|
local expected = "#a020f0[#r#00ff00===#r#ff0000 some text #r#00ff00====#r#a020f0]#r"
|
|
local actual = hfText(str, options)
|
|
local actualStripped = hecho2string(actual)
|
|
assert.equals(expected, actual)
|
|
assert.equals(expectedStripped, actualStripped)
|
|
assert.equals(20, actualStripped:len())
|
|
expectedStripped = "===[ some text ]===="
|
|
expected = "#00ff00===#r#a020f0[#r#ff0000 some text #r#a020f0]#r#00ff00====#r"
|
|
options.inside = false
|
|
actual = hfText(str, options)
|
|
actualStripped = hecho2string(actual)
|
|
assert.equals(expected, actual)
|
|
assert.equals(expectedStripped, actualStripped)
|
|
assert.equals(20, actualStripped:len())
|
|
end)
|
|
|
|
it("Should wrap hecho lines to the correct length", function()
|
|
local str = "This is a test of the emergency broadcast system. This is only a test"
|
|
local options = {width = 10, alignment = "centered"}
|
|
local actual = hfText(str, options)
|
|
for _, line in ipairs(actual:split("\n")) do
|
|
assert.equals(hecho2string(line):len(), 10)
|
|
end
|
|
options.width = 15
|
|
actual = hfText(str, options)
|
|
for _, line in ipairs(actual:split("\n")) do
|
|
assert.equals(hecho2string(line):len(), 15)
|
|
end
|
|
end)
|
|
end)
|
|
|
|
describe("ftext.TextFormatter", function()
|
|
local tf = ftext.TextFormatter
|
|
local str = "some text"
|
|
local formatter
|
|
|
|
before_each(function()
|
|
formatter = tf:new({width = 20})
|
|
end)
|
|
|
|
it("Should let you change width using :setWidth", function()
|
|
formatter:setWidth(80)
|
|
local expected =
|
|
"<white><reset><white> <reset><white> some text <reset><white> <reset><white><reset>"
|
|
local actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
assert.equals(80, cecho2string(actual):len())
|
|
end)
|
|
|
|
it("Should format for cecho by default", function()
|
|
local expected = "<white><reset><white> <reset><white> some text <reset><white> <reset><white><reset>"
|
|
local expectedStripped = " some text "
|
|
local actual = formatter:format(str)
|
|
local actualStripped = cecho2string(actual)
|
|
assert.equals(expected, actual)
|
|
assert.equals(expectedStripped, actualStripped)
|
|
assert.equals(20, actualStripped:len())
|
|
end)
|
|
|
|
it("Should produce the same line as cfText given the same options", function()
|
|
local expected = ftext.cfText(str, formatter.options)
|
|
local actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
end)
|
|
|
|
it("Should let you change type using :setType", function()
|
|
formatter:setType("h")
|
|
local expected = ftext.hfText(str, formatter.options)
|
|
local actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
formatter:setType("d")
|
|
expected = ftext.dfText(str, formatter.options)
|
|
actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
formatter:setType("")
|
|
expected = ftext.fText(str, formatter.options)
|
|
actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
end)
|
|
|
|
it("Should default to word wrapping, and let you change it with :setWrap", function()
|
|
formatter:setWidth(10)
|
|
local expected =
|
|
"<white><reset><white> <reset><white> some <reset><white> <reset><white><reset>\n<white><reset><white> <reset><white> text <reset><white> <reset><white><reset>"
|
|
local actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
expected = "<white><reset><white><reset><white> some text <reset><white><reset><white><reset>"
|
|
formatter:setWrap(false)
|
|
actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
end)
|
|
|
|
it("Should allow you to change the cap using :setCap", function()
|
|
formatter:setCap('|')
|
|
local expected = "<white>|<reset><white> <reset><white> some text <reset><white> <reset><white>|<reset>"
|
|
local actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
end)
|
|
|
|
it("Should allow you to change the capColor using :setCapColor", function()
|
|
formatter:setCapColor('<red>')
|
|
local expected = "<red><reset><white> <reset><white> some text <reset><white> <reset><red><reset>"
|
|
local actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
end)
|
|
|
|
it("Should allow you to change the spacer color using :setSpacerColor", function()
|
|
formatter:setSpacerColor("<red>")
|
|
local expected = "<white><reset><red> <reset><white> some text <reset><red> <reset><white><reset>"
|
|
local actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
end)
|
|
|
|
it("Should allow you to change the text color using :setTextColor", function()
|
|
formatter:setTextColor("<red>")
|
|
local expected = "<white><reset><white> <reset><red> some text <reset><white> <reset><white><reset>"
|
|
local actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
end)
|
|
|
|
it("Should allow you to change the spacer using :setSpacer", function()
|
|
formatter:setSpacer("=")
|
|
-- local expected = "<white><reset><white> <reset><white> some text <reset><white> <reset><white><reset>"
|
|
local expected = "<white><reset><white>====<reset><white> some text <reset><white>=====<reset><white><reset>"
|
|
local actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
end)
|
|
|
|
it("Should allow you to set the alignment using :setAlignment", function()
|
|
formatter:setAlignment("left")
|
|
local expected = "<white><reset><white><reset><white>some text <reset><white> <reset><white><reset>"
|
|
local actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
formatter:setAlignment("right")
|
|
expected = "<white><reset><white> <reset><white> some text<reset><white><reset><white><reset>"
|
|
actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
end)
|
|
|
|
it("Should allow you to change the 'inside' option using :setInside", function()
|
|
formatter:setInside(false)
|
|
local expected = "<white> <reset><white><reset><white> some text <reset><white><reset><white> <reset>"
|
|
local actual = formatter:format(str)
|
|
assert.equals(expected, actual)
|
|
end)
|
|
|
|
it("Should allow you to change the mirror option using :setMirror", function()
|
|
formatter:setCap('<')
|
|
formatter:setMirror(true)
|
|
local expected = "<white><<reset><white> <reset><white> some text <reset><white> <reset><white>><reset>"
|
|
local actual = formatter:format(str)
|
|
assert.equal(expected, actual)
|
|
end)
|
|
end)
|
|
|
|
describe("ftext.TableMaker", function()
|
|
local TableMaker = ftext.TableMaker
|
|
local tm
|
|
before_each(function()
|
|
tm = TableMaker:new()
|
|
tm:addColumn({name = "col1", width = 15, textColor = "<red>"})
|
|
tm:addColumn({name = "col2", width = 15, textColor = "<blue>"})
|
|
tm:addColumn({name = "col3", width = 15, textColor = "<green>"})
|
|
tm:addRow({"some text", "more text", "other text"})
|
|
tm:addRow({"little text", "bigger text", "text"})
|
|
end)
|
|
|
|
it("Should assemble a formatted table given default options", function()
|
|
local expected = [[<white>*************************************************<reset>
|
|
<white>*<reset><white><reset><white> <reset><red> col1 <reset><white> <reset><white><reset><white>|<reset><white><reset><white> <reset><blue> col2 <reset><white> <reset><white><reset><white>|<reset><white><reset><white> <reset><green> col3 <reset><white> <reset><white><reset><white>*<reset>
|
|
<white>*<reset><white>---------------<reset><white>|<reset><white>---------------<reset><white>|<reset><white>---------------<reset><white>*<reset>
|
|
<white>*<reset><white><reset><white> <reset><red> some text <reset><white> <reset><white><reset><white>|<reset><white><reset><white> <reset><blue> more text <reset><white> <reset><white><reset><white>|<reset><white><reset><white> <reset><green> other text <reset><white> <reset><white><reset><white>*<reset>
|
|
<white>*<reset><white>---------------<reset><white>|<reset><white>---------------<reset><white>|<reset><white>---------------<reset><white>*<reset>
|
|
<white>*<reset><white><reset><white> <reset><red> little text <reset><white> <reset><white><reset><white>|<reset><white><reset><white> <reset><blue> bigger text <reset><white> <reset><white><reset><white>|<reset><white><reset><white> <reset><green> text <reset><white> <reset><white><reset><white>*<reset>
|
|
<white>*************************************************<reset>
|
|
]]
|
|
local actual = tm:assemble()
|
|
assert.equals(expected, actual)
|
|
end)
|
|
|
|
it("TableMaker:getCell should return the text and formatter for a specific cell", function()
|
|
local expectedText = "more text"
|
|
local expectedFormatter = tm.columns[2]
|
|
local actualText, actualFormatter = tm:getCell(1, 2)
|
|
assert.equals(expectedText, actualText)
|
|
assert.equals(expectedFormatter, actualFormatter)
|
|
local expectedFormatted = "<white><reset><white> <reset><blue> more text <reset><white> <reset><white><reset>"
|
|
local actualFormatted = actualFormatter:format(actualText)
|
|
assert.equals(expectedFormatted, actualFormatted)
|
|
end)
|
|
end)
|
|
end)
|