DogFatherGitandClaude Opus 5
4e35c6f8e5
Wunsch Filipe: "die hintergrund bilder sollen alle so strahlen und
schoen sein wie dieses. dieses ist wirklich mega und perfekt."
(Massstab ist die Scouting-Seite, Szene "wald".)
DER FUND: `chat.html` hat weder `.kopf-zeile` noch `.k-kopf` -- sie
traegt ihren Titel im eigenen `.chat__kopf`. In kopf.js stand ganz
oben:
const kopf = document.querySelector('.kopf-zeile, .k-kopf');
if (!B || !kopf) return;
Damit hing ALLES an der Frage, ob es eine Kopfzeile gibt, an die man
eine Plakette haengen kann -- auch der Farbton der Seite und ihr
Hintergrundbild, die damit nichts zu tun haben. Der Chat ist an dieser
Zeile ausgestiegen und hat WEDER Ton NOCH Buehne bekommen, obwohl in
bereiche.js seit jeher `szene: 'lounge'` fuer ihn steht. Eine
Zuordnung, die es gibt und die nie ankam.
Jetzt stehen Ton und Buehne VOR der Plakette: Sie brauchen nur den
Bereich. Die Plakette braucht zusaetzlich einen Kopf -- gibt es den
nicht, faellt eben nur sie aus.
WARUM DAS KEINE PRUEFUNG GEFUNDEN HAT, gleich zweimal:
1. `chat.html` stand nicht in der Seitenliste von
pruef-workspace-seiten. Eine Pruefung, die eine Seite nicht kennt,
kann auf ihr nichts finden. Jetzt drin, zusammen mit
leistung.html -- 18 Seiten statt 16.
2. Die Buehnenregel lautete `r.buehne ? r.buehneBild === r.buehne :
!!r.buehneBild` -- fehlt das Merkmal, reichte IRGENDEIN Bild.
Gedacht war die Ausnahme fuer die Startseite, geschrieben war sie
fuer jede Seite. Der Chat verlor sein `data-buehne`, fiel auf die
Grundszene zurueck, und die Pruefung sagte "ein Motiv ist da,
alles gut". Eine Bedingung, die bei fehlender Angabe MILDER wird
statt strenger, kann den Verlust dieser Angabe nicht melden --
sie belohnt ihn. Die Ausnahme haengt jetzt an der Startseite, nicht
am Fehlen des Merkmals.
Die Regel ist dafuer aus der Schleife herausgeloest (`buehneRichtig`)
und hat sieben Gegenproben bekommen -- darunter genau den Chat-Fall.
Ohne sie waere "alles in Ordnung" nur die Aussage, dass die Regel
nichts gemeldet hat, nicht dass sie etwas melden koennte.
DIE AUSNAHME DES CHATS STEHT JETZT MIT NAMEN in der Pruefung, statt
dass die Seite aus der Liste faellt: Plakette und Wasserzeichen
entfallen dort, weil es den Ort dafuer nicht gibt -- Ton und Buehne
gelten. Ob der Chat eine Plakette bekommen soll, ist eine
Gestaltungsfrage fuer Filipe, keine Fehlerfrage.
ZWEI FALSCHE AUSSAGEN in tools/gate-bauen.mjs richtiggestellt:
"halle: dieselbe Sammlung, GESPIEGELT" -- nachgemessen haben beide
Dateien dieselbe Pruefsumme, es gibt in diesem Werkzeug keine
Spiegelung. Und "0,42 ist gemessen" ueber `const DUNKEL = 0.26`; der
Wert wurde gesenkt, die Zeile ist nicht mitgegangen. Ein Kommentar, der
mehr behauptet als der Code tut, ist schlimmer als keiner.
ZUM EIGENTLICHEN WUNSCH, ehrlich: Ich habe die Hintergrundhelligkeit
aller 18 Seiten nachgemessen. Die Scouting-Seite ist tatsaechlich die
hellste (0,0263), alle anderen liegen 19 bis 65 Prozent darunter --
aber der Grund ist NICHT die Bildbehandlung. Schleier und Abdunklung
sind fuer alle Seiten gleich und mehrfach nachgemessen. Der Unterschied
ist, WIE VIEL vom Bild noch zu sehen ist: Die Scouting-Seite traegt
eine schmale Karte, die anderen dichte Tabellen und Kachelraster. Das
liesse sich aendern, aber es ist eine Entscheidung ueber die
Inhaltsdichte von 17 Seiten -- die gehoert Filipe, nicht mir um zwei
Uhr nachts.
(Meine erste Messung sagte das Gegenteil. Sie nahm einen Streifen bei
x 0..150 -- ausgerechnet die dunkelste Spalte jedes Motivs. Danach
schien die Scouting-Seite fast schwarz, waehrend das Bildschirmfoto
derselben Seite hell und farbig ist. Ein Messfeld, das nicht
repraesentativ ist, misst zuverlaessig das Falsche.)
Geprueft: pruef-workspace-seiten (18 Seiten, alles in Ordnung),
pruef-buehne, pruef-css-klassen -- alle in Ordnung.
Co-Authored-By: Claude Opus 5 <[email protected]>
299 lines
16 KiB
JavaScript
299 lines
16 KiB
JavaScript
/* Kurzpruefung: Steht die Kopfleiste auf dem Handy ueber -- und zwar
|
|
auf ALLEN Seiten oder nur auf der neuen? Beantwortet die Frage, ob
|
|
ich einen eigenen Fehler gebaut oder einen alten gefunden habe. */
|
|
import { mkdtempSync, rmSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
|
|
const ordner = mkdtempSync(join(tmpdir(), "ws-kopf-"));
|
|
process.env.WORKSPACE_DB = join(ordner, "pruef.sqlite");
|
|
process.env.PORT = "4178";
|
|
process.env.SITE_ACCESS_SECRET = "lokaler-test";
|
|
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
|
|
process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
|
|
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
|
|
|
|
const express = (await import("express")).default;
|
|
const echteCookie = express.response.cookie;
|
|
express.response.cookie = function (n, w, o) {
|
|
return echteCookie.call(this, n, w, { ...(o || {}), secure: false });
|
|
};
|
|
import { notbremse } from "./helfer-notbremse.mjs";
|
|
await import("./index.js");
|
|
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
|
|
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
|
|
richtig fuer den Betrieb, fatal fuer eine Pruefung. Ohne diese
|
|
Zeile bleibt der Prozess nach einem Fehler ewig stehen, weil der
|
|
Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
|
|
notbremse(480_000, "pruef-workspace-seiten");
|
|
await new Promise((r) => setTimeout(r, 700));
|
|
const BASIS = "http://127.0.0.1:4178";
|
|
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 150_000).unref?.();
|
|
|
|
await fetch(BASIS + "/workspace/api/anmelden", {
|
|
method: "POST", headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({ rolle: "admin", code: "x" }),
|
|
}).catch(() => {});
|
|
|
|
const { DatabaseSync } = await import("node:sqlite");
|
|
const { scryptSync, randomBytes } = await import("node:crypto");
|
|
const d = new DatabaseSync(process.env.WORKSPACE_DB);
|
|
const salt = randomBytes(16).toString("hex");
|
|
const hash = scryptSync("CODE-DOGI-0001", salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
|
|
d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
|
|
.run("Test-DogFather", "admin", hash, salt, 32768, new Date().toISOString());
|
|
d.close();
|
|
|
|
const { chromium } = await import(
|
|
"file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
|
|
const browser = await chromium.launch();
|
|
|
|
/* Alle Seiten, die eine angemeldete Person zu sehen bekommt. Geprueft
|
|
wird auf beiden Groessen, weil die geteilten Klassen (.kopf-zeile,
|
|
.inhalt--breit, .leise) am 31.08.2026 von aufgaben.css nach start.css
|
|
gewandert sind -- faellt dabei etwas herunter, sieht man es hier. */
|
|
/** Stimmt die Buehne dieser Seite?
|
|
*
|
|
* HERAUSGELOEST, DAMIT SIE EINE GEGENPROBE BEKOMMEN KANN. Als Zeile
|
|
* mitten in der Schleife liess sie sich nur pruefen, indem man den
|
|
* Fehler in der Anwendung wieder einbaut. Als Funktion beantwortet sie
|
|
* die Frage in einer Zeile -- und die Gegenprobe unten beweist, dass
|
|
* sie auch NEIN sagen kann.
|
|
*
|
|
* @param istStart Die Startseite hat ihre feste Grundszene aus
|
|
* `body.start::before` und traegt kein `data-buehne`.
|
|
* @param gewollt Was `data-buehne` sagt (oder null).
|
|
* @param geladen Welches Motiv das CSS tatsaechlich laedt (oder null).
|
|
*/
|
|
export function buehneRichtig(istStart, gewollt, geladen) {
|
|
if (istStart) return !!geladen;
|
|
return !!gewollt && geladen === gewollt;
|
|
}
|
|
|
|
/* chat.html UND leistung.html KAMEN AM 09.09.2026 DAZU -- und der Chat
|
|
nicht aus Ordnungsliebe.
|
|
|
|
Er fehlte in dieser Liste, und genau auf ihm steckte ein Fehler, den
|
|
diese Pruefung haette finden muessen: `chat.html` hat weder
|
|
`.kopf-zeile` noch `.k-kopf`, und `kopf.js` stieg deshalb aus, BEVOR
|
|
es Ton und Buehne setzte. Die Seite lief seit jeher ohne ihr
|
|
Hintergrundbild, obwohl in bereiche.js `szene: 'lounge'` fuer sie
|
|
steht. Gefunden hat das keine Pruefung, sondern eine Messung der
|
|
Hintergrundhelligkeit aller 18 Seiten -- chat.html meldete als eine
|
|
von dreien "keine Buehne".
|
|
|
|
Eine Pruefung, die eine Seite nicht kennt, kann auf ihr nichts
|
|
finden. */
|
|
const SEITEN = ["start.html", "uebersicht.html", "aufgaben.html", "kalender.html",
|
|
"personen.html", "profil.html", "steckbrief.html", "wissen.html", "dateien.html",
|
|
"calls.html", "chat.html", "leistung.html", "startcheck.html", "report.html",
|
|
"scouting.html", "automation.html", "content.html", "bereich.html?b=live"];
|
|
|
|
let fehler = 0;
|
|
for (const [breite, hoehe, wie] of [[1440, 1000, "Computer"], [390, 844, "Handy"]]) {
|
|
console.log(`\n=== ${wie} (${breite}px)`);
|
|
const kontext = await browser.newContext({ viewport: { width: breite, height: hoehe } });
|
|
const seite = await kontext.newPage();
|
|
const konsole = [];
|
|
seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
|
|
seite.on("pageerror", (e) => konsole.push("pageerror: " + e.message));
|
|
|
|
await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
|
|
await seite.click('.rolle[data-rolle="admin"]');
|
|
await seite.fill("#code", "CODE-DOGI-0001");
|
|
await seite.click("button[type=submit]");
|
|
await seite.waitForURL("**/start.html", { timeout: 15000 });
|
|
|
|
for (const s of SEITEN) {
|
|
konsole.length = 0;
|
|
await seite.goto(BASIS + "/workspace/" + s, { waitUntil: "networkidle" });
|
|
await seite.waitForTimeout(300);
|
|
const r = await seite.evaluate(() => ({
|
|
ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
|
|
schuld: [...document.querySelectorAll("body *")]
|
|
.filter((e) => e.getBoundingClientRect().right > window.innerWidth + 1)
|
|
.map((e) => (e.tagName + "." + e.className).slice(0, 40)).slice(0, 4),
|
|
/* Die verschobenen Klassen muessen weiterhin greifen. .inhalt--breit
|
|
setzt 1240px -- kommt nur 880px an, ist die Regel verloren. */
|
|
breit: document.querySelector(".inhalt--breit")
|
|
? getComputedStyle(document.querySelector(".inhalt--breit")).maxWidth : null,
|
|
kopfzeile: document.querySelector(".kopf-zeile")
|
|
? getComputedStyle(document.querySelector(".kopf-zeile")).display : null,
|
|
abmelden: (() => {
|
|
const a = document.querySelector(".abmelden")?.getBoundingClientRect();
|
|
return a ? a.right <= window.innerWidth && a.left >= 0 : null;
|
|
})(),
|
|
/* Der Schriftzug oben links wird von kopf.js in Rang aufgeteilt.
|
|
Auf den Unterseiten ist der vordere Teil ein VERWEIS zurück zur
|
|
Startseite -- der muss die Aufteilung überleben, sonst ist der
|
|
Rückweg weg. Genau das wäre beim Zerlegen von Textknoten leicht
|
|
zu übersehen. */
|
|
markeHaupt: document.querySelector(".kopfleiste .marke__haupt")?.textContent
|
|
.replace(/ /g, " ") || null,
|
|
markeLeise: document.querySelector(".kopfleiste .marke__leise")?.textContent
|
|
.replace(/ /g, " ") || null,
|
|
markeRaute: document.querySelectorAll(".kopfleiste .marke__raute").length,
|
|
/* Ist der vordere Teil auf einer Unterseite noch ein klickbarer
|
|
Verweis auf die Startseite? */
|
|
rueckweg: document.querySelector(".kopfleiste .marke__haupt")?.tagName === "A"
|
|
? document.querySelector(".kopfleiste .marke__haupt").getAttribute("href") : null,
|
|
/* Jede Unterseite trägt Zeichen und Farbton ihrer Kachel. Beides
|
|
kommt aus bereiche.js, derselben Liste wie die Kachel -- fehlt
|
|
eins davon, ist die Zuordnung gerissen und die Seite sieht
|
|
wieder aus wie jede andere. */
|
|
ton: document.body.dataset.ton || null,
|
|
/* Jede Seite hat ihre eigene Bühne aus Filipes Bildern. Geprüft
|
|
wird nicht das Merkmal, sondern das TATSÄCHLICH geladene Bild --
|
|
ein data-buehne ohne passende CSS-Regel wäre still wirkungslos
|
|
und niemand würde es merken. */
|
|
buehne: document.body.dataset.buehne || null,
|
|
buehneBild: (getComputedStyle(document.body, "::before").backgroundImage
|
|
.match(/buehne-([a-z]+)-(breit|schmal)/) || [])[1] || null,
|
|
kopfZeichen: document.querySelectorAll(".kopf-zeichen__svg path").length,
|
|
kopfZeichenFarbe: document.querySelector(".kopf-zeichen__svg")
|
|
? getComputedStyle(document.querySelector(".kopf-zeichen__svg")).stroke : null,
|
|
wasserzeichen: document.querySelectorAll(".kopf-wasserzeichen__svg path").length,
|
|
}));
|
|
const istStart = s === "start.html";
|
|
const markeGut = r.markeHaupt && r.markeLeise && r.markeRaute === 1
|
|
&& (istStart || r.rueckweg === "start.html");
|
|
/* Auf der Startseite gibt es keinen Seitenkopf -- dort sind die
|
|
Kacheln selbst der Kopf. Überall sonst ist er Pflicht. */
|
|
/* ZWEI SEITEN HABEN KEINE KOPFZEILE, UND DAS IST ABSICHT.
|
|
|
|
Die Startseite ist ihre eigene Uebersicht. Der Chat fuellt den
|
|
Bildschirm mit zwei Spalten (Gespraechsliste und Verlauf) und
|
|
traegt seinen Titel in `.chat__kopf` -- eine zusaetzliche
|
|
Seitenkopfzeile darueber wuerde ihm eine Zeile Hoehe nehmen, die
|
|
er fuer den Verlauf braucht.
|
|
|
|
DIE AUSNAHME STEHT HIER MIT NAMEN, statt dass die Seite aus der
|
|
Liste faellt. Genau das war vorher der Fall: chat.html wurde
|
|
nicht geprueft, und deshalb blieb unbemerkt, dass sie auch ihr
|
|
Hintergrundbild verloren hatte. Eine Seite, die man aus der
|
|
Liste nimmt, damit die Liste gruen bleibt, ist eine Seite ohne
|
|
Pruefung.
|
|
|
|
WAS FUER DEN CHAT TROTZDEM GILT: Ton und Buehne. Die haengen am
|
|
Bereich, nicht an der Kopfzeile -- sie muessen ankommen. Nur
|
|
Plakette und Wasserzeichen entfallen, weil es den Ort dafuer
|
|
nicht gibt.
|
|
|
|
OFFEN FUER FILIPE: Ob der Chat eine Plakette bekommen soll, ist
|
|
eine Gestaltungsfrage, keine Fehlerfrage -- sie braucht seinen
|
|
Blick, nicht meine Entscheidung um zwei Uhr nachts. */
|
|
const ohneKopfzeile = istStart || s === "chat.html";
|
|
const kopfGut = ohneKopfzeile
|
|
? (istStart || r.ton !== null)
|
|
: (r.ton !== null && r.kopfZeichen > 0 && r.wasserzeichen > 0);
|
|
/* AM 03.09.2026 UMGESTELLT.
|
|
|
|
Hier stand: "jede Seite hat ihre EIGENE Bühne" -- geprüft wurde,
|
|
dass das geladene Bild zum data-buehne der Seite passt (Aufgaben
|
|
= Werkstatt, Kalender = Nachtstadt, und so weiter).
|
|
|
|
Filipe hat die neun Szenen an diesem Tag durch EIN Bild ersetzt:
|
|
"ersetze überall das hintergrund bild durch dieses bild". Damit
|
|
ist die alte Erwartung nicht mehr falsch bewiesen, sondern
|
|
überholt.
|
|
|
|
Was hier geprüft wird, bleibt aber dasselbe WICHTIGE: dass ein
|
|
Hintergrundbild überhaupt ankommt. Ein data-buehne ohne passende
|
|
CSS-Regel wäre still wirkungslos, und niemand würde es merken --
|
|
die Seite sähe nur "etwas dunkler" aus.
|
|
|
|
AM 07.09.2026 NOCH EINMAL UMGESTELLT -- und diesmal war die
|
|
Prüfung schlicht liegengeblieben. Filipe hat die Motive
|
|
zurückgeholt (Commit "Sieben Motive statt einem"), hier stand
|
|
aber weiter `=== "dogfather"`. Ergebnis: ALLE 32 Seiten rot, in
|
|
einer Meldung, der man nicht ansieht, welche Bedingung gefallen
|
|
ist -- 32 Fehlalarme, kein einziger Mangel. Wer eine Entscheidung
|
|
ändert, muss die Prüfung mitändern, sonst misst sie eine Welt,
|
|
die es nicht mehr gibt.
|
|
|
|
Die neue Bedingung ist SCHÄRFER als beide vorherigen: Das
|
|
geladene Bild muss zu dem Merkmal passen, das die Seite selbst
|
|
trägt. Ein `data-buehne="garage"` ohne passende CSS-Regel fiele
|
|
damit auf -- bei "überall dasselbe Bild" wäre es nie
|
|
aufgefallen, und bei "irgendein Motiv" auch nicht. */
|
|
/* "KEIN data-buehne" IST NUR AUF DER STARTSEITE IN ORDNUNG.
|
|
|
|
Hier stand `r.buehne ? r.buehneBild === r.buehne : !!r.buehneBild`
|
|
-- also: fehlt das Merkmal, reicht IRGENDEIN Bild. Gedacht war
|
|
das fuer die Startseite, die ihre feste Grundszene aus
|
|
`body.start::before` bezieht. Geschrieben war es fuer JEDE Seite.
|
|
|
|
Damit war der Chat-Fehler unsichtbar: Die Seite verlor ihr
|
|
`data-buehne`, fiel auf die Grundszene zurueck, und die Pruefung
|
|
sagte "ein Motiv ist da, alles gut". Eine Bedingung, die bei
|
|
fehlender Angabe milder wird statt strenger, kann den Verlust
|
|
dieser Angabe nicht melden -- sie belohnt ihn.
|
|
|
|
Jetzt ist die Ausnahme an die Startseite GEBUNDEN, nicht an das
|
|
Fehlen des Merkmals. Auf jeder anderen Seite ist "keine Buehne"
|
|
ein Fehler. */
|
|
const buehneGut = buehneRichtig(istStart, r.buehne, r.buehneBild);
|
|
/* JEDE BEDINGUNG EINZELN, MIT NAMEN. Vorher war das ein einziges
|
|
langes UND -- fiel es, stand da nur "FEHL" und eine Zeile, in
|
|
der alles in Ordnung aussah. Man musste die Prüfung aufmachen
|
|
und raten. Die Gründe stehen jetzt in der Meldung. */
|
|
const gruende = [];
|
|
if (!(r.ueber <= 0)) gruende.push(`ragt ${r.ueber}px heraus`);
|
|
if (konsole.length) gruende.push(`Konsole: ${konsole.join(" / ")}`);
|
|
if (r.abmelden === false) gruende.push("Abmelden-Knopf ausserhalb");
|
|
if (!markeGut) gruende.push("Schriftzug/Rückweg");
|
|
if (!kopfGut) gruende.push("Seitenkopf (Ton/Zeichen/Wasserzeichen)");
|
|
if (!buehneGut) {
|
|
gruende.push(r.buehne
|
|
? `Bühne: ${r.buehneBild} statt ${r.buehne}`
|
|
: `Bühne: die Seite trägt gar kein data-buehne (geladen: ${r.buehneBild || "nichts"})`);
|
|
}
|
|
if (!(r.breit === null || r.breit === "1240px")) gruende.push(`Breite ${r.breit}`);
|
|
if (!(r.kopfzeile === null || r.kopfzeile === "flex")) gruende.push(`Kopfzeile ${r.kopfzeile}`);
|
|
const gut = gruende.length === 0;
|
|
if (!gut) fehler++;
|
|
console.log(` ${gut ? "ok " : "FEHL"} ${String(s).padEnd(20)}`
|
|
+ `über=${String(r.ueber).padStart(3)}px abmelden=${r.abmelden}`
|
|
+ ` marke=${r.markeHaupt ? `"${r.markeHaupt}"◆"${r.markeLeise}"` : "FEHLT"}`
|
|
+ `${istStart ? "" : ` zurück=${r.rueckweg || "FEHLT"}`}`
|
|
+ `${istStart ? "" : ` ton=${r.ton || "FEHLT"} zeichen=${r.kopfZeichen}/${r.wasserzeichen}`}`
|
|
+ ` bühne=${r.buehneBild || "FEHLT"}${r.buehne && r.buehneBild !== r.buehne ? ` (gewollt: ${r.buehne})` : ""}`
|
|
+ ` breit=${r.breit}`
|
|
+ (konsole.length ? " KONSOLE: " + konsole.join(" | ") : "")
|
|
+ (r.schuld.length ? " -> " + r.schuld.join(" | ") : "")
|
|
+ (gruende.length ? "\n GRUND: " + gruende.join(" ; ") : ""));
|
|
}
|
|
await kontext.close();
|
|
}
|
|
/* ---- GEGENPROBE: kann die Buehnenregel auch NEIN sagen? ------------
|
|
Ohne das waere "alles in Ordnung" nur die Aussage, dass die Regel
|
|
nichts gemeldet hat -- nicht, dass sie etwas melden koennte. Genau
|
|
dieser Fall ist am 09.09.2026 eingetreten: Die alte Regel wurde bei
|
|
fehlendem `data-buehne` MILDER statt strenger und hat den Verlust
|
|
der Angabe belohnt statt gemeldet. */
|
|
{
|
|
const faelle = [
|
|
[false, "lounge", "lounge", true, "Seite will lounge und bekommt lounge"],
|
|
[false, "lounge", "garage", false, "Seite will lounge, bekommt garage"],
|
|
[false, null, "studio", false, "Seite hat gar kein data-buehne (der Chat-Fehler)"],
|
|
[false, null, null, false, "weder gewollt noch geladen"],
|
|
[false, "lounge", null, false, "gewollt, aber nichts geladen"],
|
|
[true, null, "studio", true, "Startseite mit ihrer Grundszene"],
|
|
[true, null, null, false, "Startseite ganz ohne Motiv"],
|
|
];
|
|
let schief = 0;
|
|
for (const [start, gewollt, geladen, soll, was] of faelle) {
|
|
const ist = buehneRichtig(start, gewollt, geladen);
|
|
if (ist !== soll) { schief++; console.log(` FEHL Gegenprobe "${was}": ${ist} statt ${soll}`); }
|
|
}
|
|
console.log(schief === 0
|
|
? ` ok die Bühnenregel erkennt alle ${faelle.length} Fälle richtig (Gegenprobe)`
|
|
: ` FEHL ${schief} Fälle der Bühnenregel stimmen nicht`);
|
|
if (schief) fehler += schief;
|
|
}
|
|
|
|
await browser.close();
|
|
console.log(`\n${fehler === 0 ? "Alles in Ordnung." : fehler + " Seite(n) fehlerhaft."}`);
|
|
try { rmSync(ordner, { recursive: true, force: true }); } catch {}
|
|
process.exit(fehler === 0 ? 0 : 1);
|