HamLogTools

Testing — HamLogTools

Slovenska različica / Slovenian version ↓

Overview

All tests run in Node.js using the built-in node:test runner — no external dependencies required.

Test file	Tool	Tests	Groups
`edi2adif.test.js`	`edi2adif.html`	122	9
`edi-crosscheck.test.js`	`edi-crosscheck.html`	56	8
`adif-merge.test.js`	`adif-merge.html`	112	21
`adif-qrz-filter.test.js`	`adif-qrz-filter.js`	48	4
`vhf-logger/vhf-logger.test.js`	`vhf-logger/vhf-logger.html`	191	17
`adif-stats.test.js`	`adif-stats.html`	133	21
`adif2cab.test.js`	`adif2cab.html`	191	31
`edi-validator.test.js`	`edi-validator.html`	109	22

The sections below document each test file in detail.

Running the tests

node --test --test-reporter=spec edi2adif.test.js
node --test --test-reporter=spec edi-crosscheck.test.js
node --test --test-reporter=spec adif-merge.test.js
node --test --test-reporter=spec adif-qrz-filter.test.js
node --test --test-reporter=spec vhf-logger/vhf-logger.test.js
node --test --test-reporter=spec adif-stats.test.js
node --test --test-reporter=spec adif2cab.test.js
node --test --test-reporter=spec edi-validator.test.js

Requires Node.js v18 or later (node:test was stabilised in v18; the project was developed on v25).

How the tests work

edi2adif.html is a single-file browser app with no module system. The test file extracts the embedded <script> block at runtime and evaluates it inside a node:vm sandbox that provides a minimal DOM mock:

edi2adif.html ──► regex extract <script> ──► vm.createContext (mock DOM)
                                               └── vm.runInContext(script)
                                                        │
                                     function declarations promoted to ctx
                                                        │
                                   ctx.normBand, ctx.parseEDI, … exposed

The mock provides no-op implementations for document.getElementById, document.addEventListener, URL.createObjectURL, Blob, FileReader, etc. — enough for the script to initialise without a real browser.

vm prototype note: Objects returned by functions running inside a vm context share the vm’s Object.prototype, not the host’s. Using assert.deepStrictEqual on them fails even when all properties are identical. All assertions therefore compare individual properties with assert.equal.

Test groups

1 · `normBand` (27 tests)

Verifies the regex table that maps EDI PBand values to canonical ADIF band names and nominal frequencies.

Sub-group	What is checked
Empty / unknown input	Falsy input returns `{band:'', freq:''}`. Unrecognised strings pass through with no frequency. Whitespace is trimmed before matching.
6 m – 23 cm	Each band matched by frequency (MHz), wavelength (e.g. `2m`), and GHz strings with both dot and comma decimal separators.
Microwave bands	13 cm through 6 mm — band name verified for all eight entries.

2 · `parseEDI` (36 tests)

Exercises the EDI-to-QSO parser across header fields, record parsing, edge cases, and error handling.

Sub-group	What is checked
Header extraction	`PCall`, `PWWLo`, `TName`, `SPowe`, `MOpe1/2` stored under lowercased keys in the `header` object. Band resolved via `normBand`.
QSO count	`ERROR` callsigns and records with fewer than 10 semicolon-delimited fields are silently skipped.
Callsign normalisation	Lowercased callsigns are uppercased.
Mode mapping	EDI mode codes 1 → `SSB`, 2 → `CW`, 3 → `CW`, 4 → `SSB`, 5 → `AM`, 6 → `FM`, 7 → `RTTY`, 8 → `SSTV`, 9 → `ATV`.
Date parsing	`YYYYMMDD` stored; `DD.MM.YYYY` display string generated. YY ≥ 90 → 1900+YY; YY < 90 → 2000+YY.
Time parsing	`HHMM` stored; `HH:MM` display string generated.
RST & exchange	`rstS`, `rstR`, `stx`, `srx` fields extracted from correct column positions.
Locator validation	6-character Maidenhead grids kept in mixed case (first 4 uppercase, last 2 lowercase — e.g. `JN65ar`); 4-character grids rejected (`wwl` set to `''`).
Distance	Parsed as integer; zero preserved.
Duplicate flag	Column 13 value `D` → `dupe=true`; absent → `dupe=false`.
Key generation	`_key` follows `CALL\\|YYYYMMDD\\|HHMM` format; does not include band (that is added later by `handleFiles`).
Source tracking	`src` filename attached to every QSO.
Edge cases	Empty input, short records, CRLF line endings, minimum-field records (exactly 10 fields).

handleFiles is not tested here because it depends on the async browser FileReader API. Fields it adds to QSOs (myCall, myLoc, contest, pwr, ops, band, _bandKey) are therefore tested via the returned header object and the dedup group below.

3 · `adifField` (10 tests)

Verifies ADIF field serialisation: <TAG:length>value .

Tag name uppercased regardless of input case.
null, undefined, and '' return an empty string (field omitted).
Numeric value 0 is serialised (not treated as falsy/empty).
Length field in output matches the actual string length of the value.

4 · `csvEsc` (11 tests)

Verifies CSV escaping for DARC QSL and generic CSV export.

