Skip to content

Commit 1b6b348

Browse files
nmischnmisch
committed
Report test_atomic_ops() failures consistently, via macros.
This prints the unexpected value in more failure cases, and it removes forty-eight hand-maintained error messages. Back-patch to 9.5, which introduced these tests. Reviewed (in an earlier version) by Andres Freund. Discussion: https://postgr.es/m/20190915160021.GA24376@alvherre.pgsql
1 parent ea9c0e1 commit 1b6b348

File tree

1 file changed

+81
-146
lines changed

1 file changed

+81
-146
lines changed

‎src/test/regress/regress.c

Lines changed: 81 additions & 146 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,34 @@
3838
#include "utils/memutils.h"
3939

4040

41+
#define EXPECT_TRUE(expr) \
42+
do { \
43+
if (!(expr)) \
44+
elog(ERROR, \
45+
"%s was unexpectedly false in file \"%s\" line %u", \
46+
#expr, __FILE__, __LINE__); \
47+
} while (0)
48+
49+
#define EXPECT_EQ_U32(result_expr, expected_expr) \
50+
do { \
51+
uint32 result = (result_expr); \
52+
uint32 expected = (expected_expr); \
53+
if (result != expected) \
54+
elog(ERROR, \
55+
"%s yielded %u, expected %s in file \"%s\" line %u", \
56+
#result_expr, result, #expected_expr, __FILE__, __LINE__); \
57+
} while (0)
58+
59+
#define EXPECT_EQ_U64(result_expr, expected_expr) \
60+
do { \
61+
uint64 result = (result_expr); \
62+
uint64 expected = (expected_expr); \
63+
if (result != expected) \
64+
elog(ERROR, \
65+
"%s yielded " UINT64_FORMAT ", expected %s in file \"%s\" line %u", \
66+
#result_expr, result, #expected_expr, __FILE__, __LINE__); \
67+
} while (0)
68+
4169
#define P_MAXDIG 12
4270
#define LDELIM '('
4371
#define RDELIM ')'
@@ -887,27 +915,13 @@ test_atomic_flag(void)
887915
pg_atomic_flag flag;
888916

889917
pg_atomic_init_flag(&flag);
890-
891-
if (!pg_atomic_unlocked_test_flag(&flag))
892-
elog(ERROR, "flag: unexpectedly set");
893-
894-
if (!pg_atomic_test_set_flag(&flag))
895-
elog(ERROR, "flag: couldn't set");
896-
897-
if (pg_atomic_unlocked_test_flag(&flag))
898-
elog(ERROR, "flag: unexpectedly unset");
899-
900-
if (pg_atomic_test_set_flag(&flag))
901-
elog(ERROR, "flag: set spuriously #2");
902-
918+
EXPECT_TRUE(pg_atomic_unlocked_test_flag(&flag));
919+
EXPECT_TRUE(pg_atomic_test_set_flag(&flag));
920+
EXPECT_TRUE(!pg_atomic_unlocked_test_flag(&flag));
921+
EXPECT_TRUE(!pg_atomic_test_set_flag(&flag));
903922
pg_atomic_clear_flag(&flag);
904-
905-
if (!pg_atomic_unlocked_test_flag(&flag))
906-
elog(ERROR, "flag: unexpectedly set #2");
907-
908-
if (!pg_atomic_test_set_flag(&flag))
909-
elog(ERROR, "flag: couldn't set");
910-
923+
EXPECT_TRUE(pg_atomic_unlocked_test_flag(&flag));
924+
EXPECT_TRUE(pg_atomic_test_set_flag(&flag));
911925
pg_atomic_clear_flag(&flag);
912926
}
913927

@@ -919,75 +933,38 @@ test_atomic_uint32(void)
919933
int i;
920934

921935
pg_atomic_init_u32(&var, 0);
922-
923-
if (pg_atomic_read_u32(&var) != 0)
924-
elog(ERROR, "atomic_read_u32() #1 wrong");
925-
936+
EXPECT_EQ_U32(pg_atomic_read_u32(&var), 0);
926937
pg_atomic_write_u32(&var, 3);
927-
928-
if (pg_atomic_read_u32(&var) != 3)
929-
elog(ERROR, "atomic_read_u32() #2 wrong");
930-
931-
if (pg_atomic_fetch_add_u32(&var, pg_atomic_read_u32(&var) - 2) != 3)
932-
elog(ERROR, "atomic_fetch_add_u32() #1 wrong");
933-
934-
if (pg_atomic_fetch_sub_u32(&var, 1) != 4)
935-
elog(ERROR, "atomic_fetch_sub_u32() #1 wrong");
936-
937-
if (pg_atomic_sub_fetch_u32(&var, 3) != 0)
938-
elog(ERROR, "atomic_sub_fetch_u32() #1 wrong");
939-
940-
if (pg_atomic_add_fetch_u32(&var, 10) != 10)
941-
elog(ERROR, "atomic_add_fetch_u32() #1 wrong");
942-
943-
if (pg_atomic_exchange_u32(&var, 5) != 10)
944-
elog(ERROR, "pg_atomic_exchange_u32() #1 wrong");
945-
946-
if (pg_atomic_exchange_u32(&var, 0) != 5)
947-
elog(ERROR, "pg_atomic_exchange_u32() #0 wrong");
938+
EXPECT_EQ_U32(pg_atomic_read_u32(&var), 3);
939+
EXPECT_EQ_U32(pg_atomic_fetch_add_u32(&var, pg_atomic_read_u32(&var) - 2),
940+
3);
941+
EXPECT_EQ_U32(pg_atomic_fetch_sub_u32(&var, 1), 4);
942+
EXPECT_EQ_U32(pg_atomic_sub_fetch_u32(&var, 3), 0);
943+
EXPECT_EQ_U32(pg_atomic_add_fetch_u32(&var, 10), 10);
944+
EXPECT_EQ_U32(pg_atomic_exchange_u32(&var, 5), 10);
945+
EXPECT_EQ_U32(pg_atomic_exchange_u32(&var, 0), 5);
948946

949947
/* test around numerical limits */
950-
if (pg_atomic_fetch_add_u32(&var, INT_MAX) != 0)
951-
elog(ERROR, "pg_atomic_fetch_add_u32() #2 wrong");
952-
953-
if (pg_atomic_fetch_add_u32(&var, INT_MAX) != INT_MAX)
954-
elog(ERROR, "pg_atomic_add_fetch_u32() #3 wrong");
955-
948+
EXPECT_EQ_U32(pg_atomic_fetch_add_u32(&var, INT_MAX), 0);
949+
EXPECT_EQ_U32(pg_atomic_fetch_add_u32(&var, INT_MAX), INT_MAX);
956950
pg_atomic_fetch_add_u32(&var, 2); /* wrap to 0 */
957-
958-
if (pg_atomic_fetch_add_u32(&var, PG_INT16_MAX) != 0)
959-
elog(ERROR, "pg_atomic_fetch_add_u32() #3 wrong");
960-
961-
if (pg_atomic_fetch_add_u32(&var, PG_INT16_MAX + 1) != PG_INT16_MAX)
962-
elog(ERROR, "pg_atomic_fetch_add_u32() #4 wrong");
963-
964-
if (pg_atomic_fetch_add_u32(&var, PG_INT16_MIN) != 2 * PG_INT16_MAX + 1)
965-
elog(ERROR, "pg_atomic_fetch_add_u32() #5 wrong");
966-
967-
if (pg_atomic_fetch_add_u32(&var, PG_INT16_MIN - 1) != PG_INT16_MAX)
968-
elog(ERROR, "pg_atomic_fetch_add_u32() #6 wrong");
969-
951+
EXPECT_EQ_U32(pg_atomic_fetch_add_u32(&var, PG_INT16_MAX), 0);
952+
EXPECT_EQ_U32(pg_atomic_fetch_add_u32(&var, PG_INT16_MAX + 1),
953+
PG_INT16_MAX);
954+
EXPECT_EQ_U32(pg_atomic_fetch_add_u32(&var, PG_INT16_MIN),
955+
2 * PG_INT16_MAX + 1);
956+
EXPECT_EQ_U32(pg_atomic_fetch_add_u32(&var, PG_INT16_MIN - 1),
957+
PG_INT16_MAX);
970958
pg_atomic_fetch_add_u32(&var, 1); /* top up to UINT_MAX */
971-
972-
if (pg_atomic_read_u32(&var) != UINT_MAX)
973-
elog(ERROR, "atomic_read_u32() #2 wrong");
974-
975-
if (pg_atomic_fetch_sub_u32(&var, INT_MAX) != UINT_MAX)
976-
elog(ERROR, "pg_atomic_fetch_sub_u32() #2 wrong");
977-
978-
if (pg_atomic_read_u32(&var) != (uint32) INT_MAX + 1)
979-
elog(ERROR, "atomic_read_u32() #3 wrong: %u", pg_atomic_read_u32(&var));
980-
981-
expected = pg_atomic_sub_fetch_u32(&var, INT_MAX);
982-
if (expected != 1)
983-
elog(ERROR, "pg_atomic_sub_fetch_u32() #3 wrong: %u", expected);
984-
959+
EXPECT_EQ_U32(pg_atomic_read_u32(&var), UINT_MAX);
960+
EXPECT_EQ_U32(pg_atomic_fetch_sub_u32(&var, INT_MAX), UINT_MAX);
961+
EXPECT_EQ_U32(pg_atomic_read_u32(&var), (uint32) INT_MAX + 1);
962+
EXPECT_EQ_U32(pg_atomic_sub_fetch_u32(&var, INT_MAX), 1);
985963
pg_atomic_sub_fetch_u32(&var, 1);
986964

987965
/* fail exchange because of old expected */
988966
expected = 10;
989-
if (pg_atomic_compare_exchange_u32(&var, &expected, 1))
990-
elog(ERROR, "atomic_compare_exchange_u32() changed value spuriously");
967+
EXPECT_TRUE(!pg_atomic_compare_exchange_u32(&var, &expected, 1));
991968

992969
/* CAS is allowed to fail due to interrupts, try a couple of times */
993970
for (i = 0; i < 1000; i++)
@@ -998,31 +975,18 @@ test_atomic_uint32(void)
998975
}
999976
if (i == 1000)
1000977
elog(ERROR, "atomic_compare_exchange_u32() never succeeded");
1001-
if (pg_atomic_read_u32(&var) != 1)
1002-
elog(ERROR, "atomic_compare_exchange_u32() didn't set value properly");
1003-
978+
EXPECT_EQ_U32(pg_atomic_read_u32(&var), 1);
1004979
pg_atomic_write_u32(&var, 0);
1005980

1006981
/* try setting flagbits */
1007-
if (pg_atomic_fetch_or_u32(&var, 1) & 1)
1008-
elog(ERROR, "pg_atomic_fetch_or_u32() #1 wrong");
1009-
1010-
if (!(pg_atomic_fetch_or_u32(&var, 2) & 1))
1011-
elog(ERROR, "pg_atomic_fetch_or_u32() #2 wrong");
1012-
1013-
if (pg_atomic_read_u32(&var) != 3)
1014-
elog(ERROR, "invalid result after pg_atomic_fetch_or_u32()");
1015-
982+
EXPECT_TRUE(!(pg_atomic_fetch_or_u32(&var, 1) & 1));
983+
EXPECT_TRUE(pg_atomic_fetch_or_u32(&var, 2) & 1);
984+
EXPECT_EQ_U32(pg_atomic_read_u32(&var), 3);
1016985
/* try clearing flagbits */
1017-
if ((pg_atomic_fetch_and_u32(&var, ~2) & 3) != 3)
1018-
elog(ERROR, "pg_atomic_fetch_and_u32() #1 wrong");
1019-
1020-
if (pg_atomic_fetch_and_u32(&var, ~1) != 1)
1021-
elog(ERROR, "pg_atomic_fetch_and_u32() #2 wrong: is %u",
1022-
pg_atomic_read_u32(&var));
986+
EXPECT_EQ_U32(pg_atomic_fetch_and_u32(&var, ~2) & 3, 3);
987+
EXPECT_EQ_U32(pg_atomic_fetch_and_u32(&var, ~1), 1);
1023988
/* no bits set anymore */
1024-
if (pg_atomic_fetch_and_u32(&var, ~0) != 0)
1025-
elog(ERROR, "pg_atomic_fetch_and_u32() #3 wrong");
989+
EXPECT_EQ_U32(pg_atomic_fetch_and_u32(&var, ~0), 0);
1026990
}
1027991

