wcwidth 0.9.0__tar.gz → 0.9.1__tar.gz

{wcwidth-0.9.0 → wcwidth-0.9.1}/.gitignore

@@ -14,7 +14,11 @@ wheelhouse
 *.so
 dist
 docs/_build
+# generated from the C headers by bin/update-docs.py, not committed
+docs/api_c.rst
 htmlcov
+htmlcov-c
+coverage-c.lcov
 .coveralls.yml
 data
 .DS_Store

{wcwidth-0.9.0 → wcwidth-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wcwidth
-Version: 0.9.0
+Version: 0.9.1
 Summary: Measures the displayed width of unicode strings in a terminal
 Author-email: Jeff Quast <contact@jeffquast.com>
 Project-URL: Homepage, https://github.com/jquast/wcwidth

{wcwidth-0.9.0 → wcwidth-0.9.1}/bin/update-docs.py

@@ -6,7 +6,9 @@ from __future__ import annotations
 # std imports
 import os
 import re
+import sys
 import glob
+import argparse
 import textwrap
 import importlib.util
 
@@ -21,7 +23,7 @@ import jinja2
 # docs/unicode_version.rst, docs/libwcwidth.rst, and the list_term_programs()
 # example in README.rst.
 
-PATH_UP = os.path.relpath(os.path.join(os.path.dirname(__file__), os.path.pardir))
+PATH_UP = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 JINJA_ENV = jinja2.Environment(
     loader=jinja2.FileSystemLoader(os.path.join(PATH_UP, 'code_templates')),
     keep_trailing_newline=True,
@@ -458,21 +460,29 @@ def report(label: str, changed: bool) -> None:
     print(f'{label}: {"updated" if changed else "up-to-date"}')
 
 
-def write_if_changed(path: str, content: str, label: str) -> None:
-    """Write *content* to *path* only if it differs, reporting the result."""
+def write_if_changed(path: str, content: str, label: str, check: bool = False) -> bool:
+    """
+    Write *content* to *path* only if it differs, reporting and returning whether it did.
+
+    With *check*, report the difference without writing, so a stale file fails the run.
+    """
     try:
         with open(path, encoding='utf-8') as fin:
             original = fin.read()
     except FileNotFoundError:
         original = ''
-    if content != original:
-        new_path = path + '.new'
-        with open(new_path, 'w', encoding='utf-8', newline='\n') as fout:
-            fout.write(content)
-        os.replace(new_path, path)
-        print(f'{label}: updated')
-    else:
+    if content == original:
         print(f'{label}: up-to-date')
+        return False
+    if check:
+        print(f'{label}: out of date, run bin/update-docs.py')
+        return True
+    new_path = path + '.new'
+    with open(new_path, 'w', encoding='utf-8', newline='\n') as fout:
+        fout.write(content)
+    os.replace(new_path, path)
+    print(f'{label}: updated')
+    return True
 
 
 def update_libwcwidth_term_programs() -> bool:
@@ -545,18 +555,31 @@ def unicode_version_page() -> str:
         source_headers=unicode_source_headers())
 
 
-def main() -> None:
-    """Regenerate all generated documentation files."""
-    write_if_changed(API_C_OUTPUT, render_api_doc(), 'docs/api_c.rst')
+def main(api_only: bool = False, check: bool = False) -> int:
+    """Regenerate all generated documentation files, or only docs/api_c.rst."""
+    stale = write_if_changed(API_C_OUTPUT, render_api_doc(), 'docs/api_c.rst', check)
+    if api_only:
+        # api_c.rst is parsed from the C headers, but everything below reads the
+        # Unicode sources under data/, which only `tox -e fetch` downloads.
+        return int(check and stale)
     write_if_changed(os.path.join(PATH_DOCS, 'unicode_version.rst'),
-                     unicode_version_page(), 'docs/unicode_version.rst')
+                     unicode_version_page(), 'docs/unicode_version.rst', check)
     report('docs/libwcwidth.rst: canonical terminal names',
            update_libwcwidth_term_programs())
     report('docs/libwcwidth.rst: Unicode version',
            update_libwcwidth_unicode_version())
     report('README.rst: list_term_programs() example',
            update_readme_term_programs())
