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
26using namespace testing;
27using namespace testing::ext;
28
29META_BEGIN_NAMESPACE()
30
31class IntfAnyTest : public testing::Test {
32public:
33    static void SetUpTestSuite()
34    {
35        SetTest();
36    }
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 */
51HWTEST_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 */
71HWTEST_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 */
101HWTEST_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 */
134HWTEST_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 */
169HWTEST_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 */
213HWTEST_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 */
245HWTEST_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 */
311HWTEST_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 */
335HWTEST_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 */
371HWTEST_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
412META_END_NAMESPACE()