Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 1 | #include "libpldmresponder/pdr.hpp" |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 2 | #include "libpldmresponder/pdr_utils.hpp" |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 3 | #include "libpldmresponder/platform.hpp" |
George Liu | 64d26be | 2020-01-15 10:58:10 +0800 | [diff] [blame] | 4 | #include "libpldmresponder/platform_numeric_effecter.hpp" |
George Liu | 0d7aca8 | 2020-03-30 15:01:36 +0800 | [diff] [blame] | 5 | #include "libpldmresponder/platform_state_effecter.hpp" |
George Liu | 1e44c73 | 2020-02-28 20:20:06 +0800 | [diff] [blame] | 6 | #include "mocked_utils.hpp" |
| 7 | #include "utils.hpp" |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 8 | |
| 9 | #include <iostream> |
| 10 | |
George Liu | 1e44c73 | 2020-02-28 20:20:06 +0800 | [diff] [blame] | 11 | using namespace pldm::utils; |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 12 | using namespace pldm::responder; |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 13 | using namespace pldm::responder::platform; |
| 14 | using namespace pldm::responder::pdr; |
| 15 | using namespace pldm::responder::pdr_utils; |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 16 | |
| 17 | TEST(getPDR, testGoodPath) |
| 18 | { |
| 19 | std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES> |
| 20 | requestPayload{}; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 21 | auto req = reinterpret_cast<pldm_msg*>(requestPayload.data()); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 22 | size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr); |
| 23 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 24 | struct pldm_get_pdr_req* request = |
| 25 | reinterpret_cast<struct pldm_get_pdr_req*>(req->payload); |
| 26 | request->request_count = 100; |
| 27 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 28 | auto pdrRepo = pldm_pdr_init(); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 29 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 30 | Repo repo(pdrRepo); |
| 31 | ASSERT_EQ(repo.empty(), false); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 32 | auto response = handler.getPDR(req, requestPayloadLength); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 33 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
| 34 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 35 | struct pldm_get_pdr_resp* resp = |
| 36 | reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload); |
| 37 | ASSERT_EQ(PLDM_SUCCESS, resp->completion_code); |
| 38 | ASSERT_EQ(2, resp->next_record_handle); |
| 39 | ASSERT_EQ(true, resp->response_count != 0); |
| 40 | |
| 41 | pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(resp->record_data); |
| 42 | ASSERT_EQ(hdr->record_handle, 1); |
| 43 | ASSERT_EQ(hdr->version, 1); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 44 | |
| 45 | pldm_pdr_destroy(pdrRepo); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 46 | } |
| 47 | |
| 48 | TEST(getPDR, testShortRead) |
| 49 | { |
| 50 | std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES> |
| 51 | requestPayload{}; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 52 | auto req = reinterpret_cast<pldm_msg*>(requestPayload.data()); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 53 | size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr); |
| 54 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 55 | struct pldm_get_pdr_req* request = |
| 56 | reinterpret_cast<struct pldm_get_pdr_req*>(req->payload); |
| 57 | request->request_count = 1; |
| 58 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 59 | auto pdrRepo = pldm_pdr_init(); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 60 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 61 | Repo repo(pdrRepo); |
| 62 | ASSERT_EQ(repo.empty(), false); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 63 | auto response = handler.getPDR(req, requestPayloadLength); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 64 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 65 | struct pldm_get_pdr_resp* resp = |
| 66 | reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload); |
| 67 | ASSERT_EQ(PLDM_SUCCESS, resp->completion_code); |
| 68 | ASSERT_EQ(1, resp->response_count); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 69 | pldm_pdr_destroy(pdrRepo); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 70 | } |
| 71 | |
| 72 | TEST(getPDR, testBadRecordHandle) |
| 73 | { |
| 74 | std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES> |
| 75 | requestPayload{}; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 76 | auto req = reinterpret_cast<pldm_msg*>(requestPayload.data()); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 77 | size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr); |
| 78 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 79 | struct pldm_get_pdr_req* request = |
| 80 | reinterpret_cast<struct pldm_get_pdr_req*>(req->payload); |
| 81 | request->record_handle = 100000; |
| 82 | request->request_count = 1; |
| 83 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 84 | auto pdrRepo = pldm_pdr_init(); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 85 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 86 | Repo repo(pdrRepo); |
| 87 | ASSERT_EQ(repo.empty(), false); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 88 | auto response = handler.getPDR(req, requestPayloadLength); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 89 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
| 90 | |
| 91 | ASSERT_EQ(responsePtr->payload[0], PLDM_PLATFORM_INVALID_RECORD_HANDLE); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 92 | |
| 93 | pldm_pdr_destroy(pdrRepo); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 94 | } |
| 95 | |
| 96 | TEST(getPDR, testNoNextRecord) |
| 97 | { |
| 98 | std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES> |
| 99 | requestPayload{}; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 100 | auto req = reinterpret_cast<pldm_msg*>(requestPayload.data()); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 101 | size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr); |
| 102 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 103 | struct pldm_get_pdr_req* request = |
| 104 | reinterpret_cast<struct pldm_get_pdr_req*>(req->payload); |
| 105 | request->record_handle = 1; |
| 106 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 107 | auto pdrRepo = pldm_pdr_init(); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 108 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 109 | Repo repo(pdrRepo); |
| 110 | ASSERT_EQ(repo.empty(), false); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 111 | auto response = handler.getPDR(req, requestPayloadLength); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 112 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 113 | struct pldm_get_pdr_resp* resp = |
| 114 | reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload); |
| 115 | ASSERT_EQ(PLDM_SUCCESS, resp->completion_code); |
| 116 | ASSERT_EQ(2, resp->next_record_handle); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 117 | |
| 118 | pldm_pdr_destroy(pdrRepo); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 119 | } |
| 120 | |
| 121 | TEST(getPDR, testFindPDR) |
| 122 | { |
| 123 | std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES> |
| 124 | requestPayload{}; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 125 | auto req = reinterpret_cast<pldm_msg*>(requestPayload.data()); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 126 | size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr); |
| 127 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 128 | struct pldm_get_pdr_req* request = |
| 129 | reinterpret_cast<struct pldm_get_pdr_req*>(req->payload); |
| 130 | request->request_count = 100; |
| 131 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 132 | auto pdrRepo = pldm_pdr_init(); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 133 | Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 134 | Repo repo(pdrRepo); |
| 135 | ASSERT_EQ(repo.empty(), false); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 136 | auto response = handler.getPDR(req, requestPayloadLength); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 137 | |
| 138 | // Let's try to find a PDR of type stateEffecter (= 11) and entity type = |
| 139 | // 100 |
| 140 | bool found = false; |
| 141 | uint32_t handle = 0; // start asking for PDRs from recordHandle 0 |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 142 | while (!found) |
| 143 | { |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 144 | request->record_handle = handle; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 145 | auto response = handler.getPDR(req, requestPayloadLength); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 146 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 147 | struct pldm_get_pdr_resp* resp = |
| 148 | reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload); |
| 149 | ASSERT_EQ(PLDM_SUCCESS, resp->completion_code); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 150 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 151 | handle = resp->next_record_handle; // point to the next pdr in case |
| 152 | // current is not what we want |
| 153 | |
| 154 | pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(resp->record_data); |
Sampa Misra | aa8ae72 | 2019-12-12 03:20:40 -0600 | [diff] [blame] | 155 | std::cerr << "PDR next record handle " << handle << "\n"; |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 156 | std::cerr << "PDR type " << hdr->type << "\n"; |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 157 | if (hdr->type == PLDM_STATE_EFFECTER_PDR) |
| 158 | { |
| 159 | pldm_state_effecter_pdr* pdr = |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 160 | reinterpret_cast<pldm_state_effecter_pdr*>(resp->record_data); |
Sampa Misra | aa8ae72 | 2019-12-12 03:20:40 -0600 | [diff] [blame] | 161 | std::cerr << "PDR entity type " << pdr->entity_type << "\n"; |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 162 | if (pdr->entity_type == 100) |
| 163 | { |
| 164 | found = true; |
| 165 | // Rest of the PDR can be accessed as need be |
| 166 | break; |
| 167 | } |
| 168 | } |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 169 | if (!resp->next_record_handle) // no more records |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 170 | { |
| 171 | break; |
| 172 | } |
| 173 | } |
| 174 | ASSERT_EQ(found, true); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 175 | |
| 176 | pldm_pdr_destroy(pdrRepo); |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 177 | } |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 178 | |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 179 | TEST(setStateEffecterStatesHandler, testGoodRequest) |
| 180 | { |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 181 | auto inPDRRepo = pldm_pdr_init(); |
| 182 | auto outPDRRepo = pldm_pdr_init(); |
| 183 | Repo outRepo(outPDRRepo); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 184 | Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 185 | Repo inRepo(inPDRRepo); |
| 186 | getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 187 | pdr_utils::PdrEntry e; |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 188 | auto record1 = pdr::getRecordByHandle(outRepo, 1, e); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 189 | ASSERT_NE(record1, nullptr); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 190 | pldm_state_effecter_pdr* pdr = |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 191 | reinterpret_cast<pldm_state_effecter_pdr*>(e.data); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 192 | EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR); |
| 193 | |
| 194 | std::vector<set_effecter_state_field> stateField; |
| 195 | stateField.push_back({PLDM_REQUEST_SET, 1}); |
| 196 | stateField.push_back({PLDM_REQUEST_SET, 1}); |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 197 | std::string value = "xyz.openbmc_project.Foo.Bar.V1"; |
George Liu | 1e44c73 | 2020-02-28 20:20:06 +0800 | [diff] [blame] | 198 | PropertyValue propertyValue = value; |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 199 | |
| 200 | MockdBusHandler handlerObj; |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 201 | DBusMapping dbusMapping{"/foo/bar", "xyz.openbmc_project.Foo.Bar", |
| 202 | "propertyName", "string"}; |
George Liu | 1e44c73 | 2020-02-28 20:20:06 +0800 | [diff] [blame] | 203 | |
| 204 | EXPECT_CALL(handlerObj, setDbusProperty(dbusMapping, propertyValue)) |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 205 | .Times(2); |
George Liu | 0d7aca8 | 2020-03-30 15:01:36 +0800 | [diff] [blame] | 206 | auto rc = platform_state_effecter::setStateEffecterStatesHandler< |
| 207 | MockdBusHandler, Handler>(handlerObj, handler, 0x1, stateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 208 | ASSERT_EQ(rc, 0); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 209 | |
| 210 | pldm_pdr_destroy(inPDRRepo); |
| 211 | pldm_pdr_destroy(outPDRRepo); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 212 | } |
| 213 | |
| 214 | TEST(setStateEffecterStatesHandler, testBadRequest) |
| 215 | { |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 216 | auto inPDRRepo = pldm_pdr_init(); |
| 217 | auto outPDRRepo = pldm_pdr_init(); |
| 218 | Repo outRepo(outPDRRepo); |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 219 | Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 220 | Repo inRepo(inPDRRepo); |
| 221 | getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 222 | pdr_utils::PdrEntry e; |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 223 | auto record1 = pdr::getRecordByHandle(outRepo, 1, e); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 224 | ASSERT_NE(record1, nullptr); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 225 | pldm_state_effecter_pdr* pdr = |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 226 | reinterpret_cast<pldm_state_effecter_pdr*>(e.data); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 227 | EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR); |
| 228 | |
| 229 | std::vector<set_effecter_state_field> stateField; |
| 230 | stateField.push_back({PLDM_REQUEST_SET, 3}); |
| 231 | stateField.push_back({PLDM_REQUEST_SET, 4}); |
| 232 | |
| 233 | MockdBusHandler handlerObj; |
George Liu | 0d7aca8 | 2020-03-30 15:01:36 +0800 | [diff] [blame] | 234 | auto rc = platform_state_effecter::setStateEffecterStatesHandler< |
| 235 | MockdBusHandler, Handler>(handlerObj, handler, 0x1, stateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 236 | ASSERT_EQ(rc, PLDM_PLATFORM_SET_EFFECTER_UNSUPPORTED_SENSORSTATE); |
| 237 | |
George Liu | 0d7aca8 | 2020-03-30 15:01:36 +0800 | [diff] [blame] | 238 | rc = platform_state_effecter::setStateEffecterStatesHandler<MockdBusHandler, |
| 239 | Handler>( |
| 240 | handlerObj, handler, 0x9, stateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 241 | ASSERT_EQ(rc, PLDM_PLATFORM_INVALID_EFFECTER_ID); |
| 242 | |
| 243 | stateField.push_back({PLDM_REQUEST_SET, 4}); |
George Liu | 0d7aca8 | 2020-03-30 15:01:36 +0800 | [diff] [blame] | 244 | rc = platform_state_effecter::setStateEffecterStatesHandler<MockdBusHandler, |
| 245 | Handler>( |
| 246 | handlerObj, handler, 0x1, stateField); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 247 | ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA); |
| 248 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 249 | pldm_pdr_destroy(inPDRRepo); |
| 250 | pldm_pdr_destroy(outPDRRepo); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 251 | } |
George Liu | 64d26be | 2020-01-15 10:58:10 +0800 | [diff] [blame] | 252 | |
| 253 | TEST(setNumericEffecterValueHandler, testGoodRequest) |
| 254 | { |
| 255 | auto inPDRRepo = pldm_pdr_init(); |
| 256 | auto numericEffecterPdrRepo = pldm_pdr_init(); |
| 257 | Repo numericEffecterPDRs(numericEffecterPdrRepo); |
| 258 | Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr); |
| 259 | Repo inRepo(inPDRRepo); |
| 260 | getRepoByType(inRepo, numericEffecterPDRs, PLDM_NUMERIC_EFFECTER_PDR); |
| 261 | |
| 262 | pdr_utils::PdrEntry e; |
| 263 | auto record3 = pdr::getRecordByHandle(numericEffecterPDRs, 3, e); |
| 264 | ASSERT_NE(record3, nullptr); |
| 265 | |
| 266 | pldm_numeric_effecter_value_pdr* pdr = |
| 267 | reinterpret_cast<pldm_numeric_effecter_value_pdr*>(e.data); |
| 268 | EXPECT_EQ(pdr->hdr.type, PLDM_NUMERIC_EFFECTER_PDR); |
| 269 | |
| 270 | uint16_t effecterId = 3; |
| 271 | uint32_t effecterValue = 2100000000; // 2036-07-18 21:20:00 |
| 272 | PropertyValue propertyValue = static_cast<uint32_t>(effecterValue); |
| 273 | |
| 274 | MockdBusHandler handlerObj; |
| 275 | DBusMapping dbusMapping{"/foo/bar", "xyz.openbmc_project.Foo.Bar", |
| 276 | "propertyName", "uint64_t"}; |
| 277 | EXPECT_CALL(handlerObj, setDbusProperty(dbusMapping, propertyValue)) |
| 278 | .Times(1); |
| 279 | |
| 280 | auto rc = platform_numeric_effecter::setNumericEffecterValueHandler< |
| 281 | MockdBusHandler, Handler>( |
| 282 | handlerObj, handler, effecterId, PLDM_EFFECTER_DATA_SIZE_UINT32, |
| 283 | reinterpret_cast<uint8_t*>(&effecterValue), 4); |
| 284 | ASSERT_EQ(rc, 0); |
| 285 | |
| 286 | pldm_pdr_destroy(inPDRRepo); |
| 287 | pldm_pdr_destroy(numericEffecterPdrRepo); |
| 288 | } |
| 289 | |
| 290 | TEST(setNumericEffecterValueHandler, testBadRequest) |
| 291 | { |
| 292 | auto inPDRRepo = pldm_pdr_init(); |
| 293 | auto numericEffecterPdrRepo = pldm_pdr_init(); |
| 294 | Repo numericEffecterPDRs(numericEffecterPdrRepo); |
| 295 | Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr); |
| 296 | Repo inRepo(inPDRRepo); |
| 297 | getRepoByType(inRepo, numericEffecterPDRs, PLDM_NUMERIC_EFFECTER_PDR); |
| 298 | |
| 299 | pdr_utils::PdrEntry e; |
| 300 | auto record3 = pdr::getRecordByHandle(numericEffecterPDRs, 3, e); |
| 301 | ASSERT_NE(record3, nullptr); |
| 302 | |
| 303 | pldm_numeric_effecter_value_pdr* pdr = |
| 304 | reinterpret_cast<pldm_numeric_effecter_value_pdr*>(e.data); |
| 305 | EXPECT_EQ(pdr->hdr.type, PLDM_NUMERIC_EFFECTER_PDR); |
| 306 | |
| 307 | uint16_t effecterId = 3; |
| 308 | uint64_t effecterValue = 9876543210; |
| 309 | MockdBusHandler handlerObj; |
| 310 | auto rc = platform_numeric_effecter::setNumericEffecterValueHandler< |
| 311 | MockdBusHandler, Handler>( |
| 312 | handlerObj, handler, effecterId, PLDM_EFFECTER_DATA_SIZE_SINT32, |
| 313 | reinterpret_cast<uint8_t*>(&effecterValue), 3); |
| 314 | ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA); |
| 315 | |
| 316 | pldm_pdr_destroy(inPDRRepo); |
| 317 | pldm_pdr_destroy(numericEffecterPdrRepo); |
| 318 | } |
Tom Joseph | b426860 | 2020-04-17 17:20:45 +0530 | [diff] [blame^] | 319 | |
| 320 | TEST(parseStateSensor, allScenarios) |
| 321 | { |
| 322 | // Sample state sensor with SensorID - 1, EntityType - Processor Module(67) |
| 323 | // State Set ID - Operational Running Status(11), Supported States - 3,4 |
| 324 | std::vector<uint8_t> sample1PDR{0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, |
| 325 | 0x00, 0x17, 0x00, 0x00, 0x00, 0x01, 0x00, |
| 326 | 0x43, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, |
| 327 | 0x00, 0x01, 0x0b, 0x00, 0x01, 0x18}; |
| 328 | |
| 329 | const auto& [terminusHandle1, sensorID1, sensorInfo1] = |
| 330 | parseStateSensorPDR(sample1PDR); |
| 331 | const auto& [containerID1, entityType1, entityInstance1] = |
| 332 | std::get<0>(sensorInfo1); |
| 333 | const auto& states1 = std::get<1>(sensorInfo1); |
| 334 | CompositeSensorStates statesCmp1{{3u, 4u}}; |
| 335 | |
| 336 | ASSERT_EQ(le16toh(terminusHandle1), 0u); |
| 337 | ASSERT_EQ(le16toh(sensorID1), 1u); |
| 338 | ASSERT_EQ(le16toh(containerID1), 0u); |
| 339 | ASSERT_EQ(le16toh(entityType1), 67u); |
| 340 | ASSERT_EQ(le16toh(entityInstance1), 1u); |
| 341 | ASSERT_EQ(states1, statesCmp1); |
| 342 | |
| 343 | // Sample state sensor with SensorID - 2, EntityType - System Firmware(31) |
| 344 | // State Set ID - Availability(2), Supported States - 3,4,9,10,11,13 |
| 345 | std::vector<uint8_t> sample2PDR{0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, |
| 346 | 0x00, 0x17, 0x00, 0x00, 0x00, 0x02, 0x00, |
| 347 | 0x1F, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, |
| 348 | 0x00, 0x01, 0x02, 0x00, 0x02, 0x18, 0x2E}; |
| 349 | |
| 350 | const auto& [terminusHandle2, sensorID2, sensorInfo2] = |
| 351 | parseStateSensorPDR(sample2PDR); |
| 352 | const auto& [containerID2, entityType2, entityInstance2] = |
| 353 | std::get<0>(sensorInfo2); |
| 354 | const auto& states2 = std::get<1>(sensorInfo2); |
| 355 | CompositeSensorStates statesCmp2{{3u, 4u, 9u, 10u, 11u, 13u}}; |
| 356 | |
| 357 | ASSERT_EQ(le16toh(terminusHandle2), 0u); |
| 358 | ASSERT_EQ(le16toh(sensorID2), 2u); |
| 359 | ASSERT_EQ(le16toh(containerID2), 0u); |
| 360 | ASSERT_EQ(le16toh(entityType2), 31u); |
| 361 | ASSERT_EQ(le16toh(entityInstance2), 1u); |
| 362 | ASSERT_EQ(states2, statesCmp2); |
| 363 | |
| 364 | // Sample state sensor with SensorID - 3, EntityType - Virtual Machine |
| 365 | // Manager(33), Composite State Sensor -2 , State Set ID - Link State(33), |
| 366 | // Supported States - 1,2, State Set ID - Configuration State(15), |
| 367 | // Supported States - 1,2,3,4 |
| 368 | std::vector<uint8_t> sample3PDR{ |
| 369 | 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x17, 0x00, 0x00, |
| 370 | 0x00, 0x03, 0x00, 0x21, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, |
| 371 | 0x02, 0x21, 0x00, 0x01, 0x06, 0x0F, 0x00, 0x01, 0x1E}; |
| 372 | |
| 373 | const auto& [terminusHandle3, sensorID3, sensorInfo3] = |
| 374 | parseStateSensorPDR(sample3PDR); |
| 375 | const auto& [containerID3, entityType3, entityInstance3] = |
| 376 | std::get<0>(sensorInfo3); |
| 377 | const auto& states3 = std::get<1>(sensorInfo3); |
| 378 | CompositeSensorStates statesCmp3{{1u, 2u}, {1u, 2u, 3u, 4u}}; |
| 379 | |
| 380 | ASSERT_EQ(le16toh(terminusHandle3), 0u); |
| 381 | ASSERT_EQ(le16toh(sensorID3), 3u); |
| 382 | ASSERT_EQ(le16toh(containerID3), 1u); |
| 383 | ASSERT_EQ(le16toh(entityType3), 33u); |
| 384 | ASSERT_EQ(le16toh(entityInstance3), 2u); |
| 385 | ASSERT_EQ(states3, statesCmp3); |
| 386 | } |