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 <TestRunner.h> 17 #include <gmock/gmock.h> 18 #include <gtest/gtest.h> 19 20 #include <meta/api/util.h> 21 #include <meta/base/bit_field.h> 22 #include <meta/ext/object_fwd.h> 23 #include <meta/interface/intf_object.h> 24 #include <meta/interface/intf_object_registry.h> 25 26 enum TestFlagBits : uint32_t { 27 FLAG1 = 1, 28 FLAG2 = 2, 29 FLAG4 = 4, 30 }; 31 32 using TestFlags = META_NS::EnumBitField<TestFlagBits, uint64_t>; 33 META_TYPE(TestFlags) 34 35 META_BEGIN_NAMESPACE() 36 37 using namespace ::testing; 38 using namespace testing::ext; 39 40 META_REGISTER_INTERFACE(ITestFlagsInterface, "eba09b49-6efe-4b97-b809-981569a935e7") 41 42 class ITestFlagsInterface : public CORE_NS::IInterface { 43 META_INTERFACE(CORE_NS::IInterface, ITestFlagsInterface) 44 public: 45 META_PROPERTY(TestFlags, Flags) 46 }; 47 48 META_REGISTER_CLASS( 49 BitfieldPropertyObject, "e62b0ab3-b07d-4423-b2bc-d4a522db8ded", META_NS::ObjectCategoryBits::NO_CATEGORY) 50 51 class BitfieldPropertyObject final : public IntroduceInterfaces<META_NS::ObjectFwd, ITestFlagsInterface> { 52 META_OBJECT(BitfieldPropertyObject, ClassId::BitfieldPropertyObject, IntroduceInterfaces) 53 public: 54 META_BEGIN_STATIC_DATA() 55 META_STATIC_PROPERTY_DATA(ITestFlagsInterface, TestFlags, Flags, TestFlagBits::FLAG2) 56 META_END_STATIC_DATA() 57 META_IMPLEMENT_PROPERTY(TestFlags, Flags) 58 }; 59 60 class BitfieldPropertyTest : public ::testing::Test { 61 public: SetUpTestSuite()62 static void SetUpTestSuite() 63 { 64 SetTest(); 65 RegisterObjectType<BitfieldPropertyObject>(); 66 } TearDownTestSuite()67 static void TearDownTestSuite() 68 { 69 UnregisterObjectType<BitfieldPropertyObject>(); 70 TearDownTest(); 71 } 72 SetUp()73 void SetUp() override 74 { 75 object_ = GetObjectRegistry().Create<ITestFlagsInterface>(ClassId::BitfieldPropertyObject); 76 ASSERT_NE(object_, nullptr); 77 } TearDown()78 void TearDown() override 79 { 80 object_.reset(); 81 } 82 83 protected: 84 ITestFlagsInterface::Ptr object_; 85 }; 86 87 MATCHER_P(ExactBitsSet, n, "") 88 { 89 return arg == n; 90 } 91 92 /** 93 * @tc.name: GetValue 94 * @tc.desc: test GetValue 95 * @tc.type:FUNC 96 * @tc.require: 97 */ 98 HWTEST_F(BitfieldPropertyTest, GetValue, TestSize.Level1) 99 { 100 EXPECT_EQ(GetValue(object_->Flags()), TestFlagBits::FLAG2); 101 } 102 103 /** 104 * @tc.name: SetValue 105 * @tc.desc: test SetValue 106 * @tc.type:FUNC 107 * @tc.require: 108 */ 109 HWTEST_F(BitfieldPropertyTest, SetValue, TestSize.Level1) 110 { 111 SetValue(object_->Flags(), TestFlagBits::FLAG1 | TestFlagBits::FLAG4); 112 EXPECT_EQ(GetValue(object_->Flags()), TestFlagBits::FLAG1 | TestFlagBits::FLAG4); 113 } 114 115 /** 116 * @tc.name: SetValueOp 117 * @tc.desc: test SetValueOp 118 * @tc.type:FUNC 119 * @tc.require: 120 */ 121 HWTEST_F(BitfieldPropertyTest, SetValueOp, TestSize.Level1) 122 { 123 TestFlags value1 = TestFlagBits::FLAG2; 124 SetValue(object_->Flags(), value1 | TestFlagBits::FLAG1 | TestFlagBits::FLAG4); 125 EXPECT_EQ(GetValue(object_->Flags()), TestFlagBits::FLAG1 | TestFlagBits::FLAG2 | TestFlagBits::FLAG4); 126 } 127 128 /** 129 * @tc.name: Or001 130 * @tc.desc: test EnumBitField Or 131 * @tc.type:FUNC 132 * @tc.require: 133 */ 134 HWTEST_F(BitfieldPropertyTest, Or001, TestSize.Level1) 135 { 136 EnumBitField<TestFlagBits> value1(TestFlagBits::FLAG1); 137 EnumBitField<TestFlagBits> value2(TestFlagBits::FLAG2 | TestFlagBits::FLAG4); 138 EXPECT_THAT( 139 (value1 | value2).GetValue(), ExactBitsSet(TestFlagBits::FLAG1 | TestFlagBits::FLAG2 | TestFlagBits::FLAG4)); 140 } 141 142 /** 143 * @tc.name: And001 144 * @tc.desc: test EnumBitField And 145 * @tc.type:FUNC 146 * @tc.require: 147 */ 148 HWTEST_F(BitfieldPropertyTest, And001, TestSize.Level1) 149 { 150 EnumBitField<TestFlagBits> value1(TestFlagBits::FLAG1); 151 EnumBitField<TestFlagBits> value2(TestFlagBits::FLAG1 | TestFlagBits::FLAG2 | TestFlagBits::FLAG4); 152 EXPECT_THAT((value1 & value2).GetValue(), ExactBitsSet(TestFlagBits::FLAG1)); 153 } 154 155 /** 156 * @tc.name: Xor001 157 * @tc.desc: test EnumBitField Xor 158 * @tc.type:FUNC 159 * @tc.require: 160 */ 161 HWTEST_F(BitfieldPropertyTest, Xor001, TestSize.Level1) 162 { 163 EnumBitField<TestFlagBits> value1(TestFlagBits::FLAG1); 164 EnumBitField<TestFlagBits> value2(TestFlagBits::FLAG1 | TestFlagBits::FLAG2 | TestFlagBits::FLAG4); 165 EXPECT_THAT((value1 ^ value2).GetValue(), ExactBitsSet(TestFlagBits::FLAG2 | TestFlagBits::FLAG4)); 166 } 167 168 /** 169 * @tc.name: Not001 170 * @tc.desc: test EnumBitField Not 171 * @tc.type:FUNC 172 * @tc.require: 173 */ 174 HWTEST_F(BitfieldPropertyTest, Not001, TestSize.Level1) 175 { 176 EnumBitField<TestFlagBits> value1(TestFlagBits::FLAG1); 177 EXPECT_THAT((~value1).GetValue(), ExactBitsSet(~TestFlagBits::FLAG1)); 178 } 179 180 /** 181 * @tc.name: SetAndClear001 182 * @tc.desc: test EnumBitField SetAndClear 183 * @tc.type:FUNC 184 * @tc.require: 185 */ 186 HWTEST_F(BitfieldPropertyTest, SetAndClear001, TestSize.Level1) 187 { 188 EnumBitField<TestFlagBits> value(TestFlagBits::FLAG1); 189 EXPECT_TRUE(value.IsSet(TestFlagBits::FLAG1)); 190 EXPECT_FALSE(value.IsSet(TestFlagBits::FLAG2)); 191 value.Set(TestFlagBits::FLAG2); 192 EXPECT_TRUE(value.IsSet(TestFlagBits::FLAG2)); 193 value.Clear(TestFlagBits::FLAG1); 194 EXPECT_FALSE(value.IsSet(TestFlagBits::FLAG1)); 195 EXPECT_TRUE(value.IsSet(TestFlagBits::FLAG2)); 196 } 197 198 enum ExtTestFlagBits : uint32_t { 199 FLAG1 = 1, 200 FLAG2 = 2, 201 FLAG4 = 4, 202 }; 203 204 using ExtTestFlags = META_NS::SubEnumBitField<ExtTestFlagBits, TestFlags, 16, 16>; // 16: param 205 206 /** 207 * @tc.name: Value 208 * @tc.desc: test TestFlags Value 209 * @tc.type:FUNC 210 * @tc.require: 211 */ 212 HWTEST_F(BitfieldPropertyTest, Value, TestSize.Level1) 213 { 214 TestFlags base(TestFlagBits::FLAG1); 215 ExtTestFlags ext(ExtTestFlagBits::FLAG2); 216 217 TestFlags res = base | ext; 218 EXPECT_THAT(res.GetValue(), ExactBitsSet(TestFlagBits::FLAG1 | (ExtTestFlagBits::FLAG2 << 16))); 219 220 ExtTestFlags sub(res); 221 EXPECT_EQ(ext, sub); 222 EXPECT_THAT(sub.GetValue(), ExactBitsSet(ExtTestFlagBits::FLAG2 << 16)); 223 EXPECT_THAT((ExtTestFlagBits)sub, ExactBitsSet(ExtTestFlagBits::FLAG2)); 224 } 225 226 /** 227 * @tc.name: Or002 228 * @tc.desc: test TestFlags Or 229 * @tc.type:FUNC 230 * @tc.require: 231 */ 232 HWTEST_F(BitfieldPropertyTest, Or002, TestSize.Level1) 233 { 234 TestFlags base(TestFlagBits::FLAG1); 235 ExtTestFlags ext(ExtTestFlagBits::FLAG2); 236 EXPECT_THAT(base | ext, ExactBitsSet(TestFlagBits::FLAG1 | (ExtTestFlagBits::FLAG2 << 16))); 237 } 238 239 /** 240 * @tc.name: And002 241 * @tc.desc: test TestFlags And 242 * @tc.type:FUNC 243 * @tc.require: 244 */ 245 HWTEST_F(BitfieldPropertyTest, And002, TestSize.Level1) 246 { 247 TestFlags base(TestFlagBits::FLAG1); 248 ExtTestFlags ext(ExtTestFlagBits::FLAG2); 249 TestFlags res = base | ext; 250 EXPECT_THAT(res & ext, ExactBitsSet(ExtTestFlagBits::FLAG2 << 16)); 251 EXPECT_THAT(res & base, ExactBitsSet(TestFlagBits::FLAG1)); 252 } 253 254 /** 255 * @tc.name: Xor002 256 * @tc.desc: test TestFlags Xor 257 * @tc.type:FUNC 258 * @tc.require: 259 */ 260 HWTEST_F(BitfieldPropertyTest, Xor002, TestSize.Level1) 261 { 262 TestFlags base(TestFlagBits::FLAG1); 263 ExtTestFlags ext(ExtTestFlagBits::FLAG2); 264 TestFlags res = base | ext; 265 EXPECT_THAT(res ^ ext, ExactBitsSet(TestFlagBits::FLAG1)); 266 EXPECT_THAT(res ^ base, ExactBitsSet(ExtTestFlagBits::FLAG2 << 16)); 267 } 268 269 /** 270 * @tc.name: Not002 271 * @tc.desc: test TestFlags Not 272 * @tc.type:FUNC 273 * @tc.require: 274 */ 275 HWTEST_F(BitfieldPropertyTest, Not002, TestSize.Level1) 276 { 277 TestFlags base(TestFlagBits::FLAG1); 278 ExtTestFlags ext(ExtTestFlagBits::FLAG2); 279 TestFlags res = base | ext; 280 EXPECT_THAT(res & ~ext, ExactBitsSet(TestFlagBits::FLAG1)); 281 EXPECT_THAT(res & ~base, ExactBitsSet(ExtTestFlagBits::FLAG2 << 16)); 282 } 283 284 /** 285 * @tc.name: SetAndClear002 286 * @tc.desc: test TestFlags SetAndClear 287 * @tc.type:FUNC 288 * @tc.require: 289 */ 290 HWTEST_F(BitfieldPropertyTest, SetAndClear002, TestSize.Level1) 291 { 292 TestFlags base(TestFlagBits::FLAG1); 293 ExtTestFlags ext(ExtTestFlagBits::FLAG2); 294 295 EXPECT_FALSE(ext.IsSet(ExtTestFlagBits::FLAG1)); 296 EXPECT_TRUE(ext.IsSet(ExtTestFlagBits::FLAG2)); 297 ext.Set(ExtTestFlagBits::FLAG1); 298 EXPECT_TRUE(ext.IsSet(ExtTestFlagBits::FLAG1)); 299 ext.Clear(ExtTestFlagBits::FLAG2); 300 EXPECT_FALSE(ext.IsSet(ExtTestFlagBits::FLAG2)); 301 EXPECT_TRUE(ext.IsSet(ExtTestFlagBits::FLAG1)); 302 303 TestFlags value = base | ext; 304 EXPECT_TRUE(value.IsSet(TestFlagBits::FLAG1)); 305 EXPECT_FALSE(value.IsSet(TestFlagBits::FLAG2)); 306 307 value.Clear(TestFlagBits::FLAG1); 308 ExtTestFlags ext2 = value; 309 EXPECT_FALSE(ext2.IsSet(ExtTestFlagBits::FLAG2)); 310 EXPECT_TRUE(ext2.IsSet(ExtTestFlagBits::FLAG1)); 311 } 312 313 /** 314 * @tc.name: SetSubBits 315 * @tc.desc: test SetSubBits 316 * @tc.type:FUNC 317 * @tc.require: 318 */ 319 HWTEST_F(BitfieldPropertyTest, SetSubBits, TestSize.Level1) 320 { 321 TestFlags base(TestFlagBits::FLAG1); 322 ExtTestFlags ext(ExtTestFlagBits::FLAG2); 323 324 base.SetSubBits(ext); 325 326 EXPECT_TRUE(base.IsSet(TestFlagBits::FLAG1)); 327 EXPECT_FALSE(base.IsSet(TestFlagBits::FLAG2)); 328 329 ExtTestFlags ext2 = base; 330 EXPECT_TRUE(ext2.IsSet(ExtTestFlagBits::FLAG2)); 331 EXPECT_FALSE(ext2.IsSet(ExtTestFlagBits::FLAG1)); 332 } 333 334 META_END_NAMESPACE() 335