1 #include "data.hpp"
2 #include "data_mock.hpp"
3 #include "firmware_handler.hpp"
4 #include "firmware_unittest.hpp"
5 #include "image_mock.hpp"
6 #include "triggerable_mock.hpp"
7 #include "util.hpp"
8 
9 #include <cstdint>
10 #include <cstring>
11 #include <vector>
12 
13 #include <gtest/gtest.h>
14 
15 namespace ipmi_flash
16 {
17 namespace
18 {
19 
20 using ::testing::Eq;
21 using ::testing::Return;
22 
23 class FirmwareHandlerWriteTestIpmiOnly : public IpmiOnlyFirmwareTest
24 {};
25 
26 class FirmwareHandlerWriteTestLpc : public FakeLpcFirmwareTest
27 {};
28 
29 TEST_F(FirmwareHandlerWriteTestIpmiOnly, DataTypeIpmiWriteSuccess)
30 {
31     /* Verify if data type ipmi, it calls write with the bytes. */
32     EXPECT_CALL(*imageMock, open("asdf", std::ios::out)).WillOnce(Return(true));
33 
34     EXPECT_TRUE(
35         handler->open(0,
36                       static_cast<std::uint16_t>(blobs::OpenFlags::write) |
37                           FirmwareFlags::UpdateFlags::ipmi,
38                       "asdf"));
39 
40     std::vector<std::uint8_t> bytes = {0xaa, 0x55};
41 
42     EXPECT_CALL(*imageMock, write(0, Eq(bytes))).WillOnce(Return(true));
43     EXPECT_TRUE(handler->write(0, 0, bytes));
44 }
45 
46 TEST_F(FirmwareHandlerWriteTestLpc, DataTypeNonIpmiWriteSuccess)
47 {
48     /* Verify if data type non-ipmi, it calls write with the length. */
49     EXPECT_CALL(*dataMock, open()).WillOnce(Return(true));
50     EXPECT_CALL(*imageMock, open("asdf", std::ios::out)).WillOnce(Return(true));
51 
52     EXPECT_TRUE(
53         handler->open(0,
54                       static_cast<std::uint16_t>(blobs::OpenFlags::write) |
55                           FirmwareFlags::UpdateFlags::lpc,
56                       "asdf"));
57 
58     struct ExtChunkHdr request;
59     request.length = 4; /* number of bytes to read. */
60     std::vector<std::uint8_t> ipmiRequest;
61     ipmiRequest.resize(sizeof(request));
62     std::memcpy(ipmiRequest.data(), &request, sizeof(request));
63 
64     std::vector<std::uint8_t> bytes = {0x01, 0x02, 0x03, 0x04};
65 
66     EXPECT_CALL(*dataMock, copyFrom(request.length)).WillOnce(Return(bytes));
67     EXPECT_CALL(*imageMock, write(0, Eq(bytes))).WillOnce(Return(true));
68     EXPECT_TRUE(handler->write(0, 0, ipmiRequest));
69 }
70 
71 TEST_F(FirmwareHandlerWriteTestLpc, DataTypeNonIpmiWriteFailsBadRequest)
72 {
73     /* Verify the data type non-ipmi, if the request's structure doesn't match,
74      * return failure. */
75     EXPECT_CALL(*dataMock, open()).WillOnce(Return(true));
76     EXPECT_CALL(*imageMock, open("asdf", std::ios::out)).WillOnce(Return(true));
77 
78     EXPECT_TRUE(
79         handler->open(0,
80                       static_cast<std::uint16_t>(blobs::OpenFlags::write) |
81                           FirmwareFlags::UpdateFlags::lpc,
82                       "asdf"));
83 
84     struct ExtChunkHdr request;
85     request.length = 4; /* number of bytes to read. */
86 
87     std::vector<std::uint8_t> ipmiRequest;
88     ipmiRequest.resize(sizeof(request));
89     std::memcpy(ipmiRequest.data(), &request, sizeof(request));
90     ipmiRequest.push_back(1);
91 
92     /* ipmiRequest is too large by one byte. */
93     EXPECT_FALSE(handler->write(0, 0, ipmiRequest));
94 }
95 
96 } // namespace
97 } // namespace ipmi_flash
98