test: cover pure-logic gaps found by the coverage audit

I ran make coverage and worked the report function by function, separating real gaps from interactive/IO wrappers that aren't unit-test targets. These tests fill the genuine pure-logic holes: predicates, parsers, formatters, transforms, and three modules that had no test file at all.

New files cover car-member (local-repository), show-kill-insert-item (show-kill-ring), the oauth2-auto plstore cache fix (auth-config), the coverage-core project-root fallback, reconcile--dirty-p, and the recurrence-frequency dispatch in calendar-sync. Extended files add the missing branches: coverage-core's merge-base and diff /dev/null handling plus the staged and branch-vs-main scopes, the detect-system-timezone symlink path, user-constants no-op and optional-failure branches, the elfeed playlist branch with HTML-entity decoding, the duplicate-line no-comment-syntax guard, and several calendar-sync edges (exception field overrides, timestamp seconds and TZID fallback, property-line position advancement, parse-ics nil and out-of-range inputs).

Mocks sit at the real boundaries (plstore, url-retrieve, process-file, git) so each function's own logic runs. Dates come from relative helpers. About 65 tests added across 15 files, and the full suite stays green.

15 files changed, 751 insertions, 0 deletions

diff --git a/tests/test-auth-config--plstore-read-fixed.el b/tests/test-auth-config--plstore-read-fixed.el
new file mode 100644
index 000000000..4b14a4a0c
--- /dev/null
+++ b/tests/test-auth-config--plstore-read-fixed.el
@@ -0,0 +1,101 @@
+;;; test-auth-config--plstore-read-fixed.el --- Tests for the oauth2-auto cache fix -*- lexical-binding: t -*-
+
+;;; Commentary:
+;; Tests for `cj/oauth2-auto--plstore-read-fixed' in auth-config.el — the
+;; advice that re-enables oauth2-auto's plstore cache.  oauth2-auto is not
+;; installed here, so its symbols and the plstore I/O are stubbed at the
+;; boundary; the function's own logic (cache-first read, puthash, the
+;; unwind-protect close) runs for real.  `require' is stubbed to no-op only
+;; for oauth2-auto (other requires delegate through), satisfying the
+;; function's `(require 'oauth2-auto)' without loading or provide-ing the
+;; package (a provide would fire auth-config's advice-add side effect).
+
+;;; Code:
+
+(require 'ert)
+(require 'cl-lib)
+(require 'plstore)
+(require 'auth-config)
+
+;; Declared special so the function (which reads these as free package
+;; globals) sees the dynamic let-bindings the tests establish.
+(defvar oauth2-auto--plstore-cache nil)
+(defvar oauth2-auto-plstore nil)
+
+(defvar test-auth--open-count 0 "Times plstore-open was called in a test.")
+(defvar test-auth--closed nil "Whether plstore-close ran in a test.")
+(defvar test-auth--get-fn nil "Stub behavior for plstore-get: (lambda (ps id) ...).")
+
+(defmacro test-auth--with-env (&rest body)
+  "Run BODY with a faked oauth2-auto + plstore environment.
+Resets the open counter and closed flag and gives a fresh cache each time."
+  (declare (indent 0))
+  `(let* ((oauth2-auto--plstore-cache (make-hash-table :test 'equal))
+          (oauth2-auto-plstore "/tmp/oauth2-test.plist")
+          (test-auth--open-count 0)
+          (test-auth--closed nil)
+          (orig-require (symbol-function 'require)))
+     (cl-letf (((symbol-function 'require)
+                (lambda (feat &rest args)
+                  (if (eq feat 'oauth2-auto)
+                      'oauth2-auto
+                    (apply orig-require feat args))))
+               ((symbol-function 'oauth2-auto--compute-id)
+                (lambda (_u _p) "ID"))
+               ((symbol-function 'plstore-open)
+                (lambda (_f) (cl-incf test-auth--open-count) 'PS))
+               ((symbol-function 'plstore-get)
+                (lambda (ps id) (funcall test-auth--get-fn ps id)))
+               ((symbol-function 'plstore-close)
+                (lambda (_p) (setq test-auth--closed t))))
+       ,@body)))
+
+;;; Normal Cases
+
+(ert-deftest test-auth-config-plstore-read-fixed-cache-hit ()
+  "Normal: a cache hit returns the cached value without opening the plstore."
+  (let ((test-auth--get-fn (lambda (_ps _id) (error "should not read"))))
+    (test-auth--with-env
+      (puthash "ID" "CACHED" oauth2-auto--plstore-cache)
+      (should (equal (cj/oauth2-auto--plstore-read-fixed "u" "p") "CACHED"))
+      (should (= test-auth--open-count 0)))))
+
+(ert-deftest test-auth-config-plstore-read-fixed-cache-miss-reads-and-caches ()
+  "Normal: a miss reads from the plstore, caches the value, and closes."
+  (let ((test-auth--get-fn (lambda (_ps id) (cons id "TOK"))))
+    (test-auth--with-env
+      (should (equal (cj/oauth2-auto--plstore-read-fixed "u" "p") "TOK"))
+      (should (equal (gethash "ID" oauth2-auto--plstore-cache) "TOK"))
+      (should (= test-auth--open-count 1))
+      (should test-auth--closed))))
+
+;;; Boundary Cases
+
+(ert-deftest test-auth-config-plstore-read-fixed-value-cached-after-first-read ()
+  "Boundary: a non-nil value is cached, so a second call does not re-open."
+  (let ((test-auth--get-fn (lambda (_ps id) (cons id "TOK"))))
+    (test-auth--with-env
+      (cj/oauth2-auto--plstore-read-fixed "u" "p")
+      (cj/oauth2-auto--plstore-read-fixed "u" "p")
+      (should (= test-auth--open-count 1)))))
+
+(ert-deftest test-auth-config-plstore-read-fixed-nil-value-rereads ()
+  "Boundary: a nil value caches nil, so every call re-opens the plstore.
+This documents current behavior — `gethash' on a nil entry is a miss."
+  (let ((test-auth--get-fn (lambda (_ps _id) (cons "ID" nil))))
+    (test-auth--with-env
+      (should-not (cj/oauth2-auto--plstore-read-fixed "u" "p"))
+      (should-not (cj/oauth2-auto--plstore-read-fixed "u" "p"))
+      (should (= test-auth--open-count 2)))))
+
+;;; Error Cases
+
+(ert-deftest test-auth-config-plstore-read-fixed-closes-on-error ()
+  "Error: a read failure still closes the plstore via unwind-protect."
+  (let ((test-auth--get-fn (lambda (&rest _) (error "boom"))))
+    (test-auth--with-env
+      (should-error (cj/oauth2-auto--plstore-read-fixed "u" "p"))
+      (should test-auth--closed))))
+
+(provide 'test-auth-config--plstore-read-fixed)
+;;; test-auth-config--plstore-read-fixed.el ends here
diff --git a/tests/test-calendar-sync--apply-single-exception.el b/tests/test-calendar-sync--apply-single-exception.el
index 2fcf7c718..3d2342708 100644
--- a/tests/test-calendar-sync--apply-single-exception.el
+++ b/tests/test-calendar-sync--apply-single-exception.el
@@ -63,5 +63,47 @@
     (let ((result (calendar-sync--apply-single-exception occ exc)))
       (should (equal "Keep" (plist-get result :summary))))))
 
+;;; Normal Cases — remaining overridable fields
+
+(ert-deftest test-calendar-sync--apply-single-exception-overrides-description ()
+  "Normal: an exception :description overrides the occurrence's."
+  (let ((occ (list :start '(2026 3 15 14 0) :description "old"))
+        (exc (list :start '(2026 3 15 14 0) :description "new")))
+    (should (equal "new"
+                   (plist-get (calendar-sync--apply-single-exception occ exc)
+                              :description)))))
+
+(ert-deftest test-calendar-sync--apply-single-exception-overrides-location ()
+  "Normal: an exception :location overrides the occurrence's."
+  (let ((occ (list :start '(2026 3 15 14 0) :location "Room A"))
+        (exc (list :start '(2026 3 15 14 0) :location "Room B")))
+    (should (equal "Room B"
+                   (plist-get (calendar-sync--apply-single-exception occ exc)
+                              :location)))))
+
+(ert-deftest test-calendar-sync--apply-single-exception-overrides-attendees ()
+  "Normal: an exception :attendees overrides the occurrence's."
+  (let ((occ (list :start '(2026 3 15 14 0) :attendees '("a")))
+        (exc (list :start '(2026 3 15 14 0) :attendees '("b" "c"))))
+    (should (equal '("b" "c")
+                   (plist-get (calendar-sync--apply-single-exception occ exc)
+                              :attendees)))))
+
+(ert-deftest test-calendar-sync--apply-single-exception-overrides-organizer ()
+  "Normal: an exception :organizer overrides the occurrence's."
+  (let ((occ (list :start '(2026 3 15 14 0) :organizer "old@x"))
+        (exc (list :start '(2026 3 15 14 0) :organizer "new@x")))
+    (should (equal "new@x"
+                   (plist-get (calendar-sync--apply-single-exception occ exc)
+                              :organizer)))))
+
+(ert-deftest test-calendar-sync--apply-single-exception-overrides-url ()
+  "Normal: an exception :url overrides the occurrence's."
+  (let ((occ (list :start '(2026 3 15 14 0) :url "http://old"))
+        (exc (list :start '(2026 3 15 14 0) :url "http://new")))
+    (should (equal "http://new"
+                   (plist-get (calendar-sync--apply-single-exception occ exc)
+                              :url)))))
+
 (provide 'test-calendar-sync--apply-single-exception)
 ;;; test-calendar-sync--apply-single-exception.el ends here
diff --git a/tests/test-calendar-sync--expand-recurring-event.el b/tests/test-calendar-sync--expand-recurring-event.el
new file mode 100644
index 000000000..41f0afa9c
--- /dev/null
+++ b/tests/test-calendar-sync--expand-recurring-event.el
@@ -0,0 +1,106 @@
+;;; test-calendar-sync--expand-recurring-event.el --- Tests for recurrence dispatch -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Tests for calendar-sync--expand-recurring-event — the dispatcher that maps
+;; an RRULE frequency to the matching expander and applies EXDATE filtering.
+;; The individual expanders, parser, and exdate helpers have their own tests;
+;; here they are stubbed at the boundary so only the dispatch and the
+;; exdate-vs-no-exdate branch are exercised.
+
+;;; Code:
+
+(require 'ert)
+(require 'cl-lib)
+(require 'testutil-calendar-sync)
+(require 'calendar-sync)
+
+(defmacro test-cs-ere--with (overrides &rest body)
+  "Run BODY with the recurrence helpers stubbed.
+OVERRIDES is an extra list of cl-letf* bindings layered on the defaults:
+RRULE present, parse-event returns 'BASE, no exdates, and every expander
+errors if called (each test re-binds the one it expects).  cl-letf* is
+sequential, so a re-bound place in OVERRIDES wins over the default."
+  (declare (indent 1))
+  `(cl-letf* (((symbol-function 'calendar-sync--get-property)
+              (lambda (_e prop) (when (string= prop "RRULE") "R")))
+             ((symbol-function 'calendar-sync--parse-event) (lambda (_e) 'BASE))
+             ((symbol-function 'calendar-sync--collect-exdates) (lambda (_e) nil))
+             ((symbol-function 'calendar-sync--expand-daily)
+              (lambda (&rest _) (error "daily should not be called")))
+             ((symbol-function 'calendar-sync--expand-weekly)
+              (lambda (&rest _) (error "weekly should not be called")))
+             ((symbol-function 'calendar-sync--expand-monthly)
+              (lambda (&rest _) (error "monthly should not be called")))
+             ((symbol-function 'calendar-sync--expand-yearly)
+              (lambda (&rest _) (error "yearly should not be called")))
+             ((symbol-function 'calendar-sync--filter-exdates)
+              (lambda (&rest _) (error "filter-exdates should not be called")))
+             ,@overrides)
+     ,@body))
+
+;;; Normal Cases — frequency dispatch
+
+(ert-deftest test-calendar-sync--expand-recurring-event-dispatches-daily ()
+  "Normal: FREQ=DAILY routes to the daily expander."
+  (test-cs-ere--with
+      (((symbol-function 'calendar-sync--parse-rrule) (lambda (_r) '(:freq daily)))
+       ((symbol-function 'calendar-sync--expand-daily) (lambda (&rest _) '(DAILY))))
+    (should (equal (calendar-sync--expand-recurring-event "evt" 'range) '(DAILY)))))
+
+(ert-deftest test-calendar-sync--expand-recurring-event-dispatches-monthly ()
+  "Normal: FREQ=MONTHLY routes to the monthly expander."
+  (test-cs-ere--with
+      (((symbol-function 'calendar-sync--parse-rrule) (lambda (_r) '(:freq monthly)))
+       ((symbol-function 'calendar-sync--expand-monthly) (lambda (&rest _) '(MONTHLY))))
+    (should (equal (calendar-sync--expand-recurring-event "evt" 'range) '(MONTHLY)))))
+
+(ert-deftest test-calendar-sync--expand-recurring-event-dispatches-yearly ()
+  "Normal: FREQ=YEARLY routes to the yearly expander."
+  (test-cs-ere--with
+      (((symbol-function 'calendar-sync--parse-rrule) (lambda (_r) '(:freq yearly)))
+       ((symbol-function 'calendar-sync--expand-yearly) (lambda (&rest _) '(YEARLY))))
+    (should (equal (calendar-sync--expand-recurring-event "evt" 'range) '(YEARLY)))))
+
+;;; Boundary / Error Cases
+
+(ert-deftest test-calendar-sync--expand-recurring-event-unsupported-freq-nil ()
+  "Error: an unsupported frequency expands to nil, no expander called."
+  (test-cs-ere--with
+      (((symbol-function 'calendar-sync--parse-rrule) (lambda (_r) '(:freq hourly))))
+    (should-not (calendar-sync--expand-recurring-event "evt" 'range))))
+
+(ert-deftest test-calendar-sync--expand-recurring-event-no-rrule-nil ()
+  "Boundary: an event with no RRULE returns nil (not a recurring event)."
+  (test-cs-ere--with
+      (((symbol-function 'calendar-sync--get-property) (lambda (&rest _) nil)))
+    (should-not (calendar-sync--expand-recurring-event "evt" 'range))))
+
+(ert-deftest test-calendar-sync--expand-recurring-event-unparseable-base-nil ()
+  "Boundary: when the base event fails to parse, expansion returns nil."
+  (test-cs-ere--with
+      (((symbol-function 'calendar-sync--parse-rrule) (lambda (_r) '(:freq daily)))
+       ((symbol-function 'calendar-sync--parse-event) (lambda (_e) nil)))
+    (should-not (calendar-sync--expand-recurring-event "evt" 'range))))
+
+;;; EXDATE branch
+
+(ert-deftest test-calendar-sync--expand-recurring-event-applies-exdate-filter ()
+  "Normal: with exdates present, occurrences pass through the exdate filter."
+  (test-cs-ere--with
+      (((symbol-function 'calendar-sync--parse-rrule) (lambda (_r) '(:freq daily)))
+       ((symbol-function 'calendar-sync--expand-daily) (lambda (&rest _) '(O1 O2)))
+       ((symbol-function 'calendar-sync--collect-exdates) (lambda (_e) '(EX)))
+       ((symbol-function 'calendar-sync--filter-exdates)
+        (lambda (occs _ex) (remq 'O2 occs))))
+    (should (equal (calendar-sync--expand-recurring-event "evt" 'range) '(O1)))))
+
+(ert-deftest test-calendar-sync--expand-recurring-event-no-exdate-skips-filter ()
+  "Boundary: with no exdates, the filter is skipped and occurrences pass through."
+  (test-cs-ere--with
+      (((symbol-function 'calendar-sync--parse-rrule) (lambda (_r) '(:freq daily)))
+       ((symbol-function 'calendar-sync--expand-daily) (lambda (&rest _) '(O1 O2))))
+    ;; filter-exdates stays the error stub; it must not be called here
+    (should (equal (calendar-sync--expand-recurring-event "evt" 'range) '(O1 O2)))))
+
+(provide 'test-calendar-sync--expand-recurring-event)
+;;; test-calendar-sync--expand-recurring-event.el ends here
diff --git a/tests/test-calendar-sync--get-all-property-lines.el b/tests/test-calendar-sync--get-all-property-lines.el
index c95041c9a..737d2af0d 100644
--- a/tests/test-calendar-sync--get-all-property-lines.el
+++ b/tests/test-calendar-sync--get-all-property-lines.el
@@ -57,5 +57,23 @@
   "Test empty event string returns nil."
   (should (null (calendar-sync--get-all-property-lines "" "ATTENDEE"))))
 
+;;; Boundary Cases — position advancement
+
+(ert-deftest test-calendar-sync--get-all-property-lines-property-at-end-no-newline ()
+  "Boundary: a match at end of string with no trailing newline still returns it.
+Exercises the end-equals-length branch of position advancement."
+  (let ((result (calendar-sync--get-all-property-lines
+                 "ATTENDEE:foo@example.com" "ATTENDEE")))
+    (should (= 1 (length result)))
+    (should (string-match-p "foo@example.com" (car result)))))
+
+(ert-deftest test-calendar-sync--get-all-property-lines-second-match-after-continuation ()
+  "Boundary: a first match with a continuation does not hide the second match."
+  (let ((result (calendar-sync--get-all-property-lines
+                 "ATTENDEE:a\n more\nATTENDEE:b\nSUMMARY:x" "ATTENDEE")))
+    (should (= 2 (length result)))
+    (should (string-match-p "more" (nth 0 result)))
+    (should (string-match-p "ATTENDEE:b" (nth 1 result)))))
+
 (provide 'test-calendar-sync--get-all-property-lines)
 ;;; test-calendar-sync--get-all-property-lines.el ends here
diff --git a/tests/test-calendar-sync--parse-timestamp.el b/tests/test-calendar-sync--parse-timestamp.el
index d05540f7c..6a56ba9e2 100644
--- a/tests/test-calendar-sync--parse-timestamp.el
+++ b/tests/test-calendar-sync--parse-timestamp.el
@@ -55,5 +55,28 @@
   "Truncated datetime returns nil."
   (should (null (calendar-sync--parse-timestamp "2026031"))))
 
+;;; Boundary / Error — second capture, TZID fallback, leap day
+
+(ert-deftest test-calendar-sync--parse-timestamp-utc-passes-nonzero-seconds ()
+  "Boundary: the seconds field is captured and passed to the UTC converter."
+  (cl-letf (((symbol-function 'calendar-sync--convert-utc-to-local)
+             (lambda (y mo d h mi s) (list 'utc y mo d h mi s))))
+    (should (equal (calendar-sync--parse-timestamp "20260315T180045Z")
+                   '(utc 2026 3 15 18 0 45)))))
+
+(ert-deftest test-calendar-sync--parse-timestamp-tzid-fallback-on-failure ()
+  "Error: when TZID conversion fails, the raw 5-tuple is returned."
+  (cl-letf (((symbol-function 'calendar-sync--convert-tz-to-local)
+             (lambda (&rest _) nil)))
+    (should (equal (calendar-sync--parse-timestamp "20260315T180000" "Fake/Zone")
+                   '(2026 3 15 18 0)))))
+
+(ert-deftest test-calendar-sync--parse-timestamp-leap-day-components ()
+  "Boundary: a valid leap day (2024-02-29) is parsed into its components."
+  (cl-letf (((symbol-function 'calendar-sync--convert-utc-to-local)
+             (lambda (y mo d h mi s) (list y mo d h mi s))))
+    (should (equal (calendar-sync--parse-timestamp "20240229T120000Z")
+                   '(2024 2 29 12 0 0)))))
+
 (provide 'test-calendar-sync--parse-timestamp)
 ;;; test-calendar-sync--parse-timestamp.el ends here
diff --git a/tests/test-calendar-sync.el b/tests/test-calendar-sync.el
index b912c1328..62b00aba1 100644
--- a/tests/test-calendar-sync.el
+++ b/tests/test-calendar-sync.el
@@ -693,5 +693,22 @@ Valid events should be parsed, invalid ones skipped."
       (should retrieved)
       (should (eq 'ok (plist-get retrieved :status))))))
 
+;;; Tests: calendar-sync--parse-ics — boundary inputs
+
+(ert-deftest test-calendar-sync--parse-ics-nil-content-returns-nil ()
+  "Boundary: nil ICS content is handled gracefully and returns nil."
+  (should (null (calendar-sync--parse-ics nil))))
+
+(ert-deftest test-calendar-sync--parse-ics-drops-out-of-range-event ()
+  "Boundary: a non-recurring event outside the date range is dropped."
+  (let* ((far (test-calendar-sync-make-vevent
+               "OutOfRangeEvent"
+               (test-calendar-sync-time-days-from-now 3650 10 0)
+               (test-calendar-sync-time-days-from-now 3650 11 0)))
+         (ics (test-calendar-sync-make-ics far))
+         (org-content (calendar-sync--parse-ics ics)))
+    (should-not (and org-content
+                     (string-match-p "OutOfRangeEvent" org-content)))))
+
 (provide 'test-calendar-sync)
 ;;; test-calendar-sync.el ends here
diff --git a/tests/test-coverage-core--changed-lines.el b/tests/test-coverage-core--changed-lines.el
index f271fde15..0662594b4 100644
--- a/tests/test-coverage-core--changed-lines.el
+++ b/tests/test-coverage-core--changed-lines.el
@@ -227,5 +227,106 @@ Binary files a/image.png and b/image.png differ
   (should-error (cj/--coverage-changed-lines 'bogus-scope)
                 :type 'user-error))
 
+;;; Boundary cases — parser, /dev/null and orphan hunks
+
+(ert-deftest test-coverage-parse-diff-dev-null-resets-current-file ()
+  "Boundary: a \"+++ /dev/null\" target resets state so a following hunk is
+not misattributed to the previous file."
+  (let* ((input (concat "diff --git a/keep.el b/keep.el\n"
+                        "--- a/keep.el\n"
+                        "+++ b/keep.el\n"
+                        "@@ -1,0 +1,2 @@\n"
+                        "+k1\n+k2\n"
+                        "diff --git a/gone.el b/gone.el\n"
+                        "--- a/gone.el\n"
+                        "+++ /dev/null\n"
+                        "@@ -1,0 +5,2 @@\n"
+                        "+orphan1\n+orphan2\n"))
+         (result (cj/--coverage-parse-diff-output input))
+         (keep (gethash "keep.el" result)))
+    (should (= 1 (hash-table-count result)))   ; gone.el never recorded
+    (should (= 2 (hash-table-count keep)))
+    (should (gethash 1 keep))
+    (should (gethash 2 keep))
+    (should-not (gethash 5 keep))              ; not misattributed
+    (should-not (gethash 6 keep))))
+
+(ert-deftest test-coverage-parse-diff-hunk-before-any-file-marker ()
+  "Boundary: a hunk header before any file marker is ignored, not crashed on."
+  (let* ((input (concat "@@ -1,0 +1,2 @@\n"
+                        "+orphan1\n+orphan2\n"
+                        "diff --git a/real.el b/real.el\n"
+                        "--- a/real.el\n"
+                        "+++ b/real.el\n"
+                        "@@ -1,0 +1,1 @@\n"
+                        "+r1\n"))
+         (result (cj/--coverage-parse-diff-output input))
+         (real (gethash "real.el" result)))
+    (should (= 1 (hash-table-count result)))
+    (should (= 1 (hash-table-count real)))
+    (should (gethash 1 real))))
+
+;;; merge-base (stubbed git invocation)
+
+(ert-deftest test-coverage-git-merge-base-returns-trimmed-sha ()
+  "Normal: a SHA with trailing newline is trimmed and returned."
+  (cl-letf (((symbol-function 'process-file)
+             (lambda (_program _infile destination _display &rest _args)
+               (with-current-buffer destination (insert "abc123\n"))
+               0)))
+    (should (equal (cj/--coverage-git-merge-base "main") "abc123"))))
+
+(ert-deftest test-coverage-git-merge-base-empty-output-errors ()
+  "Error: empty merge-base output signals user-error (no common commit)."
+  (cl-letf (((symbol-function 'process-file)
+             (lambda (_program _infile destination _display &rest _args)
+               (with-current-buffer destination (insert ""))
+               0)))
+    (should-error (cj/--coverage-git-merge-base "main") :type 'user-error)))
+
+(ert-deftest test-coverage-git-merge-base-whitespace-output-errors ()
+  "Error: whitespace-only output trims to empty and signals user-error."
+  (cl-letf (((symbol-function 'process-file)
+             (lambda (_program _infile destination _display &rest _args)
+               (with-current-buffer destination (insert "   \n"))
+               0)))
+    (should-error (cj/--coverage-git-merge-base "main") :type 'user-error)))
+
+;;; changed-lines — remaining scopes (stubbed git invocation)
+
+(ert-deftest test-coverage-changed-lines-staged-stubbed ()
+  "Normal: staged scope invokes git diff --cached via argv."
+  (let (seen-calls)
+    (cl-letf (((symbol-function 'process-file)
+               (lambda (program _infile destination _display &rest args)
+                 (push (cons program args) seen-calls)
+                 (with-current-buffer destination
+                   (insert test-coverage-diff--simple-single-file))
+                 0)))
+      (let ((result (cj/--coverage-changed-lines 'staged)))
+        (should (equal (nreverse seen-calls)
+                       '(("git" "diff" "--cached" "--unified=0"))))
+        (should (= 3 (hash-table-count (gethash "foo.el" result))))))))
+
+(ert-deftest test-coverage-changed-lines-branch-vs-main-stubbed ()
+  "Normal: branch-vs-main computes merge-base against main, then diffs."
+  (let (seen-calls)
+    (cl-letf (((symbol-function 'process-file)
+               (lambda (program _infile destination _display &rest args)
+                 (push (cons program args) seen-calls)
+                 (with-current-buffer destination
+                   (insert
+                    (pcase args
+                      (`("merge-base" "HEAD" "main") "abc123\n")
+                      (`("diff" "abc123..HEAD" "--unified=0")
+                       test-coverage-diff--simple-single-file)
+                      (_ ""))))
+                 0)))
+      (let ((result (cj/--coverage-changed-lines 'branch-vs-main)))
+        (should (equal (nreverse seen-calls)
+                       '(("git" "merge-base" "HEAD" "main")
+                         ("git" "diff" "abc123..HEAD" "--unified=0"))))
+        (should (= 3 (hash-table-count (gethash "foo.el" result))))))))
+
 (provide 'test-coverage-core--changed-lines)
 ;;; test-coverage-core--changed-lines.el ends here
diff --git a/tests/test-coverage-core--project-root.el b/tests/test-coverage-core--project-root.el
new file mode 100644
index 000000000..9d596217a
--- /dev/null
+++ b/tests/test-coverage-core--project-root.el
@@ -0,0 +1,37 @@
+;;; test-coverage-core--project-root.el --- Tests for cj/--coverage-project-root -*- lexical-binding: t -*-
+
+;;; Commentary:
+;; Tests for `cj/--coverage-project-root' in coverage-core.el — returns the
+;; projectile project root when available, else `default-directory'.
+
+;;; Code:
+
+(require 'ert)
+(require 'cl-lib)
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'coverage-core)
+
+;;; Normal Cases
+
+(ert-deftest test-coverage-project-root-uses-projectile-when-available ()
+  "Normal: with projectile available and in a project, returns its root."
+  (cl-letf (((symbol-function 'projectile-project-root)
+             (lambda () "/home/u/proj/")))
+    (should (equal (cj/--coverage-project-root) "/home/u/proj/"))))
+
+;;; Boundary Cases
+
+(ert-deftest test-coverage-project-root-falls-back-when-projectile-absent ()
+  "Boundary: with no projectile function, falls back to default-directory."
+  (cl-letf (((symbol-function 'projectile-project-root) nil))
+    (let ((default-directory "/fallback/dir/"))
+      (should (equal (cj/--coverage-project-root) "/fallback/dir/")))))
+
+(ert-deftest test-coverage-project-root-falls-back-when-not-in-project ()
+  "Boundary: projectile present but returns nil (not in a project) falls back."
+  (cl-letf (((symbol-function 'projectile-project-root) (lambda () nil)))
+    (let ((default-directory "/fallback/dir/"))
+      (should (equal (cj/--coverage-project-root) "/fallback/dir/")))))
+
+(provide 'test-coverage-core--project-root)
+;;; test-coverage-core--project-root.el ends here
diff --git a/tests/test-custom-line-paragraph-duplicate-line-or-region.el b/tests/test-custom-line-paragraph-duplicate-line-or-region.el
index bd82e00fa..84f5bc2df 100644
--- a/tests/test-custom-line-paragraph-duplicate-line-or-region.el
+++ b/tests/test-custom-line-paragraph-duplicate-line-or-region.el
@@ -447,5 +447,19 @@
         (should (string-match-p "line\u000Cwith\u000Dcontrol\nline\u000Cwith\u000Dcontrol" (buffer-string))))
     (test-duplicate-line-or-region-teardown)))
 
+;;; Error Cases
+
+(ert-deftest test-duplicate-line-or-region-comment-without-syntax-errors ()
+  "Error: requesting a comment in a mode with no comment syntax signals
+user-error rather than producing malformed output."
+  (test-duplicate-line-or-region-setup)
+  (unwind-protect
+      (with-temp-buffer
+        (fundamental-mode)  ; no comment-start defined
+        (insert "line one")
+        (goto-char (point-min))
+        (should-error (cj/duplicate-line-or-region t) :type 'user-error))
+    (test-duplicate-line-or-region-teardown)))
+
 (provide 'test-custom-line-paragraph-duplicate-line-or-region)
 ;;; test-custom-line-paragraph-duplicate-line-or-region.el ends here
diff --git a/tests/test-elfeed-config-youtube-feed-format.el b/tests/test-elfeed-config-youtube-feed-format.el
index bda90aa7d..f6c82881e 100644
--- a/tests/test-elfeed-config-youtube-feed-format.el
+++ b/tests/test-elfeed-config-youtube-feed-format.el
@@ -65,5 +65,49 @@
       (should-error (cj/youtube-to-elfeed-feed-format "https://youtube.com/@t" 'channel))
       (should-not (buffer-live-p url-buf)))))
 
+;;; Playlist branch
+
+(ert-deftest test-elfeed-youtube-playlist-parses-id-and-title ()
+  "Normal: a playlist URL yields the playlist feed line and the og:title."
+  (cl-letf (((symbol-function 'url-retrieve-synchronously)
+             (lambda (&rest _)
+               (test-elfeed--url-buffer
+                "<meta property=\"og:title\" content=\"My Playlist\">"))))
+    (let ((result (cj/youtube-to-elfeed-feed-format
+                   "https://www.youtube.com/playlist?list=PLabc123" 'playlist)))
+      (should (string-match-p "playlist_id=PLabc123" result))
+      (should (string-match-p "My Playlist" result)))))
+
+(ert-deftest test-elfeed-youtube-playlist-id-stops-at-ampersand ()
+  "Boundary: extra query params after list= are not captured into the id."
+  (cl-letf (((symbol-function 'url-retrieve-synchronously)
+             (lambda (&rest _)
+               (test-elfeed--url-buffer
+                "<meta property=\"og:title\" content=\"X\">"))))
+    (let ((result (cj/youtube-to-elfeed-feed-format
+                   "https://www.youtube.com/playlist?list=PLxyz&index=2" 'playlist)))
+      (should (string-match-p "playlist_id=PLxyz" result))
+      (should-not (string-match-p "index=2" result)))))
+
+(ert-deftest test-elfeed-youtube-playlist-no-list-param-errors ()
+  "Error: a playlist URL with no list= parameter signals an extraction error."
+  (cl-letf (((symbol-function 'url-retrieve-synchronously)
+             (lambda (&rest _) (test-elfeed--url-buffer ""))))
+    (should-error (cj/youtube-to-elfeed-feed-format
+                   "https://www.youtube.com/watch?v=abc" 'playlist))))
+
+(ert-deftest test-elfeed-youtube-playlist-decodes-html-entities-in-title ()
+  "Normal: HTML entities in the og:title are decoded in the feed comment."
+  (cl-letf (((symbol-function 'url-retrieve-synchronously)
+             (lambda (&rest _)
+               (test-elfeed--url-buffer
+                (concat "<meta property=\"og:title\" content=\""
+                        "Rock &amp; Roll &#39;n&#x27; &lt;Test&gt; &quot;X&quot;"
+                        "\">")))))
+    (let ((result (cj/youtube-to-elfeed-feed-format
+                   "https://www.youtube.com/playlist?list=PLe" 'playlist)))
+      (should (string-match-p (regexp-quote "Rock & Roll 'n' <Test> \"X\"")
+                              result)))))
+
 (provide 'test-elfeed-config-youtube-feed-format)
 ;;; test-elfeed-config-youtube-feed-format.el ends here
diff --git a/tests/test-host-environment--detect-system-timezone.el b/tests/test-host-environment--detect-system-timezone.el
index c24ac183a..1b5e61081 100644
--- a/tests/test-host-environment--detect-system-timezone.el
+++ b/tests/test-host-environment--detect-system-timezone.el
@@ -74,5 +74,30 @@ contents primitives."
             ((symbol-function 'file-symlink-p) (lambda (_) nil)))
     (should-not (cj/detect-system-timezone))))
 
+(ert-deftest test-host-environment-detect-tz-symlink-target-extracts-zone ()
+  "Boundary: with methods 1-3 nil, a /etc/localtime symlink into zoneinfo
+yields the zone after the /zoneinfo/ segment."
+  (cl-letf (((symbol-function 'cj/match-localtime-to-zoneinfo)
+             (lambda () nil))
+            ((symbol-function 'getenv) (lambda (_) nil))
+            ((symbol-function 'file-exists-p) (lambda (_) nil))
+            ((symbol-function 'file-symlink-p)
+             (lambda (path) (string= path "/etc/localtime")))
+            ((symbol-function 'file-truename)
+             (lambda (_) "/usr/share/zoneinfo/America/Denver")))
+    (should (equal (cj/detect-system-timezone) "America/Denver"))))
+
+(ert-deftest test-host-environment-detect-tz-symlink-without-zoneinfo-is-nil ()
+  "Error: a symlink target with no /zoneinfo/ segment yields nil."
+  (cl-letf (((symbol-function 'cj/match-localtime-to-zoneinfo)
+             (lambda () nil))
+            ((symbol-function 'getenv) (lambda (_) nil))
+            ((symbol-function 'file-exists-p) (lambda (_) nil))
+            ((symbol-function 'file-symlink-p)
+             (lambda (path) (string= path "/etc/localtime")))
+            ((symbol-function 'file-truename)
+             (lambda (_) "/var/lib/elsewhere/localtime")))
+    (should-not (cj/detect-system-timezone))))
+
 (provide 'test-host-environment--detect-system-timezone)
 ;;; test-host-environment--detect-system-timezone.el ends here
diff --git a/tests/test-local-repository--car-member.el b/tests/test-local-repository--car-member.el
new file mode 100644
index 000000000..8b8c9a7db
--- /dev/null
+++ b/tests/test-local-repository--car-member.el
@@ -0,0 +1,58 @@
+;;; test-local-repository--car-member.el --- Tests for car-member -*- lexical-binding: t -*-
+
+;;; Commentary:
+;; Tests for `car-member' in local-repository.el — the predicate
+;; localrepo-initialize uses to check whether an archive id is already
+;; registered in package-archives / package-archive-priorities.
+
+;;; Code:
+
+(require 'ert)
+(require 'local-repository)
+
+;;; Normal Cases
+
+(ert-deftest test-local-repository-car-member-found ()
+  "Normal: VALUE present as a car returns the matching tail (non-nil)."
+  (should (equal (car-member 'b '((a . 1) (b . 2) (c . 3)))
+                 '(b c))))
+
+(ert-deftest test-local-repository-car-member-not-found ()
+  "Normal: VALUE absent from every car returns nil."
+  (should-not (car-member 'z '((a . 1) (b . 2)))))
+
+(ert-deftest test-local-repository-car-member-string-car ()
+  "Normal: car comparison uses `equal', so string keys match by value."
+  (should (car-member "localrepo"
+                      '(("gnu" . "url1") ("localrepo" . "url2")))))
+
+;;; Boundary Cases
+
+(ert-deftest test-local-repository-car-member-empty-list ()
+  "Boundary: an empty list never matches."
+  (should-not (car-member 'a nil)))
+
+(ert-deftest test-local-repository-car-member-single-match ()
+  "Boundary: a single-element list whose car matches returns non-nil."
+  (should (car-member 'only '((only . 1)))))
+
+(ert-deftest test-local-repository-car-member-single-no-match ()
+  "Boundary: a single-element list whose car differs returns nil."
+  (should-not (car-member 'x '((only . 1)))))
+
+(ert-deftest test-local-repository-car-member-nil-value-with-nil-car ()
+  "Boundary: a nil VALUE matches a cons whose car is nil."
+  (should (car-member nil '((nil . 1) (a . 2)))))
+
+(ert-deftest test-local-repository-car-member-nil-value-no-nil-car ()
+  "Boundary: a nil VALUE with no nil car returns nil."
+  (should-not (car-member nil '((a . 1) (b . 2)))))
+
+;;; Error Cases
+
+(ert-deftest test-local-repository-car-member-non-cons-element ()
+  "Error: a non-cons element makes `car' signal wrong-type-argument."
+  (should-error (car-member 'x '(1 2)) :type 'wrong-type-argument))
+
+(provide 'test-local-repository--car-member)
+;;; test-local-repository--car-member.el ends here
diff --git a/tests/test-reconcile--dirty-p.el b/tests/test-reconcile--dirty-p.el
new file mode 100644
index 000000000..a4c372b66
--- /dev/null
+++ b/tests/test-reconcile--dirty-p.el
@@ -0,0 +1,49 @@
+;;; test-reconcile--dirty-p.el --- Tests for cj/reconcile--dirty-p -*- lexical-binding: t -*-
+
+;;; Commentary:
+;; Tests for `cj/reconcile--dirty-p' in reconcile-open-repos.el.  It runs
+;; git status --porcelain via `cj/reconcile--git' and reports clean (nil),
+;; dirty (non-nil), or 'status-failed when git itself errors.  The git call
+;; is stubbed at the `cj/reconcile--git' boundary (it returns a plist).
+
+;;; Code:
+
+(require 'ert)
+(require 'cl-lib)
+(require 'reconcile-open-repos)
+
+(defmacro test-reconcile-dirty--with-git (plist &rest body)
+  "Run BODY with `cj/reconcile--git' stubbed to return PLIST."
+  (declare (indent 1))
+  `(cl-letf (((symbol-function 'cj/reconcile--git)
+              (lambda (&rest _) ,plist)))
+     ,@body))
+
+;;; Normal Cases
+
+(ert-deftest test-reconcile-dirty-p-clean-returns-nil ()
+  "Normal: exit 0 with empty porcelain output means clean (nil)."
+  (test-reconcile-dirty--with-git '(:exit 0 :output "")
+    (should-not (cj/reconcile--dirty-p "/repo"))))
+
+(ert-deftest test-reconcile-dirty-p-dirty-returns-non-nil ()
+  "Normal: exit 0 with porcelain content means dirty (non-nil)."
+  (test-reconcile-dirty--with-git '(:exit 0 :output " M file.el\n")
+    (should (cj/reconcile--dirty-p "/repo"))))
+
+;;; Boundary Cases
+
+(ert-deftest test-reconcile-dirty-p-whitespace-only-is-clean ()
+  "Boundary: whitespace-only output trims to empty and counts as clean."
+  (test-reconcile-dirty--with-git '(:exit 0 :output "   \n")
+    (should-not (cj/reconcile--dirty-p "/repo"))))
+
+;;; Error Cases
+
+(ert-deftest test-reconcile-dirty-p-git-failure-returns-status-failed ()
+  "Error: a non-zero git exit returns the symbol 'status-failed."
+  (test-reconcile-dirty--with-git '(:exit 128 :output "fatal: not a repo")
+    (should (eq (cj/reconcile--dirty-p "/repo") 'status-failed))))
+
+(provide 'test-reconcile--dirty-p)
+;;; test-reconcile--dirty-p.el ends here
diff --git a/tests/test-show-kill-ring--insert-item.el b/tests/test-show-kill-ring--insert-item.el
new file mode 100644
index 000000000..a29ca75e6
--- /dev/null
+++ b/tests/test-show-kill-ring--insert-item.el
@@ -0,0 +1,73 @@
+;;; test-show-kill-ring--insert-item.el --- Tests for show-kill-insert-item -*- lexical-binding: t -*-
+
+;;; Commentary:
+;; Tests for `show-kill-insert-item' in show-kill-ring.el — inserts a
+;; kill-ring entry into the current buffer, truncating to
+;; `show-kill-max-item-size' with an ellipsis when too long.  The ellipsis
+;; sits inline for short items and on its own line for items wider than the
+;; frame.  Frame width is read at runtime so the test is environment-stable.
+
+;;; Code:
+
+(require 'ert)
+(require 'show-kill-ring)
+
+;;; Normal Cases
+
+(ert-deftest test-show-kill-ring-insert-item-short-verbatim ()
+  "Normal: an item shorter than the max is inserted unchanged."
+  (let ((show-kill-max-item-size 1000))
+    (with-temp-buffer
+      (show-kill-insert-item "hello")
+      (should (string= (buffer-string) "hello")))))
+
+(ert-deftest test-show-kill-ring-insert-item-inline-ellipsis ()
+  "Normal: an over-max item narrower than the frame gets an inline ellipsis."
+  (let* ((show-kill-max-item-size 5)
+         (len (/ (frame-width) 2))        ; > max, < (frame-width - 5)
+         (item (make-string len ?b)))
+    (with-temp-buffer
+      (show-kill-insert-item item)
+      (should (string= (buffer-string) "bbbbb...")))))
+
+;;; Boundary Cases
+
+(ert-deftest test-show-kill-ring-insert-item-length-equals-max-truncates ()
+  "Boundary: length exactly equal to max truncates — the guard is (< len max)."
+  (let ((show-kill-max-item-size 5))
+    (with-temp-buffer
+      (show-kill-insert-item "hello")     ; length 5, equals max
+      (should (string= (buffer-string) "hello...")))))
+
+(ert-deftest test-show-kill-ring-insert-item-wide-newline-ellipsis ()
+  "Boundary: an item wider than the frame puts the ellipsis on its own line."
+  (let* ((show-kill-max-item-size 5)
+         (item (make-string (+ (frame-width) 10) ?a)))
+    (with-temp-buffer
+      (show-kill-insert-item item)
+      (should (string= (buffer-string) "aaaaa\n...")))))
+
+(ert-deftest test-show-kill-ring-insert-item-max-nil-verbatim ()
+  "Boundary: a non-numeric max disables truncation."
+  (let ((show-kill-max-item-size nil))
+    (with-temp-buffer
+      (show-kill-insert-item "anything long enough to exceed nothing")
+      (should (string= (buffer-string)
+                       "anything long enough to exceed nothing")))))
+
+(ert-deftest test-show-kill-ring-insert-item-max-negative-verbatim ()
+  "Boundary: a negative max disables truncation."
+  (let ((show-kill-max-item-size -1))
+    (with-temp-buffer
+      (show-kill-insert-item "abc")
+      (should (string= (buffer-string) "abc")))))
+
+(ert-deftest test-show-kill-ring-insert-item-empty-string ()
+  "Boundary: an empty item inserts nothing and does not error."
+  (let ((show-kill-max-item-size 1000))
+    (with-temp-buffer
+      (show-kill-insert-item "")
+      (should (string= (buffer-string) "")))))
+
+(provide 'test-show-kill-ring--insert-item)
+;;; test-show-kill-ring--insert-item.el ends here
diff --git a/tests/test-user-constants.el b/tests/test-user-constants.el
index 8dd9284ff..0c12eecf4 100644
--- a/tests/test-user-constants.el
+++ b/tests/test-user-constants.el
@@ -120,5 +120,48 @@ The whole point of the split — a bare require must not touch the filesystem."
           (should (eq (nth 1 warn-args) :error)))
       (delete-directory dir t))))
 
+;;; verify-or-create no-op branches (target already present)
+
+(ert-deftest test-user-constants-verify-dir-existing-is-noop ()
+  "Boundary: an existing directory is a no-op — make-directory is not called."
+  (test-user-constants--load)
+  (let ((dir (make-temp-file "uc-exdir-" t)))
+    (unwind-protect
+        (cl-letf (((symbol-function 'make-directory)
+                   (lambda (&rest _) (error "should not create an existing dir"))))
+          (cj/verify-or-create-dir dir)   ; must not error
+          (should (file-directory-p dir)))
+      (delete-directory dir t))))
+
+(ert-deftest test-user-constants-verify-file-existing-is-noop ()
+  "Boundary: an existing file is left untouched — write-region is not called."
+  (test-user-constants--load)
+  (let* ((dir (make-temp-file "uc-exfile-" t))
+         (file (expand-file-name "keep.org" dir)))
+    (unwind-protect
+        (progn
+          (with-temp-file file (insert "original"))
+          (cl-letf (((symbol-function 'write-region)
+                     (lambda (&rest _) (error "should not overwrite an existing file"))))
+            (cj/verify-or-create-file file)
+            (should (equal (with-temp-buffer
+                             (insert-file-contents file) (buffer-string))
+                           "original"))))
+      (delete-directory dir t))))
+
+(ert-deftest test-user-constants-verify-file-optional-failure-logs ()
+  "Error: an optional file failure is logged, never warned or signalled."
+  (test-user-constants--load)
+  (let ((dir (make-temp-file "uc-optfile-" t))
+        (warned nil) (messaged nil))
+    (unwind-protect
+        (cl-letf (((symbol-function 'write-region) (lambda (&rest _) (error "boom")))
+                  ((symbol-function 'display-warning) (lambda (&rest _) (setq warned t)))
+                  ((symbol-function 'message) (lambda (&rest _) (setq messaged t))))
+          (cj/verify-or-create-file (expand-file-name "optional.org" dir))
+          (should messaged)
+          (should-not warned))
+      (delete-directory dir t))))
+
 (provide 'test-user-constants)
 ;;; test-user-constants.el ends here