| #include "test/jemalloc_test.h" |
| |
| #define BILLION 1000000000 |
| |
| TEST_BEGIN(test_time_init) |
| { |
| struct timespec ts; |
| |
| time_init(&ts, 42, 43); |
| assert_ld_eq(ts.tv_sec, 42, "tv_sec incorrectly initialized"); |
| assert_ld_eq(ts.tv_nsec, 43, "tv_nsec incorrectly initialized"); |
| } |
| TEST_END |
| |
| TEST_BEGIN(test_time_sec) |
| { |
| struct timespec ts; |
| |
| time_init(&ts, 42, 43); |
| assert_ld_eq(time_sec(&ts), 42, "tv_sec incorrectly read"); |
| } |
| TEST_END |
| |
| TEST_BEGIN(test_time_nsec) |
| { |
| struct timespec ts; |
| |
| time_init(&ts, 42, 43); |
| assert_ld_eq(time_nsec(&ts), 43, "tv_nsec incorrectly read"); |
| } |
| TEST_END |
| |
| TEST_BEGIN(test_time_copy) |
| { |
| struct timespec tsa, tsb; |
| |
| time_init(&tsa, 42, 43); |
| time_init(&tsb, 0, 0); |
| time_copy(&tsb, &tsa); |
| assert_ld_eq(time_sec(&tsb), 42, "tv_sec incorrectly copied"); |
| assert_ld_eq(time_nsec(&tsb), 43, "tv_nsec incorrectly copied"); |
| } |
| TEST_END |
| |
| TEST_BEGIN(test_time_compare) |
| { |
| struct timespec tsa, tsb; |
| |
| time_init(&tsa, 42, 43); |
| time_copy(&tsb, &tsa); |
| assert_d_eq(time_compare(&tsa, &tsb), 0, "Times should be equal"); |
| assert_d_eq(time_compare(&tsb, &tsa), 0, "Times should be equal"); |
| |
| time_init(&tsb, 42, 42); |
| assert_d_eq(time_compare(&tsa, &tsb), 1, |
| "tsa should be greater than tsb"); |
| assert_d_eq(time_compare(&tsb, &tsa), -1, |
| "tsb should be less than tsa"); |
| |
| time_init(&tsb, 42, 44); |
| assert_d_eq(time_compare(&tsa, &tsb), -1, |
| "tsa should be less than tsb"); |
| assert_d_eq(time_compare(&tsb, &tsa), 1, |
| "tsb should be greater than tsa"); |
| |
| time_init(&tsb, 41, BILLION - 1); |
| assert_d_eq(time_compare(&tsa, &tsb), 1, |
| "tsa should be greater than tsb"); |
| assert_d_eq(time_compare(&tsb, &tsa), -1, |
| "tsb should be less than tsa"); |
| |
| time_init(&tsb, 43, 0); |
| assert_d_eq(time_compare(&tsa, &tsb), -1, |
| "tsa should be less than tsb"); |
| assert_d_eq(time_compare(&tsb, &tsa), 1, |
| "tsb should be greater than tsa"); |
| } |
| TEST_END |
| |
| TEST_BEGIN(test_time_add) |
| { |
| struct timespec tsa, tsb; |
| |
| time_init(&tsa, 42, 43); |
| time_copy(&tsb, &tsa); |
| time_add(&tsa, &tsb); |
| time_init(&tsb, 84, 86); |
| assert_d_eq(time_compare(&tsa, &tsb), 0, "Incorrect addition result"); |
| |
| time_init(&tsa, 42, BILLION - 1); |
| time_copy(&tsb, &tsa); |
| time_add(&tsa, &tsb); |
| time_init(&tsb, 85, BILLION - 2); |
| assert_d_eq(time_compare(&tsa, &tsb), 0, "Incorrect addition result"); |
| } |
| TEST_END |
| |
| TEST_BEGIN(test_time_subtract) |
| { |
| struct timespec tsa, tsb; |
| |
| time_init(&tsa, 42, 43); |
| time_copy(&tsb, &tsa); |
| time_subtract(&tsa, &tsb); |
| time_init(&tsb, 0, 0); |
| assert_d_eq(time_compare(&tsa, &tsb), 0, |
| "Incorrect subtraction result"); |
| |
| time_init(&tsa, 42, 43); |
| time_init(&tsb, 41, 44); |
| time_subtract(&tsa, &tsb); |
| time_init(&tsb, 0, BILLION - 1); |
| assert_d_eq(time_compare(&tsa, &tsb), 0, |
| "Incorrect subtraction result"); |
| } |
| TEST_END |
| |
| TEST_BEGIN(test_time_imultiply) |
| { |
| struct timespec tsa, tsb; |
| |
| time_init(&tsa, 42, 43); |
| time_imultiply(&tsa, 10); |
| time_init(&tsb, 420, 430); |
| assert_d_eq(time_compare(&tsa, &tsb), 0, |
| "Incorrect multiplication result"); |
| |
| time_init(&tsa, 42, 666666666); |
| time_imultiply(&tsa, 3); |
| time_init(&tsb, 127, 999999998); |
| assert_d_eq(time_compare(&tsa, &tsb), 0, |
| "Incorrect multiplication result"); |
| } |
| TEST_END |
| |
| TEST_BEGIN(test_time_idivide) |
| { |
| struct timespec tsa, tsb; |
| |
| time_init(&tsa, 42, 43); |
| time_copy(&tsb, &tsa); |
| time_imultiply(&tsa, 10); |
| time_idivide(&tsa, 10); |
| assert_d_eq(time_compare(&tsa, &tsb), 0, "Incorrect division result"); |
| |
| time_init(&tsa, 42, 666666666); |
| time_copy(&tsb, &tsa); |
| time_imultiply(&tsa, 3); |
| time_idivide(&tsa, 3); |
| assert_d_eq(time_compare(&tsa, &tsb), 0, "Incorrect division result"); |
| } |
| TEST_END |
| |
| TEST_BEGIN(test_time_divide) |
| { |
| struct timespec tsa, tsb, tsc; |
| |
| time_init(&tsa, 42, 43); |
| time_copy(&tsb, &tsa); |
| time_imultiply(&tsa, 10); |
| assert_u64_eq(time_divide(&tsa, &tsb), 10, |
| "Incorrect division result"); |
| |
| time_init(&tsa, 42, 43); |
| time_copy(&tsb, &tsa); |
| time_imultiply(&tsa, 10); |
| time_init(&tsc, 0, 1); |
| time_add(&tsa, &tsc); |
| assert_u64_eq(time_divide(&tsa, &tsb), 10, |
| "Incorrect division result"); |
| |
| time_init(&tsa, 42, 43); |
| time_copy(&tsb, &tsa); |
| time_imultiply(&tsa, 10); |
| time_init(&tsc, 0, 1); |
| time_subtract(&tsa, &tsc); |
| assert_u64_eq(time_divide(&tsa, &tsb), 9, "Incorrect division result"); |
| } |
| TEST_END |
| |
| TEST_BEGIN(test_time_update) |
| { |
| struct timespec ts; |
| |
| time_init(&ts, 0, 0); |
| |
| assert_false(time_update(&ts), "Basic time update failed."); |
| |
| /* Only Rip Van Winkle sleeps this long. */ |
| { |
| struct timespec addend; |
| time_init(&addend, 631152000, 0); |
| time_add(&ts, &addend); |
| } |
| { |
| struct timespec ts0; |
| time_copy(&ts0, &ts); |
| assert_true(time_update(&ts), |
| "Update should detect time roll-back."); |
| assert_d_eq(time_compare(&ts, &ts0), 0, |
| "Time should not have been modified"); |
| } |
| |
| } |
| TEST_END |
| |
| int |
| main(void) |
| { |
| |
| return (test( |
| test_time_init, |
| test_time_sec, |
| test_time_nsec, |
| test_time_copy, |
| test_time_compare, |
| test_time_add, |
| test_time_subtract, |
| test_time_imultiply, |
| test_time_idivide, |
| test_time_divide, |
| test_time_update)); |
| } |