From nobody Tue Feb 10 04:12:54 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 34ED13396E9; Fri, 30 Jan 2026 10:06:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769767617; cv=none; b=Ir8k6joayYviqnTDdkz4tvq3EIEr+QXSX+Ogwi3urkVhRye0bzdSwaz0plNEQTp0jMQDF1piWEzrtRxRqyZ6ZuGv52d8YIMwwfrI6/XBjZz+MqC/uBE1ImUQeL5rsf80KQ2ADeMGAxbflNu0r4YFWrNoFQCK48yhPWUrNWjRXbc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769767617; c=relaxed/simple; bh=CWmR8udndqRD3mwTYihvj9ipuPGN/5Koc45Z3nq4E4w=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=PNfakkGM2EgIeBzBP8VprnWR1lsi9b0JcXO9HmgoNeZ+agioDNr+Qt5R0T47QSWsWYioaLpkquMmu9NAwkfy49sZa/Y7A/w9vUXxwwCWKPLZ3fEtVxHI0cV7z60ubMxxvprRxn7KoIa236M90jPX7HlYKoeHCCGD9ODYf+OKdk0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=U0pmMwGX; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="U0pmMwGX" Received: by smtp.kernel.org (Postfix) with ESMTPS id E80E7C19425; Fri, 30 Jan 2026 10:06:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1769767617; bh=CWmR8udndqRD3mwTYihvj9ipuPGN/5Koc45Z3nq4E4w=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=U0pmMwGXUFVEP1zYJ9CHMYVQ7Fh4t9NpmVcdhmyAKAHscTS458lWxsi1RchHx/Qi+ jasPpL5o9t6bdLSYF1cx0nltOCOVtxcB6U4OD6AUz7Yk/G7zjdBUKqIcHfsXy8djrE nsTUVRATfi49xUkZzpVtS0iKvngD0jtIxwpNEjAinGfTroFci+7D74hXjrfFeIajWw 4EBbS77m9T0NtaOb6Gt4z2UKu+RqhT4cycWdtyxRQD2LWTosBU7ySTO5T0JjrwYbt/ QXdhXeicEbgMFblh16ap0K1ksXzZgcRIhqmE1Q8kjhz/xcw9GDGs1sZGRIGyxquRzi 19O37w80bl24A== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id DDA29D49C96; Fri, 30 Jan 2026 10:06:56 +0000 (UTC) From: Rodrigo Alencar via B4 Relay Date: Fri, 30 Jan 2026 10:06:44 +0000 Subject: [PATCH v6 3/8] iio: test: add kunit test for fixed-point parsing Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260130-adf41513-iio-driver-v6-3-cf46239026bc@analog.com> References: <20260130-adf41513-iio-driver-v6-0-cf46239026bc@analog.com> In-Reply-To: <20260130-adf41513-iio-driver-v6-0-cf46239026bc@analog.com> To: linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jonathan Cameron , David Lechner , Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet , Rodrigo Alencar X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1769767615; l=18522; i=rodrigo.alencar@analog.com; s=default; h=from:subject:message-id; bh=z3lU/+mZx+x2JrYHd3QV4jsv0e9R3bBynHnvdvHhftg=; b=tFsKvHeXxV8u6O9c9GZK1v2UmeZD54PZAxrV/Gys6ENVaHZF5WMyxGjR3HKQ5QYeMJR5PvLbI nYoGc0WvN4GBwoGhsV97MQT95nit05uSQr4s+LMVMW9uLg3X1jkIjH2 X-Developer-Key: i=rodrigo.alencar@analog.com; a=ed25519; pk=ULeHbgU/OYh/PG/4anHDfLgldFItQHAhOktYRVLMFRo= X-Endpoint-Received: by B4 Relay for rodrigo.alencar@analog.com/default with auth_id=561 X-Original-From: Rodrigo Alencar Reply-To: rodrigo.alencar@analog.com From: Rodrigo Alencar Add kunit test cases that aims to verify expected behavior for iio_str_to_fixpoint() and iio_str_to_fixpoint64(). To run the test, create a .kunitconfig file with: CONFIG_KUNIT=3Dy CONFIG_IIO=3Dy CONFIG_IIO_FIXPOINT_PARSE_KUNIT_TEST=3Dy and run the command: ./tools/testing/kunit/kunit.py run --kunitconfig=3D.kunitconfig Signed-off-by: Rodrigo Alencar Reviewed-by: Andy Shevchenko --- MAINTAINERS | 1 + drivers/iio/test/Kconfig | 12 + drivers/iio/test/Makefile | 1 + drivers/iio/test/iio-test-fixpoint-parse.c | 467 +++++++++++++++++++++++++= ++++ 4 files changed, 481 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 1bf39f6d964e..a0d845117b52 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1640,6 +1640,7 @@ L: linux-iio@vger.kernel.org S: Supported W: https://ez.analog.com/linux-software-drivers F: Documentation/devicetree/bindings/iio/frequency/adi,adf41513.yaml +F: drivers/iio/test/iio-test-fixpoint-parse.c =20 ANALOG DEVICES INC ADF4377 DRIVER M: Antoniu Miclaus diff --git a/drivers/iio/test/Kconfig b/drivers/iio/test/Kconfig index 4fc17dd0dcd7..c60dff504bc2 100644 --- a/drivers/iio/test/Kconfig +++ b/drivers/iio/test/Kconfig @@ -29,6 +29,18 @@ config IIO_RESCALE_KUNIT_TEST =20 If unsure, say N. =20 +config IIO_FIXPOINT_PARSE_KUNIT_TEST + tristate "Test IIO fixpoint parsing functions" if !KUNIT_ALL_TESTS + depends on KUNIT + default KUNIT_ALL_TESTS + help + build unit tests for the IIO fixpoint parsing functions. + + For more information on KUnit and unit tests in general, please refer + to the KUnit documentation in Documentation/dev-tools/kunit/. + + If unsure, say N. + config IIO_FORMAT_KUNIT_TEST tristate "Test IIO formatting functions" if !KUNIT_ALL_TESTS depends on KUNIT diff --git a/drivers/iio/test/Makefile b/drivers/iio/test/Makefile index 0c846bc21acd..0c31aaeed755 100644 --- a/drivers/iio/test/Makefile +++ b/drivers/iio/test/Makefile @@ -5,6 +5,7 @@ =20 # Keep in alphabetical order obj-$(CONFIG_IIO_RESCALE_KUNIT_TEST) +=3D iio-test-rescale.o +obj-$(CONFIG_IIO_FIXPOINT_PARSE_KUNIT_TEST) +=3D iio-test-fixpoint-parse.o obj-$(CONFIG_IIO_FORMAT_KUNIT_TEST) +=3D iio-test-format.o obj-$(CONFIG_IIO_GTS_KUNIT_TEST) +=3D iio-test-gts.o obj-$(CONFIG_IIO_MULTIPLY_KUNIT_TEST) +=3D iio-test-multiply.o diff --git a/drivers/iio/test/iio-test-fixpoint-parse.c b/drivers/iio/test/= iio-test-fixpoint-parse.c new file mode 100644 index 000000000000..54ff585fed7d --- /dev/null +++ b/drivers/iio/test/iio-test-fixpoint-parse.c @@ -0,0 +1,467 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Unit tests for IIO fixpoint parsing functions + * + * Copyright 2026 Analog Devices Inc. + */ + +#include +#include +#include + +#define PRECISION(x) (int_pow(10, (x) - 1)) + +/* Test iio_str_to_fixpoint64() with valid positive integers */ +static void iio_test_str_to_fixpoint64_positive_integers(struct kunit *tes= t) +{ + s64 integer, fract; + int ret; + + /* Simple positive integer */ + ret =3D iio_str_to_fixpoint64("42", 0, &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 42); + KUNIT_EXPECT_EQ(test, fract, 0); + + /* Positive integer with leading + */ + ret =3D iio_str_to_fixpoint64("+10", 0, &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 10); + KUNIT_EXPECT_EQ(test, fract, 0); + + /* Large positive integer */ + ret =3D iio_str_to_fixpoint64("123456789", 0, &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 123456789); + KUNIT_EXPECT_EQ(test, fract, 0); +} + +/* Test iio_str_to_fixpoint64() with valid negative integers */ +static void iio_test_str_to_fixpoint64_negative_integers(struct kunit *tes= t) +{ + s64 integer, fract; + int ret; + + /* Simple negative integer */ + ret =3D iio_str_to_fixpoint64("-23", 0, &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, -23); + KUNIT_EXPECT_EQ(test, fract, 0); + + /* Large negative integer */ + ret =3D iio_str_to_fixpoint64("-987654321", 0, &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, -987654321); + KUNIT_EXPECT_EQ(test, fract, 0); +} + +/* Test iio_str_to_fixpoint64() with zero */ +static void iio_test_str_to_fixpoint64_zero(struct kunit *test) +{ + s64 integer, fract; + int ret; + + /* Zero */ + ret =3D iio_str_to_fixpoint64("0", 0, &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 0); + KUNIT_EXPECT_EQ(test, fract, 0); + + /* Zero with decimal */ + ret =3D iio_str_to_fixpoint64("0.0", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 0); + KUNIT_EXPECT_EQ(test, fract, 0); + + /* leading zeros */ + ret =3D iio_str_to_fixpoint64("00000000000000000000042", 0, &integer, + &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 42); + KUNIT_EXPECT_EQ(test, fract, 0); +} + +/* Test iio_str_to_fixpoint64() with valid decimal numbers */ +static void iio_test_str_to_fixpoint64_positive_decimals(struct kunit *tes= t) +{ + s64 integer, fract; + int ret; + + /* Positive decimal */ + ret =3D iio_str_to_fixpoint64("3.14", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 3); + KUNIT_EXPECT_EQ(test, fract, 140000); + + /* Decimal less than 1 */ + ret =3D iio_str_to_fixpoint64("0.5", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 0); + KUNIT_EXPECT_EQ(test, fract, 500000); + + /* Decimal with trailing zeros */ + ret =3D iio_str_to_fixpoint64("+123.000", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 123); + KUNIT_EXPECT_EQ(test, fract, 0); + + /* High precision decimal */ + ret =3D iio_str_to_fixpoint64("1.123456789", PRECISION(9), &integer, + &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 1); + KUNIT_EXPECT_EQ(test, fract, 123456789); + + /* Small decimal */ + ret =3D iio_str_to_fixpoint64("0.000000001", PRECISION(9), &integer, + &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 0); + KUNIT_EXPECT_EQ(test, fract, 1); +} + +/* Test iio_str_to_fixpoint64() with negative decimals */ +static void iio_test_str_to_fixpoint64_negative_decimals(struct kunit *tes= t) +{ + s64 integer, fract; + int ret; + + /* Negative decimal */ + ret =3D iio_str_to_fixpoint64("-2.71", PRECISION(5), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, -2); + KUNIT_EXPECT_EQ(test, fract, 71000); + + /* Negative decimal less than -1 */ + ret =3D iio_str_to_fixpoint64("-0.5", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 0); + KUNIT_EXPECT_EQ(test, fract, -500000); + + /* Negative with high precision */ + ret =3D iio_str_to_fixpoint64("-0.000000001", PRECISION(9), &integer, + &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 0); + KUNIT_EXPECT_EQ(test, fract, -1); +} + +/* Test iio_str_to_fixpoint64() with precision edge cases */ +static void iio_test_str_to_fixpoint64_precision_edge_cases(struct kunit *= test) +{ + s64 integer, fract; + int ret; + + /* More digits than precision - should truncate */ + ret =3D iio_str_to_fixpoint64("1.23456", PRECISION(3), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 1); + KUNIT_EXPECT_EQ(test, fract, 234); + + /* Fewer digits than precision - should pad with zeros */ + ret =3D iio_str_to_fixpoint64("1.23", PRECISION(7), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 1); + KUNIT_EXPECT_EQ(test, fract, 2300000); + + /* Single digit fractional with high precision */ + ret =3D iio_str_to_fixpoint64("5.1", PRECISION(9), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 5); + KUNIT_EXPECT_EQ(test, fract, 100000000); +} + +/* Test iio_str_to_fixpoint64() with newline characters */ +static void iio_test_str_to_fixpoint64_with_newline(struct kunit *test) +{ + s64 integer, fract; + int ret; + + /* Integer with newline */ + ret =3D iio_str_to_fixpoint64("-42\n", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, -42); + KUNIT_EXPECT_EQ(test, fract, 0); + + /* Decimal with newline */ + ret =3D iio_str_to_fixpoint64("3.141\n", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 3); + KUNIT_EXPECT_EQ(test, fract, 141000); +} + +/* Test iio_str_to_fixpoint64() with edge cases */ +static void iio_test_str_to_fixpoint64_edge_cases(struct kunit *test) +{ + s64 integer, fract; + int ret; + + /* Leading decimal point */ + ret =3D iio_str_to_fixpoint64(".5", PRECISION(4), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 0); + KUNIT_EXPECT_EQ(test, fract, 5000); + + /* Leading decimal with sign */ + ret =3D iio_str_to_fixpoint64("-.5", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 0); + KUNIT_EXPECT_EQ(test, fract, -500000); + + ret =3D iio_str_to_fixpoint64("+.5", PRECISION(3), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 0); + KUNIT_EXPECT_EQ(test, fract, 500); +} + +/* Test iio_str_to_fixpoint64() with invalid inputs */ +static void iio_test_str_to_fixpoint64_invalid(struct kunit *test) +{ + s64 integer, fract; + int ret; + + /* Empty string */ + ret =3D iio_str_to_fixpoint64("", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + /* Just a sign */ + ret =3D iio_str_to_fixpoint64("-", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + ret =3D iio_str_to_fixpoint64("+", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + /* Just a decimal point */ + ret =3D iio_str_to_fixpoint64(".", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + /* Non-numeric characters */ + ret =3D iio_str_to_fixpoint64("abc", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + ret =3D iio_str_to_fixpoint64("12a", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + ret =3D iio_str_to_fixpoint64("3.4x", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + ret =3D iio_str_to_fixpoint64("0xff", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + /* Multiple decimal points */ + ret =3D iio_str_to_fixpoint64("12.34.56", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + /* Trailing decimal without digits */ + ret =3D iio_str_to_fixpoint64("42.", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + /* Trailing spaces */ + ret =3D iio_str_to_fixpoint64("42 ", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + /* Too many digits in fractional part */ + ret =3D iio_str_to_fixpoint64("1.123456789012345678901", PRECISION(21), + &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); /* fails when checking precision */ +} + +/* Test iio_str_to_fixpoint() with valid inputs */ +static void iio_test_str_to_fixpoint_valid(struct kunit *test) +{ + int integer, fract; + int ret; + + /* Test with 6 decimal places */ + ret =3D iio_str_to_fixpoint("10.001234", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 10); + KUNIT_EXPECT_EQ(test, fract, 1234); + + ret =3D iio_str_to_fixpoint("-0.5", PRECISION(3), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 0); + KUNIT_EXPECT_EQ(test, fract, -500); + + /* Test with 9 decimal places */ + ret =3D iio_str_to_fixpoint("5.123456789", PRECISION(9), &integer, &fract= ); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 5); + KUNIT_EXPECT_EQ(test, fract, 123456789); + + ret =3D iio_str_to_fixpoint("1.0", PRECISION(9), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 1); + KUNIT_EXPECT_EQ(test, fract, 0); + + /* Test with 3 decimal places */ + ret =3D iio_str_to_fixpoint("-7.8", PRECISION(3), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, -7); + KUNIT_EXPECT_EQ(test, fract, 800); + + /* Truncation with 2 decimal places */ + ret =3D iio_str_to_fixpoint("3.1415", PRECISION(2), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 3); + KUNIT_EXPECT_EQ(test, fract, 14); + + /* Integer with 6 decimal places */ + ret =3D iio_str_to_fixpoint("42", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer, 42); + KUNIT_EXPECT_EQ(test, fract, 0); +} + +/* Test both functions with overflow cases */ +static void iio_test_str_to_fixpoint_overflow(struct kunit *test) +{ + s64 integer64, fract64; + int integer, fract; + int ret; + + /* integer overflow - value exceeds U64_MAX */ + ret =3D iio_str_to_fixpoint64("18446744073709551616", PRECISION(6), + &integer64, &fract64); + KUNIT_EXPECT_EQ(test, ret, -ERANGE); + + /* integer underflow - value less than S64_MIN */ + ret =3D iio_str_to_fixpoint64("-9223372036854775809", PRECISION(6), + &integer64, &fract64); + KUNIT_EXPECT_EQ(test, ret, -ERANGE); + + /* fractional underflow */ + ret =3D iio_str_to_fixpoint64("-0.9223372036854775810", PRECISION(19), + &integer64, &fract64); + KUNIT_EXPECT_EQ(test, ret, -ERANGE); + + /* Integer overflow - value exceeds U32_MAX */ + ret =3D iio_str_to_fixpoint("4294967296", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -ERANGE); + + /* Integer underflow - value less than INT_MIN */ + ret =3D iio_str_to_fixpoint("-2147483649", PRECISION(6), &integer, + &fract); + KUNIT_EXPECT_EQ(test, ret, -ERANGE); + + /* fractional overflow */ + ret =3D iio_str_to_fixpoint("0.4294967296", PRECISION(10), &integer, + &fract); + KUNIT_EXPECT_EQ(test, ret, -ERANGE); + + /* fractional underflow */ + ret =3D iio_str_to_fixpoint("-0.2147483649", PRECISION(10), &integer, + &fract); + KUNIT_EXPECT_EQ(test, ret, -ERANGE); +} + +/* Test iio_str_to_fixpoint() with invalid inputs */ +static void iio_test_str_to_fixpoint_invalid(struct kunit *test) +{ + int integer, fract; + int ret; + + /* Empty string */ + ret =3D iio_str_to_fixpoint("", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_NE(test, ret, 0); + + /* Non-numeric */ + ret =3D iio_str_to_fixpoint("abc", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_NE(test, ret, 0); + + /* Invalid characters */ + ret =3D iio_str_to_fixpoint("12.34x", PRECISION(6), &integer, &fract); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); +} + +/* Test both functions with boundary values */ +static void iio_test_fixpoint_boundary_values(struct kunit *test) +{ + s64 integer64, fract64; + int integer32, fract32; + int ret; + + /* S32_MAX */ + ret =3D iio_str_to_fixpoint("2147483647", PRECISION(6), &integer32, + &fract32); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer32, S32_MAX); + KUNIT_EXPECT_EQ(test, fract32, 0); + + /* U32_MAX */ + ret =3D iio_str_to_fixpoint("4294967295", PRECISION(6), &integer32, + &fract32); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, (u32)integer32, U32_MAX); + KUNIT_EXPECT_EQ(test, fract32, 0); + + /* S32_MIN */ + ret =3D iio_str_to_fixpoint("-2147483648", PRECISION(6), &integer32, + &fract32); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer32, S32_MIN); + KUNIT_EXPECT_EQ(test, fract32, 0); + + /* S32_MIN with fractional part */ + ret =3D iio_str_to_fixpoint("-2147483648.2147483647", PRECISION(10), + &integer32, &fract32); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer32, S32_MIN); + KUNIT_EXPECT_EQ(test, fract32, S32_MAX); + + /* S64_MAX */ + ret =3D iio_str_to_fixpoint64("9223372036854775807", PRECISION(6), + &integer64, &fract64); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer64, S64_MAX); + KUNIT_EXPECT_EQ(test, fract64, 0); + + /* U64_MAX */ + ret =3D iio_str_to_fixpoint64("18446744073709551615", PRECISION(6), + &integer64, &fract64); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, (u64)integer64, U64_MAX); + KUNIT_EXPECT_EQ(test, fract64, 0); + + /* S64_MIN */ + ret =3D iio_str_to_fixpoint64("-9223372036854775808", PRECISION(6), + &integer64, &fract64); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer64, S64_MIN); + KUNIT_EXPECT_EQ(test, fract64, 0); + + /* S64_MIN with fractional part */ + ret =3D iio_str_to_fixpoint64("-9223372036854775808.9223372036854775807", + PRECISION(19), &integer64, &fract64); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, integer64, S64_MIN); + KUNIT_EXPECT_EQ(test, fract64, S64_MAX); +} + +static struct kunit_case iio_fixpoint_parse_test_cases[] =3D { + KUNIT_CASE(iio_test_str_to_fixpoint64_positive_integers), + KUNIT_CASE(iio_test_str_to_fixpoint64_negative_integers), + KUNIT_CASE(iio_test_str_to_fixpoint64_zero), + KUNIT_CASE(iio_test_str_to_fixpoint64_positive_decimals), + KUNIT_CASE(iio_test_str_to_fixpoint64_negative_decimals), + KUNIT_CASE(iio_test_str_to_fixpoint64_precision_edge_cases), + KUNIT_CASE(iio_test_str_to_fixpoint64_with_newline), + KUNIT_CASE(iio_test_str_to_fixpoint64_edge_cases), + KUNIT_CASE(iio_test_str_to_fixpoint64_invalid), + KUNIT_CASE(iio_test_str_to_fixpoint_valid), + KUNIT_CASE(iio_test_str_to_fixpoint_overflow), + KUNIT_CASE(iio_test_str_to_fixpoint_invalid), + KUNIT_CASE(iio_test_fixpoint_boundary_values), + { } +}; + +static struct kunit_suite iio_fixpoint_parse_test_suite =3D { + .name =3D "iio-fixpoint-parse", + .test_cases =3D iio_fixpoint_parse_test_cases, +}; + +kunit_test_suite(iio_fixpoint_parse_test_suite); + +MODULE_AUTHOR("Rodrigo Alencar "); +MODULE_AUTHOR("IIO Kunit Test"); +MODULE_DESCRIPTION("Test IIO fixpoint parsing functions"); +MODULE_LICENSE("GPL"); --=20 2.43.0