207 lines
11 KiB
Lua
207 lines
11 KiB
Lua
-- Kør: luajit tests/test_adStorageStats.lua (fra repo-roden)
|
|
-- Lagerstatistik pr. vare: fyldning, værdi nu / ved toppris, gårdens samlede beholdning, dage tilbage.
|
|
|
|
dofile("FS25_ADSmartPickup/adStorageStats.lua")
|
|
local S = ADStorageStats
|
|
|
|
local failures = 0
|
|
local function check(name, actual, expected)
|
|
if actual == expected then print("OK " .. name) else failures = failures + 1; print(string.format("FAIL %s: forventede %s, fik %s", name, tostring(expected), tostring(actual))) end
|
|
end
|
|
|
|
-- ST1: fuld beregning
|
|
local st = S.itemStats({fillType = 5, level = 150000, capacity = 180000}, 412000, {consumption = 130000, production = 48000}, {price = 1.6, top = 2.0})
|
|
check("ST1 procent", st.percent, 83)
|
|
check("ST1 værdi nu", st.valueNow, 240000)
|
|
check("ST1 værdi top", st.valueTop, 300000)
|
|
check("ST1 gårdens beholdning", st.farmTotal, 412000)
|
|
check("ST1 dage på netto (412k / 82k)", math.floor(st.days * 10 + 0.5) / 10, 5.0)
|
|
check("ST1 netto pr. døgn", st.net, -82000)
|
|
|
|
-- ST2: ingen salgssted, intet forbrug, ingen kapacitet
|
|
local st2 = S.itemStats({fillType = 6, level = 5000, capacity = 0}, 5000, nil, nil)
|
|
check("ST2 ingen pris -> nil", st2.valueNow, nil)
|
|
check("ST2 intet forbrug -> dage nil", st2.days, nil)
|
|
check("ST2 kapacitet 0 -> procent nil", st2.percent, nil)
|
|
|
|
-- ST3: bygningens samlede værdi (kun varer med pris)
|
|
local total = S.buildingTotals({st, st2, S.itemStats({fillType = 7, level = 1000, capacity = 2000}, 1000, nil, {price = 2, top = 3})})
|
|
check("ST3 samlet nu", total.valueNow, 242000)
|
|
check("ST3 samlet top", total.valueTop, 303000)
|
|
|
|
-- ST4: gårdens totaler fra inventar
|
|
local totals = S.farmTotals({{entries = {{fillType = 5, level = 100}, {fillType = 6, level = 5}}}, {entries = {{fillType = 5, level = 50}}}})
|
|
check("ST4 sum pr. vare", totals[5], 150)
|
|
check("ST4 anden vare", totals[6], 5)
|
|
|
|
-- ST5: foder-forbrug i et fælles trug fordeles efter truget indhold; tomt trug -> bedste foder
|
|
local split = S.splitTroughConsumption(2400, {[116] = 3000, [7] = 1000}, {[116] = 1.0, [7] = 0.8})
|
|
check("ST5 TMR 75 %", split[116], 1800)
|
|
check("ST5 ensilage 25 %", split[7], 600)
|
|
local empty = S.splitTroughConsumption(2400, {}, {[116] = 1.0, [7] = 0.8})
|
|
check("ST5 tomt trug -> bedste foder", empty[116], 2400)
|
|
check("ST5 tomt trug -> intet på ensilage", empty[7], nil)
|
|
|
|
-- ST6: gitter — varer i rækker á n celler, tom liste giver én tom række
|
|
local rows = S.chunk({"a", "b", "c", "d"}, 3)
|
|
check("ST6 to rækker", #rows, 2)
|
|
check("ST6 første række 3", #rows[1], 3)
|
|
check("ST6 anden række 1", rows[2][1], "d")
|
|
check("ST6 tom liste -> én tom række", #S.chunk({}, 3), 1)
|
|
|
|
-- ST7: rate-kolonne: forbrug med minus, produktion med plus, intet -> streg
|
|
local fmt = function(v) return string.format("%.1fk", v / 1000) end
|
|
check("ST7 begge", S.rateText(14400, 3600, fmt), "-14.4k +3.6k")
|
|
check("ST7 kun prod", S.rateText(0, 3600, fmt), "+3.6k")
|
|
check("ST7 kun forbrug", S.rateText(2000, 0, fmt), "-2.0k")
|
|
check("ST7 intet", S.rateText(0, 0, fmt), "-")
|
|
|
|
-- ST8: fane pr. bygningstype — filtrér inventar på kind, rækkefølgen bevares
|
|
local inv = {{kind = "silo", name = "A"}, {kind = "factory", name = "B"}, {kind = "silo", name = "C"}}
|
|
local silos = S.filterKind(inv, "silo")
|
|
check("ST8 to siloer", #silos, 2)
|
|
check("ST8 rækkefølge", silos[2].name, "C")
|
|
check("ST8 ingen stalde", #S.filterKind(inv, "husbandry"), 0)
|
|
|
|
-- ST9: produktion ≥ forbrug -> beholdningen stiger, ingen dage
|
|
local rising = S.itemStats({fillType = 8, level = 1000, capacity = 2000}, 6700000, {consumption = 11500000, production = 19200000}, nil)
|
|
check("ST9 stiger -> dage nil", rising.days, nil)
|
|
check("ST9 stiger-flag", rising.rising, true)
|
|
check("ST1 falder -> ikke stiger", st.rising, false)
|
|
check("ST2 intet forbrug -> ikke stiger", st2.rising, false)
|
|
|
|
-- ST3: palleskur — procent af PLADSER (24 paller af 4000), ikke liter mod pladsantal (600 %)
|
|
local egg = S.itemStats({fillType = 8, level = 24000, capacity = 4000000, count = 24, slots = 4000}, 24000, nil, nil)
|
|
check("ST3 paller med", egg.count, 24)
|
|
check("ST3 pladser med", egg.slots, 4000)
|
|
check("ST3 procent af pladser", egg.percent, 1)
|
|
|
|
|
|
-- ---- v1.52 vareoversigt ----
|
|
|
|
-- SV1: gruppér fanens bygninger pr. vare; bygninger sorteret mest først, varer efter titel
|
|
local titles = {[31] = "Straw", [5] = "Sugarbeet", [9] = "Milk"}
|
|
local titleOf = function(ft) return titles[ft] end
|
|
local siloInv = {
|
|
{name = "Farma #1", placeable = "p1", entries = {{fillType = 31, level = 300, capacity = 1000}, {fillType = 5, level = 50, capacity = 100}}},
|
|
{name = "Farma #2", placeable = "p2", entries = {{fillType = 31, level = 700, capacity = 1000}}},
|
|
{name = "Tom", placeable = "p3", entries = {}},
|
|
}
|
|
local groups = S.groupByFillType(siloInv, titleOf)
|
|
check("SV1 to varer", #groups, 2)
|
|
check("SV1 alfabetisk: Straw først", groups[1].title, "Straw")
|
|
check("SV1 straw total", groups[1].level, 1000)
|
|
check("SV1 straw kapacitet", groups[1].capacity, 2000)
|
|
check("SV1 straw procent", groups[1].percent, 50)
|
|
check("SV1 to siloer med straw", #groups[1].buildings, 2)
|
|
check("SV1 flest først", groups[1].buildings[1].name, "Farma #2")
|
|
check("SV1 bygning procent", groups[1].buildings[1].percent, 70)
|
|
check("SV1 placeable med", groups[1].buildings[2].placeable, "p1")
|
|
check("SV1 tomt inventar", #S.groupByFillType({}, titleOf), 0)
|
|
|
|
-- SV2: gårdens kapacitet pr. vare
|
|
local caps = S.farmCapacities(siloInv)
|
|
check("SV2 kapacitet straw", caps[31], 2000)
|
|
|
|
-- SV3: varens statistik: døgn til tom på gårdens netto, pris i % af top
|
|
local straw = S.groupStats(groups[1], {level = 1500, capacity = 3000}, {consumption = 1000, production = 0}, {price = 0.5, top = 1.0})
|
|
check("SV3 døgn til tom", straw.days, 1.5)
|
|
check("SV3 døgn til fuld nil (falder)", straw.daysToFull, nil)
|
|
check("SV3 værdi nu", straw.valueNow, 500)
|
|
check("SV3 pris % af top", straw.priceRatio, 0.5)
|
|
check("SV3 tomt-niveau gul (< 3 døgn)", straw.emptyLevel, "yellow")
|
|
check("SV3 samlet niveau", straw.severity, "yellow")
|
|
|
|
-- SV4: produceret vare -> døgn til fuld på gårdens ledige kapacitet
|
|
local sugar = S.groupStats({fillType = 5, title = "Sugar", level = 950, capacity = 1000, percent = 95, buildings = {}},
|
|
{level = 950, capacity = 1000}, {consumption = 0, production = 100}, nil)
|
|
check("SV4 døgn til fuld", sugar.daysToFull, 0.5)
|
|
check("SV4 producerer", sugar.producing, true)
|
|
check("SV4 fuld-niveau rød (95 %)", sugar.fullLevel, "red")
|
|
check("SV4 ingen pris -> nil", sugar.valueNow, nil)
|
|
|
|
-- SV5: fuld lagervare der ikke produceres er ikke et problem
|
|
local stock = S.groupStats({fillType = 31, title = "Straw", level = 990, capacity = 1000, percent = 99, buildings = {}}, nil, nil, nil)
|
|
check("SV5 fuld lager uden produktion -> intet", stock.fullLevel, nil)
|
|
check("SV5 severity nil", stock.severity, nil)
|
|
|
|
-- SV6: tærskler
|
|
check("SV6 < 1 døgn rød", S.emptyLevel(0.5), "red")
|
|
check("SV6 < 3 døgn gul", S.emptyLevel(2.9), "yellow")
|
|
check("SV6 5 døgn intet", S.emptyLevel(5), nil)
|
|
check("SV6 nil intet", S.emptyLevel(nil), nil)
|
|
check("SV6 fuld 85 % gul", S.fullLevel(85, true), "yellow")
|
|
check("SV6 fuld 84 % intet", S.fullLevel(84, true), nil)
|
|
|
|
-- SV7: bygningsniveau: stald-foder næsten tomt, fabrik-output næsten fuldt
|
|
check("SV7 stald 8 % rød", S.buildingLevel({percent = 8}, "husbandry", false), "red")
|
|
check("SV7 stald 20 % gul", S.buildingLevel({percent = 20}, "husbandry", false), "yellow")
|
|
check("SV7 stald-output (mælk) 8 % intet", S.buildingLevel({percent = 8}, "husbandry", true), nil)
|
|
check("SV7 output 96 % rød", S.buildingLevel({percent = 96, isOutput = true}, "factory", false), "red")
|
|
check("SV7 silo 50 % intet", S.buildingLevel({percent = 50}, "silo", false), nil)
|
|
|
|
-- SV8: kræver handling — rød tom > rød fuld > gul tom > gul fuld > sælg (efter kroner); højst max
|
|
local mk = function(t) t.buildings = {}; return t end
|
|
local list = S.attentionList({
|
|
mk({title = "A", emptyLevel = "yellow", days = 2, consumption = 1}),
|
|
mk({title = "B", fullLevel = "red", percent = 97, producing = true}),
|
|
mk({title = "C", emptyLevel = "red", days = 0.4, consumption = 1}),
|
|
mk({title = "D", priceRatio = 0.95, valueNow = 50000, net = 0}),
|
|
mk({title = "E", priceRatio = 0.97, valueNow = 900000, net = 0}),
|
|
mk({title = "F", priceRatio = 0.99, valueNow = 900000, net = -5}), -- gården æder den: sælg ikke
|
|
mk({title = "G", priceRatio = 0.99, valueNow = 5000, net = 0}), -- for lille
|
|
}, 4)
|
|
check("SV8 højst 4", #list, 4)
|
|
check("SV8 1: rød tom", list[1].stat.title, "C")
|
|
check("SV8 1: art", list[1].kind, "empty")
|
|
check("SV8 2: rød fuld", list[2].stat.title, "B")
|
|
check("SV8 3: gul tom", list[3].stat.title, "A")
|
|
check("SV8 4: største salg", list[4].stat.title, "E")
|
|
check("SV8 4: art", list[4].kind, "sell")
|
|
|
|
-- SV9: nøgletal for fanen
|
|
local kpi = S.kpis({
|
|
mk({valueNow = 100, valueTop = 150, emptyLevel = "red"}),
|
|
mk({valueNow = 50, valueTop = 50, fullLevel = "yellow"}),
|
|
mk({}),
|
|
})
|
|
check("SV9 værdi nu", kpi.valueNow, 150)
|
|
check("SV9 ekstra ved top", kpi.gain, 50)
|
|
check("SV9 løber tør", kpi.emptyCount, 1)
|
|
check("SV9 fyldt", kpi.fullCount, 1)
|
|
|
|
-- SV10: fyldningsbrøk til bjælker, klemt til [0,1]
|
|
check("SV10 halv", S.fraction(50), 0.5)
|
|
check("SV10 over 100", S.fraction(130), 1)
|
|
check("SV10 nil", S.fraction(nil), 0)
|
|
|
|
-- SV11: skur uden pladsgrænse (kapacitet 0) -> varens procent ukendt, ikke 940 %
|
|
local shedGroups = S.groupByFillType({
|
|
{name = "A", entries = {{fillType = 9, level = 40, capacity = 100}}},
|
|
{name = "B", entries = {{fillType = 9, level = 900, capacity = 0}}},
|
|
}, titleOf)
|
|
check("SV11 procent nil ved ubegrænset skur", shedGroups[1].percent, nil)
|
|
|
|
-- "kræver handling" -> opret flow: hvem bruger varen, og hjælper et flow overhovedet? (brugerønske 29/9)
|
|
do
|
|
local inv = {
|
|
{name = "Mølle", kind = "factory", placeable = "pMill", entries = {{fillType = 7, level = 1000, isOutput = false}, {fillType = 8, level = 50, isOutput = true}}},
|
|
{name = "Silo", kind = "silo", placeable = "pSilo", entries = {{fillType = 7, level = 90000}}},
|
|
{name = "Kostald", kind = "husbandry", placeable = "pBarn", entries = {{fillType = 7, level = 500, isOutput = false}}},
|
|
}
|
|
local consumers = S.consumersOf(inv, 7)
|
|
check("forbrugere: fabrik + stald (ikke silo)", #consumers, 2)
|
|
check("forbrugere: output tæller ikke", #S.consumersOf(inv, 8), 0)
|
|
check("råd: eksisterende flow -> åbn det", S.flowAdvice({farmLevel = 91500, consumerLevel = 1500, perDay = 20000, consumerCount = 2, existingRunId = 4}), "open")
|
|
check("råd: lager andre steder -> opret flow", S.flowAdvice({farmLevel = 91500, consumerLevel = 1500, perDay = 20000, consumerCount = 2}), "flow")
|
|
check("råd: intet at flytte -> producér/køb", S.flowAdvice({farmLevel = 12700, consumerLevel = 12700, perDay = 228000, consumerCount = 1}), "produce")
|
|
check("råd: lidt andre steder, stort forbrug -> producér/køb", S.flowAdvice({farmLevel = 20000, consumerLevel = 12000, perDay = 228000, consumerCount = 1}), "produce")
|
|
check("råd: ingen forbrugere -> intet", S.flowAdvice({farmLevel = 5000, consumerLevel = 0, perDay = 0, consumerCount = 0}), "none")
|
|
end
|
|
-- "sælg nu" -> udkørsels-flow (brugerønske 29/9)
|
|
check("salg: eksisterende salgsflow -> åbn", S.sellAdvice({sourceCount = 1, existingRunId = 3}), "open")
|
|
check("salg: ingen -> opret flow", S.sellAdvice({sourceCount = 2}), "flow")
|
|
check("salg: ingen bygning med varen -> intet", S.sellAdvice({sourceCount = 0}), "none")
|
|
print(failures == 0 and "\nALLE TESTS OK" or ("\n" .. failures .. " FEJL"))
|
|
os.exit(failures == 0 and 0 or 1)
|