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 malloc debug options usage:\n"
44 "6 malloc_debug \n"
45 "6 malloc_debug front_guard[=XX]\n"
46 "6 malloc_debug Enables a front guard on all allocations. If XX is set\n"
47 "6 malloc_debug it sets the number of bytes in the guard. The default is\n"
48 "6 malloc_debug 32 bytes, the max bytes is 16384.\n"
49 "6 malloc_debug \n"
50 "6 malloc_debug rear_guard[=XX]\n"
51 "6 malloc_debug Enables a rear guard on all allocations. If XX is set\n"
52 "6 malloc_debug it sets the number of bytes in the guard. The default is\n"
53 "6 malloc_debug 32 bytes, the max bytes is 16384.\n"
54 "6 malloc_debug \n"
55 "6 malloc_debug guard[=XX]\n"
56 "6 malloc_debug Enables both a front guard and a rear guard on all allocations.\n"
57 "6 malloc_debug If XX is set it sets the number of bytes in both guards.\n"
58 "6 malloc_debug The default is 32 bytes, the max bytes is 16384.\n"
59 "6 malloc_debug \n"
60 "6 malloc_debug backtrace[=XX]\n"
61 "6 malloc_debug Enable capturing the backtrace at the point of allocation.\n"
62 "6 malloc_debug If XX is set it sets the number of backtrace frames.\n"
63 "6 malloc_debug The default is 16 frames, the max number of frames is 256.\n"
64 "6 malloc_debug \n"
65 "6 malloc_debug backtrace_enable_on_signal[=XX]\n"
66 "6 malloc_debug Enable capturing the backtrace at the point of allocation.\n"
67 "6 malloc_debug The backtrace capture is not enabled until the process\n"
68 "6 malloc_debug receives a signal. If XX is set it sets the number of backtrace\n"
69 "6 malloc_debug frames. The default is 16 frames, the max number of frames is 256.\n"
70 "6 malloc_debug \n"
71 "6 malloc_debug fill_on_alloc[=XX]\n"
72 "6 malloc_debug On first allocation, fill with the value 0xeb.\n"
73 "6 malloc_debug If XX is set it will only fill up to XX bytes of the\n"
74 "6 malloc_debug allocation. The default is to fill the entire allocation.\n"
75 "6 malloc_debug \n"
76 "6 malloc_debug fill_on_free[=XX]\n"
77 "6 malloc_debug On free, fill with the value 0xef. If XX is set it will\n"
78 "6 malloc_debug only fill up to XX bytes of the allocation. The default is to\n"
79 "6 malloc_debug fill the entire allocation.\n"
80 "6 malloc_debug \n"
81 "6 malloc_debug fill[=XX]\n"
82 "6 malloc_debug On both first allocation free, fill with the value 0xeb on\n"
83 "6 malloc_debug first allocation and the value 0xef. If XX is set, only fill\n"
84 "6 malloc_debug up to XX bytes. The default is to fill the entire allocation.\n"
85 "6 malloc_debug \n"
86 "6 malloc_debug expand_alloc[=XX]\n"
87 "6 malloc_debug Allocate an extra number of bytes for every allocation call.\n"
88 "6 malloc_debug If XX is set, that is the number of bytes to expand the\n"
89 "6 malloc_debug allocation by. The default is 16 bytes, the max bytes is 16384.\n"
90 "6 malloc_debug \n"
91 "6 malloc_debug free_track[=XX]\n"
92 "6 malloc_debug When a pointer is freed, do not free the memory right away.\n"
93 "6 malloc_debug Instead, keep XX of these allocations around and then verify\n"
94 "6 malloc_debug that they have not been modified when the total number of freed\n"
95 "6 malloc_debug allocations exceeds the XX amount. When the program terminates,\n"
96 "6 malloc_debug the rest of these allocations are verified. When this option is\n"
97 "6 malloc_debug enabled, it automatically records the backtrace at the time of the free.\n"
98 "6 malloc_debug The default is to record 100 allocations, the max allocations\n"
99 "6 malloc_debug to record is 16384.\n"
100 "6 malloc_debug \n"
101 "6 malloc_debug free_track_backtrace_num_frames[=XX]\n"
102 "6 malloc_debug This option only has meaning if free_track is set. This indicates\n"
103 "6 malloc_debug how many backtrace frames to capture when an allocation is freed.\n"
104 "6 malloc_debug If XX is set, that is the number of frames to capture. If XX\n"
105 "6 malloc_debug is set to zero, then no backtrace will be captured.\n"
106 "6 malloc_debug The default is to record 16 frames, the max number of frames is 256.\n"
107 "6 malloc_debug \n"
108 "6 malloc_debug leak_track\n"
109 "6 malloc_debug Enable the leak tracking of memory allocations.\n"
110 "6 malloc_debug \n"
111 "6 malloc_debug record_allocs[=XX]\n"
112 "6 malloc_debug Record every single allocation/free call. When a specific signal\n"
113 "6 malloc_debug is sent to the process, the contents of recording are written to\n"
114 "6 malloc_debug a file (/data/local/tmp/record_allocs.txt) and the recording is cleared.\n"
115 "6 malloc_debug If XX is set, that is the total number of allocations/frees that can\n"
116 "6 malloc_debug recorded. of frames to capture. The default value is 8000000.\n"
117 "6 malloc_debug If the allocation list fills up, all further allocations are not recorded.\n"
118 "6 malloc_debug \n"
119 "6 malloc_debug record_allocs_file[=FILE]\n"
120 "6 malloc_debug This option only has meaning if the record_allocs options has been specified.\n"
121 "6 malloc_debug This is the name of the file to which recording information will be dumped.\n"
122 "6 malloc_debug The default is /data/local/tmp/record_allocs.txt.\n"
123 );
124
TEST_F(MallocDebugConfigTest,unknown_option)125 TEST_F(MallocDebugConfigTest, unknown_option) {
126
127 ASSERT_FALSE(InitConfig("unknown_option"));
128
129 ASSERT_STREQ("", getFakeLogBuf().c_str());
130 std::string log_msg("6 malloc_debug malloc_testing: unknown option unknown_option\n");
131 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
132 }
133
TEST_F(MallocDebugConfigTest,good_option_and_bad_option)134 TEST_F(MallocDebugConfigTest, good_option_and_bad_option) {
135 ASSERT_FALSE(InitConfig("backtrace unknown_option"));
136
137 ASSERT_STREQ("", getFakeLogBuf().c_str());
138 std::string log_msg("6 malloc_debug malloc_testing: unknown option unknown_option\n");
139 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
140 }
141
TEST_F(MallocDebugConfigTest,unparseable_number)142 TEST_F(MallocDebugConfigTest, unparseable_number) {
143 ASSERT_FALSE(InitConfig("backtrace=XXX"));
144
145 ASSERT_STREQ("", getFakeLogBuf().c_str());
146 std::string log_msg("6 malloc_debug malloc_testing: bad value for option 'backtrace'\n");
147 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
148 }
149
TEST_F(MallocDebugConfigTest,illegal_value_zero)150 TEST_F(MallocDebugConfigTest, illegal_value_zero) {
151 ASSERT_FALSE(InitConfig("backtrace=0"));
152
153 ASSERT_STREQ("", getFakeLogBuf().c_str());
154 std::string log_msg(
155 "6 malloc_debug malloc_testing: bad value for option 'backtrace', value must be >= 1: 0\n");
156 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
157 }
158
TEST_F(MallocDebugConfigTest,no_space)159 TEST_F(MallocDebugConfigTest, no_space) {
160 ASSERT_FALSE(InitConfig("backtrace=10front_guard"));
161
162 ASSERT_STREQ("", getFakeLogBuf().c_str());
163 std::string log_msg(
164 "6 malloc_debug malloc_testing: bad value for option 'backtrace', "
165 "non space found after option: front_guard\n");
166 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
167 }
168
TEST_F(MallocDebugConfigTest,illegal_value_negative)169 TEST_F(MallocDebugConfigTest, illegal_value_negative) {
170 ASSERT_FALSE(InitConfig("backtrace=-1"));
171
172 ASSERT_STREQ("", getFakeLogBuf().c_str());
173 std::string log_msg(
174 "6 malloc_debug malloc_testing: bad value for option 'backtrace', "
175 "value cannot be negative: -1\n");
176 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
177 }
178
TEST_F(MallocDebugConfigTest,overflow)179 TEST_F(MallocDebugConfigTest, overflow) {
180 ASSERT_FALSE(InitConfig("backtrace=99999999999999999999"));
181
182 ASSERT_STREQ("", getFakeLogBuf().c_str());
183 std::string log_msg(
184 "6 malloc_debug malloc_testing: bad value for option 'backtrace': "
185 "Math result not representable\n");
186 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
187 }
188
TEST_F(MallocDebugConfigTest,set_value_error)189 TEST_F(MallocDebugConfigTest, set_value_error) {
190 ASSERT_FALSE(InitConfig("leak_track=12"));
191
192 ASSERT_STREQ("", getFakeLogBuf().c_str());
193 std::string log_msg(
194 "6 malloc_debug malloc_testing: value set for option 'leak_track' "
195 "which does not take a value\n");
196 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
197 }
198
TEST_F(MallocDebugConfigTest,space_before_equal)199 TEST_F(MallocDebugConfigTest, space_before_equal) {
200 ASSERT_TRUE(InitConfig("backtrace =10")) << getFakeLogPrint();
201 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
202 ASSERT_EQ(10U, config->backtrace_frames());
203
204 ASSERT_STREQ("", getFakeLogBuf().c_str());
205 ASSERT_STREQ("", getFakeLogPrint().c_str());
206 }
207
TEST_F(MallocDebugConfigTest,space_after_equal)208 TEST_F(MallocDebugConfigTest, space_after_equal) {
209 ASSERT_TRUE(InitConfig("backtrace= 10")) << getFakeLogPrint();
210 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
211 ASSERT_EQ(10U, config->backtrace_frames());
212
213 ASSERT_STREQ("", getFakeLogBuf().c_str());
214 ASSERT_STREQ("", getFakeLogPrint().c_str());
215 }
216
TEST_F(MallocDebugConfigTest,extra_space)217 TEST_F(MallocDebugConfigTest, extra_space) {
218 ASSERT_TRUE(InitConfig(" backtrace=64 ")) << getFakeLogPrint();
219 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
220 ASSERT_EQ(64U, config->backtrace_frames());
221
222 ASSERT_STREQ("", getFakeLogBuf().c_str());
223 ASSERT_STREQ("", getFakeLogPrint().c_str());
224 }
225
TEST_F(MallocDebugConfigTest,multiple_options)226 TEST_F(MallocDebugConfigTest, multiple_options) {
227 ASSERT_TRUE(InitConfig(" backtrace=64 front_guard=48")) << getFakeLogPrint();
228 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS | FRONT_GUARD, config->options());
229 ASSERT_EQ(64U, config->backtrace_frames());
230 ASSERT_EQ(48U, config->front_guard_bytes());
231
232 ASSERT_STREQ("", getFakeLogBuf().c_str());
233 ASSERT_STREQ("", getFakeLogPrint().c_str());
234 }
235
TEST_F(MallocDebugConfigTest,front_guard)236 TEST_F(MallocDebugConfigTest, front_guard) {
237 ASSERT_TRUE(InitConfig("front_guard=48")) << getFakeLogPrint();
238 ASSERT_EQ(FRONT_GUARD, config->options());
239 ASSERT_EQ(48U, config->front_guard_bytes());
240
241 ASSERT_TRUE(InitConfig("front_guard")) << getFakeLogPrint();
242 ASSERT_EQ(FRONT_GUARD, config->options());
243 ASSERT_EQ(32U, config->front_guard_bytes());
244
245 ASSERT_TRUE(InitConfig("front_guard=39")) << getFakeLogPrint();
246 ASSERT_EQ(FRONT_GUARD, config->options());
247 #if defined(__LP64__)
248 ASSERT_EQ(48U, config->front_guard_bytes());
249 #else
250 ASSERT_EQ(40U, config->front_guard_bytes());
251 #endif
252
253 ASSERT_TRUE(InitConfig("front_guard=41")) << getFakeLogPrint();
254 ASSERT_EQ(FRONT_GUARD, config->options());
255 ASSERT_EQ(48U, config->front_guard_bytes());
256
257 ASSERT_STREQ("", getFakeLogBuf().c_str());
258 ASSERT_STREQ("", getFakeLogPrint().c_str());
259 }
260
TEST_F(MallocDebugConfigTest,rear_guard)261 TEST_F(MallocDebugConfigTest, rear_guard) {
262 ASSERT_TRUE(InitConfig("rear_guard=50")) << getFakeLogPrint();
263 ASSERT_EQ(REAR_GUARD, config->options());
264 ASSERT_EQ(50U, config->rear_guard_bytes());
265
266 ASSERT_TRUE(InitConfig("rear_guard")) << getFakeLogPrint();
267 ASSERT_EQ(REAR_GUARD, config->options());
268 ASSERT_EQ(32U, config->rear_guard_bytes());
269
270 ASSERT_STREQ("", getFakeLogBuf().c_str());
271 ASSERT_STREQ("", getFakeLogPrint().c_str());
272 }
273
TEST_F(MallocDebugConfigTest,guard)274 TEST_F(MallocDebugConfigTest, guard) {
275 ASSERT_TRUE(InitConfig("guard=32")) << getFakeLogPrint();
276 ASSERT_EQ(FRONT_GUARD | REAR_GUARD, config->options());
277 ASSERT_EQ(32U, config->front_guard_bytes());
278 ASSERT_EQ(32U, config->rear_guard_bytes());
279
280 ASSERT_TRUE(InitConfig("guard")) << getFakeLogPrint();
281 ASSERT_EQ(FRONT_GUARD | REAR_GUARD, config->options());
282 ASSERT_EQ(32U, config->front_guard_bytes());
283 ASSERT_EQ(32U, config->rear_guard_bytes());
284
285 ASSERT_STREQ("", getFakeLogBuf().c_str());
286 ASSERT_STREQ("", getFakeLogPrint().c_str());
287 }
288
TEST_F(MallocDebugConfigTest,backtrace)289 TEST_F(MallocDebugConfigTest, backtrace) {
290 ASSERT_TRUE(InitConfig("backtrace=64")) << getFakeLogPrint();
291 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
292 ASSERT_EQ(64U, config->backtrace_frames());
293 ASSERT_TRUE(config->backtrace_enabled());
294 ASSERT_FALSE(config->backtrace_enable_on_signal());
295
296 ASSERT_TRUE(InitConfig("backtrace")) << getFakeLogPrint();
297 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
298 ASSERT_EQ(16U, config->backtrace_frames());
299 ASSERT_TRUE(config->backtrace_enabled());
300 ASSERT_FALSE(config->backtrace_enable_on_signal());
301
302 ASSERT_STREQ("", getFakeLogBuf().c_str());
303 ASSERT_STREQ("", getFakeLogPrint().c_str());
304 }
305
TEST_F(MallocDebugConfigTest,backtrace_enable_on_signal)306 TEST_F(MallocDebugConfigTest, backtrace_enable_on_signal) {
307 ASSERT_TRUE(InitConfig("backtrace_enable_on_signal=64")) << getFakeLogPrint();
308 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
309 ASSERT_EQ(64U, config->backtrace_frames());
310 ASSERT_FALSE(config->backtrace_enabled());
311 ASSERT_TRUE(config->backtrace_enable_on_signal());
312
313 ASSERT_TRUE(InitConfig("backtrace_enable_on_signal")) << getFakeLogPrint();
314 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
315 ASSERT_EQ(16U, config->backtrace_frames());
316 ASSERT_FALSE(config->backtrace_enabled());
317 ASSERT_TRUE(config->backtrace_enable_on_signal());
318
319 ASSERT_STREQ("", getFakeLogBuf().c_str());
320 ASSERT_STREQ("", getFakeLogPrint().c_str());
321 }
322
TEST_F(MallocDebugConfigTest,backtrace_enable_on_signal_init)323 TEST_F(MallocDebugConfigTest, backtrace_enable_on_signal_init) {
324 ASSERT_TRUE(InitConfig("backtrace_enable_on_signal=64")) << getFakeLogPrint();
325 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
326 ASSERT_EQ(64U, config->backtrace_frames());
327 ASSERT_FALSE(config->backtrace_enabled());
328 ASSERT_TRUE(config->backtrace_enable_on_signal());
329
330 ASSERT_TRUE(InitConfig("backtrace")) << getFakeLogPrint();
331 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
332 ASSERT_EQ(16U, config->backtrace_frames());
333 ASSERT_TRUE(config->backtrace_enabled());
334 ASSERT_FALSE(config->backtrace_enable_on_signal());
335
336 ASSERT_STREQ("", getFakeLogBuf().c_str());
337 ASSERT_STREQ("", getFakeLogPrint().c_str());
338 }
339
TEST_F(MallocDebugConfigTest,backtrace_enable_and_backtrace)340 TEST_F(MallocDebugConfigTest, backtrace_enable_and_backtrace) {
341 ASSERT_TRUE(InitConfig("backtrace_enable_on_signal backtrace")) << getFakeLogPrint();
342 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
343 ASSERT_EQ(16U, config->backtrace_frames());
344 ASSERT_TRUE(config->backtrace_enabled());
345 ASSERT_TRUE(config->backtrace_enable_on_signal());
346
347 ASSERT_TRUE(InitConfig("backtrace backtrace_enable_on_signal")) << getFakeLogPrint();
348 ASSERT_EQ(BACKTRACE | TRACK_ALLOCS, config->options());
349 ASSERT_EQ(16U, config->backtrace_frames());
350 ASSERT_TRUE(config->backtrace_enabled());
351 ASSERT_TRUE(config->backtrace_enable_on_signal());
352
353 ASSERT_STREQ("", getFakeLogBuf().c_str());
354 ASSERT_STREQ("", getFakeLogPrint().c_str());
355 }
356
TEST_F(MallocDebugConfigTest,fill_on_alloc)357 TEST_F(MallocDebugConfigTest, fill_on_alloc) {
358 ASSERT_TRUE(InitConfig("fill_on_alloc=64")) << getFakeLogPrint();
359 ASSERT_EQ(FILL_ON_ALLOC, config->options());
360 ASSERT_EQ(64U, config->fill_on_alloc_bytes());
361
362 ASSERT_TRUE(InitConfig("fill_on_alloc")) << getFakeLogPrint();
363 ASSERT_EQ(FILL_ON_ALLOC, config->options());
364 ASSERT_EQ(SIZE_MAX, config->fill_on_alloc_bytes());
365
366 ASSERT_STREQ("", getFakeLogBuf().c_str());
367 ASSERT_STREQ("", getFakeLogPrint().c_str());
368 }
369
TEST_F(MallocDebugConfigTest,fill_on_free)370 TEST_F(MallocDebugConfigTest, fill_on_free) {
371 ASSERT_TRUE(InitConfig("fill_on_free=64")) << getFakeLogPrint();
372 ASSERT_EQ(FILL_ON_FREE, config->options());
373 ASSERT_EQ(64U, config->fill_on_free_bytes());
374
375 ASSERT_TRUE(InitConfig("fill_on_free")) << getFakeLogPrint();
376 ASSERT_EQ(FILL_ON_FREE, config->options());
377 ASSERT_EQ(SIZE_MAX, config->fill_on_free_bytes());
378
379 ASSERT_STREQ("", getFakeLogBuf().c_str());
380 ASSERT_STREQ("", getFakeLogPrint().c_str());
381 }
382
TEST_F(MallocDebugConfigTest,fill)383 TEST_F(MallocDebugConfigTest, fill) {
384 ASSERT_TRUE(InitConfig("fill=64")) << getFakeLogPrint();
385 ASSERT_EQ(FILL_ON_ALLOC | FILL_ON_FREE, config->options());
386 ASSERT_EQ(64U, config->fill_on_alloc_bytes());
387 ASSERT_EQ(64U, config->fill_on_free_bytes());
388
389 ASSERT_TRUE(InitConfig("fill")) << getFakeLogPrint();
390 ASSERT_EQ(FILL_ON_ALLOC | FILL_ON_FREE, config->options());
391 ASSERT_EQ(SIZE_MAX, config->fill_on_alloc_bytes());
392 ASSERT_EQ(SIZE_MAX, config->fill_on_free_bytes());
393
394 ASSERT_STREQ("", getFakeLogBuf().c_str());
395 ASSERT_STREQ("", getFakeLogPrint().c_str());
396 }
397
TEST_F(MallocDebugConfigTest,expand_alloc)398 TEST_F(MallocDebugConfigTest, expand_alloc) {
399 ASSERT_TRUE(InitConfig("expand_alloc=1234")) << getFakeLogPrint();
400 ASSERT_EQ(EXPAND_ALLOC, config->options());
401 ASSERT_EQ(1234U, config->expand_alloc_bytes());
402
403 ASSERT_TRUE(InitConfig("expand_alloc")) << getFakeLogPrint();
404 ASSERT_EQ(EXPAND_ALLOC, config->options());
405 ASSERT_EQ(16U, config->expand_alloc_bytes());
406
407 ASSERT_STREQ("", getFakeLogBuf().c_str());
408 ASSERT_STREQ("", getFakeLogPrint().c_str());
409 }
410
TEST_F(MallocDebugConfigTest,free_track)411 TEST_F(MallocDebugConfigTest, free_track) {
412 ASSERT_TRUE(InitConfig("free_track=1234")) << getFakeLogPrint();
413 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE, config->options());
414 ASSERT_EQ(1234U, config->free_track_allocations());
415 ASSERT_EQ(SIZE_MAX, config->fill_on_free_bytes());
416 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
417
418 ASSERT_TRUE(InitConfig("free_track")) << getFakeLogPrint();
419 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE, config->options());
420 ASSERT_EQ(100U, config->free_track_allocations());
421 ASSERT_EQ(SIZE_MAX, config->fill_on_free_bytes());
422 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
423
424 ASSERT_STREQ("", getFakeLogBuf().c_str());
425 ASSERT_STREQ("", getFakeLogPrint().c_str());
426 }
427
TEST_F(MallocDebugConfigTest,free_track_and_fill_on_free)428 TEST_F(MallocDebugConfigTest, free_track_and_fill_on_free) {
429 ASSERT_TRUE(InitConfig("free_track=1234 fill_on_free=32")) << getFakeLogPrint();
430 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE, config->options());
431 ASSERT_EQ(1234U, config->free_track_allocations());
432 ASSERT_EQ(32U, config->fill_on_free_bytes());
433 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
434
435 ASSERT_TRUE(InitConfig("free_track fill_on_free=60")) << getFakeLogPrint();
436 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE, config->options());
437 ASSERT_EQ(100U, config->free_track_allocations());
438 ASSERT_EQ(60U, config->fill_on_free_bytes());
439 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
440
441 // Now reverse the arguments.
442 ASSERT_TRUE(InitConfig("fill_on_free=32 free_track=1234")) << getFakeLogPrint();
443 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE, config->options());
444 ASSERT_EQ(1234U, config->free_track_allocations());
445 ASSERT_EQ(32U, config->fill_on_free_bytes());
446 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
447
448 ASSERT_STREQ("", getFakeLogBuf().c_str());
449 ASSERT_STREQ("", getFakeLogPrint().c_str());
450 }
451
TEST_F(MallocDebugConfigTest,free_track_backtrace_num_frames)452 TEST_F(MallocDebugConfigTest, free_track_backtrace_num_frames) {
453 ASSERT_TRUE(InitConfig("free_track_backtrace_num_frames=123")) << getFakeLogPrint();
454
455 ASSERT_EQ(0U, config->options());
456 ASSERT_EQ(123U, config->free_track_backtrace_num_frames());
457
458 ASSERT_TRUE(InitConfig("free_track_backtrace_num_frames")) << getFakeLogPrint();
459 ASSERT_EQ(0U, config->options());
460 ASSERT_EQ(16U, config->free_track_backtrace_num_frames());
461
462 ASSERT_STREQ("", getFakeLogBuf().c_str());
463 ASSERT_STREQ("", getFakeLogPrint().c_str());
464 }
465
TEST_F(MallocDebugConfigTest,free_track_backtrace_num_frames_zero)466 TEST_F(MallocDebugConfigTest, free_track_backtrace_num_frames_zero) {
467 ASSERT_TRUE(InitConfig("free_track_backtrace_num_frames=0")) << getFakeLogPrint();
468
469 ASSERT_EQ(0U, config->options());
470 ASSERT_EQ(0U, config->free_track_backtrace_num_frames());
471
472 ASSERT_STREQ("", getFakeLogBuf().c_str());
473 ASSERT_STREQ("", getFakeLogPrint().c_str());
474 }
475
TEST_F(MallocDebugConfigTest,free_track_backtrace_num_frames_and_free_track)476 TEST_F(MallocDebugConfigTest, free_track_backtrace_num_frames_and_free_track) {
477 ASSERT_TRUE(InitConfig("free_track free_track_backtrace_num_frames=123")) << getFakeLogPrint();
478 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE, config->options());
479 ASSERT_EQ(123U, config->free_track_backtrace_num_frames());
480
481 ASSERT_TRUE(InitConfig("free_track free_track_backtrace_num_frames")) << getFakeLogPrint();
482 ASSERT_EQ(FREE_TRACK | FILL_ON_FREE, 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,leak_track)489 TEST_F(MallocDebugConfigTest, leak_track) {
490 ASSERT_TRUE(InitConfig("leak_track")) << getFakeLogPrint();
491 ASSERT_EQ(LEAK_TRACK | TRACK_ALLOCS, config->options());
492
493 ASSERT_STREQ("", getFakeLogBuf().c_str());
494 ASSERT_STREQ("", getFakeLogPrint().c_str());
495 }
496
TEST_F(MallocDebugConfigTest,leak_track_fail)497 TEST_F(MallocDebugConfigTest, leak_track_fail) {
498 ASSERT_FALSE(InitConfig("leak_track=100")) << getFakeLogPrint();
499
500 ASSERT_STREQ("", getFakeLogBuf().c_str());
501 std::string log_msg(
502 "6 malloc_debug malloc_testing: value set for option 'leak_track' "
503 "which does not take a value\n");
504 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
505 }
506
TEST_F(MallocDebugConfigTest,record_allocs)507 TEST_F(MallocDebugConfigTest, record_allocs) {
508 ASSERT_TRUE(InitConfig("record_allocs=1234")) << getFakeLogPrint();
509 ASSERT_EQ(RECORD_ALLOCS, config->options());
510 ASSERT_EQ(1234U, config->record_allocs_num_entries());
511 ASSERT_STREQ("/data/local/tmp/record_allocs.txt", config->record_allocs_file().c_str());
512
513 ASSERT_TRUE(InitConfig("record_allocs")) << getFakeLogPrint();
514 ASSERT_EQ(RECORD_ALLOCS, config->options());
515 ASSERT_EQ(8000000U, config->record_allocs_num_entries());
516 ASSERT_STREQ("/data/local/tmp/record_allocs.txt", config->record_allocs_file().c_str());
517
518 ASSERT_STREQ("", getFakeLogBuf().c_str());
519 ASSERT_STREQ("", getFakeLogPrint().c_str());
520 }
521
TEST_F(MallocDebugConfigTest,record_allocs_file)522 TEST_F(MallocDebugConfigTest, record_allocs_file) {
523 ASSERT_TRUE(InitConfig("record_allocs=1234 record_allocs_file=/fake/file")) << getFakeLogPrint();
524 ASSERT_STREQ("/fake/file", config->record_allocs_file().c_str());
525
526 ASSERT_TRUE(InitConfig("record_allocs_file")) << getFakeLogPrint();
527 ASSERT_STREQ("/data/local/tmp/record_allocs.txt", config->record_allocs_file().c_str());
528
529 ASSERT_STREQ("", getFakeLogBuf().c_str());
530 ASSERT_STREQ("", getFakeLogPrint().c_str());
531 }
532
TEST_F(MallocDebugConfigTest,guard_min_error)533 TEST_F(MallocDebugConfigTest, guard_min_error) {
534 ASSERT_FALSE(InitConfig("guard=0"));
535
536 ASSERT_STREQ("", getFakeLogBuf().c_str());
537 std::string log_msg(
538 "6 malloc_debug malloc_testing: bad value for option 'guard', value must be >= 1: 0\n");
539 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
540 }
541
TEST_F(MallocDebugConfigTest,guard_max_error)542 TEST_F(MallocDebugConfigTest, guard_max_error) {
543 ASSERT_FALSE(InitConfig("guard=20000"));
544
545 ASSERT_STREQ("", getFakeLogBuf().c_str());
546 std::string log_msg(
547 "6 malloc_debug malloc_testing: bad value for option 'guard', "
548 "value must be <= 16384: 20000\n");
549 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
550 }
551
TEST_F(MallocDebugConfigTest,front_guard_min_error)552 TEST_F(MallocDebugConfigTest, front_guard_min_error) {
553 ASSERT_FALSE(InitConfig("front_guard=0"));
554
555 ASSERT_STREQ("", getFakeLogBuf().c_str());
556 std::string log_msg(
557 "6 malloc_debug malloc_testing: bad value for option 'front_guard', "
558 "value must be >= 1: 0\n");
559 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
560 }
561
TEST_F(MallocDebugConfigTest,front_guard_max_error)562 TEST_F(MallocDebugConfigTest, front_guard_max_error) {
563 ASSERT_FALSE(InitConfig("front_guard=20000"));
564
565 ASSERT_STREQ("", getFakeLogBuf().c_str());
566 std::string log_msg(
567 "6 malloc_debug malloc_testing: bad value for option 'front_guard', "
568 "value must be <= 16384: 20000\n");
569 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
570 }
571
TEST_F(MallocDebugConfigTest,rear_guard_min_error)572 TEST_F(MallocDebugConfigTest, rear_guard_min_error) {
573 ASSERT_FALSE(InitConfig("rear_guard=0"));
574
575 ASSERT_STREQ("", getFakeLogBuf().c_str());
576 std::string log_msg(
577 "6 malloc_debug malloc_testing: bad value for option 'rear_guard', "
578 "value must be >= 1: 0\n");
579 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
580 }
581
TEST_F(MallocDebugConfigTest,rear_guard_max_error)582 TEST_F(MallocDebugConfigTest, rear_guard_max_error) {
583 ASSERT_FALSE(InitConfig("rear_guard=20000"));
584
585 ASSERT_STREQ("", getFakeLogBuf().c_str());
586 std::string log_msg(
587 "6 malloc_debug malloc_testing: bad value for option 'rear_guard', "
588 "value must be <= 16384: 20000\n");
589 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
590 }
591
TEST_F(MallocDebugConfigTest,fill_min_error)592 TEST_F(MallocDebugConfigTest, fill_min_error) {
593 ASSERT_FALSE(InitConfig("fill=0"));
594
595 ASSERT_STREQ("", getFakeLogBuf().c_str());
596 std::string log_msg(
597 "6 malloc_debug malloc_testing: bad value for option 'fill', "
598 "value must be >= 1: 0\n");
599 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
600 }
601
TEST_F(MallocDebugConfigTest,fill_on_alloc_min_error)602 TEST_F(MallocDebugConfigTest, fill_on_alloc_min_error) {
603 ASSERT_FALSE(InitConfig("fill_on_alloc=0"));
604
605 ASSERT_STREQ("", getFakeLogBuf().c_str());
606 std::string log_msg(
607 "6 malloc_debug malloc_testing: bad value for option 'fill_on_alloc', "
608 "value must be >= 1: 0\n");
609 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
610 }
611
TEST_F(MallocDebugConfigTest,fill_on_free_min_error)612 TEST_F(MallocDebugConfigTest, fill_on_free_min_error) {
613 ASSERT_FALSE(InitConfig("fill_on_free=0"));
614
615 ASSERT_STREQ("", getFakeLogBuf().c_str());
616 std::string log_msg(
617 "6 malloc_debug malloc_testing: bad value for option 'fill_on_free', "
618 "value must be >= 1: 0\n");
619 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
620 }
621
TEST_F(MallocDebugConfigTest,backtrace_min_error)622 TEST_F(MallocDebugConfigTest, backtrace_min_error) {
623 ASSERT_FALSE(InitConfig("backtrace=0"));
624
625 ASSERT_STREQ("", getFakeLogBuf().c_str());
626 std::string log_msg(
627 "6 malloc_debug malloc_testing: bad value for option 'backtrace', "
628 "value must be >= 1: 0\n");
629 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
630 }
631
TEST_F(MallocDebugConfigTest,backtrace_max_error)632 TEST_F(MallocDebugConfigTest, backtrace_max_error) {
633 ASSERT_FALSE(InitConfig("backtrace=300"));
634
635 ASSERT_STREQ("", getFakeLogBuf().c_str());
636 std::string log_msg(
637 "6 malloc_debug malloc_testing: bad value for option 'backtrace', "
638 "value must be <= 256: 300\n");
639 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
640 }
641
TEST_F(MallocDebugConfigTest,backtrace_enable_on_signal_min_error)642 TEST_F(MallocDebugConfigTest, backtrace_enable_on_signal_min_error) {
643 ASSERT_FALSE(InitConfig("backtrace_enable_on_signal=0"));
644
645 ASSERT_STREQ("", getFakeLogBuf().c_str());
646 std::string log_msg(
647 "6 malloc_debug malloc_testing: bad value for option 'backtrace_enable_on_signal', "
648 "value must be >= 1: 0\n");
649 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
650 }
651
TEST_F(MallocDebugConfigTest,backtrace_enable_on_signal_max_error)652 TEST_F(MallocDebugConfigTest, backtrace_enable_on_signal_max_error) {
653 ASSERT_FALSE(InitConfig("backtrace_enable_on_signal=300"));
654
655 ASSERT_STREQ("", getFakeLogBuf().c_str());
656 std::string log_msg(
657 "6 malloc_debug malloc_testing: bad value for option 'backtrace_enable_on_signal', "
658 "value must be <= 256: 300\n");
659 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
660 }
661
TEST_F(MallocDebugConfigTest,expand_alloc_min_error)662 TEST_F(MallocDebugConfigTest, expand_alloc_min_error) {
663 ASSERT_FALSE(InitConfig("expand_alloc=0"));
664
665 ASSERT_STREQ("", getFakeLogBuf().c_str());
666 std::string log_msg(
667 "6 malloc_debug malloc_testing: bad value for option 'expand_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,expand_alloc_max_error)672 TEST_F(MallocDebugConfigTest, expand_alloc_max_error) {
673 ASSERT_FALSE(InitConfig("expand_alloc=21000"));
674
675 ASSERT_STREQ("", getFakeLogBuf().c_str());
676 std::string log_msg(
677 "6 malloc_debug malloc_testing: bad value for option 'expand_alloc', "
678 "value must be <= 16384: 21000\n");
679 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
680 }
681
TEST_F(MallocDebugConfigTest,free_track_min_error)682 TEST_F(MallocDebugConfigTest, free_track_min_error) {
683 ASSERT_FALSE(InitConfig("free_track=0"));
684
685 ASSERT_STREQ("", getFakeLogBuf().c_str());
686 std::string log_msg(
687 "6 malloc_debug malloc_testing: bad value for option 'free_track', "
688 "value must be >= 1: 0\n");
689 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
690 }
691
TEST_F(MallocDebugConfigTest,free_track_max_error)692 TEST_F(MallocDebugConfigTest, free_track_max_error) {
693 ASSERT_FALSE(InitConfig("free_track=21000"));
694
695 ASSERT_STREQ("", getFakeLogBuf().c_str());
696 std::string log_msg(
697 "6 malloc_debug malloc_testing: bad value for option 'free_track', "
698 "value must be <= 16384: 21000\n");
699 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
700 }
701
TEST_F(MallocDebugConfigTest,free_track_backtrace_num_frames_max_error)702 TEST_F(MallocDebugConfigTest, free_track_backtrace_num_frames_max_error) {
703 ASSERT_FALSE(InitConfig("free_track_backtrace_num_frames=400"));
704
705 ASSERT_STREQ("", getFakeLogBuf().c_str());
706 std::string log_msg(
707 "6 malloc_debug malloc_testing: bad value for option 'free_track_backtrace_num_frames', "
708 "value must be <= 256: 400\n");
709 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
710 }
711
TEST_F(MallocDebugConfigTest,record_alloc_min_error)712 TEST_F(MallocDebugConfigTest, record_alloc_min_error) {
713 ASSERT_FALSE(InitConfig("record_allocs=0"));
714
715 ASSERT_STREQ("", getFakeLogBuf().c_str());
716 std::string log_msg(
717 "6 malloc_debug malloc_testing: bad value for option 'record_allocs', "
718 "value must be >= 1: 0\n");
719 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
720 }
721
TEST_F(MallocDebugConfigTest,record_allocs_max_error)722 TEST_F(MallocDebugConfigTest, record_allocs_max_error) {
723 ASSERT_FALSE(InitConfig("record_allocs=100000000"));
724
725 ASSERT_STREQ("", getFakeLogBuf().c_str());
726 std::string log_msg(
727 "6 malloc_debug malloc_testing: bad value for option 'record_allocs', "
728 "value must be <= 50000000: 100000000\n");
729 ASSERT_STREQ((log_msg + usage_string).c_str(), getFakeLogPrint().c_str());
730 }
731