Skip to content

Commit

Permalink
tests/unittests/core-atomic: Use stdatomic.h instead of custom atomic.h
Browse files Browse the repository at this point in the history
  • Loading branch information
Joakim Nohlgård committed Feb 8, 2017
1 parent c1b84f0 commit cb34eed
Showing 1 changed file with 100 additions and 137 deletions.
237 changes: 100 additions & 137 deletions tests/unittests/tests-core/tests-core-atomic.c
View file
Expand Up @@ -8,212 +8,175 @@
*/

#include <limits.h>
#include <stdint.h>
#include <stdatomic.h>

#include "embUnit.h"

#include "atomic.h"

#include "tests-core.h"

/* Test atomic_set_to_one on a variable set to 0 */
static void test_atomic_set_to_one_zero(void)
{
atomic_int_t res = ATOMIC_INIT(0);

TEST_ASSERT_EQUAL_INT(1, atomic_set_to_one(&res));
TEST_ASSERT_EQUAL_INT(1, ATOMIC_VALUE(res));
}

/* Test atomic_set_to_one on a variable set to 1 */
static void test_atomic_set_to_one_one(void)
{
atomic_int_t res = ATOMIC_INIT(1);

TEST_ASSERT_EQUAL_INT(0, atomic_set_to_one(&res));
TEST_ASSERT_EQUAL_INT(1, ATOMIC_VALUE(res));
}

