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
16 #include "common_components/tests/test_helper.h"
17 #include "common_interfaces/objects/composite_base_class.h"
18 #include "common_interfaces/objects/base_object.h"
19
20 #include <vector>
21 #include <memory>
22 #include <functional>
23
24 namespace common {
25 class CompositeBaseClassTest : public test::BaseTestWithScope {
26 protected:
MockAllocator()27 static CompositeBaseClass* MockAllocator()
28 {
29 void* memory = ::operator new(sizeof(uint64_t) * 16);
30
31 auto* baseClass = reinterpret_cast<BaseClass*>(memory);
32 baseClass->SetObjectType(CommonType::LINE_STRING);
33 baseClass->ClearBitField();
34
35 return reinterpret_cast<CompositeBaseClass*>(baseClass);
36 }
37
SetUp()38 void SetUp() override
39 {
40 roots_ = std::make_unique<BaseClassRoots>();
41 }
42
TearDown()43 void TearDown() override
44 {
45 roots_.reset();
46 }
47
48 std::unique_ptr<BaseClassRoots> roots_;
49 };
50
HWTEST_F_L0(CompositeBaseClassTest,InitializeOnce)51 HWTEST_F_L0(CompositeBaseClassTest, InitializeOnce)
52 {
53 auto allocator = []() -> CompositeBaseClass* {
54 return CompositeBaseClassTest::MockAllocator();
55 };
56
57 roots_->InitializeCompositeBaseClass(allocator);
58 roots_->InitializeCompositeBaseClass(allocator);
59
60 EXPECT_TRUE(true);
61 }
62
HWTEST_F_L0(CompositeBaseClassTest,CreateAndGetType)63 HWTEST_F_L0(CompositeBaseClassTest, CreateAndGetType)
64 {
65 auto allocator = []() -> CompositeBaseClass* {
66 return CompositeBaseClassTest::MockAllocator();
67 };
68
69 roots_->InitializeCompositeBaseClass(allocator);
70
71 auto* baseClass = roots_->GetBaseClass(CommonType::LINE_STRING);
72 ASSERT_NE(baseClass, nullptr);
73 EXPECT_EQ(baseClass->GetObjectType(), CommonType::LINE_STRING);
74 }
75
HWTEST_F_L0(CompositeBaseClassTest,GetBaseClassReturnsCorrectType)76 HWTEST_F_L0(CompositeBaseClassTest, GetBaseClassReturnsCorrectType)
77 {
78 auto allocator = []() -> CompositeBaseClass* {
79 return CompositeBaseClassTest::MockAllocator();
80 };
81
82 roots_->InitializeCompositeBaseClass(allocator);
83
84 auto* lineString = roots_->GetBaseClass(CommonType::LINE_STRING);
85 auto* slicedString = roots_->GetBaseClass(CommonType::SLICED_STRING);
86 auto* treeString = roots_->GetBaseClass(CommonType::TREE_STRING);
87
88 ASSERT_NE(lineString, nullptr);
89 ASSERT_NE(slicedString, nullptr);
90 ASSERT_NE(treeString, nullptr);
91
92 EXPECT_EQ(lineString->GetObjectType(), CommonType::LINE_STRING);
93 EXPECT_EQ(slicedString->GetObjectType(), CommonType::SLICED_STRING);
94 EXPECT_EQ(treeString->GetObjectType(), CommonType::TREE_STRING);
95 }
96
HWTEST_F_L0(CompositeBaseClassTest,IterateCompositeBaseClass)97 HWTEST_F_L0(CompositeBaseClassTest, IterateCompositeBaseClass)
98 {
99 auto allocator = []() -> CompositeBaseClass* {
100 return CompositeBaseClassTest::MockAllocator();
101 };
102
103 roots_->InitializeCompositeBaseClass(allocator);
104
105 std::vector<CompositeBaseClass*> visited;
106
107 roots_->IterateCompositeBaseClass([&visited](RefField<>& field) {
108 auto* ptr = reinterpret_cast<CompositeBaseClass*>(const_cast<void*>(static_cast<const void*>(&field)));
109 visited.push_back(ptr);
110 });
111
112 EXPECT_EQ(visited.size(), 3);
113 }
114 }