Apply X-macro trick to reduce duplicated code

X macros are a technique for reliable maintenance of parallel lists
of code and/or data, whose corresponding items must be declared or
executed in the same order.

The operations in DUT are defined and implemented by means of X-macro
technique, meaning that the duplicated code can then be eliminated.

Reference: https://en.wikipedia.org/wiki/X_Macro

Author: jserv

dudect/constant.c

@@ -12,16 +12,33 @@
  */
 static struct list_head *l = NULL;
 
+#define dut_new() ((void) (l = q_new()))
+
+#define dut_size(n)                                \
+    do {                                           \
+        for (int __iter = 0; __iter < n; ++__iter) \
+            q_size(l);                             \
+    } while (0)
+
+#define dut_insert_head(s, n)    \
+    do {                         \
+        int j = n;               \
+        while (j--)              \
+            q_insert_head(l, s); \
+    } while (0)
+
+#define dut_insert_tail(s, n)    \
+    do {                         \
+        int j = n;               \
+        while (j--)              \
+            q_insert_tail(l, s); \
+    } while (0)
+
+#define dut_free() ((void) (q_free(l)))
+
 static char random_string[N_MEASURES][8];
 static int random_string_iter = 0;
 
-enum {
-    test_insert_head,
-    test_insert_tail,
-    test_remove_head,
-    test_remove_tail,
-};
-
 /* Implement the necessary queue interface to simulation */
 void init_dut(void)
 {
@@ -55,11 +72,11 @@ void measure(int64_t *before_ticks,
              uint8_t *input_data,
              int mode)
 {
-    assert(mode == test_insert_head || mode == test_insert_tail ||
-           mode == test_remove_head || mode == test_remove_tail);
+    assert(mode == DUT(insert_head) || mode == DUT(insert_tail) ||
+           mode == DUT(remove_head) || mode == DUT(remove_tail));
 
     switch (mode) {
-    case test_insert_head:
+    case DUT(insert_head):
         for (size_t i = DROP_SIZE; i < N_MEASURES - DROP_SIZE; i++) {
             char *s = get_random_string();
             dut_new();
@@ -72,7 +89,7 @@ void measure(int64_t *before_ticks,
             dut_free();
         }
         break;
-    case test_insert_tail:
+    case DUT(insert_tail):
         for (size_t i = DROP_SIZE; i < N_MEASURES - DROP_SIZE; i++) {
             char *s = get_random_string();
             dut_new();
@@ -85,7 +102,7 @@ void measure(int64_t *before_ticks,
             dut_free();
         }
         break;
-    case test_remove_head:
+    case DUT(remove_head):
         for (size_t i = DROP_SIZE; i < N_MEASURES - DROP_SIZE; i++) {
             dut_new();
             dut_insert_head(
@@ -99,7 +116,7 @@ void measure(int64_t *before_ticks,
             dut_free();
         }
         break;
-    case test_remove_tail:
+    case DUT(remove_tail):
         for (size_t i = DROP_SIZE; i < N_MEASURES - DROP_SIZE; i++) {
             dut_new();
             dut_insert_head(

dudect/constant.h

@@ -11,29 +11,19 @@
 
 #define DROP_SIZE 20
 
-#define dut_new() ((void) (l = q_new()))
-
-#define dut_size(n)                                \
-    do {                                           \
-        for (int __iter = 0; __iter < n; ++__iter) \
-            q_size(l);                             \
-    } while (0)
-
-#define dut_insert_head(s, n)    \
-    do {                         \
-        int j = n;               \
-        while (j--)              \
-            q_insert_head(l, s); \
-    } while (0)
-
-#define dut_insert_tail(s, n)    \
-    do {                         \
-        int j = n;               \
-        while (j--)              \
-            q_insert_tail(l, s); \
-    } while (0)
-
-#define dut_free() ((void) (q_free(l)))
+#define DUT_FUNCS  \
+    _(insert_head) \
+    _(insert_tail) \
+    _(remove_head) \
+    _(remove_tail)
+
+#define DUT(x) DUT_##x
+
+enum {
+#define _(x) DUT(x),
+    DUT_FUNCS
+#undef _
+};
 
 void init_dut();
 void prepare_inputs(uint8_t *input_data, uint8_t *classes);

dudect/fixture.c

@@ -170,22 +170,12 @@ static bool test_const(char *text, int mode)
     return result;
 }
 
-bool is_insert_head_const(void)
-{
-    return test_const("insert_head", 0);
-}
-
-bool is_insert_tail_const(void)
-{
-    return test_const("insert_tail", 1);
-}
-
-bool is_remove_head_const(void)
-{
-    return test_const("remove_head", 2);
-}
+#define DUT_FUNC_IMPL(op)                \
+    bool is_##op##_const(void)           \
+    {                                    \
+        return test_const(#op, DUT(op)); \
+    }
 
-bool is_remove_tail_const(void)
-{
-    return test_const("remove_tail", 3);
-}
+#define _(x) DUT_FUNC_IMPL(x)
+DUT_FUNCS
+#undef _

dudect/fixture.h

@@ -5,9 +5,8 @@
 #include "constant.h"
 
 /* Interface to test if function is constant */
-bool is_insert_head_const(void);
-bool is_insert_tail_const(void);
-bool is_remove_head_const(void);
-bool is_remove_tail_const(void);
+#define _(x) bool is_##x##_const(void);
+DUT_FUNCS
+#undef _
 
 #endif

scripts/aspell-pws

@@ -7,6 +7,7 @@ bash
 etc
 var
 dudect
+dut
 runtime
 todo
 fixme