/* Test atomic_set_to_one twice */
static void test_atomic_set_to_one_twice(void)
{
atomic_int_t res = ATOMIC_INIT(0);

TEST_ASSERT_EQUAL_INT(1, atomic_set_to_one(&res));
TEST_ASSERT_EQUAL_INT(1, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(0, atomic_set_to_one(&res));
TEST_ASSERT_EQUAL_INT(1, ATOMIC_VALUE(res));
}

/* Test atomic_set_to_zero on a variable set to 0 */
static void test_atomic_set_to_zero_zero(void)
/* Test atomic_flag back and forth */
static void test_atomic_flag(void)
{
atomic_int_t res = ATOMIC_INIT(0);
atomic_flag flag = ATOMIC_FLAG_INIT;

TEST_ASSERT_EQUAL_INT(0, atomic_set_to_zero(&res));
TEST_ASSERT_EQUAL_INT(0, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(0, atomic_flag_test_and_set(&flag));
TEST_ASSERT_EQUAL_INT(1, atomic_flag_test_and_set(&flag));
atomic_flag_clear(&flag);
TEST_ASSERT_EQUAL_INT(0, atomic_flag_test_and_set(&flag));
}

/* Test atomic_set_to_zero on a variable set to 1 */
static void test_atomic_set_to_zero_one(void)
{
atomic_int_t res = ATOMIC_INIT(1);

TEST_ASSERT_EQUAL_INT(1, atomic_set_to_zero(&res));
TEST_ASSERT_EQUAL_INT(0, ATOMIC_VALUE(res));
}

/* Test atomic_set_to_zero twice */
static void test_atomic_set_to_zero_twice(void)
{
atomic_int_t res = ATOMIC_INIT(1);

TEST_ASSERT_EQUAL_INT(1, atomic_set_to_zero(&res));
TEST_ASSERT_EQUAL_INT(0, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(0, atomic_set_to_zero(&res));
TEST_ASSERT_EQUAL_INT(0, ATOMIC_VALUE(res));
}

/* Test atomic_inc */
/* Test atomic_fetch_add */
static void test_atomic_inc_positive(void)
{
atomic_int_t res = ATOMIC_INIT(0);
atomic_int res = ATOMIC_VAR_INIT(0);

TEST_ASSERT_EQUAL_INT(0, atomic_inc(&res));
TEST_ASSERT_EQUAL_INT(1, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(1, atomic_inc(&res));
TEST_ASSERT_EQUAL_INT(2, ATOMIC_VALUE(res));
ATOMIC_VALUE(res) = 0;
TEST_ASSERT_EQUAL_INT(0, atomic_fetch_add(&res, 1));
TEST_ASSERT_EQUAL_INT(1, atomic_load(&res));
TEST_ASSERT_EQUAL_INT(1, atomic_fetch_add(&res, 1));
TEST_ASSERT_EQUAL_INT(2, atomic_load(&res));
atomic_store(&res, 0);
for (int i = 0; i < 512; ++i) {
TEST_ASSERT_EQUAL_INT(i, atomic_inc(&res));
TEST_ASSERT_EQUAL_INT(i + 1, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(i, atomic_fetch_add(&res, 1));
TEST_ASSERT_EQUAL_INT(i + 1, atomic_load(&res));
}
}

static void test_atomic_inc_negative(void)
{
atomic_int_t res = ATOMIC_INIT(-99);
atomic_int res = ATOMIC_VAR_INIT(-99);

for (int i = -99; i < 123; ++i) {
TEST_ASSERT_EQUAL_INT(i, atomic_inc(&res));
TEST_ASSERT_EQUAL_INT(i + 1, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(i, atomic_fetch_add(&res, 1));
TEST_ASSERT_EQUAL_INT(i + 1, atomic_load(&res));
}
}

static void test_atomic_inc_rollover(void)
{
atomic_int_t res = ATOMIC_INIT(INT_MAX - 30);
atomic_int res = ATOMIC_VAR_INIT(INT_MAX - 30);

for (int i = 0; i < 30; ++i) {
TEST_ASSERT_EQUAL_INT(INT_MAX - 30 + i, atomic_inc(&res));
TEST_ASSERT_EQUAL_INT(INT_MAX - 30 + i + 1, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(INT_MAX - 30 + i, atomic_fetch_add(&res, 1));
TEST_ASSERT_EQUAL_INT(INT_MAX - 30 + i + 1, atomic_load(&res));
}
TEST_ASSERT_EQUAL_INT(INT_MAX, atomic_inc(&res));
TEST_ASSERT_EQUAL_INT(INT_MIN, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(INT_MIN, atomic_inc(&res));
TEST_ASSERT_EQUAL_INT(INT_MIN + 1, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(INT_MIN + 1, atomic_inc(&res));
TEST_ASSERT_EQUAL_INT(INT_MIN + 2, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(INT_MAX, atomic_fetch_add(&res, 1));
TEST_ASSERT_EQUAL_INT(INT_MIN, atomic_load(&res));
TEST_ASSERT_EQUAL_INT(INT_MIN, atomic_fetch_add(&res, 1));
TEST_ASSERT_EQUAL_INT(INT_MIN + 1, atomic_load(&res));
TEST_ASSERT_EQUAL_INT(INT_MIN + 1, atomic_fetch_add(&res, 1));
TEST_ASSERT_EQUAL_INT(INT_MIN + 2, atomic_load(&res));
}

/* Test atomic_dec */
/* Test atomic_fetch_sub */
static void test_atomic_dec_negative(void)
{
atomic_int_t res = ATOMIC_INIT(0);
atomic_int res = ATOMIC_VAR_INIT(0);

TEST_ASSERT_EQUAL_INT(0, atomic_dec(&res));
TEST_ASSERT_EQUAL_INT(-1, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(-1, atomic_dec(&res));
TEST_ASSERT_EQUAL_INT(-2, ATOMIC_VALUE(res));
ATOMIC_VALUE(res) = 0;
TEST_ASSERT_EQUAL_INT(0, atomic_fetch_sub(&res, 1));
TEST_ASSERT_EQUAL_INT(-1, atomic_load(&res));
TEST_ASSERT_EQUAL_INT(-1, atomic_fetch_sub(&res, 1));
TEST_ASSERT_EQUAL_INT(-2, atomic_load(&res));
atomic_store(&res, 0);
for (int i = 0; i < 512; ++i) {
TEST_ASSERT_EQUAL_INT(-i, atomic_dec(&res));
TEST_ASSERT_EQUAL_INT(-i - 1, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(-i, atomic_fetch_sub(&res, 1));
TEST_ASSERT_EQUAL_INT(-i - 1, atomic_load(&res));
}
}

static void test_atomic_dec_positive(void)
{
atomic_int_t res = ATOMIC_INIT(99);
atomic_int res = ATOMIC_VAR_INIT(99);

for (int i = 99; i < -123; --i) {
TEST_ASSERT_EQUAL_INT(i, atomic_dec(&res));
TEST_ASSERT_EQUAL_INT(i - 1, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(i, atomic_fetch_sub(&res, 1));
TEST_ASSERT_EQUAL_INT(i - 1, atomic_load(&res));
}
}

static void test_atomic_dec_rollover(void)
{
atomic_int_t res = ATOMIC_INIT(INT_MIN + 30);
atomic_int res = ATOMIC_VAR_INIT(INT_MIN + 30);

for (int i = 0; i < 30; ++i) {
TEST_ASSERT_EQUAL_INT(INT_MIN + 30 - i, atomic_dec(&res));
TEST_ASSERT_EQUAL_INT(INT_MIN + 30 - i - 1, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(INT_MIN + 30 - i, atomic_fetch_sub(&res, 1));
TEST_ASSERT_EQUAL_INT(INT_MIN + 30 - i - 1, atomic_load(&res));
}
TEST_ASSERT_EQUAL_INT(INT_MIN, atomic_dec(&res));
TEST_ASSERT_EQUAL_INT(INT_MAX, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(INT_MAX, atomic_dec(&res));
TEST_ASSERT_EQUAL_INT(INT_MAX - 1, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(INT_MAX - 1, atomic_dec(&res));
TEST_ASSERT_EQUAL_INT(INT_MAX - 2, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(INT_MIN, atomic_fetch_sub(&res, 1));
TEST_ASSERT_EQUAL_INT(INT_MAX, atomic_load(&res));
TEST_ASSERT_EQUAL_INT(INT_MAX, atomic_fetch_sub(&res, 1));
TEST_ASSERT_EQUAL_INT(INT_MAX - 1, atomic_load(&res));
TEST_ASSERT_EQUAL_INT(INT_MAX - 1, atomic_fetch_sub(&res, 1));
TEST_ASSERT_EQUAL_INT(INT_MAX - 2, atomic_load(&res));
}

/* Test atomic_cas with a correct old value */
static void test_atomic_cas_same(void)
{
atomic_int_t res = ATOMIC_INIT(0);

TEST_ASSERT_EQUAL_INT(1, atomic_cas(&res, 0, 12345));
TEST_ASSERT_EQUAL_INT(12345, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(1, atomic_cas(&res, 12345, -9876));
TEST_ASSERT_EQUAL_INT(-9876, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(1, atomic_cas(&res, -9876, -9876));
TEST_ASSERT_EQUAL_INT(-9876, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(1, atomic_cas(&res, -9876, 0));
TEST_ASSERT_EQUAL_INT(0, ATOMIC_VALUE(res));
atomic_int res = ATOMIC_VAR_INIT(0);
int expected;

expected = 0;
TEST_ASSERT_EQUAL_INT(1, atomic_compare_exchange_weak(&res, &expected, 12345));
TEST_ASSERT_EQUAL_INT(12345, atomic_load(&res));
TEST_ASSERT_EQUAL_INT(0, expected);
expected = 12345;
TEST_ASSERT_EQUAL_INT(1, atomic_compare_exchange_weak(&res, &expected, -9876));
TEST_ASSERT_EQUAL_INT(-9876, atomic_load(&res));
TEST_ASSERT_EQUAL_INT(12345, expected);
expected = -9876;
TEST_ASSERT_EQUAL_INT(1, atomic_compare_exchange_weak(&res, &expected, -9876));
TEST_ASSERT_EQUAL_INT(-9876, atomic_load(&res));
TEST_ASSERT_EQUAL_INT(-9876, expected);
expected = -9876;
TEST_ASSERT_EQUAL_INT(1, atomic_compare_exchange_weak(&res, &expected, 0));
TEST_ASSERT_EQUAL_INT(0, atomic_load(&res));
}

/* Test atomic_cas with a non-matching old value */
static void test_atomic_cas_diff(void)
{
atomic_int_t res = ATOMIC_INIT(32767);

TEST_ASSERT_EQUAL_INT(0, atomic_cas(&res, 22222, 12345));
TEST_ASSERT_EQUAL_INT(32767, ATOMIC_VALUE(res));
ATOMIC_VALUE(res) = -12345;
TEST_ASSERT_EQUAL_INT(0, atomic_cas(&res, 12345, 12345));
TEST_ASSERT_EQUAL_INT(-12345, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(0, atomic_cas(&res, 12345, 12345));
TEST_ASSERT_EQUAL_INT(-12345, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(0, atomic_cas(&res, 12345, -12345));
TEST_ASSERT_EQUAL_INT(-12345, ATOMIC_VALUE(res));
atomic_int res = ATOMIC_VAR_INIT(32767);
int expected;

expected = 22222;
TEST_ASSERT_EQUAL_INT(0, atomic_compare_exchange_weak(&res, &expected, 12345));
TEST_ASSERT_EQUAL_INT(32767, expected);
TEST_ASSERT_EQUAL_INT(32767, atomic_load(&res));

atomic_store(&res, -12345);
expected = 12345;
TEST_ASSERT_EQUAL_INT(0, atomic_compare_exchange_weak(&res, &expected, 12345));
TEST_ASSERT_EQUAL_INT(-12345, expected);
TEST_ASSERT_EQUAL_INT(-12345, atomic_load(&res));

expected = 12345;
TEST_ASSERT_EQUAL_INT(0, atomic_compare_exchange_weak(&res, &expected, 12345));
TEST_ASSERT_EQUAL_INT(-12345, expected);
TEST_ASSERT_EQUAL_INT(-12345, atomic_load(&res));

expected = 12345;
TEST_ASSERT_EQUAL_INT(0, atomic_compare_exchange_weak(&res, &expected, -12345));
TEST_ASSERT_EQUAL_INT(-12345, expected);
TEST_ASSERT_EQUAL_INT(-12345, atomic_load(&res));
}

/* Test ATOMIC_VALUE */
/* Test atomic_load, atomic_store */
static void test_atomic_value(void)
{
atomic_int_t res = ATOMIC_INIT(12345);
atomic_int_t *ptr = &res;

TEST_ASSERT_EQUAL_INT(12345, ATOMIC_VALUE(res));
ATOMIC_VALUE(res) = 24332;
TEST_ASSERT_EQUAL_INT(24332, ATOMIC_VALUE(res));
TEST_ASSERT_EQUAL_INT(24332, res.value);
res.value = 12323;
TEST_ASSERT_EQUAL_INT(ATOMIC_VALUE(res), res.value);
TEST_ASSERT_EQUAL_INT(ATOMIC_VALUE(*ptr), res.value);
atomic_int res = ATOMIC_VAR_INIT(12345);

TEST_ASSERT_EQUAL_INT(12345, atomic_load(&res));
atomic_store(&res, 24332);
TEST_ASSERT_EQUAL_INT(24332, atomic_load(&res));
}

/* ATOMIC_INIT is implicitly tested by the other tests */
/* ATOMIC_VAR_INIT is implicitly tested by the other tests */

Test *tests_core_atomic_tests(void)
{
EMB_UNIT_TESTFIXTURES(fixtures) {
new_TestFixture(test_atomic_set_to_one_one),
new_TestFixture(test_atomic_set_to_one_zero),
new_TestFixture(test_atomic_set_to_one_twice),
new_TestFixture(test_atomic_set_to_zero_one),
new_TestFixture(test_atomic_set_to_zero_zero),
new_TestFixture(test_atomic_set_to_zero_twice),
new_TestFixture(test_atomic_flag),
new_TestFixture(test_atomic_inc_positive),
new_TestFixture(test_atomic_inc_negative),
new_TestFixture(test_atomic_inc_rollover),
Expand Down

0 comments on commit cb34eed

Please sign in to comment.