1028992
static void
@@ -1033,37 +997,20 @@ test_atomic_uint64(void)
1033997
int i;
1034998

1035999
pg_atomic_init_u64(&var, 0);
1036-
1037-
if (pg_atomic_read_u64(&var) != 0)
1038-
elog(ERROR, "atomic_read_u64() #1 wrong");
1039-
1000+
EXPECT_EQ_U64(pg_atomic_read_u64(&var), 0);
10401001
pg_atomic_write_u64(&var, 3);
1041-
1042-
if (pg_atomic_read_u64(&var) != 3)
1043-
elog(ERROR, "atomic_read_u64() #2 wrong");
1044-
1045-
if (pg_atomic_fetch_add_u64(&var, pg_atomic_read_u64(&var) - 2) != 3)
1046-
elog(ERROR, "atomic_fetch_add_u64() #1 wrong");
1047-
1048-
if (pg_atomic_fetch_sub_u64(&var, 1) != 4)
1049-
elog(ERROR, "atomic_fetch_sub_u64() #1 wrong");
1050-
1051-
if (pg_atomic_sub_fetch_u64(&var, 3) != 0)
1052-
elog(ERROR, "atomic_sub_fetch_u64() #1 wrong");
1053-
1054-
if (pg_atomic_add_fetch_u64(&var, 10) != 10)
1055-
elog(ERROR, "atomic_add_fetch_u64() #1 wrong");
1056-
1057-
if (pg_atomic_exchange_u64(&var, 5) != 10)
1058-
elog(ERROR, "pg_atomic_exchange_u64() #1 wrong");
1059-
1060-
if (pg_atomic_exchange_u64(&var, 0) != 5)
1061-
elog(ERROR, "pg_atomic_exchange_u64() #0 wrong");
1002+
EXPECT_EQ_U64(pg_atomic_read_u64(&var), 3);
1003+
EXPECT_EQ_U64(pg_atomic_fetch_add_u64(&var, pg_atomic_read_u64(&var) - 2),
1004+
3);
1005+
EXPECT_EQ_U64(pg_atomic_fetch_sub_u64(&var, 1), 4);
1006+
EXPECT_EQ_U64(pg_atomic_sub_fetch_u64(&var, 3), 0);
1007+
EXPECT_EQ_U64(pg_atomic_add_fetch_u64(&var, 10), 10);
1008+
EXPECT_EQ_U64(pg_atomic_exchange_u64(&var, 5), 10);
1009+
EXPECT_EQ_U64(pg_atomic_exchange_u64(&var, 0), 5);
10621010

