1 #include "test/jemalloc_test.h" 2 3 #include "jemalloc/internal/log.h" 4 5 static void 6 update_log_var_names(const char *names) { 7 strncpy(log_var_names, names, sizeof(log_var_names)); 8 } 9 10 static void 11 expect_no_logging(const char *names) { 12 log_var_t log_l1 = LOG_VAR_INIT("l1"); 13 log_var_t log_l2 = LOG_VAR_INIT("l2"); 14 log_var_t log_l2_a = LOG_VAR_INIT("l2.a"); 15 16 update_log_var_names(names); 17 18 int count = 0; 19 20 for (int i = 0; i < 10; i++) { 21 log_do_begin(log_l1) 22 count++; 23 log_do_end(log_l1) 24 25 log_do_begin(log_l2) 26 count++; 27 log_do_end(log_l2) 28 29 log_do_begin(log_l2_a) 30 count++; 31 log_do_end(log_l2_a) 32 } 33 expect_d_eq(count, 0, "Disabled logging not ignored!"); 34 } 35 36 TEST_BEGIN(test_log_disabled) { 37 test_skip_if(!config_log); 38 atomic_store_b(&log_init_done, true, ATOMIC_RELAXED); 39 expect_no_logging(""); 40 expect_no_logging("abc"); 41 expect_no_logging("a.b.c"); 42 expect_no_logging("l12"); 43 expect_no_logging("l123|a456|b789"); 44 expect_no_logging("|||"); 45 } 46 TEST_END 47 48 TEST_BEGIN(test_log_enabled_direct) { 49 test_skip_if(!config_log); 50 atomic_store_b(&log_init_done, true, ATOMIC_RELAXED); 51 log_var_t log_l1 = LOG_VAR_INIT("l1"); 52 log_var_t log_l1_a = LOG_VAR_INIT("l1.a"); 53 log_var_t log_l2 = LOG_VAR_INIT("l2"); 54 55 int count; 56 57 count = 0; 58 update_log_var_names("l1"); 59 for (int i = 0; i < 10; i++) { 60 log_do_begin(log_l1) 61 count++; 62 log_do_end(log_l1) 63 } 64 expect_d_eq(count, 10, "Mis-logged!"); 65 66 count = 0; 67 update_log_var_names("l1.a"); 68 for (int i = 0; i < 10; i++) { 69 log_do_begin(log_l1_a) 70 count++; 71 log_do_end(log_l1_a) 72 } 73 expect_d_eq(count, 10, "Mis-logged!"); 74 75 count = 0; 76 update_log_var_names("l1.a|abc|l2|def"); 77 for (int i = 0; i < 10; i++) { 78 log_do_begin(log_l1_a) 79 count++; 80 log_do_end(log_l1_a) 81 82 log_do_begin(log_l2) 83 count++; 84 log_do_end(log_l2) 85 } 86 expect_d_eq(count, 20, "Mis-logged!"); 87 } 88 TEST_END 89 90 TEST_BEGIN(test_log_enabled_indirect) { 91 test_skip_if(!config_log); 92 atomic_store_b(&log_init_done, true, ATOMIC_RELAXED); 93 update_log_var_names("l0|l1|abc|l2.b|def"); 94 95 /* On. */ 96 log_var_t log_l1 = LOG_VAR_INIT("l1"); 97 /* Off. */ 98 log_var_t log_l1a = LOG_VAR_INIT("l1a"); 99 /* On. */ 100 log_var_t log_l1_a = LOG_VAR_INIT("l1.a"); 101 /* Off. */ 102 log_var_t log_l2_a = LOG_VAR_INIT("l2.a"); 103 /* On. */ 104 log_var_t log_l2_b_a = LOG_VAR_INIT("l2.b.a"); 105 /* On. */ 106 log_var_t log_l2_b_b = LOG_VAR_INIT("l2.b.b"); 107 108 /* 4 are on total, so should sum to 40. */ 109 int count = 0; 110 for (int i = 0; i < 10; i++) { 111 log_do_begin(log_l1) 112 count++; 113 log_do_end(log_l1) 114 115 log_do_begin(log_l1a) 116 count++; 117 log_do_end(log_l1a) 118 119 log_do_begin(log_l1_a) 120 count++; 121 log_do_end(log_l1_a) 122 123 log_do_begin(log_l2_a) 124 count++; 125 log_do_end(log_l2_a) 126 127 log_do_begin(log_l2_b_a) 128 count++; 129 log_do_end(log_l2_b_a) 130 131 log_do_begin(log_l2_b_b) 132 count++; 133 log_do_end(log_l2_b_b) 134 } 135 136 expect_d_eq(count, 40, "Mis-logged!"); 137 } 138 TEST_END 139 140 TEST_BEGIN(test_log_enabled_global) { 141 test_skip_if(!config_log); 142 atomic_store_b(&log_init_done, true, ATOMIC_RELAXED); 143 update_log_var_names("abc|.|def"); 144 145 log_var_t log_l1 = LOG_VAR_INIT("l1"); 146 log_var_t log_l2_a_a = LOG_VAR_INIT("l2.a.a"); 147 148 int count = 0; 149 for (int i = 0; i < 10; i++) { 150 log_do_begin(log_l1) 151 count++; 152 log_do_end(log_l1) 153 154 log_do_begin(log_l2_a_a) 155 count++; 156 log_do_end(log_l2_a_a) 157 } 158 expect_d_eq(count, 20, "Mis-logged!"); 159 } 160 TEST_END 161 162 TEST_BEGIN(test_logs_if_no_init) { 163 test_skip_if(!config_log); 164 atomic_store_b(&log_init_done, false, ATOMIC_RELAXED); 165 166 log_var_t l = LOG_VAR_INIT("definitely.not.enabled"); 167 168 int count = 0; 169 for (int i = 0; i < 10; i++) { 170 log_do_begin(l) 171 count++; 172 log_do_end(l) 173 } 174 expect_d_eq(count, 0, "Logging shouldn't happen if not initialized."); 175 } 176 TEST_END 177 178 /* 179 * This really just checks to make sure that this usage compiles; we don't have 180 * any test code to run. 181 */ 182 TEST_BEGIN(test_log_only_format_string) { 183 if (false) { 184 LOG("log_str", "No arguments follow this format string."); 185 } 186 } 187 TEST_END 188 189 int 190 main(void) { 191 return test( 192 test_log_disabled, 193 test_log_enabled_direct, 194 test_log_enabled_indirect, 195 test_log_enabled_global, 196 test_logs_if_no_init, 197 test_log_only_format_string); 198 } 199