131 lines
11 KiB
Lua
131 lines
11 KiB
Lua
-- Kør: luajit tests/test_adFlowWagons.lua (fra repo-roden)
|
|
dofile("FS25_ADSmartPickup/adRuns.lua")
|
|
dofile("FS25_ADSmartPickup/adFlowWagons.lua")
|
|
local W = ADFlowWagons
|
|
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
|
|
-- gem/indlæs: traktor -> vogn
|
|
local text = W.serialize({vehicleB = "wagon2", vehicleA = "wagon1"})
|
|
check("gem: sorteret", text, "vehicleA=wagon1;vehicleB=wagon2")
|
|
local parsed = W.parse(text)
|
|
check("indlæs: A", parsed.vehicleA, "wagon1")
|
|
check("indlæs: B", parsed.vehicleB, "wagon2")
|
|
check("indlæs: tom", next(W.parse("")), nil)
|
|
check("indlæs: nil", next(W.parse(nil)), nil)
|
|
check("indlæs: skrald springes over", next(W.parse("=x;;y=")), nil)
|
|
-- husk vogn: ny tabel, gammel urørt
|
|
local before = {t1 = "w1"}
|
|
local after = W.remember(before, "t1", "w9")
|
|
check("husk: ny vogn", after.t1, "w9")
|
|
check("husk: original urørt", before.t1, "w1")
|
|
check("husk: samme vogn -> samme tabel", W.remember(after, "t1", "w9"), after)
|
|
-- start: hent / vent / start
|
|
check("start: har redskab bagpå", W.startAction({hasRear = true, wagonId = "w1", wagonExists = true, hasConnect = true}), "start")
|
|
check("start: ingen husket vogn", W.startAction({}), "start")
|
|
check("start: vognen findes ikke", W.startAction({wagonId = "w1", wagonExists = false, hasConnect = true}), "start")
|
|
check("start: vognen uden Connect", W.startAction({wagonId = "w1", wagonExists = true, hasConnect = false}), "start")
|
|
check("start: vognen på en anden", W.startAction({wagonId = "w1", wagonExists = true, hasConnect = true, wagonAttached = true}), "wait")
|
|
check("start: vognen lånt ud", W.startAction({wagonId = "w1", wagonExists = true, hasConnect = true, wagonBusy = true}), "wait")
|
|
check("start: hent", W.startAction({wagonId = "w1", wagonExists = true, hasConnect = true}), "fetch")
|
|
-- ejer: flowets vogn er flowets — også når flowet er stoppet (in-game 29/9: marksilo lånte Cow Food-vognen)
|
|
local runs = {{id = 1, stopped = false, wagons = {t1 = "w1"}}, {id = 2, stopped = true, wagons = {t2 = "w2"}}}
|
|
check("ejer: kørende flow holder", W.isHeld(runs, "w1"), true)
|
|
check("ejer: stoppet flow holder stadig", W.isHeld(runs, "w2"), true)
|
|
check("ejer: ukendt vogn", W.isHeld(runs, "w3"), false)
|
|
check("ejer: flowet findes", W.ownerOf(runs, "w2").id, 2)
|
|
-- bygning væk: to tjek i træk
|
|
local count, gone = W.missingStep(0, true)
|
|
check("væk: første tjek -> ikke endnu", gone, false)
|
|
count, gone = W.missingStep(count, true)
|
|
check("væk: andet tjek -> væk", gone, true)
|
|
count, gone = W.missingStep(1, false)
|
|
check("væk: fundet igen nulstiller", count, 0)
|
|
check("væk: fundet igen -> ikke væk", gone, false)
|
|
-- manglende bygninger i et flow
|
|
local exists = {a = true, b = true}
|
|
check("mangler: alle findes", #W.missingBuildings({sourceBuildingIds = {"a"}, targetBuildingIds = {"b"}}, exists, exists), 0)
|
|
check("mangler: én væk", W.missingBuildings({targetBuildingIds = {"a", "c"}, storeBuildingIds = {}}, exists, {a = true, c = true})[1], "c")
|
|
-- review v1.51
|
|
check("R1 traktoren er lånt ud af puljen -> vent", W.startAction({tractorBusy = true, hasRear = true, wagonId = "w1", wagonExists = true, hasConnect = true}), "wait")
|
|
local runs2 = {{id = 1, stopped = true, wagons = {t1 = "w1"}}, {id = 2, stopped = false, wagons = {t9 = "w1"}}}
|
|
check("R4 holdt hvis ET kørende flow har vognen", W.isHeld(runs2, "w1"), true)
|
|
local seen = {a = true, c = true}
|
|
check("R+ bygning aldrig set i sessionen tæller ikke som væk", #W.missingBuildings({targetBuildingIds = {"b"}}, {a = true}, seen), 0)
|
|
check("R+ bygning set og nu væk", W.missingBuildings({targetBuildingIds = {"c"}}, {a = true}, seen)[1], "c")
|
|
-- gæt flowets vogn ud fra parkeringsnavnet (ingen husket vogn: vognene var sat på plads før v1.51)
|
|
local cands = {{id = "v1", parkName = "P Cow Food vogn 1"}, {id = "v3", parkName = "P Cow Food vogn 3"},
|
|
{id = "g1", parkName = "P Goat Food vogn 1"}, {id = "v2", parkName = "P Cow Food vogn 2"}}
|
|
check("gæt: samme nummer", W.guessWagon("Cow Food", 3, cands, {}), "v3")
|
|
check("gæt: nummer optaget -> anden med flowets navn", W.guessWagon("Cow Food", 3, cands, {v3 = true}), "v1")
|
|
check("gæt: andet flow", W.guessWagon("Goat Food", 2, cands, {}), "g1")
|
|
check("gæt: intet passer", W.guessWagon("Pig Food", 1, cands, {}), nil)
|
|
check("gæt: store/små bogstaver", W.guessWagon("cow food", 2, cands, {}), "v2")
|
|
check("gæt: 'Cow Food 1' matcher ikke 'Cow Food 10'", W.guessWagon("Cow Food", 1, {{id = "x", parkName = "P Cow Food vogn 10"}, {id = "y", parkName = "P Cow Food vogn 1"}}, {}), "y")
|
|
-- tøm vognen før den parkeres (flow stoppet): mål -> silo/fabrik -> hjem
|
|
check("tøm: tom vogn -> hjem", W.emptyStep("start", {cargo = 0}), "home")
|
|
check("tøm: last -> flowets mål", W.emptyStep("start", {cargo = 5000, hasTarget = true}), "target")
|
|
check("tøm: last uden mål -> silo", W.emptyStep("start", {cargo = 5000, hasTarget = false}), "dump")
|
|
check("tøm: kører stadig -> vent", W.emptyStep("target", {cargo = 5000, adActive = true}), "wait")
|
|
check("tøm: mål fuldt, rest -> silo", W.emptyStep("target", {cargo = 2000}), "dump")
|
|
check("tøm: målet tog det hele -> hjem", W.emptyStep("target", {cargo = 0}), "home")
|
|
check("tøm: silo tog det -> hjem", W.emptyStep("dump", {cargo = 0}), "home")
|
|
check("tøm: silo kunne ikke -> giv op, hjem", W.emptyStep("dump", {cargo = 2000}), "giveUp")
|
|
check("tøm: for længe -> giv op", W.emptyStep("target", {cargo = 5000, adActive = true, elapsedMs = W.EMPTY_TIMEOUT_MS}), "giveUp")
|
|
-- flowet startes igen mens traktoren tømmer/kører hjem fra et stop: hjemturen afbrydes, den kører videre med vognen
|
|
-- (in-game 29/9: Stop+Start med 1 s mellemrum -> tømning ved forkert mål i 10 min, vogn sat af, traktor i garage)
|
|
check("genstart: tømmer -> afbryd", W.abortHomeTripOnStart({emptying = true}), true)
|
|
check("genstart: flowets hjemtur -> afbryd", W.abortHomeTripOnStart({flowHoming = true}), true)
|
|
check("genstart: puljens hjemtur (markarbejde) -> rør ikke", W.abortHomeTripOnStart({poolReturning = true}), false)
|
|
check("genstart: intet i gang", W.abortHomeTripOnStart({}), false)
|
|
-- tøm-mål: kun flowets egne mål — AD's 2. markør kan være forældet (æg-markør) eller et Wait-punkt (in-game 29/9)
|
|
check("tøm-mål: AD's mål er et af flowets", W.emptyTarget(12638, {12636, 12638}), 12638)
|
|
check("tøm-mål: forældet/Wait-markør -> flowets første mål", W.emptyTarget(12658, {12636, 12638}), 12636)
|
|
check("tøm-mål: intet AD-mål -> flowets første", W.emptyTarget(nil, {12636}), 12636)
|
|
check("tøm-mål: flow uden mål -> intet (silo)", W.emptyTarget(12658, {}), nil)
|
|
check("tøm-mål: ingen liste -> intet", W.emptyTarget(12658, nil), nil)
|
|
-- ledig traktor (puljen/markarbejde/marksilo må låne den): kun solo fra et stoppet flow
|
|
check("ledig: intet flow", W.tractorFree({}), true)
|
|
check("ledig: kørende flow", W.tractorFree({hasRun = true}), false)
|
|
check("ledig: stoppet flow, solo", W.tractorFree({hasRun = true, stopped = true}), true)
|
|
check("ledig: stoppet flow, flow-vogn bagpå", W.tractorFree({hasRun = true, stopped = true, carriesFlowWagon = true}), false)
|
|
check("ledig: stoppet flow, tømmer/kører hjem", W.tractorFree({hasRun = true, stopped = true, homeTrip = true}), false)
|
|
-- venteårsag i loggen (før stod der altid "i brug andetsteds")
|
|
check("vent-årsag: traktor optaget", W.waitReason({tractorBusy = true}), "tractorBusy")
|
|
check("vent-årsag: vogn på en anden", W.waitReason({wagonAttached = true}), "wagonAttached")
|
|
check("vent-årsag: vogn reserveret", W.waitReason({wagonBusy = true}), "wagonReserved")
|
|
-- tømning går i stå ved et fuldt mål (in-game 29/9: fåre-/BGA-vogne stod 10 min ved fuldt mål efter Stop alt)
|
|
check("tøm: står ved fuldt mål -> silo", W.emptyStep("target", {cargo = 5000, adActive = true, stalled = true}), "dump")
|
|
check("tøm: står ved silo uden at tømme -> næste silo", W.emptyStep("dump", {cargo = 5000, adActive = true, stalled = true, dumpAttempts = 1}), "dump")
|
|
check("tøm: 3 siloer prøvet -> giv op", W.emptyStep("dump", {cargo = 5000, adActive = true, stalled = true, dumpAttempts = W.MAX_DUMP_ATTEMPTS}), "giveUp")
|
|
check("tøm: kører mod målet (ikke i stå) -> vent", W.emptyStep("target", {cargo = 5000, adActive = true, stalled = false}), "wait")
|
|
check("i stå: tæt på, uændret længe", W.isStalled({nearTarget = true, sinceChangeMs = W.EMPTY_STALL_MS}), true)
|
|
check("i stå: tæt på, lige ankommet", W.isStalled({nearTarget = true, sinceChangeMs = 5000}), false)
|
|
check("i stå: på vej (langt væk)", W.isStalled({nearTarget = false, sinceChangeMs = 999999}), false)
|
|
-- hent vogn: ét nyt forsøg efter "stoppedAway" (AD standsede undervejs — fx spærret af en anden traktor)
|
|
check("hent igen: stoppedAway første gang", W.retryFetch("stoppedAway (37 m fra markøren)", 0), true)
|
|
check("hent igen: stoppedAway anden gang -> nej", W.retryFetch("stoppedAway", 1), false)
|
|
check("hent igen: noAttachable -> nej (markøren skal rettes)", W.retryFetch("noAttachable", 0), false)
|
|
-- manuel påkobling (spilleren sendte traktoren til Connect): traktor i et kørende flow startes bagefter
|
|
-- (in-game 29/9: Cow Food 3 hentede sin vogn manuelt efter et fejlet forsøg og blev holdende)
|
|
check("manuel kobling: kørende flow, egen vogn -> start", W.startAfterManualAttach({flowRunning = true, ownWagon = true}), true)
|
|
check("manuel kobling: stoppet flow -> nej", W.startAfterManualAttach({flowRunning = false, ownWagon = true}), false)
|
|
check("manuel kobling: AD kører allerede -> nej", W.startAfterManualAttach({flowRunning = true, ownWagon = true, adActive = true}), false)
|
|
check("manuel kobling: fremmed vogn -> nej", W.startAfterManualAttach({flowRunning = true, ownWagon = false}), false)
|
|
-- husk vogn ved hjemtur: kun når flowet KØRTE med den (stop); ikke ved oprydning efter indlæsning, hvor traktoren
|
|
-- kan have et puljeredskab på fra et lån (in-game 29/9: Biogas Silage "huskede" en læssevogn fra markarbejdet)
|
|
check("husk ved stop af kørende flow", W.shouldRememberOnHome("stop"), true)
|
|
check("husk ikke ved oprydning efter indlæsning", W.shouldRememberOnHome("afterLoad"), false)
|
|
-- forældreløs påkobling (hentet før genindlæsning, opgaven tabt): sættes tilbage efter 2 min uden ejer
|
|
check("forældreløs: ingen ejer, længe nok -> hjem", W.orphanAction({owned = false, idleMs = W.ORPHAN_MS}), "home")
|
|
check("forældreløs: har ejer -> intet", W.orphanAction({owned = true, idleMs = W.ORPHAN_MS}), "none")
|
|
check("forældreløs: for kort tid -> vent", W.orphanAction({owned = false, idleMs = 1000}), "wait")
|
|
-- parkeret sæt på traktorens egen plads er ikke forældreløst (in-game 29/9: vinmarks-REX blev skilt ad)
|
|
check("forældreløs: står på egen parkering -> intet", W.orphanAction({owned = false, atOwnPark = true, idleMs = W.ORPHAN_MS}), "none")
|
|
print(failures == 0 and "\nALLE TESTS OK" or ("\n" .. failures .. " FEJL"))
|
|
os.exit(failures == 0 and 0 or 1)
|