+    return int(check and stale)
 
 
 if __name__ == '__main__':
-    main()
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--api-only', action='store_true',
+                        help='regenerate docs/api_c.rst only, which needs no Unicode data')
+    parser.add_argument('--check', action='store_true',
+                        help='report stale output instead of writing it, for CI')
+    args = parser.parse_args()
+    if args.check and not args.api_only:
+        parser.error('--check needs --api-only: the other outputs read the fetched Unicode data')
+    sys.exit(main(api_only=args.api_only, check=args.check))

{wcwidth-0.9.0 → wcwidth-0.9.1}/docs/developing.rst

@@ -18,6 +18,12 @@ To run tests with detailed coverage reporting showing missing lines::
 
    tox -epy314 -- --cov-report=term-missing
 
+The C11 library's coverage is measured separately, since coverage.py cannot see compiled
+code.  This merges two instrumented runs, the C11 test suite and the Python suite driving
+the C extension, and writes ``coverage-c.lcov`` and ``htmlcov-c/index.html``::
+
+   tox -e c_coverage
+
 Updating Unicode Version
 ------------------------
 

{wcwidth-0.9.0 → wcwidth-0.9.1}/docs/history.rst

@@ -2,7 +2,13 @@
 History
 =======
 
-0.9.0 *unreleased* ('jq/libwcwidth-shim-wheels' branch)
+0.9.1 *2026-09-23*
+  * **Bugfix** a regression in 0.9.0 Python and libwcwidth_ `width()`_ mis-measured CSI sequences
+    over 64 bytes, `PR #271`_.
+  * **Performance** improvement of ~15% for 11 many Python API functions when using
+    default ``ambiguous_width`` and ``term_program`` arguments. `PR #273`_
+
+0.9.0 *2026-09-23*
   * **New** Optional CPython extension using libwcwidth_, improving performance 10-58x `PR #248`_.
   * **Drop Support** for Python 3.8, `PR #248`_.
 
@@ -299,6 +305,8 @@ https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c::
 .. _`PR #253`: https://github.com/jquast/wcwidth/pull/253
 .. _`PR #259`: https://github.com/jquast/wcwidth/pull/259
 .. _`PR #262`: https://github.com/jquast/wcwidth/pull/262
+.. _`PR #271`: https://github.com/jquast/wcwidth/pull/271
+.. _`PR #273`: https://github.com/jquast/wcwidth/pull/273
 .. _`Issue #101`: https://github.com/jquast/wcwidth/issues/101
 .. _`Issue #155`: https://github.com/jquast/wcwidth/issues/155
 .. _`Issue #211`: https://github.com/jquast/wcwidth/issues/211

{wcwidth-0.9.0 → wcwidth-0.9.1}/docs/libwcwidth.rst

@@ -10,16 +10,20 @@ The Python documentation_ closely matches this C library.  The C API adds UTF-8
 array interfaces.
 
 The lowest-level functions are derived from POSIX.1-2001 and POSIX.1-2008 `wcwidth(3)`_ and
-`wcswidth(3)`_, which this library implements as `wcwidth_u32()`_ and `wcswidth_u32()`_.  These
-functions return -1 when C0 and C1 control codes other than NUL are present; NUL measures as
-zero-width.  They do not parse terminal escape sequences: any escape sequence contains control
-codes, so these functions return -1 for it.
+`wcswidth(3)`_, which this library implements as :ref:`wcwidth_u32() <libwcwidth-wcwidth>` and
+:ref:`wcswidth_u32() <libwcwidth-wcswidth>`.  These functions return -1 when C0 and C1 control
+codes other than NUL are present; NUL measures as zero-width.
+:ref:`wcstwidth_u8() <libwcwidth-wcstwidth>` applies corrections for a specific terminal program,
+as described in the Python Corrections_ documentation.
 
-`wcwidth_width_u8()`_ is a higher-level wrapper of `wcswidth_u8()`_ that also measures terminal
-control sequences, like colors, bold, tabstops, and horizontal cursor movement.
+:ref:`wcwidth_width_u8() <libwcwidth-width>` is a higher-level wrapper of
+:ref:`wcswidth_u8() <libwcwidth-wcswidth>` that also measures terminal control sequences, like
+colors, bold, tabstops, and horizontal cursor movement.
 
