Commit d1fadef1 authored by Brendan Higgins's avatar Brendan Higgins Committed by Shuah Khan
Browse files

kunit: test: add string_stream a std::stream like string builder 



A number of test features need to do pretty complicated string printing
where it may not be possible to rely on a single preallocated string
with parameters.

So provide a library for constructing the string as you go similar to
C++'s std::string. string_stream is really just a string builder,
nothing more.

Signed-off-by: default avatarBrendan Higgins <brendanhiggins@google.com>
Reviewed-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: default avatarLogan Gunthorpe <logang@deltatee.com>
Reviewed-by: default avatarStephen Boyd <swboyd@chromium.org>
Signed-off-by: default avatarShuah Khan <skhan@linuxfoundation.org>
parent 0a756853

include/kunit/string-stream.h

0 → 100644
+51 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * C++ stream style string builder used in KUnit for building messages.

 *

 * Copyright (C) 2019, Google LLC.

 * Author: Brendan Higgins <brendanhiggins@google.com>

 */



#ifndef _KUNIT_STRING_STREAM_H

#define _KUNIT_STRING_STREAM_H



#include <linux/spinlock.h>

#include <linux/types.h>

#include <stdarg.h>



struct string_stream_fragment {

	struct kunit *test;

	struct list_head node;

	char *fragment;

};



struct string_stream {

	size_t length;

	struct list_head fragments;

	/* length and fragments are protected by this lock */

	spinlock_t lock;

	struct kunit *test;

	gfp_t gfp;

};



struct kunit;



struct string_stream *alloc_string_stream(struct kunit *test, gfp_t gfp);



int __printf(2, 3) string_stream_add(struct string_stream *stream,

				     const char *fmt, ...);



int string_stream_vadd(struct string_stream *stream,

		       const char *fmt,

		       va_list args);



char *string_stream_get_string(struct string_stream *stream);



int string_stream_append(struct string_stream *stream,

			 struct string_stream *other);



bool string_stream_is_empty(struct string_stream *stream);



int string_stream_destroy(struct string_stream *stream);



#endif /* _KUNIT_STRING_STREAM_H */

lib/kunit/Makefile

+2 −1
Original line number Diff line number Diff line 
obj-$(CONFIG_KUNIT) +=			test.o
 
obj-$(CONFIG_KUNIT) +=			test.o \

					string-stream.o

lib/kunit/string-stream.c

0 → 100644
+217 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * C++ stream style string builder used in KUnit for building messages.

 *

 * Copyright (C) 2019, Google LLC.

 * Author: Brendan Higgins <brendanhiggins@google.com>

 */



#include <kunit/string-stream.h>

#include <kunit/test.h>

#include <linux/list.h>

#include <linux/slab.h>



struct string_stream_fragment_alloc_context {

	struct kunit *test;

	int len;

	gfp_t gfp;

};



static int string_stream_fragment_init(struct kunit_resource *res,

				       void *context)

{

	struct string_stream_fragment_alloc_context *ctx = context;

	struct string_stream_fragment *frag;



	frag = kunit_kzalloc(ctx->test, sizeof(*frag), ctx->gfp);

	if (!frag)

		return -ENOMEM;



	frag->test = ctx->test;

	frag->fragment = kunit_kmalloc(ctx->test, ctx->len, ctx->gfp);

	if (!frag->fragment)

		return -ENOMEM;



	res->allocation = frag;



	return 0;

}



static void string_stream_fragment_free(struct kunit_resource *res)

{

	struct string_stream_fragment *frag = res->allocation;



	list_del(&frag->node);

	kunit_kfree(frag->test, frag->fragment);

	kunit_kfree(frag->test, frag);

}



static struct string_stream_fragment *alloc_string_stream_fragment(

		struct kunit *test, int len, gfp_t gfp)

{

	struct string_stream_fragment_alloc_context context = {

		.test = test,

		.len = len,

		.gfp = gfp

	};



