[linux-2.6-block.git] / drivers / iio / test / iio-test-format.c

// SPDX-License-Identifier: GPL-2.0-only
/* Unit tests for IIO formatting functions
 *
 * Copyright (c) 2020 Lars-Peter Clausen <lars@metafoo.de>
 */

#include <kunit/test.h>
#include <linux/iio/iio.h>

#define IIO_TEST_FORMAT_EXPECT_EQ(_test, _buf, _ret, _val) do { \
		KUNIT_EXPECT_EQ(_test, strlen(_buf), _ret); \
		KUNIT_EXPECT_STREQ(_test, (_buf), (_val)); \
	} while (0)

static void iio_test_iio_format_value_integer(struct kunit *test)
{
	char *buf;
	int val;
	int ret;

	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);

	val = 42;
	ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "42\n");

	val = -23;
	ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-23\n");

	val = 0;
	ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0\n");

	val = INT_MAX;
	ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "2147483647\n");

	val = INT_MIN;
	ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-2147483648\n");
}

static void iio_test_iio_format_value_fixedpoint(struct kunit *test)
{
	int values[2];
	char *buf;
	int ret;

	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);

	/* positive >= 1 */
	values[0] = 1;
	values[1] = 10;

	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1.000010\n");

	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO_DB, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1.000010 dB\n");

	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_NANO, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1.000000010\n");

	/* positive < 1 */
	values[0] = 0;
	values[1] = 12;

	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000012\n");

	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO_DB, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000012 dB\n");

	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_NANO, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000000012\n");

	/* negative <= -1 */
	values[0] = -1;
	values[1] = 10;

	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1.000010\n");

	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO_DB, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1.000010 dB\n");

	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_NANO, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1.000000010\n");

	/* negative > -1 */
	values[0] = 0;
	values[1] = -123;
	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.000123\n");

	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO_DB, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.000123 dB\n");

	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_NANO, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.000000123\n");
}

static void iio_test_iio_format_value_fractional(struct kunit *test)
{
	int values[2];
	char *buf;
	int ret;

	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);

	/* positive < 1 */
	values[0] = 1;
	values[1] = 10;
	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.100000000\n");

	/* positive >= 1 */
	values[0] = 100;
	values[1] = 3;
	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "33.333333333\n");

	/* negative > -1 */
	values[0] = -1;
	values[1] = 1000000000;
	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.000000001\n");

	/* negative <= -1 */
	values[0] = -200;
	values[1] = 3;
	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-66.666666666\n");

	/* Zero */
	values[0] = 0;
	values[1] = -10;
	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000000000\n");
}

static void iio_test_iio_format_value_fractional_log2(struct kunit *test)
{
	int values[2];
	char *buf;
	int ret;

	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);

	/* positive < 1 */
	values[0] = 123;
	values[1] = 10;
	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.120117187\n");

	/* positive >= 1 */
	values[0] = 1234567;
	values[1] = 10;
	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1205.631835937\n");

	/* negative > -1 */
	values[0] = -123;
	values[1] = 10;
	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.120117187\n");

	/* negative <= -1 */
	values[0] = -1234567;
	values[1] = 10;
	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1205.631835937\n");

	/* Zero */
	values[0] = 0;
	values[1] = 10;
	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000000000\n");
}

static void iio_test_iio_format_value_multiple(struct kunit *test)
{
	int values[] = {1, -2, 3, -4, 5};
	char *buf;
	int ret;

	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);

	ret = iio_format_value(buf, IIO_VAL_INT_MULTIPLE,
			       ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1 -2 3 -4 5 \n");
}

static void iio_test_iio_format_value_integer_64(struct kunit *test)
{
	int values[2];
	s64 value;
	char *buf;
	int ret;

	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);

	value = 24;
	values[0] = lower_32_bits(value);
	values[1] = upper_32_bits(value);
	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "24\n");

	value = -24;
	values[0] = lower_32_bits(value);
	values[1] = upper_32_bits(value);
	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-24\n");

	value = 0;
	values[0] = lower_32_bits(value);
	values[1] = upper_32_bits(value);
	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0\n");

	value = UINT_MAX;
	values[0] = lower_32_bits(value);
	values[1] = upper_32_bits(value);
	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "4294967295\n");

	value = -((s64)UINT_MAX);
	values[0] = lower_32_bits(value);
	values[1] = upper_32_bits(value);
	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-4294967295\n");

	value = LLONG_MAX;
	values[0] = lower_32_bits(value);
	values[1] = upper_32_bits(value);
	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "9223372036854775807\n");

	value = LLONG_MIN;
	values[0] = lower_32_bits(value);
	values[1] = upper_32_bits(value);
	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-9223372036854775808\n");
}

static struct kunit_case iio_format_test_cases[] = {
		KUNIT_CASE(iio_test_iio_format_value_integer),
		KUNIT_CASE(iio_test_iio_format_value_fixedpoint),
		KUNIT_CASE(iio_test_iio_format_value_fractional),
		KUNIT_CASE(iio_test_iio_format_value_fractional_log2),
		KUNIT_CASE(iio_test_iio_format_value_multiple),
		KUNIT_CASE(iio_test_iio_format_value_integer_64),
		{}
};

