HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/test/test-macro.c

47,631 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 9a9a1fa2dac7fd79e176517a37be3df42ef45beb

Lines 1001–1128 of 1,128

        x = n = 0;
        FOREACH_ARRAY(i, a, 0)
                FOREACH_ARRAY(j, b, 0) {
                        x += (*i) * (*j);
                        n++;
                }
        assert_se(x == 0);
        assert_se(n == 0);
 
        x = n = 0;
        FOREACH_ARRAY(i, a, -1)
                FOREACH_ARRAY(j, b, -1) {
                        x += (*i) * (*j);
                        n++;
                }
        assert_se(x == 0);
        assert_se(n == 0);
}
 
#define TEST_ROUND_UP_BY_TYPE(type, max_value)                          \
        ({                                                              \
                type x, y;                                              \
                x = 0, y = 1;                                           \
                assert_se(ROUND_UP(x, y) == 0);                         \
                x = 0, y = 2;                                           \
                assert_se(ROUND_UP(x, y) == 0);                         \
                x = 0, y = 3;                                           \
                assert_se(ROUND_UP(x, y) == 0);                         \
                x = 0, y = 4;                                           \
                assert_se(ROUND_UP(x, y) == 0);                         \
                x = 1, y = 1;                                           \
                assert_se(ROUND_UP(x, y) == 1);                         \
                x = 1, y = 2;                                           \
                assert_se(ROUND_UP(x, y) == 2);                         \
                x = 1, y = 3;                                           \
                assert_se(ROUND_UP(x, y) == 3);                         \
                x = 1, y = 4;                                           \
                assert_se(ROUND_UP(x, y) == 4);                         \
                x = 2, y = 1;                                           \
                assert_se(ROUND_UP(x, y) == 2);                         \
                x = 2, y = 2;                                           \
                assert_se(ROUND_UP(x, y) == 2);                         \
                x = 2, y = 3;                                           \
                assert_se(ROUND_UP(x, y) == 3);                         \
                x = 2, y = 4;                                           \
                assert_se(ROUND_UP(x, y) == 4);                         \
                x = 3, y = 1;                                           \
                assert_se(ROUND_UP(x, y) == 3);                         \
                x = 3, y = 2;                                           \
                assert_se(ROUND_UP(x, y) == 4);                         \
                x = 3, y = 3;                                           \
                assert_se(ROUND_UP(x, y) == 3);                         \
                x = 3, y = 4;                                           \
                assert_se(ROUND_UP(x, y) == 4);                         \
                x = 4, y = 1;                                           \
                assert_se(ROUND_UP(x, y) == 4);                         \
                x = 4, y = 2;                                           \
                assert_se(ROUND_UP(x, y) == 4);                         \
                x = 4, y = 3;                                           \
                assert_se(ROUND_UP(x, y) == 6);                         \
                x = 4, y = 4;                                           \
                assert_se(ROUND_UP(x, y) == 4);                         \
                x = max_value, y = 1;                                   \
                assert_se(ROUND_UP(x, y) == max_value);                 \
                x = max_value, y = 2;                                   \
                assert_se(ROUND_UP(x, y) == max_value);                 \
                x = max_value, y = 3;                                   \
                assert_se(ROUND_UP(x, y) == max_value);                 \
                x = max_value, y = 4;                                   \
                assert_se(ROUND_UP(x, y) == max_value);                 \
                x = max_value-1, y = 1;                                 \
                assert_se(ROUND_UP(x, y) == max_value-1);               \
                x = max_value-1, y = 2;                                 \
                assert_se(ROUND_UP(x, y) == max_value-1);               \
                x = max_value-1, y = 4;                                 \
                assert_se(ROUND_UP(x, y) == max_value);                 \
        })
 
TEST(ROUND_UP) {
        TEST_ROUND_UP_BY_TYPE(uint8_t, UINT8_MAX);
        TEST_ROUND_UP_BY_TYPE(uint16_t, UINT16_MAX);
        TEST_ROUND_UP_BY_TYPE(uint32_t, UINT32_MAX);
        TEST_ROUND_UP_BY_TYPE(uint64_t, UINT64_MAX);
}
 
TEST(u64_multiply_safe) {
        assert_se(u64_multiply_safe(0, 0) == 0);
        assert_se(u64_multiply_safe(10, 0) == 0);
        assert_se(u64_multiply_safe(0, 10) == 0);
        assert_se(u64_multiply_safe(10, 10) == 100);
 
        assert_se(u64_multiply_safe(UINT64_MAX, 0) == 0);
        assert_se(u64_multiply_safe(UINT64_MAX, 1) == UINT64_MAX);
        assert_se(u64_multiply_safe(UINT64_MAX, 2) == 0);
        assert_se(u64_multiply_safe(0, UINT64_MAX) == 0);
        assert_se(u64_multiply_safe(1, UINT64_MAX) == UINT64_MAX);
        assert_se(u64_multiply_safe(2, UINT64_MAX) == 0);
 
        assert_se(u64_multiply_safe(UINT64_MAX / 2, 0) == 0);
        assert_se(u64_multiply_safe(UINT64_MAX / 2, 1) == UINT64_MAX / 2);
        assert_se(u64_multiply_safe(UINT64_MAX / 2, 2) == UINT64_MAX - 1);
        assert_se(u64_multiply_safe(UINT64_MAX / 2, 3) == 0);
        assert_se(u64_multiply_safe(0, UINT64_MAX / 2) == 0);
        assert_se(u64_multiply_safe(1, UINT64_MAX / 2) == UINT64_MAX / 2);
        assert_se(u64_multiply_safe(2, UINT64_MAX / 2) == UINT64_MAX - 1);
        assert_se(u64_multiply_safe(3, UINT64_MAX / 2) == 0);
 
        assert_se(u64_multiply_safe(UINT64_MAX, UINT64_MAX) == 0);
}
 
static void test_once_impl(void) {
        static unsigned count = 0;
 
        if (ONCE) {
                log_info("This should be logged only once.");
                count++;
        }
 
        ASSERT_EQ(count, 1u);
}
 
TEST(once) {
        for (unsigned i = 0; i < 20; i++)
                test_once_impl();
}
 
DEFINE_TEST_MAIN(LOG_INFO);