[thirdparty/systemd.git] / src / test / test-ellipsize.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <stdio.h>

#include "alloc-util.h"
#include "constants.h"
#include "escape.h"
#include "string-util.h"
#include "strv.h"
#include "terminal-util.h"
#include "tests.h"
#include "utf8.h"

static void test_ellipsize_mem_one(const char *s, size_t old_length, size_t new_length) {
        _cleanup_free_ char *n = NULL;
        _cleanup_free_ char *t1 = NULL, *t2 = NULL, *t3 = NULL;
        char buf[LINE_MAX];
        bool has_wide_chars;
        size_t max_width;

        n = memdup_suffix0(s, old_length);

        if (!utf8_is_valid(n))
                /* We don't support invalid sequences… */
                return;

        /* Report out inputs. We duplicate the data so that cellescape
         * can properly report truncated multibyte sequences. */
        log_info("%s \"%s\" old_length=%zu/%zu new_length=%zu", __func__,
                 cellescape(buf, sizeof buf, n),
                 old_length, utf8_console_width(n),
                 new_length);

        /* To keep this test simple, any case with wide chars starts with this glyph */
        has_wide_chars = startswith(s, "你");
        max_width = MIN(utf8_console_width(n), new_length);

        t1 = ellipsize_mem(n, old_length, new_length, 30);
        log_info("30%% → %s utf8_console_width=%zu", t1, utf8_console_width(t1));
        if (!has_wide_chars)
                assert_se(utf8_console_width(t1) == max_width);
        else
                assert_se(utf8_console_width(t1) <= max_width);

        t2 = ellipsize_mem(n, old_length, new_length, 90);
        log_info("90%% → %s utf8_console_width=%zu", t2, utf8_console_width(t2));
        if (!has_wide_chars)
                assert_se(utf8_console_width(t2) == max_width);
        else
                assert_se(utf8_console_width(t2) <= max_width);

        t3 = ellipsize_mem(n, old_length, new_length, 100);
        log_info("100%% → %s utf8_console_width=%zu", t3, utf8_console_width(t3));
        if (!has_wide_chars)
                assert_se(utf8_console_width(t3) == max_width);
        else
                assert_se(utf8_console_width(t3) <= max_width);

        if (new_length >= old_length) {
                ASSERT_STREQ(t1, n);
                ASSERT_STREQ(t2, n);
                ASSERT_STREQ(t3, n);
        }
}

TEST(ellipsize_mem) {
        FOREACH_STRING(s,
                       "_XXXXXXXXXXX_", /* ASCII */
                       "_aąęółśćńżźć_", /* two-byte utf-8 */
                       "გამარჯობა",     /* multi-byte utf-8 */
                       "你好世界",       /* wide characters */
                       "你გą世óoó界")    /* a mix */
                for (ssize_t l = strlen(s); l >= 0; l--)
                        for (ssize_t k = strlen(s) + 1; k >= 0; k--)
                                test_ellipsize_mem_one(s, l, k);
}

static void test_ellipsize_one(const char *p) {
        _cleanup_free_ char *t = NULL;
        t = ellipsize(p, columns(), 70);
        puts(t);
        free(t);
        t = ellipsize(p, columns(), 0);
        puts(t);
        free(t);
        t = ellipsize(p, columns(), 100);
        puts(t);
        free(t);
        t = ellipsize(p, 0, 50);
        puts(t);
        free(t);
        t = ellipsize(p, 1, 50);
        puts(t);
        free(t);
        t = ellipsize(p, 2, 50);
        puts(t);
        free(t);
        t = ellipsize(p, 3, 50);
        puts(t);
        free(t);
        t = ellipsize(p, 4, 50);
        puts(t);
        free(t);
        t = ellipsize(p, 5, 50);
        puts(t);
}

TEST(ellipsize) {
        test_ellipsize_one(DIGITS LETTERS DIGITS LETTERS);
        test_ellipsize_one("한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어");
        test_ellipsize_one("-日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国");
        test_ellipsize_one("中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国-中国中国中国中国中国中国中国中国中国中国中国中国中国");
        test_ellipsize_one("sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd");
        test_ellipsize_one("🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮");
        test_ellipsize_one("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.");
        test_ellipsize_one("shórt");
}

TEST(ellipsize_ansi) {
        const char *s = ANSI_HIGHLIGHT_YELLOW_UNDERLINE "yęllow"
                        ANSI_HIGHLIGHT_GREY_UNDERLINE "grěy"
                        ANSI_HIGHLIGHT_BLUE_UNDERLINE "blue"
                        ANSI_NORMAL "nórmął";
        size_t len = strlen(s);

        for (unsigned percent = 0; percent <= 100; percent += 15)
                for (ssize_t x = 21; x >= 0; x--) {
                        _cleanup_free_ char *t = ellipsize_mem(s, len, x, percent);
                        printf("%02zd: \"%s\"\n", x, t);
                        assert_se(utf8_is_valid(t));

                        if (DEBUG_LOGGING) {
                                _cleanup_free_ char *e = cescape(t);
                                printf("  : \"%s\"\n", e);
                        }
                }
}

