src/tests/test_NvidiaGpuSensorTest.cpp

117     ocp::accelerator_management::CommonNonSuccessResponse response{};
118     response.command = 0x42;
119     response.completion_code = static_cast<uint8_t>(
121     response.reason_code = htole16(0x1234);
126     std::array<uint8_t, sizeof(response)> buf{};
127     std::memcpy(buf.data(), &response, sizeof(response));
139     ocp::accelerator_management::CommonNonSuccessResponse response{};
140     response.command = 0x42;
141     response.completion_code = static_cast<uint8_t>(
143     response.reason_code = htole16(0x5678);
148     std::array<uint8_t, sizeof(response)> buf{};
149     std::memcpy(buf.data(), &response, sizeof(response));
229     // Create a mock successful response
232     gpu::QueryDeviceIdentificationResponse response{};
240     gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
242     // Populate response data
243     response.hdr.command = static_cast<uint8_t>(
245     response.hdr.completion_code = static_cast<uint8_t>(
247     response.hdr.reserved = 0;
248     response.hdr.data_size =
250     response.device_identification =
252     response.instance_id = 7;
254     std::memcpy(buf.data(), &response, sizeof(response));
275     // Create a mock successful response
279     ocp::accelerator_management::CommonNonSuccessResponse response{};
287     gpu::packHeader(headerInfo, response.msgHdr.hdr);
289     // Populate response data
290     response.command = static_cast<uint8_t>(
292     response.command = static_cast<uint8_t>(
294     response.completion_code = static_cast<uint8_t>(
296     response.reason_code = htole16(0x1234);
298     std::memcpy(buf.data(), &response, sizeof(response));
381     // Create a mock successful response
384     gpu::GetTemperatureReadingResponse response{};
392     gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
394     // Populate response data
395     response.hdr.command = static_cast<uint8_t>(
397     response.hdr.completion_code = static_cast<uint8_t>(
399     response.hdr.reserved = 0;
400     response.hdr.data_size = htole16(sizeof(int32_t));
403     response.reading = htole32(19328);
405     std::memcpy(buf.data(), &response, sizeof(response));
426     // Populate error response data
460     // Create a mock response with invalid data_size
463     gpu::GetTemperatureReadingResponse response{};
471     gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
473     response.hdr.command = static_cast<uint8_t>(
475     response.hdr.completion_code = static_cast<uint8_t>(
477     response.hdr.reserved = 0;
478     response.hdr.data_size = htole16(1); // Invalid - should be sizeof(int32_t)
479     response.reading = htole32(19328);
481     std::memcpy(buf.data(), &response, sizeof(response));
531     // Create a mock successful response
534     gpu::ReadThermalParametersResponse response{};
542     gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
544     // Populate response data
545     response.hdr.command = static_cast<uint8_t>(
547     response.hdr.completion_code = static_cast<uint8_t>(
549     response.hdr.reserved = 0;
550     response.hdr.data_size = htole16(sizeof(int32_t));
553     response.threshold = htole32(21760);
555     std::memcpy(buf.data(), &response, sizeof(response));
577     // Populate error response data
611     // Create a mock response with invalid data_size
614     gpu::ReadThermalParametersResponse response{};
622     gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
624     response.hdr.command = static_cast<uint8_t>(
626     response.hdr.completion_code = static_cast<uint8_t>(
628     response.hdr.reserved = 0;
629     response.hdr.data_size = htole16(2); // Invalid - should be sizeof(int32_t)
630     response.threshold = htole32(21760);
632     std::memcpy(buf.data(), &response, sizeof(response));
685     // Create a mock successful response
688     gpu::GetPowerDrawResponse response{};
696     gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
698     // Populate response data
699     response.hdr.command = static_cast<uint8_t>(
701     response.hdr.completion_code = static_cast<uint8_t>(
703     response.hdr.reserved = 0;
704     response.hdr.data_size = htole16(sizeof(uint32_t));
707     response.power = htole32(250);
709     std::memcpy(buf.data(), &response, sizeof(response));
730     // Populate error response data
763     // Create a mock response with invalid data_size
766     gpu::GetPowerDrawResponse response{};
774     gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
776     response.hdr.command = static_cast<uint8_t>(
778     response.hdr.completion_code = static_cast<uint8_t>(
780     response.hdr.reserved = 0;
781     response.hdr.data_size = htole16(2); // Invalid - should be sizeof(uint32_t)
782     response.power = htole32(250);
784     std::memcpy(buf.data(), &response, sizeof(response));
834     // Create a mock successful response
837     gpu::GetCurrentEnergyCounterResponse response{};
845     gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
847     // Populate response data
848     response.hdr.command = static_cast<uint8_t>(
850     response.hdr.completion_code = static_cast<uint8_t>(
852     response.hdr.reserved = 0;
853     response.hdr.data_size = htole16(sizeof(uint64_t));
856     response.energy = htole64(3600000);
858     std::memcpy(buf.data(), &response, sizeof(response));
880     // Populate error response data
914     // Create a mock response with invalid data_size
917     gpu::GetCurrentEnergyCounterResponse response{};
925     gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
927     response.hdr.command = static_cast<uint8_t>(
929     response.hdr.completion_code = static_cast<uint8_t>(
931     response.hdr.reserved = 0;
932     response.hdr.data_size = htole16(4); // Invalid - should be sizeof(uint64_t)
933     response.energy = htole64(3600000);
935     std::memcpy(buf.data(), &response, sizeof(response));
984     // Create a mock successful response
987     gpu::GetVoltageResponse response{};
995     gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
997     // Populate response data
998     response.hdr.command =
1000     response.hdr.completion_code = static_cast<uint8_t>(
1002     response.hdr.reserved = 0;
1003     response.hdr.data_size = htole16(sizeof(uint32_t));
1006     response.voltage = htole32(12500);
1008     std::memcpy(buf.data(), &response, sizeof(response));
1029     // Populate error response data
1062     // Create a mock response with invalid data_size
1065     gpu::GetVoltageResponse response{};
1073     gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
1075     response.hdr.command =
1077     response.hdr.completion_code = static_cast<uint8_t>(
1079     response.hdr.reserved = 0;
1080     response.hdr.data_size = htole16(2); // Invalid - should be sizeof(uint32_t)
1081     response.voltage = htole32(12500);
1083     std::memcpy(buf.data(), &response, sizeof(response));
1141     ocp::accelerator_management::CommonResponse* response =
1150     gpu::packHeader(headerInfo, response->msgHdr.hdr);
1152     response->command = static_cast<uint8_t>(
1154     response->completion_code = static_cast<uint8_t>(
1156     response->reserved = 0;
1157     response->data_size = htole16(numValues * sizeof(uint32_t));
1284     ocp::accelerator_management::CommonResponse* response =
1293     gpu::packHeader(headerInfo, response->msgHdr.hdr);
1295     response->command =
1297     response->completion_code = static_cast<uint8_t>(
1299     response->reserved = 0;
1300     response->data_size =
1373     ocp::accelerator_management::CommonResponse* response =
1382     gpu::packHeader(headerInfo, response->msgHdr.hdr);
1384     response->command =
1386     response->completion_code = static_cast<uint8_t>(
1388     response->reserved = 0;
1389     response->data_size = htole16(1);