1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "TestRunner.h"
16
17 #include <gtest/gtest.h>
18
19 #include <base/util/uid_util.h>
20
21 #include <meta/interface/interface_helpers.h>
22 #include <meta/interface/intf_metadata.h>
23 #include <meta/interface/object_macros.h>
24
25 using namespace testing::ext;
26
27 META_BEGIN_NAMESPACE()
28
29 class InterfaceHelperTest : public testing::Test {
30 public:
SetUpTestSuite()31 static void SetUpTestSuite()
32 {
33 SetTest();
34 }
TearDownTestSuite()35 static void TearDownTestSuite()
36 {
37 TearDownTest();
38 }
SetUp()39 void SetUp() {}
TearDown()40 void TearDown() {}
41 };
42
43 namespace {
44
45 struct BaseA : public CORE_NS::IInterface {
46 META_INTERFACE(CORE_NS::IInterface, BaseA, "aefe1c98-1072-4867-8809-7fbea5887fa8")
47 };
48
49 struct BaseB : public CORE_NS::IInterface {
50 META_INTERFACE(CORE_NS::IInterface, BaseB, "916c2330-6096-41d8-b40a-2e04fe0b74cb")
51 };
52
53 struct BaseC : public CORE_NS::IInterface {
54 META_INTERFACE(CORE_NS::IInterface, BaseC, "c6dbe0a5-4201-454e-83d9-d944d20b52b6")
55 };
56
57 struct BaseD : public CORE_NS::IInterface {
58 META_INTERFACE(CORE_NS::IInterface, BaseD, "c891c511-9e80-4d31-8247-e74a2a2fc406")
59 };
60
61 struct BaseE3 : public CORE_NS::IInterface {
62 META_INTERFACE(CORE_NS::IInterface, BaseE3, "6fbdaf63-b0c6-45b3-acf4-5b15ac2059b1")
63 };
64
65 struct BaseE2 : public BaseE3 {
66 META_INTERFACE(BaseE3, BaseE2, "d44b6a34-9a8a-4588-9265-415e3a8a6787")
67 };
68
69 struct BaseE1 : public BaseE2 {
70 META_INTERFACE(BaseE2, BaseE1, "c1b8e289-878a-4fc5-b7f5-e5770f174244")
71 };
72
73 struct BaseE : public BaseE1 {
74 META_INTERFACE(BaseE1, BaseE, "c99600c5-84d7-456e-8540-389804f7244c")
75 };
76
77 struct Class : IntroduceInterfaces<BaseA, BaseB, BaseC, BaseD, BaseE> {
78 using MyBase = IntroduceInterfaces<BaseA, BaseB, BaseC, BaseD, BaseE>;
79 using MyBase::GetInterface;
80
81 template<typename T>
Cast__anon8d2127b40111::Class82 T* Cast()
83 {
84 return static_cast<T*>(this);
85 }
86 };
87
88 template<size_t S>
CONTAINS(Internal::UIDArray<S> arr,const BASE_NS::Uid & uid)89 constexpr bool CONTAINS(Internal::UIDArray<S> arr, const BASE_NS::Uid& uid)
90 {
91 for (size_t i = 0; i != S; ++i) {
92 if (arr.data[i].uid == uid) {
93 return true;
94 }
95 }
96 return false;
97 }
98
99 } // namespace
100
101 HWTEST_F(InterfaceHelperTest, IntroduceInterfaces, TestSize.Level1)
102 {
103 using CORE_NS::IInterface;
104 Class c;
105 EXPECT_TRUE(c.GetInterface(CORE_NS::IInterface::UID) == static_cast<IInterface*>(c.Cast<BaseA>()));
106 EXPECT_TRUE(c.GetInterface(BaseA::UID) == static_cast<IInterface*>(c.Cast<BaseA>()));
107 EXPECT_TRUE(c.GetInterface(BaseB::UID) == static_cast<IInterface*>(c.Cast<BaseB>()));
108 EXPECT_TRUE(c.GetInterface(BaseC::UID) == static_cast<IInterface*>(c.Cast<BaseC>()));
109 EXPECT_TRUE(c.GetInterface(BaseD::UID) == static_cast<IInterface*>(c.Cast<BaseD>()));
110 EXPECT_TRUE(c.GetInterface(BaseE::UID) == static_cast<IInterface*>(c.Cast<BaseE>()));
111 EXPECT_TRUE(c.GetInterface(BaseE1::UID) == static_cast<IInterface*>(c.Cast<BaseE1>()));
112 EXPECT_TRUE(c.GetInterface(BaseE2::UID) == static_cast<IInterface*>(c.Cast<BaseE2>()));
113 EXPECT_TRUE(c.GetInterface(BaseE3::UID) == static_cast<IInterface*>(c.Cast<BaseE3>()));
114 }
115
116 HWTEST_F(InterfaceHelperTest, GetInterfaces, TestSize.Level1)
117 {
118 using GI = GetInterfacesImpl<void, BaseA, BaseB, BaseC, BaseD, BaseE>;
119 static_assert(GI::SIZE == 8);
120
121 constexpr auto arr = GetInterfaces<void, BaseA, BaseB, BaseC, BaseD, BaseE>();
122 static_assert(sizeof(arr.data) / sizeof(arr.data[0]) == 8);
123
124 static_assert(CONTAINS(arr, BASE_NS::Uid { "aefe1c98-1072-4867-8809-7fbea5887fa8" }));
125 static_assert(CONTAINS(arr, BASE_NS::Uid { "916c2330-6096-41d8-b40a-2e04fe0b74cb" }));
126 static_assert(CONTAINS(arr, BASE_NS::Uid { "c6dbe0a5-4201-454e-83d9-d944d20b52b6" }));
127 static_assert(CONTAINS(arr, BASE_NS::Uid { "c891c511-9e80-4d31-8247-e74a2a2fc406" }));
128 static_assert(CONTAINS(arr, BASE_NS::Uid { "6fbdaf63-b0c6-45b3-acf4-5b15ac2059b1" }));
129 static_assert(CONTAINS(arr, BASE_NS::Uid { "d44b6a34-9a8a-4588-9265-415e3a8a6787" }));
130 static_assert(CONTAINS(arr, BASE_NS::Uid { "c1b8e289-878a-4fc5-b7f5-e5770f174244" }));
131 static_assert(CONTAINS(arr, BASE_NS::Uid { "c99600c5-84d7-456e-8540-389804f7244c" }));
132 }
133
134 struct IDervivedLifecycle : ILifecycle {
135 META_INTERFACE(ILifecycle, IDervivedLifecycle, "c891f671-9e80-4d31-8247-e74a2a2fc406")
136
BuildIDervivedLifecycle137 bool Build(const IMetadata::Ptr& parameters) override
138 {
139 return true;
140 }
SetInstanceIdIDervivedLifecycle141 void SetInstanceId(InstanceId) override {}
DestroyIDervivedLifecycle142 void Destroy() override {}
143 };
144
145 struct IOtherDervivedLifecycle : ILifecycle {
146 META_INTERFACE(ILifecycle, IOtherDervivedLifecycle, "c981f671-9e80-4d31-8247-e74a2a2fc406")
147
BuildIOtherDervivedLifecycle148 bool Build(const IMetadata::Ptr& parameters) override
149 {
150 return true;
151 }
SetInstanceIdIOtherDervivedLifecycle152 void SetInstanceId(InstanceId) override {}
DestroyIOtherDervivedLifecycle153 void Destroy() override {}
154 };
155
156 struct LivelyClass : IntroduceInterfaces<BaseA, IDervivedLifecycle, IOtherDervivedLifecycle, BaseD, BaseE> {
157 using MyBase = IntroduceInterfaces<BaseA, IDervivedLifecycle, IOtherDervivedLifecycle, BaseD, BaseE>;
158 using MyBase::GetInterface;
159 };
160
161 HWTEST_F(InterfaceHelperTest, ILifecycleSupport, TestSize.Level1)
162 {
163 static_assert(HAS_ILIFECYCLE<BaseA, BaseB, ILifecycle, BaseC>);
164 static_assert(HAS_ILIFECYCLE<BaseA, BaseB, IDervivedLifecycle, BaseC>);
165 static_assert(HAS_ILIFECYCLE<BaseA, IDervivedLifecycle, IDervivedLifecycle, BaseC>);
166 static_assert(HAS_ILIFECYCLE<BaseA, IOtherDervivedLifecycle, IDervivedLifecycle, BaseC>);
167
168 LivelyClass c;
169 EXPECT_TRUE(c.GetInterface(ILifecycle::UID));
170 EXPECT_TRUE(c.GetInterface(IDervivedLifecycle::UID));
171 }
172
173 struct BaseF : CORE_NS::IInterface {
174 META_INTERFACE(CORE_NS::IInterface, BaseF, "23f2cf2e-7052-4037-b2ca-c0164918f1e1")
175 };
176
177 struct BaseG : CORE_NS::IInterface {
178 META_INTERFACE(CORE_NS::IInterface, BaseG, "41a6cfd4-55dc-4372-8ec1-7ca68fdbcafe")
179 };
180
181 struct BaseH : CORE_NS::IInterface {
182 META_INTERFACE(CORE_NS::IInterface, BaseH, "920e72e2-abd5-4322-ba35-2a767db8ae89")
183 };
184
185 struct AnotherClass : IntroduceInterfaces<BaseF, BaseG> {};
186
187 struct TopClass : IntroduceInterfaces<Class, BaseH, AnotherClass> {
188 using MyBase = IntroduceInterfaces<Class, BaseH, AnotherClass>;
189 using MyBase::GetInterface;
190
191 template<typename T>
CastTopClass192 T* Cast()
193 {
194 return static_cast<T*>(this);
195 }
196 };
197
198 HWTEST_F(InterfaceHelperTest, EmbeddedIntroduceInterfacesSupport, TestSize.Level1)
199 {
200 using GI = GetInterfacesImpl<TopClass, Class, BaseH, AnotherClass>;
201 static_assert(GI::SIZE == 11);
202
203 constexpr auto arr = GetInterfaces<TopClass, Class, BaseH, AnotherClass>();
204 static_assert(sizeof(arr.data) / sizeof(arr.data[0]) == 11);
205
206 static_assert(CONTAINS(arr, BASE_NS::Uid { "aefe1c98-1072-4867-8809-7fbea5887fa8" }));
207 static_assert(CONTAINS(arr, BASE_NS::Uid { "916c2330-6096-41d8-b40a-2e04fe0b74cb" }));
208 static_assert(CONTAINS(arr, BASE_NS::Uid { "c6dbe0a5-4201-454e-83d9-d944d20b52b6" }));
209 static_assert(CONTAINS(arr, BASE_NS::Uid { "c891c511-9e80-4d31-8247-e74a2a2fc406" }));
210 static_assert(CONTAINS(arr, BASE_NS::Uid { "6fbdaf63-b0c6-45b3-acf4-5b15ac2059b1" }));
211 static_assert(CONTAINS(arr, BASE_NS::Uid { "d44b6a34-9a8a-4588-9265-415e3a8a6787" }));
212 static_assert(CONTAINS(arr, BASE_NS::Uid { "c1b8e289-878a-4fc5-b7f5-e5770f174244" }));
213 static_assert(CONTAINS(arr, BASE_NS::Uid { "c99600c5-84d7-456e-8540-389804f7244c" }));
214 static_assert(CONTAINS(arr, BASE_NS::Uid { "23f2cf2e-7052-4037-b2ca-c0164918f1e1" }));
215 static_assert(CONTAINS(arr, BASE_NS::Uid { "41a6cfd4-55dc-4372-8ec1-7ca68fdbcafe" }));
216 static_assert(CONTAINS(arr, BASE_NS::Uid { "920e72e2-abd5-4322-ba35-2a767db8ae89" }));
217 }
218
219 HWTEST_F(InterfaceHelperTest, EmbeddedIntroduceInterfacesSupportGetInterface, TestSize.Level1)
220 {
221 using CORE_NS::IInterface;
222 TopClass c;
223 EXPECT_TRUE(c.GetInterface(CORE_NS::IInterface::UID) == static_cast<IInterface*>(c.Cast<BaseA>()));
224 EXPECT_TRUE(c.GetInterface(BaseA::UID) == static_cast<IInterface*>(c.Cast<BaseA>()));
225 EXPECT_TRUE(c.GetInterface(BaseB::UID) == static_cast<IInterface*>(c.Cast<BaseB>()));
226 EXPECT_TRUE(c.GetInterface(BaseC::UID) == static_cast<IInterface*>(c.Cast<BaseC>()));
227 EXPECT_TRUE(c.GetInterface(BaseD::UID) == static_cast<IInterface*>(c.Cast<BaseD>()));
228 EXPECT_TRUE(c.GetInterface(BaseE::UID) == static_cast<IInterface*>(c.Cast<BaseE>()));
229 EXPECT_TRUE(c.GetInterface(BaseE1::UID) == static_cast<IInterface*>(c.Cast<BaseE1>()));
230 EXPECT_TRUE(c.GetInterface(BaseE2::UID) == static_cast<IInterface*>(c.Cast<BaseE2>()));
231 EXPECT_TRUE(c.GetInterface(BaseE3::UID) == static_cast<IInterface*>(c.Cast<BaseE3>()));
232 EXPECT_TRUE(c.GetInterface(BaseF::UID) == static_cast<IInterface*>(c.Cast<BaseF>()));
233 EXPECT_TRUE(c.GetInterface(BaseG::UID) == static_cast<IInterface*>(c.Cast<BaseG>()));
234 EXPECT_TRUE(c.GetInterface(BaseH::UID) == static_cast<IInterface*>(c.Cast<BaseH>()));
235 }
236
237 META_END_NAMESPACE()
238