linux-kernel - Re: [PATCH v2 5/6] lib: math_kunit: Add tests for new macros related to rounding to nearest value

lists.openwall.net		lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC
Open Source and information security mailing list archives

Hash Suite: Windows password security audit tool. GUI, reports in PDF.

[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]

Message-ID: <ZtHSIyDbljwrkWBE@e133380.arm.com>
Date: Fri, 30 Aug 2024 15:07:31 +0100
From: Dave Martin <Dave.Martin@....com>
To: Devarsh Thakkar <devarsht@...com>
Cc: mchehab@...nel.org, hverkuil-cisco@...all.nl,
	linux-media@...r.kernel.org, linux-kernel@...r.kernel.org,
	sebastian.fricke@...labora.com, linux-doc@...r.kernel.org,
	praneeth@...com, nm@...com, vigneshr@...com, s-jain1@...com,
	r-donadkar@...com, b-brnich@...com, detheridge@...com,
	p-mantena@...com, vijayp@...com, andi.shyti@...ux.intel.com,
	nicolas@...fresne.ca, andriy.shevchenko@...ux.intel.com,
	jirislaby@...nel.org, davidgow@...gle.com, dlatypov@...gle.com,
	corbet@....net, broonie@...nel.org, jani.nikula@...el.com,
	rdunlap@...radead.org, nik.borisov@...e.com
Subject: Re: [PATCH v2 5/6] lib: math_kunit: Add tests for new macros related
 to rounding to nearest value

On Mon, Aug 26, 2024 at 08:38:21PM +0530, Devarsh Thakkar wrote:
> Add tests for round_closest_up/down and roundclosest macros which round
> to nearest multiple of specified argument. These are tested with kunit
> tool as shared here [1] :

The tests here don't seem to be well targeted at the actual edge cases
where incrementing or decremting the dividend by 1 is expected to
change the result, or when round_closest_up() and round_closest_down()
are expected to differ.

There's also no coverage of:

	* negative inputs

	* types other than int

	* inputs close to type limits

(I've highlighted a few specific issues below, though there seems to be
a more general lack of coverage here.)

> 
> Link: https://gist.github.com/devarsht/3f9042825be3da4e133b8f4eda067876 [1]
> Signed-off-by: Devarsh Thakkar <devarsht@...com>
> Acked-by: Andy Shevchenko <andriy.shevchenko@...ux.intel.com>
> ---
> V2: No change
> ---
>  lib/math/math_kunit.c | 35 +++++++++++++++++++++++++++++++++++
>  1 file changed, 35 insertions(+)
> 
> diff --git a/lib/math/math_kunit.c b/lib/math/math_kunit.c
> index be27f2afb8e4..05022f010be6 100644
> --- a/lib/math/math_kunit.c
> +++ b/lib/math/math_kunit.c
> @@ -70,6 +70,26 @@ static void round_down_test(struct kunit *test)
>  	KUNIT_EXPECT_EQ(test, round_down((1 << 30) - 1, 1 << 29), 1 << 29);
>  }
>  
> +static void round_closest_up_test(struct kunit *test)
> +{
> +	KUNIT_EXPECT_EQ(test, round_closest_up(17, 4), 16);
> +	KUNIT_EXPECT_EQ(test, round_closest_up(15, 4), 16);
> +	KUNIT_EXPECT_EQ(test, round_closest_up(14, 4), 16);
> +	KUNIT_EXPECT_EQ(test, round_closest_up((1 << 30) - 1, 1 << 30), 1 << 30);
> +	KUNIT_EXPECT_EQ(test, round_closest_up((1 << 30) + 1, 1 << 30), 1 << 30);

These miss the edge case where the result is expected to change; could
we also check:

	round_closest_up(1 << 29, 1 << 30)


> +	KUNIT_EXPECT_EQ(test, round_closest_up((1 << 30) - 1, 2), 1 << 30);
> +}
> +
> +static void round_closest_down_test(struct kunit *test)
> +{
> +	KUNIT_EXPECT_EQ(test, round_closest_down(17, 4), 16);
> +	KUNIT_EXPECT_EQ(test, round_closest_down(15, 4), 16);
> +	KUNIT_EXPECT_EQ(test, round_closest_down(14, 4), 12);
> +	KUNIT_EXPECT_EQ(test, round_closest_down((1 << 30) - 1, 1 << 30), 1 << 30);
> +	KUNIT_EXPECT_EQ(test, round_closest_down((1 << 30) + 1, 1 << 30), 1 << 30);
> +	KUNIT_EXPECT_EQ(test, round_closest_down((1 << 30) - 1, 2), (1 << 30) - 2);
> +}
> +
>  /* These versions can round to numbers that aren't a power of two */
>  static void roundup_test(struct kunit *test)
>  {
> @@ -95,6 +115,18 @@ static void rounddown_test(struct kunit *test)
>  	KUNIT_EXPECT_EQ(test, rounddown(4, 3), 3);
>  }
>  
> +static void roundclosest_test(struct kunit *test)
> +{
> +	KUNIT_EXPECT_EQ(test, roundclosest(21, 5), 20);
> +	KUNIT_EXPECT_EQ(test, roundclosest(19, 5), 20);

This seems to miss the edge cases (e.g., roundclosest(20 * N + 10, 20),
roundclosest(20 * N +/- 9, 20) for some N.

> +	KUNIT_EXPECT_EQ(test, roundclosest(17, 5), 15);
> +	KUNIT_EXPECT_EQ(test, roundclosest((1 << 30), 3), (1 << 30) - 1);
> +	KUNIT_EXPECT_EQ(test, roundclosest((1 << 30) - 1, 1 << 29), 1 << 30);
> +
> +	KUNIT_EXPECT_EQ(test, roundclosest(4, 3), 3);
> +	KUNIT_EXPECT_EQ(test, roundclosest(5, 3), 6);
> +}
> +

[...]

Cheers
---Dave