* [PATCH v1 0/2] iio: test: Add test for IIO_VAL_INT_64.
@ 2021-11-05 10:04 Andriy Tryshnivskyy
2021-11-05 10:05 ` [PATCH v1 1/2] iio: test: Add check against NULL for buffer in tests Andriy Tryshnivskyy
` (2 more replies)
0 siblings, 3 replies; 10+ messages in thread
From: Andriy Tryshnivskyy @ 2021-11-05 10:04 UTC (permalink / raw)
To: jbhayana, jic23
Cc: lars, linux-iio, linux-kernel, Vasyl.Vavrychuk, andy.shevchenko,
andriy.tryshnivskyy
Add test for IIO_VAL_INT_64.
Add check against NULL for buffer in tests.
Use ARRAY_SIZE(values) where it is possible.
Andriy Tryshnivskyy (2):
iio: test: Add check against NULL for buffer in tests.
iio: test: Add test for IIO_VAL_INT_64.
drivers/iio/test/iio-test-format.c | 123 ++++++++++++++++++++++-------
1 file changed, 96 insertions(+), 27 deletions(-)
base-commit: 7d2a07b769330c34b4deabeed939325c77a7ec2f
--
2.17.1
^ permalink raw reply [flat|nested] 10+ messages in thread
* [PATCH v1 1/2] iio: test: Add check against NULL for buffer in tests.
2021-11-05 10:04 [PATCH v1 0/2] iio: test: Add test for IIO_VAL_INT_64 Andriy Tryshnivskyy
@ 2021-11-05 10:05 ` Andriy Tryshnivskyy
2021-11-05 10:16 ` Andy Shevchenko
2021-11-05 10:05 ` [PATCH v1 2/2] iio: test: Add test for IIO_VAL_INT_64 Andriy Tryshnivskyy
2021-11-05 10:17 ` [PATCH v1 0/2] " Andy Shevchenko
2 siblings, 1 reply; 10+ messages in thread
From: Andriy Tryshnivskyy @ 2021-11-05 10:05 UTC (permalink / raw)
To: jbhayana, jic23
Cc: lars, linux-iio, linux-kernel, Vasyl.Vavrychuk, andy.shevchenko,
andriy.tryshnivskyy
Add KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf) for every test.
Also use ARRAY_SIZE(values) where it is possible.
Signed-off-by: Andriy Tryshnivskyy <andriy.tryshnivskyy@opensynergy.com>
---
drivers/iio/test/iio-test-format.c | 69 ++++++++++++++++++------------
1 file changed, 42 insertions(+), 27 deletions(-)
diff --git a/drivers/iio/test/iio-test-format.c b/drivers/iio/test/iio-test-format.c
index f1e951eddb43..b746d00bc0ea 100644
--- a/drivers/iio/test/iio-test-format.c
+++ b/drivers/iio/test/iio-test-format.c
@@ -14,10 +14,13 @@
static void iio_test_iio_format_value_integer(struct kunit *test)
{
- char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
+ 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");
@@ -41,142 +44,154 @@ static void iio_test_iio_format_value_integer(struct kunit *test)
static void iio_test_iio_format_value_fixedpoint(struct kunit *test)
{
- char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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)
{
- char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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)
{
- char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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, 2, values);
+ 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)
{
- char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
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");
--
2.17.1
^ permalink raw reply related [flat|nested] 10+ messages in thread
* [PATCH v1 2/2] iio: test: Add test for IIO_VAL_INT_64.
2021-11-05 10:04 [PATCH v1 0/2] iio: test: Add test for IIO_VAL_INT_64 Andriy Tryshnivskyy
2021-11-05 10:05 ` [PATCH v1 1/2] iio: test: Add check against NULL for buffer in tests Andriy Tryshnivskyy
@ 2021-11-05 10:05 ` Andriy Tryshnivskyy
2021-11-05 20:20 ` kernel test robot
2021-11-05 10:17 ` [PATCH v1 0/2] " Andy Shevchenko
2 siblings, 1 reply; 10+ messages in thread
From: Andriy Tryshnivskyy @ 2021-11-05 10:05 UTC (permalink / raw)
To: jbhayana, jic23
Cc: lars, linux-iio, linux-kernel, Vasyl.Vavrychuk, andy.shevchenko,
andriy.tryshnivskyy
Add test for newly introduced type IIO_VAL_INT_64.
Signed-off-by: Andriy Tryshnivskyy <andriy.tryshnivskyy@opensynergy.com>
---
Changes comparing v0 -> v1:
* add KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf)
* use ARRAY_SIZE(values)
* fixes according to Reverse Christmas Tree Format
* use constant UINT_MAX
drivers/iio/test/iio-test-format.c | 54 ++++++++++++++++++++++++++++++
1 file changed, 54 insertions(+)
diff --git a/drivers/iio/test/iio-test-format.c b/drivers/iio/test/iio-test-format.c
index b746d00bc0ea..237321436b83 100644
--- a/drivers/iio/test/iio-test-format.c
+++ b/drivers/iio/test/iio-test-format.c
@@ -197,12 +197,66 @@ static void iio_test_iio_format_value_multiple(struct kunit *test)
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),
{}
};
--
2.17.1
^ permalink raw reply related [flat|nested] 10+ messages in thread
* Re: [PATCH v1 1/2] iio: test: Add check against NULL for buffer in tests.
2021-11-05 10:05 ` [PATCH v1 1/2] iio: test: Add check against NULL for buffer in tests Andriy Tryshnivskyy
@ 2021-11-05 10:16 ` Andy Shevchenko
2021-11-13 16:52 ` Jonathan Cameron
0 siblings, 1 reply; 10+ messages in thread
From: Andy Shevchenko @ 2021-11-05 10:16 UTC (permalink / raw)
To: Andriy Tryshnivskyy
Cc: jbhayana, Jonathan Cameron, Lars-Peter Clausen, linux-iio,
Linux Kernel Mailing List, Vasyl.Vavrychuk
On Fri, Nov 5, 2021 at 12:05 PM Andriy Tryshnivskyy
<andriy.tryshnivskyy@opensynergy.com> wrote:
>
> Add KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf) for every test.
> Also use ARRAY_SIZE(values) where it is possible.
Strictly speaking 'also' and similar in the commit message means you
have to split. Here are two patches in one. But these are test cases
and I don't care so much about the rules. Up to maintainers.
>
> Signed-off-by: Andriy Tryshnivskyy <andriy.tryshnivskyy@opensynergy.com>
> ---
> drivers/iio/test/iio-test-format.c | 69 ++++++++++++++++++------------
> 1 file changed, 42 insertions(+), 27 deletions(-)
>
> diff --git a/drivers/iio/test/iio-test-format.c b/drivers/iio/test/iio-test-format.c
> index f1e951eddb43..b746d00bc0ea 100644
> --- a/drivers/iio/test/iio-test-format.c
> +++ b/drivers/iio/test/iio-test-format.c
> @@ -14,10 +14,13 @@
>
> static void iio_test_iio_format_value_integer(struct kunit *test)
> {
> - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> + 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");
> @@ -41,142 +44,154 @@ static void iio_test_iio_format_value_integer(struct kunit *test)
>
> static void iio_test_iio_format_value_fixedpoint(struct kunit *test)
> {
> - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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)
> {
> - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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)
> {
> - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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, 2, values);
> + 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)
> {
> - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> 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");
> --
> 2.17.1
>
--
With Best Regards,
Andy Shevchenko
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [PATCH v1 0/2] iio: test: Add test for IIO_VAL_INT_64.
2021-11-05 10:04 [PATCH v1 0/2] iio: test: Add test for IIO_VAL_INT_64 Andriy Tryshnivskyy
2021-11-05 10:05 ` [PATCH v1 1/2] iio: test: Add check against NULL for buffer in tests Andriy Tryshnivskyy
2021-11-05 10:05 ` [PATCH v1 2/2] iio: test: Add test for IIO_VAL_INT_64 Andriy Tryshnivskyy
@ 2021-11-05 10:17 ` Andy Shevchenko
2021-11-05 10:26 ` Andriy Tryshnivskyy
2 siblings, 1 reply; 10+ messages in thread
From: Andy Shevchenko @ 2021-11-05 10:17 UTC (permalink / raw)
To: Andriy Tryshnivskyy
Cc: jbhayana, Jonathan Cameron, Lars-Peter Clausen, linux-iio,
Linux Kernel Mailing List, Vasyl.Vavrychuk
On Fri, Nov 5, 2021 at 12:05 PM Andriy Tryshnivskyy
<andriy.tryshnivskyy@opensynergy.com> wrote:
>
> Add test for IIO_VAL_INT_64.
> Add check against NULL for buffer in tests.
> Use ARRAY_SIZE(values) where it is possible.
With or without splitting, for the entire series
Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
> Andriy Tryshnivskyy (2):
> iio: test: Add check against NULL for buffer in tests.
> iio: test: Add test for IIO_VAL_INT_64.
>
> drivers/iio/test/iio-test-format.c | 123 ++++++++++++++++++++++-------
> 1 file changed, 96 insertions(+), 27 deletions(-)
>
>
> base-commit: 7d2a07b769330c34b4deabeed939325c77a7ec2f
> --
> 2.17.1
>
--
With Best Regards,
Andy Shevchenko
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [PATCH v1 0/2] iio: test: Add test for IIO_VAL_INT_64.
2021-11-05 10:17 ` [PATCH v1 0/2] " Andy Shevchenko
@ 2021-11-05 10:26 ` Andriy Tryshnivskyy
0 siblings, 0 replies; 10+ messages in thread
From: Andriy Tryshnivskyy @ 2021-11-05 10:26 UTC (permalink / raw)
To: Andy Shevchenko
Cc: jbhayana, Jonathan Cameron, Lars-Peter Clausen, linux-iio,
Linux Kernel Mailing List, Vasyl.Vavrychuk
Thank you for review!
Best regards,
Andriy.
On 05.11.21 12:17, Andy Shevchenko wrote:
> CAUTION: This email originated from outside of the organization.
> Do not click links or open attachments unless you recognize the sender and know the content is safe.
>
>
> On Fri, Nov 5, 2021 at 12:05 PM Andriy Tryshnivskyy
> <andriy.tryshnivskyy@opensynergy.com> wrote:
>> Add test for IIO_VAL_INT_64.
>> Add check against NULL for buffer in tests.
>> Use ARRAY_SIZE(values) where it is possible.
> With or without splitting, for the entire series
> Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
>
>> Andriy Tryshnivskyy (2):
>> iio: test: Add check against NULL for buffer in tests.
>> iio: test: Add test for IIO_VAL_INT_64.
>>
>> drivers/iio/test/iio-test-format.c | 123 ++++++++++++++++++++++-------
>> 1 file changed, 96 insertions(+), 27 deletions(-)
>>
>>
>> base-commit: 7d2a07b769330c34b4deabeed939325c77a7ec2f
>> --
>> 2.17.1
>>
>
> --
> With Best Regards,
> Andy Shevchenko
>
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [PATCH v1 2/2] iio: test: Add test for IIO_VAL_INT_64.
2021-11-05 10:05 ` [PATCH v1 2/2] iio: test: Add test for IIO_VAL_INT_64 Andriy Tryshnivskyy
@ 2021-11-05 20:20 ` kernel test robot
0 siblings, 0 replies; 10+ messages in thread
From: kernel test robot @ 2021-11-05 20:20 UTC (permalink / raw)
To: Andriy Tryshnivskyy, jbhayana, jic23
Cc: kbuild-all, lars, linux-iio, linux-kernel, Vasyl.Vavrychuk,
andy.shevchenko, andriy.tryshnivskyy
[-- Attachment #1: Type: text/plain, Size: 4164 bytes --]
Hi Andriy,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on 7d2a07b769330c34b4deabeed939325c77a7ec2f]
url: https://github.com/0day-ci/linux/commits/Andriy-Tryshnivskyy/iio-test-Add-test-for-IIO_VAL_INT_64/20211105-180624
base: 7d2a07b769330c34b4deabeed939325c77a7ec2f
config: arc-buildonly-randconfig-r002-20211105 (attached as .config)
compiler: arc-elf-gcc (GCC) 11.2.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/679e11158271ed8c6219060b06dca25dce946859
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Andriy-Tryshnivskyy/iio-test-Add-test-for-IIO_VAL_INT_64/20211105-180624
git checkout 679e11158271ed8c6219060b06dca25dce946859
# save the attached .config to linux build tree
mkdir build_dir
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=arc SHELL=/bin/bash drivers/iio/test/
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
All errors (new ones prefixed by >>):
drivers/iio/test/iio-test-format.c: In function 'iio_test_iio_format_value_integer_64':
>> drivers/iio/test/iio-test-format.c:213:37: error: 'IIO_VAL_INT_64' undeclared (first use in this function); did you mean 'IIO_VAL_INT'?
213 | ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
| ^~~~~~~~~~~~~~
| IIO_VAL_INT
drivers/iio/test/iio-test-format.c:213:37: note: each undeclared identifier is reported only once for each function it appears in
vim +213 drivers/iio/test/iio-test-format.c
199
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
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 26599 bytes --]
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [PATCH v1 1/2] iio: test: Add check against NULL for buffer in tests.
2021-11-05 10:16 ` Andy Shevchenko
@ 2021-11-13 16:52 ` Jonathan Cameron
2021-11-27 18:53 ` Jonathan Cameron
0 siblings, 1 reply; 10+ messages in thread
From: Jonathan Cameron @ 2021-11-13 16:52 UTC (permalink / raw)
To: Andy Shevchenko
Cc: Andriy Tryshnivskyy, jbhayana, Lars-Peter Clausen, linux-iio,
Linux Kernel Mailing List, Vasyl.Vavrychuk
On Fri, 5 Nov 2021 12:16:40 +0200
Andy Shevchenko <andy.shevchenko@gmail.com> wrote:
> On Fri, Nov 5, 2021 at 12:05 PM Andriy Tryshnivskyy
> <andriy.tryshnivskyy@opensynergy.com> wrote:
> >
> > Add KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf) for every test.
> > Also use ARRAY_SIZE(values) where it is possible.
>
> Strictly speaking 'also' and similar in the commit message means you
> have to split. Here are two patches in one. But these are test cases
> and I don't care so much about the rules. Up to maintainers.
Ideally I'd agree, but sometimes it's just not worth wasting anyones time
if both parts are mechanical as here.
Given this is Lars' code I'll leave a bit longer for him to give any tags
he wishes before picking it up.
Give me a poke if I seem to have lost it in a few weeks. In theory I
shouldn't given I'm using patchwork as a backup tracker these days, but
meh - I've lost series before!
Thanks,
Jonathan
>
> >
> > Signed-off-by: Andriy Tryshnivskyy <andriy.tryshnivskyy@opensynergy.com>
> > ---
> > drivers/iio/test/iio-test-format.c | 69 ++++++++++++++++++------------
> > 1 file changed, 42 insertions(+), 27 deletions(-)
> >
> > diff --git a/drivers/iio/test/iio-test-format.c b/drivers/iio/test/iio-test-format.c
> > index f1e951eddb43..b746d00bc0ea 100644
> > --- a/drivers/iio/test/iio-test-format.c
> > +++ b/drivers/iio/test/iio-test-format.c
> > @@ -14,10 +14,13 @@
> >
> > static void iio_test_iio_format_value_integer(struct kunit *test)
> > {
> > - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> > + 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");
> > @@ -41,142 +44,154 @@ static void iio_test_iio_format_value_integer(struct kunit *test)
> >
> > static void iio_test_iio_format_value_fixedpoint(struct kunit *test)
> > {
> > - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> > 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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)
> > {
> > - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> > 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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)
> > {
> > - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> > 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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, 2, values);
> > + 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)
> > {
> > - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> > 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");
> > --
> > 2.17.1
> >
>
>
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [PATCH v1 1/2] iio: test: Add check against NULL for buffer in tests.
2021-11-13 16:52 ` Jonathan Cameron
@ 2021-11-27 18:53 ` Jonathan Cameron
2021-11-28 18:23 ` Andriy Tryshnivskyy
0 siblings, 1 reply; 10+ messages in thread
From: Jonathan Cameron @ 2021-11-27 18:53 UTC (permalink / raw)
To: Andy Shevchenko
Cc: Andriy Tryshnivskyy, jbhayana, Lars-Peter Clausen, linux-iio,
Linux Kernel Mailing List, Vasyl.Vavrychuk
On Sat, 13 Nov 2021 16:52:14 +0000
Jonathan Cameron <jic23@kernel.org> wrote:
> On Fri, 5 Nov 2021 12:16:40 +0200
> Andy Shevchenko <andy.shevchenko@gmail.com> wrote:
>
> > On Fri, Nov 5, 2021 at 12:05 PM Andriy Tryshnivskyy
> > <andriy.tryshnivskyy@opensynergy.com> wrote:
> > >
> > > Add KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf) for every test.
> > > Also use ARRAY_SIZE(values) where it is possible.
> >
> > Strictly speaking 'also' and similar in the commit message means you
> > have to split. Here are two patches in one. But these are test cases
> > and I don't care so much about the rules. Up to maintainers.
>
> Ideally I'd agree, but sometimes it's just not worth wasting anyones time
> if both parts are mechanical as here.
>
> Given this is Lars' code I'll leave a bit longer for him to give any tags
> he wishes before picking it up.
>
> Give me a poke if I seem to have lost it in a few weeks. In theory I
> shouldn't given I'm using patchwork as a backup tracker these days, but
> meh - I've lost series before!
Enough time I think. Applied to the togreg branch of iio.git and pushed out
as testing for 0-day to have a quick sanity check. I'll push it out so
linux-next picks it up later in the week.
Thanks,
Jonathan
>
> Thanks,
>
> Jonathan
>
> >
> > >
> > > Signed-off-by: Andriy Tryshnivskyy <andriy.tryshnivskyy@opensynergy.com>
> > > ---
> > > drivers/iio/test/iio-test-format.c | 69 ++++++++++++++++++------------
> > > 1 file changed, 42 insertions(+), 27 deletions(-)
> > >
> > > diff --git a/drivers/iio/test/iio-test-format.c b/drivers/iio/test/iio-test-format.c
> > > index f1e951eddb43..b746d00bc0ea 100644
> > > --- a/drivers/iio/test/iio-test-format.c
> > > +++ b/drivers/iio/test/iio-test-format.c
> > > @@ -14,10 +14,13 @@
> > >
> > > static void iio_test_iio_format_value_integer(struct kunit *test)
> > > {
> > > - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> > > + 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");
> > > @@ -41,142 +44,154 @@ static void iio_test_iio_format_value_integer(struct kunit *test)
> > >
> > > static void iio_test_iio_format_value_fixedpoint(struct kunit *test)
> > > {
> > > - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> > > 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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)
> > > {
> > > - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> > > 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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)
> > > {
> > > - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> > > 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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, 2, values);
> > > + 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)
> > > {
> > > - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
> > > 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");
> > > --
> > > 2.17.1
> > >
> >
> >
>
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [PATCH v1 1/2] iio: test: Add check against NULL for buffer in tests.
2021-11-27 18:53 ` Jonathan Cameron
@ 2021-11-28 18:23 ` Andriy Tryshnivskyy
0 siblings, 0 replies; 10+ messages in thread
From: Andriy Tryshnivskyy @ 2021-11-28 18:23 UTC (permalink / raw)
To: Jonathan Cameron, Andy Shevchenko
Cc: jbhayana, Lars-Peter Clausen, linux-iio,
Linux Kernel Mailing List, Vasyl.Vavrychuk
Thank you very much!
Best regards,
Andriy
On 27.11.21 20:53, Jonathan Cameron wrote:
> CAUTION: This email originated from outside of the organization.
> Do not click links or open attachments unless you recognize the sender and know the content is safe.
>
>
> On Sat, 13 Nov 2021 16:52:14 +0000
> Jonathan Cameron <jic23@kernel.org> wrote:
>
>> On Fri, 5 Nov 2021 12:16:40 +0200
>> Andy Shevchenko <andy.shevchenko@gmail.com> wrote:
>>
>>> On Fri, Nov 5, 2021 at 12:05 PM Andriy Tryshnivskyy
>>> <andriy.tryshnivskyy@opensynergy.com> wrote:
>>>> Add KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf) for every test.
>>>> Also use ARRAY_SIZE(values) where it is possible.
>>> Strictly speaking 'also' and similar in the commit message means you
>>> have to split. Here are two patches in one. But these are test cases
>>> and I don't care so much about the rules. Up to maintainers.
>> Ideally I'd agree, but sometimes it's just not worth wasting anyones time
>> if both parts are mechanical as here.
>>
>> Given this is Lars' code I'll leave a bit longer for him to give any tags
>> he wishes before picking it up.
>>
>> Give me a poke if I seem to have lost it in a few weeks. In theory I
>> shouldn't given I'm using patchwork as a backup tracker these days, but
>> meh - I've lost series before!
> Enough time I think. Applied to the togreg branch of iio.git and pushed out
> as testing for 0-day to have a quick sanity check. I'll push it out so
> linux-next picks it up later in the week.
>
> Thanks,
>
> Jonathan
>
>> Thanks,
>>
>> Jonathan
>>
>>>> Signed-off-by: Andriy Tryshnivskyy <andriy.tryshnivskyy@opensynergy.com>
>>>> ---
>>>> drivers/iio/test/iio-test-format.c | 69 ++++++++++++++++++------------
>>>> 1 file changed, 42 insertions(+), 27 deletions(-)
>>>>
>>>> diff --git a/drivers/iio/test/iio-test-format.c b/drivers/iio/test/iio-test-format.c
>>>> index f1e951eddb43..b746d00bc0ea 100644
>>>> --- a/drivers/iio/test/iio-test-format.c
>>>> +++ b/drivers/iio/test/iio-test-format.c
>>>> @@ -14,10 +14,13 @@
>>>>
>>>> static void iio_test_iio_format_value_integer(struct kunit *test)
>>>> {
>>>> - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
>>>> + 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");
>>>> @@ -41,142 +44,154 @@ static void iio_test_iio_format_value_integer(struct kunit *test)
>>>>
>>>> static void iio_test_iio_format_value_fixedpoint(struct kunit *test)
>>>> {
>>>> - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
>>>> 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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)
>>>> {
>>>> - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
>>>> 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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)
>>>> {
>>>> - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
>>>> 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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, 2, values);
>>>> + 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)
>>>> {
>>>> - char *buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
>>>> 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");
>>>> --
>>>> 2.17.1
>>>>
>>>
>
^ permalink raw reply [flat|nested] 10+ messages in thread
end of thread, other threads:[~2021-11-28 18:46 UTC | newest]
Thread overview: 10+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-11-05 10:04 [PATCH v1 0/2] iio: test: Add test for IIO_VAL_INT_64 Andriy Tryshnivskyy
2021-11-05 10:05 ` [PATCH v1 1/2] iio: test: Add check against NULL for buffer in tests Andriy Tryshnivskyy
2021-11-05 10:16 ` Andy Shevchenko
2021-11-13 16:52 ` Jonathan Cameron
2021-11-27 18:53 ` Jonathan Cameron
2021-11-28 18:23 ` Andriy Tryshnivskyy
2021-11-05 10:05 ` [PATCH v1 2/2] iio: test: Add test for IIO_VAL_INT_64 Andriy Tryshnivskyy
2021-11-05 20:20 ` kernel test robot
2021-11-05 10:17 ` [PATCH v1 0/2] " Andy Shevchenko
2021-11-05 10:26 ` Andriy Tryshnivskyy
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).