static struct kunit_suite iio_format_test_suite = {
	.name = "iio-format",
	.test_cases = iio_format_test_cases,
};
kunit_test_suite(iio_format_test_suite);

MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
MODULE_DESCRIPTION("Test IIO formatting functions");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
0bf49ffb LPC	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/* Unit tests for IIO formatting functions
	3	*
	4	* Copyright (c) 2020 Lars-Peter Clausen <lars@metafoo.de>
	5	*/
	6
	7	#include <kunit/test.h>
	8	#include <linux/iio/iio.h>
	9
	10	#define IIO_TEST_FORMAT_EXPECT_EQ(_test, _buf, _ret, _val) do { \
28dce2c4	11	KUNIT_EXPECT_EQ(_test, strlen(_buf), _ret); \
0bf49ffb LPC	12	KUNIT_EXPECT_STREQ(_test, (_buf), (_val)); \
	13	} while (0)
	14
	15	static void iio_test_iio_format_value_integer(struct kunit *test)
	16	{
ee8ec048	17	char *buf;
0bf49ffb LPC	18	int val;
	19	int ret;
	20
ee8ec048 AT	21	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	22	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
	23
0bf49ffb LPC	24	val = 42;
	25	ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
	26	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "42\n");
	27
	28	val = -23;
	29	ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
	30	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-23\n");
	31
	32	val = 0;
	33	ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
	34	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0\n");
	35
	36	val = INT_MAX;
	37	ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
	38	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "2147483647\n");
	39
	40	val = INT_MIN;
	41	ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
	42	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-2147483648\n");
	43	}
	44
	45	static void iio_test_iio_format_value_fixedpoint(struct kunit *test)
	46	{
0bf49ffb	47	int values[2];
ee8ec048	48	char *buf;
0bf49ffb LPC	49	int ret;
0bf49ffb LPC	50
ee8ec048 AT	51	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	52	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
	53
0bf49ffb LPC	54	/* positive >= 1 */
	55	values[0] = 1;
	56	values[1] = 10;
	57
ee8ec048	58	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(values), values);
0bf49ffb LPC	59	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1.000010\n");
0bf49ffb LPC	60
ee8ec048	61	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO_DB, ARRAY_SIZE(values), values);
0bf49ffb LPC	62	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1.000010 dB\n");
0bf49ffb LPC	63
ee8ec048	64	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_NANO, ARRAY_SIZE(values), values);
0bf49ffb LPC	65	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1.000000010\n");
	66
	67	/* positive < 1 */
	68	values[0] = 0;
	69	values[1] = 12;
	70
ee8ec048	71	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(values), values);
0bf49ffb LPC	72	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000012\n");
0bf49ffb LPC	73
ee8ec048	74	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO_DB, ARRAY_SIZE(values), values);
0bf49ffb LPC	75	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000012 dB\n");
0bf49ffb LPC	76
ee8ec048	77	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_NANO, ARRAY_SIZE(values), values);
0bf49ffb LPC	78	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000000012\n");
	79
	80	/* negative <= -1 */
	81	values[0] = -1;
	82	values[1] = 10;
	83
ee8ec048	84	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(values), values);
0bf49ffb LPC	85	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1.000010\n");
0bf49ffb LPC	86
ee8ec048	87	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO_DB, ARRAY_SIZE(values), values);
0bf49ffb LPC	88	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1.000010 dB\n");
0bf49ffb LPC	89
ee8ec048	90	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_NANO, ARRAY_SIZE(values), values);
0bf49ffb LPC	91	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1.000000010\n");
	92
	93	/* negative > -1 */
	94	values[0] = 0;
	95	values[1] = -123;
ee8ec048	96	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(values), values);
0bf49ffb LPC	97	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.000123\n");
0bf49ffb LPC	98
ee8ec048	99	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO_DB, ARRAY_SIZE(values), values);
0bf49ffb LPC	100	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.000123 dB\n");
0bf49ffb LPC	101
ee8ec048	102	ret = iio_format_value(buf, IIO_VAL_INT_PLUS_NANO, ARRAY_SIZE(values), values);
0bf49ffb LPC	103	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.000000123\n");
	104	}
	105
	106	static void iio_test_iio_format_value_fractional(struct kunit *test)
	107	{
0bf49ffb	108	int values[2];
ee8ec048	109	char *buf;
0bf49ffb LPC	110	int ret;
0bf49ffb LPC	111
ee8ec048 AT	112	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	113	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
	114
0bf49ffb LPC	115	/* positive < 1 */
	116	values[0] = 1;
	117	values[1] = 10;
ee8ec048	118	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
0bf49ffb LPC	119	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.100000000\n");
	120
	121	/* positive >= 1 */
	122	values[0] = 100;
	123	values[1] = 3;
ee8ec048	124	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
0bf49ffb LPC	125	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "33.333333333\n");
	126
	127	/* negative > -1 */
	128	values[0] = -1;
	129	values[1] = 1000000000;
