1 /*
2  * Copyright (C) 2024 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 
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 
19 #include <meta/interface/detail/any.h>
20 #include <meta/interface/intf_object_registry.h>
21 
22 #include "src/test_runner.h"
23 #include "src/testing_objects.h"
24 #include "src/util.h"
25 
26 using namespace testing;
27 using namespace testing::ext;
28 
29 META_BEGIN_NAMESPACE()
30 
31 class IntfAnyTest : public testing::Test {
32 public:
SetUpTestSuite()33     static void SetUpTestSuite()
34     {
35         SetTest();
36     }
TearDownTestSuite()37     static void TearDownTestSuite()
38     {
39         ResetTest();
40     }
41     void SetUp() override {}
42     void TearDown() override {}
43 };
44 
45 /**
46  * @tc.name: IntfAnyTest
47  * @tc.desc: test BasicCompatibility001 function
48  * @tc.type: FUNC
49  * @tc.require: I7DMS1
50  */
HWTEST_F(IntfAnyTest, BasicCompatibility001, TestSize.Level1)51 HWTEST_F(IntfAnyTest, BasicCompatibility001, TestSize.Level1)
52 {
53     Any<uint32_t> any { 1 };
54     TypeId uid = UidFromType<uint32_t>();
55     EXPECT_THAT(any.GetCompatibleTypes(CompatibilityDirection::BOTH), UnorderedElementsAre(uid));
56     EXPECT_TRUE(IsCompatible(any, uid));
57     EXPECT_TRUE(IsCompatibleWith<uint32_t>(any));
58     EXPECT_TRUE(IsSetCompatible(any, uid));
59     EXPECT_TRUE(IsSetCompatibleWith<uint32_t>(any));
60     EXPECT_TRUE(IsGetCompatible(any, uid));
61     EXPECT_TRUE(IsGetCompatibleWith<uint32_t>(any));
62     EXPECT_EQ(any.GetTypeId(), uid);
63 }
64 
65 /**
66  * @tc.name: IntfAnyTest
67  * @tc.desc: test SharedPointerCompatibility function
68  * @tc.type: FUNC
69  * @tc.require: I7DMS1
70  */
HWTEST_F(IntfAnyTest, SharedPointerCompatibility, TestSize.Level1)71 HWTEST_F(IntfAnyTest, SharedPointerCompatibility, TestSize.Level1)
72 {
73     Any<IObject::Ptr> any { CreateTestType<IObject>() };
74     TypeId uid = UidFromType<IObject::Ptr>();
75     EXPECT_THAT(any.GetCompatibleTypes(CompatibilityDirection::BOTH), UnorderedElementsAre(uid, SharedPtrIInterfaceId));
76     EXPECT_THAT(any.GetCompatibleTypes(CompatibilityDirection::SET), UnorderedElementsAre(uid, SharedPtrIInterfaceId));
77     EXPECT_THAT(any.GetCompatibleTypes(CompatibilityDirection::GET),
78         UnorderedElementsAre(uid, SharedPtrIInterfaceId, SharedPtrConstIInterfaceId));
79     EXPECT_TRUE(IsCompatible(any, uid));
80     EXPECT_TRUE(IsCompatibleWith<IObject::Ptr>(any));
81     EXPECT_TRUE(IsSetCompatible(any, uid));
82     EXPECT_TRUE(IsSetCompatibleWith<IObject::Ptr>(any));
83     EXPECT_TRUE(IsSetCompatibleWith<SharedPtrIInterface>(any));
84     EXPECT_TRUE(IsGetCompatible(any, uid));
85     EXPECT_TRUE(IsGetCompatibleWith<IObject::Ptr>(any));
86     EXPECT_TRUE(IsGetCompatibleWith<SharedPtrIInterface>(any));
87     EXPECT_TRUE(IsGetCompatibleWith<SharedPtrConstIInterface>(any));
88     EXPECT_EQ(any.GetTypeId(), uid);
89 
90     Any<IObject::ConstPtr> constAny { CreateTestType<IObject>() };
91     EXPECT_FALSE(IsGetCompatibleWith<SharedPtrIInterface>(constAny));
92     EXPECT_TRUE(IsGetCompatibleWith<SharedPtrConstIInterface>(constAny));
93 }
94 
95 /**
96  * @tc.name: IntfAnyTest
97  * @tc.desc: test WeakPointerCompatibility function
98  * @tc.type: FUNC
99  * @tc.require: I7DMS1
100  */
HWTEST_F(IntfAnyTest, WeakPointerCompatibility, TestSize.Level1)101 HWTEST_F(IntfAnyTest, WeakPointerCompatibility, TestSize.Level1)
102 {
103     IObject::Ptr p = CreateTestType<IObject>();
104     Any<IObject::WeakPtr> any { p };
105     TypeId uid = UidFromType<IObject::WeakPtr>();
106     EXPECT_THAT(any.GetCompatibleTypes(CompatibilityDirection::BOTH),
107         UnorderedElementsAre(uid, SharedPtrIInterfaceId, WeakPtrIInterfaceId));
108     EXPECT_THAT(any.GetCompatibleTypes(CompatibilityDirection::SET),
109         UnorderedElementsAre(uid, SharedPtrIInterfaceId, WeakPtrIInterfaceId));
110     EXPECT_THAT(any.GetCompatibleTypes(CompatibilityDirection::GET),
111         UnorderedElementsAre(
112             uid, SharedPtrIInterfaceId, SharedPtrConstIInterfaceId, WeakPtrIInterfaceId, WeakPtrConstIInterfaceId));
113     EXPECT_TRUE(IsCompatible(any, uid));
114     EXPECT_TRUE(IsCompatibleWith<IObject::WeakPtr>(any));
115     EXPECT_TRUE(IsSetCompatible(any, uid));
116     EXPECT_TRUE(IsSetCompatibleWith<IObject::WeakPtr>(any));
117     EXPECT_TRUE(IsSetCompatibleWith<SharedPtrIInterface>(any));
118     EXPECT_TRUE(IsSetCompatibleWith<WeakPtrIInterface>(any));
119     EXPECT_TRUE(IsGetCompatible(any, uid));
120     EXPECT_TRUE(IsGetCompatibleWith<IObject::WeakPtr>(any));
121     EXPECT_TRUE(IsGetCompatibleWith<SharedPtrIInterface>(any));
122     EXPECT_TRUE(IsGetCompatibleWith<SharedPtrConstIInterface>(any));
123     EXPECT_TRUE(IsGetCompatibleWith<WeakPtrIInterface>(any));
124     EXPECT_TRUE(IsGetCompatibleWith<WeakPtrConstIInterface>(any));
125     EXPECT_EQ(any.GetTypeId(), uid);
126 }
127 
128 /**
129  * @tc.name: IntfAnyTest
130  * @tc.desc: test GetSet001 function
131  * @tc.type: FUNC
132  * @tc.require: I7DMS1
133  */
HWTEST_F(IntfAnyTest, GetSet001, TestSize.Level1)134 HWTEST_F(IntfAnyTest, GetSet001, TestSize.Level1)
135 {
136     Any<uint32_t> any { 1 };
137     uint32_t v = 0;
138     EXPECT_TRUE(any.GetValue(v));
139     EXPECT_EQ(v, 1);
140     EXPECT_EQ(GetValue<uint32_t>(any), 1);
141 
142     EXPECT_TRUE(any.SetValue((uint32_t(2))));
143     EXPECT_EQ(GetValue<uint32_t>(any), 2);
144 
145     EXPECT_FALSE(any.SetValue(float(3.0f)));
146     EXPECT_EQ(GetValue<float>(any), 0);
147 
148     Any<uint32_t> other;
149     EXPECT_TRUE(other.CopyFrom(any));
150     EXPECT_EQ(GetValue<uint32_t>(other), 2);
151 
152     auto c1 = other.Clone(false);
153     ASSERT_TRUE(c1);
154     EXPECT_EQ(GetValue<uint32_t>(*c1), 0);
155     auto c2 = other.Clone(true);
156     ASSERT_TRUE(c2);
157     EXPECT_EQ(GetValue<uint32_t>(*c2), 2);
158 
159     Any<float> otherType;
160     EXPECT_FALSE(otherType.CopyFrom(any));
161 }
162 
163 /**
164  * @tc.name: IntfAnyTest
165  * @tc.desc: test GetSetSharedPointer function
166  * @tc.type: FUNC
167  * @tc.require: I7DMS1
168  */
HWTEST_F(IntfAnyTest, GetSetSharedPointer, TestSize.Level1)169 HWTEST_F(IntfAnyTest, GetSetSharedPointer, TestSize.Level1)
170 {
171     auto p = CreateTestType<IObject>();
172     auto p2 = CreateTestType<IObject>();
173     {
174         Any<IObject::Ptr> any { p };
175         IObject::Ptr v;
176         EXPECT_TRUE(any.GetValue(v));
177         EXPECT_EQ(v, p);
178         EXPECT_EQ(GetValue<IObject::Ptr>(any), p);
179         EXPECT_TRUE(any.SetValue(interface_pointer_cast<CORE_NS::IInterface>(p2)));
180         EXPECT_EQ(GetValue<IObject::Ptr>(any), p2);
181     }
182     {
183         Any<IObject::Ptr> any { p };
184         SharedPtrIInterface v;
185         EXPECT_TRUE(any.GetValue(v));
186         EXPECT_EQ(interface_pointer_cast<IObject>(v), p);
187         EXPECT_EQ(interface_pointer_cast<IObject>(GetValue<SharedPtrIInterface>(any)), p);
188         EXPECT_EQ(interface_pointer_cast<IObject>(GetValue<SharedPtrConstIInterface>(any)), p);
189         EXPECT_TRUE(any.SetValue(interface_pointer_cast<CORE_NS::IInterface>(p2)));
190         EXPECT_EQ(interface_pointer_cast<IObject>(GetValue<SharedPtrConstIInterface>(any)), p2);
191     }
192     {
193         auto p = CreateTestType<IObject>();
194         Any<IObject::ConstPtr> constAny { p };
195         SharedPtrConstIInterface v;
196         EXPECT_TRUE(constAny.GetValue(v));
197         EXPECT_EQ(interface_pointer_cast<IObject>(v), p);
198         EXPECT_NE(interface_pointer_cast<IObject>(GetValue<SharedPtrIInterface>(constAny)), p);
199         EXPECT_EQ(interface_pointer_cast<IObject>(GetValue<SharedPtrConstIInterface>(constAny)), p);
200         EXPECT_TRUE(constAny.SetValue(interface_pointer_cast<CORE_NS::IInterface>(p2)));
201         EXPECT_EQ(interface_pointer_cast<IObject>(GetValue<SharedPtrConstIInterface>(constAny)), p2);
202         EXPECT_TRUE(constAny.SetValue(interface_pointer_cast<const CORE_NS::IInterface>(p)));
203         EXPECT_EQ(interface_pointer_cast<IObject>(GetValue<SharedPtrConstIInterface>(constAny)), p);
204     }
205 }
206 
207 /**
208  * @tc.name: IntfAnyTest
209  * @tc.desc: test GetSetWeakPointer function
210  * @tc.type: FUNC
211  * @tc.require: I7DMS1
212  */
HWTEST_F(IntfAnyTest, GetSetWeakPointer, TestSize.Level1)213 HWTEST_F(IntfAnyTest, GetSetWeakPointer, TestSize.Level1)
214 {
215     auto p = CreateTestType<IObject>();
216     auto p2 = CreateTestType<IObject>();
217     WeakPtrIInterface weak = interface_pointer_cast<CORE_NS::IInterface>(p2);
218 
219     {
220         Any<IObject::WeakPtr> any { p };
221         IObject::WeakPtr v;
222         EXPECT_TRUE(any.GetValue(v));
223         EXPECT_EQ(v.lock(), p);
224         EXPECT_EQ(GetValue<IObject::WeakPtr>(any).lock(), p);
225         EXPECT_EQ(interface_pointer_cast<IObject>(GetValue<WeakPtrIInterface>(any)), p);
226         EXPECT_EQ(interface_pointer_cast<IObject>(GetValue<WeakPtrConstIInterface>(any)), p);
227         EXPECT_TRUE(any.SetValue(weak));
228         EXPECT_EQ(GetValue<IObject::WeakPtr>(any).lock(), p2);
229     }
230     {
231         Any<IObject::WeakPtr> any { p };
232         SharedPtrIInterface v;
233         EXPECT_TRUE(any.GetValue(v));
234         EXPECT_EQ(interface_pointer_cast<IObject>(v), p);
235         EXPECT_EQ(interface_pointer_cast<IObject>(GetValue<SharedPtrIInterface>(any)), p);
236     }
237 }
238 
239 /**
240  * @tc.name: IntfAnyTest
241  * @tc.desc: test PtrCopyFrom function
242  * @tc.type: FUNC
243  * @tc.require: I7DMS1
244  */
HWTEST_F(IntfAnyTest, PtrCopyFrom, TestSize.Level1)245 HWTEST_F(IntfAnyTest, PtrCopyFrom, TestSize.Level1)
246 {
247     auto p1 = CreateTestType<IObject>();
248     auto p2 = CreateTestType<IObject>();
249     {
250         Any<IObject::Ptr> any { p1 };
251         Any<IObject::Ptr> source { p2 };
252         EXPECT_TRUE(any.CopyFrom(source));
253         EXPECT_EQ(GetValue<IObject::Ptr>(any), p2);
254     }
255     {
256         Any<IObject::Ptr> any { p1 };
257         Any<SharedPtrIInterface> source { interface_pointer_cast<CORE_NS::IInterface>(p2) };
258         EXPECT_TRUE(any.CopyFrom(source));
259         EXPECT_EQ(GetValue<IObject::Ptr>(any), p2);
260     }
261     {
262         Any<IObject::Ptr> any { p1 };
263         Any<ITestType::Ptr> source { interface_pointer_cast<ITestType>(p2) };
264         EXPECT_TRUE(any.CopyFrom(source));
265         EXPECT_EQ(GetValue<IObject::Ptr>(any), p2);
266     }
267     {
268         Any<IObject::ConstPtr> any { p1 };
269         Any<IObject::Ptr> source { p2 };
270         EXPECT_TRUE(any.CopyFrom(source));
271         EXPECT_EQ(GetValue<IObject::ConstPtr>(any), p2);
272     }
273     {
274         Any<IObject::ConstPtr> any { p1 };
275         Any<SharedPtrIInterface> source { interface_pointer_cast<CORE_NS::IInterface>(p2) };
276         EXPECT_TRUE(any.CopyFrom(source));
277         EXPECT_EQ(GetValue<IObject::ConstPtr>(any), p2);
278     }
279     {
280         Any<IObject::ConstPtr> any { p1 };
281         Any<ITestType::Ptr> source { interface_pointer_cast<ITestType>(p2) };
282         EXPECT_TRUE(any.CopyFrom(source));
283         EXPECT_EQ(GetValue<IObject::ConstPtr>(any), p2);
284     }
285     {
286         Any<IObject::ConstPtr> any { p1 };
287         Any<IObject::ConstPtr> source { p2 };
288         EXPECT_TRUE(any.CopyFrom(source));
289         EXPECT_EQ(GetValue<IObject::ConstPtr>(any), p2);
290     }
291     {
292         Any<IObject::ConstPtr> any { p1 };
293         Any<SharedPtrConstIInterface> source { interface_pointer_cast<CORE_NS::IInterface>(p2) };
294         EXPECT_TRUE(any.CopyFrom(source));
295         EXPECT_EQ(GetValue<IObject::ConstPtr>(any), p2);
296     }
297     {
298         Any<IObject::ConstPtr> any { p1 };
299         Any<ITestType::ConstPtr> source { interface_pointer_cast<ITestType>(p2) };
300         EXPECT_TRUE(any.CopyFrom(source));
301         EXPECT_EQ(GetValue<IObject::ConstPtr>(any), p2);
302     }
303 }
304 
305 /**
306  * @tc.name: IntfAnyTest
307  * @tc.desc: test BasicCompatibility002 function
308  * @tc.type: FUNC
309  * @tc.require: I7DMS1
310  */
HWTEST_F(IntfAnyTest, BasicCompatibility002, TestSize.Level1)311 HWTEST_F(IntfAnyTest, BasicCompatibility002, TestSize.Level1)
312 {
313     ArrayAny<uint32_t> any { 1, 2, 3 };
314     using Type = uint32_t[];
315 
316     TypeId arrayUid = ArrayUidFromType<uint32_t>();
317     TypeId vectorUid = UidFromType<BASE_NS::vector<uint32_t>>();
318 
319     EXPECT_THAT(any.GetCompatibleTypes(CompatibilityDirection::BOTH), UnorderedElementsAre(arrayUid, vectorUid));
320     EXPECT_TRUE(IsCompatible(any, arrayUid));
321     EXPECT_TRUE(IsCompatibleWith<Type>(any));
322     EXPECT_TRUE(IsSetCompatible(any, arrayUid));
323     EXPECT_TRUE(IsSetCompatibleWith<Type>(any));
324     EXPECT_TRUE(IsGetCompatible(any, arrayUid));
325     EXPECT_TRUE(IsGetCompatibleWith<Type>(any));
326     EXPECT_EQ(any.GetTypeId(), arrayUid);
327 }
328 
329 /**
330  * @tc.name: IntfAnyTest
331  * @tc.desc: test GetSetTypes function
332  * @tc.type: FUNC
333  * @tc.require: I7DMS1
334  */
HWTEST_F(IntfAnyTest, GetSetTypes, TestSize.Level1)335 HWTEST_F(IntfAnyTest, GetSetTypes, TestSize.Level1)
336 {
337     static constexpr auto valueCount = 3;
338     const uint32_t valuesArr[valueCount] = { 1, 2, 3 };
339     const BASE_NS::vector<uint32_t> vectorArr = { 4, 5, 6 };
340 
341     auto arrayUid = UidFromType<uint32_t[]>();
342     auto vectorUid = UidFromType<BASE_NS::vector<uint32_t>>();
343 
344     ArrayAny<uint32_t> any { valuesArr };
345 
346     uint32_t values[valueCount];
347     auto valuesSize = sizeof(uint32_t) * valueCount;
348 
349     EXPECT_TRUE(any.GetData(arrayUid, values, valuesSize));
350     EXPECT_THAT(values, ::ElementsAreArray(valuesArr));
351 
352     BASE_NS::vector<uint32_t> valuesVec;
353     EXPECT_TRUE(any.GetData(vectorUid, &valuesVec, sizeof(valuesVec)));
354     EXPECT_THAT(values, ::ElementsAreArray(valuesArr));
355 
356     EXPECT_TRUE(any.SetData(vectorUid, &vectorArr, sizeof(vectorArr)));
357     EXPECT_TRUE(any.GetData(arrayUid, values, valuesSize));
358     EXPECT_THAT(values, ::ElementsAreArray(vectorArr));
359 
360     EXPECT_TRUE(any.SetData(arrayUid, vectorArr.data(), sizeof(uint32_t) * vectorArr.size()));
361     EXPECT_TRUE(any.GetData(arrayUid, values, valuesSize));
362     EXPECT_THAT(values, ::ElementsAreArray(vectorArr));
363 }
364 
365 /**
366  * @tc.name: IntfAnyTest
367  * @tc.desc: test GetSet002 function
368  * @tc.type: FUNC
369  * @tc.require: I7DMS1
370  */
HWTEST_F(IntfAnyTest, GetSet002, TestSize.Level1)371 HWTEST_F(IntfAnyTest, GetSet002, TestSize.Level1)
372 {
373     using ArrayType = BASE_NS::vector<uint32_t>;
374 
375     BASE_NS::vector<uint32_t> vv { 1 };
376     ArrayAny<uint32_t> any { vv };
377     uint32_t v = 0;
378     EXPECT_TRUE(any.GetValueAt(0, v));
379     EXPECT_EQ(v, 1);
380     EXPECT_EQ(GetValue<BASE_NS::vector<uint32_t>>(any), vv);
381 
382     EXPECT_FALSE(any.GetValue(1, v));
383     EXPECT_FALSE(any.SetValue(1, v));
384     EXPECT_EQ(GetValue<ArrayType>(any), vv);
385 
386     EXPECT_TRUE(any.SetValueAt(0, static_cast<uint32_t>(42)));
387     EXPECT_TRUE(any.GetValueAt(0, v));
388     EXPECT_EQ(v, 42);
389 
390     vv = { 1, 2 };
391     EXPECT_TRUE(any.SetValue(vv));
392     EXPECT_EQ(GetValue<ArrayType>(any), vv);
393 
394     EXPECT_FALSE(any.SetValue(3.0f));
395     EXPECT_EQ(GetValue<ArrayType>(any), vv);
396 
397     ArrayAny<uint32_t> other;
398     EXPECT_TRUE(other.CopyFrom(any));
399     EXPECT_EQ(GetValue<ArrayType>(other), vv);
400 
401     auto c1 = interface_pointer_cast<IArrayAny>(other.Clone(false));
402     ASSERT_TRUE(c1);
403     EXPECT_EQ(c1->GetSize(), 0);
404     auto c2 = interface_pointer_cast<IArrayAny>(other.Clone(true));
405     ASSERT_TRUE(c2);
406     EXPECT_EQ(GetValue<ArrayType>(*c2), vv);
407 
408     ArrayAny<float> otherType;
409     EXPECT_FALSE(otherType.CopyFrom(any));
410 }
411 
412 META_END_NAMESPACE()