Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / system / core / 27b282c33b3bc78f08f528d71897dc962a72adb0 / . / libcutils / trace-dev_test.cpp
blob: 841674a99efbe37e99e0155b49b4f2c5e25f2ae0 [file] [log] [blame]
Christopher Ferris626efb72016-02-23 18:02:20 -0800[diff] [blame]1/*
2 * Copyright (C) 2016 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 <sys/types.h>
18#include <unistd.h>
19
20#include <memory>
21#include <string>
22
23#include <android-base/file.h>
24#include <android-base/stringprintf.h>
Christopher Ferris626efb72016-02-23 18:02:20 -0800[diff] [blame]25#include <gtest/gtest.h>
26
Elliott Hughes8e9aeb92017-11-10 10:22:07 -0800[diff] [blame]27#include "../trace-dev.cpp"
Christopher Ferris626efb72016-02-23 18:02:20 -0800[diff] [blame]28
29class TraceDevTest : public ::testing::Test {
30 protected:
31 void SetUp() override {
32 lseek(tmp_file_.fd, 0, SEEK_SET);
33 atrace_marker_fd = tmp_file_.fd;
34 }
35
36 void TearDown() override {
37 atrace_marker_fd = -1;
38 }
39
40 TemporaryFile tmp_file_;
41
42 static std::string MakeName(size_t length) {
43 std::string name;
44 for (size_t i = 0; i < length; i++) {
45 name += '0' + (i % 10);
46 }
47 return name;
48 }
49};
50
51TEST_F(TraceDevTest, atrace_begin_body_normal) {
52 atrace_begin_body("fake_name");
53
54 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
55
56 std::string actual;
57 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
58 std::string expected = android::base::StringPrintf("B|%d|fake_name", getpid());
59 ASSERT_STREQ(expected.c_str(), actual.c_str());
60}
61
62TEST_F(TraceDevTest, atrace_begin_body_exact) {
63 std::string expected = android::base::StringPrintf("B|%d|", getpid());
64 std::string name = MakeName(ATRACE_MESSAGE_LENGTH - expected.length() - 1);
65 atrace_begin_body(name.c_str());
66
67 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
68 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
69
70 std::string actual;
71 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
72 expected += name;
73 ASSERT_STREQ(expected.c_str(), actual.c_str());
74
75 // Add a single character and verify we get the exact same value as before.
76 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
77 name += '*';
78 atrace_begin_body(name.c_str());
79 EXPECT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
80 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
81 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
82 ASSERT_STREQ(expected.c_str(), actual.c_str());
83}
84
85TEST_F(TraceDevTest, atrace_begin_body_truncated) {
86 std::string expected = android::base::StringPrintf("B|%d|", getpid());
87 std::string name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
88 atrace_begin_body(name.c_str());
89
90 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
91 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
92
93 std::string actual;
94 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
95 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 1;
96 expected += android::base::StringPrintf("%.*s", expected_len, name.c_str());
97 ASSERT_STREQ(expected.c_str(), actual.c_str());
98}
99
100TEST_F(TraceDevTest, atrace_async_begin_body_normal) {
101 atrace_async_begin_body("fake_name", 12345);
102
103 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
104
105 std::string actual;
106 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
107 std::string expected = android::base::StringPrintf("S|%d|fake_name|12345", getpid());
108 ASSERT_STREQ(expected.c_str(), actual.c_str());
109}
110
111TEST_F(TraceDevTest, atrace_async_begin_body_exact) {
112 std::string expected = android::base::StringPrintf("S|%d|", getpid());
113 std::string name = MakeName(ATRACE_MESSAGE_LENGTH - expected.length() - 7);
114 atrace_async_begin_body(name.c_str(), 12345);
115
116 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
117 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
118
119 std::string actual;
120 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
121 expected += name + "|12345";
122 ASSERT_STREQ(expected.c_str(), actual.c_str());
123
124 // Add a single character and verify we get the exact same value as before.
125 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
126 name += '*';
127 atrace_async_begin_body(name.c_str(), 12345);
128 EXPECT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
129 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
130 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
131 ASSERT_STREQ(expected.c_str(), actual.c_str());
132}
133
134TEST_F(TraceDevTest, atrace_async_begin_body_truncated) {
135 std::string expected = android::base::StringPrintf("S|%d|", getpid());
136 std::string name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
137 atrace_async_begin_body(name.c_str(), 12345);
138
139 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
140 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
141
142 std::string actual;
143 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
144 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 7;
145 expected += android::base::StringPrintf("%.*s|12345", expected_len, name.c_str());
146 ASSERT_STREQ(expected.c_str(), actual.c_str());
147}
148
149TEST_F(TraceDevTest, atrace_async_end_body_normal) {
150 atrace_async_end_body("fake_name", 12345);
151
152 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
153
154 std::string actual;
155 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
156 std::string expected = android::base::StringPrintf("F|%d|fake_name|12345", getpid());
157 ASSERT_STREQ(expected.c_str(), actual.c_str());
158}
159
160TEST_F(TraceDevTest, atrace_async_end_body_exact) {
161 std::string expected = android::base::StringPrintf("F|%d|", getpid());
162 std::string name = MakeName(ATRACE_MESSAGE_LENGTH - expected.length() - 7);
163 atrace_async_end_body(name.c_str(), 12345);
164
165 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
166 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
167
168 std::string actual;
169 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
170 expected += name + "|12345";
171 ASSERT_STREQ(expected.c_str(), actual.c_str());
172
173 // Add a single character and verify we get the exact same value as before.
174 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
175 name += '*';
176 atrace_async_end_body(name.c_str(), 12345);
177 EXPECT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
178 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
179 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
180 ASSERT_STREQ(expected.c_str(), actual.c_str());
181}
182
183TEST_F(TraceDevTest, atrace_async_end_body_truncated) {
184 std::string expected = android::base::StringPrintf("F|%d|", getpid());
185 std::string name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
186 atrace_async_end_body(name.c_str(), 12345);
187
188 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
189 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
190
191 std::string actual;
192 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
193 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 7;
194 expected += android::base::StringPrintf("%.*s|12345", expected_len, name.c_str());
195 ASSERT_STREQ(expected.c_str(), actual.c_str());
196}
197
Ray Ye399465a2022-03-21 20:21:53 +0000[diff] [blame]198TEST_F(TraceDevTest, atrace_async_for_track_begin_body_normal) {
199 atrace_async_for_track_begin_body("fake_track", "fake_name", 12345);
200
201 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
202
203 std::string actual;
204 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
205 std::string expected = android::base::StringPrintf("T|%d|fake_track|fake_name|12345", getpid());
206 ASSERT_STREQ(expected.c_str(), actual.c_str());
207}
208
209TEST_F(TraceDevTest, atrace_async_for_track_begin_body_exact_track_name) {
210 const int name_size = 5;
211 std::string expected = android::base::StringPrintf("T|%d|", getpid());
212 std::string track_name =
213 MakeName(ATRACE_MESSAGE_LENGTH - expected.length() - 1 - name_size - 6);
214 atrace_async_for_track_begin_body(track_name.c_str(), "name", 12345);
215
216 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
217 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
218
219 std::string actual;
220 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
221 expected += track_name + "|name|12345";
222 ASSERT_STREQ(expected.c_str(), actual.c_str());
223
224 // Add a single character and verify name truncation
225 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
226 track_name += '*';
227 expected = android::base::StringPrintf("T|%d|", getpid());
228 expected += track_name + "|nam|12345";
229 atrace_async_for_track_begin_body(track_name.c_str(), "name", 12345);
230 EXPECT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
231 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
232 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
233 ASSERT_STREQ(expected.c_str(), actual.c_str());
234}
235
236TEST_F(TraceDevTest, atrace_async_for_track_begin_body_truncated_track_name) {
237 std::string expected = android::base::StringPrintf("T|%d|", getpid());
238 std::string track_name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
239 atrace_async_for_track_begin_body(track_name.c_str(), "name", 12345);
240
241 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
242 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
243
244 std::string actual;
245 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
246 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 9;
247 expected += android::base::StringPrintf("%.*s|n|12345", expected_len, track_name.c_str());
248 ASSERT_STREQ(expected.c_str(), actual.c_str());
249}
250
251TEST_F(TraceDevTest, atrace_async_for_track_begin_body_exact_name) {
252 const int track_name_size = 11;
253 std::string expected = android::base::StringPrintf("T|%d|", getpid());
254 std::string name =
255 MakeName(ATRACE_MESSAGE_LENGTH - expected.length() - 1 - track_name_size - 6);
256 atrace_async_for_track_begin_body("track_name", name.c_str(), 12345);
257
258 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
259 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
260
261 std::string actual;
262 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
263 expected += "track_name|" + name + "|12345";
264 ASSERT_STREQ(expected.c_str(), actual.c_str());
265
266 // Add a single character and verify we get the same value as before.
267 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
268 name += '*';
269 atrace_async_for_track_begin_body("track_name", name.c_str(), 12345);
270 EXPECT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
271 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
272 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
273 ASSERT_STREQ(expected.c_str(), actual.c_str());
274}
275
276TEST_F(TraceDevTest, atrace_async_for_track_begin_body_truncated_name) {
277 std::string expected = android::base::StringPrintf("T|%d|track_name|", getpid());
278 std::string name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
279 atrace_async_for_track_begin_body("track_name", name.c_str(), 12345);
280
281 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
282 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
283
284 std::string actual;
285 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
286 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 1 - 6;
287 expected += android::base::StringPrintf("%.*s|12345", expected_len, name.c_str());
288 ASSERT_STREQ(expected.c_str(), actual.c_str());
289}
290
291TEST_F(TraceDevTest, atrace_async_for_track_begin_body_truncated_both) {
292 std::string expected = android::base::StringPrintf("T|%d|", getpid());
293 std::string name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
294 std::string track_name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
295 atrace_async_for_track_begin_body(track_name.c_str(), name.c_str(), 12345);
296
297 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
298 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
299
300 std::string actual;
301 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
302 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 3 - 6;
303 expected += android::base::StringPrintf("%.*s|%.1s|12345", expected_len, track_name.c_str(),
304 name.c_str());
305 ASSERT_STREQ(expected.c_str(), actual.c_str());
306}
307
308TEST_F(TraceDevTest, atrace_async_for_track_end_body_normal) {
309 atrace_async_for_track_end_body("fake_track", "fake_name", 12345);
310
311 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
312
313 std::string actual;
314 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
315 std::string expected = android::base::StringPrintf("U|%d|fake_track|fake_name|12345", getpid());
316 ASSERT_STREQ(expected.c_str(), actual.c_str());
317}
318
319TEST_F(TraceDevTest, atrace_async_for_track_end_body_exact_track_name) {
320 const int name_size = 5;
321 std::string expected = android::base::StringPrintf("U|%d|", getpid());
322 std::string track_name =
323 MakeName(ATRACE_MESSAGE_LENGTH - expected.length() - 1 - name_size - 6);
324 atrace_async_for_track_end_body(track_name.c_str(), "name", 12345);
325
326 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
327 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
328
329 std::string actual;
330 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
331 expected += track_name + "|name|12345";
332 ASSERT_STREQ(expected.c_str(), actual.c_str());
333
334 // Add a single character and verify name truncation
335 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
336 track_name += '*';
337 expected = android::base::StringPrintf("U|%d|", getpid());
338 expected += track_name + "|nam|12345";
339 atrace_async_for_track_end_body(track_name.c_str(), "name", 12345);
340 EXPECT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
341 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
342 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
343 ASSERT_STREQ(expected.c_str(), actual.c_str());
344}
345
346TEST_F(TraceDevTest, atrace_async_for_track_end_body_truncated_track_name) {
347 std::string expected = android::base::StringPrintf("U|%d|", getpid());
348 std::string track_name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
349 atrace_async_for_track_end_body(track_name.c_str(), "name", 12345);
350
351 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
352 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
353
354 std::string actual;
355 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
356 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 9;
357 expected += android::base::StringPrintf("%.*s|n|12345", expected_len, track_name.c_str());
358 ASSERT_STREQ(expected.c_str(), actual.c_str());
359}
360
361TEST_F(TraceDevTest, atrace_async_for_track_end_body_exact_name) {
362 const int track_name_size = 11;
363 std::string expected = android::base::StringPrintf("U|%d|", getpid());
364 std::string name =
365 MakeName(ATRACE_MESSAGE_LENGTH - expected.length() - 1 - track_name_size - 6);
366 atrace_async_for_track_end_body("track_name", name.c_str(), 12345);
367
368 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
369 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
370
371 std::string actual;
372 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
373 expected += "track_name|" + name + "|12345";
374 ASSERT_STREQ(expected.c_str(), actual.c_str());
375
376 // Add a single character and verify we get the same value as before.
377 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
378 name += '*';
379 atrace_async_for_track_end_body("track_name", name.c_str(), 12345);
380 EXPECT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
381 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
382 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
383 ASSERT_STREQ(expected.c_str(), actual.c_str());
384}
385
386TEST_F(TraceDevTest, atrace_async_for_track_end_body_truncated_name) {
387 std::string expected = android::base::StringPrintf("U|%d|track_name|", getpid());
388 std::string name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
389 atrace_async_for_track_end_body("track_name", name.c_str(), 12345);
390
391 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
392 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
393
394 std::string actual;
395 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
396 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 1 - 6;
397 expected += android::base::StringPrintf("%.*s|12345", expected_len, name.c_str());
398 ASSERT_STREQ(expected.c_str(), actual.c_str());
399}
400
401TEST_F(TraceDevTest, atrace_async_for_track_end_body_truncated_both) {
402 std::string expected = android::base::StringPrintf("U|%d|", getpid());
403 std::string name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
404 std::string track_name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
405 atrace_async_for_track_end_body(track_name.c_str(), name.c_str(), 12345);
406
407 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
408 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
409
410 std::string actual;
411 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
412 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 3 - 6;
413 expected += android::base::StringPrintf("%.*s|%.1s|12345", expected_len, track_name.c_str(),
414 name.c_str());
415 ASSERT_STREQ(expected.c_str(), actual.c_str());
416}
417
Lucas Dupin2c2c5d92021-12-08 16:37:22 -0800[diff] [blame]418TEST_F(TraceDevTest, atrace_instant_body_normal) {
419 atrace_instant_body("fake_name");
420
421 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
422
423 std::string actual;
424 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
425 std::string expected = android::base::StringPrintf("I|%d|fake_name", getpid());
426 ASSERT_STREQ(expected.c_str(), actual.c_str());
427}
428
429TEST_F(TraceDevTest, atrace_instant_body_exact) {
430 std::string expected = android::base::StringPrintf("I|%d|", getpid());
431 std::string name = MakeName(ATRACE_MESSAGE_LENGTH - expected.length() - 1);
432 atrace_instant_body(name.c_str());
433
434 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
435 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
436
437 std::string actual;
438 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
439 expected += name;
440 ASSERT_STREQ(expected.c_str(), actual.c_str());
441
442 // Add a single character and verify we get the exact same value as before.
443 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
444 name += '*';
445 atrace_instant_body(name.c_str());
446 EXPECT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
447 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
448 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
449 ASSERT_STREQ(expected.c_str(), actual.c_str());
450}
451
452TEST_F(TraceDevTest, atrace_instant_body_truncated) {
453 std::string expected = android::base::StringPrintf("I|%d|", getpid());
454 std::string name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
455 atrace_instant_body(name.c_str());
456
457 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
458 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
459
460 std::string actual;
461 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
462 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 1;
463 expected += android::base::StringPrintf("%.*s", expected_len, name.c_str());
464 ASSERT_STREQ(expected.c_str(), actual.c_str());
465}
466
467TEST_F(TraceDevTest, atrace_instant_for_track_body_normal) {
468 atrace_instant_for_track_body("fake_track", "fake_name");
469
470 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
471
472 std::string actual;
473 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
474 std::string expected = android::base::StringPrintf("N|%d|fake_track|fake_name", getpid());
475 ASSERT_STREQ(expected.c_str(), actual.c_str());
476}
477
Ray Ye9a542402022-03-15 23:28:01 +0000[diff] [blame]478TEST_F(TraceDevTest, atrace_instant_for_track_body_exact_track_name) {
479 const int name_size = 5;
Lucas Dupin2c2c5d92021-12-08 16:37:22 -0800[diff] [blame]480 std::string expected = android::base::StringPrintf("N|%d|", getpid());
Ray Ye9a542402022-03-15 23:28:01 +0000[diff] [blame]481 std::string track_name = MakeName(ATRACE_MESSAGE_LENGTH - expected.length() - 1 - name_size);
482 atrace_instant_for_track_body(track_name.c_str(), "name");
Lucas Dupin2c2c5d92021-12-08 16:37:22 -0800[diff] [blame]483
484 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
485 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
486
487 std::string actual;
488 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
Ray Ye9a542402022-03-15 23:28:01 +0000[diff] [blame]489 expected += track_name + "|name";
Lucas Dupin2c2c5d92021-12-08 16:37:22 -0800[diff] [blame]490 ASSERT_STREQ(expected.c_str(), actual.c_str());
491
Ray Ye9a542402022-03-15 23:28:01 +0000[diff] [blame]492 // Add a single character and verify name truncation
Lucas Dupin2c2c5d92021-12-08 16:37:22 -0800[diff] [blame]493 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
Ray Ye9a542402022-03-15 23:28:01 +0000[diff] [blame]494 track_name += '*';
495 expected = android::base::StringPrintf("N|%d|", getpid());
496 expected += track_name + "|nam";
497 atrace_instant_for_track_body(track_name.c_str(), "name");
Lucas Dupin2c2c5d92021-12-08 16:37:22 -0800[diff] [blame]498 EXPECT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
499 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
500 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
501 ASSERT_STREQ(expected.c_str(), actual.c_str());
502}
503
Ray Ye9a542402022-03-15 23:28:01 +0000[diff] [blame]504TEST_F(TraceDevTest, atrace_instant_for_track_body_truncated_track_name) {
Lucas Dupin2c2c5d92021-12-08 16:37:22 -0800[diff] [blame]505 std::string expected = android::base::StringPrintf("N|%d|", getpid());
Ray Ye9a542402022-03-15 23:28:01 +0000[diff] [blame]506 std::string track_name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
507 atrace_instant_for_track_body(track_name.c_str(), "name");
Lucas Dupin2c2c5d92021-12-08 16:37:22 -0800[diff] [blame]508
509 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
510 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
511
512 std::string actual;
513 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
Ray Ye9a542402022-03-15 23:28:01 +0000[diff] [blame]514 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 3;
515 expected += android::base::StringPrintf("%.*s|n", expected_len, track_name.c_str());
516 ASSERT_STREQ(expected.c_str(), actual.c_str());
517}
518
519TEST_F(TraceDevTest, atrace_instant_for_track_body_exact_name) {
520 const int track_name_size = 11;
521 std::string expected = android::base::StringPrintf("N|%d|", getpid());
522 std::string name = MakeName(ATRACE_MESSAGE_LENGTH - expected.length() - 1 - track_name_size);
523 atrace_instant_for_track_body("track_name", name.c_str());
524
525 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
526 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
527
528 std::string actual;
529 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
530 expected += "track_name|" + name;
531 ASSERT_STREQ(expected.c_str(), actual.c_str());
532
533 // Add a single character and verify we get the same value as before.
534 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
535 name += '*';
536 atrace_instant_for_track_body("track_name", name.c_str());
537 EXPECT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
538 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
539 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
540 ASSERT_STREQ(expected.c_str(), actual.c_str());
541}
542
543TEST_F(TraceDevTest, atrace_instant_for_track_body_truncated_name) {
544 std::string expected = android::base::StringPrintf("N|%d|track_name|", getpid());
545 std::string name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
546 atrace_instant_for_track_body("track_name", name.c_str());
547
548 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
549 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
550
551 std::string actual;
552 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
553 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 1;
554 expected += android::base::StringPrintf("%.*s", expected_len, name.c_str());
555 ASSERT_STREQ(expected.c_str(), actual.c_str());
556}
557
558TEST_F(TraceDevTest, atrace_instant_for_track_body_truncated_both) {
559 std::string expected = android::base::StringPrintf("N|%d|", getpid());
560 std::string name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
561 std::string track_name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
562 atrace_instant_for_track_body(track_name.c_str(), name.c_str());
563
564 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
565 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
566
567 std::string actual;
568 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
569 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 3;
570 expected +=
571 android::base::StringPrintf("%.*s|%.1s", expected_len, track_name.c_str(), name.c_str());
Lucas Dupin2c2c5d92021-12-08 16:37:22 -0800[diff] [blame]572 ASSERT_STREQ(expected.c_str(), actual.c_str());
573}
574
Christopher Ferris626efb72016-02-23 18:02:20 -0800[diff] [blame]575TEST_F(TraceDevTest, atrace_int_body_normal) {
576 atrace_int_body("fake_name", 12345);
577
578 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
579
580 std::string actual;
581 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
582 std::string expected = android::base::StringPrintf("C|%d|fake_name|12345", getpid());
583 ASSERT_STREQ(expected.c_str(), actual.c_str());
584}
585
586TEST_F(TraceDevTest, atrace_int_body_exact) {
587 std::string expected = android::base::StringPrintf("C|%d|", getpid());
588 std::string name = MakeName(ATRACE_MESSAGE_LENGTH - expected.length() - 7);
589 atrace_int_body(name.c_str(), 12345);
590
591 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
592 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
593
594 std::string actual;
595 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
596 expected += name + "|12345";
597 ASSERT_STREQ(expected.c_str(), actual.c_str());
598
599 // Add a single character and verify we get the exact same value as before.
600 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
601 name += '*';
602 atrace_int_body(name.c_str(), 12345);
603 EXPECT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
604 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
605 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
606 ASSERT_STREQ(expected.c_str(), actual.c_str());
607}
608
609TEST_F(TraceDevTest, atrace_int_body_truncated) {
610 std::string expected = android::base::StringPrintf("C|%d|", getpid());
611 std::string name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
612 atrace_int_body(name.c_str(), 12345);
613
614 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
615 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
616
617 std::string actual;
618 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
619 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 7;
620 expected += android::base::StringPrintf("%.*s|12345", expected_len, name.c_str());
621 ASSERT_STREQ(expected.c_str(), actual.c_str());
622}
623
624TEST_F(TraceDevTest, atrace_int64_body_normal) {
625 atrace_int64_body("fake_name", 17179869183L);
626
627 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
628
629 std::string actual;
630 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
631 std::string expected = android::base::StringPrintf("C|%d|fake_name|17179869183", getpid());
632 ASSERT_STREQ(expected.c_str(), actual.c_str());
633}
634
635TEST_F(TraceDevTest, atrace_int64_body_exact) {
636 std::string expected = android::base::StringPrintf("C|%d|", getpid());
637 std::string name = MakeName(ATRACE_MESSAGE_LENGTH - expected.length() - 13);
638 atrace_int64_body(name.c_str(), 17179869183L);
639
640 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
641 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
642
643 std::string actual;
644 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
645 expected += name + "|17179869183";
646 ASSERT_STREQ(expected.c_str(), actual.c_str());
647
648 // Add a single character and verify we get the exact same value as before.
649 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
650 name += '*';
651 atrace_int64_body(name.c_str(), 17179869183L);
652 EXPECT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
653 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
654 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
655 ASSERT_STREQ(expected.c_str(), actual.c_str());
656}
657
658TEST_F(TraceDevTest, atrace_int64_body_truncated) {
659 std::string expected = android::base::StringPrintf("C|%d|", getpid());
660 std::string name = MakeName(2 * ATRACE_MESSAGE_LENGTH);
661 atrace_int64_body(name.c_str(), 17179869183L);
662
663 ASSERT_EQ(ATRACE_MESSAGE_LENGTH - 1, lseek(atrace_marker_fd, 0, SEEK_CUR));
664 ASSERT_EQ(0, lseek(atrace_marker_fd, 0, SEEK_SET));
665
666 std::string actual;
667 ASSERT_TRUE(android::base::ReadFdToString(atrace_marker_fd, &actual));
668 int expected_len = ATRACE_MESSAGE_LENGTH - expected.length() - 13;
669 expected += android::base::StringPrintf("%.*s|17179869183", expected_len, name.c_str());
670 ASSERT_STREQ(expected.c_str(), actual.c_str());
671}