ee8ec048	130	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
0bf49ffb LPC	131	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.000000001\n");
	132
	133	/* negative <= -1 */
	134	values[0] = -200;
	135	values[1] = 3;
ee8ec048	136	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
0bf49ffb LPC	137	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-66.666666666\n");
	138
	139	/* Zero */
	140	values[0] = 0;
	141	values[1] = -10;
ee8ec048	142	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
0bf49ffb LPC	143	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000000000\n");
	144	}
	145
	146	static void iio_test_iio_format_value_fractional_log2(struct kunit *test)
	147	{
0bf49ffb	148	int values[2];
ee8ec048	149	char *buf;
0bf49ffb LPC	150	int ret;
0bf49ffb LPC	151
ee8ec048 AT	152	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	153	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
	154
0bf49ffb LPC	155	/* positive < 1 */
	156	values[0] = 123;
	157	values[1] = 10;
ee8ec048	158	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
0bf49ffb LPC	159	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.120117187\n");
	160
	161	/* positive >= 1 */
	162	values[0] = 1234567;
	163	values[1] = 10;
ee8ec048	164	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
0bf49ffb LPC	165	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1205.631835937\n");
	166
	167	/* negative > -1 */
	168	values[0] = -123;
	169	values[1] = 10;
ee8ec048	170	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
0bf49ffb LPC	171	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.120117187\n");
	172
	173	/* negative <= -1 */
	174	values[0] = -1234567;
	175	values[1] = 10;
ee8ec048	176	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
0bf49ffb LPC	177	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1205.631835937\n");
	178
	179	/* Zero */
	180	values[0] = 0;
	181	values[1] = 10;
ee8ec048	182	ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
0bf49ffb LPC	183	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000000000\n");
	184	}
	185
	186	static void iio_test_iio_format_value_multiple(struct kunit *test)
	187	{
0bf49ffb	188	int values[] = {1, -2, 3, -4, 5};
ee8ec048	189	char *buf;
0bf49ffb LPC	190	int ret;
0bf49ffb LPC	191
ee8ec048 AT	192	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	193	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
	194
0bf49ffb LPC	195	ret = iio_format_value(buf, IIO_VAL_INT_MULTIPLE,
	196	ARRAY_SIZE(values), values);
	197	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1 -2 3 -4 5 \n");
	198	}
	199
1d9b750c AT	200	static void iio_test_iio_format_value_integer_64(struct kunit *test)
	201	{
	202	int values[2];
	203	s64 value;
	204	char *buf;
	205	int ret;
	206
	207	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	208	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
	209
	210	value = 24;
	211	values[0] = lower_32_bits(value);
	212	values[1] = upper_32_bits(value);
	213	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	214	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "24\n");
	215
	216	value = -24;
	217	values[0] = lower_32_bits(value);
	218	values[1] = upper_32_bits(value);
	219	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	220	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-24\n");
	221
	222	value = 0;
	223	values[0] = lower_32_bits(value);
	224	values[1] = upper_32_bits(value);
	225	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	226	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0\n");
	227
	228	value = UINT_MAX;
	229	values[0] = lower_32_bits(value);
	230	values[1] = upper_32_bits(value);
	231	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	232	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "4294967295\n");
	233
	234	value = -((s64)UINT_MAX);
	235	values[0] = lower_32_bits(value);
	236	values[1] = upper_32_bits(value);
	237	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	238	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-4294967295\n");
	239
	240	value = LLONG_MAX;
	241	values[0] = lower_32_bits(value);
	242	values[1] = upper_32_bits(value);
	243	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	244	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "9223372036854775807\n");
	245
	246	value = LLONG_MIN;
	247	values[0] = lower_32_bits(value);
	248	values[1] = upper_32_bits(value);
	249	ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
	250	IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-9223372036854775808\n");
	251	}
	252
0bf49ffb LPC	253	static struct kunit_case iio_format_test_cases[] = {
	254	KUNIT_CASE(iio_test_iio_format_value_integer),
	255	KUNIT_CASE(iio_test_iio_format_value_fixedpoint),
	256	KUNIT_CASE(iio_test_iio_format_value_fractional),
	257	KUNIT_CASE(iio_test_iio_format_value_fractional_log2),
	258	KUNIT_CASE(iio_test_iio_format_value_multiple),
1d9b750c	259	KUNIT_CASE(iio_test_iio_format_value_integer_64),
0bf49ffb LPC	260	{}
	261	};
	262
	263	static struct kunit_suite iio_format_test_suite = {
	264	.name = "iio-format",
	265	.test_cases = iio_format_test_cases,
	266	};
	267	kunit_test_suite(iio_format_test_suite);
520f94b6 LB	268
	269	MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
	270	MODULE_DESCRIPTION("Test IIO formatting functions");
	271	MODULE_LICENSE("GPL v2");