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,guard_min_error)574 TEST_F(MallocDebugConfigTest, guard_min_error) {
575 ASSERT_FALSE(InitConfig("guard=0"));
576
577 ASSERT_STREQ("", getFakeLogBuf().c_str());
578 std::string log_msg(
579 "6 malloc_debug malloc_testing: bad value for option 'guard', value must be >= 1: 0\n");
580 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
581 }
582
TEST_F(MallocDebugConfigTest,guard_max_error)583 TEST_F(MallocDebugConfigTest, guard_max_error) {
584 ASSERT_FALSE(InitConfig("guard=20000"));
585
586 ASSERT_STREQ("", getFakeLogBuf().c_str());
587 std::string log_msg(
588 "6 malloc_debug malloc_testing: bad value for option 'guard', "
589 "value must be <= 16384: 20000\n");
590 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
591 }
592
TEST_F(MallocDebugConfigTest,front_guard_min_error)593 TEST_F(MallocDebugConfigTest, front_guard_min_error) {
594 ASSERT_FALSE(InitConfig("front_guard=0"));
595
596 ASSERT_STREQ("", getFakeLogBuf().c_str());
597 std::string log_msg(
598 "6 malloc_debug malloc_testing: bad value for option 'front_guard', "
599 "value must be >= 1: 0\n");
600 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
601 }
602
TEST_F(MallocDebugConfigTest,front_guard_max_error)603 TEST_F(MallocDebugConfigTest, front_guard_max_error) {
604 ASSERT_FALSE(InitConfig("front_guard=20000"));
605
606 ASSERT_STREQ("", getFakeLogBuf().c_str());
607 std::string log_msg(
608 "6 malloc_debug malloc_testing: bad value for option 'front_guard', "
609 "value must be <= 16384: 20000\n");
610 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
611 }
612
TEST_F(MallocDebugConfigTest,rear_guard_min_error)613 TEST_F(MallocDebugConfigTest, rear_guard_min_error) {
614 ASSERT_FALSE(InitConfig("rear_guard=0"));
615
616 ASSERT_STREQ("", getFakeLogBuf().c_str());
617 std::string log_msg(
618 "6 malloc_debug malloc_testing: bad value for option 'rear_guard', "
619 "value must be >= 1: 0\n");
620 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
621 }
622
TEST_F(MallocDebugConfigTest,rear_guard_max_error)623 TEST_F(MallocDebugConfigTest, rear_guard_max_error) {
624 ASSERT_FALSE(InitConfig("rear_guard=20000"));
625
626 ASSERT_STREQ("", getFakeLogBuf().c_str());
627 std::string log_msg(
628 "6 malloc_debug malloc_testing: bad value for option 'rear_guard', "
629 "value must be <= 16384: 20000\n");
630 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
631 }
632
TEST_F(MallocDebugConfigTest,fill_min_error)633 TEST_F(MallocDebugConfigTest, fill_min_error) {
634 ASSERT_FALSE(InitConfig("fill=0"));
635
636 ASSERT_STREQ("", getFakeLogBuf().c_str());
637 std::string log_msg(
638 "6 malloc_debug malloc_testing: bad value for option 'fill', "
639 "value must be >= 1: 0\n");
640 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
641 }
642
TEST_F(MallocDebugConfigTest,fill_on_alloc_min_error)643 TEST_F(MallocDebugConfigTest, fill_on_alloc_min_error) {
644 ASSERT_FALSE(InitConfig("fill_on_alloc=0"));
645
646 ASSERT_STREQ("", getFakeLogBuf().c_str());
647 std::string log_msg(
648 "6 malloc_debug malloc_testing: bad value for option 'fill_on_alloc', "
649 "value must be >= 1: 0\n");
650 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
651 }
652
TEST_F(MallocDebugConfigTest,fill_on_free_min_error)653 TEST_F(MallocDebugConfigTest, fill_on_free_min_error) {
654 ASSERT_FALSE(InitConfig("fill_on_free=0"));
655
656 ASSERT_STREQ("", getFakeLogBuf().c_str());
657 std::string log_msg(
658 "6 malloc_debug malloc_testing: bad value for option 'fill_on_free', "
659 "value must be >= 1: 0\n");
660 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
661 }
662
TEST_F(MallocDebugConfigTest,backtrace_min_error)663 TEST_F(MallocDebugConfigTest, backtrace_min_error) {
664 ASSERT_FALSE(InitConfig("backtrace=0"));
665
666 ASSERT_STREQ("", getFakeLogBuf().c_str());
667 std::string log_msg(
668 "6 malloc_debug malloc_testing: bad value for option 'backtrace', "
669 "value must be >= 1: 0\n");
670 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
671 }
672
TEST_F(MallocDebugConfigTest,backtrace_max_error)673 TEST_F(MallocDebugConfigTest, backtrace_max_error) {
674 ASSERT_FALSE(InitConfig("backtrace=300"));
675
676 ASSERT_STREQ("", getFakeLogBuf().c_str());
677 std::string log_msg(
678 "6 malloc_debug malloc_testing: bad value for option 'backtrace', "
679 "value must be <= 256: 300\n");
680 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
681 }
682
TEST_F(MallocDebugConfigTest,backtrace_enable_on_signal_min_error)683 TEST_F(MallocDebugConfigTest, backtrace_enable_on_signal_min_error) {
684 ASSERT_FALSE(InitConfig("backtrace_enable_on_signal=0"));
685
686 ASSERT_STREQ("", getFakeLogBuf().c_str());
687 std::string log_msg(
688 "6 malloc_debug malloc_testing: bad value for option 'backtrace_enable_on_signal', "
689 "value must be >= 1: 0\n");
690 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
691 }
692
TEST_F(MallocDebugConfigTest,backtrace_enable_on_signal_max_error)693 TEST_F(MallocDebugConfigTest, backtrace_enable_on_signal_max_error) {
694 ASSERT_FALSE(InitConfig("backtrace_enable_on_signal=300"));
695
696 ASSERT_STREQ("", getFakeLogBuf().c_str());
697 std::string log_msg(
698 "6 malloc_debug malloc_testing: bad value for option 'backtrace_enable_on_signal', "
699 "value must be <= 256: 300\n");
700 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
701 }
702
TEST_F(MallocDebugConfigTest,expand_alloc_min_error)703 TEST_F(MallocDebugConfigTest, expand_alloc_min_error) {
704 ASSERT_FALSE(InitConfig("expand_alloc=0"));
705
706 ASSERT_STREQ("", getFakeLogBuf().c_str());
707 std::string log_msg(
708 "6 malloc_debug malloc_testing: bad value for option 'expand_alloc', "
709 "value must be >= 1: 0\n");
710 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
711 }
712
TEST_F(MallocDebugConfigTest,expand_alloc_max_error)713 TEST_F(MallocDebugConfigTest, expand_alloc_max_error) {
714 ASSERT_FALSE(InitConfig("expand_alloc=21000"));
715
716 ASSERT_STREQ("", getFakeLogBuf().c_str());
717 std::string log_msg(
718 "6 malloc_debug malloc_testing: bad value for option 'expand_alloc', "
719 "value must be <= 16384: 21000\n");
720 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
721 }
722
TEST_F(MallocDebugConfigTest,free_track_min_error)723 TEST_F(MallocDebugConfigTest, free_track_min_error) {
724 ASSERT_FALSE(InitConfig("free_track=0"));
725
726 ASSERT_STREQ("", getFakeLogBuf().c_str());
727 std::string log_msg(
728 "6 malloc_debug malloc_testing: bad value for option 'free_track', "
729 "value must be >= 1: 0\n");
730 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
731 }
732
TEST_F(MallocDebugConfigTest,free_track_max_error)733 TEST_F(MallocDebugConfigTest, free_track_max_error) {
734 ASSERT_FALSE(InitConfig("free_track=21000"));
735
736 ASSERT_STREQ("", getFakeLogBuf().c_str());
737 std::string log_msg(
738 "6 malloc_debug malloc_testing: bad value for option 'free_track', "
739 "value must be <= 16384: 21000\n");
740 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
741 }
742
TEST_F(MallocDebugConfigTest,free_track_backtrace_num_frames_max_error)743 TEST_F(MallocDebugConfigTest, free_track_backtrace_num_frames_max_error) {
744 ASSERT_FALSE(InitConfig("free_track_backtrace_num_frames=400"));
745
746 ASSERT_STREQ("", getFakeLogBuf().c_str());
747 std::string log_msg(
748 "6 malloc_debug malloc_testing: bad value for option 'free_track_backtrace_num_frames', "
749 "value must be <= 256: 400\n");
750 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
751 }
752
TEST_F(MallocDebugConfigTest,record_alloc_min_error)753 TEST_F(MallocDebugConfigTest, record_alloc_min_error) {
754 ASSERT_FALSE(InitConfig("record_allocs=0"));
755
756 ASSERT_STREQ("", getFakeLogBuf().c_str());
757 std::string log_msg(
758 "6 malloc_debug malloc_testing: bad value for option 'record_allocs', "
759 "value must be >= 1: 0\n");
760 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
761 }
762
TEST_F(MallocDebugConfigTest,record_allocs_max_error)763 TEST_F(MallocDebugConfigTest, record_allocs_max_error) {
764 ASSERT_FALSE(InitConfig("record_allocs=100000000"));
765
766 ASSERT_STREQ("", getFakeLogBuf().c_str());
767 std::string log_msg(
768 "6 malloc_debug malloc_testing: bad value for option 'record_allocs', "
769 "value must be <= 50000000: 100000000\n");
770 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
771 }
772
TEST_F(MallocDebugConfigTest,abort_on_error)773 TEST_F(MallocDebugConfigTest, abort_on_error) {
774 ASSERT_TRUE(InitConfig("abort_on_error")) << getFakeLogPrint();
775 ASSERT_EQ(ABORT_ON_ERROR, config->options());
776
777 ASSERT_STREQ("", getFakeLogBuf().c_str());
778 ASSERT_STREQ("", getFakeLogPrint().c_str());
779 }
780
TEST_F(MallocDebugConfigTest,trigger_abort_fail)781 TEST_F(MallocDebugConfigTest, trigger_abort_fail) {
782 ASSERT_FALSE(InitConfig("abort_on_error=200")) << getFakeLogPrint();
783
784 ASSERT_STREQ("", getFakeLogBuf().c_str());
785 std::string log_msg(
786 "6 malloc_debug malloc_testing: value set for option 'abort_on_error' "
787 "which does not take a value\n");
788 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
789 }
790
TEST_F(MallocDebugConfigTest,verbose)791 TEST_F(MallocDebugConfigTest, verbose) {
792 ASSERT_TRUE(InitConfig("verbose")) << getFakeLogPrint();
793 ASSERT_EQ(VERBOSE, config->options());
794
795 ASSERT_STREQ("", getFakeLogBuf().c_str());
796 ASSERT_STREQ("", getFakeLogPrint().c_str());
797 }
798
TEST_F(MallocDebugConfigTest,trigger_verbose_fail)799 TEST_F(MallocDebugConfigTest, trigger_verbose_fail) {
800 ASSERT_FALSE(InitConfig("verbose=200")) << getFakeLogPrint();
801
802 ASSERT_STREQ("", getFakeLogBuf().c_str());
803 std::string log_msg(
804 "6 malloc_debug malloc_testing: value set for option 'verbose' "
805 "which does not take a value\n");
806 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
807 }
808
TEST_F(MallocDebugConfigTest,check_unreachable_on_signal)809 TEST_F(MallocDebugConfigTest, check_unreachable_on_signal) {
810 ASSERT_TRUE(InitConfig("check_unreachable_on_signal")) << getFakeLogPrint();
811 ASSERT_EQ(CHECK_UNREACHABLE_ON_SIGNAL, config->options());
812
813 ASSERT_STREQ("", getFakeLogBuf().c_str());
814 ASSERT_STREQ("", getFakeLogPrint().c_str());
815 }
816
TEST_F(MallocDebugConfigTest,trigger_check_unreachable_on_signal_fail)817 TEST_F(MallocDebugConfigTest, trigger_check_unreachable_on_signal_fail) {
818 ASSERT_FALSE(InitConfig("check_unreachable_on_signal=200")) << getFakeLogPrint();
819
820 ASSERT_STREQ("", getFakeLogBuf().c_str());
821 std::string log_msg(
822 "6 malloc_debug malloc_testing: value set for option 'check_unreachable_on_signal' "
823 "which does not take a value\n");
824 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
825 }
826
TEST_F(MallocDebugConfigTest,log_allocator_stats_on_signal)827 TEST_F(MallocDebugConfigTest, log_allocator_stats_on_signal) {
828 ASSERT_TRUE(InitConfig("log_allocator_stats_on_signal")) << getFakeLogPrint();
829 ASSERT_EQ(LOG_ALLOCATOR_STATS_ON_SIGNAL, config->options());
830
831 ASSERT_STREQ("", getFakeLogBuf().c_str());
832 ASSERT_STREQ("", getFakeLogPrint().c_str());
833 }
834
TEST_F(MallocDebugConfigTest,trigger_log_allocator_stats_on_signal_fail)835 TEST_F(MallocDebugConfigTest, trigger_log_allocator_stats_on_signal_fail) {
836 ASSERT_FALSE(InitConfig("log_allocator_stats_on_signal=200")) << getFakeLogPrint();
837
838 ASSERT_STREQ("", getFakeLogBuf().c_str());
839 std::string log_msg(
840 "6 malloc_debug malloc_testing: value set for option 'log_allocator_stats_on_signal' "
841 "which does not take a value\n");
842 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
843 }
844
TEST_F(MallocDebugConfigTest,size)845 TEST_F(MallocDebugConfigTest, size) {
846 ASSERT_TRUE(InitConfig("backtrace_size=37")) << getFakeLogPrint();
847 ASSERT_EQ(BACKTRACE_SPECIFIC_SIZES, config->options());
848 ASSERT_EQ(37U, config->backtrace_min_size_bytes());
849 ASSERT_EQ(37U, config->backtrace_max_size_bytes());
850
851 ASSERT_TRUE(InitConfig("bt_sz=39")) << getFakeLogPrint();
852 ASSERT_EQ(BACKTRACE_SPECIFIC_SIZES, config->options());
853 ASSERT_EQ(39U, config->backtrace_min_size_bytes());
854 ASSERT_EQ(39U, config->backtrace_max_size_bytes());
855
856 ASSERT_FALSE(InitConfig("backtrace_size")) << getFakeLogPrint();
857 ASSERT_FALSE(InitConfig("backtrace_size=0")) << getFakeLogPrint();
858 ASSERT_FALSE(InitConfig("backtrace_size=-1")) << getFakeLogPrint();
859
860 ASSERT_STREQ("", getFakeLogBuf().c_str());
861 std::string log_msg("6 malloc_debug malloc_testing: bad value for option 'backtrace_size'\n" +
862 usage_string +
863 "6 malloc_debug malloc_testing: bad value for option 'backtrace_size', value "
864 "must be >= 1: 0\n" +
865 usage_string +
866 "6 malloc_debug malloc_testing: bad value for option 'backtrace_size', value "
867 "cannot be negative: -1\n" +
868 usage_string);
869 ASSERT_STREQ(log_msg.c_str(), getFakeLogPrint().c_str());
870 }
871
TEST_F(MallocDebugConfigTest,min_size)872 TEST_F(MallocDebugConfigTest, min_size) {
873 ASSERT_TRUE(InitConfig("backtrace_min_size=9")) << getFakeLogPrint();
874 ASSERT_EQ(BACKTRACE_SPECIFIC_SIZES, config->options());
875 ASSERT_EQ(9U, config->backtrace_min_size_bytes());
876 ASSERT_EQ(SIZE_MAX, config->backtrace_max_size_bytes());
877
878 ASSERT_TRUE(InitConfig("bt_min_sz=11")) << getFakeLogPrint();
879 ASSERT_EQ(BACKTRACE_SPECIFIC_SIZES, config->options());
880 ASSERT_EQ(11U, config->backtrace_min_size_bytes());
881 ASSERT_EQ(SIZE_MAX, config->backtrace_max_size_bytes());
882
883 ASSERT_FALSE(InitConfig("backtrace_min_size")) << getFakeLogPrint();
884 ASSERT_FALSE(InitConfig("backtrace_min_size=0")) << getFakeLogPrint();
885 ASSERT_FALSE(InitConfig("backtrace_min_size=-1")) << getFakeLogPrint();
886
887 ASSERT_STREQ("", getFakeLogBuf().c_str());
888 std::string log_msg("6 malloc_debug malloc_testing: bad value for option 'backtrace_min_size'\n" +
889 usage_string +
890 "6 malloc_debug malloc_testing: bad value for option 'backtrace_min_size', "
891 "value must be >= 1: 0\n" +
892 usage_string +
893 "6 malloc_debug malloc_testing: bad value for option 'backtrace_min_size', "
894 "value cannot be negative: -1\n" +
895 usage_string);
896 ASSERT_STREQ(log_msg.c_str(), getFakeLogPrint().c_str());
897 }
898
TEST_F(MallocDebugConfigTest,max_size)899 TEST_F(MallocDebugConfigTest, max_size) {
900 ASSERT_TRUE(InitConfig("backtrace_max_size=13")) << getFakeLogPrint();
901 ASSERT_EQ(BACKTRACE_SPECIFIC_SIZES, config->options());
902 ASSERT_EQ(0U, config->backtrace_min_size_bytes());
903 ASSERT_EQ(13U, config->backtrace_max_size_bytes());
904
905 ASSERT_TRUE(InitConfig("bt_max_sz=15")) << getFakeLogPrint();
906 ASSERT_EQ(BACKTRACE_SPECIFIC_SIZES, config->options());
907 ASSERT_EQ(0U, config->backtrace_min_size_bytes());
908 ASSERT_EQ(15U, config->backtrace_max_size_bytes());
909
910 ASSERT_FALSE(InitConfig("backtrace_max_size")) << getFakeLogPrint();
911 ASSERT_FALSE(InitConfig("backtrace_max_size=0")) << getFakeLogPrint();
912 ASSERT_FALSE(InitConfig("backtrace_max_size=-1")) << getFakeLogPrint();
913
914 ASSERT_STREQ("", getFakeLogBuf().c_str());
915 std::string log_msg("6 malloc_debug malloc_testing: bad value for option 'backtrace_max_size'\n" +
916 usage_string +
917 "6 malloc_debug malloc_testing: bad value for option 'backtrace_max_size', "
918 "value must be >= 1: 0\n" +
919 usage_string +
920 "6 malloc_debug malloc_testing: bad value for option 'backtrace_max_size', "
921 "value cannot be negative: -1\n" +
922 usage_string);
923 ASSERT_STREQ(log_msg.c_str(), getFakeLogPrint().c_str());
924 }
925