	return kunit_alloc_resource(test,

				    string_stream_fragment_init,

				    string_stream_fragment_free,

				    gfp,

				    &context);

}



static int string_stream_fragment_destroy(struct string_stream_fragment *frag)

{

	return kunit_resource_destroy(frag->test,

				      kunit_resource_instance_match,

				      string_stream_fragment_free,

				      frag);

}



int string_stream_vadd(struct string_stream *stream,

		       const char *fmt,

		       va_list args)

{

	struct string_stream_fragment *frag_container;

	int len;

	va_list args_for_counting;



	/* Make a copy because `vsnprintf` could change it */

	va_copy(args_for_counting, args);



	/* Need space for null byte. */

	len = vsnprintf(NULL, 0, fmt, args_for_counting) + 1;



	va_end(args_for_counting);



	frag_container = alloc_string_stream_fragment(stream->test,

						      len,

						      stream->gfp);

	if (!frag_container)

		return -ENOMEM;



	len = vsnprintf(frag_container->fragment, len, fmt, args);

	spin_lock(&stream->lock);

	stream->length += len;

	list_add_tail(&frag_container->node, &stream->fragments);

	spin_unlock(&stream->lock);



	return 0;

}



int string_stream_add(struct string_stream *stream, const char *fmt, ...)

{

	va_list args;

	int result;



	va_start(args, fmt);

	result = string_stream_vadd(stream, fmt, args);

	va_end(args);



	return result;

}



static void string_stream_clear(struct string_stream *stream)

{

	struct string_stream_fragment *frag_container, *frag_container_safe;



	spin_lock(&stream->lock);

	list_for_each_entry_safe(frag_container,

				 frag_container_safe,

				 &stream->fragments,

				 node) {

		string_stream_fragment_destroy(frag_container);

	}

	stream->length = 0;

	spin_unlock(&stream->lock);

}



char *string_stream_get_string(struct string_stream *stream)

{

	struct string_stream_fragment *frag_container;

	size_t buf_len = stream->length + 1; /* +1 for null byte. */

	char *buf;



	buf = kunit_kzalloc(stream->test, buf_len, stream->gfp);

	if (!buf)

		return NULL;



	spin_lock(&stream->lock);

	list_for_each_entry(frag_container, &stream->fragments, node)

		strlcat(buf, frag_container->fragment, buf_len);

	spin_unlock(&stream->lock);



	return buf;

}



int string_stream_append(struct string_stream *stream,

			 struct string_stream *other)

{

	const char *other_content;



	other_content = string_stream_get_string(other);



	if (!other_content)

		return -ENOMEM;



	return string_stream_add(stream, other_content);

}



bool string_stream_is_empty(struct string_stream *stream)

{

	return list_empty(&stream->fragments);

}



struct string_stream_alloc_context {

	struct kunit *test;

	gfp_t gfp;

};



static int string_stream_init(struct kunit_resource *res, void *context)

{

	struct string_stream *stream;

	struct string_stream_alloc_context *ctx = context;



	stream = kunit_kzalloc(ctx->test, sizeof(*stream), ctx->gfp);

	if (!stream)

		return -ENOMEM;



	res->allocation = stream;

	stream->gfp = ctx->gfp;

	stream->test = ctx->test;

	INIT_LIST_HEAD(&stream->fragments);

	spin_lock_init(&stream->lock);



	return 0;

}



static void string_stream_free(struct kunit_resource *res)

{

	struct string_stream *stream = res->allocation;



	string_stream_clear(stream);

}



struct string_stream *alloc_string_stream(struct kunit *test, gfp_t gfp)

{

	struct string_stream_alloc_context context = {

		.test = test,

		.gfp = gfp

	};



	return kunit_alloc_resource(test,

				    string_stream_init,

				    string_stream_free,

				    gfp,

				    &context);

}



int string_stream_destroy(struct string_stream *stream)

{

	return kunit_resource_destroy(stream->test,

				      kunit_resource_instance_match,

				      string_stream_free,

				      stream);

}