-`wcstwidth_u8()`_ applies corrections for a specific terminal program and version, as described
-in the Python Corrections_ documentation.
+The text transforms have their own sections:
+:ref:`wcwidth_ljust_u8() <libwcwidth-align>` with ``rjust`` and ``center``,
+:ref:`wcwidth_clip_u8() <libwcwidth-clip>`, :ref:`wcwidth_wrap_u8() <libwcwidth-wrap>`, and
+:ref:`wcwidth_escape_strip() <libwcwidth-escape-strip>`.
 
 Quick Start
 -----------
@@ -187,6 +191,8 @@ throughout, or use the ``_u32`` forms and re-encode the result.  `wcwidth_encode
 Re-encoding to a legacy charset is the caller's iconv(3) or ICU (``ucnv_*``) call; a byte cast
 works when every codepoint fits the target, and iconv reports ``EILSEQ`` when one does not.
 
+.. _libwcwidth-wcwidth:
+
 wcwidth_u32()
 ~~~~~~~~~~~~~
 
@@ -206,6 +212,8 @@ U+2640 above is Ambiguous, so it answers to the second argument, while U+2630 is
 2 under either setting.  A single codepoint needs no ``_u8`` variant; use `wcswidth_u8()`_ to
 measure text.
 
+.. _libwcwidth-wcswidth:
+
 wcswidth_u32() and wcswidth_u8()
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -219,6 +227,8 @@ when any control code other than NUL is present:
     wcswidth_u32(family, 5, 1)   /* man ZWJ woman ZWJ girl */  2
     wcswidth_u8("café", 5, 1)                                  4
 
+.. _libwcwidth-wcstwidth:
+
 wcstwidth_u32() and wcstwidth_u8()
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -230,6 +240,8 @@ argument applies terminal-specific corrections:
     wcswidth_u8("☰", 3, 1)               /* U+2630, wide */  2
     wcstwidth_u8("☰", 3, 1, "vte")                            1
 
+.. _libwcwidth-width:
+
 wcwidth_width_u32() and wcwidth_width_u8()
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -261,6 +273,8 @@ codes:
         /* err is WCWIDTH_ERROR_VERTICAL_CTRL */
     }
 
+.. _libwcwidth-align:
+
 wcwidth_ljust_u8(), wcwidth_rjust_u8(), and wcwidth_center_u8()
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -288,6 +302,8 @@ returns a ``malloc``\ 'd NUL-terminated string the caller must ``free``:
     /* "*café*" */
     free(out);
 
+.. _libwcwidth-clip:
+
 wcwidth_clip_u8()
 ~~~~~~~~~~~~~~~~~
 
@@ -344,6 +360,8 @@ Movement is reported wherever it appears; the OSC sequences only where the clip
 `wcwidth_clip_u32()`_ is the codepoint-array form, returning a ``malloc``\ 'd array of ``*out_len``
 codepoints.
 
+.. _libwcwidth-wrap:
+
 wcwidth_wrap_u8() and wcwidth_wrap_u8_text()
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -383,6 +401,8 @@ unbreakable unit, so a line is never broken inside one, even at a space or hyphe
 text.  Python's `wrap()`_ behaves the same way.  `wcwidth_wrap_u32()`_ and `wcwidth_wrap_u32_text()`_ are the
 codepoint-array forms.
 
+.. _libwcwidth-escape-strip:
+
 wcwidth_escape_strip()
 ~~~~~~~~~~~~~~~~~~~~~~
 

{wcwidth-0.9.0 → wcwidth-0.9.1}/libwcwidth/include/wcwidth/wcwidth_config.h

@@ -18,8 +18,8 @@ extern "C" {
 
 #define WCWIDTH_VERSION_MAJOR 0
 #define WCWIDTH_VERSION_MINOR 9
-#define WCWIDTH_VERSION_PATCH 0
-#define WCWIDTH_VERSION "0.9.0"
+#define WCWIDTH_VERSION_PATCH 1
+#define WCWIDTH_VERSION "0.9.1"
 
 /* Unicode version the library tables were generated from. */
 #define WCWIDTH_UNICODE_VERSION "18.0.0"

{wcwidth-0.9.0 → wcwidth-0.9.1}/libwcwidth/src/width.c

@@ -90,12 +90,6 @@ is_illegal_ctrl(uint32_t ucs)
     if (ucs >= 28 && ucs <= 31) {
         return true; /* FS, GS, RS, US */
     }
-    if (ucs == 0x7F) {
-        return true; /* DEL */
-    }
-    if (ucs >= 0x80 && ucs <= 0x9F) {
-        return true; /* C1 control characters */
-    }
     return false;
 }
 
@@ -417,7 +411,9 @@ static size_t
 escape_span_u32(const uint32_t *cp, size_t n, size_t idx)
 {
     char buf[64];
+    char *heap = NULL;
     size_t cap = 16;
+    size_t span = 1;
     wcwidth_esc_result_t result;
 
     if (idx + 1 < n && (cp[idx + 1] == '(' || cp[idx + 1] == ')')) {
@@ -428,26 +424,56 @@ escape_span_u32(const uint32_t *cp, size_t n, size_t idx)
     }
 
     /*
-     * Copy 16 first: nearly every sequence is shorter, and copying 64 each
-     * time dominates on SGR-dense text.  The classifier misreads a truncated
-     * run as an unterminated sequence, so widen and retry before classifying.
+     * Widen before classifying: the classifier reads a truncated run as
+     * unterminated.  Stop once a byte has ended the sequence, or the copy would
+     * run on into the text that follows, and only a CSI with no final byte
+     * takes a heap copy.
      */
     for (;;) {
+        char *out = (heap != NULL) ? heap : buf;
+        bool open = true; /* the sequence has no final byte yet */
         size_t j = 0;
 
         while (j < cap && idx + j < n && cp[idx + j] < 0x80) {
-            buf[j] = (char) cp[idx + j];
+            uint32_t b = cp[idx + j];
+
+            if (j > 1 && (b < 0x20 || b > 0x3F)) {
+                open = false;
+            }
+            out[j] = (char) b;
             j++;
         }
-        if (j == cap && idx + j < n && cp[idx + j] < 0x80 && cap < sizeof(buf)) {
-            cap = sizeof(buf);
-            continue;
+        if (open && j == cap && idx + j < n && cp[idx + j] < 0x80) {
+            if (cap < sizeof(buf)) {
+                cap = sizeof(buf);
+                continue;
+            }
+            if (heap == NULL && cp[idx + 1] == '[') {
+                size_t run = cap;
+
+                while (idx + run < n && cp[idx + run] < 0x80) {
+                    run++;
+                }
+                heap = (char *) malloc(run);
+                if (heap == NULL) {
+                    return 1;
+                }
+                cap = run;
+                continue;
+            }
         }
-        if (j == 0 || !wcwidth_escape_classify(buf, j, 0, &result) || result.length == 0) {
-            return 1;
+        if (j == 0 || !wcwidth_escape_classify(out, j, 0, &result) || result.length == 0) {
+            span = 1;
         }
-        return result.length;
+        else {
+            span = result.length;
+        }
+        break;
+    }
+    if (heap != NULL) {
+        free(heap);
     }
+    return span;
 }
 
 /*

{wcwidth-0.9.0 → wcwidth-0.9.1}/libwcwidth/tests/test_align.c

@@ -234,6 +234,34 @@ TEST(align_control_codes_strict)
     ASSERT_EQ(WCWIDTH_ERROR_ILLEGAL_CTRL, error);
 }
 
+TEST(null_opts_defaults)
+{
+    uint32_t cps[] = {'h', 'i'};
+    size_t len = 0;
+    int error = WCWIDTH_ERROR_NONE;
+    char *s;
+    uint32_t *u;
+
+    s = wcwidth_ljust_u8("hi", 2, WCWIDTH_PARSE, NULL, &len, &error);
+    ASSERT_EQ(2, len);
+    free(s);
+    s = wcwidth_rjust_u8("hi", 2, WCWIDTH_PARSE, NULL, &len, &error);
+    ASSERT_EQ(2, len);
+    free(s);
+    s = wcwidth_center_u8("hi", 2, WCWIDTH_PARSE, NULL, &len, &error);
+    ASSERT_EQ(2, len);
+    free(s);
+    u = wcwidth_ljust_u32(cps, 2, WCWIDTH_PARSE, NULL, &len, &error);
+    ASSERT_EQ(2, len);
+    free(u);
+    u = wcwidth_rjust_u32(cps, 2, WCWIDTH_PARSE, NULL, &len, &error);
+    ASSERT_EQ(2, len);
+    free(u);
+    u = wcwidth_center_u32(cps, 2, WCWIDTH_PARSE, NULL, &len, &error);
+    ASSERT_EQ(2, len);
+    free(u);
+}
+
 int
 main(void)
 {
@@ -247,5 +275,6 @@ main(void)
     RUN_TEST(rjust_huge_dest_width_multibyte_fill);
     RUN_TEST(center_huge_dest_width);
     RUN_TEST(align_control_codes_strict);
+    RUN_TEST(null_opts_defaults);
     return test_summary();
 }

{wcwidth-0.9.0 → wcwidth-0.9.1}/libwcwidth/tests/test_clip.c

@@ -143,6 +143,42 @@ TEST(unsupported_osc)
     cs_assert("ab\x1b]0;t\x07xy", 0, 3, "ab\x1b]0;t\x07x");
 }
 
+TEST(null_opts_and_tabsize_zero)
+{
+    size_t len = 0;
+    int error = WCWIDTH_ERROR_NONE;
+    wcwidth_clip_opts_t opts = WCWIDTH_CLIP_OPTS_DEFAULT;
+    char *s;
+
+    s = wcwidth_clip_u8("a\tb", 3, WCWIDTH_PARSE, NULL, &len, &error);
+    ASSERT_NOT_NULL(s);
+    free(s);
+
+    opts.tabsize = 0;
+    s = wcwidth_clip_u8("a\tb", 3, WCWIDTH_PARSE, &opts, &len, &error);
+    ASSERT_STREQ("a\tb", s);
+    free(s);
+}
+
+TEST(u32_null_opts_and_past_end)
+{
+    uint32_t cps[] = {'h', 'i'};
+    size_t len = 0;
+    int error = WCWIDTH_ERROR_NONE;
+    wcwidth_clip_opts_t opts = WCWIDTH_CLIP_OPTS_DEFAULT;
+    uint32_t *u;
+
+    u = wcwidth_clip_u32(cps, 2, WCWIDTH_PARSE, NULL, &len, &error);
+    ASSERT_NOT_NULL(u);
+    free(u);
+
+    opts.v_start = 5;
+    opts.v_end = 9;
+    u = wcwidth_clip_u32(cps, 2, WCWIDTH_PARSE, &opts, &len, &error);
+    ASSERT_NOT_NULL(u);
+    free(u);
+}
+
 int
 main(void)
 {
@@ -154,5 +190,7 @@ main(void)
     RUN_TEST(tab_captures_style);
     RUN_TEST(unsupported_cursor_movement);
     RUN_TEST(unsupported_osc);
+    RUN_TEST(null_opts_and_tabsize_zero);
+    RUN_TEST(u32_null_opts_and_past_end);
     return test_summary();
 }

{wcwidth-0.9.0 → wcwidth-0.9.1}/libwcwidth/tests/test_sgr.c

@@ -162,6 +162,55 @@ TEST(to_escape_colon_form)
     ASSERT_STREQ("\x1b[38;2;10;20;30m", buf);
 }
 
+TEST(attribute_and_color_codes)
+{
+    static const char *const active[] = {"2",  "3",  "5",  "6",  "7",  "8",      "9",
+                                         "21", "30", "37", "40", "47", "48;5;9", "48;2;1;2;3"};
+    size_t i;
+    wcwidth_sgr_state_t s;
+
+    for (i = 0; i < sizeof(active) / sizeof(active[0]); i++) {
+        s = WCWIDTH_SGR_STATE_DEFAULT;
+        wcwidth_sgr_update(&s, active[i], strlen(active[i]));
+        ASSERT_TRUE(wcwidth_sgr_is_active(&s));
+    }
+
+    s = WCWIDTH_SGR_STATE_DEFAULT;
+    wcwidth_sgr_update(&s, "31;41", 5);
+    ASSERT_TRUE(wcwidth_sgr_is_active(&s));
+    wcwidth_sgr_update(&s, "39", 2);
+    ASSERT_TRUE(wcwidth_sgr_is_active(&s));
+    wcwidth_sgr_update(&s, "49", 2);
+    ASSERT_FALSE(wcwidth_sgr_is_active(&s));
+
+    s = WCWIDTH_SGR_STATE_DEFAULT;
+    wcwidth_sgr_update(&s, "1;2;3;4;5;6;7;8;9;21", 20);
+    ASSERT_TRUE(wcwidth_sgr_is_active(&s));
+    wcwidth_sgr_update(&s, "22;23;24;25;27;28;29", 20);
+    ASSERT_FALSE(wcwidth_sgr_is_active(&s));
+
+    s = WCWIDTH_SGR_STATE_DEFAULT;
+    wcwidth_sgr_update(&s, "38;5;99999999999999", 19);
+    ASSERT_TRUE(wcwidth_sgr_is_active(&s));
+
+    {
+        char many[512];
+        size_t p;
+
+        for (p = 0; p < sizeof(many) - 1; p++) {
+            many[p] = (p % 2 == 0) ? '1' : ';';
+        }
+        many[p] = '\0';
+        s = WCWIDTH_SGR_STATE_DEFAULT;
+        wcwidth_sgr_update(&s, many, p);
+        ASSERT_TRUE(s.bold);
+
+        s = WCWIDTH_SGR_STATE_DEFAULT;
+        wcwidth_sgr_update(&s, ";;1", 3);
+        ASSERT_TRUE(s.bold);
+    }
+}
+
 int
 main(void)
 {
@@ -171,5 +220,6 @@ main(void)
     RUN_TEST(to_escape_bounded);
     RUN_TEST(to_escape_colon_form);
     RUN_TEST(propagate_basic);
+    RUN_TEST(attribute_and_color_codes);
     return test_summary();
 }

{wcwidth-0.9.0 → wcwidth-0.9.1}/libwcwidth/tests/test_text_sizing.c

@@ -40,10 +40,23 @@ TEST(display_width_basic)
     ASSERT_EQ(3, wcwidth_ts_display_width(&ts, 1));
 }
 
+TEST(parse_invalid_and_clamped)
+{
+    wcwidth_ts_params_t params;
+
+    ASSERT_TRUE(wcwidth_ts_parse_params("z=1", 3, &params));  /* unknown key */
+    ASSERT_TRUE(wcwidth_ts_parse_params("s=-5", 4, &params)); /* clamped low */
+    ASSERT_TRUE(wcwidth_ts_parse_params("s=", 2, &params));   /* no digits */
+    ASSERT_TRUE(wcwidth_ts_parse_params("s=2x", 4, &params)); /* trailing junk */
+    ASSERT_TRUE(wcwidth_ts_parse_params("s=99999999999999999999", 22, &params));
+    ASSERT_TRUE(params.scale >= 1); /* saturated, then clamped high */
+}
+
 int
 main(void)
 {
     RUN_TEST(parse_basic);
     RUN_TEST(display_width_basic);
+    RUN_TEST(parse_invalid_and_clamped);
     return test_summary();
 }

{wcwidth-0.9.0 → wcwidth-0.9.1}/libwcwidth/tests/test_textwrap.c

@@ -240,6 +240,55 @@ TEST(wrap_lone_continuation_bytes)
     }
 }
 
+TEST(wrap_max_lines_placeholder)
+{
+    char *out;
+    size_t len;
+    wcwidth_wrap_opts_t o = WCWIDTH_WRAP_OPTS_DEFAULT;
+    const char *exp[] = {"aa bb [...]"};
+
+    o.width = 11;
+    o.max_lines = 1;
+    ASSERT_EQ(0, wcwidth_wrap_u8("aa bb cccccccc", 14, &o, &out, &len));
+    check_lines(out, len, exp, 1);
+    free(out);
+
+    o = WCWIDTH_WRAP_OPTS_DEFAULT;
+    o.width = 4;
+    o.max_lines = 1;
+    ASSERT_EQ(-2, wcwidth_wrap_u8("aaaa bbbb", 9, &o, &out, &len));
+
+    o = WCWIDTH_WRAP_OPTS_DEFAULT;
+    o.width = 6;
+    o.max_lines = 1;
+    ASSERT_EQ(0, wcwidth_wrap_u8("aa bbbb", 7, &o, &out, &len));
+    free(out);
+
+    o = WCWIDTH_WRAP_OPTS_DEFAULT;
+    o.width = 6;
+    o.max_lines = 2;
+    ASSERT_EQ(0, wcwidth_wrap_u8("aa bb cc dd ee", 14, &o, &out, &len));
+    free(out);
+
+    o = WCWIDTH_WRAP_OPTS_DEFAULT;
+    o.width = 11;
+    o.max_lines = 2;
+    ASSERT_EQ(0, wcwidth_wrap_u8("aa bb ccccccccc dd", 18, &o, &out, &len));
+    free(out);
+
+    o = WCWIDTH_WRAP_OPTS_DEFAULT;
+    o.width = 3;
+    o.expand_tabs = false;
+    ASSERT_EQ(0, wcwidth_wrap_u8("a\tb", 3, &o, &out, &len));
+    free(out);
+
+    o = WCWIDTH_WRAP_OPTS_DEFAULT;
+    o.width = 2;
+    o.break_long_words = false;
+    ASSERT_EQ(0, wcwidth_wrap_u8("abcdef", 6, &o, &out, &len));
+    free(out);
+}
+
 int
 main(void)
 {
@@ -251,5 +300,6 @@ main(void)
     RUN_TEST(wrap_lines_u8);
     RUN_TEST(wrap_tabsize_zero);
     RUN_TEST(wrap_lone_continuation_bytes);
+    RUN_TEST(wrap_max_lines_placeholder);
     return test_summary();
 }

{wcwidth-0.9.0 → wcwidth-0.9.1}/libwcwidth/tests/test_utf8.c

@@ -50,9 +50,27 @@ TEST(encode_roundtrip)
     }
 }
 
+TEST(decode_malformed)
+{
+    static const char *const bad[] = {
+        "\xf8",     "\xff",         "\xe2\x82",     "\xe2\x28\xa1",
+        "\xc0\xaf", "\xe0\x80\xaf", "\xed\xa0\x80", "\xf4\x90\x80\x80"};
+    size_t i;
+    uint32_t cp = 0;
+
+    ASSERT_EQ(0, wcwidth_utf8_decode_single("", 0, &cp));
+    for (i = 0; i < sizeof(bad) / sizeof(bad[0]); i++) {
+        size_t used = wcwidth_utf8_decode_single(bad[i], strlen(bad[i]), &cp);
+
+        ASSERT_EQ(0xFFFD, cp);
+        ASSERT_TRUE(used >= 1 && used <= strlen(bad[i]));
+    }
+}
+
 int
 main(void)
 {
     RUN_TEST(encode_roundtrip);
+    RUN_TEST(decode_malformed);
     return test_summary();
 }

{wcwidth-0.9.0 → wcwidth-0.9.1}/libwcwidth/tests/test_wcswidth.c

@@ -88,6 +88,12 @@ TEST(wcstwidth_terminal_overrides)
     ASSERT_EQ(2, wcstwidth_u32(family, 5, 1, "kitty"));
 }
 
+TEST(null_input)
+{
+    ASSERT_EQ(0, wcswidth_u8(NULL, 0, 1));
+    ASSERT_EQ(0, wcstwidth_u8(NULL, 0, 1, "kitty"));
+}
+
 int
 main(void)
 {
@@ -97,5 +103,6 @@ main(void)
     RUN_TEST(wcstwidth_u8_basic);
     RUN_TEST(wcstwidth_u8_long);
     RUN_TEST(wcstwidth_terminal_overrides);
+    RUN_TEST(null_input);
     return test_summary();
 }