Re: [dm-devel] [PATCH 2/9] libmultipath: strbuf: simple api for growing string buffers

[Benjamin Marzinski <bmarzins@redhat.com>]

On Thu, Jul 15, 2021 at 12:52:16PM +0200, mwilck@suse.com wrote:
> From: Martin Wilck <mwilck@suse.com>
> 
> Add an API for string buffers that grow in size as text is added.
> This API will be useful in several places of the multipath-tools code
> base. Add unit tests for these helpers, too.
> 

This looks good. I have a couple of nitpicks, but none of them are
actually bugs, so if you prefer what you have, you can ignore them.

> Signed-off-by: Martin Wilck <mwilck@suse.com>
> ---
>  libmultipath/Makefile |   2 +-
>  libmultipath/strbuf.c | 207 +++++++++++++++++++++
>  libmultipath/strbuf.h | 168 +++++++++++++++++
>  tests/Makefile        |   3 +-
>  tests/strbuf.c        | 412 ++++++++++++++++++++++++++++++++++++++++++
>  5 files changed, 790 insertions(+), 2 deletions(-)
>  create mode 100644 libmultipath/strbuf.c
>  create mode 100644 libmultipath/strbuf.h
>  create mode 100644 tests/strbuf.c
> 
> diff --git a/libmultipath/Makefile b/libmultipath/Makefile
> index e7254f3..7f3921c 100644
> --- a/libmultipath/Makefile
> +++ b/libmultipath/Makefile
> @@ -53,7 +53,7 @@ OBJS = memory.o parser.o vector.o devmapper.o callout.o \
>  	log.o configure.o structs_vec.o sysfs.o prio.o checkers.o \
>  	lock.o file.o wwids.o prioritizers/alua_rtpg.o prkey.o \
>  	io_err_stat.o dm-generic.o generic.o foreign.o nvme-lib.o \
> -	libsg.o valid.o
> +	libsg.o valid.o strbuf.o
>  
>  all:	$(DEVLIB)
>  
> diff --git a/libmultipath/strbuf.c b/libmultipath/strbuf.c
> new file mode 100644
> index 0000000..8422a50
> --- /dev/null
> +++ b/libmultipath/strbuf.c
> @@ -0,0 +1,207 @@
> +/*
> + * Copyright (c) 2021 SUSE LLC
> + * SPDX-License-Identifier: GPL-2.0-only
> + */
> +#include <inttypes.h>
> +#include <stdint.h>
> +#include <limits.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <stdarg.h>
> +#include <stdbool.h>
> +#include <stdio.h>
> +#include <assert.h>
> +#include "strbuf.h"
> +
> +static const char empty_str[] = "";
> +
> +const char *get_strbuf_str(const struct strbuf *buf)
> +{
> +	return buf->buf ? buf->buf : empty_str;
> +}
> +
> +char *steal_strbuf_str(struct strbuf *buf)
> +{
> +	char *p = buf->buf;
> +
> +	buf->buf = NULL;
> +	buf->size = buf->offs = 0;
> +	return p;
> +}
> +
> +size_t get_strbuf_len(const struct strbuf *buf)
> +{
> +	return buf->offs;
> +}
> +
> +static bool strbuf_is_sane(const struct strbuf *buf)
> +{
> +	return buf && ((!buf->buf && !buf->size && !buf->offs) ||
> +		       (buf->buf && buf->size && buf->size > buf->offs));
> +}
> +
> +void reset_strbuf(struct strbuf *buf)
> +{
> +	free(buf->buf);
> +	buf->buf = NULL;
> +	buf->size = buf->offs = 0;
> +}
> +
> +void free_strbuf(struct strbuf *buf)
> +{
> +	if (!buf)
> +		return;
> +	reset_strbuf(buf);
> +	free(buf);
> +}
> +
> +struct strbuf *new_strbuf(void)
> +{
> +	return calloc(1, sizeof(struct strbuf));
> +}
> +
> +int truncate_strbuf(struct strbuf *buf, size_t offs)
> +{
> +	if (!buf->buf)
> +		return -EFAULT;
> +	if (offs > buf->offs)
> +		return -ERANGE;
> +
> +	buf->offs = offs;
> +	buf->buf[offs] = '\0';
> +	return 0;
> +}
> +
> +#define BUF_CHUNK 64
> +
> +static int expand_strbuf(struct strbuf *buf, int addsz)
> +{
> +	size_t add;
> +	char *tmp;
> +
> +	assert(strbuf_is_sane(buf));
> +	if (addsz < 0)
> +		return -EINVAL;
> +	if (buf->size - buf->offs >= (size_t)addsz + 1)
> +		return 0;
> +

With this add calculation, if you need exactly (x) BUF_CHUNKS worth of
space, you will add (x + 1) BUF_CHUNKS worth of space.  If you instead
use

add = ((addsz - (buf->size - buf->offs)) / BUF_CHUNK + 1)

you will avoid allocating the extra BUF_CHUNK.

> +	add = ((addsz + 1 - (buf->size - buf->offs)) / BUF_CHUNK + 1)
> +		* BUF_CHUNK;
> +
> +	if (buf->size >= SIZE_MAX - add) {
> +		add = SIZE_MAX - buf->size;
> +		if (add < (size_t)addsz + 1)
> +			return -EOVERFLOW;
> +	}
> +
> +	tmp = realloc(buf->buf, buf->size + add);
> +	if (!tmp)
> +		return -ENOMEM;
> +
> +	buf->buf = tmp;
> +	buf->size += add;
> +	buf->buf[buf->offs] = '\0';
> +
> +	return 0;
> +}
> +
> +int __append_strbuf_str(struct strbuf *buf, const char *str, int slen)
> +{
> +	int ret;
> +
> +	if ((ret = expand_strbuf(buf, slen)) < 0)
> +		return ret;
> +

This is correct, but I think it would be clearer if you calculated
buf->offs like you do in fill_strbufi():

	memcpy(buf->buf + buf->offs, str, slen);
	buf->offs += slen;

> +	buf->offs = (char *)mempcpy(buf->buf + buf->offs, str, slen)
> +		- buf->buf;
> +	buf->buf[buf->offs] = '\0';
> +
> +	return slen;
> +}
> +
> +int append_strbuf_str(struct strbuf *buf, const char *str)
> +{
> +	size_t slen;
> +
> +	if (!str)
> +		return -EINVAL;
> +
> +	slen = strlen(str);
> +	if (slen > INT_MAX)
> +		return -ERANGE;
> +
> +	return __append_strbuf_str(buf, str, slen);
> +}
> +
> +int fill_strbuf(struct strbuf *buf, char c, int slen)
> +{
> +	int ret;
> +
> +	if ((ret = expand_strbuf(buf, slen)) < 0)
> +		return ret;
> +
> +	memset(buf->buf + buf->offs, c, slen);
> +	buf->offs += slen;
> +	buf->buf[buf->offs] = '\0';
> +
> +	return slen;
> +}
> +
> +int append_strbuf_quoted(struct strbuf *buff, const char *ptr)
> +{
> +	char *quoted, *q;
> +	const char *p;
> +	unsigned n_quotes, i;
> +	size_t qlen;
> +	int ret;
> +
> +	if (!ptr)
> +		return -EINVAL;
> +
> +	for (n_quotes = 0, p = strchr(ptr, '"'); p; p = strchr(++p, '"'))
> +		n_quotes++;
> +
> +	/* leading + trailing quote, 1 extra quote for every quote in ptr */
> +	qlen = strlen(ptr) + 2 + n_quotes;
> +	if (qlen > INT_MAX)
> +		return -ERANGE;
> +	if ((ret = expand_strbuf(buff, qlen)) < 0)
> +		return ret;
> +
> +	quoted = &(buff->buf[buff->offs]);
> +	*quoted++ = '"';
> +	for (p = ptr, q = quoted, i = 0; i < n_quotes; i++) {

"qlen - 2 - (q - quoted)" is likely more space then you need here,
although it doesn't matter, since you already know that you will find a
quote before the end of the string. I get that it matches the
calculation after the loop. but even that one is confusing. I would
prefer that you either did something like

	size_t len = strlen(ptr);

...

		char *q1 = memccpy(q, p, '"', len - (p - ptr));

or even more obviously correct

	const char *p_end = ptr + strlen(ptr);

...

		char *q1 = memccpy(q, p, '"', p_end - p);


-Ben

> +		char *q1 = memccpy(q, p, '"', qlen - 2 - (q - quoted));
> +
> +		assert(q1 != NULL);
> +		p += q1 - q;
> +		*q1++ = '"';
> +		q = q1;
> +	}
> +	q = mempcpy(q, p, qlen - 2 - (q - quoted));
> +	*q++ = '"';
> +	*q = '\0';
> +	ret = q - &(buff->buf[buff->offs]);
> +	buff->offs += ret;
> +	return ret;
> +}
> +
> +__attribute__((format(printf, 2, 3)))
> +int print_strbuf(struct strbuf *buf, const char *fmt, ...)
> +{
> +	va_list ap;
> +	int ret;
> +	char *tail;
> +
> +	va_start(ap, fmt);
> +	ret = vasprintf(&tail, fmt, ap);
> +	va_end(ap);
> +
> +	if (ret < 0)
> +		return -ENOMEM;
> +
> +	ret = __append_strbuf_str(buf, tail, ret);
> +
> +	free(tail);
> +	return ret;
> +}
> diff --git a/libmultipath/strbuf.h b/libmultipath/strbuf.h
> new file mode 100644
> index 0000000..5903572
> --- /dev/null
> +++ b/libmultipath/strbuf.h
> @@ -0,0 +1,168 @@
> +/*
> + * Copyright (c) 2021 SUSE LLC
> + * SPDX-License-Identifier: GPL-2.0-only
> + */
> +#ifndef _STRBUF_H
> +#define _STRBUF_H
> +#include <errno.h>
> +#include <string.h>
> +
> +struct strbuf {
> +	char *buf;
> +	size_t size;
> +	size_t offs;
> +};
> +
> +/**
> + * reset_strbuf(): prepare strbuf for new content
> + * @param strbuf: string buffer to reset
> + *
> + * Frees internal buffer and resets size and offset to 0.
> + * Can be used to cleanup a struct strbuf on stack.
> + */
> +void reset_strbuf(struct strbuf *buf);
> +
> +/**
> + * free_strbuf(): free resources
> + * @param strbuf: string buffer to discard
> + *
> + * Frees all memory occupied by a struct strbuf.
> + */
> +void free_strbuf(struct strbuf *buf);
> +
> +/**
> + * macro: STRBUF_INIT
> + *
> + * Use this to initialize a local struct strbuf on the stack,
> + * or in a global/static variable.
> + */
> +#define STRBUF_INIT { .buf = NULL, }
> +
> +/**
> + * macro: STRBUF_ON_STACK
> + *
> + * Define and initialize a local struct @strbuf to be cleaned up when
> + * the current scope is left
> + */
> +#define STRBUF_ON_STACK(__x)						\
> +	struct strbuf __attribute__((cleanup(reset_strbuf))) (__x) = STRBUF_INIT;
> +
> +/**
> + * new_strbuf(): allocate a struct strbuf on the heap
> + *
> + * @returns: pointer to allocated struct, or NULL in case of error.
> + */
> +struct strbuf *new_strbuf(void);
> +
> +/**
> + * get_strbuf_str(): retrieve string from strbuf
> + * @param buf: a struct strbuf
> + * @returns: pointer to the string written to the strbuf so far.
> + *
> + * If @strbuf was never written to, the function returns a zero-
> + * length string. The return value of this function must not be
> + * free()d.
> + */
> +const char *get_strbuf_str(const struct strbuf *buf);
> +
> +/**
> + * steal_strbuf_str(): retrieve string from strbuf and reset
> + * @param buf: a struct strbuf
> + * @returns: pointer to the string written to @strbuf, or NULL
> + *
> + * After calling this function, the @strbuf is empty as if freshly
> + * initialized. The caller is responsible to free() the returned pointer.
> + * If @strbuf was never written to (not even an empty string was appended),
> + * the function returns NULL.
> + */
> +char *steal_strbuf_str(struct strbuf *buf);
> +
> +/**
> + * get_strbuf_len(): retrieve string length from strbuf
> + * @param buf: a struct strbuf
> + * @returns: the length of the string written to @strbuf so far.
> + */
> +size_t get_strbuf_len(const struct strbuf *buf);
> +
> +/**
> + * truncate_strbuf(): shorten the buffer
> + * @param buf: struct strbuf to truncate
> + * @param offs: new buffer position / offset
> + * @returns: 0 on success, negative error code otherwise.
> + *
> + * If @strbuf is freshly allocated/reset (never written to), -EFAULT
> + * is returned. if @offs must be higher than the current offset as returned
> + * by get_strbuf_len(), -ERANGE is returned. The allocated size of the @strbuf
> + * remains unchanged.
> + */
> +int truncate_strbuf(struct strbuf *buf, size_t offs);
> +
> +/**
> + * __append_strbuf_str(): append string of known length
> + * @param buf: the struct strbuf to write to
> + * @param str: the string to append, not necessarily 0-terminated
> + * @param slen: max number of characters to append, must be non-negative
> + * @returns: @slen = number of appended characters if successful (excluding
> + * terminating '\0'); negative error code otherwise.
> + *
> + * Notes: a 0-byte is always appended to the output buffer after @slen characters.
> + * 0-bytes possibly contained in the first @slen characters are copied into
> + * the output. If the function returns an error, @strbuf is unchanged.
> + */
> +int __append_strbuf_str(struct strbuf *buf, const char *str, int slen);
> +
> +/**
> + * append_strbuf_str(): append string
> + * @param buf: the struct strbuf to write to
> + * @param str: the string to append, 0-terminated
> + * @returns: number of appended characters if successful (excluding
> + * terminating '\0'); negative error code otherwise
> + *
> + * Appends the given 0-terminated string to @strbuf, expanding @strbuf's size
> + * as necessary. If the function returns an error, @strbuf is unchanged.
> + */
> +int append_strbuf_str(struct strbuf *buf, const char *str);
> +
> +/**
> + * fill_strbuf_str(): pad strbuf with a character
> + * @param buf: the struct strbuf to write to
> + * @param c: the character used for filling
> + * @param slen: max number of characters to append, must be non-negative
> + * @returns: number of appended characters if successful (excluding
> + * terminating '\0'); negative error code otherwise
> + *
> + * Appends the given character @slen times to @strbuf, expanding @strbuf's size
> + * as necessary. If the function returns an error, @strbuf is unchanged.
> + */
> +int fill_strbuf(struct strbuf *buf, char c, int slen);
> +
> +/**
> + * append_strbuf_quoted(): append string in double quotes, escaping quotes in string
> + * @param buf: the struct strbuf to write to
> + * @param str: the string to append, 0-terminated
> + * @returns: number of appended characters if successful (excluding
> + * terminating '\0'); negative error code otherwise
> + *
> + * Appends the given string to @strbuf, with leading and trailing double
> + * quotes (") added, expanding @strbuf's size as necessary. Any double quote
> + * characters (") in the string are transformed to double double quotes ("").
> + * If the function returns an error, @strbuf is unchanged.
> + */
> +int append_strbuf_quoted(struct strbuf *buf, const char *str);
> +
> +/**
> + * print_strbuf(): print to strbuf, formatted
> + * @param buf: the struct strbuf to print to
> + * @param fmt: printf()-like format string
> + * @returns: number of appended characters if successful, (excluding
> + * terminating '\0'); negative error code otherwise
> + *
> + * Appends the the arguments following @fmt, formatted as in printf(), to
> + * @strbuf, expanding @strbuf's size as necessary. The function makes sure that
> + * the output @strbuf is always 0-terminated.
> + * If the function returns an error, @strbuf is unchanged.
> + */
> +__attribute__((format(printf, 2, 3)))
> +int print_strbuf(struct strbuf *buf, const char *fmt, ...);
> +
> +#endif
> diff --git a/tests/Makefile b/tests/Makefile
> index e70c8ed..8cbc4b7 100644
> --- a/tests/Makefile
> +++ b/tests/Makefile
> @@ -13,7 +13,7 @@ CFLAGS += $(BIN_CFLAGS) -I$(multipathdir) -I$(mpathcmddir) \
>  LIBDEPS += -L. -L$(mpathcmddir) -lmultipath -lmpathcmd -lcmocka
>  
>  TESTS := uevent parser util dmevents hwtable blacklist unaligned vpd pgpolicy \
> -	 alias directio valid devt mpathvalid
> +	 alias directio valid devt mpathvalid strbuf
>  HELPERS := test-lib.o test-log.o
>  
>  .SILENT: $(TESTS:%=%.o)
> @@ -63,6 +63,7 @@ mpathvalid-test_OBJDEPS := ../libmpathvalid/mpath_valid.o
>  ifneq ($(DIO_TEST_DEV),)
>  directio-test_LIBDEPS := -laio
>  endif
> +strbuf-test_OBJDEPS := ../libmultipath/strbuf.o
>  
>  %.o: %.c
>  	$(CC) $(CFLAGS) $($*-test_FLAGS) -c -o $@ $<
> diff --git a/tests/strbuf.c b/tests/strbuf.c
> new file mode 100644
> index 0000000..43a477d
> --- /dev/null
> +++ b/tests/strbuf.c
> @@ -0,0 +1,412 @@
> +/*
> + * Copyright (c) 2021 SUSE LLC
> + * SPDX-License-Identifier: GPL-2.0-only
> + */
> +
> +#define _GNU_SOURCE
> +#include <stdbool.h>
> +#include <stdarg.h>
> +#include <stddef.h>
> +#include <setjmp.h>
> +#include <stdlib.h>
> +#include <stdbool.h>
> +#include <cmocka.h>
> +#include <errno.h>
> +#include "strbuf.h"
> +#include "debug.h"
> +#include "globals.c"
> +
> +void *__real_realloc(void *ptr, size_t size);
> +
> +static bool mock_realloc = false;
> +void *__wrap_realloc(void *ptr, size_t size)
> +{
> +	void *p;
> +	if (!mock_realloc)
> +		return __real_realloc(ptr, size);
> +
> +	p = mock_ptr_type(void *);
> +	condlog(4, "%s: %p, %zu -> %p", __func__, ptr, size, p);
> +	return p;
> +}
> +
> +static void test_strbuf_00(void **state)
> +{
> +	STRBUF_ON_STACK(buf);
> +	char *p;
> +
> +	assert_ptr_equal(buf.buf, NULL);
> +	assert_int_equal(buf.size, 0);
> +	assert_int_equal(buf.offs, 0);
> +	assert_int_equal(get_strbuf_len(&buf), 0);
> +	assert_string_equal(get_strbuf_str(&buf), "");
> +	p = steal_strbuf_str(&buf);
> +	assert_ptr_equal(p, NULL);
> +
> +	assert_ptr_equal(buf.buf, NULL);
> +	assert_int_equal(buf.size, 0);
> +	assert_int_equal(buf.offs, 0);
> +	assert_int_equal(get_strbuf_len(&buf), 0);
> +	assert_string_equal(get_strbuf_str(&buf), "");
> +
> +	assert_int_equal(append_strbuf_str(&buf, "moin"), 4);
> +	assert_int_equal(get_strbuf_len(&buf), 4);
> +	assert_in_range(buf.size, 5, SIZE_MAX);
> +	assert_string_equal(get_strbuf_str(&buf), "moin");
> +	p = steal_strbuf_str(&buf);
> +	assert_string_equal(p, "moin");
> +	free(p);
> +
> +	assert_ptr_equal(buf.buf, NULL);
> +	assert_int_equal(buf.size, 0);
> +	assert_int_equal(buf.offs, 0);
> +	assert_int_equal(get_strbuf_len(&buf), 0);
> +	assert_string_equal(get_strbuf_str(&buf), "");
> +
> +	assert_int_equal(append_strbuf_str(&buf, NULL), -EINVAL);
> +	assert_int_equal(buf.size, 0);
> +	assert_int_equal(buf.offs, 0);
> +	assert_int_equal(get_strbuf_len(&buf), 0);
> +	assert_string_equal(get_strbuf_str(&buf), "");
> +
> +	assert_int_equal(append_strbuf_str(&buf, ""), 0);
> +	/* appending a 0-length string allocates memory */
> +	assert_in_range(buf.size, 1, SIZE_MAX);
> +	assert_int_equal(buf.offs, 0);
> +	assert_int_equal(get_strbuf_len(&buf), 0);
> +	assert_string_equal(get_strbuf_str(&buf), "");
> +	p = steal_strbuf_str(&buf);
> +	assert_string_equal(p, "");
> +	free(p);
> +
> +	assert_int_equal(__append_strbuf_str(&buf, "x", 0), 0);
> +	/* appending a 0-length string allocates memory */
> +	assert_in_range(buf.size, 1, SIZE_MAX);
> +	assert_int_equal(buf.offs, 0);
> +	assert_int_equal(get_strbuf_len(&buf), 0);
> +	assert_string_equal(get_strbuf_str(&buf), "");
> +}
> +
> +static void test_strbuf_alloc_err(void **state)
> +{
> +	STRBUF_ON_STACK(buf);
> +	size_t sz, ofs;
> +	int rc;
> +
> +	mock_realloc = true;
> +	will_return(__wrap_realloc, NULL);
> +	assert_int_equal(append_strbuf_str(&buf, "moin"), -ENOMEM);
> +	assert_int_equal(buf.size, 0);
> +	assert_int_equal(buf.offs, 0);
> +	assert_int_equal(get_strbuf_len(&buf), 0);
> +	assert_string_equal(get_strbuf_str(&buf), "");
> +
> +	mock_realloc = false;
> +	assert_int_equal(append_strbuf_str(&buf, "moin"), 4);
> +	sz = buf.size;
> +	assert_in_range(sz, 5, SIZE_MAX);
> +	assert_int_equal(buf.offs, 4);
> +	assert_int_equal(get_strbuf_len(&buf), 4);
> +	assert_string_equal(get_strbuf_str(&buf), "moin");
> +
> +	mock_realloc = true;
> +	will_return(__wrap_realloc, NULL);
> +	ofs = get_strbuf_len(&buf);
> +	while ((rc = append_strbuf_str(&buf, " hello")) >= 0) {
> +		condlog(3, "%s", get_strbuf_str(&buf));
> +		assert_int_equal(rc, 6);
> +		assert_int_equal(get_strbuf_len(&buf), ofs + 6);
> +		assert_memory_equal(get_strbuf_str(&buf), "moin", 4);
> +		assert_string_equal(get_strbuf_str(&buf) + ofs, " hello");
> +		ofs = get_strbuf_len(&buf);
> +	}
> +	assert_int_equal(rc, -ENOMEM);
> +	assert_int_equal(buf.size, sz);
> +	assert_int_equal(get_strbuf_len(&buf), ofs);
> +	assert_memory_equal(get_strbuf_str(&buf), "moin", 4);
> +	assert_string_equal(get_strbuf_str(&buf) + ofs - 6, " hello");
> +
> +	reset_strbuf(&buf);
> +	assert_ptr_equal(buf.buf, NULL);
> +	assert_int_equal(buf.size, 0);
> +	assert_int_equal(buf.offs, 0);
> +	assert_int_equal(get_strbuf_len(&buf), 0);
> +	assert_string_equal(get_strbuf_str(&buf), "");
> +
> +	mock_realloc = false;
> +}
> +
> +static void test_strbuf_overflow(void **state)
> +{
> +	STRBUF_ON_STACK(buf);
> +
> +	assert_int_equal(append_strbuf_str(&buf, "x"), 1);
> +	/* fake huge buffer */
> +	buf.size = SIZE_MAX - 1;
> +	buf.offs = buf.size - 1;
> +	assert_int_equal(append_strbuf_str(&buf, "x"), -EOVERFLOW);
> +}
> +
> +static void test_strbuf_big(void **state)
> +{
> +	STRBUF_ON_STACK(buf);
> +	const char big[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\n";
> +	char *bbig;
> +	int i;
> +
> +	/* Under valgrind, 30000 iterations need ca. 30s on my laptop */
> +	for (i = 0; i < 30000; i++) {
> +		if (i % 1000 == 0)
> +			condlog(4, "%d", i);
> +		assert_int_equal(append_strbuf_str(&buf, big), sizeof(big) - 1);
> +		assert_int_equal(get_strbuf_len(&buf), (sizeof(big) - 1) * (i + 1));
> +		assert_memory_equal(get_strbuf_str(&buf), big, sizeof(big) - 1);
> +		assert_string_equal(get_strbuf_str(&buf) + get_strbuf_len(&buf)
> +				    - (sizeof(big) - 1), big);
> +	};
> +	bbig = steal_strbuf_str(&buf);
> +
> +	assert_ptr_equal(buf.buf, NULL);
> +	assert_int_equal(buf.size, 0);
> +	assert_int_equal(buf.offs, 0);
> +	assert_int_equal(get_strbuf_len(&buf), 0);
> +	assert_string_equal(get_strbuf_str(&buf), "");
> +
> +	assert_int_equal(strlen(bbig), i * (sizeof(big) - 1));
> +	assert_memory_equal(bbig, big, sizeof(big) - 1);
> +	free(bbig);
> +}
> +
> +static void test_strbuf_nul(void **state)
> +{
> +	STRBUF_ON_STACK(buf);
> +	char greet[] = "hello, sir!";
> +
> +	assert_int_equal(__append_strbuf_str(&buf, greet, 6), 6);
> +	assert_string_equal(get_strbuf_str(&buf), "hello,");
> +	assert_int_equal(__append_strbuf_str(&buf, greet, 6), 6);
> +	assert_string_equal(get_strbuf_str(&buf), "hello,hello,");
> +
> +	/* overwrite comma with NUL; append_strbuf_str() stops at NUL byte */
> +	greet[5] = '\0';
> +	reset_strbuf(&buf);
> +	assert_int_equal(append_strbuf_str(&buf, greet), 5);
> +	assert_int_equal(get_strbuf_len(&buf), 5);
> +	assert_string_equal(get_strbuf_str(&buf), "hello");
> +	assert_int_equal(append_strbuf_str(&buf, greet), 5);
> +	assert_int_equal(get_strbuf_len(&buf), 10);
> +	assert_string_equal(get_strbuf_str(&buf), "hellohello");
> +
> +	/* __append_strbuf_str() appends full memory, including NUL bytes */
> +	reset_strbuf(&buf);
> +	assert_int_equal(__append_strbuf_str(&buf, greet, sizeof(greet) - 1),
> +			 sizeof(greet) - 1);
> +	assert_int_equal(get_strbuf_len(&buf), sizeof(greet) - 1);
> +	assert_string_equal(get_strbuf_str(&buf), "hello");
> +	assert_string_equal(get_strbuf_str(&buf) + get_strbuf_len(&buf) - 5, " sir!");
> +	assert_int_equal(__append_strbuf_str(&buf, greet, sizeof(greet) - 1),
> +			 sizeof(greet) - 1);
> +	assert_string_equal(get_strbuf_str(&buf), "hello");
> +	assert_int_equal(get_strbuf_len(&buf), 2 * (sizeof(greet) - 1));
> +	assert_string_equal(get_strbuf_str(&buf) + get_strbuf_len(&buf) - 5, " sir!");
> +}
> +
> +static void test_strbuf_quoted(void **state)
> +{
> +	STRBUF_ON_STACK(buf);
> +	const char said[] = "She said ";
> +	const char greet[] = "hi, man!";
> +	char *p;
> +	size_t n;
> +
> +	assert_int_equal(append_strbuf_str(&buf, said), sizeof(said) - 1);
> +	assert_int_equal(append_strbuf_quoted(&buf, greet), sizeof(greet) + 1);
> +	assert_string_equal(get_strbuf_str(&buf), "She said \"hi, man!\"");
> +	n = get_strbuf_len(&buf);
> +	p = steal_strbuf_str(&buf);
> +	assert_int_equal(append_strbuf_str(&buf, said), sizeof(said) - 1);
> +	assert_int_equal(append_strbuf_quoted(&buf, p), n + 4);
> +	assert_string_equal(get_strbuf_str(&buf),
> +			    "She said \"She said \"\"hi, man!\"\"\"");
> +	free(p);
> +	n = get_strbuf_len(&buf);
> +	p = steal_strbuf_str(&buf);
> +	assert_int_equal(append_strbuf_str(&buf, said), sizeof(said) - 1);
> +	assert_int_equal(append_strbuf_quoted(&buf, p), n + 8);
> +	assert_string_equal(get_strbuf_str(&buf),
> +			    "She said \"She said \"\"She said \"\"\"\"hi, man!\"\"\"\"\"\"\"");
> +	free(p);
> +}
> +
> +static void test_strbuf_escaped(void **state)
> +{
> +	STRBUF_ON_STACK(buf);
> +	const char said[] = "She said \"hi, man\"";
> +
> +	assert_int_equal(append_strbuf_quoted(&buf, said), sizeof(said) + 3);
> +	assert_string_equal(get_strbuf_str(&buf),
> +			    "\"She said \"\"hi, man\"\"\"");
> +
> +	reset_strbuf(&buf);
> +	assert_int_equal(append_strbuf_quoted(&buf, "\""), 4);
> +	assert_string_equal(get_strbuf_str(&buf), "\"\"\"\"");
> +
> +	reset_strbuf(&buf);
> +	assert_int_equal(append_strbuf_quoted(&buf, "\"\""), 6);
> +	assert_string_equal(get_strbuf_str(&buf), "\"\"\"\"\"\"");
> +
> +	reset_strbuf(&buf);
> +	assert_int_equal(append_strbuf_quoted(&buf, "\"Hi\""), 8);
> +	assert_string_equal(get_strbuf_str(&buf), "\"\"\"Hi\"\"\"");
> +}
> +
> +#define SENTENCE "yields, preceded by itself, falsehood"
> +static void test_print_strbuf(void **state)
> +{
> +	STRBUF_ON_STACK(buf);
> +	char sentence[] = SENTENCE;
> +
> +	assert_int_equal(print_strbuf(&buf, "\"%s\" %s.", sentence, sentence),
> +			 2 * (sizeof(sentence) - 1) + 4);
> +	assert_string_equal(get_strbuf_str(&buf),
> +			    "\"" SENTENCE "\" " SENTENCE ".");
> +	condlog(3, "%s", get_strbuf_str(&buf));
> +
> +	reset_strbuf(&buf);
> +	assert_int_equal(print_strbuf(&buf, "0x%08x", 0xdeadbeef), 10);
> +	assert_string_equal(get_strbuf_str(&buf), "0xdeadbeef");
> +
> +	reset_strbuf(&buf);
> +	assert_int_equal(print_strbuf(&buf, "%d%% of %d is %0.2f",
> +				      5, 100, 0.05), 17);
> +	assert_string_equal(get_strbuf_str(&buf), "5% of 100 is 0.05");
> +}
> +
> +static void test_truncate_strbuf(void **state)
> +{
> +	STRBUF_ON_STACK(buf);
> +	const char str[] = "hello my dear!\n";
> +	size_t sz, sz1;
> +
> +	assert_int_equal(truncate_strbuf(&buf, 1), -EFAULT);
> +	assert_int_equal(truncate_strbuf(&buf, 0), -EFAULT);
> +
> +	assert_int_equal(append_strbuf_str(&buf, str), sizeof(str) - 1);
> +	assert_int_equal(get_strbuf_len(&buf), sizeof(str) - 1);
> +	assert_string_equal(get_strbuf_str(&buf), str);
> +
> +	assert_int_equal(truncate_strbuf(&buf, sizeof(str)), -ERANGE);
> +	assert_int_equal(get_strbuf_len(&buf), sizeof(str) - 1);
> +	assert_string_equal(get_strbuf_str(&buf), str);
> +
> +	assert_int_equal(truncate_strbuf(&buf, sizeof(str) - 1), 0);
> +	assert_int_equal(get_strbuf_len(&buf), sizeof(str) - 1);
> +	assert_string_equal(get_strbuf_str(&buf), str);
> +
> +	assert_int_equal(truncate_strbuf(&buf, sizeof(str) - 2), 0);
> +	assert_int_equal(get_strbuf_len(&buf), sizeof(str) - 2);
> +	assert_string_not_equal(get_strbuf_str(&buf), str);
> +	assert_memory_equal(get_strbuf_str(&buf), str, sizeof(str) - 2);
> +
> +	assert_int_equal(truncate_strbuf(&buf, 5), 0);
> +	assert_int_equal(get_strbuf_len(&buf), 5);
> +	assert_string_not_equal(get_strbuf_str(&buf), str);
> +	assert_string_equal(get_strbuf_str(&buf), "hello");
> +
> +	reset_strbuf(&buf);
> +	assert_int_equal(append_strbuf_str(&buf, str), sizeof(str) - 1);
> +
> +	sz = buf.size;
> +	while (buf.size == sz)
> +		assert_int_equal(append_strbuf_str(&buf, str), sizeof(str) - 1);
> +
> +	sz1  = buf.size;
> +	assert_in_range(get_strbuf_len(&buf), sz + 1, SIZE_MAX);
> +	assert_string_equal(get_strbuf_str(&buf) +
> +			    get_strbuf_len(&buf) - (sizeof(str) - 1), str);
> +	assert_int_equal(truncate_strbuf(&buf, get_strbuf_len(&buf) + 1),
> +			 -ERANGE);
> +	assert_int_equal(truncate_strbuf(&buf, get_strbuf_len(&buf)), 0);
> +	assert_int_equal(truncate_strbuf(&buf, get_strbuf_len(&buf)
> +					 - (sizeof(str) - 1)), 0);
> +	assert_in_range(get_strbuf_len(&buf), 1, sz);
> +	assert_string_equal(get_strbuf_str(&buf) +
> +			    get_strbuf_len(&buf) - (sizeof(str) - 1), str);
> +	assert_int_equal(buf.size, sz1);
> +
> +	assert_int_equal(truncate_strbuf(&buf, 5), 0);
> +	assert_int_equal(get_strbuf_len(&buf), 5);
> +	assert_string_equal(get_strbuf_str(&buf), "hello");
> +	assert_int_equal(buf.size, sz1);
> +
> +	assert_int_equal(truncate_strbuf(&buf, 0), 0);
> +	assert_int_equal(get_strbuf_len(&buf), 0);
> +	assert_string_equal(get_strbuf_str(&buf), "");
> +	assert_int_equal(buf.size, sz1);
> +}
> +
> +static void test_fill_strbuf(void **state)
> +{
> +	STRBUF_ON_STACK(buf);
> +	int i;
> +	char *p;
> +
> +	assert_int_equal(fill_strbuf(&buf, '+', -5), -EINVAL);
> +
> +	assert_int_equal(fill_strbuf(&buf, '+', 0), 0);
> +	assert_int_equal(get_strbuf_len(&buf), 0);
> +	assert_string_equal(get_strbuf_str(&buf), "");
> +
> +	assert_int_equal(fill_strbuf(&buf, '+', 1), 1);
> +	assert_int_equal(get_strbuf_len(&buf), 1);
> +	assert_string_equal(get_strbuf_str(&buf), "+");
> +
> +	assert_int_equal(fill_strbuf(&buf, '-', 3), 3);
> +	assert_int_equal(get_strbuf_len(&buf), 4);
> +	assert_string_equal(get_strbuf_str(&buf), "+---");
> +
> +	assert_int_equal(fill_strbuf(&buf, '\0', 3), 3);
> +	assert_int_equal(get_strbuf_len(&buf), 7);
> +	assert_string_equal(get_strbuf_str(&buf), "+---");
> +
> +	truncate_strbuf(&buf, 4);
> +	assert_int_equal(fill_strbuf(&buf, '+', 4), 4);
> +	assert_int_equal(get_strbuf_len(&buf), 8);
> +	assert_string_equal(get_strbuf_str(&buf), "+---++++");
> +
> +	reset_strbuf(&buf);
> +	assert_int_equal(fill_strbuf(&buf, 'x', 30000), 30000);
> +	assert_int_equal(get_strbuf_len(&buf), 30000);
> +	p = steal_strbuf_str(&buf);
> +	assert_int_equal(strlen(p), 30000);
> +	for (i = 0; i < 30000; i++)
> +		assert_int_equal(p[i], 'x');
> +	free(p);
> +}
> +
> +static int test_strbuf(void)
> +{
> +	const struct CMUnitTest tests[] = {
> +		cmocka_unit_test(test_strbuf_00),
> +		cmocka_unit_test(test_strbuf_alloc_err),
> +		cmocka_unit_test(test_strbuf_overflow),
> +		cmocka_unit_test(test_strbuf_big),
> +		cmocka_unit_test(test_strbuf_nul),
> +		cmocka_unit_test(test_strbuf_quoted),
> +		cmocka_unit_test(test_strbuf_escaped),
> +		cmocka_unit_test(test_print_strbuf),
> +		cmocka_unit_test(test_truncate_strbuf),
> +		cmocka_unit_test(test_fill_strbuf),
> +	};
> +
> +	return cmocka_run_group_tests(tests, NULL, NULL);
> +}
> +
> +int main(void)
> +{
> +	int ret = 0;
> +
> +	init_test_verbosity(-1);
> +	ret += test_strbuf();
> +	return ret;
> +}
> -- 
> 2.32.0

--
dm-devel mailing list
dm-devel@redhat.com
https://listman.redhat.com/mailman/listinfo/dm-devel