1 #include "common/test/mocked_utils.hpp"
2 #include "libpldmresponder/pdr_utils.hpp"
3 #include "libpldmresponder/platform.hpp"
4
5 #include <libpldm/platform.h>
6
7 #include <sdbusplus/test/sdbus_mock.hpp>
8 #include <sdeventplus/event.hpp>
9
10 #include <gtest/gtest.h>
11
12 using namespace pldm::responder;
13 using namespace pldm::responder::platform;
14 using namespace pldm::responder::pdr;
15 using namespace pldm::responder::pdr_utils;
16 using namespace pldm::utils;
17
18 using ::testing::_;
19 using ::testing::Return;
20 using ::testing::StrEq;
21
TEST(GeneratePDRByStateEffecter,testGoodJson)22 TEST(GeneratePDRByStateEffecter, testGoodJson)
23 {
24 MockdBusHandler mockedUtils;
25 EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
26 .Times(5)
27 .WillRepeatedly(Return("foo.bar"));
28
29 auto inPDRRepo = pldm_pdr_init();
30 auto outPDRRepo = pldm_pdr_init();
31 Repo outRepo(outPDRRepo);
32 auto event = sdeventplus::Event::get_default();
33 Handler handler(&mockedUtils, 0, nullptr, "./pdr_jsons/state_effecter/good",
34 inPDRRepo, nullptr, nullptr, nullptr, nullptr, nullptr,
35 event);
36 Repo inRepo(inPDRRepo);
37 getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR);
38
39 // 2 entries
40 ASSERT_EQ(outRepo.getRecordCount(), 2);
41
42 // Check first PDR
43 pdr_utils::PdrEntry e;
44 auto record2 = pdr::getRecordByHandle(outRepo, 2, e);
45 ASSERT_NE(record2, nullptr);
46 pldm_state_effecter_pdr* pdr = new (e.data) pldm_state_effecter_pdr;
47
48 ASSERT_EQ(pdr->hdr.record_handle, 2);
49 ASSERT_EQ(pdr->hdr.version, 1);
50 ASSERT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR);
51 ASSERT_EQ(pdr->hdr.record_change_num, 0);
52 ASSERT_EQ(pdr->hdr.length, 23);
53
54 ASSERT_EQ(pdr->terminus_handle, TERMINUS_HANDLE);
55 ASSERT_EQ(pdr->effecter_id, 1);
56 ASSERT_EQ(pdr->entity_type, 33);
57 ASSERT_EQ(pdr->entity_instance, 0);
58 ASSERT_EQ(pdr->container_id, 0);
59 ASSERT_EQ(pdr->effecter_semantic_id, 0);
60 ASSERT_EQ(pdr->effecter_init, PLDM_NO_INIT);
61 ASSERT_EQ(pdr->has_description_pdr, false);
62 ASSERT_EQ(pdr->composite_effecter_count, 2);
63 state_effecter_possible_states* states = new (pdr->possible_states)
64 state_effecter_possible_states;
65 ASSERT_EQ(states->state_set_id, 196);
66 ASSERT_EQ(states->possible_states_size, 1);
67 bitfield8_t bf1{};
68 bf1.byte = 2;
69 ASSERT_EQ(states->states[0].byte, bf1.byte);
70
71 const auto& [dbusMappings1, dbusValMaps1] =
72 handler.getDbusObjMaps(pdr->effecter_id);
73 ASSERT_EQ(dbusMappings1[0].objectPath, "/foo/bar");
74
75 // Check second PDR
76 auto record3 = pdr::getRecordByHandle(outRepo, 3, e);
77 ASSERT_NE(record3, nullptr);
78 pdr = new (e.data) pldm_state_effecter_pdr;
79
80 ASSERT_EQ(pdr->hdr.record_handle, 3);
81 ASSERT_EQ(pdr->hdr.version, 1);
82 ASSERT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR);
83 ASSERT_EQ(pdr->hdr.record_change_num, 0);
84 ASSERT_EQ(pdr->hdr.length, 24);
85
86 ASSERT_EQ(pdr->terminus_handle, TERMINUS_HANDLE);
87 ASSERT_EQ(pdr->effecter_id, 2);
88 ASSERT_EQ(pdr->entity_type, 100);
89 ASSERT_EQ(pdr->entity_instance, 0);
90 ASSERT_EQ(pdr->container_id, 0);
91 ASSERT_EQ(pdr->effecter_semantic_id, 0);
92 ASSERT_EQ(pdr->effecter_init, PLDM_NO_INIT);
93 ASSERT_EQ(pdr->has_description_pdr, false);
94 ASSERT_EQ(pdr->composite_effecter_count, 2);
95 states = new (pdr->possible_states) state_effecter_possible_states;
96 ASSERT_EQ(states->state_set_id, 197);
97 ASSERT_EQ(states->possible_states_size, 1);
98 bf1.byte = 2;
99 ASSERT_EQ(states->states[0].byte, bf1.byte);
100 states = new (pdr->possible_states + sizeof(state_effecter_possible_states))
101 state_effecter_possible_states;
102 ASSERT_EQ(states->state_set_id, 198);
103 ASSERT_EQ(states->possible_states_size, 2);
104 bitfield8_t bf2[2];
105 bf2[0].byte = 38;
106 bf2[1].byte = 128;
107 ASSERT_EQ(states->states[0].byte, bf2[0].byte);
108 ASSERT_EQ(states->states[1].byte, bf2[1].byte);
109
110 const auto& [dbusMappings2, dbusValMaps2] =
111 handler.getDbusObjMaps(pdr->effecter_id);
112 ASSERT_EQ(dbusMappings2[0].objectPath, "/foo/bar");
113 ASSERT_EQ(dbusMappings2[1].objectPath, "/foo/bar");
114
115 ASSERT_THROW(handler.getDbusObjMaps(0xDEAD), std::exception);
116
117 pldm_pdr_destroy(inPDRRepo);
118 pldm_pdr_destroy(outPDRRepo);
119 }
120
TEST(GeneratePDRByNumericEffecter,testGoodJson)121 TEST(GeneratePDRByNumericEffecter, testGoodJson)
122 {
123 MockdBusHandler mockedUtils;
124 EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
125 .Times(5)
126 .WillRepeatedly(Return("foo.bar"));
127
128 auto inPDRRepo = pldm_pdr_init();
129 auto outPDRRepo = pldm_pdr_init();
130 Repo outRepo(outPDRRepo);
131 auto event = sdeventplus::Event::get_default();
132 Handler handler(&mockedUtils, 0, nullptr, "./pdr_jsons/state_effecter/good",
133 inPDRRepo, nullptr, nullptr, nullptr, nullptr, nullptr,
134 event);
135 Repo inRepo(inPDRRepo);
136 getRepoByType(inRepo, outRepo, PLDM_NUMERIC_EFFECTER_PDR);
137
138 // 1 entries
139 ASSERT_EQ(outRepo.getRecordCount(), 1);
140
141 // Check first PDR
142 pdr_utils::PdrEntry e;
143 auto record = pdr::getRecordByHandle(outRepo, 4, e);
144 ASSERT_NE(record, nullptr);
145
146 pldm_numeric_effecter_value_pdr* pdr = new (e.data)
147 pldm_numeric_effecter_value_pdr;
148 EXPECT_EQ(pdr->hdr.record_handle, 4);
149 EXPECT_EQ(pdr->hdr.version, 1);
150 EXPECT_EQ(pdr->hdr.type, PLDM_NUMERIC_EFFECTER_PDR);
151 EXPECT_EQ(pdr->hdr.record_change_num, 0);
152 EXPECT_EQ(pdr->hdr.length,
153 sizeof(pldm_numeric_effecter_value_pdr) - sizeof(pldm_pdr_hdr));
154
155 EXPECT_EQ(pdr->effecter_id, 3);
156 EXPECT_EQ(pdr->effecter_data_size, 4);
157
158 const auto& [dbusMappings, dbusValMaps] =
159 handler.getDbusObjMaps(pdr->effecter_id);
160 EXPECT_EQ(dbusMappings[0].objectPath, "/foo/bar");
161 EXPECT_EQ(dbusMappings[0].interface, "xyz.openbmc_project.Foo.Bar");
162 EXPECT_EQ(dbusMappings[0].propertyName, "propertyName");
163 EXPECT_EQ(dbusMappings[0].propertyType, "uint64_t");
164
165 pldm_pdr_destroy(inPDRRepo);
166 pldm_pdr_destroy(outPDRRepo);
167 }
168
TEST(GeneratePDR,testMalformedJson)169 TEST(GeneratePDR, testMalformedJson)
170 {
171 MockdBusHandler mockedUtils;
172 EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
173 .Times(5)
174 .WillRepeatedly(Return("foo.bar"));
175
176 auto inPDRRepo = pldm_pdr_init();
177 auto outPDRRepo = pldm_pdr_init();
178 Repo outRepo(outPDRRepo);
179 auto event = sdeventplus::Event::get_default();
180 Handler handler(&mockedUtils, 0, nullptr, "./pdr_jsons/state_effecter/good",
181 inPDRRepo, nullptr, nullptr, nullptr, nullptr, nullptr,
182 event);
183 Repo inRepo(inPDRRepo);
184 getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR);
185
186 ASSERT_EQ(outRepo.getRecordCount(), 2);
187 ASSERT_THROW(pdr_utils::readJson("./pdr_jsons/state_effecter/malformed"),
188 std::exception);
189
190 pldm_pdr_destroy(inPDRRepo);
191 pldm_pdr_destroy(outPDRRepo);
192 }
193
TEST(findStateEffecterId,goodJson)194 TEST(findStateEffecterId, goodJson)
195 {
196 MockdBusHandler mockedUtils;
197 EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
198 .Times(5)
199 .WillRepeatedly(Return("foo.bar"));
200
201 auto inPDRRepo = pldm_pdr_init();
202 auto event = sdeventplus::Event::get_default();
203 Handler handler(&mockedUtils, 0, nullptr, "./pdr_jsons/state_effecter/good",
204 inPDRRepo, nullptr, nullptr, nullptr, nullptr, nullptr,
205 event);
206 uint16_t entityType = 33;
207 uint16_t entityInstance = 0;
208 uint16_t containerId = 0;
209 uint16_t stateSetId = 196;
210 auto effecterId = findStateEffecterId(inPDRRepo, entityType, entityInstance,
211 containerId, stateSetId, true);
212 ASSERT_EQ(effecterId, 1);
213 stateSetId = 300;
214 effecterId = findStateEffecterId(inPDRRepo, entityType, entityInstance,
215 containerId, stateSetId, true);
216 ASSERT_EQ(effecterId, PLDM_INVALID_EFFECTER_ID);
217 pldm_pdr_destroy(inPDRRepo);
218 }
219