10631011
/* fail exchange because of old expected */
10641012
expected = 10;
1065-
if (pg_atomic_compare_exchange_u64(&var, &expected, 1))
1066-
elog(ERROR, "atomic_compare_exchange_u64() changed value spuriously");
1013+
EXPECT_TRUE(!pg_atomic_compare_exchange_u64(&var, &expected, 1));
10671014

10681015
/* CAS is allowed to fail due to interrupts, try a couple of times */
10691016
for (i = 0; i < 100; i++)
@@ -1074,31 +1021,19 @@ test_atomic_uint64(void)
10741021
}
10751022
if (i == 100)
10761023
elog(ERROR, "atomic_compare_exchange_u64() never succeeded");
1077-
if (pg_atomic_read_u64(&var) != 1)
1078-
elog(ERROR, "atomic_compare_exchange_u64() didn't set value properly");
1024+
EXPECT_EQ_U64(pg_atomic_read_u64(&var), 1);
10791025

10801026
pg_atomic_write_u64(&var, 0);
10811027

10821028
/* try setting flagbits */
1083-
if (pg_atomic_fetch_or_u64(&var, 1) & 1)
1084-
elog(ERROR, "pg_atomic_fetch_or_u64() #1 wrong");
1085-
1086-
if (!(pg_atomic_fetch_or_u64(&var, 2) & 1))
1087-
elog(ERROR, "pg_atomic_fetch_or_u64() #2 wrong");
1088-
1089-
if (pg_atomic_read_u64(&var) != 3)
1090-
elog(ERROR, "invalid result after pg_atomic_fetch_or_u64()");
1091-
1029+
EXPECT_TRUE(!(pg_atomic_fetch_or_u64(&var, 1) & 1));
1030+
EXPECT_TRUE(pg_atomic_fetch_or_u64(&var, 2) & 1);
1031+
EXPECT_EQ_U64(pg_atomic_read_u64(&var), 3);
10921032
/* try clearing flagbits */
1093-
if ((pg_atomic_fetch_and_u64(&var, ~2) & 3) != 3)
1094-
elog(ERROR, "pg_atomic_fetch_and_u64() #1 wrong");
1095-
1096-
if (pg_atomic_fetch_and_u64(&var, ~1) != 1)
1097-
elog(ERROR, "pg_atomic_fetch_and_u64() #2 wrong: is " UINT64_FORMAT,
1098-
pg_atomic_read_u64(&var));
1033+
EXPECT_EQ_U64((pg_atomic_fetch_and_u64(&var, ~2) & 3), 3);
1034+
EXPECT_EQ_U64(pg_atomic_fetch_and_u64(&var, ~1), 1);
10991035
/* no bits set anymore */
1100-
if (pg_atomic_fetch_and_u64(&var, ~0) != 0)
1101-
elog(ERROR, "pg_atomic_fetch_and_u64() #3 wrong");
1036+
EXPECT_EQ_U64(pg_atomic_fetch_and_u64(&var, ~0), 0);
11021037
}
11031038

11041039

0 commit comments

Comments
 (0)