1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <limits.h>
18
19 #include <memory>
20 #include <string>
21
22 #include <gtest/gtest.h>
23
24 #include "Config.h"
25
26 #include "log_fake.h"
27
28 class MallocDebugConfigTest : public ::testing::Test {
29 protected:
SetUp()30 void SetUp() override {
31 resetLogs();
32 }
33
34 std::unique_ptr<Config> config;
35
InitConfig(const char * options)36 bool InitConfig(const char* options) {
37 config.reset(new Config);
38 return config->Init(options);
39 }
40 };
41
42 std::string usage_string(
43 "6 malloc_debug For malloc debug option descriptions go to:\n"
44 "6 malloc_debug "
45 "https://android.googlesource.com/platform/bionic/+/main/libc/malloc_debug/README.md\n");
46
TEST_F(MallocDebugConfigTest,unknown_option)47 TEST_F(MallocDebugConfigTest, unknown_option) {
48
49 ASSERT_FALSE(InitConfig("unknown_option"));
50
51 ASSERT_STREQ("", getFakeLogBuf().c_str());
52 std::string log_msg("6 malloc_debug malloc_testing: unknown option unknown_option\n");
53 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
54 }
55
TEST_F(MallocDebugConfigTest,good_option_and_bad_option)56 TEST_F(MallocDebugConfigTest, good_option_and_bad_option) {
57 ASSERT_FALSE(InitConfig("backtrace unknown_option"));
58
59 ASSERT_STREQ("", getFakeLogBuf().c_str());
60 std::string log_msg("6 malloc_debug malloc_testing: unknown option unknown_option\n");
61 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
62 }
63
TEST_F(MallocDebugConfigTest,unparseable_number)64 TEST_F(MallocDebugConfigTest, unparseable_number) {
65 ASSERT_FALSE(InitConfig("backtrace=XXX"));
66
67 ASSERT_STREQ("", getFakeLogBuf().c_str());
68 std::string log_msg("6 malloc_debug malloc_testing: bad value for option 'backtrace'\n");
69 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
70 }
71
TEST_F(MallocDebugConfigTest,illegal_value_zero)72 TEST_F(MallocDebugConfigTest, illegal_value_zero) {
73 ASSERT_FALSE(InitConfig("backtrace=0"));
74
75 ASSERT_STREQ("", getFakeLogBuf().c_str());
76 std::string log_msg(
77 "6 malloc_debug malloc_testing: bad value for option 'backtrace', value must be >= 1: 0\n");
78 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
79 }
80
TEST_F(MallocDebugConfigTest,no_space)81 TEST_F(MallocDebugConfigTest, no_space) {
82 ASSERT_FALSE(InitConfig("backtrace=10front_guard"));
83
84 ASSERT_STREQ("", getFakeLogBuf().c_str());
85 std::string log_msg(
86 "6 malloc_debug malloc_testing: bad value for option 'backtrace', "
87 "non space found after option: front_guard\n");
88 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
89 }
90
TEST_F(MallocDebugConfigTest,illegal_value_negative)91 TEST_F(MallocDebugConfigTest, illegal_value_negative) {
92 ASSERT_FALSE(InitConfig("backtrace=-1"));
93
94 ASSERT_STREQ("", getFakeLogBuf().c_str());
95 std::string log_msg(
96 "6 malloc_debug malloc_testing: bad value for option 'backtrace', "
97 "value cannot be negative: -1\n");
98 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
99 }
100
TEST_F(MallocDebugConfigTest,overflow)101 TEST_F(MallocDebugConfigTest, overflow) {
102 ASSERT_FALSE(InitConfig("backtrace=99999999999999999999"));
103
104 ASSERT_STREQ("", getFakeLogBuf().c_str());
105 std::string log_msg(
106 "6 malloc_debug malloc_testing: bad value for option 'backtrace': "
107 "Math result not representable\n");
108 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
109 }
110
TEST_F(MallocDebugConfigTest,set_value_error)111 TEST_F(MallocDebugConfigTest, set_value_error) {
112 ASSERT_FALSE(InitConfig("leak_track=12"));
113
114 ASSERT_STREQ("", getFakeLogBuf().c_str());
115 std::string log_msg(
116 "6 malloc_debug malloc_testing: value set for option 'leak_track' "
117 "which does not take a value\n");
118 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
119 }
120
TEST_F(MallocDebugConfigTest,space_before_equal)121 TEST_F(MallocDebugConfigTest, space_before_equal) {
122 ASSERT_TRUE(InitConfig("backtrace =10")) << getFakeLogPrint();
123 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
124 ASSERT_EQ(10U, config->backtrace_frames());
125
126 ASSERT_STREQ("", getFakeLogBuf().c_str());
127 ASSERT_STREQ("", getFakeLogPrint().c_str());
128 }
129
TEST_F(MallocDebugConfigTest,space_after_equal)130 TEST_F(MallocDebugConfigTest, space_after_equal) {
131 ASSERT_TRUE(InitConfig("backtrace= 10")) << getFakeLogPrint();
132 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
133 ASSERT_EQ(10U, config->backtrace_frames());
134
135 ASSERT_STREQ("", getFakeLogBuf().c_str());
136 ASSERT_STREQ("", getFakeLogPrint().c_str());
137 }
138
TEST_F(MallocDebugConfigTest,extra_space)139 TEST_F(MallocDebugConfigTest, extra_space) {
140 ASSERT_TRUE(InitConfig(" backtrace=64 ")) << getFakeLogPrint();
141 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
142 ASSERT_EQ(64U, config->backtrace_frames());
143
144 ASSERT_STREQ("", getFakeLogBuf().c_str());
145 ASSERT_STREQ("", getFakeLogPrint().c_str());
146 }
147
TEST_F(MallocDebugConfigTest,multiple_options)148 TEST_F(MallocDebugConfigTest, multiple_options) {
149 ASSERT_TRUE(InitConfig(" backtrace=64 front_guard=48")) << getFakeLogPrint();
150 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS | FRONT_GUARD, config->options());
151 ASSERT_EQ(64U, config->backtrace_frames());
152 ASSERT_EQ(48U, config->front_guard_bytes());
153
154 ASSERT_STREQ("", getFakeLogBuf().c_str());
155 ASSERT_STREQ("", getFakeLogPrint().c_str());
156 }
157
TEST_F(MallocDebugConfigTest,front_guard)158 TEST_F(MallocDebugConfigTest, front_guard) {
159 ASSERT_TRUE(InitConfig("front_guard=48")) << getFakeLogPrint();
160 ASSERT_EQ(FRONT_GUARD | TRACK_ALLOCS, config->options());
161 ASSERT_EQ(48U, config->front_guard_bytes());
162
163 ASSERT_TRUE(InitConfig("front_guard")) << getFakeLogPrint();
164 ASSERT_EQ(FRONT_GUARD | TRACK_ALLOCS, config->options());
165 ASSERT_EQ(32U, config->front_guard_bytes());
166
167 ASSERT_TRUE(InitConfig("front_guard=39")) << getFakeLogPrint();
168 ASSERT_EQ(FRONT_GUARD | TRACK_ALLOCS, config->options());
169 #if defined(__LP64__)
170 ASSERT_EQ(48U, config->front_guard_bytes());
171 #else
172 ASSERT_EQ(40U, config->front_guard_bytes());
173 #endif
174
175 ASSERT_TRUE(InitConfig("front_guard=41")) << getFakeLogPrint();
176 ASSERT_EQ(FRONT_GUARD | TRACK_ALLOCS, config->options());
177 ASSERT_EQ(48U, config->front_guard_bytes());
178
179 ASSERT_STREQ("", getFakeLogBuf().c_str());
180 ASSERT_STREQ("", getFakeLogPrint().c_str());
181 }
182
TEST_F(MallocDebugConfigTest,rear_guard)183 TEST_F(MallocDebugConfigTest, rear_guard) {
184 ASSERT_TRUE(InitConfig("rear_guard=50")) << getFakeLogPrint();
185 ASSERT_EQ(REAR_GUARD | TRACK_ALLOCS, config->options());
186 ASSERT_EQ(50U, config->rear_guard_bytes());
187
188 ASSERT_TRUE(InitConfig("rear_guard")) << getFakeLogPrint();
189 ASSERT_EQ(REAR_GUARD | TRACK_ALLOCS, config->options());
190 ASSERT_EQ(32U, config->rear_guard_bytes());
191
192 ASSERT_STREQ("", getFakeLogBuf().c_str());
193 ASSERT_STREQ("", getFakeLogPrint().c_str());
194 }
195
TEST_F(MallocDebugConfigTest,guard)196 TEST_F(MallocDebugConfigTest, guard) {
197 ASSERT_TRUE(InitConfig("guard=32")) << getFakeLogPrint();
198 ASSERT_EQ(FRONT_GUARD | REAR_GUARD | TRACK_ALLOCS, config->options());
199 ASSERT_EQ(32U, config->front_guard_bytes());
200 ASSERT_EQ(32U, config->rear_guard_bytes());
201
202 ASSERT_TRUE(InitConfig("guard")) << getFakeLogPrint();
203 ASSERT_EQ(FRONT_GUARD | REAR_GUARD | TRACK_ALLOCS, config->options());
204 ASSERT_EQ(32U, config->front_guard_bytes());
205 ASSERT_EQ(32U, config->rear_guard_bytes());
206
207 ASSERT_STREQ("", getFakeLogBuf().c_str());
208 ASSERT_STREQ("", getFakeLogPrint().c_str());
209 }
210
TEST_F(MallocDebugConfigTest,backtrace)211 TEST_F(MallocDebugConfigTest, backtrace) {
212 ASSERT_TRUE(InitConfig("backtrace=64")) << getFakeLogPrint();
213 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
214 ASSERT_EQ(64U, config->backtrace_frames());
215 ASSERT_TRUE(config->backtrace_enabled());
216 ASSERT_FALSE(config->backtrace_enable_on_signal());
217 ASSERT_FALSE(config->backtrace_dump_on_exit());
218
219 ASSERT_TRUE(InitConfig("bt=23")) << getFakeLogPrint();
220 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
221 ASSERT_EQ(23U, config->backtrace_frames());
222 ASSERT_TRUE(config->backtrace_enabled());
223 ASSERT_FALSE(config->backtrace_enable_on_signal());
224 ASSERT_FALSE(config->backtrace_dump_on_exit());
225
226 ASSERT_TRUE(InitConfig("backtrace")) << getFakeLogPrint();
227 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
228 ASSERT_EQ(16U, config->backtrace_frames());
229 ASSERT_TRUE(config->backtrace_enabled());
230 ASSERT_FALSE(config->backtrace_enable_on_signal());
231 ASSERT_FALSE(config->backtrace_dump_on_exit());
232
233 ASSERT_TRUE(InitConfig("bt")) << getFakeLogPrint();
234 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
235 ASSERT_EQ(16U, config->backtrace_frames());
236 ASSERT_TRUE(config->backtrace_enabled());
237 ASSERT_FALSE(config->backtrace_enable_on_signal());
238 ASSERT_FALSE(config->backtrace_dump_on_exit());
239
240 ASSERT_STREQ("", getFakeLogBuf().c_str());
241 ASSERT_STREQ("", getFakeLogPrint().c_str());
242 }
243
TEST_F(MallocDebugConfigTest,backtrace_enable_on_signal)244 TEST_F(MallocDebugConfigTest, backtrace_enable_on_signal) {
245 ASSERT_TRUE(InitConfig("backtrace_enable_on_signal=64")) << getFakeLogPrint();
246 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
247 ASSERT_EQ(64U, config->backtrace_frames());
248 ASSERT_FALSE(config->backtrace_enabled());
249 ASSERT_TRUE(config->backtrace_enable_on_signal());
250 ASSERT_FALSE(config->backtrace_dump_on_exit());
251
252 ASSERT_TRUE(InitConfig("bt_en_on_sig=64")) << getFakeLogPrint();
253 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
254 ASSERT_EQ(64U, config->backtrace_frames());
255 ASSERT_FALSE(config->backtrace_enabled());
256 ASSERT_TRUE(config->backtrace_enable_on_signal());
257 ASSERT_FALSE(config->backtrace_dump_on_exit());
258
259 ASSERT_TRUE(InitConfig("backtrace_enable_on_signal")) << getFakeLogPrint();
260 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
261 ASSERT_EQ(16U, config->backtrace_frames());
262 ASSERT_FALSE(config->backtrace_enabled());
263 ASSERT_TRUE(config->backtrace_enable_on_signal());
264 ASSERT_FALSE(config->backtrace_dump_on_exit());
265
266 ASSERT_TRUE(InitConfig("bt_en_on_sig")) << getFakeLogPrint();
267 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
268 ASSERT_EQ(16U, config->backtrace_frames());
269 ASSERT_FALSE(config->backtrace_enabled());
270 ASSERT_TRUE(config->backtrace_enable_on_signal());
271 ASSERT_FALSE(config->backtrace_dump_on_exit());
272
273 ASSERT_STREQ("", getFakeLogBuf().c_str());
274 ASSERT_STREQ("", getFakeLogPrint().c_str());
275 }
276
TEST_F(MallocDebugConfigTest,backtrace_enable_on_signal_init)277 TEST_F(MallocDebugConfigTest, backtrace_enable_on_signal_init) {
278 ASSERT_TRUE(InitConfig("backtrace_enable_on_signal=64")) << getFakeLogPrint();
279 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
280 ASSERT_EQ(64U, config->backtrace_frames());
281 ASSERT_FALSE(config->backtrace_enabled());
282 ASSERT_TRUE(config->backtrace_enable_on_signal());
283 ASSERT_FALSE(config->backtrace_dump_on_exit());
284
285 ASSERT_TRUE(InitConfig("backtrace")) << getFakeLogPrint();
286 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
287 ASSERT_EQ(16U, config->backtrace_frames());
288 ASSERT_TRUE(config->backtrace_enabled());
289 ASSERT_FALSE(config->backtrace_enable_on_signal());
290 ASSERT_FALSE(config->backtrace_dump_on_exit());
291
292 ASSERT_STREQ("", getFakeLogBuf().c_str());
293 ASSERT_STREQ("", getFakeLogPrint().c_str());
294 }
295
TEST_F(MallocDebugConfigTest,backtrace_enable_and_backtrace)296 TEST_F(MallocDebugConfigTest, backtrace_enable_and_backtrace) {
297 ASSERT_TRUE(InitConfig("backtrace_enable_on_signal backtrace")) << getFakeLogPrint();
298 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
299 ASSERT_EQ(16U, config->backtrace_frames());
300 ASSERT_TRUE(config->backtrace_enabled());
301 ASSERT_TRUE(config->backtrace_enable_on_signal());
302 ASSERT_FALSE(config->backtrace_dump_on_exit());
303
304 ASSERT_TRUE(InitConfig("backtrace backtrace_enable_on_signal")) << getFakeLogPrint();
305 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
306 ASSERT_EQ(16U, config->backtrace_frames());
307 ASSERT_TRUE(config->backtrace_enabled());
308 ASSERT_TRUE(config->backtrace_enable_on_signal());
309 ASSERT_FALSE(config->backtrace_dump_on_exit());
310
311 ASSERT_STREQ("", getFakeLogBuf().c_str());
312 ASSERT_STREQ("", getFakeLogPrint().c_str());
313 }
314
TEST_F(MallocDebugConfigTest,backtrace_dump_on_exit)315 TEST_F(MallocDebugConfigTest, backtrace_dump_on_exit) {
316 ASSERT_TRUE(InitConfig("backtrace_dump_on_exit")) << getFakeLogPrint();
317 ASSERT_EQ(0U, config->options());
318 ASSERT_TRUE(config->backtrace_dump_on_exit());
319
320 ASSERT_TRUE(InitConfig("bt_dmp_on_ex")) << getFakeLogPrint();
321 ASSERT_EQ(0U, config->options());
322 ASSERT_TRUE(config->backtrace_dump_on_exit());
323
324 ASSERT_STREQ("", getFakeLogBuf().c_str());
325 ASSERT_STREQ("", getFakeLogPrint().c_str());
326 }
327
TEST_F(MallocDebugConfigTest,backtrace_dump_on_exit_error)328 TEST_F(MallocDebugConfigTest, backtrace_dump_on_exit_error) {
329 ASSERT_FALSE(InitConfig("backtrace_dump_on_exit=something")) << getFakeLogPrint();
330
331 ASSERT_STREQ("", getFakeLogBuf().c_str());
332 std::string log_msg(
333 "6 malloc_debug malloc_testing: value set for option 'backtrace_dump_on_exit' "
334 "which does not take a value\n");
335 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
336 }
337
TEST_F(MallocDebugConfigTest,backtrace_dump_prefix)338 TEST_F(MallocDebugConfigTest, backtrace_dump_prefix) {
339 ASSERT_TRUE(InitConfig("backtrace_dump_prefix")) << getFakeLogPrint();
340 ASSERT_EQ(0U, config->options());
341 ASSERT_EQ("/data/local/tmp/backtrace_heap", config->backtrace_dump_prefix());
342
343 ASSERT_TRUE(InitConfig("bt_dmp_pre")) << getFakeLogPrint();
344 ASSERT_EQ(0U, config->options());
345 ASSERT_EQ("/data/local/tmp/backtrace_heap", config->backtrace_dump_prefix());
346
347 ASSERT_TRUE(InitConfig("backtrace_dump_prefix=/fake/location")) << getFakeLogPrint();
348 ASSERT_EQ(0U, config->options());
349 ASSERT_EQ("/fake/location", config->backtrace_dump_prefix());
350
351 ASSERT_TRUE(InitConfig("bt_dmp_pre=/fake/location")) << getFakeLogPrint();
352 ASSERT_EQ(0U, config->options());
353 ASSERT_EQ("/fake/location", config->backtrace_dump_prefix());
354
355 ASSERT_STREQ("", getFakeLogBuf().c_str());
356 ASSERT_STREQ("", getFakeLogPrint().c_str());
357 }
358
TEST_F(MallocDebugConfigTest,backtrace_full)359 TEST_F(MallocDebugConfigTest, backtrace_full) {
360 ASSERT_TRUE(InitConfig("backtrace_full")) << getFakeLogPrint();
361 ASSERT_EQ(BACKTRACE_FULL, config->options());
362
363 ASSERT_TRUE(InitConfig("bt_full")) << getFakeLogPrint();
364 ASSERT_EQ(BACKTRACE_FULL, config->options());
365
366 ASSERT_STREQ("", getFakeLogBuf().c_str());
367 ASSERT_STREQ("", getFakeLogPrint().c_str());
368 }
369
TEST_F(MallocDebugConfigTest,backtrace_full_fail)370 TEST_F(MallocDebugConfigTest, backtrace_full_fail) {
371 ASSERT_FALSE(InitConfig("backtrace_full=200")) << getFakeLogPrint();
372
373 ASSERT_STREQ("", getFakeLogBuf().c_str());
374 std::string log_msg(
375 "6 malloc_debug malloc_testing: value set for option 'backtrace_full' "
376 "which does not take a value\n");
377 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
378 }
379
TEST_F(MallocDebugConfigTest,fill_on_alloc)380 TEST_F(MallocDebugConfigTest, fill_on_alloc) {
381 ASSERT_TRUE(InitConfig("fill_on_alloc=64")) << getFakeLogPrint();
382 ASSERT_EQ(FILL_ON_ALLOC, config->options());
383 ASSERT_EQ(64U, config->fill_on_alloc_bytes());
384
385 ASSERT_TRUE(InitConfig("fill_on_alloc")) << getFakeLogPrint();
386 ASSERT_EQ(FILL_ON_ALLOC, config->options());
387 ASSERT_EQ(SIZE_MAX, config->fill_on_alloc_bytes());
388
389 ASSERT_STREQ("", getFakeLogBuf().c_str());
390 ASSERT_STREQ("", getFakeLogPrint().c_str());
391 }
392
TEST_F(MallocDebugConfigTest,fill_on_free)393 TEST_F(MallocDebugConfigTest, fill_on_free) {
394 ASSERT_TRUE(InitConfig("fill_on_free=64")) << getFakeLogPrint();
395 ASSERT_EQ(FILL_ON_FREE, config->options());
396 ASSERT_EQ(64U, config->fill_on_free_bytes());
397
398 ASSERT_TRUE(InitConfig("fill_on_free")) << getFakeLogPrint();
399 ASSERT_EQ(FILL_ON_FREE, config->options());
400 ASSERT_EQ(SIZE_MAX, config->fill_on_free_bytes());
401
402 ASSERT_STREQ("", getFakeLogBuf().c_str());
403 ASSERT_STREQ("", getFakeLogPrint().c_str());
404 }
405
TEST_F(MallocDebugConfigTest,fill)406 TEST_F(MallocDebugConfigTest, fill) {
407 ASSERT_TRUE(InitConfig("fill=64")) << getFakeLogPrint();
408 ASSERT_EQ(FILL_ON_ALLOC | FILL_ON_FREE, config->options());
409 ASSERT_EQ(64U, config->fill_on_alloc_bytes());
410 ASSERT_EQ(64U, config->fill_on_free_bytes());
411
412 ASSERT_TRUE(InitConfig("fill")) << getFakeLogPrint();
413 ASSERT_EQ(FILL_ON_ALLOC | FILL_ON_FREE, config->options());
414 ASSERT_EQ(SIZE_MAX, config->fill_on_alloc_bytes());
415 ASSERT_EQ(SIZE_MAX, config->fill_on_free_bytes());
416
417 ASSERT_STREQ("", getFakeLogBuf().c_str());
418 ASSERT_STREQ("", getFakeLogPrint().c_str());
419 }
420
TEST_F(MallocDebugConfigTest,expand_alloc)421 TEST_F(MallocDebugConfigTest, expand_alloc) {
422 ASSERT_TRUE(InitConfig("expand_alloc=1234")) << getFakeLogPrint();
423 ASSERT_EQ(EXPAND_ALLOC, config->options());
424 ASSERT_EQ(1234U, config->expand_alloc_bytes());
425
426 ASSERT_TRUE(InitConfig("expand_alloc")) << getFakeLogPrint();
427 ASSERT_EQ(EXPAND_ALLOC, config->options());
428 ASSERT_EQ(16U, config->expand_alloc_bytes());
429
430 ASSERT_STREQ("", getFakeLogBuf().c_str());
431 ASSERT_STREQ("", getFakeLogPrint().c_str());
432 }
433
TEST_F(MallocDebugConfigTest,free_track)434 TEST_F(MallocDebugConfigTest, free_track) {
435 ASSERT_TRUE(InitConfig("free_track=1234")) << getFakeLogPrint();
436 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE | TRACK_ALLOCS, config->options());
437 ASSERT_EQ(1234U, config->free_track_allocations());
438 ASSERT_EQ(SIZE_MAX, config->fill_on_free_bytes());
439 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
440
441 ASSERT_TRUE(InitConfig("free_track")) << getFakeLogPrint();
442 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE | TRACK_ALLOCS, config->options());
443 ASSERT_EQ(100U, config->free_track_allocations());
444 ASSERT_EQ(SIZE_MAX, config->fill_on_free_bytes());
445 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
446
447 ASSERT_STREQ("", getFakeLogBuf().c_str());
448 ASSERT_STREQ("", getFakeLogPrint().c_str());
449 }
450
TEST_F(MallocDebugConfigTest,free_track_and_fill_on_free)451 TEST_F(MallocDebugConfigTest, free_track_and_fill_on_free) {
452 ASSERT_TRUE(InitConfig("free_track=1234 fill_on_free=32")) << getFakeLogPrint();
453 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE | TRACK_ALLOCS, config->options());
454 ASSERT_EQ(1234U, config->free_track_allocations());
455 ASSERT_EQ(32U, config->fill_on_free_bytes());
456 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
457
458 ASSERT_TRUE(InitConfig("free_track fill_on_free=60")) << getFakeLogPrint();
459 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE | TRACK_ALLOCS, config->options());
460 ASSERT_EQ(100U, config->free_track_allocations());
461 ASSERT_EQ(60U, config->fill_on_free_bytes());
462 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
463
464 // Now reverse the arguments.
465 ASSERT_TRUE(InitConfig("fill_on_free=32 free_track=1234")) << getFakeLogPrint();
466 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE | TRACK_ALLOCS, config->options());
467 ASSERT_EQ(1234U, config->free_track_allocations());
468 ASSERT_EQ(32U, config->fill_on_free_bytes());
469 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
470
471 ASSERT_STREQ("", getFakeLogBuf().c_str());
472 ASSERT_STREQ("", getFakeLogPrint().c_str());
473 }
474
TEST_F(MallocDebugConfigTest,free_track_backtrace_num_frames)475 TEST_F(MallocDebugConfigTest, free_track_backtrace_num_frames) {
476 ASSERT_TRUE(InitConfig("free_track_backtrace_num_frames=123")) << getFakeLogPrint();
477
478 ASSERT_EQ(0U, config->options());
479 ASSERT_EQ(123U, config->free_track_backtrace_num_frames());
480
481 ASSERT_TRUE(InitConfig("free_track_backtrace_num_frames")) << getFakeLogPrint();
482 ASSERT_EQ(0U, config->options());
483 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
484
485 ASSERT_STREQ("", getFakeLogBuf().c_str());
486 ASSERT_STREQ("", getFakeLogPrint().c_str());
487 }
488
TEST_F(MallocDebugConfigTest,free_track_backtrace_num_frames_zero)489 TEST_F(MallocDebugConfigTest, free_track_backtrace_num_frames_zero) {
490 ASSERT_TRUE(InitConfig("free_track_backtrace_num_frames=0")) << getFakeLogPrint();
491
492 ASSERT_EQ(0U, config->options());
493 ASSERT_EQ(0U, config->free_track_backtrace_num_frames());
494
495 ASSERT_STREQ("", getFakeLogBuf().c_str());
496 ASSERT_STREQ("", getFakeLogPrint().c_str());
497 }
498
TEST_F(MallocDebugConfigTest,free_track_backtrace_num_frames_and_free_track)499 TEST_F(MallocDebugConfigTest, free_track_backtrace_num_frames_and_free_track) {
500 ASSERT_TRUE(InitConfig("free_track free_track_backtrace_num_frames=123")) << getFakeLogPrint();
501 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE | TRACK_ALLOCS, config->options());
502 ASSERT_EQ(123U, config->free_track_backtrace_num_frames());
503
504 ASSERT_TRUE(InitConfig("free_track free_track_backtrace_num_frames")) << getFakeLogPrint();
505 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE | TRACK_ALLOCS, config->options());
506 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
507
508 ASSERT_STREQ("", getFakeLogBuf().c_str());
509 ASSERT_STREQ("", getFakeLogPrint().c_str());
510 }
511
TEST_F(MallocDebugConfigTest,leak_track)512 TEST_F(MallocDebugConfigTest, leak_track) {
513 ASSERT_TRUE(InitConfig("leak_track")) << getFakeLogPrint();
514 ASSERT_EQ(LEAK_TRACK | TRACK_ALLOCS, config->options());
515
516 ASSERT_STREQ("", getFakeLogBuf().c_str());
517 ASSERT_STREQ("", getFakeLogPrint().c_str());
518 }
519
TEST_F(MallocDebugConfigTest,leak_track_fail)520 TEST_F(MallocDebugConfigTest, leak_track_fail) {
521 ASSERT_FALSE(InitConfig("leak_track=100")) << getFakeLogPrint();
522
523 ASSERT_STREQ("", getFakeLogBuf().c_str());
524 std::string log_msg(
525 "6 malloc_debug malloc_testing: value set for option 'leak_track' "
526 "which does not take a value\n");
527 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
528 }
529
TEST_F(MallocDebugConfigTest,verify_pointers)530 TEST_F(MallocDebugConfigTest, verify_pointers) {
531 ASSERT_TRUE(InitConfig("verify_pointers")) << getFakeLogPrint();
532 ASSERT_EQ(TRACK_ALLOCS, config->options());
533
534 ASSERT_STREQ("", getFakeLogBuf().c_str());
535 ASSERT_STREQ("", getFakeLogPrint().c_str());
536 }
537
TEST_F(MallocDebugConfigTest,verify_pointers_fail)538 TEST_F(MallocDebugConfigTest, verify_pointers_fail) {
539 ASSERT_FALSE(InitConfig("verify_pointers=200")) << getFakeLogPrint();
540
541 ASSERT_STREQ("", getFakeLogBuf().c_str());
542 std::string log_msg(
543 "6 malloc_debug malloc_testing: value set for option 'verify_pointers' "
544 "which does not take a value\n");
545 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
546 }
547
TEST_F(MallocDebugConfigTest,record_allocs)548 TEST_F(MallocDebugConfigTest, record_allocs) {
549 ASSERT_TRUE(InitConfig("record_allocs=1234")) << getFakeLogPrint();
550 ASSERT_EQ(RECORD_ALLOCS, config->options());
551 ASSERT_EQ(1234U, config->record_allocs_num_entries());
552 ASSERT_STREQ("/data/local/tmp/record_allocs.txt", config->record_allocs_file().c_str());
553
554 ASSERT_TRUE(InitConfig("record_allocs")) << getFakeLogPrint();
555 ASSERT_EQ(RECORD_ALLOCS, config->options());
556 ASSERT_EQ(8000000U, config->record_allocs_num_entries());
557 ASSERT_STREQ("/data/local/tmp/record_allocs.txt", config->record_allocs_file().c_str());
558
559 ASSERT_STREQ("", getFakeLogBuf().c_str());
560 ASSERT_STREQ("", getFakeLogPrint().c_str());
561 }
562
TEST_F(MallocDebugConfigTest,record_allocs_file)563 TEST_F(MallocDebugConfigTest, record_allocs_file) {
564 ASSERT_TRUE(InitConfig("record_allocs=1234 record_allocs_file=/fake/file")) << getFakeLogPrint();
565 ASSERT_STREQ("/fake/file", config->record_allocs_file().c_str());
566
567 ASSERT_TRUE(InitConfig("record_allocs_file")) << getFakeLogPrint();
568 ASSERT_STREQ("/data/local/tmp/record_allocs.txt", config->record_allocs_file().c_str());
569
570 ASSERT_STREQ("", getFakeLogBuf().c_str());
571 ASSERT_STREQ("", getFakeLogPrint().c_str());
572 }
573
TEST_F(MallocDebugConfigTest,record_allocs_on_exit)574 TEST_F(MallocDebugConfigTest, record_allocs_on_exit) {
575 ASSERT_TRUE(InitConfig("record_allocs_on_exit")) << getFakeLogPrint();
576 ASSERT_EQ(0U, config->options());
577 ASSERT_TRUE(config->record_allocs_on_exit());
578
579 ASSERT_STREQ("", getFakeLogBuf().c_str());
580 ASSERT_STREQ("", getFakeLogPrint().c_str());
581 }
582
TEST_F(MallocDebugConfigTest,record_allocs_on_exit_error)583 TEST_F(MallocDebugConfigTest, record_allocs_on_exit_error) {
584 ASSERT_FALSE(InitConfig("record_allocs_on_exit=something")) << getFakeLogPrint();
585
586 ASSERT_STREQ("", getFakeLogBuf().c_str());
587 std::string log_msg(
588 "6 malloc_debug malloc_testing: value set for option 'record_allocs_on_exit' "
589 "which does not take a value\n");
590 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
591 }
592
TEST_F(MallocDebugConfigTest,guard_min_error)593 TEST_F(MallocDebugConfigTest, guard_min_error) {
594 ASSERT_FALSE(InitConfig("guard=0"));
595
596 ASSERT_STREQ("", getFakeLogBuf().c_str());
597 std::string log_msg(
598 "6 malloc_debug malloc_testing: bad value for option 'guard', value must be >= 1: 0\n");
599 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
600 }
601
TEST_F(MallocDebugConfigTest,guard_max_error)602 TEST_F(MallocDebugConfigTest, guard_max_error) {
603 ASSERT_FALSE(InitConfig("guard=20000"));
604
605 ASSERT_STREQ("", getFakeLogBuf().c_str());
606 std::string log_msg(
607 "6 malloc_debug malloc_testing: bad value for option 'guard', "
608 "value must be <= 16384: 20000\n");
609 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
610 }
611
TEST_F(MallocDebugConfigTest,front_guard_min_error)612 TEST_F(MallocDebugConfigTest, front_guard_min_error) {
613 ASSERT_FALSE(InitConfig("front_guard=0"));
614
615 ASSERT_STREQ("", getFakeLogBuf().c_str());
616 std::string log_msg(
617 "6 malloc_debug malloc_testing: bad value for option 'front_guard', "
618 "value must be >= 1: 0\n");
619 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
620 }
621
TEST_F(MallocDebugConfigTest,front_guard_max_error)622 TEST_F(MallocDebugConfigTest, front_guard_max_error) {
623 ASSERT_FALSE(InitConfig("front_guard=20000"));
624
625 ASSERT_STREQ("", getFakeLogBuf().c_str());
626 std::string log_msg(
627 "6 malloc_debug malloc_testing: bad value for option 'front_guard', "
628 "value must be <= 16384: 20000\n");
629 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
630 }
631
TEST_F(MallocDebugConfigTest,rear_guard_min_error)632 TEST_F(MallocDebugConfigTest, rear_guard_min_error) {
633 ASSERT_FALSE(InitConfig("rear_guard=0"));
634
635 ASSERT_STREQ("", getFakeLogBuf().c_str());
636 std::string log_msg(
637 "6 malloc_debug malloc_testing: bad value for option 'rear_guard', "
638 "value must be >= 1: 0\n");
639 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
640 }
641
TEST_F(MallocDebugConfigTest,rear_guard_max_error)642 TEST_F(MallocDebugConfigTest, rear_guard_max_error) {
643 ASSERT_FALSE(InitConfig("rear_guard=20000"));
644
645 ASSERT_STREQ("", getFakeLogBuf().c_str());
646 std::string log_msg(
647 "6 malloc_debug malloc_testing: bad value for option 'rear_guard', "
648 "value must be <= 16384: 20000\n");
649 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
650 }
651
TEST_F(MallocDebugConfigTest,fill_min_error)652 TEST_F(MallocDebugConfigTest, fill_min_error) {
653 ASSERT_FALSE(InitConfig("fill=0"));
654
655 ASSERT_STREQ("", getFakeLogBuf().c_str());
656 std::string log_msg(
657 "6 malloc_debug malloc_testing: bad value for option 'fill', "
658 "value must be >= 1: 0\n");
659 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
660 }
661
TEST_F(MallocDebugConfigTest,fill_on_alloc_min_error)662 TEST_F(MallocDebugConfigTest, fill_on_alloc_min_error) {
663 ASSERT_FALSE(InitConfig("fill_on_alloc=0"));
664
665 ASSERT_STREQ("", getFakeLogBuf().c_str());
666 std::string log_msg(
667 "6 malloc_debug malloc_testing: bad value for option 'fill_on_alloc', "
668 "value must be >= 1: 0\n");
669 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
670 }
671
TEST_F(MallocDebugConfigTest,fill_on_free_min_error)672 TEST_F(MallocDebugConfigTest, fill_on_free_min_error) {
673 ASSERT_FALSE(InitConfig("fill_on_free=0"));
674
675 ASSERT_STREQ("", getFakeLogBuf().c_str());
676 std::string log_msg(
677 "6 malloc_debug malloc_testing: bad value for option 'fill_on_free', "
678 "value must be >= 1: 0\n");
679 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
680 }
681
TEST_F(MallocDebugConfigTest,backtrace_min_error)682 TEST_F(MallocDebugConfigTest, backtrace_min_error) {
683 ASSERT_FALSE(InitConfig("backtrace=0"));
684
685 ASSERT_STREQ("", getFakeLogBuf().c_str());
686 std::string log_msg(
687 "6 malloc_debug malloc_testing: bad value for option 'backtrace', "
688 "value must be >= 1: 0\n");
689 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
690 }
691
TEST_F(MallocDebugConfigTest,backtrace_max_error)692 TEST_F(MallocDebugConfigTest, backtrace_max_error) {
693 ASSERT_FALSE(InitConfig("backtrace=300"));
694
695 ASSERT_STREQ("", getFakeLogBuf().c_str());
696 std::string log_msg(
697 "6 malloc_debug malloc_testing: bad value for option 'backtrace', "
698 "value must be <= 256: 300\n");
699 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
700 }
701
TEST_F(MallocDebugConfigTest,backtrace_enable_on_signal_min_error)702 TEST_F(MallocDebugConfigTest, backtrace_enable_on_signal_min_error) {
703 ASSERT_FALSE(InitConfig("backtrace_enable_on_signal=0"));
704
705 ASSERT_STREQ("", getFakeLogBuf().c_str());
706 std::string log_msg(
707 "6 malloc_debug malloc_testing: bad value for option 'backtrace_enable_on_signal', "
708 "value must be >= 1: 0\n");
709 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
710 }
711
TEST_F(MallocDebugConfigTest,backtrace_enable_on_signal_max_error)712 TEST_F(MallocDebugConfigTest, backtrace_enable_on_signal_max_error) {
713 ASSERT_FALSE(InitConfig("backtrace_enable_on_signal=300"));
714
715 ASSERT_STREQ("", getFakeLogBuf().c_str());
716 std::string log_msg(
717 "6 malloc_debug malloc_testing: bad value for option 'backtrace_enable_on_signal', "
718 "value must be <= 256: 300\n");
719 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
720 }
721
TEST_F(MallocDebugConfigTest,expand_alloc_min_error)722 TEST_F(MallocDebugConfigTest, expand_alloc_min_error) {
723 ASSERT_FALSE(InitConfig("expand_alloc=0"));
724
725 ASSERT_STREQ("", getFakeLogBuf().c_str());
726 std::string log_msg(
727 "6 malloc_debug malloc_testing: bad value for option 'expand_alloc', "
728 "value must be >= 1: 0\n");
729 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
730 }
731
TEST_F(MallocDebugConfigTest,expand_alloc_max_error)732 TEST_F(MallocDebugConfigTest, expand_alloc_max_error) {
733 ASSERT_FALSE(InitConfig("expand_alloc=21000"));
734
735 ASSERT_STREQ("", getFakeLogBuf().c_str());
736 std::string log_msg(
737 "6 malloc_debug malloc_testing: bad value for option 'expand_alloc', "
738 "value must be <= 16384: 21000\n");
739 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
740 }
741
TEST_F(MallocDebugConfigTest,free_track_min_error)742 TEST_F(MallocDebugConfigTest, free_track_min_error) {
743 ASSERT_FALSE(InitConfig("free_track=0"));
744
745 ASSERT_STREQ("", getFakeLogBuf().c_str());
746 std::string log_msg(
747 "6 malloc_debug malloc_testing: bad value for option 'free_track', "
748 "value must be >= 1: 0\n");
749 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
750 }
751
TEST_F(MallocDebugConfigTest,free_track_max_error)752 TEST_F(MallocDebugConfigTest, free_track_max_error) {
753 ASSERT_FALSE(InitConfig("free_track=21000"));
754
755 ASSERT_STREQ("", getFakeLogBuf().c_str());
756 std::string log_msg(
757 "6 malloc_debug malloc_testing: bad value for option 'free_track', "
758 "value must be <= 16384: 21000\n");
759 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
760 }
761
TEST_F(MallocDebugConfigTest,free_track_backtrace_num_frames_max_error)762 TEST_F(MallocDebugConfigTest, free_track_backtrace_num_frames_max_error) {
763 ASSERT_FALSE(InitConfig("free_track_backtrace_num_frames=400"));
764
765 ASSERT_STREQ("", getFakeLogBuf().c_str());
766 std::string log_msg(
767 "6 malloc_debug malloc_testing: bad value for option 'free_track_backtrace_num_frames', "
768 "value must be <= 256: 400\n");
769 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
770 }
771
TEST_F(MallocDebugConfigTest,record_alloc_min_error)772 TEST_F(MallocDebugConfigTest, record_alloc_min_error) {
773 ASSERT_FALSE(InitConfig("record_allocs=0"));
774
775 ASSERT_STREQ("", getFakeLogBuf().c_str());
776 std::string log_msg(
777 "6 malloc_debug malloc_testing: bad value for option 'record_allocs', "
778 "value must be >= 1: 0\n");
779 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
780 }
781
TEST_F(MallocDebugConfigTest,record_allocs_max_error)782 TEST_F(MallocDebugConfigTest, record_allocs_max_error) {
783 ASSERT_FALSE(InitConfig("record_allocs=100000000"));
784
785 ASSERT_STREQ("", getFakeLogBuf().c_str());
786 std::string log_msg(
787 "6 malloc_debug malloc_testing: bad value for option 'record_allocs', "
788 "value must be <= 50000000: 100000000\n");
789 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
790 }
791
TEST_F(MallocDebugConfigTest,abort_on_error)792 TEST_F(MallocDebugConfigTest, abort_on_error) {
793 ASSERT_TRUE(InitConfig("abort_on_error")) << getFakeLogPrint();
794 ASSERT_EQ(ABORT_ON_ERROR, config->options());
795
796 ASSERT_STREQ("", getFakeLogBuf().c_str());
797 ASSERT_STREQ("", getFakeLogPrint().c_str());
798 }
799
TEST_F(MallocDebugConfigTest,trigger_abort_fail)800 TEST_F(MallocDebugConfigTest, trigger_abort_fail) {
801 ASSERT_FALSE(InitConfig("abort_on_error=200")) << getFakeLogPrint();
802
803 ASSERT_STREQ("", getFakeLogBuf().c_str());
804 std::string log_msg(
805 "6 malloc_debug malloc_testing: value set for option 'abort_on_error' "
806 "which does not take a value\n");
807 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
808 }
809
TEST_F(MallocDebugConfigTest,verbose)810 TEST_F(MallocDebugConfigTest, verbose) {
811 ASSERT_TRUE(InitConfig("verbose")) << getFakeLogPrint();
812 ASSERT_EQ(VERBOSE, config->options());
813
814 ASSERT_STREQ("", getFakeLogBuf().c_str());
815 ASSERT_STREQ("", getFakeLogPrint().c_str());
816 }
817
TEST_F(MallocDebugConfigTest,trigger_verbose_fail)818 TEST_F(MallocDebugConfigTest, trigger_verbose_fail) {
819 ASSERT_FALSE(InitConfig("verbose=200")) << getFakeLogPrint();
820
821 ASSERT_STREQ("", getFakeLogBuf().c_str());
822 std::string log_msg(
823 "6 malloc_debug malloc_testing: value set for option 'verbose' "
824 "which does not take a value\n");
825 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
826 }
827
TEST_F(MallocDebugConfigTest,check_unreachable_on_signal)828 TEST_F(MallocDebugConfigTest, check_unreachable_on_signal) {
829 ASSERT_TRUE(InitConfig("check_unreachable_on_signal")) << getFakeLogPrint();
830 ASSERT_EQ(CHECK_UNREACHABLE_ON_SIGNAL, config->options());
831
832 ASSERT_STREQ("", getFakeLogBuf().c_str());
833 ASSERT_STREQ("", getFakeLogPrint().c_str());
834 }
835
TEST_F(MallocDebugConfigTest,trigger_check_unreachable_on_signal_fail)836 TEST_F(MallocDebugConfigTest, trigger_check_unreachable_on_signal_fail) {
837 ASSERT_FALSE(InitConfig("check_unreachable_on_signal=200")) << getFakeLogPrint();
838
839 ASSERT_STREQ("", getFakeLogBuf().c_str());
840 std::string log_msg(
841 "6 malloc_debug malloc_testing: value set for option 'check_unreachable_on_signal' "
842 "which does not take a value\n");
843 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
844 }
845
TEST_F(MallocDebugConfigTest,log_allocator_stats_on_signal)846 TEST_F(MallocDebugConfigTest, log_allocator_stats_on_signal) {
847 ASSERT_TRUE(InitConfig("log_allocator_stats_on_signal")) << getFakeLogPrint();
848 ASSERT_EQ(LOG_ALLOCATOR_STATS_ON_SIGNAL, config->options());
849
850 ASSERT_STREQ("", getFakeLogBuf().c_str());
851 ASSERT_STREQ("", getFakeLogPrint().c_str());
852 }
853
TEST_F(MallocDebugConfigTest,trigger_log_allocator_stats_on_signal_fail)854 TEST_F(MallocDebugConfigTest, trigger_log_allocator_stats_on_signal_fail) {
855 ASSERT_FALSE(InitConfig("log_allocator_stats_on_signal=200")) << getFakeLogPrint();
856
857 ASSERT_STREQ("", getFakeLogBuf().c_str());
858 std::string log_msg(
859 "6 malloc_debug malloc_testing: value set for option 'log_allocator_stats_on_signal' "
860 "which does not take a value\n");
861 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
862 }
863
TEST_F(MallocDebugConfigTest,log_allocator_stats_on_exit)864 TEST_F(MallocDebugConfigTest, log_allocator_stats_on_exit) {
865 ASSERT_TRUE(InitConfig("log_allocator_stats_on_exit")) << getFakeLogPrint();
866 ASSERT_EQ(LOG_ALLOCATOR_STATS_ON_EXIT, config->options());
867
868 ASSERT_STREQ("", getFakeLogBuf().c_str());
869 ASSERT_STREQ("", getFakeLogPrint().c_str());
870 }
871
TEST_F(MallocDebugConfigTest,trigger_log_allocator_stats_on_exit_fail)872 TEST_F(MallocDebugConfigTest, trigger_log_allocator_stats_on_exit_fail) {
873 ASSERT_FALSE(InitConfig("log_allocator_stats_on_exit=200")) << getFakeLogPrint();
874
875 ASSERT_STREQ("", getFakeLogBuf().c_str());
876 std::string log_msg(
877 "6 malloc_debug malloc_testing: value set for option 'log_allocator_stats_on_exit' "
878 "which does not take a value\n");
879 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
880 }
881
TEST_F(MallocDebugConfigTest,size)882 TEST_F(MallocDebugConfigTest, size) {
883 ASSERT_TRUE(InitConfig("backtrace_size=37")) << getFakeLogPrint();
884 ASSERT_EQ(BACKTRACE_SPECIFIC_SIZES, config->options());
885 ASSERT_EQ(37U, config->backtrace_min_size_bytes());
886 ASSERT_EQ(37U, config->backtrace_max_size_bytes());
887
888 ASSERT_TRUE(InitConfig("bt_sz=39")) << getFakeLogPrint();
889 ASSERT_EQ(BACKTRACE_SPECIFIC_SIZES, config->options());
890 ASSERT_EQ(39U, config->backtrace_min_size_bytes());
891 ASSERT_EQ(39U, config->backtrace_max_size_bytes());
892
893 ASSERT_FALSE(InitConfig("backtrace_size")) << getFakeLogPrint();
894 ASSERT_FALSE(InitConfig("backtrace_size=0")) << getFakeLogPrint();
895 ASSERT_FALSE(InitConfig("backtrace_size=-1")) << getFakeLogPrint();
896
897 ASSERT_STREQ("", getFakeLogBuf().c_str());
898 std::string log_msg("6 malloc_debug malloc_testing: bad value for option 'backtrace_size'\n" +
899 usage_string +
900 "6 malloc_debug malloc_testing: bad value for option 'backtrace_size', value "
901 "must be >= 1: 0\n" +
902 usage_string +
903 "6 malloc_debug malloc_testing: bad value for option 'backtrace_size', value "
904 "cannot be negative: -1\n" +
905 usage_string);
906 ASSERT_STREQ(log_msg.c_str(), getFakeLogPrint().c_str());
907 }
908
TEST_F(MallocDebugConfigTest,min_size)909 TEST_F(MallocDebugConfigTest, min_size) {
910 ASSERT_TRUE(InitConfig("backtrace_min_size=9")) << getFakeLogPrint();
911 ASSERT_EQ(BACKTRACE_SPECIFIC_SIZES, config->options());
912 ASSERT_EQ(9U, config->backtrace_min_size_bytes());
913 ASSERT_EQ(SIZE_MAX, config->backtrace_max_size_bytes());
914
915 ASSERT_TRUE(InitConfig("bt_min_sz=11")) << getFakeLogPrint();
916 ASSERT_EQ(BACKTRACE_SPECIFIC_SIZES, config->options());
917 ASSERT_EQ(11U, config->backtrace_min_size_bytes());
918 ASSERT_EQ(SIZE_MAX, config->backtrace_max_size_bytes());
919
920 ASSERT_FALSE(InitConfig("backtrace_min_size")) << getFakeLogPrint();
921 ASSERT_FALSE(InitConfig("backtrace_min_size=0")) << getFakeLogPrint();
922 ASSERT_FALSE(InitConfig("backtrace_min_size=-1")) << getFakeLogPrint();
923
924 ASSERT_STREQ("", getFakeLogBuf().c_str());
925 std::string log_msg("6 malloc_debug malloc_testing: bad value for option 'backtrace_min_size'\n" +
926 usage_string +
927 "6 malloc_debug malloc_testing: bad value for option 'backtrace_min_size', "
928 "value must be >= 1: 0\n" +
929 usage_string +
930 "6 malloc_debug malloc_testing: bad value for option 'backtrace_min_size', "
931 "value cannot be negative: -1\n" +
932 usage_string);
933 ASSERT_STREQ(log_msg.c_str(), getFakeLogPrint().c_str());
934 }
935
TEST_F(MallocDebugConfigTest,max_size)936 TEST_F(MallocDebugConfigTest, max_size) {
937 ASSERT_TRUE(InitConfig("backtrace_max_size=13")) << getFakeLogPrint();
938 ASSERT_EQ(BACKTRACE_SPECIFIC_SIZES, config->options());
939 ASSERT_EQ(0U, config->backtrace_min_size_bytes());
940 ASSERT_EQ(13U, config->backtrace_max_size_bytes());
941
942 ASSERT_TRUE(InitConfig("bt_max_sz=15")) << getFakeLogPrint();
943 ASSERT_EQ(BACKTRACE_SPECIFIC_SIZES, config->options());
944 ASSERT_EQ(0U, config->backtrace_min_size_bytes());
945 ASSERT_EQ(15U, config->backtrace_max_size_bytes());
946
947 ASSERT_FALSE(InitConfig("backtrace_max_size")) << getFakeLogPrint();
948 ASSERT_FALSE(InitConfig("backtrace_max_size=0")) << getFakeLogPrint();
949 ASSERT_FALSE(InitConfig("backtrace_max_size=-1")) << getFakeLogPrint();
950
951 ASSERT_STREQ("", getFakeLogBuf().c_str());
952 std::string log_msg("6 malloc_debug malloc_testing: bad value for option 'backtrace_max_size'\n" +
953 usage_string +
954 "6 malloc_debug malloc_testing: bad value for option 'backtrace_max_size', "
955 "value must be >= 1: 0\n" +
956 usage_string +
957 "6 malloc_debug malloc_testing: bad value for option 'backtrace_max_size', "
958 "value cannot be negative: -1\n" +
959 usage_string);
960 ASSERT_STREQ(log_msg.c_str(), getFakeLogPrint().c_str());
961 }
962