6 #include <client/src/ProfilingUtils.hpp> 8 #include <common/include/NumericCast.hpp> 9 #include <common/include/SwTrace.hpp> 10 #include <common/include/Threads.hpp> 12 #include <doctest/doctest.h> 18 TEST_CASE(
"TimelineLabelPacketTestNoBuffer")
20 const uint64_t profilingGuid = 123456u;
21 const std::string label =
"some label";
22 unsigned int numberOfBytesWritten = 789u;
23 TimelinePacketStatus result = WriteTimelineLabelBinaryPacket(profilingGuid,
27 numberOfBytesWritten);
28 CHECK(result == TimelinePacketStatus::BufferExhaustion);
29 CHECK(numberOfBytesWritten == 0);
32 TEST_CASE(
"TimelineLabelPacketTestBufferExhaustionZeroValue")
34 std::vector<unsigned char> buffer(512, 0);
36 const uint64_t profilingGuid = 123456u;
37 const std::string label =
"some label";
38 unsigned int numberOfBytesWritten = 789u;
39 TimelinePacketStatus result = WriteTimelineLabelBinaryPacket(profilingGuid,
43 numberOfBytesWritten);
44 CHECK(result == TimelinePacketStatus::BufferExhaustion);
45 CHECK(numberOfBytesWritten == 0);
48 TEST_CASE(
"TimelineLabelPacketTestBufferExhaustionFixedValue")
50 std::vector<unsigned char> buffer(10, 0);
52 const uint64_t profilingGuid = 123456u;
53 const std::string label =
"some label";
54 unsigned int numberOfBytesWritten = 789u;
55 TimelinePacketStatus result = WriteTimelineLabelBinaryPacket(profilingGuid,
59 numberOfBytesWritten);
60 CHECK(result == TimelinePacketStatus::BufferExhaustion);
61 CHECK(numberOfBytesWritten == 0);
64 TEST_CASE(
"TimelineLabelPacketTestInvalidLabel")
66 std::vector<unsigned char> buffer(512, 0);
68 const uint64_t profilingGuid = 123456u;
69 const std::string label =
"s0m€ l@b€l";
70 unsigned int numberOfBytesWritten = 789u;
71 TimelinePacketStatus result = WriteTimelineLabelBinaryPacket(profilingGuid,
75 numberOfBytesWritten);
76 CHECK(result == TimelinePacketStatus::Error);
77 CHECK(numberOfBytesWritten == 0);
80 TEST_CASE(
"TimelineLabelPacketTestSingleConstructionOfData")
82 std::vector<unsigned char> buffer(512, 0);
84 const uint64_t profilingGuid = 123456u;
85 const std::string label =
"some label";
86 unsigned int numberOfBytesWritten = 789u;
87 TimelinePacketStatus result = WriteTimelineLabelBinaryPacket(profilingGuid,
91 numberOfBytesWritten);
92 CHECK(result == TimelinePacketStatus::Ok);
93 CHECK(numberOfBytesWritten == 28);
95 unsigned int uint32_t_size =
sizeof(uint32_t);
96 unsigned int uint64_t_size =
sizeof(uint64_t);
99 unsigned int offset = 0;
100 uint32_t decl_Id = ReadUint32(buffer.data(), offset);
101 CHECK(decl_Id == uint32_t(0));
104 offset += uint32_t_size;
105 uint64_t readProfilingGuid = ReadUint64(buffer.data(), offset);
106 CHECK(readProfilingGuid == profilingGuid);
109 offset += uint64_t_size;
110 uint32_t swTraceLabelLength = ReadUint32(buffer.data(), offset);
111 CHECK(swTraceLabelLength == 11);
113 offset += uint32_t_size;
114 CHECK(std::memcmp(buffer.data() + offset,
116 swTraceLabelLength - 1) == 0);
118 offset += swTraceLabelLength * uint32_t_size;
119 CHECK(buffer[offset] ==
'\0');
122 TEST_CASE(
"TimelineRelationshipPacketNullBufferTest")
124 ProfilingRelationshipType relationshipType = ProfilingRelationshipType::DataLink;
125 const uint64_t relationshipGuid = 123456u;
126 const uint64_t headGuid = 234567u;
127 const uint64_t tailGuid = 345678u;
128 const uint64_t attributeGuid = 876345u;
129 unsigned int numberOfBytesWritten = 789u;
130 TimelinePacketStatus result = WriteTimelineRelationshipBinary(relationshipType,
137 numberOfBytesWritten);
138 CHECK(result == TimelinePacketStatus::BufferExhaustion);
139 CHECK(numberOfBytesWritten == 0);
142 TEST_CASE(
"TimelineRelationshipPacketZeroBufferSizeTest")
144 std::vector<unsigned char> buffer(512, 0);
146 ProfilingRelationshipType relationshipType = ProfilingRelationshipType::DataLink;
147 const uint64_t relationshipGuid = 123456u;
148 const uint64_t headGuid = 234567u;
149 const uint64_t tailGuid = 345678u;
150 const uint64_t attributeGuid = 876345u;
151 unsigned int numberOfBytesWritten = 789u;
152 TimelinePacketStatus result = WriteTimelineRelationshipBinary(relationshipType,
159 numberOfBytesWritten);
160 CHECK(result == TimelinePacketStatus::BufferExhaustion);
161 CHECK(numberOfBytesWritten == 0);
164 TEST_CASE(
"TimelineRelationshipPacketSmallBufferSizeTest")
166 std::vector<unsigned char> buffer(10, 0);
168 ProfilingRelationshipType relationshipType = ProfilingRelationshipType::DataLink;
169 const uint64_t relationshipGuid = 123456u;
170 const uint64_t headGuid = 234567u;
171 const uint64_t tailGuid = 345678u;
172 const uint64_t attributeGuid = 876345u;
173 unsigned int numberOfBytesWritten = 789u;
174 TimelinePacketStatus result =
175 WriteTimelineRelationshipBinary(relationshipType,
182 numberOfBytesWritten);
183 CHECK(result == TimelinePacketStatus::BufferExhaustion);
184 CHECK(numberOfBytesWritten == 0);
187 TEST_CASE(
"TimelineRelationshipPacketInvalidRelationTest")
189 std::vector<unsigned char> buffer(512, 0);
190 ProfilingRelationshipType relationshipType =
static_cast<ProfilingRelationshipType
>(5);
191 const uint64_t relationshipGuid = 123456u;
192 const uint64_t headGuid = 234567u;
193 const uint64_t tailGuid = 345678u;
194 const uint64_t attributeGuid = 876345u;
196 unsigned int numberOfBytesWritten = 789u;
198 CHECK_THROWS_AS(WriteTimelineRelationshipBinary(relationshipType,
205 numberOfBytesWritten),
206 arm::pipe::InvalidArgumentException);
208 CHECK(numberOfBytesWritten == 0);
211 TEST_CASE(
"TimelineRelationshipPacketTestDataConstruction")
213 std::vector<unsigned char> buffer(512, 0);
215 ProfilingRelationshipType relationshipType = ProfilingRelationshipType::RetentionLink;
216 const uint64_t relationshipGuid = 123456u;
217 const uint64_t headGuid = 234567u;
218 const uint64_t tailGuid = 345678u;
219 const uint64_t attributeGuid = 876345u;
220 unsigned int numberOfBytesWritten = 789u;
221 TimelinePacketStatus result =
222 WriteTimelineRelationshipBinary(relationshipType,
229 numberOfBytesWritten);
230 CHECK(result == TimelinePacketStatus::Ok);
231 CHECK(numberOfBytesWritten == 40);
233 unsigned int uint32_t_size =
sizeof(uint32_t);
234 unsigned int uint64_t_size =
sizeof(uint64_t);
237 unsigned int offset = 0;
239 uint32_t readDeclId = ReadUint32(buffer.data(), offset);
240 CHECK(readDeclId == 3);
243 offset += uint32_t_size;
244 uint32_t readRelationshipType = ReadUint32(buffer.data(), offset);
245 CHECK(readRelationshipType == 0);
248 offset += uint32_t_size;
249 uint64_t readRelationshipGuid = ReadUint64(buffer.data(), offset);
250 CHECK(readRelationshipGuid == relationshipGuid);
253 offset += uint64_t_size;
254 uint64_t readHeadGuid = ReadUint64(buffer.data(), offset);
255 CHECK(readHeadGuid == headGuid);
258 offset += uint64_t_size;
259 uint64_t readTailGuid = ReadUint64(buffer.data(), offset);
260 CHECK(readTailGuid == tailGuid);
263 offset += uint64_t_size;
264 uint64_t readAttributeGuid = ReadUint64(buffer.data(), offset);
265 CHECK(readAttributeGuid == attributeGuid);
268 TEST_CASE(
"TimelineRelationshipPacketExecutionLinkTestDataConstruction")
270 std::vector<unsigned char> buffer(512, 0);
272 ProfilingRelationshipType relationshipType = ProfilingRelationshipType::ExecutionLink;
273 const uint64_t relationshipGuid = 123456u;
274 const uint64_t headGuid = 234567u;
275 const uint64_t tailGuid = 345678u;
276 const uint64_t attributeGuid = 876345u;
277 unsigned int numberOfBytesWritten = 789u;
278 TimelinePacketStatus result =
279 WriteTimelineRelationshipBinary(relationshipType,
286 numberOfBytesWritten);
287 CHECK(result == TimelinePacketStatus::Ok);
288 CHECK(numberOfBytesWritten == 40);
290 unsigned int uint32_t_size =
sizeof(uint32_t);
291 unsigned int uint64_t_size =
sizeof(uint64_t);
293 unsigned int offset = 0;
294 uint32_t readDeclId = ReadUint32(buffer.data(), offset);
295 CHECK(readDeclId == 3);
298 offset += uint32_t_size;
299 uint32_t readRelationshipType = ReadUint32(buffer.data(), offset);
300 CHECK(readRelationshipType == 1);
303 offset += uint32_t_size;
304 uint64_t readRelationshipGuid = ReadUint64(buffer.data(), offset);
305 CHECK(readRelationshipGuid == relationshipGuid);
308 offset += uint64_t_size;
309 uint64_t readHeadGuid = ReadUint64(buffer.data(), offset);
310 CHECK(readHeadGuid == headGuid);
313 offset += uint64_t_size;
314 uint64_t readTailGuid = ReadUint64(buffer.data(), offset);
315 CHECK(readTailGuid == tailGuid);
318 offset += uint64_t_size;
319 uint64_t readAttributeGuid = ReadUint64(buffer.data(), offset);
320 CHECK(readAttributeGuid == attributeGuid);
324 TEST_CASE(
"TimelineRelationshipPacketDataLinkTestDataConstruction")
326 std::vector<unsigned char> buffer(512, 0);
328 ProfilingRelationshipType relationshipType = ProfilingRelationshipType::DataLink;
329 const uint64_t relationshipGuid = 123456u;
330 const uint64_t headGuid = 234567u;
331 const uint64_t tailGuid = 345678u;
332 const uint64_t attributeGuid = 876345u;
333 unsigned int numberOfBytesWritten = 789u;
334 TimelinePacketStatus result =
335 WriteTimelineRelationshipBinary(relationshipType,
342 numberOfBytesWritten);
343 CHECK(result == TimelinePacketStatus::Ok);
344 CHECK(numberOfBytesWritten == 40);
346 unsigned int uint32_t_size =
sizeof(uint32_t);
347 unsigned int uint64_t_size =
sizeof(uint64_t);
349 unsigned int offset = 0;
350 uint32_t readDeclId = ReadUint32(buffer.data(), offset);
351 CHECK(readDeclId == 3);
354 offset += uint32_t_size;
355 uint32_t readRelationshipType = ReadUint32(buffer.data(), offset);
356 CHECK(readRelationshipType == 2);
359 offset += uint32_t_size;
360 uint64_t readRelationshipGuid = ReadUint64(buffer.data(), offset);
361 CHECK(readRelationshipGuid == relationshipGuid);
364 offset += uint64_t_size;
365 uint64_t readHeadGuid = ReadUint64(buffer.data(), offset);
366 CHECK(readHeadGuid == headGuid);
369 offset += uint64_t_size;
370 uint64_t readTailGuid = ReadUint64(buffer.data(), offset);
371 CHECK(readTailGuid == tailGuid);
374 offset += uint64_t_size;
375 uint64_t readAttributeGuid = ReadUint64(buffer.data(), offset);
376 CHECK(readAttributeGuid == attributeGuid);
380 TEST_CASE(
"TimelineRelationshipPacketLabelLinkTestDataConstruction")
382 std::vector<unsigned char> buffer(512, 0);
384 ProfilingRelationshipType relationshipType = ProfilingRelationshipType::LabelLink;
385 const uint64_t relationshipGuid = 123456u;
386 const uint64_t headGuid = 234567u;
387 const uint64_t tailGuid = 345678u;
388 const uint64_t attributeGuid = 876345u;
389 unsigned int numberOfBytesWritten = 789u;
390 TimelinePacketStatus result =
391 WriteTimelineRelationshipBinary(relationshipType,
398 numberOfBytesWritten);
399 CHECK(result == TimelinePacketStatus::Ok);
400 CHECK(numberOfBytesWritten == 40);
402 unsigned int uint32_t_size =
sizeof(uint32_t);
403 unsigned int uint64_t_size =
sizeof(uint64_t);
406 unsigned int offset = 0;
407 uint32_t readDeclId = ReadUint32(buffer.data(), offset);
408 CHECK(readDeclId == 3);
411 offset += uint32_t_size;
412 uint32_t readRelationshipType = ReadUint32(buffer.data(), offset);
413 CHECK(readRelationshipType == 3);
416 offset += uint32_t_size;
417 uint64_t readRelationshipGuid = ReadUint64(buffer.data(), offset);
418 CHECK(readRelationshipGuid == relationshipGuid);
421 offset += uint64_t_size;
422 uint64_t readHeadGuid = ReadUint64(buffer.data(), offset);
423 CHECK(readHeadGuid == headGuid);
426 offset += uint64_t_size;
427 uint64_t readTailGuid = ReadUint64(buffer.data(), offset);
428 CHECK(readTailGuid == tailGuid);
431 offset += uint64_t_size;
432 uint64_t readAttributeGuid = ReadUint64(buffer.data(), offset);
433 CHECK(readAttributeGuid == attributeGuid);
436 TEST_CASE(
"TimelineMessageDirectoryPacketTestNoBuffer")
438 unsigned int numberOfBytesWritten = 789u;
439 TimelinePacketStatus result = WriteTimelineMessageDirectoryPackage(
nullptr,
441 numberOfBytesWritten);
442 CHECK(result == TimelinePacketStatus::BufferExhaustion);
443 CHECK(numberOfBytesWritten == 0);
446 TEST_CASE(
"TimelineMessageDirectoryPacketTestBufferExhausted")
448 std::vector<unsigned char> buffer(512, 0);
450 unsigned int numberOfBytesWritten = 789u;
451 TimelinePacketStatus result = WriteTimelineMessageDirectoryPackage(buffer.data(),
453 numberOfBytesWritten);
454 CHECK(result == TimelinePacketStatus::BufferExhaustion);
455 CHECK(numberOfBytesWritten == 0);
458 TEST_CASE(
"TimelineMessageDirectoryPacketTestFullConstruction")
460 std::vector<unsigned char> buffer(512, 0);
461 unsigned int numberOfBytesWritten = 789u;
462 TimelinePacketStatus result = WriteTimelineMessageDirectoryPackage(buffer.data(),
465 numberOfBytesWritten);
466 CHECK(result == TimelinePacketStatus::Ok);
468 CHECK(numberOfBytesWritten == 451);
470 unsigned int uint8_t_size =
sizeof(uint8_t);
471 unsigned int uint32_t_size =
sizeof(uint32_t);
472 unsigned int uint64_t_size =
sizeof(uint64_t);
475 unsigned int offset = 0;
476 uint32_t packetHeaderWord0 = ReadUint32(buffer.data(), offset);
477 uint32_t packetFamily = (packetHeaderWord0 >> 26) & 0x0000003F;
478 uint32_t packetClass = (packetHeaderWord0 >> 19) & 0x0000007F;
479 uint32_t packetType = (packetHeaderWord0 >> 16) & 0x00000007;
480 uint32_t streamId = (packetHeaderWord0 >> 0) & 0x00000007;
481 CHECK(packetFamily == 1);
482 CHECK(packetClass == 0);
483 CHECK(packetType == 0);
484 CHECK(streamId == 0);
486 offset += uint32_t_size;
487 uint32_t packetHeaderWord1 = ReadUint32(buffer.data(), offset);
488 uint32_t sequenceNumbered = (packetHeaderWord1 >> 24) & 0x00000001;
489 uint32_t dataLength = (packetHeaderWord1 >> 0) & 0x00FFFFFF;
490 CHECK(sequenceNumbered == 0);
491 CHECK(dataLength == 443);
494 offset += uint32_t_size;
495 uint8_t readStreamVersion = ReadUint8(buffer.data(), offset);
496 CHECK(readStreamVersion == 4);
497 offset += uint8_t_size;
498 uint8_t readPointerBytes = ReadUint8(buffer.data(), offset);
499 CHECK(readPointerBytes == uint64_t_size);
500 offset += uint8_t_size;
501 uint8_t readThreadIdBytes = ReadUint8(buffer.data(), offset);
502 CHECK(readThreadIdBytes == ThreadIdSize);
505 offset += uint8_t_size;
506 uint32_t declCount = ReadUint32(buffer.data(), offset);
507 CHECK(declCount == 5);
510 offset += uint32_t_size;
511 uint32_t readDeclId = ReadUint32(buffer.data(), offset);
512 CHECK(readDeclId == 0);
518 offset += uint32_t_size;
519 uint32_t swTraceDeclNameLength = ReadUint32(buffer.data(), offset);
520 CHECK(swTraceDeclNameLength == 13);
522 std::string label =
"declareLabel";
523 offset += uint32_t_size;
524 CHECK(std::memcmp(buffer.data() + offset,
526 swTraceDeclNameLength - 1) == 0);
529 std::vector<uint32_t> swTraceString;
530 StringToSwTraceString<SwTraceCharPolicy>(label, swTraceString);
532 uint32_t swTraceUINameLength = ReadUint32(buffer.data(), offset);
533 CHECK(swTraceUINameLength == 14);
535 label =
"declare label";
536 offset += uint32_t_size;
537 CHECK(std::memcmp(buffer.data() + offset,
539 swTraceUINameLength - 1) == 0);
542 StringToSwTraceString<SwTraceCharPolicy>(label, swTraceString);
544 uint32_t swTraceArgTypesLength = ReadUint32(buffer.data(), offset);
545 CHECK(swTraceArgTypesLength == 3);
548 offset += uint32_t_size;
549 CHECK(std::memcmp(buffer.data() + offset,
551 swTraceArgTypesLength - 1) == 0);
554 StringToSwTraceString<SwTraceCharPolicy>(label, swTraceString);
556 uint32_t swTraceArgNamesLength = ReadUint32(buffer.data(), offset);
557 CHECK(swTraceArgNamesLength == 11);
559 label =
"guid,value";
560 offset += uint32_t_size;
561 CHECK(std::memcmp(buffer.data() + offset,
563 swTraceArgNamesLength - 1) == 0);
566 StringToSwTraceString<SwTraceCharPolicy>(label, swTraceString);
568 readDeclId = ReadUint32(buffer.data(), offset);
569 CHECK(readDeclId == 1);
572 offset += uint32_t_size;
573 swTraceDeclNameLength = ReadUint32(buffer.data(), offset);
574 CHECK(swTraceDeclNameLength == 14);
576 label =
"declareEntity";
577 offset += uint32_t_size;
578 CHECK(std::memcmp(buffer.data() + offset,
580 swTraceDeclNameLength - 1) == 0);
583 TEST_CASE(
"TimelineEntityPacketTestNoBuffer")
585 const uint64_t profilingGuid = 123456u;
586 unsigned int numberOfBytesWritten = 789u;
587 TimelinePacketStatus result = WriteTimelineEntityBinary(profilingGuid,
590 numberOfBytesWritten);
591 CHECK(result == TimelinePacketStatus::BufferExhaustion);
592 CHECK(numberOfBytesWritten == 0);
595 TEST_CASE(
"TimelineEntityPacketTestBufferExhaustedWithZeroBufferSize")
597 std::vector<unsigned char> buffer(512, 0);
599 const uint64_t profilingGuid = 123456u;
600 unsigned int numberOfBytesWritten = 789u;
601 TimelinePacketStatus result = WriteTimelineEntityBinary(profilingGuid,
604 numberOfBytesWritten);
605 CHECK(result == TimelinePacketStatus::BufferExhaustion);
606 CHECK(numberOfBytesWritten == 0);
609 TEST_CASE(
"TimelineEntityPacketTestBufferExhaustedWithFixedBufferSize")
611 std::vector<unsigned char> buffer(10, 0);
613 const uint64_t profilingGuid = 123456u;
614 unsigned int numberOfBytesWritten = 789u;
615 TimelinePacketStatus result = WriteTimelineEntityBinary(profilingGuid,
618 numberOfBytesWritten);
619 CHECK(result == TimelinePacketStatus::BufferExhaustion);
620 CHECK(numberOfBytesWritten == 0);
623 TEST_CASE(
"TimelineEntityPacketTestFullConstructionOfData")
625 std::vector<unsigned char> buffer(512, 0);
627 const uint64_t profilingGuid = 123456u;
628 unsigned int numberOfBytesWritten = 789u;
629 TimelinePacketStatus result = WriteTimelineEntityBinary(profilingGuid,
632 numberOfBytesWritten);
633 CHECK(result == TimelinePacketStatus::Ok);
634 CHECK(numberOfBytesWritten == 12);
636 unsigned int uint32_t_size =
sizeof(uint32_t);
638 unsigned int offset = 0;
640 uint32_t decl_Id = ReadUint32(buffer.data(), offset);
641 CHECK(decl_Id == uint32_t(1));
644 offset += uint32_t_size;
645 uint64_t readProfilingGuid = ReadUint64(buffer.data(), offset);
646 CHECK(readProfilingGuid == profilingGuid);
649 TEST_CASE(
"TimelineEventClassTestNoBuffer")
651 const uint64_t profilingGuid = 123456u;
652 const uint64_t profilingNameGuid = 3345u;
653 unsigned int numberOfBytesWritten = 789u;
654 TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
658 numberOfBytesWritten);
659 CHECK(result == TimelinePacketStatus::BufferExhaustion);
660 CHECK(numberOfBytesWritten == 0);
663 TEST_CASE(
"TimelineEventClassTestBufferExhaustionZeroValue")
665 std::vector<unsigned char> buffer(512, 0);
667 const uint64_t profilingGuid = 123456u;
668 const uint64_t profilingNameGuid = 3345u;
669 unsigned int numberOfBytesWritten = 789u;
670 TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
674 numberOfBytesWritten);
675 CHECK(result == TimelinePacketStatus::BufferExhaustion);
676 CHECK(numberOfBytesWritten == 0);
679 TEST_CASE(
"TimelineEventClassTestBufferExhaustionFixedValue")
681 std::vector<unsigned char> buffer(10, 0);
683 const uint64_t profilingGuid = 123456u;
684 const uint64_t profilingNameGuid = 5564u;
685 unsigned int numberOfBytesWritten = 789u;
686 TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
690 numberOfBytesWritten);
691 CHECK(result == TimelinePacketStatus::BufferExhaustion);
692 CHECK(numberOfBytesWritten == 0);
695 TEST_CASE(
"TimelineEventClassTestFullConstructionOfData")
697 std::vector<unsigned char> buffer(512, 0);
699 const uint64_t profilingGuid = 123456u;
700 const uint64_t profilingNameGuid = 654321u;
701 unsigned int numberOfBytesWritten = 789u;
702 TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
706 numberOfBytesWritten);
707 CHECK(result == TimelinePacketStatus::Ok);
708 CHECK(numberOfBytesWritten == 20);
710 unsigned int uint32_t_size =
sizeof(uint32_t);
711 unsigned int uint64_t_size =
sizeof(uint64_t);
713 unsigned int offset = 0;
715 uint32_t declId = ReadUint32(buffer.data(), offset);
716 CHECK(declId == uint32_t(2));
719 offset += uint32_t_size;
720 uint64_t readProfilingGuid = ReadUint64(buffer.data(), offset);
721 CHECK(readProfilingGuid == profilingGuid);
723 offset += uint64_t_size;
724 uint64_t readProfilingNameGuid = ReadUint64(buffer.data(), offset);
725 CHECK(readProfilingNameGuid == profilingNameGuid);
728 TEST_CASE(
"TimelineEventPacketTestNoBuffer")
730 const uint64_t timestamp = 456789u;
731 const int threadId = arm::pipe::GetCurrentThreadId();
732 const uint64_t profilingGuid = 123456u;
733 unsigned int numberOfBytesWritten = 789u;
734 TimelinePacketStatus result = WriteTimelineEventBinary(timestamp,
739 numberOfBytesWritten);
740 CHECK(result == TimelinePacketStatus::BufferExhaustion);
741 CHECK(numberOfBytesWritten == 0);
744 TEST_CASE(
"TimelineEventPacketTestBufferExhaustionZeroValue")
746 std::vector<unsigned char> buffer(512, 0);
748 const uint64_t timestamp = 456789u;
749 const int threadId = arm::pipe::GetCurrentThreadId();
750 const uint64_t profilingGuid = 123456u;
751 unsigned int numberOfBytesWritten = 789u;
752 TimelinePacketStatus result = WriteTimelineEventBinary(timestamp,
757 numberOfBytesWritten);
758 CHECK(result == TimelinePacketStatus::BufferExhaustion);
759 CHECK(numberOfBytesWritten == 0);
762 TEST_CASE(
"TimelineEventPacketTestBufferExhaustionFixedValue")
764 std::vector<unsigned char> buffer(10, 0);
766 const uint64_t timestamp = 456789u;
767 const int threadId = arm::pipe::GetCurrentThreadId();
768 const uint64_t profilingGuid = 123456u;
769 unsigned int numberOfBytesWritten = 789u;
770 TimelinePacketStatus result = WriteTimelineEventBinary(timestamp,
775 numberOfBytesWritten);
776 CHECK(result == TimelinePacketStatus::BufferExhaustion);
777 CHECK(numberOfBytesWritten == 0);
780 TEST_CASE(
"TimelineEventPacketTestFullConstructionOfData")
782 std::vector<unsigned char> buffer(512, 0);
784 const uint64_t timestamp = 456789u;
785 const int threadId = arm::pipe::GetCurrentThreadId();
786 const uint64_t profilingGuid = 123456u;
787 unsigned int numberOfBytesWritten = 789u;
788 TimelinePacketStatus result = WriteTimelineEventBinary(timestamp,
793 numberOfBytesWritten);
794 CHECK(result == TimelinePacketStatus::Ok);
796 unsigned int uint32_t_size =
sizeof(uint32_t);
797 unsigned int uint64_t_size =
sizeof(uint64_t);
798 CHECK(numberOfBytesWritten == 20 + ThreadIdSize);
800 unsigned int offset = 0;
802 uint32_t readDeclId = ReadUint32(buffer.data(), offset);
803 CHECK(readDeclId == 4);
806 offset += uint32_t_size;
807 uint64_t readTimestamp = ReadUint64(buffer.data(), offset);
808 CHECK(readTimestamp == timestamp);
811 offset += uint64_t_size;
812 std::vector<uint8_t> readThreadId(ThreadIdSize, 0);
813 ReadBytes(buffer.data(), offset, ThreadIdSize, readThreadId.data());
814 CHECK(readThreadId == threadId);
817 offset += ThreadIdSize;
818 uint64_t readProfilingGuid = ReadUint64(buffer.data(), offset);
819 CHECK(readProfilingGuid == profilingGuid);
TEST_SUITE("TimelinePacketTests")
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)