From 1d5d7c141e58d3c413310295b69a971aa64d6337 Mon Sep 17 00:00:00 2001 From: Michael Stangl Date: Tue, 28 Jul 2026 13:49:21 +0200 Subject: [PATCH] [FIX] Scanner-Insert in TEST_MUBEA: eff wurde durch AND statt IF zu T mubea:build-separator-one nutzte (and blockname (ssg-ils-block-laden blockname)) fuer eff - AutoLISPs AND liefert bei mehreren wahren Ausdruecken T zurueck statt des letzten Werts (anders als in Common Lisp/Scheme). Sobald ein Blockname (z.B. "Scanner") direkt gefunden wurde, statt ueber den Separator_SP-Fallback zu laufen, wurde eff=T an "_.INSERT" uebergeben. Fix: (if blockname (ssg-ils-block-laden blockname)). Ausserdem: Scanner-Testeintrag in mubea.json ergaenzt und _vario_count/_separator_count in test_mubea.py, damit erwartete Ergebniszahlen auch bei "anzahl">1 (Template->mehrere Kopien) stimmen. Co-Authored-By: Claude Sonnet 5 --- tests/test_mubea.lsp | 141 ++++++++++++++++++++++++++++++-------- tests/test_mubea.py | 16 ++++- tests/testdata/mubea.json | 10 +++ 3 files changed, 136 insertions(+), 31 deletions(-) diff --git a/tests/test_mubea.lsp b/tests/test_mubea.lsp index 07937ac..1bcb1f0 100644 --- a/tests/test_mubea.lsp +++ b/tests/test_mubea.lsp @@ -5,7 +5,9 @@ ;; - Kreisel (Eintraege mit "id", Block KREISEL_*) via kreisel-insert-script ;; - Vario (test_id "VF_*") Block VF_* via variofoerderer-einfuegen ;; + vf-block-erstellen -;; (deltaL/L_VF werden fuer winkel+deltaH geloest, L_GF Split 500/4230) +;; (deltaL/L_VF werden fuer winkel+deltaH geloest, L_GF Split 500/4230; +;; "anzahl"/"delta_y"/"delta_x" wie bei Gefaelle: Template->mehrere +;; Foerderer mit fortlaufend suffixiertem test_id, _01.._anzahl) ;; - Gefaelle (test_id "GF_*", Modus 1) Block GF_* via gefaellestrecke-einfuegen ;; - Separator (Eintraege mit "block") Block S-LP/Separator_SP via _.INSERT ;; @@ -109,18 +111,9 @@ ;; erzwingen in test_foerderer.lsp), statt den automatisch kleinsten ;; gueltigen Winkel zu nehmen. L_GF1 aus JSON ist der Vorlauf-Zielwert; ;; L_GF2 (Nachlauf) ist der Rest (L_GF_gesamt - L_GF1). -(defun mubea:build-vario (e / tid richtung deltaH deltaL winkel-soll gf1-ziel seite hz - startpunkt ergebnis winkel-treffer best-winkel L_GF L_VF - gf1 gf2 hoehe-bis lastEnt ent) - (setq tid (ssg-val e "test_id") - richtung (ssg-val e "richtung") - deltaL (float (ssg-val e "deltaL")) - deltaH (float (ssg-val e "deltaH")) - winkel-soll(ssg-val e "winkel") - gf1-ziel (float (ssg-val e "L_GF1")) - seite (ssg-val e "seite") - hz (ssg-val e "hz") - startpunkt (list (float (ssg-val e "x")) (float (ssg-val e "y")) (float (ssg-val e "z")))) +(defun mubea:build-vario-one (tid richtung deltaL deltaH winkel-soll gf1-ziel seite hz + startpunkt / ergebnis winkel-treffer best-winkel L_GF L_VF + gf1 gf2 hoehe-bis lastEnt ent) (if (or (null seite) (= seite "")) (setq seite "links")) (if (null hz) (setq hz 0.0) (setq hz (float hz))) (princ (strcat "\n [VARIO] " tid " -> deltaL=" (rtos deltaL 2 0) @@ -172,6 +165,48 @@ (mubea:result-json tid "vario" "failed" nil nil nil nil))) ) +;; --- Vario(s) aus einem Template-Eintrag bauen --- +;; Wie mubea:build-gf: "anzahl" identische Kopien, je um "delta_y"/"delta_x" (mm) +;; versetzt (nur startpunkt x/y - Default 1/0/0 -> genau ein Foerderer wie bisher). +;; Bei mehreren Kopien wird "test_id" fortlaufend suffixiert (_01.._anzahl), +;; bei genau einer Kopie bleibt der Template-Name erhalten (kompatibel zur +;; frueheren Einzelbenennung). +;; Rueckgabe: LISTE von Ergebnis-JSON-Strings (eine je Kopie). +(defun mubea:build-vario (e / tid0 richtung deltaL deltaH winkel-soll gf1-ziel seite hz + start0 anzahl dy dx i off nr tid startpunkt ergebnisse) + (setq tid0 (ssg-val e "test_id") + richtung (ssg-val e "richtung") + deltaL (float (ssg-val e "deltaL")) + deltaH (float (ssg-val e "deltaH")) + winkel-soll(ssg-val e "winkel") + gf1-ziel (float (ssg-val e "L_GF1")) + seite (ssg-val e "seite") + hz (ssg-val e "hz") + start0 (list (float (ssg-val e "x")) (float (ssg-val e "y")) (float (ssg-val e "z"))) + anzahl (ssg-val e "anzahl") + dy (ssg-val e "delta_y") + dx (ssg-val e "delta_x")) + (if (or (null anzahl) (< anzahl 1)) (setq anzahl 1)) + (setq dy (if dy (float dy) 0.0)) + (setq dx (if dx (float dx) 0.0)) + + (setq ergebnisse '() i 0) + (while (< i anzahl) + (setq off (float i)) + (setq nr (1+ i)) + (setq tid + (if (> anzahl 1) + (strcat tid0 "_" (if (< nr 10) (strcat "0" (itoa nr)) (itoa nr))) + tid0)) + (setq startpunkt (list (+ (car start0) (* dx off)) (+ (cadr start0) (* dy off)) (caddr start0))) + (setq ergebnisse + (cons (mubea:build-vario-one tid richtung deltaL deltaH winkel-soll gf1-ziel seite hz startpunkt) + ergebnisse)) + (setq i (1+ i)) + ) + (reverse ergebnisse) +) + ;; --- Gefaellestrecke: Init-Konflikt umgehen ----------------------------- ;; gefaellestrecke-einfuegen ruft "(if (not *lib-initialized*) (gf-init- @@ -281,26 +316,33 @@ ) -;; --- Separator (Eintraege mit "block"): _.INSERT der Blockdatei --- +;; --- Ein einzelner Separator: Blockdefinition laden, dann per Name einfuegen --- ;; Verwendet den in JSON genannten Block; faellt auf Separator_SP zurueck ;; (Block der "Separator einfuegen"-Routine ILS_SEPARATOR_INSERT). -(defun mubea:build-separator (e idx / blockname x y z rot pt pfad tid) - (setq blockname (ssg-val e "block") - x (float (ssg-val e "x")) - y (float (ssg-val e "y")) - z (float (ssg-val e "z")) - rot (ssg-val e "rotation")) - (if (null rot) (setq rot 0)) - (setq rot (float rot)) - (setq pt (list x y z)) - (setq tid (strcat "SEPARATOR_" (itoa idx))) +;; Nutzt ssg-ils-block-laden (wie Kreisel/GF/VF), um den Block vorab zu +;; definieren, dann klassisches "_.INSERT eff pt "" "" rot" (wie ueberall sonst +;; im Projekt, z.B. omni:insert-dxf/KreiselInsert). NEUE Bloecke (z.B. "Scanner") +;; koennen dabei eine zusaetzliche Rueckfrage einschieben, die die feste +;; Antwortfolge verschiebt und das INSERT nicht sauber beendet (CMDACTIVE bleibt +;; > 0) - dieselbe Absicherung wie in ssg-ils-block-laden-dim (Zeilen 418f.) und +;; omni:insert-dxf (Zeile 980): nach dem INSERT verbleibende Prompts mit Leer- +;; Antworten (Enter) abfangen, bis der Befehl sauber beendet ist. +(defun mubea:build-separator-one (tid blockname pt rot / eff) (princ (strcat "\n [SEP] " tid " '" (if blockname blockname "?") - "' -> (" (rtos x 2 0) "," (rtos y 2 0) "," (rtos z 2 0) ") R=" (rtos rot 2 0))) - (setq pfad (and blockname (ssg-ils-block-datei blockname))) - (if (null pfad) (setq pfad (ssg-ils-block-datei "Separator_SP"))) - (if pfad + "' -> (" (rtos (car pt) 2 0) "," (rtos (cadr pt) 2 0) "," (rtos (caddr pt) 2 0) + ") R=" (rtos rot 2 0))) + ;; NICHT (and blockname (ssg-ils-block-laden blockname)) verwenden: AutoLISPs + ;; AND liefert bei mehreren wahren Ausdruecken T zurueck, NICHT den letzten + ;; Wert (anders als z.B. in Common Lisp/Scheme) - eff waere dann bei einem + ;; erfolgreich direkt gefundenen Block (z.B. "Scanner", das NICHT ueber den + ;; Separator_SP-Fallback laeuft) das Symbol T statt des Blocknamen-Strings, + ;; und das anschliessende "_.INSERT" wuerde einen Block namens T einfuegen. + (setq eff (if blockname (ssg-ils-block-laden blockname))) + (if (null eff) (setq eff (ssg-ils-block-laden "Separator_SP"))) + (if eff (progn - (command "_.INSERT" pfad pt "" "" rot) + (command "_.INSERT" eff pt "" "" rot) + (while (> (getvar "CMDACTIVE") 0) (command "")) (mubea:ent-json tid "separator" (entlast))) (progn ;; Kein Block gefunden -> sichtbaren Platzhalter zeichnen @@ -312,6 +354,47 @@ (if blockname blockname "S-LP") nil pt nil))) ) +;; --- Separator(en) aus einem Eintrag bauen (Eintraege mit "block") --- +;; Wie mubea:build-gf: "anzahl" identische Kopien, je um "delta_y"/"delta_x" +;; (mm) versetzt (Default 1/0/0 -> genau ein Separator am angegebenen Ort). +;; Namensbasis fuer die Kopien: "test_id", falls angegeben (erzeugt +;; "_01".."_anzahl"), sonst Fallback "SEPARATOR_" wie +;; bisher (Einzel-Separatoren ohne "test_id" bleiben dadurch unveraendert). +;; "assigned_to" bleibt reine Dokumentation und wird hier NICHT zur Namens- +;; bildung verwendet, da mehrere Separatoren denselben assigned_to-Wert teilen +;; koennen (z.B. mehrere S-LP-Eintraege mit assigned_to "GF_Mubea_01"). +;; Rueckgabe: LISTE von Ergebnis-JSON-Strings (eine je Kopie). +(defun mubea:build-separator (e idx / blockname x0 y0 z rot tid0 anzahl dy dx + i nr tid pt ergebnisse) + (setq blockname (ssg-val e "block") + x0 (float (ssg-val e "x")) + y0 (float (ssg-val e "y")) + z (float (ssg-val e "z")) + rot (ssg-val e "rotation") + tid0 (cond ((ssg-val e "test_id")) ((strcat "SEPARATOR_" (itoa idx)))) + anzahl (ssg-val e "anzahl") + dy (ssg-val e "delta_y") + dx (ssg-val e "delta_x")) + (if (null rot) (setq rot 0)) + (setq rot (float rot)) + (if (or (null anzahl) (< anzahl 1)) (setq anzahl 1)) + (setq dy (if dy (float dy) 0.0)) + (setq dx (if dx (float dx) 0.0)) + + (setq ergebnisse '() i 0) + (while (< i anzahl) + (setq nr (1+ i)) + (setq tid + (if (> anzahl 1) + (strcat tid0 "_" (if (< nr 10) (strcat "0" (itoa nr)) (itoa nr))) + tid0)) + (setq pt (list (+ x0 (* dx (float i))) (+ y0 (* dy (float i))) z)) + (setq ergebnisse (cons (mubea:build-separator-one tid blockname pt rot) ergebnisse)) + (setq i (1+ i)) + ) + (reverse ergebnisse) +) + ;; --- JSON-Export der Mubea-Ergebnisse --- (defun mubea:export-results (tests-out-dir / out-json f first) diff --git a/tests/test_mubea.py b/tests/test_mubea.py index 4161caa..b806ec8 100644 --- a/tests/test_mubea.py +++ b/tests/test_mubea.py @@ -33,18 +33,30 @@ def _is_gefaelle(item): return tid.startswith("GF_") +def _vario_count(testdata): + """Wie _gefaelle_count: ein VF-Eintrag ist ein Template, das ueber 'anzahl' + expandiert wird (Default 1, falls Feld fehlt).""" + return sum(int(t.get("anzahl", 1)) for t in testdata if _is_vario(t)) + + def _gefaelle_count(testdata): """Anzahl erzeugter Gefaellestrecken: ein GF-Eintrag ist ein Template, das ueber 'anzahl' expandiert wird (Default 1, falls Feld fehlt).""" return sum(int(t.get("anzahl", 1)) for t in testdata if _is_gefaelle(t)) +def _separator_count(testdata): + """Wie _gefaelle_count: ein Separator-Eintrag kann per 'anzahl' mehrere + identische, versetzte Kopien erzeugen (Default 1, falls Feld fehlt).""" + return sum(int(t.get("anzahl", 1)) for t in testdata if _is_separator(t)) + + def _expected_counts(testdata): return { "kreisel": sum(1 for t in testdata if _is_kreisel(t)), - "vario": sum(1 for t in testdata if _is_vario(t)), + "vario": _vario_count(testdata), "gefaellestrecke": _gefaelle_count(testdata), - "separator": sum(1 for t in testdata if _is_separator(t)), + "separator": _separator_count(testdata), } diff --git a/tests/testdata/mubea.json b/tests/testdata/mubea.json index 7ebab92..620aa18 100644 --- a/tests/testdata/mubea.json +++ b/tests/testdata/mubea.json @@ -47,6 +47,16 @@ "rotation": 90, "assigned_to": "Kreisel_links" }, + { + "comment": "Scanner linken Kreisel unten", + "function": "insert", + "block": "Scanner", + "x": 400, + "y": -4823, + "z": 1467, + "rotation": 0, + "assigned_to": "Kreisel_links" + }, { "id": "Kreisel_rechts", "function": "insert",