Cover Lua API validation and formatexpr setup

Add Lua API validation cases for invalid wrap mode, non-boolean
hyphenation, and empty hyphen markers. Also pin that `set_formatexpr`
installs Wrappin's `formatexpr()` as the global default and that new
buffers inherit that setting.

Author: Roundlay

tests/suites/lifecycle.lua

@@ -11,6 +11,7 @@ local support = require("support")
 
 local with_buffer = support.with_buffer
 local assert_lines = support.assert_lines
+local assert_raises = support.assert_raises
 
 local function test_reflows_comment_block_and_restores_exact_original()
     with_buffer({
@@ -167,6 +168,104 @@ end
 -- current one. Cursor motion (restore_cursor) still targets the current
 -- window, which is a deliberate asymmetry that this test does not pin
 -- directly -- only buffer identity is asserted.
+-- Lua API validation: the three resolve_* helpers each raise on invalid
+-- input. The command parser's invalid-mode path was previously tested;
+-- these cases pin the same error strings fire when invalid values
+-- reach wrappin.run through the Lua API.
+local function test_run_rejects_unknown_wrap_mode()
+    with_buffer({ "alpha beta" }, function()
+        assert_raises(
+            function()
+                wrappin.run({
+                    start_line = 0,
+                    end_line = 0,
+                    max_width = 12,
+                    wrap_mode = "bogus",
+                })
+            end,
+            "Wrappin wrap_mode must be 'normal', 'soft', or 'hard'",
+            "wrappin.run should reject an unknown wrap_mode"
+        )
+    end)
+end
+
+local function test_run_rejects_non_boolean_hyphenate()
+    with_buffer({ "alpha beta" }, function()
+        assert_raises(
+            function()
+                wrappin.run({
+                    start_line = 0,
+                    end_line = 0,
+                    max_width = 12,
+                    hard_wrap_hyphenate = "maybe",
+                })
+            end,
+            "Wrappin hard_wrap_hyphenate must be a boolean",
+            "wrappin.run should reject a non-boolean hyphenate"
+        )
+    end)
+end
+
+local function test_run_rejects_empty_hyphenchar()
+    with_buffer({ "alpha beta" }, function()
+        assert_raises(
+            function()
+                wrappin.run({
+                    start_line = 0,
+                    end_line = 0,
+                    max_width = 12,
+                    hard_wrap_hyphenchar = "",
+                })
+            end,
+            "Wrappin hard_wrap_hyphenchar must be a non-empty string",
+            "wrappin.run should reject an empty hyphenchar"
+        )
+    end)
+end
+
+-- setup({ set_formatexpr = true }) writes vim.o.formatexpr, which sets
+-- both the global default (vim.go) AND the current buffer's local
+-- (vim.bo). New buffers created afterwards inherit the global default.
+-- Pre-existing buffers that were loaded before setup() keep their
+-- stale local value -- documented in the plan as not-pinned here.
+--
+-- Test saves and restores vim.go.formatexpr under pcall so a buggy
+-- plugin change does not leave the global option polluted for later
+-- cases in this run.
+local function test_setup_set_formatexpr_installs_global_default()
+    local saved_global = vim.go.formatexpr
+    local expected = "v:lua.require'wrappin'.formatexpr()"
+
+    local ok, err = pcall(function()
+        with_buffer({ "" }, function()
+            wrappin.setup({ set_formatexpr = true })
+
+            if vim.go.formatexpr ~= expected then
+                error("expected vim.go.formatexpr == " .. expected ..
+                    "\n    got: " .. vim.inspect(vim.go.formatexpr))
+            end
+
+            if vim.bo.formatexpr ~= expected then
+                error("expected current-buffer vim.bo.formatexpr == " .. expected ..
+                    "\n    got: " .. vim.inspect(vim.bo.formatexpr))
+            end
+
+            local new = vim.api.nvim_create_buf(true, false)
+            local new_bo = vim.bo[new].formatexpr
+            pcall(vim.api.nvim_buf_delete, new, { force = true })
+
+            if new_bo ~= expected then
+                error("new buffer should inherit global formatexpr\n    got: " .. vim.inspect(new_bo))
+            end
+        end)
+    end)
+
+    vim.go.formatexpr = saved_global
+    vim.bo.formatexpr = saved_global
+
+    if not ok then error(err, 0) end
+end
+
 local function test_explicit_bufnr_targets_named_buffer()
     -- with_buffer manages buf_a (the current buffer, wiped even on error).
     -- buf_b is a listed non-scratch buffer created by this test; it must
@@ -348,4 +447,8 @@ return {
     { name = "context_scan_limit_zero_disables_inheritance", fn = test_context_scan_limit_zero_disables_inheritance },
     { name = "two_independent_snapshots_restore_in_any_order", fn = test_two_independent_snapshots_restore_in_any_order },
     { name = "explicit_bufnr_targets_named_buffer", fn = test_explicit_bufnr_targets_named_buffer },
+    { name = "run_rejects_unknown_wrap_mode", fn = test_run_rejects_unknown_wrap_mode },
+    { name = "run_rejects_non_boolean_hyphenate", fn = test_run_rejects_non_boolean_hyphenate },
+    { name = "run_rejects_empty_hyphenchar", fn = test_run_rejects_empty_hyphenchar },
+    { name = "setup_set_formatexpr_installs_global_default", fn = test_setup_set_formatexpr_installs_global_default },
 }

tests/support.lua

@@ -84,4 +84,20 @@ function M.assert_command_error(cmd, expected_substring, label)
     end
 end
 
+-- Run `fn` (zero-arg Lua function) and assert it raises with an error
+-- whose message contains `expected_substring`. Parallel to
+-- assert_command_error, for the Lua API surface instead of the Ex
+-- command surface.
+function M.assert_raises(fn, expected_substring, label)
+    local ok, err = pcall(fn)
+
+    if ok then
+        error(label .. "\nexpected call to raise with substring: " .. expected_substring .. "\nactual: call succeeded")
+    end
+
+    if type(err) ~= "string" or err:find(expected_substring, 1, true) == nil then
+        error(label .. "\nexpected error containing: " .. expected_substring .. "\nactual error: " .. tostring(err))
+    end
+end
+
 return M