Add two tests and improve SBIUnit
cover Add two tests and improve SBIUnit
This patch series intriduces two more tests for OpenSBI:
- spinlocks test (for functions from riscv_locks.h)
- atomics test (for functions from riscv_atomic.h)
Also, it adds a functionality of defining the init function for the test suite. It allows us to initialize global variables used in the multiple test cases (see the atomic test in this patch series).
Ivan Orlov (3):
lib: tests: Add test suite init function
lib: tests: Add test for atomic_t
lib: tests: Add test for spinlocks
include/sbi/sbi_unit_test.h | 2 + lib/sbi/tests/objects.mk | 6 ++ lib/sbi/tests/riscv_atomic_test.c | 143 ++++++++++++++++++++++++++++++ lib/sbi/tests/riscv_locks_test.c | 41 +++++++++ lib/sbi/tests/sbi_unit_test.c | 3 + 5 files changed, 195 insertions(+) create mode 100644 lib/sbi/tests/riscv_atomic_test.c create mode 100644 lib/sbi/tests/riscv_locks_test.c
Signature · 1 line
2.34.1
PATCH 1/3 lib: tests: Add test suite init function
Allow to define an init function for the test suite. It could help us to initialize global variable once, and use them in multiple test cases after the initialization.
For instance, if multiple test cases use the same atomic_t var, it could be helpful to call ATOMIC_INIT once during the suite initialization.
--- include/sbi/sbi_unit_test.h | 2 ++ lib/sbi/tests/sbi_unit_test.c | 3 +++ 2 files changed, 5 insertions(+)
include/sbi/sbi_unit_test.h +2 -0
@@ -19,6 +19,7 @@ struct sbiunit_test_case {struct sbiunit_test_suite {const char *name; +void (*init)(void );struct sbiunit_test_case *cases; };
@@ -34,6 +35,7 @@ struct sbiunit_test_suite {#define SBIUNIT_TEST_SUITE (suite_name, cases_arr) \ struct sbiunit_test_suite suite_name = { \ .name = #suite_name, \ + .init = NULL, \ .cases = cases_arr \ }
lib/sbi/tests/sbi_unit_test.c +3 -0
@@ -17,6 +17,9 @@ static void run_test_suite(struct sbiunit_test_suite *suite)sbi_printf ("## Running test suite: %s\n" , suite->name); +if (suite->init) + suite->init (); + s_case = suite->cases;while (s_case->test_func) { s_case->test_func (s_case);
Signature · 1 line
2.34.1
Anup Patel
AppliedPATCH 1/3 lib: tests: Add test suite init function
Quoted 10 lines · On Tue, Apr 23, 2024 at 9:23?PM Ivan Orlov <[email protected]> wrote:
Allow to define an init function for the test suite. It could help us to initialize global variable once, and use them in multiple test cases after the initialization.
For instance, if multiple test cases use the same
atomic_tvar, it could be helpful to callATOMIC_INITonce during the suite initialization.Signed-off-by Ivan Orlov <[email protected]>
LGTM.
Applied this patch to the riscv/opensbi repo.
Thanks,
Anup
Quoted 42 lines
--- include/sbi/sbi_unit_test.h | 2 ++ lib/sbi/tests/sbi_unit_test.c | 3 +++ 2 files changed, 5 insertions(+)include/sbi/sbi_unit_test.h +2
-0@@ -19,6 +19,7 @@ struct sbiunit_test_case {struct sbiunit_test_suite {const char *name; +void (*init)(void );struct sbiunit_test_case *cases; };@@ -34,6 +35,7 @@ struct sbiunit_test_suite {#define SBIUNIT_TEST_SUITE (suite_name, cases_arr) \ struct sbiunit_test_suite suite_name = { \ .name = #suite_name, \ + .init = NULL, \ .cases = cases_arr \ }lib/sbi/tests/sbi_unit_test.c +3
-1@@ -17,6 +17,9 @@ static void run_test_suite(struct sbiunit_test_suite *suite)sbi_printf ("## Running test suite: %s\n" , suite->name); +if (suite->init) + suite->init (); + s_case = suite->cases;while (s_case->test_func) { s_case->test_func (s_case); --2.34.1
PATCH 2/3 lib: tests: Add test for atomic_t
In reply to Ivan OrlovImplement the test which covers some of the functions from the riscv_atomic.h header file. The test contains 9 test cases:
1) atomic read/write test
2) add/return test
3) sub/return test
4) cmpxchg test
5) atomic_xchg test
6) atomic_raw_set_bit test
7) atomic_raw_clear_bit test
8) atomic_set_bit test
9) atomic_clear_bit test
Some of the test cases operate on the test_atomic variable. It gets initialized in the suite init function.
--- lib/sbi/tests/objects.mk | 3 + lib/sbi/tests/riscv_atomic_test.c | 143 ++++++++++++++++++++++++++++++ 2 files changed, 146 insertions(+) create mode 100644 lib/sbi/tests/riscv_atomic_test.c
lib/sbi/tests/objects.mk +3 -0
@@ -6,3 +6,6 @@ libsbi-objs-$(CONFIG_SBIUNIT) += tests/sbi_bitmap_test.o carray-sbi_unit_tests-$(CONFIG_SBIUNIT) += console_test_suite libsbi-objs-$(CONFIG_SBIUNIT) += tests/sbi_console_test.o + +carray-sbi_unit_tests-$(CONFIG_SBIUNIT) += atomic_test_suite +libsbi-objs-$(CONFIG_SBIUNIT) += tests/riscv_atomic_test.o
lib/sbi/tests/riscv_atomic_test.c new file +143 -0
143 lines not on this page · raw message
Signature · 1 line
2.34.1
Anup Patel
AppliedPATCH 2/3 lib: tests: Add test for atomic_t
Quoted 14 lines · On Tue, Apr 23, 2024 at 9:23?PM Ivan Orlov <[email protected]> wrote:
Implement the test which covers some of the functions from the
riscv_atomic.hheader file. The test contains 9 test cases:1) atomic read/write test
2) add/return test
3) sub/return test
4) cmpxchg test
5)atomic_xchgtest
6)atomic_raw_set_bittest
7)atomic_raw_clear_bittest
8)atomic_set_bittest
9)atomic_clear_bittest
Quoted 4 lines
Some of the test cases operate on the
test_atomicvariable. It gets initialized in the suite init function.Signed-off-by Ivan Orlov <[email protected]>
LGTM.
Applied this patch to the riscv/opensbi repo.
Thanks,
Anup
Quoted 169 lines
--- lib/sbi/tests/objects.mk | 3 + lib/sbi/tests/riscv_atomic_test.c | 143 ++++++++++++++++++++++++++++++ 2 files changed, 146 insertions(+) create mode 100644 lib/sbi/tests/riscv_atomic_test.clib/sbi/tests/objects.mk +3
-0@@ -6,3 +6,6 @@ libsbi-objs-$(CONFIG_SBIUNIT) += tests/sbi_bitmap_test.o carray-sbi_unit_tests-$(CONFIG_SBIUNIT) += console_test_suite libsbi-objs-$(CONFIG_SBIUNIT) += tests/sbi_console_test.o + +carray-sbi_unit_tests-$(CONFIG_SBIUNIT) += atomic_test_suite +libsbi-objs-$(CONFIG_SBIUNIT) += tests/riscv_atomic_test.olib/sbi/tests/riscv_atomic_test.c new file +143
-1@@ -0,0 +1,143 @@ +#include <sbi/sbi_unit_test.h> +#include <sbi/riscv_atomic.h> +#include <sbi/sbi_bitops.h> + +#define ATOMIC_TEST_VAL1 239l +#define ATOMIC_TEST_VAL2 30l +#define ATOMIC_TEST_VAL3 2024l + +#define ATOMIC_TEST_BIT_NUM 3 + +#define ATOMIC_TEST_RAW_BIT_CELL 1 +#define ATOMIC_TEST_RAW_BIT_NUM 15 + +static atomic_t test_atomic; + +static void atomic_test_suite_init (void ) +{ +ATOMIC_INIT (&test_atomic,0 ); +} + +static void atomic_rw_test (struct sbiunit_test_case *test) +{ +/* We should read the same value as we've written */ +atomic_write (&test_atomic,ATOMIC_TEST_VAL1 ); +SBIUNIT_EXPECT_EQ (test,atomic_read (&test_atomic),ATOMIC_TEST_VAL1 ); +/* Negative value should also work */ +atomic_write (&test_atomic, -ATOMIC_TEST_VAL1 ); +SBIUNIT_EXPECT_EQ (test,atomic_read (&test_atomic), -ATOMIC_TEST_VAL1 ); +} + +static void add_return_test (struct sbiunit_test_case *test) +{ +atomic_write (&test_atomic,ATOMIC_TEST_VAL1 ); +SBIUNIT_EXPECT_EQ (test,atomic_add_return (&test_atomic,ATOMIC_TEST_VAL2 ), +ATOMIC_TEST_VAL1 +ATOMIC_TEST_VAL2 ); +/* The atomic value should be updated as well */ +SBIUNIT_EXPECT_EQ (test,atomic_read (&test_atomic),ATOMIC_TEST_VAL1 +ATOMIC_TEST_VAL2 ); +} + +static void sub_return_test (struct sbiunit_test_case *test) +{ +atomic_write (&test_atomic,ATOMIC_TEST_VAL1 ); +SBIUNIT_EXPECT_EQ (test,atomic_sub_return (&test_atomic,ATOMIC_TEST_VAL2 ), +ATOMIC_TEST_VAL1 -ATOMIC_TEST_VAL2 ); +SBIUNIT_EXPECT_EQ (test,atomic_read (&test_atomic),ATOMIC_TEST_VAL1 -ATOMIC_TEST_VAL2 ); +} + +static void cmpxchg_test (struct sbiunit_test_case *test) +{ +atomic_write (&test_atomic,ATOMIC_TEST_VAL1 ); +/* if current value != expected, it stays the same */ +SBIUNIT_EXPECT_EQ (test,atomic_cmpxchg (&test_atomic,ATOMIC_TEST_VAL2 ,ATOMIC_TEST_VAL3 ), +ATOMIC_TEST_VAL1 ); +SBIUNIT_EXPECT_EQ (test,atomic_read (&test_atomic),ATOMIC_TEST_VAL1 ); +/* if current value == expected, it gets updated */ +SBIUNIT_EXPECT_EQ (test,atomic_cmpxchg (&test_atomic,ATOMIC_TEST_VAL1 ,ATOMIC_TEST_VAL2 ), +ATOMIC_TEST_VAL1 ); +SBIUNIT_EXPECT_EQ (test,atomic_read (&test_atomic),ATOMIC_TEST_VAL2 ); +} + +static void atomic_xchg_test (struct sbiunit_test_case *test) +{ +atomic_write (&test_atomic,ATOMIC_TEST_VAL1 ); +SBIUNIT_EXPECT_EQ (test,atomic_xchg (&test_atomic,ATOMIC_TEST_VAL2 ),ATOMIC_TEST_VAL1 ); +SBIUNIT_EXPECT_EQ (test,atomic_read (&test_atomic),ATOMIC_TEST_VAL2 ); +} + +static void atomic_raw_set_bit_test (struct sbiunit_test_case *test) +{ +unsigned long data[] = {0 ,0 ,0 }; +/* the bitpos points to the bit of one of the elements of the `data` array */ +size_t bitpos =ATOMIC_TEST_RAW_BIT_CELL *BITS_PER_LONG +ATOMIC_TEST_RAW_BIT_NUM ; + +/* check if the bit we set actually gets set */ +SBIUNIT_EXPECT_EQ (test,atomic_raw_set_bit (bitpos, data),0 ); +SBIUNIT_EXPECT_EQ (test, data[ATOMIC_TEST_RAW_BIT_CELL ],1 <<ATOMIC_TEST_RAW_BIT_NUM ); + +/* Other elements of the `data` array should stay untouched */ +SBIUNIT_EXPECT_EQ (test, data[0 ],0 ); +SBIUNIT_EXPECT_EQ (test, data[2 ],0 ); + +/* check that if we set the bit twice it stays set */ +SBIUNIT_EXPECT_EQ (test,atomic_raw_set_bit (bitpos, data),1 ); +SBIUNIT_EXPECT_EQ (test, data[ATOMIC_TEST_RAW_BIT_CELL ],1 <<ATOMIC_TEST_RAW_BIT_NUM ); +} + +static void atomic_raw_clear_bit_test (struct sbiunit_test_case *test) +{ +unsigned long data[] = {~1UL ,1 <<ATOMIC_TEST_RAW_BIT_NUM , ~1UL }; +/* the bitpos points to the bit of one of the elements of the `data` array */ +size_t bitpos =ATOMIC_TEST_RAW_BIT_CELL *BITS_PER_LONG +ATOMIC_TEST_RAW_BIT_NUM ; + +/* check if the bit we clear actually gets cleared */ +SBIUNIT_EXPECT_EQ (test,atomic_raw_clear_bit (bitpos, data),1 ); +SBIUNIT_EXPECT_EQ (test, data[ATOMIC_TEST_RAW_BIT_CELL ],0 ); + +/* Other elements of the `data` array should stay untouched */ +SBIUNIT_EXPECT_EQ (test, data[0 ], ~1UL ); +SBIUNIT_EXPECT_EQ (test, data[2 ], ~1UL ); + +/* check that if we clear the bit twice it stays cleared */ +SBIUNIT_EXPECT_EQ (test,atomic_raw_clear_bit (bitpos, data),0 ); +SBIUNIT_EXPECT_EQ (test, data[ATOMIC_TEST_RAW_BIT_CELL ],0 ); +} + +static void atomic_set_bit_test (struct sbiunit_test_case *test) +{ +atomic_write (&test_atomic,0 ); +SBIUNIT_EXPECT_EQ (test,atomic_set_bit (ATOMIC_TEST_BIT_NUM , &test_atomic),0 ); +SBIUNIT_EXPECT_EQ (test,atomic_read (&test_atomic),1 <<ATOMIC_TEST_BIT_NUM ); +/* If we set the bit twice, it stays 1 */ +SBIUNIT_EXPECT_EQ (test,atomic_set_bit (ATOMIC_TEST_BIT_NUM , &test_atomic),1 ); +SBIUNIT_EXPECT_EQ (test,atomic_read (&test_atomic),1 <<ATOMIC_TEST_BIT_NUM ); +} + +static void atomic_clear_bit_test (struct sbiunit_test_case *test) +{ +atomic_write (&test_atomic,1 <<ATOMIC_TEST_BIT_NUM ); +SBIUNIT_EXPECT_EQ (test,atomic_clear_bit (ATOMIC_TEST_BIT_NUM , &test_atomic),1 ); +SBIUNIT_EXPECT_EQ (test,atomic_read (&test_atomic),0 ); +/* if we clear the bit twice, it stays 0 */ +SBIUNIT_EXPECT_EQ (test,atomic_clear_bit (ATOMIC_TEST_BIT_NUM , &test_atomic),0 ); +SBIUNIT_EXPECT_EQ (test,atomic_read (&test_atomic),0 ); +} + +static struct sbiunit_test_case atomic_test_cases[] = { +SBIUNIT_TEST_CASE (atomic_rw_test), +SBIUNIT_TEST_CASE (add_return_test), +SBIUNIT_TEST_CASE (sub_return_test), +SBIUNIT_TEST_CASE (cmpxchg_test), +SBIUNIT_TEST_CASE (atomic_xchg_test), +SBIUNIT_TEST_CASE (atomic_raw_set_bit_test), +SBIUNIT_TEST_CASE (atomic_raw_clear_bit_test), +SBIUNIT_TEST_CASE (atomic_set_bit_test), +SBIUNIT_TEST_CASE (atomic_clear_bit_test), +SBIUNIT_END_CASE , +}; + +const struct sbiunit_test_suite atomic_test_suite = { + .name ="atomic_test_suite" , + .cases = atomic_test_cases, + .init = atomic_test_suite_init +}; --2.34.1
PATCH 3/3 lib: tests: Add test for spinlocks
In reply to Ivan OrlovImplement the test which covers some of the functions from the riscv_locks.h file. This test consists of 3 test cases:
1) For lock/unlock functions
2) Unsuccessful trylock (the lock was previously taken)
3) Successful trylock (the lock is free and can be taken)
--- lib/sbi/tests/objects.mk | 3 +++ lib/sbi/tests/riscv_locks_test.c | 41 ++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+) create mode 100644 lib/sbi/tests/riscv_locks_test.c
lib/sbi/tests/objects.mk +3 -0
@@ -9,3 +9,6 @@ libsbi-objs-$(CONFIG_SBIUNIT) += tests/sbi_console_test.o carray-sbi_unit_tests-$(CONFIG_SBIUNIT) += atomic_test_suite libsbi-objs-$(CONFIG_SBIUNIT) += tests/riscv_atomic_test.o + +carray-sbi_unit_tests-$(CONFIG_SBIUNIT) += locks_test_suite +libsbi-objs-$(CONFIG_SBIUNIT) += tests/riscv_locks_test.o
lib/sbi/tests/riscv_locks_test.c new file +41 -0
41 lines not on this page · raw message
Signature · 1 line
2.34.1
Anup Patel
AppliedPATCH 3/3 lib: tests: Add test for spinlocks
Quoted 9 lines · On Tue, Apr 23, 2024 at 9:23?PM Ivan Orlov <[email protected]> wrote:
Implement the test which covers some of the functions from the
riscv_locks.hfile. This test consists of 3 test cases:1) For lock/unlock functions
2) Unsuccessful trylock (the lock was previously taken)
3) Successful trylock (the lock is free and can be taken)Signed-off-by Ivan Orlov <[email protected]>
LGTM.
Applied this patch to the riscv/opensbi repo.
Thanks,
Anup
Quoted 67 lines
--- lib/sbi/tests/objects.mk | 3 +++ lib/sbi/tests/riscv_locks_test.c | 41 ++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+) create mode 100644 lib/sbi/tests/riscv_locks_test.clib/sbi/tests/objects.mk +3
-0@@ -9,3 +9,6 @@ libsbi-objs-$(CONFIG_SBIUNIT) += tests/sbi_console_test.o carray-sbi_unit_tests-$(CONFIG_SBIUNIT) += atomic_test_suite libsbi-objs-$(CONFIG_SBIUNIT) += tests/riscv_atomic_test.o + +carray-sbi_unit_tests-$(CONFIG_SBIUNIT) += locks_test_suite +libsbi-objs-$(CONFIG_SBIUNIT) += tests/riscv_locks_test.olib/sbi/tests/riscv_locks_test.c new file +41
-1@@ -0,0 +1,41 @@ +#include <sbi/sbi_unit_test.h> +#include <sbi/riscv_locks.h> + +static spinlock_t test_lock =SPIN_LOCK_INITIALIZER ; + +static void spin_lock_test (struct sbiunit_test_case *test) +{ +/* We don't want to accidentally get locked */ +SBIUNIT_ASSERT (test, !spin_lock_check (&test_lock)); + +spin_lock (&test_lock); +SBIUNIT_EXPECT (test,spin_lock_check (&test_lock)); +spin_unlock (&test_lock); + +SBIUNIT_ASSERT (test, !spin_lock_check (&test_lock)); +} + +static void spin_trylock_fail (struct sbiunit_test_case *test) +{ +/* We don't want to accidentally get locked */ +SBIUNIT_ASSERT (test, !spin_lock_check (&test_lock)); + +spin_lock (&test_lock); +SBIUNIT_EXPECT (test, !spin_trylock (&test_lock)); +spin_unlock (&test_lock); +} + +static void spin_trylock_success (struct sbiunit_test_case *test) +{ +SBIUNIT_EXPECT (test,spin_trylock (&test_lock)); +spin_unlock (&test_lock); +} + +static struct sbiunit_test_case locks_test_cases[] = { +SBIUNIT_TEST_CASE (spin_lock_test), +SBIUNIT_TEST_CASE (spin_trylock_fail), +SBIUNIT_TEST_CASE (spin_trylock_success), +SBIUNIT_END_CASE , +}; + +SBIUNIT_TEST_SUITE (locks_test_suite, locks_test_cases); --2.34.1