TEST(ellipsize_ansi_cats) {
        _cleanup_free_ char *e = NULL, *f = NULL, *g = NULL, *h = NULL;

        /* Make sure we don't cut off in the middle of an ANSI escape sequence. */

        e = ellipsize("01" ANSI_NORMAL "23", 4, 0);
        puts(e);
        ASSERT_STREQ(e, "01" ANSI_NORMAL "23");
        f = ellipsize("ab" ANSI_NORMAL "cd", 4, 90);
        puts(f);
        ASSERT_STREQ(f, "ab" ANSI_NORMAL "cd");

        g = ellipsize("🐱🐱" ANSI_NORMAL "🐱🐱" ANSI_NORMAL, 5, 0);
        puts(g);
        ASSERT_STREQ(g, "…" ANSI_NORMAL "🐱🐱" ANSI_NORMAL);
        h = ellipsize("🐱🐱" ANSI_NORMAL "🐱🐱" ANSI_NORMAL, 5, 90);
        puts(h);
        ASSERT_STREQ(h, "🐱…" ANSI_NORMAL "🐱" ANSI_NORMAL);
}

DEFINE_TEST_MAIN(LOG_INFO);
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
35d811f5 SL	2
	3	#include <stdio.h>
	4
b5efdb8a	5	#include "alloc-util.h"
28db6fbf	6	#include "constants.h"
cb558ab2	7	#include "escape.h"
07630cea	8	#include "string-util.h"
9924aef6	9	#include "strv.h"
07630cea	10	#include "terminal-util.h"
4f7452a8	11	#include "tests.h"
9924aef6	12	#include "utf8.h"
35d811f5	13
9924aef6 ZJS	14	static void test_ellipsize_mem_one(const char *s, size_t old_length, size_t new_length) {
	15	_cleanup_free_ char *n = NULL;
	16	_cleanup_free_ char t1 = NULL, t2 = NULL, *t3 = NULL;
	17	char buf[LINE_MAX];
	18	bool has_wide_chars;
	19	size_t max_width;
	20
	21	n = memdup_suffix0(s, old_length);
	22
	23	if (!utf8_is_valid(n))
	24	/* We don't support invalid sequences… */
	25	return;
	26
	27	/* Report out inputs. We duplicate the data so that cellescape
	28	* can properly report truncated multibyte sequences. */
	29	log_info("%s \"%s\" old_length=%zu/%zu new_length=%zu", __func__,
	30	cellescape(buf, sizeof buf, n),
	31	old_length, utf8_console_width(n),
	32	new_length);
	33
	34	/* To keep this test simple, any case with wide chars starts with this glyph */
	35	has_wide_chars = startswith(s, "你");
	36	max_width = MIN(utf8_console_width(n), new_length);
	37
	38	t1 = ellipsize_mem(n, old_length, new_length, 30);
	39	log_info("30%% → %s utf8_console_width=%zu", t1, utf8_console_width(t1));
	40	if (!has_wide_chars)
	41	assert_se(utf8_console_width(t1) == max_width);
	42	else
	43	assert_se(utf8_console_width(t1) <= max_width);
	44
	45	t2 = ellipsize_mem(n, old_length, new_length, 90);
	46	log_info("90%% → %s utf8_console_width=%zu", t2, utf8_console_width(t2));
	47	if (!has_wide_chars)
	48	assert_se(utf8_console_width(t2) == max_width);
	49	else
	50	assert_se(utf8_console_width(t2) <= max_width);
	51
	52	t3 = ellipsize_mem(n, old_length, new_length, 100);
	53	log_info("100%% → %s utf8_console_width=%zu", t3, utf8_console_width(t3));
	54	if (!has_wide_chars)
	55	assert_se(utf8_console_width(t3) == max_width);
	56	else
	57	assert_se(utf8_console_width(t3) <= max_width);
	58
	59	if (new_length >= old_length) {
c79e88b3 IK	60	ASSERT_STREQ(t1, n);
	61	ASSERT_STREQ(t2, n);
	62	ASSERT_STREQ(t3, n);
9924aef6 ZJS	63	}
	64	}
	65
