test+fix:custom-misc: add tests and fix fraction glyph bug

  Add test coverage for 4 functions in custom-misc.el:

  - cj/replace-fraction-glyphs (24 tests)
  - cj/format-region-or-buffer (17 tests)
  - cj/count-words-buffer-or-region (20 tests)
  - cj/jump-to-matching-paren (18 tests)

  Refactored functions using internal/interactive split pattern:
  - Internal functions (cj/--function-name) contain business logic with
    explicit parameters and validation
  - Interactive wrappers handle UI concerns (region detection, messages)
  - Tests call internal functions directly (no mocking required)

  Bug Fix: cj/--replace-fraction-glyphs
  Fixed "Invalid search bound" error when converting glyphs to text.
  Original code used fixed end position which became invalid when
  replacements changed buffer size. Fixed by using copy-marker for
  dynamic end position tracking.

4 files changed, 691 insertions, 0 deletions

diff --git a/tests/test-custom-misc-count-words.el b/tests/test-custom-misc-count-words.el
new file mode 100644
index 00000000..f2bf793f
--- /dev/null
+++ b/tests/test-custom-misc-count-words.el
@@ -0,0 +1,148 @@
+;;; test-custom-misc-count-words.el --- Tests for cj/--count-words -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Tests for the cj/--count-words function from custom-misc.el
+;;
+;; This function counts words in a region using Emacs's built-in count-words.
+;; A word is defined by Emacs's word boundaries, which generally means
+;; sequences of word-constituent characters separated by whitespace or punctuation.
+;;
+;; We test the NON-INTERACTIVE implementation (cj/--count-words) to avoid
+;; mocking region selection. This follows our testing best practice of
+;; separating business logic from UI interaction.
+
+;;; Code:
+
+(require 'ert)
+(require 'testutil-general)
+
+;; Add modules directory to load path
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+
+;; Stub dependencies before loading the module
+(defvar cj/custom-keymap (make-sparse-keymap)
+  "Stub keymap for testing.")
+
+;; Now load the actual production module
+(require 'custom-misc)
+
+;;; Test Helpers
+
+(defun test-count-words (input-text)
+  "Test cj/--count-words on INPUT-TEXT.
+Returns the word count."
+  (with-temp-buffer
+    (insert input-text)
+    (cj/--count-words (point-min) (point-max))))
+
+;;; Normal Cases
+
+(ert-deftest test-count-words-multiple-words ()
+  "Should count multiple words."
+  (should (= 5 (test-count-words "The quick brown fox jumps"))))
+
+(ert-deftest test-count-words-single-word ()
+  "Should count single word."
+  (should (= 1 (test-count-words "hello"))))
+
+(ert-deftest test-count-words-with-punctuation ()
+  "Should count words with punctuation."
+  (should (= 5 (test-count-words "Hello, world! How are you?"))))
+
+(ert-deftest test-count-words-multiple-spaces ()
+  "Should count words separated by multiple spaces."
+  (should (= 3 (test-count-words "hello    world    test"))))
+
+(ert-deftest test-count-words-with-newlines ()
+  "Should count words across newlines."
+  (should (= 6 (test-count-words "line one\nline two\nline three"))))
+
+(ert-deftest test-count-words-with-tabs ()
+  "Should count words separated by tabs."
+  (should (= 3 (test-count-words "hello\tworld\ttest"))))
+
+(ert-deftest test-count-words-mixed-whitespace ()
+  "Should count words with mixed whitespace."
+  (should (= 4 (test-count-words "hello \t world\n\ntest  end"))))
+
+(ert-deftest test-count-words-hyphenated ()
+  "Should count hyphenated words."
+  ;; Emacs treats hyphens as word separators in count-words
+  (should (= 7 (test-count-words "This is state-of-the-art technology"))))
+
+(ert-deftest test-count-words-contractions ()
+  "Should count contractions."
+  ;; Emacs treats apostrophes as word separators in count-words
+  (should (= 6 (test-count-words "don't can't won't"))))
+
+(ert-deftest test-count-words-numbers ()
+  "Should count numbers as words."
+  (should (= 6 (test-count-words "The year 2024 has 365 days"))))
+
+;;; Boundary Cases
+
+(ert-deftest test-count-words-empty-string ()
+  "Should return 0 for empty string."
+  (should (= 0 (test-count-words ""))))
+
+(ert-deftest test-count-words-only-whitespace ()
+  "Should return 0 for whitespace-only text."
+  (should (= 0 (test-count-words "   \t\n\n   "))))
+
+(ert-deftest test-count-words-only-punctuation ()
+  "Should count punctuation-only text."
+  ;; Emacs may count consecutive punctuation as a word
+  (should (= 1 (test-count-words "!@#$%^&*()"))))
+
+(ert-deftest test-count-words-leading-trailing-spaces ()
+  "Should count words ignoring leading/trailing spaces."
+  (should (= 3 (test-count-words "   hello world test   "))))
+
+(ert-deftest test-count-words-unicode ()
+  "Should count Unicode words."
+  (should (= 3 (test-count-words "café résumé naïve"))))
+
+(ert-deftest test-count-words-very-long-text ()
+  "Should handle very long text."
+  (let ((long-text (mapconcat (lambda (_) "word") (make-list 1000 nil) " ")))
+    (should (= 1000 (test-count-words long-text)))))
+
+(ert-deftest test-count-words-multiline-paragraph ()
+  "Should count words in multi-line paragraph."
+  (let ((text "This is a paragraph
+that spans multiple
+lines with various
+words in it."))
+    (should (= 13 (test-count-words text)))))
+
+;;; Error Cases
+
+(ert-deftest test-count-words-start-greater-than-end ()
+  "Should error when start > end."
+  (should-error
+   (with-temp-buffer
+     (insert "hello world")
+     (cj/--count-words (point-max) (point-min)))
+   :type 'error))
+
+(ert-deftest test-count-words-empty-region ()
+  "Should return 0 for empty region (start == end)."
+  (with-temp-buffer
+    (insert "hello world")
+    (let ((pos (/ (+ (point-min) (point-max)) 2)))
+      (should (= 0 (cj/--count-words pos pos))))))
+
+(ert-deftest test-count-words-partial-region ()
+  "Should count words only in specified region."
+  (with-temp-buffer
+    (insert "one two three four five")
+    ;; Count only "two three four" (positions roughly in middle)
+    (goto-char (point-min))
+    (search-forward "two")
+    (let ((start (match-beginning 0)))
+      (search-forward "four")
+      (let ((end (match-end 0)))
+        (should (= 3 (cj/--count-words start end)))))))
+
+(provide 'test-custom-misc-count-words)
+;;; test-custom-misc-count-words.el ends here
diff --git a/tests/test-custom-misc-format-region.el b/tests/test-custom-misc-format-region.el
new file mode 100644
index 00000000..c40a8898
--- /dev/null
+++ b/tests/test-custom-misc-format-region.el
@@ -0,0 +1,161 @@
+;;; test-custom-misc-format-region.el --- Tests for cj/--format-region -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Tests for the cj/--format-region function from custom-misc.el
+;;
+;; This function reformats text by applying three operations:
+;; 1. untabify - converts tabs to spaces
+;; 2. indent-region - reindents according to major mode
+;; 3. delete-trailing-whitespace - removes trailing whitespace
+;;
+;; Note: indent-region behavior is major-mode dependent. We test in
+;; emacs-lisp-mode and fundamental-mode for predictable results.
+;;
+;; We test the NON-INTERACTIVE implementation (cj/--format-region)
+;; to avoid mocking region selection. This follows our testing best practice
+;; of separating business logic from UI interaction.
+
+;;; Code:
+
+(require 'ert)
+(require 'testutil-general)
+
+;; Add modules directory to load path
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+
+;; Stub dependencies before loading the module
+(defvar cj/custom-keymap (make-sparse-keymap)
+  "Stub keymap for testing.")
+
+;; Now load the actual production module
+(require 'custom-misc)
+
+;;; Test Helpers
+
+(defun test-format-region (input-text &optional mode)
+  "Test cj/--format-region on INPUT-TEXT.
+MODE is the major mode to use (defaults to fundamental-mode).
+Returns the buffer string after operation."
+  (with-temp-buffer
+    (funcall (or mode #'fundamental-mode))
+    (insert input-text)
+    (cj/--format-region (point-min) (point-max))
+    (buffer-string)))
+
+;;; Normal Cases - Tab Conversion
+
+(ert-deftest test-format-region-converts-tabs ()
+  "Should convert tabs to spaces."
+  (let ((result (test-format-region "hello\tworld")))
+    (should-not (string-match-p "\t" result))
+    (should (string-match-p " " result))))
+
+(ert-deftest test-format-region-multiple-tabs ()
+  "Should convert multiple tabs."
+  (let ((result (test-format-region "\t\thello\t\tworld\t\t")))
+    (should-not (string-match-p "\t" result))))
+
+;;; Normal Cases - Trailing Whitespace
+
+(ert-deftest test-format-region-removes-trailing-spaces ()
+  "Should remove trailing spaces."
+  (let ((result (test-format-region "hello world   ")))
+    (should (string= result "hello world"))))
+
+(ert-deftest test-format-region-removes-trailing-tabs ()
+  "Should remove trailing tabs."
+  (let ((result (test-format-region "hello world\t\t")))
+    (should (string= result "hello world"))))
+
+(ert-deftest test-format-region-removes-trailing-mixed ()
+  "Should remove trailing mixed whitespace."
+  (let ((result (test-format-region "hello world \t \t ")))
+    (should (string= result "hello world"))))
+
+(ert-deftest test-format-region-multiline-trailing ()
+  "Should remove trailing whitespace from multiple lines."
+  (let ((result (test-format-region "line1   \nline2\t\t\nline3 \t ")))
+    (should (string= result "line1\nline2\nline3"))))
+
+;;; Normal Cases - Combined Operations
+
+(ert-deftest test-format-region-tabs-and-trailing ()
+  "Should handle both tabs and trailing whitespace."
+  (let ((result (test-format-region "\thello\tworld\t\t")))
+    (should-not (string-match-p "\t" result))
+    ;; Should not end with whitespace
+    (should-not (string-match-p "[ \t]+$" result))))
+
+(ert-deftest test-format-region-preserves-interior-spaces ()
+  "Should preserve interior spaces while fixing edges."
+  (let ((result (test-format-region "\thello   world\t")))
+    (should (string-match-p "hello   world" result))
+    (should-not (string-match-p "\t" result))))
+
+;;; Normal Cases - Indentation (Mode-Specific)
+
+(ert-deftest test-format-region-elisp-indentation ()
+  "Should reindent Elisp code."
+  (let* ((input "(defun foo ()\n(+ 1 2))")
+         (result (test-format-region input #'emacs-lisp-mode))
+         (lines (split-string result "\n")))
+    ;; The inner form should be indented - second line should start with 2 spaces
+    (should (= 2 (length lines)))
+    (should (string-prefix-p "(defun foo ()" (car lines)))
+    (should (string-prefix-p "  " (cadr lines)))))
+
+;;; Boundary Cases
+
+(ert-deftest test-format-region-empty-string ()
+  "Should handle empty string."
+  (let ((result (test-format-region "")))
+    (should (string= result ""))))
+
+(ert-deftest test-format-region-no-issues ()
+  "Should handle text with no formatting issues (no-op)."
+  (let ((result (test-format-region "hello world")))
+    (should (string= result "hello world"))))
+
+(ert-deftest test-format-region-only-whitespace ()
+  "Should handle text with only whitespace."
+  (let ((result (test-format-region "\t   \t   ")))
+    ;; Should become empty or just spaces, no tabs
+    (should-not (string-match-p "\t" result))))
+
+(ert-deftest test-format-region-single-line ()
+  "Should handle single line."
+  (let ((result (test-format-region "\thello\t")))
+    (should-not (string-match-p "\t" result))))
+
+(ert-deftest test-format-region-very-long-text ()
+  "Should handle very long text."
+  (let* ((long-text (mapconcat (lambda (_) "\thello\t") (make-list 100 nil) "\n"))
+         (result (test-format-region long-text)))
+    (should-not (string-match-p "\t" result))))
+
+(ert-deftest test-format-region-newlines-preserved ()
+  "Should preserve newlines while fixing formatting."
+  (let ((result (test-format-region "line1\t \nline2\t \nline3\t ")))
+    (should (= 2 (cl-count ?\n result)))))
+
+;;; Error Cases
+
+(ert-deftest test-format-region-start-greater-than-end ()
+  "Should error when start > end."
+  (should-error
+   (with-temp-buffer
+     (insert "hello world")
+     (cj/--format-region (point-max) (point-min)))
+   :type 'error))
+
+(ert-deftest test-format-region-empty-region ()
+  "Should handle empty region (start == end) without error."
+  (with-temp-buffer
+    (insert "hello world")
+    (let ((pos (/ (+ (point-min) (point-max)) 2)))
+      (cj/--format-region pos pos)
+      ;; Should complete without error
+      (should (string= (buffer-string) "hello world")))))
+
+(provide 'test-custom-misc-format-region)
+;;; test-custom-misc-format-region.el ends here
diff --git a/tests/test-custom-misc-jump-to-matching-paren.el b/tests/test-custom-misc-jump-to-matching-paren.el
new file mode 100644
index 00000000..973b6dfa
--- /dev/null
+++ b/tests/test-custom-misc-jump-to-matching-paren.el
@@ -0,0 +1,197 @@
+;;; test-custom-misc-jump-to-matching-paren.el --- Tests for cj/jump-to-matching-paren -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Tests for the cj/jump-to-matching-paren function from custom-misc.el
+;;
+;; This function jumps to matching delimiters using Emacs's sexp navigation.
+;; It works with any delimiter that has matching syntax according to the
+;; current syntax table (parentheses, brackets, braces, etc.).
+;;
+;; Unlike other functions in this test suite, this is an INTERACTIVE function
+;; that moves point and displays messages. We test it as an integration test
+;; by setting up buffers, positioning point, calling the function, and
+;; verifying where point ends up.
+;;
+;; Key behaviors:
+;; - When on opening delimiter: jump forward to matching closing delimiter
+;; - When on closing delimiter: jump backward to matching opening delimiter
+;; - When just after closing delimiter: jump backward to matching opening
+;; - When not on delimiter: display message, don't move
+;; - When no matching delimiter: display error message, don't move
+
+;;; Code:
+
+(require 'ert)
+(require 'testutil-general)
+
+;; Add modules directory to load path
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+
+;; Stub dependencies before loading the module
+(defvar cj/custom-keymap (make-sparse-keymap)
+  "Stub keymap for testing.")
+
+;; Now load the actual production module
+(require 'custom-misc)
+
+;;; Test Helpers
+
+(defun test-jump-to-matching-paren (text point-position)
+  "Test cj/jump-to-matching-paren with TEXT and point at POINT-POSITION.
+Returns the new point position after calling the function.
+POINT-POSITION is 1-indexed (1 = first character)."
+  (with-temp-buffer
+    (emacs-lisp-mode)  ; Use elisp mode for proper syntax table
+    (insert text)
+    (goto-char point-position)
+    (cj/jump-to-matching-paren)
+    (point)))
+
+;;; Normal Cases - Forward Jump (Opening to Closing)
+
+(ert-deftest test-jump-paren-forward-simple ()
+  "Should jump forward from opening paren to closing paren."
+  ;; Text: "(hello)"
+  ;; Start at position 1 (on opening paren)
+  ;; Should end at position 8 (after closing paren)
+  (should (= 8 (test-jump-to-matching-paren "(hello)" 1))))
+
+(ert-deftest test-jump-paren-forward-nested ()
+  "Should jump forward over nested parens."
+  ;; Text: "(foo (bar))"
+  ;; Start at position 1 (on outer opening paren)
+  ;; Should end at position 12 (after outer closing paren)
+  (should (= 12 (test-jump-to-matching-paren "(foo (bar))" 1))))
+
+(ert-deftest test-jump-paren-forward-inner-nested ()
+  "Should jump forward from inner opening paren."
+  ;; Text: "(foo (bar))"
+  ;; Start at position 6 (on inner opening paren)
+  ;; Should end at position 11 (after inner closing paren)
+  (should (= 11 (test-jump-to-matching-paren "(foo (bar))" 6))))
+
+(ert-deftest test-jump-bracket-forward ()
+  "Should jump forward from opening bracket."
+  ;; Text: "[1 2 3]"
+  ;; Start at position 1
+  ;; Should end at position 8
+  (should (= 8 (test-jump-to-matching-paren "[1 2 3]" 1))))
+
+;; Note: Braces are not treated as matching delimiters in emacs-lisp-mode
+;; so we don't test them here
+
+;;; Normal Cases - Backward Jump (Closing to Opening)
+
+(ert-deftest test-jump-paren-backward-simple ()
+  "Should jump backward from closing paren to opening paren."
+  ;; Text: "(hello)"
+  ;; Start at position 7 (on closing paren)
+  ;; Should end at position 2 (after opening paren)
+  (should (= 2 (test-jump-to-matching-paren "(hello)" 7))))
+
+(ert-deftest test-jump-paren-backward-nested ()
+  "Should jump backward over nested parens from after outer closing."
+  ;; Text: "(foo (bar))"
+  ;; Start at position 12 (after outer closing paren)
+  ;; backward-sexp goes back to before opening paren
+  (should (= 1 (test-jump-to-matching-paren "(foo (bar))" 12))))
+
+(ert-deftest test-jump-paren-backward-inner-nested ()
+  "Should jump backward from inner closing paren."
+  ;; Text: "(foo (bar))"
+  ;; Start at position 10 (on inner closing paren)
+  ;; Should end at position 7 (after inner opening paren)
+  (should (= 7 (test-jump-to-matching-paren "(foo (bar))" 10))))
+
+(ert-deftest test-jump-bracket-backward ()
+  "Should jump backward from after closing bracket."
+  ;; Text: "[1 2 3]"
+  ;; Start at position 8 (after ])
+  ;; backward-sexp goes back one sexp
+  (should (= 1 (test-jump-to-matching-paren "[1 2 3]" 8))))
+
+;;; Normal Cases - Jump from After Closing Delimiter
+
+(ert-deftest test-jump-paren-after-closing ()
+  "Should jump backward when just after closing paren."
+  ;; Text: "(hello)"
+  ;; Start at position 8 (after closing paren)
+  ;; backward-sexp goes back one sexp, ending before the opening paren
+  (should (= 1 (test-jump-to-matching-paren "(hello)" 8))))
+
+;;; Boundary Cases - No Movement
+
+(ert-deftest test-jump-paren-not-on-delimiter ()
+  "Should not move when not on delimiter."
+  ;; Text: "(hello world)"
+  ;; Start at position 3 (on 'e' in hello)
+  ;; Should stay at position 3
+  (should (= 3 (test-jump-to-matching-paren "(hello world)" 3))))
+
+(ert-deftest test-jump-paren-on-whitespace ()
+  "Should not move when on whitespace."
+  ;; Text: "(hello world)"
+  ;; Start at position 7 (on space)
+  ;; Should stay at position 7
+  (should (= 7 (test-jump-to-matching-paren "(hello world)" 7))))
+
+;;; Boundary Cases - Unmatched Delimiters
+
+(ert-deftest test-jump-paren-unmatched-opening ()
+  "Should not move from unmatched opening paren."
+  ;; Text: "(hello"
+  ;; Start at position 1 (on opening paren with no closing)
+  ;; Should stay at position 1
+  (should (= 1 (test-jump-to-matching-paren "(hello" 1))))
+
+(ert-deftest test-jump-paren-unmatched-closing ()
+  "Should move to beginning from unmatched closing paren."
+  ;; Text: "hello)"
+  ;; Start at position 6 (on closing paren with no opening)
+  ;; backward-sexp with unmatched closing paren goes to beginning
+  (should (= 1 (test-jump-to-matching-paren "hello)" 6))))
+
+;;; Boundary Cases - Empty Delimiters
+
+(ert-deftest test-jump-paren-empty ()
+  "Should jump over empty parens."
+  ;; Text: "()"
+  ;; Start at position 1
+  ;; Should end at position 3
+  (should (= 3 (test-jump-to-matching-paren "()" 1))))
+
+(ert-deftest test-jump-paren-empty-backward ()
+  "Should stay put when on closing paren of empty parens."
+  ;; Text: "()"
+  ;; Start at position 2 (on closing paren)
+  ;; backward-sexp from closing of empty parens gives an error, so stays at 2
+  (should (= 2 (test-jump-to-matching-paren "()" 2))))
+
+;;; Boundary Cases - Multiple Delimiter Types
+
+(ert-deftest test-jump-paren-mixed-delimiters ()
+  "Should jump over mixed delimiter types."
+  ;; Text: "(foo [bar {baz}])"
+  ;; Start at position 1 (on opening paren)
+  ;; Should end at position 18 (after closing paren)
+  (should (= 18 (test-jump-to-matching-paren "(foo [bar {baz}])" 1))))
+
+(ert-deftest test-jump-bracket-in-parens ()
+  "Should jump from bracket inside parens."
+  ;; Text: "(foo [bar])"
+  ;; Start at position 6 (on opening bracket)
+  ;; Should end at position 11 (after closing bracket)
+  (should (= 11 (test-jump-to-matching-paren "(foo [bar])" 6))))
+
+;;; Complex Cases - Strings and Comments
+
+(ert-deftest test-jump-paren-over-string ()
+  "Should jump over parens containing strings."
+  ;; Text: "(\"hello (world)\")"
+  ;; Start at position 1 (on opening paren)
+  ;; Should end at position 18 (after closing paren)
+  ;; The parens in the string should be ignored
+  (should (= 18 (test-jump-to-matching-paren "(\"hello (world)\")" 1))))
+
+(provide 'test-custom-misc-jump-to-matching-paren)
+;;; test-custom-misc-jump-to-matching-paren.el ends here
diff --git a/tests/test-custom-misc-replace-fraction-glyphs.el b/tests/test-custom-misc-replace-fraction-glyphs.el
new file mode 100644
index 00000000..81d1546e
--- /dev/null
+++ b/tests/test-custom-misc-replace-fraction-glyphs.el
@@ -0,0 +1,185 @@
+;;; test-custom-misc-replace-fraction-glyphs.el --- Tests for cj/--replace-fraction-glyphs -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Tests for the cj/--replace-fraction-glyphs function from custom-misc.el
+;;
+;; This function bidirectionally converts between text fractions (1/4) and
+;; Unicode fraction glyphs (¼). It supports 5 common fractions:
+;; - 1/4 ↔ ¼
+;; - 1/2 ↔ ½
+;; - 3/4 ↔ ¾
+;; - 1/3 ↔ ⅓
+;; - 2/3 ↔ ⅔
+;;
+;; We test the NON-INTERACTIVE implementation (cj/--replace-fraction-glyphs)
+;; to avoid mocking prefix arguments. This follows our testing best practice
+;; of separating business logic from UI interaction.
+
+;;; Code:
+
+(require 'ert)
+(require 'testutil-general)
+
+;; Add modules directory to load path
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+
+;; Stub dependencies before loading the module
+(defvar cj/custom-keymap (make-sparse-keymap)
+  "Stub keymap for testing.")
+
+;; Now load the actual production module
+(require 'custom-misc)
+
+;;; Test Helpers
+
+(defun test-replace-fraction-glyphs (input-text to-glyphs)
+  "Test cj/--replace-fraction-glyphs on INPUT-TEXT.
+TO-GLYPHS determines conversion direction.
+Returns the buffer string after operation."
+  (with-temp-buffer
+    (insert input-text)
+    (cj/--replace-fraction-glyphs (point-min) (point-max) to-glyphs)
+    (buffer-string)))
+
+;;; Normal Cases - Text to Glyphs
+
+(ert-deftest test-replace-fraction-glyphs-text-to-glyph-quarter ()
+  "Should convert 1/4 to ¼."
+  (let ((result (test-replace-fraction-glyphs "1/4" t)))
+    (should (string= result "¼"))))
+
+(ert-deftest test-replace-fraction-glyphs-text-to-glyph-half ()
+  "Should convert 1/2 to ½."
+  (let ((result (test-replace-fraction-glyphs "1/2" t)))
+    (should (string= result "½"))))
+
+(ert-deftest test-replace-fraction-glyphs-text-to-glyph-three-quarters ()
+  "Should convert 3/4 to ¾."
+  (let ((result (test-replace-fraction-glyphs "3/4" t)))
+    (should (string= result "¾"))))
+
+(ert-deftest test-replace-fraction-glyphs-text-to-glyph-third ()
+  "Should convert 1/3 to ⅓."
+  (let ((result (test-replace-fraction-glyphs "1/3" t)))
+    (should (string= result "⅓"))))
+
+(ert-deftest test-replace-fraction-glyphs-text-to-glyph-two-thirds ()
+  "Should convert 2/3 to ⅔."
+  (let ((result (test-replace-fraction-glyphs "2/3" t)))
+    (should (string= result "⅔"))))
+
+(ert-deftest test-replace-fraction-glyphs-text-to-glyph-multiple ()
+  "Should convert multiple fractions in text."
+  (let ((result (test-replace-fraction-glyphs "Use 1/4 cup and 1/2 teaspoon" t)))
+    (should (string= result "Use ¼ cup and ½ teaspoon"))))
+
+(ert-deftest test-replace-fraction-glyphs-text-to-glyph-all-types ()
+  "Should convert all fraction types."
+  (let ((result (test-replace-fraction-glyphs "1/4 1/2 3/4 1/3 2/3" t)))
+    (should (string= result "¼ ½ ¾ ⅓ ⅔"))))
+
+;;; Normal Cases - Glyphs to Text
+
+(ert-deftest test-replace-fraction-glyphs-glyph-to-text-quarter ()
+  "Should convert ¼ to 1/4."
+  (let ((result (test-replace-fraction-glyphs "¼" nil)))
+    (should (string= result "1/4"))))
+
+(ert-deftest test-replace-fraction-glyphs-glyph-to-text-half ()
+  "Should convert ½ to 1/2."
+  (let ((result (test-replace-fraction-glyphs "½" nil)))
+    (should (string= result "1/2"))))
+
+(ert-deftest test-replace-fraction-glyphs-glyph-to-text-three-quarters ()
+  "Should convert ¾ to 3/4."
+  (let ((result (test-replace-fraction-glyphs "¾" nil)))
+    (should (string= result "3/4"))))
+
+(ert-deftest test-replace-fraction-glyphs-glyph-to-text-third ()
+  "Should convert ⅓ to 1/3."
+  (let ((result (test-replace-fraction-glyphs "⅓" nil)))
+    (should (string= result "1/3"))))
+
+(ert-deftest test-replace-fraction-glyphs-glyph-to-text-two-thirds ()
+  "Should convert ⅔ to 2/3."
+  (let ((result (test-replace-fraction-glyphs "⅔" nil)))
+    (should (string= result "2/3"))))
+
+(ert-deftest test-replace-fraction-glyphs-glyph-to-text-multiple ()
+  "Should convert multiple glyphs in text."
+  (let ((result (test-replace-fraction-glyphs "Use ¼ cup and ½ teaspoon" nil)))
+    (should (string= result "Use 1/4 cup and 1/2 teaspoon"))))
+
+(ert-deftest test-replace-fraction-glyphs-glyph-to-text-all-types ()
+  "Should convert all glyph types."
+  (let ((result (test-replace-fraction-glyphs "¼ ½ ¾ ⅓ ⅔" nil)))
+    (should (string= result "1/4 1/2 3/4 1/3 2/3"))))
+
+;;; Boundary Cases
+
+(ert-deftest test-replace-fraction-glyphs-empty-string ()
+  "Should handle empty string."
+  (let ((result (test-replace-fraction-glyphs "" t)))
+    (should (string= result ""))))
+
+(ert-deftest test-replace-fraction-glyphs-no-fractions-to-glyphs ()
+  "Should handle text with no fractions (no-op) when converting to glyphs."
+  (let ((result (test-replace-fraction-glyphs "hello world" t)))
+    (should (string= result "hello world"))))
+
+(ert-deftest test-replace-fraction-glyphs-no-fractions-to-text ()
+  "Should handle text with no glyphs (no-op) when converting to text."
+  (let ((result (test-replace-fraction-glyphs "hello world" nil)))
+    (should (string= result "hello world"))))
+
+(ert-deftest test-replace-fraction-glyphs-at-start ()
+  "Should handle fraction at start of text."
+  (let ((result (test-replace-fraction-glyphs "1/2 of the total" t)))
+    (should (string= result "½ of the total"))))
+
+(ert-deftest test-replace-fraction-glyphs-at-end ()
+  "Should handle fraction at end of text."
+  (let ((result (test-replace-fraction-glyphs "Reduce by 1/4" t)))
+    (should (string= result "Reduce by ¼"))))
+
+(ert-deftest test-replace-fraction-glyphs-repeated ()
+  "Should handle repeated fractions."
+  (let ((result (test-replace-fraction-glyphs "1/4 and 1/4 and 1/4" t)))
+    (should (string= result "¼ and ¼ and ¼"))))
+
+(ert-deftest test-replace-fraction-glyphs-very-long-text ()
+  "Should handle very long text with many fractions."
+  (let* ((long-text (mapconcat (lambda (_) "1/4") (make-list 50 nil) " "))
+         (result (test-replace-fraction-glyphs long-text t)))
+    (should (string-match-p "¼" result))
+    (should-not (string-match-p "1/4" result))))
+
+(ert-deftest test-replace-fraction-glyphs-bidirectional ()
+  "Should correctly convert back and forth."
+  (let* ((original "Use 1/4 cup")
+         (to-glyph (test-replace-fraction-glyphs original t))
+         (back-to-text (test-replace-fraction-glyphs to-glyph nil)))
+    (should (string= to-glyph "Use ¼ cup"))
+    (should (string= back-to-text original))))
+
+;;; Error Cases
+
+(ert-deftest test-replace-fraction-glyphs-start-greater-than-end ()
+  "Should error when start > end."
+  (should-error
+   (with-temp-buffer
+     (insert "1/4")
+     (cj/--replace-fraction-glyphs (point-max) (point-min) t))
+   :type 'error))
+
+(ert-deftest test-replace-fraction-glyphs-empty-region ()
+  "Should handle empty region (start == end) without error."
+  (with-temp-buffer
+    (insert "1/4")
+    (let ((pos (/ (+ (point-min) (point-max)) 2)))
+      (cj/--replace-fraction-glyphs pos pos t)
+      ;; Should complete without error
+      (should (string= (buffer-string) "1/4")))))
+
+(provide 'test-custom-misc-replace-fraction-glyphs)
+;;; test-custom-misc-replace-fraction-glyphs.el ends here