Plain strings returned unchanged.
Strings containing a comma, double-quote, newline (\n), or carriage return (\r) are wrapped in double-quotes.
Embedded double-quotes are doubled (" → "").
null and undefined coerced to ''; numbers coerced to string.

5 · `modeBadge` (8 tests)

Verifies the mapping from mode string to CSS badge class used in the table renderer.

SSB and AM map to badge-ssb (analog voice modes).
CW maps to badge-cw.
FM maps to badge-fm.
RTTY, SSTV, ATV, and unknown modes fall back to badge-digi.

6 · `i18n` (5 tests)

Verifies the translation lookup function t(key) and setLang(lang).

Default language is Slovenian (sl).
Switching to en and back to sl works correctly.
Unknown keys return the key string itself (safe fallback).

7 · Duplicate detection (6 tests)

Verifies the cross-file deduplication algorithm from finishLoad.

The _all array is a lexical let binding inside the vm scope and cannot be mutated from outside. The 5-line algorithm is therefore reimplemented inline and tested in isolation:

No duplicates → all dupe=false.
Two entries with the same _bandKey → second flagged.
Three identical entries → only the first kept.
Same call + time but different band → not a duplicate.
Entry already marked dupe=true by the EDI parser stays dupe=true; a following identical entry is also flagged by the dedup pass.
Mixed unique / duplicate set verified row-by-row.

8 · CSV export row format (9 tests)

Verifies the row-generation logic for the generic CSV export.

Header has exactly 19 columns; each data row has the same column count.
Row number is the first column.
Serial numbers (stx, srx) have leading zeros stripped (001 → 1).
Missing optional fields (exchange, locator, power, etc.) produce empty columns.
Contest names containing commas are wrapped in double-quotes by csvEsc.
Distance 0 is treated as absent and produces an empty cell; distance > 0 is kept.

9 · Inline edit — field mutation (11 tests)

Verifies the save logic from commitEdit().

startEdit/commitEdit manipulate real DOM nodes and cannot be driven from a vm context without full browser APIs. The mutation logic is replicated inline and tested in isolation.

Sub-group	What is checked
Basic fields	`rstS`, `rstR`, and `mode` are trimmed and saved directly to the QSO object.
Locator validation	Valid 6-char Maidenhead grid (A–R, 0–9, A–X) saved in mixed case (first 4 uppercase, last 2 lowercase; e.g. `JN65ar`). 4-char, 8-char, non-Maidenhead characters, S–Z first pair, and non-digit middle pair are all rejected and clear `wwl` to `''`.

What is not tested

Area	Reason
`handleFiles`	Requires async browser `FileReader`; not polyfillable in a pure vm context.
`finishLoad` / DOM update functions	Call `document.getElementById(...).style`, `.innerHTML`, etc. on real DOM nodes; only meaningful in a browser.
Export functions (`exportADIF`, `exportDARC`, `exportCSV`)	Depend on `_all` state, DOM checkboxes, and `Blob`/`URL.createObjectURL`. End-to-end browser tests (e.g. Playwright) would be needed.
Sorting (`sortFiltered`, `setSort`)	Depends on `_filtered` state; testable only with a full state setup.

Testiranje — HamLogTools [SL]

Pregled

Vsi testi tečejo v Node.js z vgrajenim izvajalcem node:test — brez zunanjih odvisnosti.

Testna datoteka	Orodje	Testov	Skupin
`edi2adif.test.js`	`edi2adif.html`	122	9
`edi-crosscheck.test.js`	`edi-crosscheck.html`	56	8
`adif-merge.test.js`	`adif-merge.html`	112	21
`adif-qrz-filter.test.js`	`adif-qrz-filter.js`	48	4
`vhf-logger/vhf-logger.test.js`	`vhf-logger/vhf-logger.html`	191	17
`adif-stats.test.js`	`adif-stats.html`	133	21
`adif2cab.test.js`	`adif2cab.html`	191	31
`edi-validator.test.js`	`edi-validator.html`	109	22

Spodnji razdelki dokumentirajo vsako testno datoteko podrobno.

Zaganjanje testov

node --test --test-reporter=spec edi2adif.test.js
node --test --test-reporter=spec edi-crosscheck.test.js
node --test --test-reporter=spec adif-merge.test.js
node --test --test-reporter=spec adif-qrz-filter.test.js
node --test --test-reporter=spec vhf-logger/vhf-logger.test.js
node --test --test-reporter=spec adif-stats.test.js
node --test --test-reporter=spec adif2cab.test.js
node --test --test-reporter=spec edi-validator.test.js

Zahteva Node.js v18 ali novejši (node:test je bil stabiliziran v v18; projekt je bil razvit na v25).

Kako testi delujejo

edi2adif.html je enostranska brskalniška aplikacija brez sistema modulov. Testna datoteka ob zagonu izvleče vgrajeni blok <script> in ga izvede znotraj peskovnika node:vm, ki zagotavlja minimalni nadomestek DOM-a:

edi2adif.html ──► regex izvleče <script> ──► vm.createContext (nadom. DOM)
                                                └── vm.runInContext(skripta)
                                                         │
                                      deklaracije funkcij prenesene v ctx
                                                         │
                                   ctx.normBand, ctx.parseEDI, … dostopni

Nadomestek zagotavlja brezdejavne implementacije za document.getElementById, document.addEventListener, URL.createObjectURL, Blob, FileReader itd. — dovolj, da se skripta inicializira brez pravega brskalnika.

Opomba o prototipih vm: Objekti, ki jih vrnejo funkcije v vm kontekstu, delijo Object.prototype iz vm, ne iz gostitelja. Zato assert.deepStrictEqual na njih ne uspe, čeprav so vse lastnosti identične. Vsa primerjanja zato primerjajo posamezne lastnosti z assert.equal.

Skupine testov

1 · `normBand` (27 testov)

Preverja tabelo regularnih izrazov, ki preslika vrednosti EDI PBand v kanonična imena pasov ADIF in nominalne frekvence.

Podskupina	Kaj se preverja
Prazen / neznan vnos	Lažni vnos vrne `{band:'', freq:''}`. Neprepoznani nizi se prenesejo brez frekvence. Beli prostor se obreže pred ujemanjem.
6 m – 23 cm	Vsak pas se ujema po frekvenci (MHz), valovni dolžini (npr. `2m`) in nizih GHz z decimalno piko in vejico.
Mikrovalovni pasovi	13 cm do 6 mm — ime pasu preverjeno za vseh osem vnosov.

2 · `parseEDI` (36 testov)

Preverja razčlenjevalnik EDI v QSO prek polj glave, razčlenjevanja zapisov, robnih primerov in obravnavanja napak.

Podskupina	Kaj se preverja
Ekstrakcija glave	`PCall`, `PWWLo`, `TName`, `SPowe`, `MOpe1/2` shranjeni pod ključi z malimi črkami v objektu `header`. Pas razrešen prek `normBand`.
Število QSO	Klicni znaki `ERROR` in zapisi z manj kot 10 polji (ločenimi s podpičjem) so tiho preskočeni.
Normalizacija klicnega znaka	Klicni znaki z malimi črkami se pretvorijo v velike.
Mapiranje načina	EDI kode načina 1 → `SSB`, 2 → `CW`, 3 → `CW`, 4 → `SSB`, 5 → `AM`, 6 → `FM`, 7 → `RTTY`, 8 → `SSTV`, 9 → `ATV`.
Razčlenjevanje datuma	Shranjeno `YYYYMMDD`; generiran prikazni niz `DD.MM.YYYY`. LL ≥ 90 → 1900+LL; LL < 90 → 2000+LL.
Razčlenjevanje časa	Shranjeno `HHMM`; generiran prikazni niz `HH:MM`.
RST in izmenjava	Polja `rstS`, `rstR`, `stx`, `srx` izvlečena iz pravilnih položajev stolpcev.
Validacija lokatorja	Maidenhead mreže s 6 znaki se ohranijo z mešanimi črkami (prvi 4 znaki z velikimi, zadnja 2 z malimi — npr. `JN65ar`); mreže s 4 znaki so zavrnjene (`wwl` nastavljeno na `''`).
Razdalja	Razčlenjena kot celo število; ničla ohranjena.
Zastavica duplikata	Vrednost `D` v stolpcu 13 → `dupe=true`; odsotnost → `dupe=false`.
Generiranje ključa	`_key` sledi obliki `KLICNI_ZNAK\\|YYYYMMDD\\|HHMM`; ne vsebuje pasu (ta se doda pozneje v `handleFiles`).
Sledenje izvoru	Ime datoteke `src` je pripeto vsakemu QSO.
Robni primeri	Prazen vnos, kratki zapisi, zaključki vrstic CRLF, zapisi z minimalnim številom polj (točno 10).

handleFiles tu ni testiran, ker je odvisen od asinhronega brskalnikovega API-ja FileReader. Polja, ki jih doda QSO-jem (myCall, myLoc, contest, pwr, ops, band, _bandKey), so zato preverjena prek vrnjenega objekta header in spodnje skupine za deduplikacijo.

3 · `adifField` (10 testov)

Preverja serializacijo polj ADIF: <OZNAKA:dolžina>vrednost .

Ime oznake pretvorjeno v velike črke ne glede na vhodni primer.
null, undefined in '' vrnejo prazen niz (polje izpuščeno).
Numerična vrednost 0 je serializirana (ne obravnavana kot lažna/prazna).
Polje dolžine v izhodu ustreza dejanski dolžini vrednosti.

4 · `csvEsc` (11 testov)

Preverja ubežanje CSV za izvoz DARC QSL in generični CSV.

Navadni nizi vrnjeni nespremenjeni.
Nizi z vejico, dvojnimi narekovaji, novo vrstico (\n) ali zaključkom vrstice (\r) so zaviti v dvojne narekovaje.
Vdelani dvojni narekovaji se podvojijo (" → "").
null in undefined pretvorjeni v ''; števila pretvorjena v niz.

5 · `modeBadge` (8 testov)

Preverja preslikavo niza načina v razred CSS značke, ki se uporablja v prikazu tabele.

SSB in AM preslikata v badge-ssb (analogni govorni načini).
CW preslika v badge-cw.
FM preslika v badge-fm.
RTTY, SSTV, ATV in neznani načini padejo na rezervno vrednost badge-digi.

6 · `i18n` (5 testov)

Preverja funkcijo za iskanje prevodov t(ključ) in setLang(jezik).

Privzeti jezik je slovenščina (sl).
Preklop na en in nazaj na sl deluje pravilno.
Neznani ključi vrnejo sam ključ (varna rezervna vrednost).

7 · Zaznavanje duplikatov (6 testov)

Preverja algoritem deduplikacije iz finishLoad.

Polje _all je leksikalna vezava let znotraj obsega vm in je ni mogoče mutirati od zunaj. 5-vrstični algoritem je zato reimplementiran neposredno in testiran v izolaciji:

Brez duplikatov → vse dupe=false.
Dva vnosa z enakim _bandKey → drugi označen.
Trije enaki vnosi → ohranjen le prvi.
Enak klicni znak + čas, a različen pas → ni duplikat.
Vnos, ki ga je razčlenjevalnik EDI že označil z dupe=true, ostane označen; naslednji enaki vnos je prav tako označen s prehodom deduplikacije.
Mešana množica edinstvenih in podvojenih vnosov preverjena vrstico po vrstico.

8 · Format vrstice CSV izvoza (9 testov)

Preverja logiko generiranja vrstic za generični CSV izvoz.

Glava ima natanko 19 stolpcev; vsaka vrstica s podatki ima enako število stolpcev.
Zaporedna številka vrstice je v prvem stolpcu.
Serijske številke (stx, srx) imajo odstranjene vodilne ničle (001 → 1).
Manjkajoča neobvezna polja (izmenjava, lokator, moč itd.) ustvarijo prazne stolpce.
Imena tekmovanj z vejicami so zavita v dvojne narekovaje prek csvEsc.
Razdalja 0 je obravnavana kot odsotna in ustvari prazno celico; razdalja > 0 je ohranjena.

9 · Urejanje v živo — mutacija polj (11 testov)

Preverja logiko shranjevanja iz commitEdit().

startEdit/commitEdit manipulirata z resničnimi vozlišči DOM in ju ni mogoče izvajati iz vm konteksta brez polnih brskalniških API-jev. Logika mutacije je reimplementirana neposredno in testirana v izolaciji.

Podskupina	Kaj se preverja
Osnovna polja	`rstS`, `rstR` in `mode` so obrezani in shranjeni neposredno v objekt QSO.
Validacija lokatorja	Veljavna 6-znakovna Maidenhead mreža (A–R, 0–9, A–X) se shrani z mešanimi črkami (prvi 4 z velikimi, zadnja 2 z malimi; npr. `JN65ar`). 4-znakovni, 8-znakovni, znaki zunaj Maidenhead, prvi par S–Z in nečiselni srednji par so zavrnjeni in `wwl` se postavi na `''`.

`edi-crosscheck.test.js` — 56 tests · 8 groups

Covers the pure logic of edi-crosscheck.html: suffix stripping, edit distance, EDI parsing, and all crosscheck algorithms including configurable thresholds and missing-locator suggestions.

How the tests work

edi-crosscheck.html is evaluated inside a node:vm context, the same pattern as edi2adif.html. Unlike that tool, no code is stripped — instead a Proxy-based DOM mock absorbs all property access and method calls silently, so the startup event-wiring runs without error.

Module-level state (_histDB, _results) is const/let and therefore not accessible as ctx properties. Tests route all state through function declarations:

clearHist() — resets the DB and result set between tests
addToHistDB(qsos) — populates the historical database
runCrosscheck(qsos) — runs the check and returns the results array

Test groups

1 · `baseCall` (13 tests)

Verifies suffix stripping for crosscheck matching.

Portable/mobile suffixes (/P, /M, /MM, /AM, /QRP, /R, /A, /B) stripped from trailing position.
Italian regional suffixes (/IV3, /I1, etc.) stripped — treated the same as /P because they indicate the same station operating from a different region.
Numerical district suffixes (/1, /2, etc.) stripped.
Prefix-slash callsigns (OE/S59DGO, F/ON4AAA) left unchanged — they represent a different operating location (prefix is a country/region prefix, not a suffix).
Heuristic: if the part before the slash contains a digit, it’s a callsign/suffix pattern and the suffix is stripped; otherwise it’s a prefix/call pattern and kept as-is.
Plain callsigns unchanged. Result always uppercased.

2 · `levenshtein` (9 tests)

Verifies the Levenshtein distance function with maxDist=2 early-exit.

Distance 0 for identical strings.
Distance 1 for single substitution, insertion, or deletion.
Distance 2 for two substitutions.
Returns maxDist+1 when the length difference alone exceeds maxDist (early exit).
Handles empty strings correctly.

3 · `parseEDI` (9 tests)

Verifies QSO extraction from an EDI file fragment.

Two-record file parsed correctly; callsigns and portable suffixes preserved.
Band resolved from PBand header and applied to all QSOs.
Locator stored in mixed-case convention (JN65ar); invalid locators cleared to ''.
Date formatted as DD.MM.YYYY; two-digit year expanded.
ERROR callsigns skipped; CRLF line endings handled.

4 · `runCrosscheck — locator mismatch` (6 tests)

Test	What is verified
Clean match	No issue when locator equals historical mode
High severity	`LOC_MISMATCH` severity `high` when mode confidence ≥ 60% and new locator never seen
Medium severity	`LOC_MISMATCH` severity `med` when new locator appeared before (e.g. portable operation)
Threshold	No flag when callsign has fewer than 3 historical appearances
No locator	No `LOC_MISMATCH` when QSO has no locator (`wwl = ''`) — instead `LOC_MISSING` may be raised
allLocs order	Historical locator list in the issue is sorted by count descending

5 · `runCrosscheck — callsign check` (8 tests)

Test	What is verified
CALL_SIMILAR d=1	Call not in history; distance-1 match found and ranked first
CALL_UNKNOWN	Call not in history; no similar found within distance 2
In history	No call issue when base call exists in DB
Portable normalisation	`S59ABC/P` matched against `S59ABC` history — no call flag
Sort order	Similar suggestions sorted by distance ASC, then count DESC
Distance 2	Distance-2 matches also flagged (`CALL_SIMILAR`)
Combined issues	Unknown call produces only `CALL_SIMILAR`; no spurious LOC issue without history
Deduplication	Repeated unknown call in new log reuses precomputed similar-call list

6 · `runCrosscheck — missing locator suggestion` (4 tests)

Test	What is verified
Suggests mode locator	`LOC_MISSING` raised when new log QSO has no locator but history exists
Medium severity	`LOC_MISSING` severity `med` when mode confidence is below the threshold
Threshold	No `LOC_MISSING` when fewer than `_minAppearances` historical entries
Empty history locators	No `LOC_MISSING` when all historical entries have empty locators

7 · `runCrosscheck — configurable thresholds` (3 tests)

Test	What is verified
`_minAppearances`	No flag when historical count is below the slider threshold
`_minConfidence`	Severity respects the confidence slider (high vs med)
Empty locators ignored	Empty historical locators do not affect mode calculation

8 · `runCrosscheck — callsign by locator` (4 tests)

Test	What is verified
CALL_BY_LOC basic	Suggests calls historically seen from the same locator and within Levenshtein ≤ 2
No match	No `CALL_BY_LOC` when no historical calls from that locator are within distance 2
Separate from CALL_SIMILAR	`CALL_BY_LOC` and `CALL_SIMILAR` appear as distinct issues in the result
Redundant coexistence	`CALL_BY_LOC` is raised even when its candidates overlap with `CALL_SIMILAR` — both signals are shown as corroborating evidence

`adif-merge.test.js` — 112 tests · 21 groups

Covers the pure logic of adif-merge.html: ADIF parsing, deduplication, field normalization, export helpers, XSS escaping, CSV escaping, i18n key completeness, and regression tests for code-review fixes.

How the tests work

adif-merge.html is evaluated inside a node:vm context using the same Proxy-based DOM mock as the other HTML tools. Module-level let bindings are not ctx properties; these test helpers are injected via a second vm.runInContext call:

_getAllForTest() / _setAllForTest(arr) — read and write the _all QSO array
_getFilteredForTest() / _setFilteredForTest(arr) — access _filtered
_getDeselForTest() — read the _desel Set
_getSourcesForTest() / _setSourcesForTest(arr) — read and write _sources
_getI18nForTest(lang, key) — read a value from the S i18n object
_getLangKeys(lang) — list all keys for a given language

A local adif() helper computes :length from the actual string value of each field, so test fixtures are not brittle against length miscalculations.

Test groups

1 · `parseADIF — basic extraction` (9 tests)

Minimal QSO (call, date, time, band, mode) parsed correctly.
CALL uppercased, BAND lowercased, MODE uppercased regardless of input case.
RST_SENT, RST_RCVD, and GRIDSQUARE extracted to convenience properties.
Arbitrary fields (e.g. COMMENT, TX_PWR) preserved in q.fields dict.
src set to the filename argument.
Records without CALL silently skipped.

2 · `parseADIF — date/time normalization` (7 tests)

YYYYMMDD stored as-is; ISO YYYY-MM-DD stripped of dashes.
Normalized date written back to q.fields.QSO_DATE.
HHMMSS and HH:MM:SS times stripped/truncated to HHMM for the dedup key.
Display strings DD.MM.YYYY and HH:MM generated for UI.

3 · `parseADIF — multi-record / edge cases` (9 tests)

Multiple records in one file all parsed; files without <EOH> (headerless ADIF) handled gracefully.
Empty records between <EOR> markers skipped.
Tag names are case-insensitive; all stored with uppercase keys in q.fields.
CRLF line endings handled; APP_* tags preserved; type specifier <TAG:len:TYPE> ignored cleanly.
Empty string input returns zero QSOs.

4 · `parseADIF — fields dict kept in sync` (4 tests)

Normalization writes back to q.fields so ADIF export is lossless and uses the normalized value:

CALL in dict: uppercase + trimmed; BAND: lowercase; MODE: uppercase; QSO_DATE: dashes stripped.

5 · `updateKey` (3 tests)

Key format is CALL|BAND|MODE|DATE|TIME.
Different mode or different band each produce a different key.

6 · `recomputeDupes` (7 tests)

First occurrence → dupe=false; subsequent same key → dupe=true.
Same call with different mode, band, or time → both dupe=false.
Third occurrence of same key also dupe=true.
Stale dupe=true flags from previous state are cleared before recomputing.

7 · `parseADIF dedup key uniqueness` (4 tests)

Integration — keys round-trip correctly through parse + updateKey:

Same QSO from two different files → identical _key.
Case differences in CALL or BAND normalize to the same key.
Different mode → different key (no false dedup).

8 · `adifField` (7 tests)

Produces <TAG:length>value format (trailing space per ADIF convention).
Tag uppercased; length matches actual string length.
null, undefined, and '' → empty string (field skipped in export).
Numeric value 100 serialised as '100'.

9 · `htmlEsc` (9 tests)

&, <, >, " escaped to HTML entities; plain strings unchanged.
null and undefined → ''; numbers coerced to string.
XSS payload <script>alert(1)</script> rendered safe.

10 · `csvEsc` (7 tests)

Comma, double-quote, and newline trigger quoting; embedded double-quotes doubled.
null → ''; numbers coerced to string.

11 · `modeBadge` (13 tests)

SSB, AM, USB, LSB → badge-ssb.
CW → badge-cw; FM → badge-fm.
FT8, FT4, RTTY, JS8, WSPR, unknown, and empty string → badge-digi.

12 · `buildFilename` (6 tests)

STATION_CALLSIGN used when present; MY_CALLSIGN as fallback; "merged" when neither.
Filename always contains "merged"; correct extension appended (.adi, .csv).
/ in callsign replaced with - for filesystem safety.

13 · `ADIF export — field preservation` (2 tests)

Arbitrary fields (TX_PWR, ANTENNA, NOTES, MY_GRIDSQUARE) survive parse → export via q.fields.
Minimum required fields (CALL, QSO_DATE, TIME_ON, BAND, MODE) all present in q.fields.

14 · `I18N` (4 tests)

All SL keys present in EN and vice versa.
A fixed list of required UI keys (drop zone, stat bar, export buttons, table headers, error messages) present in both languages.
dropTitle differs between SL and EN.

15 · `parseADIF — real-world fixtures` (4 tests)

WSJT-X FT8 log: HHMMSS time truncated to HHMM, FREQ and STATION_CALLSIGN preserved.
Log4OM-style contest entry: RST, TX_PWR, COMMENT extracted correctly.
Two-file merge: combined QSO list, correct call + band per source.
Cross-file duplicate: same QSO in two files → second flagged after recomputeDupes.

16 · `parseADIF — missing optional fields` (5 tests)

Regression — parser must not crash when optional fields are absent:

Missing BAND → band = ''; missing TIME_ON → time = '', timeDisp = ''.
Missing QSO_DATE → date = '', dateDisp = ''.
Missing RST_SENT/RST_RCVD → ''; missing GRIDSQUARE → grid = ''.

17 · `parseADIF — no submode property on QSO object` (2 tests)

Regression — SUBMODE was a dead property removed from the QSO object during code review:

submode is not a property of the parsed QSO object.
SUBMODE tag is still preserved in q.fields for lossless ADIF export.

18 · `adifField — export consistency` (3 tests)

adifField is idempotent w.r.t. tag case (lowercase input → same output as uppercase).
APP_ADIFMERGE_SRC annotation built with correct :length from the source filename.
Empty value → empty output (field skipped, not emitted as <TAG:0>).

19 · `updateKey — empty band handling` (2 tests)

Documents behavior when band is absent — no crash, produces CALL||MODE|DATE|TIME; two such QSOs with identical other fields share the same key (will be deduped).

20 · `I18N — errBand key` (3 tests)

Regression — errBand translation key added during code review:

Key present in SL and EN; values differ between languages.

21 · `parseADIF — re-merge safety (APP_ADIFMERGE_SRC)` (2 tests)

Regression — re-merging a previously merged ADIF file must not duplicate the provenance tag:

APP_ADIFMERGE_SRC from a prior merge stored in q.fields (history preserved).
q.src always reflects the filename passed to parseADIF, not the old annotation, so exportADIF writes the correct new source tag.

CLI Tool Tests — `adif-qrz-filter.test.js`

A separate test suite covers the Node.js CLI tool. It also uses node:test with no external dependencies.

Tests: 48 across 4 test groups

Running

node --test adif-qrz-filter.test.js
node --test --test-reporter=spec adif-qrz-filter.test.js

Test groups

#	Group	Tests	What is checked
1	`parseAdif`	6	ADIF parsing: header extraction, record splitting, `QSL_VIA` extraction, CRLF handling, missing `CALL` skipping
2	`extractField`	8	Generic `<TAG:length>value` extraction for `CALL`, `QSL_VIA`, case-insensitivity, trimming, uppercasing, ADIF type specifier (`<TAG:len:TYPE>`)
3	`usesQslBuro`	31	Fuzzy logic: 12 positive cases (buro/bureau + European variants: buero/büro/buerau/boureau/burea/buiro; “Direct or Bureau” wins), 16 negative cases (no/direct only/only via LoTW/eQSL only/”QSL via CALL”), 3 edge cases (null/empty)
4	`cache`	3	JSON cache save/load round-trip, 7-day TTL purge, missing file handling

How the tests work

The CLI tool is evaluated inside a node:vm context that stubs fs, https, process, and console. Pure functions (parseAdif, extractField, usesQslBuro, loadCache, saveCache) are extracted and tested directly.

Note on deepStrictEqual: As with the edi2adif.html vm tests, assert.deepStrictEqual on vm-created objects can fail even when properties are identical. The cache tests therefore use assert.equal on individual properties or Object.keys().length for empty-object checks.

`vhf-logger/vhf-logger.test.js` — 191 tests · 17 groups

Covers the pure logic of vhf-logger/vhf-logger.html: callsign normalization, band mapping, geo utilities, dupe detection, dupe recalculation, EDI build, crosscheck lookup, EDI import parsing, ZIP generation, band colors, manual time state, and backup/restore validation.

How the tests work

vhf-logger/vhf-logger.html is evaluated inside a node:vm context using the same Proxy-based DOM mock as edi-crosscheck.html. Because module-level let bindings are not ctx properties, helpers are injected via a second vm.runInContext call. The ctx also explicitly receives TextEncoder, TextDecoder, Uint8Array, DataView, and ArrayBuffer so that makeZip can run correctly:

_setCurrentForTest(session) — sets the active session for dupe-related tests
_getCurrentForTest() — reads the active session back
_getEditingExistingForTest() — reads the _editingExisting flag for session-edit tests
_getI18nValueForTest(lang, key) — reads a value from the S i18n object for i18n coverage tests
_getManualTimeForTest() — reads the _manualTime state variable
_setManualTimeForTest(v) — sets _manualTime for state tests
_getBandColorsForTest() — returns the BAND_COLORS map

Test groups

1 · `baseCall` (10 tests)

Verifies suffix stripping used for dupe detection and crosscheck lookup.

/P, /M, /MM, /AM, /QRP suffixes stripped from trailing position.
Numerical district suffixes (/1, /2) stripped.
Prefix-slash callsigns (OE/S59DGO) kept unchanged (heuristic: slash before digit-containing part = suffix, otherwise = prefix).
Plain callsigns unchanged; result always uppercased.

2 · `normBand` (10 tests)

Verifies the band mapping table.

Canonical band names returned for MHz strings (144 MHz, 432 MHz), wavelength strings (2m, 70cm), and GHz strings (1.3 GHz).
Empty/unknown input returns {band:'', freq:''}.
Whitespace trimmed before matching.

3 · `locToLatLon` (7 tests)

Verifies Maidenhead locator → latitude/longitude conversion.

JN65VP → approx. lat 45.5°N, lon 13.8°E (Ajdovščina area).
IO91wm → approx. lat 51.3°N, lon -0.1°E (London area).
Sub-square letters (3rd pair) converted correctly.
Invalid input (wrong length, wrong characters) returns null.
4-character locators return null (only 6-character supported).

4 · `haversine` (4 tests)

Verifies great-circle distance calculation.

JN65VP → JN58UD ≈ 320 km (±30).
Same locator → distance 0.
Result is an integer (floored).
Distance is symmetric.

5 · `calcBearing` (5 tests)

Verifies great-circle bearing calculation.

Result is in range 0–359.
Result is an integer.
Due north → 0, due east → 90, due south → 180, due west → 270 (±2° tolerance for sub-square centre offset).

6 · `levenshtein` (7 tests)

Verifies the Levenshtein distance function with maxDist=2 early exit.

Distance 0 for identical strings.
Distance 1 for single substitution, insertion, or deletion.
Returns maxDist+1 when length difference alone exceeds maxDist (early exit).
Handles empty strings correctly.

7 · `isDupe` (7 tests)

Verifies dupe detection using baseCall() normalization and excludeId.

Same call + band → dupe detected.
Same base call with /P suffix → also detected as dupe.
Different band → not a dupe.
excludeId param prevents false-dupe when checking the QSO being edited.
No session (_current = null) → always returns false.

8 · `recalcDupes` (4 tests)

Verifies full dupe-flag recalculation across a session.

First occurrence of a base call per band → dupe=false; subsequent → dupe=true.
/P portable call normalizes to base call — counted as dupe of plain base call.
Per-band isolation: same call on different bands both get dupe=false.
After recalcDupes, the _current.qsos array is mutated in place.

9 · `buildEdi` (57 tests)

Verifies REG1TEST EDI v1 output format.

File starts with [REG1TEST;1] header.
TDate uses full YYYYMMDD;YYYYMMDD (start;end); QSO records use YYMMDD.
TName, PCall, PWWLo, PBand, PClub, PSect, MOpe1 headers present and correct.
Equipment headers: SPowe, SAnte, STXEq, SRXEq, SAntH populated from band config.
C* summary block: CQSOs, CQSOP, CWWLs, CWWLB, CExcs, CExcB, CDXCs, CDXCB, CToSc, CODXC — computed from non-dupe QSOs.
[QSORecords N] section present with correct count.
QSO line has exactly 15 semicolon-separated fields (col 0–14).
Dupe flag at col 14: D for duped QSO, empty for normal QSO.
nrS / nrR zero-padded to 3 digits.
WWL in QSO line is 6 characters uppercase.
PClub header populated from session.club; empty when not set.
Modes: SSB → 1, CW → 2, FM → 6.
Non-spec keywords absent: TCall, TLocator, RAZ, RClub not emitted.
Optional headers: PExch, PAdr1, PAdr2, RCall, RHBBS, RPoCo, RPhon — populated from session fields or emitted as empty lines.
Correct field order per spec 15.3.1: TName before TDate before PCall; STXEq before SPowe before SRXEq.
No blank lines between CODXC and [Remarks]; no blank line between [Remarks] and [QSORecords;N].
[END;S56OA HamLogTools VHF Logger] footer present.

10 · `lookupCall` (6 tests)

Verifies crosscheck lookup against the weighted+raw baseline DB.

Call in baseline → found=true, modeLoc set to most common locator.
/P portable → base call looked up correctly.
Call not in baseline → found=false, similar array populated from Levenshtein search.
similar list sorted by distance ASC, then count DESC.
Call completely unknown with no close match → found=false, similar=[].

11 · `sessionEdit` (10 tests)

Verifies state and i18n coverage for the session-editing feature.

_editingExisting flag initialises to false.
Four new SL i18n keys (btnEditSetup, setupEdit, btnSaveSetup, errBandHasQsos) are non-empty strings.
Four new EN i18n keys (same set) are non-empty strings.
sl.setupEdit and en.setupEdit are distinct strings (translation exists).

12 · `parseEdiForImport` (10 tests)

Verifies EDI file parsing for the import feature.

Correct QSO count from a 3-record EDI fragment.
YYMMDD date in QSO records converted to full YYYYMMDD (YY ≥ 80 → 19xx, YY < 80 → 20xx).
Mode number 1 → SSB, 2 → CW.
Dupe flag D at col 13 detected; clean QSOs have dupe=false.
Callsign uppercased; locator normalised to 4-upper + 2-lower mixed case.
Header fields (PBand, PCall) extracted.
UTC time parsed correctly from HHMM.

13 · `makeZip` (5 tests)

Verifies the minimal ZIP generator (STORE/no-compression).

Returns a Uint8Array.
First 4 bytes are the ZIP local file header magic PK\x03\x04.
Last 22 bytes start with the end-of-central-directory magic PK\x05\x06.
EOCD entry count field matches the number of files passed in.
Empty file list produces a valid minimal ZIP (≥ 22 bytes).

14 · `bandColors` (4 tests)

Verifies the BAND_COLORS map used to colour band tabs.

Map has entries for 2m and 70cm.
2m and 70cm have distinct colour values.
All values are 7-character #rrggbb hex strings.

15 · `manualTime` (7 tests)

Verifies manual UTC time override state and i18n keys for new features.

_manualTime initialises to null.
State can be set and read back via helpers.
sl.toastImported contains ${n} placeholder.
sl.errImportBand contains ${band} placeholder.
sl.btnExportAll and en.btnExportAll are non-empty strings.
sl.btnImport and en.btnImport are non-empty strings.

16 · `backup` (32 tests)

Verifies validateBackup() structure checks and i18n strings for the backup/restore feature.

Valid backup object (correct app, sessions array, valid sessions and QSOs) returns the sessions array.
Empty sessions array accepted.
Returns null for wrong app field, missing app, sessions not an array, null or raw array input.
Session-level validation: returns null if id is missing or empty, myCall missing, bands or qsos not arrays.
Session myLoc must be a valid 6-character Maidenhead locator ([A-R]{2}[0-9]{2}[A-X]{2}, case-insensitive); returns null if absent or malformed.
Session contest must be a non-empty string; returns null if absent or empty string.
QSO-level validation: returns null if _id, band, or call missing from any QSO.
sl.btnRestore ≠ en.btnRestore (distinct translations).
sl.confirmRestore and en.confirmRestore contain ${n} placeholder.
sl.toastRestoreDone and en.toastRestoreDone contain ${n} placeholder.

17 · `I18N` (3 tests)

Verifies i18n key symmetry between SL and EN translations.

All SL keys present in EN (no orphaned SL-only translations).
All EN keys present in SL (no orphaned EN-only translations).
SL and EN have the same total number of keys.

`adif-stats.test.js` — 133 tests · 21 groups

Covers the pure logic of adif-stats.html: DXCC prefix lookup, band/mode normalisation, locator conversion, QRB calculation, ADIF parsing, statistics aggregation, filter logic, date/month formatting, XSS escaping, SVG chart helpers, and i18n key completeness.

How the tests work

adif-stats.html is evaluated inside a node:vm context using the same mock setup as the other HTML tools. Only the <script> block is extracted; the minimal mock provides localStorage, document.getElementById, URL, Blob, setTimeout, and console.

Pure functions are accessed directly as context properties: lookupCall, normBand, normMode, locToLatLon, haversine, parseADIF, computeStats, fmtDate, fmtMonth, htmlEsc, svgHBar, svgVBar, t.

An adif() helper builds minimal ADIF fixture strings with correct <TAG:length>value encoding.

Test groups

1 · `lookupCall` (17 tests)

Verifies DXCC entity lookup by callsign prefix using the built-in PREFIX_DB table.

S5 (Slovenia), DL (Germany), K (USA), JA (Japan) — basic EU/NA/AS lookups.
Russia EU vs AS — calls with digit 1–8 map to EU; digit 9 or 0 maps to AS.
/P suffix stripped — S59DGO/P resolved as S59DGO.
OE/ prefix notation — OE/S59DGO resolved by the OE prefix (Austria), not S5.
Unknown call — returns { country: 'Unknown', cont: '?' }.
Empty string — returns Unknown.
Lowercase input — normalised to uppercase before lookup.
DXCC overrides — KL (Alaska), CU (Azores), TK (Corsica), 9H (Malta), UA2 (Kaliningrad) resolve correctly despite sharing prefixes with larger entities.

2 · `normBand` (5 tests)

Converts band string to lowercase (2M → 2m, 40M → 40m).
Trims surrounding whitespace.
Empty string and null both return ''.

3 · `normMode` (5 tests)

Returns the mode string uppercased when no submode is given (cw → CW).
Submode wins over mode when both present (DIGI + FT8 → FT8; DIGI + FT4 → FT4).
Both empty → empty string.

4 · `locToLatLon` (5 tests)

Converts a 4-character Maidenhead locator to [lat, lon].
JN65 → lat 45.5, lon 13.
null and too-short input return null.
A 6-character locator (JN65ar) produces the same result as the 4-character prefix — only the first 4 characters are used.

5 · `haversine` (5 tests)

Same locator → distance 0.
Different locators → distance > 0.
Transatlantic distance (JN65 → FN20) > 6 000 km.
Invalid or null locator → 0.

6 · `parseADIF — basic extraction` (9 tests)

CALL extracted; BAND lowercased; MODE uppercased regardless of input case.
SUBMODE overrides MODE (DIGI + FT8 → mode FT8).
src set to the filename argument.
Records without CALL silently skipped.
Multiple records all parsed; headerless ADIF (no <EOH>) handled; tag names case-insensitive.

7 · `parseADIF — date/time/QRB` (8 tests)

QSO_DATE stored as YYYYMMDD; ISO format (YYYY-MM-DD) normalised.
Short date (< 8 chars after normalisation) stored as ''.
TIME_ON HHMMSS truncated to HHMM; HHMM kept as-is.
DISTANCE field used as qrb when present.
GRIDSQUARE + MY_GRIDSQUARE → qrb via haversine when DISTANCE absent.
DISTANCE takes priority over grid-based calculation.

8 · `parseADIF — country/cont` (3 tests)

Slovenia S56OA → { country: 'Slovenia', cont: 'EU' }.
JA1ZLO → { cont: 'AS' }.
Unknown prefix → { country: 'Unknown', cont: '?' }.

9 · `computeStats — overview` (7 tests)

Empty array → total=0, empty calls Set.
total counts all QSOs.
calls Set counts unique callsigns (same call twice = 1).
dates Set counts unique dates.
bestDX tracks the QSO with the highest qrb.
firstDate / lastDate track the chronological span.
countries Set excludes 'Unknown'.

10 · `computeStats — aggregates` (9 tests)

byBand counts QSOs per band; tracks unique calls and best DX per band.
byMode counts QSOs per mode.
byCont tracks unique countries per continent.
byHour is a 24-element array; correct slot incremented by time field.
byMonth groups by YYYYMM key.
topCalls Map sorted descending by count.
Unknown continent ('?') not added to byCont.

11 · `applyFilters — date filter` (6 tests)

Replicates the date-range filtering logic in isolation:

QSO with empty date excluded when from or to is set.
QSO within range passes; before from or after to excluded.
No filter (both empty) passes all QSOs including those with empty dates.

12 · `fmtDate` (4 tests)

'20240315' → '15.03.2024'.
Empty string → empty string.
Input shorter than 8 chars returned as-is.

13 · `fmtMonth` (3 tests)

'202403' → '03/2024'; '202412' → '12/2024'.
Empty string → empty string.

14 · `htmlEsc` (7 tests)

&, <, >, " escaped to HTML entities; plain text unchanged.
XSS payload rendered safe.
Numbers coerced to string.

15 · `svgHBar` (6 tests)

Empty items → no <svg> tag.
Single item → <svg> present; multiple items produce <rect> bars.
Labels appear in output.
Zero-value item produces no <rect> (skipped by bw>0 guard).
colorFn callback applied to bar fill.

16 · `svgVBar` (6 tests)

Empty items → no <svg> tag.
Non-empty items → <svg> and <rect> present.
All-zero values → no <rect> elements.
24-item hour chart renders correctly with width 580.
Short bar (height < 14 px) places the value label above the bar in var(--muted) colour.
Zero-value bar has no value label; non-zero bar has its label.

17 · `I18N` (8 tests)

t('secOver') returns a non-empty translated string (not the key itself).
Unknown key returns the key string (safe fallback).
Section keys (secBand, secMode, secCont, secCountry, secTime, secTop) all non-empty.
Stat card keys (cTotal, cUniq, cCountries, cDays, cBestDX, cDateRange) all non-empty.
New section keys (secDxcc, secHeatmap, secBandHour, secQrb, dxccTotal, dxccCount, dxccProg, qrbRange, qrbNoData) all non-empty and differ from their key name.
hmapDow has 7 |-separated day abbreviations; SL first = Po, last = Ne.
hmapMon has 12 |-separated month abbreviations; first = Jan, last = Dec.
hmapMore non-empty and differs from its key name.

18 · `computeStats — byDay` (3 tests)

byDay Map counts QSOs per YYYYMMDD key.
QSOs with empty date are not added to byDay.
Three distinct dates → byDay.size === 3.

19 · `computeStats — byBandHour` (4 tests)

A band entry in byBandHour is a 24-element array.
Correct hour slot incremented per time field ('1430' → index 14).
Separate arrays per band (no cross-band contamination).
QSO with empty time → no band entry created in byBandHour.

20 · `computeStats — byDxcc / byBandDxcc` (5 tests)

byDxcc counts unique DXCC entity names; each entry has .qso count and .bands Set.
Two QSOs from Germany → byDxcc.get('Germany').qso === 2.
Same call on two bands → bands Set has both bands.
byBandDxcc Map: per-band Set of countries; correct size per band.
'Unknown' country excluded from both byDxcc and byBandDxcc.

21 · `computeStats — qrbBuckets` (8 tests)

qrbBuckets is a 6-element array (bucket indices 0–5).
Bucket 0 (< 500 km): qrb 200 and 499 both land here.
Bucket 1 (500–1 000 km): qrb 500 and 999.
Bucket 2 (1 000–2 000 km): qrb 1 000 and 1 999.
Bucket 3 (2 000–5 000 km): qrb 2 000 and 4 999.
Bucket 4 (5 000–10 000 km): qrb 5 000 and 9 999.
Bucket 5 (≥ 10 000 km): qrb 10 000 and 15 000.
qrb === 0 not bucketed (represents unknown distance).

`adif2cab.test.js` — 191 tests · 31 groups

Covers the pure logic of adif2cab.html: Cabrillo mode mapping, RST defaults, frequency conversion, ADIF parsing, exchange extraction per contest, QSO line formatting, XSS escaping, badge helpers, CONTESTS array structure, and i18n key completeness.

How the tests work

adif2cab.html is evaluated inside a node:vm context using the same Proxy-based DOM mock as the other HTML tools. Only the <script> block is extracted. Pure functions are accessed directly as context properties.

Three injected helpers give access to const/let module state:

_getContests() — returns the CONTESTS array
_getLangKeys(lang) — lists all i18n keys for a given language
_getI18n(lang, key) — reads a value from the S i18n object

A local adif() helper builds ADIF fixture strings with correct <TAG:length>value encoding. A makeQso() helper builds a minimal QSO object with sensible defaults; individual fields are overridden per test via spread.

Test groups

1 · `modeToCAB — phone modes → PH` (5 tests)

SSB, USB, LSB, AM → PH.
Lowercase ssb normalised to uppercase before lookup → PH.

2 · `modeToCAB — CW → CW` (2 tests)

CW (upper and lower) → CW.

3 · `modeToCAB — FM-based voice → FM` (5 tests)

Cabrillo v3 spec defines FM as a distinct mode value (not PH).

FM, C4FM, DSTAR, DMR, DIGITALVOICE → FM.

4 · `modeToCAB — RTTY → RY` (2 tests)

Cabrillo v3 spec defines RY for RTTY (not the DG catch-all).

RTTY (upper and lower) → RY.

5 · `modeToCAB — digital modes → DG` (8 tests)

FT8, FT4, PSK31, JT65, JS8, WSPR → DG.
Empty string and null → DG (safe catch-all).

6 · `dfltRST` (7 tests)

PH and FM → '59' (two-digit phone RST).
CW, DG, RY → '599' (three-digit CW/digital RST; RTTY uses 3-digit by convention).
Unknown mode and empty string → '59' (phone default).

7 · `freqToKHz — FREQ field conversion` (6 tests)

14.210 MHz → 14210, 144.300 MHz → 144300, 432.200 MHz → 432200.
Half-kHz value rounded correctly (14.0005 → 14001).
FREQ '0' and FREQ '' (not > 0) fall back to BAND_KHZ.

8 · `freqToKHz — BAND_KHZ fallback` (10 tests)

20m → 14200, 2m → 144300, 40m → 7100, 70cm → 432200, 23cm → 1296100.
6m → 50200, 4m → 70200.
Unknown band string → 0.
No fields property falls back gracefully; no band → 0.

9 · `parseADIF — basic extraction` (8 tests)

Minimal QSO parsed: call, date, time, band, mode extracted correctly.
CALL normalised to uppercase; BAND to lowercase; MODE to uppercase.
RST_SENT → rstS, RST_RCVD → rstR.
src set to the filename argument.
Records without CALL field are silently skipped.
Arbitrary ADIF fields preserved in fields dict with uppercase keys.

10 · `parseADIF — date/time normalization` (7 tests)

YYYYMMDD stored as-is; ISO YYYY-MM-DD stripped of dashes.
Display date formatted as DD.MM.YYYY.
HHMMSS time truncated to HHMM; display time formatted as HH:MM.
Missing QSO_DATE or TIME_ON → empty string (no crash).

11 · `parseADIF — multi-record / edge cases` (11 tests)

Two-QSO file parsed correctly.
File without <EOH> (headerless ADIF) accepted.
Tags case-insensitive; <TAG:len:type> type-specifier variant handled.
CRLF line endings handled.
STATION_CALLSIGN preserved in fields (used to auto-populate the header callsign).
Empty file returns zero QSOs.
fields dict keys are uppercase regardless of input case.
STX (WPX sent serial), SRX (received serial), and SRX_STRING preserved in fields.

12 · `extractExchR — CQ-WW-SSB` (6 tests)

CQZONE field returned when present; whitespace trimmed.
Falls back to SRX_STRING, then SRX when CQZONE absent.
CQZONE takes priority over SRX_STRING when both present.
All fields absent → ''.

13 · `extractExchR — CQ-WW-CW` (3 tests)

Same CQZONE priority chain as CQ-WW-SSB.

14 · `extractExchR — IARU-HF` (6 tests)

ITUZ returned when present; whitespace trimmed.
SRX_STRING fallback accepts HQ abbreviations (e.g. DARC).
ITUZ takes priority over SRX_STRING; SRX is the tertiary fallback.

15 · `extractExchR — ARRL-DX` (6 tests)

STATE returned when present; whitespace trimmed.
STATE takes priority over SRX_STRING; SRX tertiary fallback.

16 · `extractExchR — GENERIC` (5 tests)

SRX_STRING returned; falls back to SRX; SRX_STRING has priority.
Unknown contestId behaves as GENERIC.

17 · `extractExchR — CQ-WW-RTTY` (5 tests)

Same CQZONE priority chain as CQ-WW-SSB/CW.
CQZONE takes priority over SRX_STRING; SRX tertiary fallback.

18 · `extractExchR — IARU-VHF` (7 tests)

GRIDSQUARE field returned and uppercased (ADIF stores mixed-case, Cabrillo expects uppercase).
Already-uppercase locator unchanged.
Whitespace trimmed before uppercasing.
SRX_STRING and SRX fallbacks also uppercased.
GRIDSQUARE takes priority over SRX_STRING.

19 · `extractExchR — CQ-WPX-SSB` (4 tests)

SRX_STRING returned; falls back to SRX; SRX_STRING has priority.
All absent → ''.

20 · `extractExchR — CQ-WPX-CW` (3 tests)

Same SRX_STRING/SRX priority chain as CQ-WPX-SSB.

21 · `formatCabDate` (7 tests)

YYYYMMDD → YYYY-MM-DD (e.g. 20241026 → 2024-10-26).
null, undefined, empty string → '0000-00-00' (safe sentinel).
Non-8-digit string returned as-is (pass-through for already-formatted dates).

22 · `buildQSOLine — structure` (12 tests)

Line starts with QSO: and ends with ` 0` (transmitter ID).
CAB mode, date (YYYY-MM-DD), time (HHMM), my callsign, their callsign appear in the output.
HF frequency right-aligned to 5 chars (7100 → ' 7100'); zero freq → ' 0'.
VHF/UHF frequencies use 7-char field: 144300 → ' 144300', 432200 → ' 432200', 1296100 → '1296100'.

23 · `buildQSOLine — exchange handling` (6 tests)

Per-row exchS used when non-empty; header-level default fills in when exchS = ''.
exchR included in line; empty exchR produces padded empty field without crashing.
Exchange fields padded to contest.exchW: 4 for CQ WW, 6 for IARU.

24 · `buildQSOLine — RST defaults` (3 tests)

Empty rstS → dfltRST(cabMode) applied (59 for PH, 599 for CW).
Explicit rstS value overrides the default.

25 · `buildQSOLine — IARU-VHF locator exchange` (4 tests)

6-char locator (JN65AR) fits exchW:6 exactly.
4-char locator (JN65) padded to 6 with trailing spaces.
Sent locator (exchS) included in the line.
Empty exchR produces padded empty field without crashing.

26 · `buildQSOLine — CQ WPX per-QSO serial` (3 tests)

Per-QSO exchS serial number used when set (e.g. '001').
Serial padded to exchW:6.
Falls back to the header default when exchS is empty.

27 · `htmlEsc` (9 tests)

&, <, >, " escaped to HTML entities.
Plain strings returned unchanged.
null and undefined → ''; numbers coerced to string.
XSS payload <script>alert(1)</script> neutralised.

28 · `cabModeBadge` (6 tests)

Maps Cabrillo mode to CSS badge class for the preview table.

PH → badge-ssb.
CW → badge-cw.
FM, DG, RY, '' → badge-digi.

29 · `modeBadge` (9 tests)

Maps ADIF mode to CSS badge class for the preview table.

SSB, USB, LSB, AM → badge-ssb.
CW → badge-cw.
FM → badge-fm.
FT8, RTTY, '' → badge-digi.

30 · `CONTESTS — structure` (11 tests)

Array contains exactly 9 entries.
Each entry has required fields: id, name, exchSentLbl, exchRcvdLbl, exchRcvdField, exchW > 0.
exchRcvdField correct per contest: CQ-WW-SSB/CQ-WW-CW/CQ-WW-RTTY → CQZONE, IARU-HF → ITUZ, IARU-VHF → GRIDSQUARE, ARRL-DX → STATE, CQ-WPX-SSB/CQ-WPX-CW/GENERIC → SRX_STRING.
Each label has both sl and en sub-keys.

31 · `I18N` (4 tests)

All SL keys present in EN and vice versa (no orphaned translations).
Required UI keys verified for both languages (drop zone, header panel, export button, stat chips, toast messages).
SL and EN dropTitle values differ (sanity check that translations are distinct).

`edi-validator.test.js` — 109 tests · 22 groups

Covers the pure logic of edi-validator.html: Maidenhead geo utilities, and the full validate() function across all spec checks and issue types.

How the tests work

edi-validator.html is evaluated inside a node:vm context using the same Proxy-based DOM mock as the other HTML tools. The validate(text) function is accessed directly as a context property and accepts raw EDI file text, returning {issues[], qsoCount}.

The S i18n object (const S = {sl:{...}, en:{...}}) is exported via a second vm.runInContext('globalThis._S = S', ctx) call. A minimal valid EDI fixture is defined in the test file and used as a base for mutation-based tests (each test mutates one aspect of the fixture to trigger a specific issue code).

Test groups

1 · `locToLatLon` (4 tests)

Verifies Maidenhead locator → latitude/longitude conversion.

JN65VP → approx lat 45.5°N, lon 13.8°E.
4-character locator accepted (returns approximate centre of the large square).
Invalid locator returns null.
Lowercase locator accepted (case-insensitive).

2 · `haversine` (2 tests)

Verifies great-circle distance calculation.

Same point → distance 0.
JN65VP → JN78DG ≈ 294 km (±30).

3 · `validate — clean EDI` (4 tests)

Baseline sanity check with a well-formed EDI fixture.

No errors returned for valid EDI.
No warnings returned for EDI with all ZRS fields populated and spec-compliant content.
qsoCount matches the number of [QSORecords;N] QSO lines.
No [END;...] → iNoEnd (info).

4 · `validate — structure` (6 tests)

Checks for required section markers and blank-line rules.

Missing [REG1TEST;1] → eNoReg1test (error).
Missing [Remarks] → eNoRemarks (error).
Missing [QSORecords;N] → eNoQsoSection (error).
Blank line in header section → eBlankInHeader (error).
Blank line in [Remarks] section → iBlankInRemarks (info, not error).
CRLF and LF line endings both accepted without error.

5 · `validate — non-spec keywords` (6 tests)

Checks for keywords not defined in the REG1TEST v1 spec.

TCall, TLocator, RAZ, RClub, RBand → eNonSpecKw (error).
Completely unknown keyword → eNonSpecKw.

6 · `validate — header formats` (8 tests)

Checks header field syntax.

TDate=YYYYMMDD;YYYYMMDD valid format → no error.
TDate wrong format → eTDateFormat (error).
TDate single date (missing second half) → eTDateFormat.
PWWLo 4-character locator → wPwwloFormat (warn; too short for QRB calculation).
PWWLo invalid characters → wPwwloFormat.
PBand unknown value → wPBandUnknown (warn).
PBand 145 MHz (known value) → no wPBandUnknown.
Keyword out of spec order → iKwOrder (info).

7 · `validate — ZRS mandatory fields` (6 tests)

Checks ZRS-required fields are non-empty.

Empty PSect, PClub, RName, RHBBS, SPowe each → wFieldEmpty (warn).
All mandatory fields populated → no wFieldEmpty.

8 · `validate — QSO count` (3 tests)

Checks declared vs. actual QSO count.

Declared count matches actual → no eQsoCountMismatch.
Declared 2, found 1 → eQsoCountMismatch (error).
Declared 0, found 1 → eQsoCountMismatch.

9 · `validate — QSO field count` (3 tests)

Checks each QSO record has exactly 15 semicolon-delimited fields.

14 fields → eQsoFieldCount (error).
16 fields → eQsoFieldCount.
15 fields → no eQsoFieldCount.

10 · `validate — QSO date` (6 tests)

Checks QSO date field (YYMMDD at col 0).

Valid date → no eQsoDate.
5-digit date → eQsoDate (error).
Month 00 → eQsoDate.
Month 13 → eQsoDate.
Day 00 → eQsoDate.
Invalid month → eQsoDate but not wQsoDateOutOfRange (range check suppressed for structurally invalid dates).

11 · `validate — QSO time` (4 tests)

Checks QSO time field (HHMM at col 1).

Valid time → no eQsoTime.
5-digit time → eQsoTime (error).
Hour 24 → eQsoTime.
Minute 60 → eQsoTime.

12 · `validate — QSO mode` (5 tests)

Checks QSO mode field (col 3, valid values 0–9; mode 0 = “none of below” per spec).

Mode 0 → valid, no error (spec-defined “none of below” value).
Mode 1 and 9 → valid, no error.
Mode A (non-numeric) → eQsoMode (error).
Mode 10 (out of range) → eQsoMode.

13 · `validate — QSO dupe flag` (6 tests)

Checks QSO dupe flag field (col 14, valid values empty or D).

Empty dupe field → no error.
D → no error.
X (invalid value) → eQsoDupe (error).
d (lowercase) → eQsoDupe.
D with non-zero QRB → iDupeNonZeroQrb (info; dupes typically report QRB 0).
D with QRB 0 → no iDupeNonZeroQrb.

14 · `validate — QSO WWL format` (4 tests)

Checks QSO locator field (col 9).

Valid 6-char Maidenhead → no warning.
Valid 4-char Maidenhead → no warning (short locators permitted in QSO records).
Empty WWL → no warning.
Invalid WWL (wrong characters) → wQsoWwlFormat (warn).

15 · `validate — QRB deviation` (5 tests)

Checks declared QRB (col 10) against haversine-calculated distance.

Declared QRB within 10% of calculated → no wQrbDeviation.
Declared QRB off by >10% → wQrbDeviation (warn).
PWWLo is 4-char → QRB check skipped (insufficient locator precision).
Dupe QSO → QRB deviation check skipped.
Non-numeric QRB → wQsoQrbNum (warn); wQrbDeviation not raised.

16 · `validate — line length` (2 tests)

Checks each line does not exceed 75 characters.

Line ≤75 chars → no wLineTooLong.
Line 76 chars → wLineTooLong (warn).

17 · `validate — non-ASCII characters` (3 tests)

Checks for characters outside the 7-bit ASCII range (spec §15.3.4).

Pure ASCII content → no wNonAscii.
Non-ASCII character present → wNonAscii (not eNonAscii).
Non-ASCII → severity is warn (not error).

18 · `validate — duplicate keywords` (4 tests)

Checks that each header keyword appears at most once.

No duplicate keywords → no wDuplicateKw.
Duplicate TDate → wDuplicateKw (warn).
Duplicate PCall → wDuplicateKw.
First occurrence wins: a valid first TDate means no eTDateFormat even when the keyword is duplicated.

19 · `validate — QSO date day` (5 tests)

Checks that the day value is valid for the given month and year (leap year aware).

Valid day → no wQsoDateDay.
Feb 29 on a leap year → no wQsoDateDay.
Feb 29 on a non-leap year → wQsoDateDay (warn).
Feb 30 → wQsoDateDay.
April 31 → wQsoDateDay.

20 · `validate — QSO date range` (5 tests)

Checks that QSO dates fall within the TDate header range (YYYYMMDD;YYYYMMDD).

QSO date within TDate range → no wQsoDateOutOfRange.
QSO date before TDate start → wQsoDateOutOfRange (warn).
QSO date after TDate end → wQsoDateOutOfRange.
No TDate in header → no wQsoDateOutOfRange.
Invalid TDate format (not parseable) → no wQsoDateOutOfRange (range not checked).

21 · `validate — QSO RST format` (13 tests)

Checks RST fields (col 4 = RST sent, col 6 = RST received) match the expected digit count for the mode. Rules: SSB/AM/FM (modes 1/4/5/6) → 2 digits; CW/RTTY (modes 2/3/7) → 3 digits; modes 0/8/9 → check skipped. Empty RST is always allowed.

SSB mode 1 with 59 → no wQsoRstFormat.
CW mode 2 with 599 → no wQsoRstFormat.
SSB mode 1 with 599 (3 digits) → wQsoRstFormat (warn).
CW mode 2 with 59 (2 digits) → wQsoRstFormat.
FM mode 6 with 59 → no wQsoRstFormat.
RTTY mode 7 with 599 → no wQsoRstFormat.
Mode 0 (none) → no wQsoRstFormat (check skipped).
Empty RST → no wQsoRstFormat (allowed by spec).
SSB mode 4 with 59 → no wQsoRstFormat.
CW mode 3 with 599 → no wQsoRstFormat.
CW mode 3 with 59 (2 digits) → wQsoRstFormat.
AM mode 5 with 59 → no wQsoRstFormat.
AM mode 5 with 599 (3 digits) → wQsoRstFormat.

22 · `I18N` (5 tests)

Verifies i18n key completeness and translation distinctness.

sl.sevError and en.sevError are non-empty strings.
sl.sevError ≠ en.sevError (translations are distinct).
All SL keys present in EN (no orphaned SL-only translations).
All EN keys present in SL (no orphaned EN-only translations).

`edi-crosscheck.test.js` — 56 testov · 8 skupin

Pokriva čisto logiko edi-crosscheck.html: odstranjevanje pripon, razdalja urejanja, razčlenjevanje EDI in vse algoritme crosschecka, vključno z nastavljivimi pragovi in predlogi za manjkajoče lokatorje.

Kako testi delujejo

edi-crosscheck.html se izvede znotraj konteksta node:vm po enakem vzorcu kot edi2adif.html. Za razliko od tega orodja kode ne odstranjujemo — namesto tega nadomestek DOM na osnovi Proxy tiho absorbira vse dostope do lastnosti in klice metod, tako da se začetno priklapljanje poslušalcev dogodkov izvede brez napak.

Stanje na ravni modula (_histDB, _results) je const/let in zato ni dostopno kot lastnost ctx. Testi upravljajo z vsem stanjem prek deklaracij funkcij:

clearHist() — ponastavi bazo in rezultate med testi
addToHistDB(qsos) — polni zgodovinsko bazo
runCrosscheck(qsos) — izvede crosscheck in vrne polje rezultatov

Skupine testov

1 · `baseCall` (13 testov)

Preverja odstranjevanje pripon za ujemanje pri crosschecku.

Prenosne/mobilne pripone (/P, /M, /MM, /AM, /QRP, /R, /A, /B) se odstranijo z zadnjega mesta.
Italijanski regionalni sufiksi (/IV3, /I1 itd.) se odstranijo — obravnavani so enako kot /P, ker gre za isto postajo, ki oddaja iz druge regije.
Številčni sufiksi okrajev (/1, /2 itd.) se odstranijo.
Klicni znaki z predponsko poševnico (OE/S59DGO, F/ON4AAA) ostanejo nespremenjeni — predstavljajo drugačno lokacijo delovanja (predpona je državna/regionalna, ne sufiks).
Hevristika: če del pred poševnico vsebuje številko, gre za vzorec klicniZnak/sufiks in sufiks se odstrani; sicer gre za predpona/klicniZnak in se ohrani nespremenjeno.
Navadni klicni znaki nespremenjeni. Rezultat je vedno z velikimi črkami.

2 · `levenshtein` (9 testov)

Preverja funkcijo Levenshteinove razdalje z zgodnjim izhodom pri maxDist=2.

Razdalja 0 za enake nize.
Razdalja 1 za eno zamenjavo, vstavljanje ali brisanje.
Razdalja 2 za dve zamenjavi.
Vrne maxDist+1, ko razlika v dolžini sama presega maxDist (zgodnji izhod).
Pravilno obravnava prazne nize.

3 · `parseEDI` (9 testov)

Preverja ekstrakcijo QSO iz fragmenta EDI datoteke.

Datoteka z dvema zapisoma razčlenjena pravilno; klicni znaki in prenosne pripone ohranjeni.
Pas razrešen iz glave PBand in apliciran na vse QSO-je.
Lokator shranjen po konvenciji mešanih črk (JN65ar); neveljavni lokatorji počiščeni na ''.
Datum formatiran kot DD.MM.YYYY; dvo-cifreno leto razvito.
Klicni znaki ERROR preskočeni; obravnavani zaključki vrstic CRLF.

4 · `runCrosscheck — neskladje lokatorja` (6 testov)

Test	Kaj se preverja
Čisto ujemanje	Brez težave, ko se lokator ujema z zgodovinskim modusom
Visoka resnost	`LOC_MISMATCH` resnost `high`, ko zaupanje v modus ≥ 60% in nov lokator še nikoli ni bil viden
Srednja resnost	`LOC_MISMATCH` resnost `med`, ko je bil nov lokator že viden (npr. prenosna postaja)
Prag	Brez zastavice, ko ima klicni znak manj kot 3 zgodovinska pojavitev
Brez lokatorja	Ni `LOC_MISMATCH`, ko QSO nima lokatorja (`wwl = ''`) — namesto tega se lahko pojavi `LOC_MISSING`
Vrstni red allLocs	Seznam zgodovinskih lokatorjev v težavi je razvrščen po številu padajoče

5 · `runCrosscheck — preverjanje klicnega znaka` (8 testov)

Test	Kaj se preverja
CALL_SIMILAR d=1	Klicni znak ni v zgodovini; ujemanje z razdaljo 1 najdeno in razvrščeno na vrhu
CALL_UNKNOWN	Klicni znak ni v zgodovini; ni podobnega v razdalji 2
V zgodovini	Brez težave z klicnim znakom, ko bazni klicni znak obstaja v bazi
Normalizacija prenosnih	`S59ABC/P` se primerja z zgodovino `S59ABC` — brez zastavice klicnega znaka
Vrstni red	Podobni predlogi razvrščeni po razdalji naraščajoče, nato po številu padajoče
Razdalja 2	Ujemanja z razdaljo 2 so prav tako označena (`CALL_SIMILAR`)
Kombinacija težav	Neznani klicni znak ustvari samo `CALL_SIMILAR`; brez napačne LOC težave brez zgodovine
Deduplikacija	Ponavljajoči se neznani klicni znak v novem dnevniku ponovno uporabi preračunan seznam podobnih

6 · `runCrosscheck — predlog za manjkajoč lokator` (4 testa)

Test	Kaj se preverja
Predlagaj modus	`LOC_MISSING` se sproži, ko nov dnevnik nima lokatorja, a zgodovina obstaja
Srednja resnost	`LOC_MISSING` resnost `med`, ko je zaupanje v modus pod pragom
Prag	Ni `LOC_MISSING`, ko je zgodovinskih pojavitev manj kot `_minAppearances`
Prazni lokatorji v zgodovini	Ni `LOC_MISSING`, ko imajo vsi zgodovinski vnosi prazne lokatorje

7 · `runCrosscheck — nastavljivi pragovi` (3 teste)

Test	Kaj se preverja
`_minAppearances`	Ni zastavice, ko je zgodovinsko število pod pragom drsnika
`_minConfidence`	Resnost upošteva prag zaupanja drsnika (high vs med)
Prazni lokatorji prezrti	Prazni zgodovinski lokatorji ne vplivajo na izračun modusa

8 · `runCrosscheck — klicni znak po lokatorju` (4 testi)

Test	Kaj se preverja
CALL_BY_LOC osnovno	Predlaga klicne znake, ki so bili zgodovinsko videni z istega lokatorja in so v razdalji Levenshtein ≤ 2
Brez ujemanja	Ni `CALL_BY_LOC`, ko noben zgodovinski klicni znak z istega lokatorja ni v razdalji 2
Ločeno od CALL_SIMILAR	`CALL_BY_LOC` in `CALL_SIMILAR` se pojavita kot ločeni težavi v rezultatu
Redundantno soobstajanje	`CALL_BY_LOC` se sproži tudi, ko se kandidati prekrivajo s `CALL_SIMILAR` — oba signala se prikažeta kot potrjevalni dokaz

`adif-merge.test.js` — 112 testov · 21 skupin

Pokriva čisto logiko adif-merge.html: razčlenjevanje ADIF, deduplikacijo, normalizacijo polj, pomožnike za izvoz, XSS ubežanje, ubežanje CSV, popolnost i18n ključev in regresijske teste za popravke iz code reviewa.

Kako testi delujejo

adif-merge.html se izvede znotraj konteksta node:vm z enakim nadomestkom DOM na osnovi Proxy kot ostala HTML orodja. Modularni let vezani niso lastnosti ctx; ti testni pomočniki se vbrizgajo prek drugega klica vm.runInContext:

_getAllForTest() / _setAllForTest(arr) — branje in pisanje polja QSO _all
_getFilteredForTest() / _setFilteredForTest(arr) — dostop do _filtered
_getDeselForTest() — branje množice _desel
_getSourcesForTest() / _setSourcesForTest(arr) — branje in pisanje _sources
_getI18nForTest(jezik, ključ) — branje vrednosti iz i18n objekta S
_getLangKeys(jezik) — seznam vseh ključev za podan jezik

Lokalni pomočnik adif() izračuna :dolžino iz dejanske vrednosti niza vsakega polja, da fiksture testov niso krhke pri napakah v dolžini.

Skupine testov

1 · `parseADIF — basic extraction` (9 testov)

Minimalen QSO (klicni znak, datum, čas, pas, način) razčlenjen pravilno.
CALL z velikimi črkami, BAND z malimi, MODE z velikimi — ne glede na vnos.
RST_SENT, RST_RCVD in GRIDSQUARE izvlečeni v priročne lastnosti.
Polja po meri (npr. COMMENT, TX_PWR) ohranjena v slovarju q.fields.
src nastavljen na ime datoteke; zapisi brez CALL tiho preskočeni.

2 · `parseADIF — date/time normalization` (7 testov)

YYYYMMDD shranjen kot je; ISO YYYY-MM-DD oblikovan brez pomišljajev.
Normaliziran datum zapisan nazaj v q.fields.QSO_DATE.
HHMMSS in HH:MM:SS časi okrnjeni na HHMM za dedup ključ.
Prikazni nizi DD.MM.YYYY in HH:MM generirani za UI.

3 · `parseADIF — multi-record / edge cases` (9 testov)

Več zapisov v eni datoteki razčlenjenih; datoteke brez <EOH> pravilno obravnavane.
Prazni zapisi med oznakami <EOR> preskočeni; oznake neobčutljive na velikost črk.
Zaključki vrstic CRLF obravnavani; oznake APP_* ohranjene; type specifier <TAG:len:TYPE> ignoriran.
Prazen vnos vrne nič QSO-jev.

4 · `parseADIF — fields dict kept in sync` (4 testi)

Normalizacija piše nazaj v q.fields, tako da je ADIF izvoz brez izgub:

CALL v slovarju: velike + obrezano; BAND: male; MODE: velike; QSO_DATE: brez pomišljajev.

5 · `updateKey` (3 testi)

Format ključa je CALL|BAND|MODE|DATE|TIME.
Različen način ali različen pas vsak ustvarita različen ključ.

6 · `recomputeDupes` (7 testov)

Prva pojavitev → dupe=false; naslednja z enakim ključem → dupe=true.
Enak klicni znak z različnim načinom, pasom ali časom → oba dupe=false.
Tretja pojavitev enakega ključa prav tako dupe=true.
Zastarele zastavice dupe=true se počistijo pred ponovnim izračunom.

7 · `parseADIF dedup key uniqueness` (4 testi)

Integracija — ključi se pravilno prenesejo skozi parse + updateKey:

Enak QSO iz dveh datotek → enak _key.
Razlika v velikosti črk v CALL ali BAND normalizira na enak ključ.
Različen način → različen ključ (brez lažne deduplikacije).

8 · `adifField` (7 testov)

Ustvari format <OZNAKA:dolžina>vrednost (presledek na koncu po ADIF konvenciji).
Oznaka z velikimi črkami; dolžina ustreza dejanski dolžini niza.
null, undefined in '' → prazen niz (polje izpuščeno v izvozu).
Numerična vrednost 100 serializirana kot '100'.

9 · `htmlEsc` (9 testov)

&, <, >, " ubežani v HTML entitete; navadni nizi nespremenjeni.
null in undefined → ''; števila pretvorjena v niz.
XSS napad <script>alert(1)</script> prikazan varno.

10 · `csvEsc` (7 testov)

Vejica, dvojni narekovaj in nova vrstica sprožijo narekovaje; vdelani dvojni narekovaji podvojeni.
null → ''; števila pretvorjena v niz.

11 · `modeBadge` (13 testov)

SSB, AM, USB, LSB → badge-ssb; CW → badge-cw; FM → badge-fm.
FT8, FT4, RTTY, JS8, WSPR, neznan in prazen niz → badge-digi.

12 · `buildFilename` (6 testov)

STATION_CALLSIGN uporabljen, če je prisoten; MY_CALLSIGN kot nadomestilo; "merged", ko ni nobenega.
Ime vedno vsebuje "merged"; pravilna končnica dodana (.adi, .csv).
/ v klicnem znaku nadomeščen z - za varnost datotečnega sistema.

13 · `ADIF export — field preservation` (2 testa)

Polja po meri (TX_PWR, ANTENNA, NOTES, MY_GRIDSQUARE) preživijo krog parse → izvoz prek q.fields.
Obvezna polja (CALL, QSO_DATE, TIME_ON, BAND, MODE) prisotna v q.fields.

14 · `I18N` (4 testi)

Vsi SL ključi prisotni v EN in obratno.
Zahtevani UI ključi (drop cona, stat vrstica, gumbi izvoza, glave tabele, sporočila napak) prisotni v obeh jezikih.
dropTitle se razlikuje med SL in EN.

15 · `parseADIF — real-world fixtures` (4 testi)

WSJT-X FT8 dnevnik: čas HHMMSS okrnjen na HHMM, FREQ in STATION_CALLSIGN ohranjeni.
Log4OM tekmovalni vnos: RST, TX_PWR, COMMENT pravilno izvlečeni.
Merge dveh datotek: združen seznam QSO, pravilen klicni znak + pas per vir.
MedDatotečni duplikat: enak QSO v dveh datotekah → drugi označen po recomputeDupes.

16 · `parseADIF — missing optional fields` (5 testov)

Regresija — razčlenjevalnik se ne sme zrušiti, ko manjkajo neobvezna polja:

Manjkajoč BAND → band = ''; manjkajoč TIME_ON → time = '', timeDisp = ''.
Manjkajoč QSO_DATE → date = '', dateDisp = ''.
Manjkajoča RST_SENT/RST_RCVD → ''; manjkajoč GRIDSQUARE → grid = ''.

17 · `parseADIF — no submode property on QSO object` (2 testa)

Regresija — SUBMODE je bila mrtva lastnost, odstranjena iz objekta QSO med code reviewom:

submode ni lastnost razčlenjenega objekta QSO.
Oznaka SUBMODE je še vedno ohranjena v q.fields za ADIF izvoz brez izgub.

18 · `adifField — export consistency` (3 testi)

adifField je idempotentna glede na velikost črk oznake (majhne ali velike → isti izhod).
Anotacija APP_ADIFMERGE_SRC zgrajena s pravilno :dolžino iz izvorne datoteke.
Prazna vrednost → prazen izhod (polje izpuščeno, ne oddano kot <TAG:0>).

19 · `updateKey — empty band handling` (2 testa)

Dokumentira vedenje pri odsotnem band — brez zrušitve, ustvari CALL||MODE|DATE|TIME; dva takšna QSO z enakimi ostalimi polji si delita ključ (bosta deduplicirani).

20 · `I18N — errBand key` (3 testi)

Regresija — prevajalski ključ errBand dodan med code reviewom:

Ključ prisoten v SL in EN; vrednosti se razlikujeta med jezikoma.

21 · `parseADIF — re-merge safety (APP_ADIFMERGE_SRC)` (2 testa)

Regresija — ponovni merge predhodno merganega ADIF ne sme podvojiti oznake provenienc:

APP_ADIFMERGE_SRC iz prejšnjega mergea shranjen v q.fields (zgodovina ohranjena).
q.src vedno odraža ime datoteke, podano parseADIF, ne staro anotacijo — exportADIF zapiše pravilno novo oznako izvora.

Testi CLI orodja — `adif-qrz-filter.test.js`

Ločena testna zbirka pokriva Node.js CLI orodje. Tudi ta uporablja node:test brez zunanjih odvisnosti.

Testov: 48 v 4 skupinah

Zaganjanje

node --test adif-qrz-filter.test.js
node --test --test-reporter=spec adif-qrz-filter.test.js

Skupine testov

#	Skupina	Testov	Kaj se preverja
1	`parseAdif`	6	Razčlenjevanje ADIF: ekstrakcija glave, razdelitev zapisov, izvleček `QSL_VIA`, obravnava CRLF, preskočitev manjkajočega `CALL`
2	`extractField`	8	Generična ekstrakcija `<TAG:dolžina>vrednost` za `CALL`, `QSL_VIA`, neobčutljivost na velikost črk, obrezovanje, pretvorba v velike črke, ADIF type specifier (`<TAG:len:TYPE>`)
3	`usesQslBuro`	31	Fuzzy logika: 12 pozitivnih primerov (buro/bureau + evropske črkovalice: buero/büro/buerau/boureau/burea/buiro; “Direct or Bureau” pravilno vrne true), 16 negativnih primerov (no/direct only/only via LoTW/eQSL only/”QSL via KLICNI_ZNAK”), 3 robni primeri (null/prazno)
4	`cache`	3	Krog shranjevanja/nalaganja JSON predpomnilnika, čiščenje po 7 dneh, obravnava manjkajoče datoteke

Kako testi delujejo

CLI orodje se izvede znotraj konteksta node:vm, ki nadomesti fs, https, process in console. Čiste funkcije (parseAdif, extractField, usesQslBuro, loadCache, saveCache) se izvlečejo in testirajo neposredno.

Opomba o deepStrictEqual: Tako kot pri testih edi2adif.html v vm kontekstu lahko assert.deepStrictEqual na vm-ustvarjenih objektih ne uspe, čeprav so lastnosti identične. Testi predpomnilnika zato uporabljajo assert.equal na posameznih lastnostih ali Object.keys().length za preverjanje praznih objektov.

`vhf-logger/vhf-logger.test.js` — 191 testov · 17 skupin

Pokriva čisto logiko vhf-logger/vhf-logger.html: normalizacijo klicnih znakov, mapiranje pasov, geo pomožnike, zaznavanje duplikatov, preračun duplikatov, gradnjo EDI, crosscheck poizvedbe, razčlenjevanje uvoza EDI, generiranje ZIP, barve pasov, stanje ročnega časa in validacijo backup/obnovi.

Kako testi delujejo

vhf-logger/vhf-logger.html se izvede znotraj konteksta node:vm z enakim nadomestkom DOM na osnovi Proxy kot edi-crosscheck.html. Ker modularni let vezani niso lastnosti ctx, se pomožne funkcije vbrizgajo prek drugega klica vm.runInContext. Ctx izrecno prejme TextEncoder, TextDecoder, Uint8Array, DataView in ArrayBuffer za pravilno delovanje makeZip:

_setCurrentForTest(seja) — nastavi aktivno sejo za teste duplikatov
_getCurrentForTest() — prebere aktivno sejo
_getEditingExistingForTest() — prebere zastavico _editingExisting
_getI18nValueForTest(jezik, ključ) — prebere vrednost iz S objekta za i18n teste
_getManualTimeForTest() — prebere stanje _manualTime
_setManualTimeForTest(v) — nastavi _manualTime za teste stanja
_getBandColorsForTest() — vrne mapo BAND_COLORS

Skupine testov

1 · `baseCall` (10 testov)

Preverja odstranjevanje pripon, ki se uporablja pri zaznavanju duplikatov in crosscheck poizvedbah.

Pripone /P, /M, /MM, /AM, /QRP se odstranijo z zadnjega mesta.
Številčni sufiksi okrajev (/1, /2) se odstranijo.
Klicni znaki s predponsko poševnico (OE/S59DGO) ostanejo nespremenjeni (hevristika: poševnica pred delom s številko = sufiks, sicer = predpona).
Navadni klicni znaki nespremenjeni; rezultat je vedno z velikimi črkami.

2 · `normBand` (10 testov)

Preverja tabelo za mapiranje pasov.

Kanonska imena pasov se vrnejo za nize MHz (144 MHz, 432 MHz), nize valovnih dolžin (2m, 70cm) in nize GHz (1.3 GHz).
Prazen/neznan vnos vrne {band:'', freq:''}.
Beli prostor se obreže pred ujemanjem.

3 · `locToLatLon` (7 testov)

Preverja pretvorbo Maidenhead lokatorja → zemljepisna širina/dolžina.

JN65VP → pribl. lat 45,5°S, lon 13,8°V (območje Ajdovščine).
IO91wm → pribl. lat 51,3°S, lon −0,1°V (območje Londona).
Podskvadratne črke (3. par) pravilno pretvorjene.
Neveljaven vnos (napačna dolžina, napačni znaki) vrne null.
4-znakovni lokatorji vrnejo null (podprti so samo 6-znakovni).

4 · `haversine` (4 testi)

Preverja izračun razdalje po velikem krogu.

JN65VP → JN58UD ≈ 320 km (±30).
Enak lokator → razdalja 0.
Rezultat je celo število (zaokroženo navzdol).
Razdalja je simetrična.

5 · `calcBearing` (5 testov)

Preverja izračun smeri po velikem krogu.

Rezultat je v obsegu 0–359.
Rezultat je celo število.
Sever → 0, vzhod → 90, jug → 180, zahod → 270 (toleranca ±2° za odmik sredine podskvadrata).

6 · `levenshtein` (7 testov)

Preverja funkcijo Levenshteinove razdalje z zgodnjim izhodom pri maxDist=2.

Razdalja 0 za enake nize.
Razdalja 1 za eno zamenjavo, vstavljanje ali brisanje.
Vrne maxDist+1, ko razlika v dolžini sama presega maxDist (zgodnji izhod).
Pravilno obravnava prazne nize.

7 · `isDupe` (7 testov)

Preverja zaznavanje duplikatov z normalizacijo baseCall() in parametrom excludeId.

Enak klicni znak + pas → duplikat zaznan.
Enak bazni klicni znak s pripono /P → prav tako zaznan kot duplikat.
Različen pas → ni duplikat.
Parameter excludeId preprečuje lažni duplikat pri preverjanju QSO, ki se ureja.
Brez seje (_current = null) → vedno vrne false.

8 · `recalcDupes` (4 testi)

Preverja popolni preračun zastavic duplikatov v seji.

Prva pojavitev baznega klicnega znaka per pas → dupe=false; kasnejše → dupe=true.
Prenosni klicni znak s /P se normalizira v bazni — šteje kot duplikat navadnega baznega klicnega znaka.
Izolacija po pasovih: enak klicni znak na različnih pasovih oba dobita dupe=false.
Po recalcDupes je polje _current.qsos mutirano na mestu.

9 · `buildEdi` (57 testov)

Preverja izhodni format REG1TEST EDI v1.

Datoteka se začne z glavo [REG1TEST;1].
TDate uporablja polni YYYYMMDD;YYYYMMDD (začetek;konec); QSO zapisi uporabljajo YYMMDD.
Prisotne in pravilne glave TName, PCall, PWWLo, PBand, PClub, PSect, MOpe1.
Glave opreme: SPowe, SAnte, STXEq, SRXEq, SAntH izpolnjene iz konfiguracije pasu.
Blok C*: CQSOs, CQSOP, CWWLs, CWWLB, CExcs, CExcB, CDXCs, CDXCB, CToSc, CODXC — izračunani iz QSO-jev brez duplikatov.
Razdelek [QSORecords N] prisoten s pravilnim številom.
Vrstica QSO ima natanko 15 polj, ločenih s podpičji (stolpci 0–14).
Zastavica duplikata v stolpcu 14: D za podvojeni QSO, prazno za normalnega.
nrS / nrR dopolnjeni z ničlami na 3 znake.
WWL v vrstici QSO je 6 znakov z velikimi črkami.
Glava PClub izpolnjena iz session.club; prazna, ko ni nastavljena.
Načini: SSB → 1, CW → 2, FM → 6.
Nestandardne ključne besede odsotne: TCall, TLocator, RAZ, RClub se ne oddajo.
Opcijske glave: PExch, PAdr1, PAdr2, RCall, RHBBS, RPoCo, RPhon — izpolnjene iz polj seje ali oddane kot prazne vrstice.
Pravilen vrstni red polj po spec 15.3.1: TName pred TDate pred PCall; STXEq pred SPowe pred SRXEq.
Brez praznih vrstic med CODXC in [Remarks]; brez prazne vrstice med [Remarks] in [QSORecords;N].
Podnožje [END;S56OA HamLogTools VHF Logger] prisotno.

10 · `lookupCall` (6 testov)

Preverja crosscheck poizvedbo v uteženi+raw baseline bazi.

Klicni znak v baseline → found=true, modeLoc nastavljen na najpogostejši lokator.
Prenosni /P → bazni klicni znak se pravilno poišče.
Klicni znak ni v baseline → found=false, polje similar izpolnjeno iz Levenshteinove iskanja.
Seznam similar razvrščen po razdalji naraščajoče, nato po številu padajoče.
Povsem neznan klicni znak brez bližnjega ujemanja → found=false, similar=[].

11 · `sessionEdit` (10 testov)

Preverja stanje in i18n pokritost za funkcijo urejanja seje.

Zastavica _editingExisting se inicializira na false.
Štirje novi SL i18n ključi (btnEditSetup, setupEdit, btnSaveSetup, errBandHasQsos) so neprazni nizi.
Štirje novi EN i18n ključi (ista množica) so neprazni nizi.
sl.setupEdit in en.setupEdit sta različna niza (prevod obstaja).

16 · `backup` (32 testov)

Preverja strukturno validacijo validateBackup() in i18n nize za funkcijo backup/obnovi.

Veljaven backup objekt (pravilen app, polje sessions, veljavne seje in QSO-ji) vrne polje sej.
Prazno polje sessions je sprejemljivo.
Vrne null za napačno polje app, manjkajoč app, sessions ki ni polje, null ali neovit niz.
Validacija na ravni seje: vrne null, če id manjka ali je prazen, myCall manjka, bands ali qsos nista polji.
myLoc seje mora biti veljaven 6-znakovni Maidenhead lokator ([A-R]{2}[0-9]{2}[A-X]{2}, neobčutljivo na velikost); vrne null, če manjka ali je napačen.
contest seje mora biti neprazen niz; vrne null, če manjka ali je prazen niz.
Validacija na ravni QSO: vrne null, če v kateremkoli QSO manjka _id, band ali call.
sl.btnRestore ≠ en.btnRestore (obstajata različna prevoda).
sl.confirmRestore in en.confirmRestore vsebujeta ${n} placeholder.
sl.toastRestoreDone in en.toastRestoreDone vsebujeta ${n} placeholder.

17 · `I18N` (3 testi)

Preverja simetričnost i18n ključev med SL in EN prevodi.

Vsi SL ključi prisotni v EN (brez osamelih SL-only prevodov).
Vsi EN ključi prisotni v SL (brez osamelih EN-only prevodov).
SL in EN imata enako skupno število ključev.

`adif-stats.test.js` — 133 testov · 21 skupin

Pokriva čisto logiko adif-stats.html: iskanje DXCC predpon, normalizacijo pasu/načina, pretvorbo lokatorjev, izračun QRB, razčlenjevanje ADIF, agregacijo statistik, logiko filtrov, formatiranje datumov/mesecev, XSS ubežanje, pomočnike SVG grafikonov in popolnost i18n ključev.

Kako testi delujejo

adif-stats.html se izvede znotraj konteksta node:vm z enakim nadomestkom DOM kot ostala HTML orodja. Izvleče se samo blok <script>; minimalni nadomestek zagotavlja localStorage, document.getElementById, URL, Blob, setTimeout in console.

Čiste funkcije so dostopne neposredno kot lastnosti konteksta: lookupCall, normBand, normMode, locToLatLon, haversine, parseADIF, computeStats, fmtDate, fmtMonth, htmlEsc, svgHBar, svgVBar, t.

Pomočnik adif() gradi minimalne ADIF fiksture z izračunom dolžin <TAG:dolžina>vrednost.

Skupine testov

1 · `lookupCall` (17 testov)

Preverja iskanje DXCC entitete po predponi klicnega znaka v vgrajeni bazi PREFIX_DB.

S5 (Slovenija), DL (Nemčija), K (ZDA), JA (Japonska) — osnovna iskanja EU/NA/AS.
Rusija EU in AS — klicni znaki z mestom 1–8 → EU; z mestom 9 ali 0 → AS.
Pripona /P odstranjena — S59DGO/P razrešen kot S59DGO.
Oblika OE/ predpone — OE/S59DGO razrešen po predponi OE (Avstrija), ne S5.
Neznan klicni znak — vrne { country: 'Unknown', cont: '?' }.
Prazen niz — vrne Unknown.
Mali vnos — normaliziran v velike črke pred iskanjem.
DXCC preglasitve — KL (Aljaska), CU (Azori), TK (Korzika), 9H (Malta), UA2 (Kaliningrad) se razrešijo pravilno kljub deljenim predponam z večjimi entitetami.

2 · `normBand` (5 testov)

Pretvori niz pasu v male črke (2M → 2m, 40M → 40m).
Obreže okoliški beli prostor.
Prazen niz in null vrneta ''.

3 · `normMode` (5 testov)

Vrne niz načina z velikimi črkami, ko podnačin ni podan (cw → CW).
Podnačin ima prednost pred načinom, ko sta oba prisotna (DIGI + FT8 → FT8).
Oba prazna → prazen niz.

4 · `locToLatLon` (5 testov)

Pretvori 4-znakovni Maidenhead lokator v [lat, lon].
JN65 → lat 45,5, lon 13.
null in prekratek vnos vrneta null.
6-znakovni lokator da enak rezultat kot 4-znakovni (upoštevata se samo prvi 4 znaki).

5 · `haversine` (5 testov)

Enak lokator → razdalja 0.
Različna lokatorja → razdalja > 0.
Atlantska razdalja (JN65 → FN20) > 6 000 km.
Neveljaven ali null lokator → 0.

6 · `parseADIF — basic extraction` (9 testov)

CALL izvlečen; BAND z malimi; MODE z velikimi — ne glede na vnos.
SUBMODE preglasi MODE (DIGI + FT8 → način FT8).
src nastavljen na ime datoteke.
Zapisi brez CALL tiho preskočeni; več zapisov razčlenjenih; ADIF brez <EOH> pravilno obravnavan; oznake neobčutljive na velikost.

7 · `parseADIF — date/time/QRB` (8 testov)

QSO_DATE shranjen kot YYYYMMDD; ISO oblika (YYYY-MM-DD) normalizirana.
Kratek datum (< 8 znakov po normalizaciji) shranjen kot ''.
TIME_ON HHMMSS okrnjen na HHMM; HHMM ohranjen.
Polje DISTANCE → qrb ko je prisotno.
GRIDSQUARE + MY_GRIDSQUARE → qrb prek haversina ko DISTANCE manjka.
DISTANCE ima prednost pred izračunom iz koordinat.

8 · `parseADIF — country/cont` (3 testi)

Slovenija S56OA → { country: 'Slovenia', cont: 'EU' }.
JA1ZLO → { cont: 'AS' }.
Neznana predpona → { country: 'Unknown', cont: '?' }.

9 · `computeStats — overview` (7 testov)

Prazno polje → total=0, prazna množica calls.
total šteje vse QSO-je.
Množica calls šteje unikatne klicne znake (isti klicni znak dvakrat = 1).
Množica dates šteje unikatne datume.
bestDX sledi QSO z najvišjim qrb.
firstDate / lastDate sledita kronoloŠkemu razponu.
Množica countries izključuje 'Unknown'.

10 · `computeStats — aggregates` (9 testov)

byBand šteje QSO-je per pas; sledi unikatnim klicnim znakom in best DX per pas.
byMode šteje QSO-je per način.
byCont sledi unikatnim državam per kontinent.
byHour je 24-elementno polje; pravilna reža naraščena po polju time.
byMonth grupi po ključu YYYYMM.
topCalls Map razvrščen padajoče po številu.
Neznan kontinent ('?') ni dodan v byCont.

11 · `applyFilters — date filter` (6 testov)

Replicira logiko filtriranja datumskega obsega v izolaciji:

QSO s praznim datumom je izključen, ko je nastavljen from ali to.
QSO v obsegu prestane filter; pred from ali po to izključen.
Brez filtra (oba prazna) prepusti vse QSO-je vključno s tistimi brez datuma.

12 · `fmtDate` (4 testi)

'20240315' → '15.03.2024'.
Prazen niz → prazen niz.
Vnos krajši od 8 znakov vrnjen nespremenjen.

13 · `fmtMonth` (3 testi)

'202403' → '03/2024'; '202412' → '12/2024'.
Prazen niz → prazen niz.

14 · `htmlEsc` (7 testov)

&, <, >, " ubežani v HTML entitete; navadno besedilo nespremenjeno.
XSS napad prikazan varno.
Števila pretvorjena v niz.

15 · `svgHBar` (6 testov)

Prazni elementi → ni oznake <svg>.
En element → <svg> prisoten; več elementov ustvari palice <rect>.
Oznake se pojavijo v izhodu.
Nič-vrednostni element ne ustvari <rect> (preskočen z varovalko bw>0).
Povratni klic colorFn apliciran na polnilo palice.

16 · `svgVBar` (6 testov)

Prazni elementi → ni oznake <svg>.
Neprazni elementi → prisotna <svg> in <rect>.
Vse nič-vrednosti → ni elementov <rect>.
24-elementni urni grafikon se pravilno izriše s širino 580.
Kratka palica (višina < 14 px) postavi vrednostno oznako nad palico v barvi var(--muted).
Nič-vrednostna palica nima oznake vrednosti; palica brez nič ima svojo oznako.

17 · `I18N` (8 testov)

t('secOver') vrne nepraznen prevedeni niz (ne sam ključ).
Neznan ključ vrne sam niz ključa (varna rezervna vrednost).
Razdelčni ključi (secBand, secMode, secCont, secCountry, secTime, secTop) vsi vrnejo neprazne nize.
Ključi stat kartice (cTotal, cUniq, cCountries, cDays, cBestDX, cDateRange) vsi neprazni.
Novi razdelčni ključi (secDxcc, secHeatmap, secBandHour, secQrb, dxccTotal, dxccCount, dxccProg, qrbRange, qrbNoData) neprazni in se razlikujejo od imen ključev.
hmapDow ima 7 |-ločenih krajšav dni; SL prvi = Po, zadnji = Ne.
hmapMon ima 12 |-ločenih krajšav mesecev; prvi = Jan, zadnji = Dec.
hmapMore je neprazen in se razlikuje od imen ključev.

18 · `computeStats — byDay` (3 testi)

byDay Map šteje QSO-je per ključ YYYYMMDD.
QSO-ji s praznim datumom se ne dodajo v byDay.
Trije različni datumi → byDay.size === 3.

19 · `computeStats — byBandHour` (4 testi)

Vnos pasu v byBandHour je 24-elementno polje.
Pravilna urna reža naraščena per polje time ('1430' → indeks 14).
Ločena polja per pas (ni medpasovnega onesnaževanja).
QSO s praznim time → ni vnosa pasu ustvarjenega v byBandHour.

20 · `computeStats — byDxcc / byBandDxcc` (5 testov)

byDxcc šteje unikatna DXCC imena entitet; vsak vnos ima .qso in množico .bands.
Dva QSO-ja iz Nemčije → byDxcc.get('Germany').qso === 2.
Isti klicni znak na dveh pasovih → množica bands ima oba pasova.
byBandDxcc Map: množica držav per pas; pravilna velikost per pas.
Država 'Unknown' izključena iz obeh byDxcc in byBandDxcc.

21 · `computeStats — qrbBuckets` (8 testov)

qrbBuckets je 6-elementno polje (razredi 0–5).
Razred 0 (< 500 km): qrb 200 in 499 oba sem.
Razred 1 (500–1 000 km): qrb 500 in 999.
Razred 2 (1 000–2 000 km): qrb 1 000 in 1 999.
Razred 3 (2 000–5 000 km): qrb 2 000 in 4 999.
Razred 4 (5 000–10 000 km): qrb 5 000 in 9 999.
Razred 5 (≥ 10 000 km): qrb 10 000 in 15 000.
qrb === 0 ne spade v noben razred (pomeni neznano razdaljo).

`adif2cab.test.js` — 191 testov · 31 skupin

Pokriva čisto logiko adif2cab.html: preslikavo načinov Cabrillo, privzete RST, pretvorbo frekvence, razčlenjevanje ADIF, ekstrakcijo izmenjave per tekmovanje, formatiranje vrstic QSO, XSS ubežanje, pomočnike za značke, strukturo polja CONTESTS in celovitost i18n ključev.

Kako testi delujejo

adif2cab.html se izvede znotraj konteksta node:vm z enakim nadomestkom DOM na osnovi Proxy kot ostala HTML orodja. Izvleče se le blok <script>. Do čistih funkcij se dostopa neposredno kot do lastnosti konteksta.

Trije injicirani pomočniki omogočajo dostop do stanja modulne ravni (const/let):

_getContests() — vrne polje CONTESTS
_getLangKeys(lang) — seznam vseh i18n ključev za podan jezik
_getI18n(lang, key) — prebere vrednost iz i18n objekta S

Lokalni pomočnik adif() gradi testne nize ADIF s pravilnim kodiranjem <OZNAKA:dolžina>vrednost. Pomočnik makeQso() gradi minimalni objekt QSO s smiselnimi privzetimi vrednostmi.

Skupine testov

1 · `modeToCAB — phone modes → PH` (5 testov)

SSB, USB, LSB, AM → PH.
Male črke ssb normalizirane → PH.

2 · `modeToCAB — CW → CW` (2 testa)

CW (velike in male) → CW.

3 · `modeToCAB — FM-based voice → FM` (5 testov)

Cabrillo v3 specifikacija določa FM kot ločeno vrednost načina (ne PH).

FM, C4FM, DSTAR, DMR, DIGITALVOICE → FM.

4 · `modeToCAB — RTTY → RY` (2 testa)

Cabrillo v3 specifikacija določa RY za RTTY (ne splošnega DG).

RTTY (velike in male) → RY.

5 · `modeToCAB — digital modes → DG` (8 testov)

FT8, FT4, PSK31, JT65, JS8, WSPR → DG.
Prazen niz in null → DG (varni splošni primer).

6 · `dfltRST` (7 testov)

PH in FM → '59' (dvomestni RST za foničke načine).
CW, DG, RY → '599' (tromestni RST; RTTY po konvenciji tromestni).
Neznan način in prazen niz → '59' (privzeto za foniko).

7 · `freqToKHz — pretvorba polja FREQ` (6 testov)

14.210 MHz → 14210, 144.300 MHz → 144300, 432.200 MHz → 432200.
Vrednost polkHz pravilno zaokrožena.
FREQ '0' in FREQ '' padeta na BAND_KHZ.

8 · `freqToKHz — rezervna vrednost BAND_KHZ` (10 testov)

20m → 14200, 2m → 144300, 40m → 7100, 70cm → 432200, 23cm → 1296100.
6m → 50200, 4m → 70200.
Neznani pas → 0. Brez polja fields deluje brez napake.

9 · `parseADIF — osnovna ekstrakcija` (8 testov)

Minimalen QSO razčlenjen; CALL normaliziran v velike črke, BAND v male, MODE v velike.
RST_SENT → rstS, RST_RCVD → rstR; src nastavljen na ime datoteke.
Zapisi brez CALL tiho preskočeni; poljubna ADIF polja ohranjena v slovarju fields.

10 · `parseADIF — normalizacija datuma/časa` (7 testov)

YYYYMMDD shranjen nespremenjen; ISO YYYY-MM-DD brez pomišljajev.
Prikazni datum kot DD.MM.YYYY; čas HHMMSS okrajšan na HHMM, prikazan kot HH:MM.
Manjkajoči QSO_DATE ali TIME_ON → prazen niz.

11 · `parseADIF — večzapisni / robni primeri` (11 testov)

Datoteka z dvema QSO-jema razčlenjena pravilno. Datoteka brez <EOH> sprejeta.
Oznake neobčutljive na velikost; variant <OZNAKA:dol:tip> podprt.
Zaključki vrstic CRLF obdelani. STATION_CALLSIGN ohranjen v fields.
Prazna datoteka → nič QSO-jev. Ključi v fields so v velikih črkah.
STX (oddana serijska številka WPX), SRX (sprejeta) in SRX_STRING ohranjeni v fields.

12 · `extractExchR — CQ-WW-SSB` (6 testov)

CQZONE vrnjen ko je prisoten; beli prostor obrezan.
Rezervni vrstni red: CQZONE → SRX_STRING → SRX → ''.

13 · `extractExchR — CQ-WW-CW` (3 testi)

Enak prednostni vrstni red CQZONE kot pri CQ-WW-SSB.

14 · `extractExchR — IARU-HF` (6 testov)

ITUZ vrnjen ko je prisoten; beli prostor obrezan.
SRX_STRING rezerva sprejme kratice HQ (npr. DARC). Vrstni red: ITUZ → SRX_STRING → SRX.

15 · `extractExchR — ARRL-DX` (6 testov)

STATE vrnjen ko je prisoten; beli prostor obrezan. Vrstni red: STATE → SRX_STRING → SRX.

16 · `extractExchR — GENERIC` (5 testov)

SRX_STRING ima prednost pred SRX. Neznan contestId se obnaša kot GENERIC.

17 · `extractExchR — CQ-WW-RTTY` (5 testov)

Enak prednostni vrstni red CQZONE kot pri CQ-WW-SSB/CW.
Rezervni vrstni red: CQZONE → SRX_STRING → SRX → ''.

18 · `extractExchR — IARU-VHF` (7 testov)

GRIDSQUARE vrnjen in pretvorjen v velike črke (ADIF shranjuje mešano, Cabrillo pričakuje velike).
Že obstoječe velike črke ostanejo nespremenjene.
Beli prostor obrezan pred pretvorbo.
Rezervni vrednosti SRX_STRING in SRX prav tako v velikih črkah.
GRIDSQUARE ima prednost pred SRX_STRING.

19 · `extractExchR — CQ-WPX-SSB` (4 testi)

SRX_STRING vrnjen; rezerva SRX; SRX_STRING ima prednost.
Vse odsotno → ''.

20 · `extractExchR — CQ-WPX-CW` (3 testi)

Enak prednostni vrstni red SRX_STRING/SRX kot pri CQ-WPX-SSB.

21 · `formatCabDate` (7 testov)

YYYYMMDD → YYYY-MM-DD. null, undefined, prazen niz → '0000-00-00'.
Niz, ki ni 8-mestni, vrnjen nespremenjen.

22 · `buildQSOLine — struktura` (12 testov)

Vrstica se začne z QSO: in konča z ` 0` (ID oddajnika).
Način CAB, datum, čas, moj klicni znak, klicni znak partnerja so v izhodu.
HF frekvenca poravnana desno na 5 znakov (7100 → ' 7100'); ničelna → ' 0'.
VHF/UHF frekvence 7-mestno polje: 144300 → ' 144300', 432200 → ' 432200', 1296100 → '1296100'.

23 · `buildQSOLine — obdelava izmenjave` (6 testov)

Per-vrstica exchS se uporabi ko je neprazna; privzeta vrednost glave zapolni pri exchS = ''.
exchR vključen; prazna exchR ustvari zapolnjeno prazno polje brez napake.
Izmenjava zapolnjena na contest.exchW: 4 za CQ WW, 6 za IARU.

24 · `buildQSOLine — privzeti RST` (3 testi)

Prazna rstS → dfltRST(cabMode) se uporabi (59 za PH, 599 za CW).
Eksplicitna vrednost rstS prepiše privzeto.

25 · `buildQSOLine — izmenjava lokatorja IARU-VHF` (4 testi)

6-mestni lokator (JN65AR) se natanko ujema z exchW:6.
4-mestni lokator (JN65) zapolnjen na 6 z repi presledkov.
Oddani lokator (exchS) vključen v vrstico.
Prazna exchR ustvari zapolnjeno prazno polje brez napake.

26 · `buildQSOLine — per-QSO serijska številka CQ WPX` (3 testi)

Per-QSO exchS serijska številka se uporabi ko je nastavljena (npr. '001').
Serijska številka zapolnjena na exchW:6.
Pade na privzeto glave ko je exchS prazna.

27 · `htmlEsc` (9 testov)

&, <, >, " ubežani v HTML entitete. Navadni nizi nespremenjeni.
null in undefined → ''; števila pretvorjena v niz.
XSS koristna obremenitev nevtralizirana.

28 · `cabModeBadge` (6 testov)

PH → badge-ssb; CW → badge-cw; FM, DG, RY, '' → badge-digi.

29 · `modeBadge` (9 testov)

SSB, USB, LSB, AM → badge-ssb; CW → badge-cw; FM → badge-fm; FT8, RTTY, '' → badge-digi.

30 · `CONTESTS — struktura` (11 testov)

Polje vsebuje točno 9 vnosov; vsak ima zahtevana polja in exchW > 0.
exchRcvdField pravilen per tekmovanje: CQ-WW-SSB/CQ-WW-CW/CQ-WW-RTTY → CQZONE, IARU-HF → ITUZ, IARU-VHF → GRIDSQUARE, ARRL-DX → STATE, CQ-WPX-SSB/CQ-WPX-CW/GENERIC → SRX_STRING.
Vsaka oznaka ima podključa sl in en.

31 · `I18N` (4 testi)

Vsi ključi SL prisotni v EN in obratno; zahtevani ključi vmesnika preverjeni v obeh jezikih.
Vrednosti dropTitle v SL in EN sta različni (preverba, da so prevodi dejansko različni).

`edi-validator.test.js` — 109 testov · 22 skupin

Pokriva čisto logiko edi-validator.html: Maidenhead geo pomočnike in celotno funkcijo validate() za vse preverbe specifikacije in tipe težav.

Kako testi delujejo

edi-validator.html se izvede znotraj konteksta node:vm z enakim nadomestkom DOM na osnovi Proxy kot ostala HTML orodja. Funkcija validate(text) je dostopna neposredno kot lastnost konteksta in sprejme surovo besedilo EDI datoteke ter vrne {issues[], qsoCount}.

I18n objekt S (const S = {sl:{...}, en:{...}}) se izvozi prek drugega klica vm.runInContext('globalThis._S = S', ctx). V testni datoteki je definirana minimalna veljavna EDI fikstura in se uporablja kot osnova za mutacijske teste (vsak test mutira en vidik fiksture, da sproži določeno kodo težave).

Skupine testov

1 · `locToLatLon` (4 testi)

Preverja pretvorbo Maidenhead lokatorja → geografske koordinate.

JN65VP → pribl. lat 45,5°S, lon 13,8°V.
4-znakovni lokator sprejet.
Neveljaven lokator vrne null.
Mali lokator sprejet (neobčutljivo na velikost).

2 · `haversine` (2 testa)

Preverja izračun razdalje po velikem krogu.

Ista točka → razdalja 0.
JN65VP → JN78DG ≈ 294 km (±30).

3 · `validate — clean EDI` (4 testi)

Osnovna preverba z dobro oblikovano EDI fikstura.

Brez napak za veljaven EDI.
Brez opozoril za EDI z vsemi polji ZRS in vsebino v skladu s specifikacijo.
qsoCount ustreza številu QSO vrstic v [QSORecords;N].
Manjkajoč [END;...] → iNoEnd (info).

4 · `validate — structure` (6 testov)

Preverja obvezne razdelčne oznake in pravila za prazne vrstice.

Manjkajoč [REG1TEST;1] → eNoReg1test (error).
Manjkajoč [Remarks] → eNoRemarks (error).
Manjkajoč [QSORecords;N] → eNoQsoSection (error).
Prazna vrstica v razdelku glave → eBlankInHeader (error).
Prazna vrstica v razdelku [Remarks] → iBlankInRemarks (info, ne error).
Zaključki vrstic CRLF in LF sprejeti brez napak.

5 · `validate — non-spec keywords` (6 testov)

Preverja ključne besede, ki niso definirane v specifikaciji REG1TEST v1.

TCall, TLocator, RAZ, RClub, RBand → eNonSpecKw (error).
Popolnoma neznana ključna beseda → eNonSpecKw.

6 · `validate — header formats` (8 testov)

Preverja sintakso polj glave.

TDate=YYYYMMDD;YYYYMMDD — veljaven format, brez napake.
Napačen format TDate → eTDateFormat (error).
TDate en sam datum (manjka drugi del) → eTDateFormat.
PWWLo 4-znakovni lokator → wPwwloFormat (warn; prekratek za QRB izračun).
PWWLo neveljavni znaki → wPwwloFormat.
Neznana vrednost PBand → wPBandUnknown (warn).
PBand 145 MHz (znana vrednost) → brez wPBandUnknown.
Ključna beseda izven specifikacijskega vrstnega reda → iKwOrder (info).

7 · `validate — ZRS mandatory fields` (6 testov)

Preverja, da obvezna polja ZRS niso prazna.

Prazni PSect, PClub, RName, RHBBS, SPowe → vsak wFieldEmpty (warn).
Vsa obvezna polja izpolnjena → brez wFieldEmpty.

8 · `validate — QSO count` (3 testi)

Preverja deklarirano vs. dejansko število QSO.

Deklarirano število ustreza dejanskemu → brez eQsoCountMismatch.
Deklarirani 2, najdeni 1 → eQsoCountMismatch (error).
Deklarirani 0, najdeni 1 → eQsoCountMismatch.

9 · `validate — QSO field count` (3 testi)

Preverja, da ima vsak zapis QSO natanko 15 polj, ločenih s podpičji.

14 polj → eQsoFieldCount (error).
16 polj → eQsoFieldCount.
15 polj → brez eQsoFieldCount.

10 · `validate — QSO date` (6 testov)

Preverja polje datuma QSO (YYMMDD pri stolpcu 0).

Veljaven datum → brez eQsoDate.
5-mestni datum → eQsoDate (error).
Mesec 00 → eQsoDate.
Mesec 13 → eQsoDate.
Dan 00 → eQsoDate.
Neveljaven mesec → eQsoDate, a ne wQsoDateOutOfRange (preverba obsega je zatrta za strukturno neveljavne datume).

11 · `validate — QSO time` (4 testi)

Preverja polje časa QSO (HHMM pri stolpcu 1).

Veljaven čas → brez eQsoTime.
5-mestni čas → eQsoTime (error).
Ura 24 → eQsoTime.
Minuta 60 → eQsoTime.

12 · `validate — QSO mode` (5 testov)

Preverja polje načina QSO (stolpec 3, veljavne vrednosti 0–9; način 0 = “nobeden od spodaj” po spec).

Način 0 → veljaven, brez napake (vrednost po spec “nobeden od spodaj”).
Način 1 in 9 → veljaven, brez napake.
Način A (neštevilčen) → eQsoMode (error).
Način 10 (izven obsega) → eQsoMode.

13 · `validate — QSO dupe flag` (6 testov)

Preverja polje zastavice duplikata QSO (stolpec 14, veljavne vrednosti prazno ali D).

Prazno polje duplikata → brez napake.
D → brez napake.
X (neveljavna vrednost) → eQsoDupe (error).
d (mala črka) → eQsoDupe.
D z neničelnim QRB → iDupeNonZeroQrb (info; duplikati tipično poročajo QRB 0).
D z QRB 0 → brez iDupeNonZeroQrb.

14 · `validate — QSO WWL format` (4 testi)

Preverja polje lokatorja QSO (stolpec 9).

Veljaven 6-znakovni Maidenhead → brez opozorila.
Veljaven 4-znakovni Maidenhead → brez opozorila (kratki lokatorji so dovoljeni v QSO zapisih).
Prazen WWL → brez opozorila.
Neveljaven WWL (napačni znaki) → wQsoWwlFormat (warn).

15 · `validate — QRB deviation` (5 testov)

Preverja deklarirani QRB (stolpec 10) glede na haversinom izračunano razdaljo.

Deklarirani QRB znotraj 10 % izračunanega → brez wQrbDeviation.
Deklarirani QRB za >10 % drugačen → wQrbDeviation (warn).
PWWLo je 4-znakovni → QRB preverba preskočena (nezadostna natančnost lokatorja).
QSO duplikat → QRB preverba odmika preskočena.
Neštevilčni QRB → wQsoQrbNum (warn); wQrbDeviation se ne sproži.

16 · `validate — line length` (2 testa)

Preverja, da nobena vrstica ne presega 75 znakov.

Vrstica ≤75 znakov → brez wLineTooLong.
Vrstica 76 znakov → wLineTooLong (warn).

17 · `validate — non-ASCII characters` (3 testi)

Preverja znake izven 7-bitnega ASCII obsega (spec §15.3.4).

Vsebina samo z ASCII → brez wNonAscii.
Prisoten ne-ASCII znak → wNonAscii (ne eNonAscii).
Ne-ASCII → resnost je warn (ne error).

18 · `validate — duplicate keywords` (4 testi)

Preverja, da se vsaka ključna beseda glave pojavi največ enkrat.

Brez podvojenih ključnih besed → brez wDuplicateKw.
Podvojen TDate → wDuplicateKw (warn).
Podvojen PCall → wDuplicateKw.
Zmaga prva pojavitev: veljaven prvi TDate pomeni brez eTDateFormat, čeprav je ključna beseda podvojena.

19 · `validate — QSO date day` (5 testov)

Preverja, da je vrednost dneva veljavna za dani mesec in leto (z upoštevanjem prestopnih let).

Veljaven dan → brez wQsoDateDay.
1. februar v prestopnem letu → brez wQsoDateDay.
1. februar v neprestopnem letu → wQsoDateDay (warn).
1. februar → wQsoDateDay.
1. april → wQsoDateDay.

20 · `validate — QSO date range` (5 testov)

Preverja, da datumi QSO padejo znotraj obsega TDate (YYYYMMDD;YYYYMMDD) iz glave.

Datum QSO znotraj obsega TDate → brez wQsoDateOutOfRange.
Datum QSO pred začetkom TDate → wQsoDateOutOfRange (warn).
Datum QSO po koncu TDate → wQsoDateOutOfRange.
Brez TDate v glavi → brez wQsoDateOutOfRange.
Neveljaven format TDate (ni razčlenljiv) → brez wQsoDateOutOfRange (obseg ni preverjen).

21 · `validate — QSO RST format` (13 testov)

Preverja polji RST (stolpec 4 = oddani RST, stolpec 6 = sprejeti RST) glede na pričakovano število cifer za način. Pravila: SSB/AM/FM (načini 1/4/5/6) → 2 cifri; CW/RTTY (načini 2/3/7) → 3 cifre; načini 0/8/9 → preverba preskočena. Prazen RST je vedno dovoljen.

SSB način 1 z 59 → brez wQsoRstFormat.
CW način 2 z 599 → brez wQsoRstFormat.
SSB način 1 z 599 (3 cifre) → wQsoRstFormat (warn).
CW način 2 z 59 (2 cifri) → wQsoRstFormat.
FM način 6 z 59 → brez wQsoRstFormat.
RTTY način 7 z 599 → brez wQsoRstFormat.
Način 0 (nobeden) → brez wQsoRstFormat (preverba preskočena).
Prazen RST → brez wQsoRstFormat (dovoljeno po spec).
SSB način 4 z 59 → brez wQsoRstFormat.
CW način 3 z 599 → brez wQsoRstFormat.
CW način 3 z 59 (2 cifri) → wQsoRstFormat.
AM način 5 z 59 → brez wQsoRstFormat.
AM način 5 z 599 (3 cifre) → wQsoRstFormat.

22 · `I18N` (5 testov)

Preverja celovitost i18n ključev in razlikovanje prevodov.

sl.sevError in en.sevError sta neprazna niza.
sl.sevError ≠ en.sevError (prevoda sta različna).
Vsi SL ključi prisotni v EN (brez osamelih SL-only prevodov).
Vsi EN ključi prisotni v SL (brez osamelih EN-only prevodov).

Kaj ni testirano

Področje	Razlog
`handleFiles`	Zahteva asinhroni brskalniški `FileReader`; ni nadomestljiv v čistem vm kontekstu.
`finishLoad` / funkcije za posodobitev DOM	Kličejo `.style`, `.innerHTML` itd. na resničnih vozliščih DOM; smiselno le v brskalniku.
Izvozne funkcije (`exportADIF`, `exportDARC`, `exportCSV`)	Odvisne od stanja `_all`, potrditvenih polj DOM in `Blob`/`URL.createObjectURL`. Potrebni bi bili celostni brskalniški testi (npr. Playwright).
`startEdit` / `restoreCell` / `commitEdit` (DOM del)	Upravljanje z dejanskimi vozlišči TD; testabilno le z jsdom ali Playwright. Logika validacije je testirana v skupini 8.
Razvrščanje (`sortFiltered`, `setSort`)	Odvisno od stanja `_filtered`; testabilno le s celotno nastavitvijo stanja.

This site is open source. Improve this page.

HamLogTools

Testing — HamLogTools

Overview

Running the tests

How the tests work

Test groups

1 · normBand (27 tests)

2 · parseEDI (36 tests)

3 · adifField (10 tests)

4 · csvEsc (11 tests)

5 · modeBadge (8 tests)

6 · i18n (5 tests)

7 · Duplicate detection (6 tests)

8 · CSV export row format (9 tests)

9 · Inline edit — field mutation (11 tests)

What is not tested

Testiranje — HamLogTools [SL]

Pregled

Zaganjanje testov

Kako testi delujejo

Skupine testov

1 · normBand (27 testov)

2 · parseEDI (36 testov)

3 · adifField (10 testov)

4 · csvEsc (11 testov)

5 · modeBadge (8 testov)

6 · i18n (5 testov)

7 · Zaznavanje duplikatov (6 testov)

8 · Format vrstice CSV izvoza (9 testov)

9 · Urejanje v živo — mutacija polj (11 testov)

edi-crosscheck.test.js — 56 tests · 8 groups

How the tests work

Test groups

1 · baseCall (13 tests)

2 · levenshtein (9 tests)

3 · parseEDI (9 tests)

4 · runCrosscheck — locator mismatch (6 tests)

5 · runCrosscheck — callsign check (8 tests)

6 · runCrosscheck — missing locator suggestion (4 tests)

7 · runCrosscheck — configurable thresholds (3 tests)

8 · runCrosscheck — callsign by locator (4 tests)

adif-merge.test.js — 112 tests · 21 groups

How the tests work

Test groups

1 · parseADIF — basic extraction (9 tests)

2 · parseADIF — date/time normalization (7 tests)

3 · parseADIF — multi-record / edge cases (9 tests)

4 · parseADIF — fields dict kept in sync (4 tests)

5 · updateKey (3 tests)

6 · recomputeDupes (7 tests)

7 · parseADIF dedup key uniqueness (4 tests)

8 · adifField (7 tests)

9 · htmlEsc (9 tests)

10 · csvEsc (7 tests)

11 · modeBadge (13 tests)

12 · buildFilename (6 tests)

13 · ADIF export — field preservation (2 tests)

14 · I18N (4 tests)

15 · parseADIF — real-world fixtures (4 tests)

16 · parseADIF — missing optional fields (5 tests)

17 · parseADIF — no submode property on QSO object (2 tests)

18 · adifField — export consistency (3 tests)

19 · updateKey — empty band handling (2 tests)

20 · I18N — errBand key (3 tests)

21 · parseADIF — re-merge safety (APP_ADIFMERGE_SRC) (2 tests)

CLI Tool Tests — adif-qrz-filter.test.js

Running

Test groups

How the tests work

vhf-logger/vhf-logger.test.js — 191 tests · 17 groups

How the tests work

Test groups

1 · baseCall (10 tests)

2 · normBand (10 tests)

3 · locToLatLon (7 tests)

4 · haversine (4 tests)

5 · calcBearing (5 tests)

6 · levenshtein (7 tests)

7 · isDupe (7 tests)

8 · recalcDupes (4 tests)

1 · `normBand` (27 tests)

2 · `parseEDI` (36 tests)

3 · `adifField` (10 tests)

4 · `csvEsc` (11 tests)

5 · `modeBadge` (8 tests)

6 · `i18n` (5 tests)

1 · `normBand` (27 testov)

2 · `parseEDI` (36 testov)

3 · `adifField` (10 testov)

4 · `csvEsc` (11 testov)

5 · `modeBadge` (8 testov)

6 · `i18n` (5 testov)

`edi-crosscheck.test.js` — 56 tests · 8 groups

1 · `baseCall` (13 tests)

2 · `levenshtein` (9 tests)

3 · `parseEDI` (9 tests)

4 · `runCrosscheck — locator mismatch` (6 tests)

5 · `runCrosscheck — callsign check` (8 tests)

6 · `runCrosscheck — missing locator suggestion` (4 tests)

7 · `runCrosscheck — configurable thresholds` (3 tests)

8 · `runCrosscheck — callsign by locator` (4 tests)

`adif-merge.test.js` — 112 tests · 21 groups

1 · `parseADIF — basic extraction` (9 tests)

2 · `parseADIF — date/time normalization` (7 tests)

3 · `parseADIF — multi-record / edge cases` (9 tests)

4 · `parseADIF — fields dict kept in sync` (4 tests)

5 · `updateKey` (3 tests)

6 · `recomputeDupes` (7 tests)

7 · `parseADIF dedup key uniqueness` (4 tests)

8 · `adifField` (7 tests)

9 · `htmlEsc` (9 tests)

10 · `csvEsc` (7 tests)

11 · `modeBadge` (13 tests)

12 · `buildFilename` (6 tests)

13 · `ADIF export — field preservation` (2 tests)

14 · `I18N` (4 tests)

15 · `parseADIF — real-world fixtures` (4 tests)

16 · `parseADIF — missing optional fields` (5 tests)

17 · `parseADIF — no submode property on QSO object` (2 tests)

18 · `adifField — export consistency` (3 tests)

19 · `updateKey — empty band handling` (2 tests)

20 · `I18N — errBand key` (3 tests)

21 · `parseADIF — re-merge safety (APP_ADIFMERGE_SRC)` (2 tests)

CLI Tool Tests — `adif-qrz-filter.test.js`

`vhf-logger/vhf-logger.test.js` — 191 tests · 17 groups

1 · `baseCall` (10 tests)

2 · `normBand` (10 tests)

3 · `locToLatLon` (7 tests)

4 · `haversine` (4 tests)

5 · `calcBearing` (5 tests)

6 · `levenshtein` (7 tests)

7 · `isDupe` (7 tests)

8 · `recalcDupes` (4 tests)

9 · `buildEdi` (57 tests)

10 · `lookupCall` (6 tests)

11 · `sessionEdit` (10 tests)

12 · `parseEdiForImport` (10 tests)

13 · `makeZip` (5 tests)

14 · `bandColors` (4 tests)

15 · `manualTime` (7 tests)

16 · `backup` (32 tests)

17 · `I18N` (3 tests)

`adif-stats.test.js` — 133 tests · 21 groups

1 · `lookupCall` (17 tests)

2 · `normBand` (5 tests)

3 · `normMode` (5 tests)

4 · `locToLatLon` (5 tests)

5 · `haversine` (5 tests)

6 · `parseADIF — basic extraction` (9 tests)

7 · `parseADIF — date/time/QRB` (8 tests)

8 · `parseADIF — country/cont` (3 tests)

9 · `computeStats — overview` (7 tests)

10 · `computeStats — aggregates` (9 tests)

11 · `applyFilters — date filter` (6 tests)

12 · `fmtDate` (4 tests)

13 · `fmtMonth` (3 tests)

14 · `htmlEsc` (7 tests)

15 · `svgHBar` (6 tests)

16 · `svgVBar` (6 tests)

17 · `I18N` (8 tests)