4f7452a8	66	TEST(ellipsize_mem) {
9924aef6 ZJS	67	FOREACH_STRING(s,
	68	"_XXXXXXXXXXX_", /* ASCII */
	69	"_aąęółśćńżźć_", /* two-byte utf-8 */
	70	"გამარჯობა", /* multi-byte utf-8 */
	71	"你好世界", /* wide characters */
	72	"你გą世óoó界") /* a mix */
5980d463 ZJS	73	for (ssize_t l = strlen(s); l >= 0; l--)
5980d463 ZJS	74	for (ssize_t k = strlen(s) + 1; k >= 0; k--)
9924aef6 ZJS	75	test_ellipsize_mem_one(s, l, k);
	76	}
	77
	78	static void test_ellipsize_one(const char *p) {
3d41b6b8	79	_cleanup_free_ char *t = NULL;
35d811f5 SL	80	t = ellipsize(p, columns(), 70);
35d811f5 SL	81	puts(t);
c30a49b2 LP	82	free(t);
	83	t = ellipsize(p, columns(), 0);
	84	puts(t);
	85	free(t);
	86	t = ellipsize(p, columns(), 100);
	87	puts(t);
	88	free(t);
	89	t = ellipsize(p, 0, 50);
	90	puts(t);
	91	free(t);
	92	t = ellipsize(p, 1, 50);
	93	puts(t);
	94	free(t);
	95	t = ellipsize(p, 2, 50);
	96	puts(t);
	97	free(t);
	98	t = ellipsize(p, 3, 50);
	99	puts(t);
	100	free(t);
	101	t = ellipsize(p, 4, 50);
	102	puts(t);
	103	free(t);
	104	t = ellipsize(p, 5, 50);
	105	puts(t);
35d811f5 SL	106	}
35d811f5 SL	107
4f7452a8	108	TEST(ellipsize) {
9924aef6 ZJS	109	test_ellipsize_one(DIGITS LETTERS DIGITS LETTERS);
	110	test_ellipsize_one("한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어한국어");
	111	test_ellipsize_one("-日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国日本国");
	112	test_ellipsize_one("中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国中国-中国中国中国中国中国中国中国中国中国中国中国中国中国");
	113	test_ellipsize_one("sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd sÿstëmd");
	114	test_ellipsize_one("🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮🐮");
	115	test_ellipsize_one("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.");
	116	test_ellipsize_one("shórt");
	117	}
	118
cb558ab2 ZJS	119	TEST(ellipsize_ansi) {
	120	const char *s = ANSI_HIGHLIGHT_YELLOW_UNDERLINE "yęllow"
	121	ANSI_HIGHLIGHT_GREY_UNDERLINE "grěy"
	122	ANSI_HIGHLIGHT_BLUE_UNDERLINE "blue"
	123	ANSI_NORMAL "nórmął";
	124	size_t len = strlen(s);
	125
	126	for (unsigned percent = 0; percent <= 100; percent += 15)
	127	for (ssize_t x = 21; x >= 0; x--) {
	128	_cleanup_free_ char *t = ellipsize_mem(s, len, x, percent);
	129	printf("%02zd: \"%s\"\n", x, t);
	130	assert_se(utf8_is_valid(t));
	131
	132	if (DEBUG_LOGGING) {
	133	_cleanup_free_ char *e = cescape(t);
	134	printf(" : \"%s\"\n", e);
	135	}
	136	}
	137	}
	138
	139	TEST(ellipsize_ansi_cats) {
7e48f3ba	140	_cleanup_free_ char e = NULL, f = NULL, g = NULL, h = NULL;
cb558ab2 ZJS	141
	142	/* Make sure we don't cut off in the middle of an ANSI escape sequence. */
	143
	144	e = ellipsize("01" ANSI_NORMAL "23", 4, 0);
	145	puts(e);
c79e88b3	146	ASSERT_STREQ(e, "01" ANSI_NORMAL "23");
cb558ab2 ZJS	147	f = ellipsize("ab" ANSI_NORMAL "cd", 4, 90);
cb558ab2 ZJS	148	puts(f);
c79e88b3	149	ASSERT_STREQ(f, "ab" ANSI_NORMAL "cd");
cb558ab2 ZJS	150
	151	g = ellipsize("🐱🐱" ANSI_NORMAL "🐱🐱" ANSI_NORMAL, 5, 0);
	152	puts(g);
c79e88b3	153	ASSERT_STREQ(g, "…" ANSI_NORMAL "🐱🐱" ANSI_NORMAL);
cb558ab2 ZJS	154	h = ellipsize("🐱🐱" ANSI_NORMAL "🐱🐱" ANSI_NORMAL, 5, 90);
cb558ab2 ZJS	155	puts(h);
c79e88b3	156	ASSERT_STREQ(h, "🐱…" ANSI_NORMAL "🐱" ANSI_NORMAL);
cb558ab2 ZJS	157	}
cb558ab2 ZJS	158
4f7452a8	159	DEFINE_TEST_MAIN(LOG_INFO);