// SPDX-License-Identifier: GPL-2.0-only#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include <limits.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h> #include "debug.h"#include "tests.h"#include <api/io.h>#include <linux/kernel.h>#include <linux/zalloc.h> #define TEMPL "/tmp/perf-test-XXXXXX" #define EXPECT_EQUAL(val, expected)                             \do {								\	if (val != expected) {					\		pr_debug("%s:%d: %d != %d\n",			\			__FILE__, __LINE__, val, expected);	\		ret = -1;					\	}							\} while (0) #define EXPECT_EQUAL64(val, expected)                           \do {								\	if (val != expected) {					\		pr_debug("%s:%d: %lld != %lld\n",		\			__FILE__, __LINE__, val, expected);	\		ret = -1;					\	}							\} while (0) static int make_test_file(char path[PATH_MAX], const char *contents){	ssize_t contents_len = strlen(contents);	int fd; 	strcpy(path, TEMPL);	fd = mkstemp(path);	if (fd < 0) {		pr_debug("mkstemp failed");		return -1;	}	if (write(fd, contents, contents_len) < contents_len) {		pr_debug("short write");		close(fd);		unlink(path);		return -1;	}	close(fd);	return 0;} static int setup_test(char path[PATH_MAX], const char *contents,		      size_t buf_size, struct io *io){	if (make_test_file(path, contents))		return -1; 	io->fd = open(path, O_RDONLY);	if (io->fd < 0) {		pr_debug("Failed to open '%s'\n", path);		unlink(path);		return -1;	}	io->buf = malloc(buf_size);	if (io->buf == NULL) {		pr_debug("Failed to allocate memory");		close(io->fd);		unlink(path);		return -1;	}	io__init(io, io->fd, io->buf, buf_size);	return 0;} static void cleanup_test(char path[PATH_MAX], struct io *io){	zfree(&io->buf);	close(io->fd);	unlink(path);} static int do_test_get_char(const char *test_string, size_t buf_size){	char path[PATH_MAX];	struct io io;	int ch, ret = 0;	size_t i; 	if (setup_test(path, test_string, buf_size, &io))		return -1; 	for (i = 0; i < strlen(test_string); i++) {		ch = io__get_char(&io); 		EXPECT_EQUAL(ch, test_string[i]);		EXPECT_EQUAL(io.eof, false);	}	ch = io__get_char(&io);	EXPECT_EQUAL(ch, -1);	EXPECT_EQUAL(io.eof, true); 	cleanup_test(path, &io);	return ret;} static int test_get_char(void){	int i, ret = 0;	size_t j; 	static const char *const test_strings[] = {		"12345678abcdef90",		"a\nb\nc\nd\n",		"\a\b\t\v\f\r",	};	for (i = 0; i <= 10; i++) {		for (j = 0; j < ARRAY_SIZE(test_strings); j++) {			if (do_test_get_char(test_strings[j], 1 << i))				ret = -1;		}	}	return ret;} static int do_test_get_hex(const char *test_string,			__u64 val1, int ch1,			__u64 val2, int ch2,			__u64 val3, int ch3,			bool end_eof){	char path[PATH_MAX];	struct io io;	int ch, ret = 0;	__u64 hex; 	if (setup_test(path, test_string, 4, &io))		return -1; 	ch = io__get_hex(&io, &hex);	EXPECT_EQUAL64(hex, val1);	EXPECT_EQUAL(ch, ch1); 	ch = io__get_hex(&io, &hex);	EXPECT_EQUAL64(hex, val2);	EXPECT_EQUAL(ch, ch2); 	ch = io__get_hex(&io, &hex);	EXPECT_EQUAL64(hex, val3);	EXPECT_EQUAL(ch, ch3); 	EXPECT_EQUAL(io.eof, end_eof); 	cleanup_test(path, &io);	return ret;} static int test_get_hex(void){	int ret = 0; 	if (do_test_get_hex("12345678abcdef90",				0x12345678abcdef90, -1,				0, -1,				0, -1,				true))		ret = -1; 	if (do_test_get_hex("1\n2\n3\n",				1, '\n',				2, '\n',				3, '\n',				false))		ret = -1; 	if (do_test_get_hex("12345678ABCDEF90;a;b",				0x12345678abcdef90, ';',				0xa, ';',				0xb, -1,				true))		ret = -1; 	if (do_test_get_hex("0x1x2x",				0, 'x',				1, 'x',				2, 'x',				false))		ret = -1; 	if (do_test_get_hex("x1x",				0, -2,				1, 'x',				0, -1,				true))		ret = -1; 	if (do_test_get_hex("10000000000000000000000000000abcdefgh99i",				0xabcdef, 'g',				0, -2,				0x99, 'i',				false))		ret = -1; 	return ret;} static int do_test_get_dec(const char *test_string,			__u64 val1, int ch1,			__u64 val2, int ch2,			__u64 val3, int ch3,			bool end_eof){	char path[PATH_MAX];	struct io io;	int ch, ret = 0;	__u64 dec; 	if (setup_test(path, test_string, 4, &io))		return -1; 	ch = io__get_dec(&io, &dec);	EXPECT_EQUAL64(dec, val1);	EXPECT_EQUAL(ch, ch1); 	ch = io__get_dec(&io, &dec);	EXPECT_EQUAL64(dec, val2);	EXPECT_EQUAL(ch, ch2); 	ch = io__get_dec(&io, &dec);	EXPECT_EQUAL64(dec, val3);	EXPECT_EQUAL(ch, ch3); 	EXPECT_EQUAL(io.eof, end_eof); 	cleanup_test(path, &io);	return ret;} static int test_get_dec(void){	int ret = 0; 	if (do_test_get_dec("12345678abcdef90",				12345678, 'a',				0, -2,				0, -2,				false))		ret = -1; 	if (do_test_get_dec("1\n2\n3\n",				1, '\n',				2, '\n',				3, '\n',				false))		ret = -1; 	if (do_test_get_dec("12345678;1;2",				12345678, ';',				1, ';',				2, -1,				true))		ret = -1; 	if (do_test_get_dec("0x1x2x",				0, 'x',				1, 'x',				2, 'x',				false))		ret = -1; 	if (do_test_get_dec("x1x",				0, -2,				1, 'x',				0, -1,				true))		ret = -1; 	if (do_test_get_dec("10000000000000000000000000000000000000000000000000000000000123456789ab99c",				123456789, 'a',				0, -2,				99, 'c',				false))		ret = -1; 	return ret;} static int test_get_line(void){	char path[PATH_MAX];	struct io io;	char test_string[1024];	char *line = NULL;	size_t i, line_len = 0;	size_t buf_size = 128;	int ret = 0; 	for (i = 0; i < 512; i++)		test_string[i] = 'a';	test_string[512] = '\n';	for (i = 513; i < 1023; i++)		test_string[i] = 'b';	test_string[1023] = '\0'; 	if (setup_test(path, test_string, buf_size, &io))		return -1; 	EXPECT_EQUAL((int)io__getline(&io, &line, &line_len), 513);	EXPECT_EQUAL((int)strlen(line), 513);	for (i = 0; i < 512; i++)		EXPECT_EQUAL(line[i], 'a');	EXPECT_EQUAL(line[512], '\n');	EXPECT_EQUAL((int)io__getline(&io, &line, &line_len), 510);	for (i = 0; i < 510; i++)		EXPECT_EQUAL(line[i], 'b'); 	free(line);	cleanup_test(path, &io);	return ret;} static int test__api_io(struct test_suite *test __maybe_unused,			int subtest __maybe_unused){	int ret = 0; 	if (test_get_char())		ret = TEST_FAIL;	if (test_get_hex())		ret = TEST_FAIL;	if (test_get_dec())		ret = TEST_FAIL;	if (test_get_line())		ret = TEST_FAIL;	return ret;} DEFINE_SUITE("Test api io", api_io);