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 "ecmascript/containers/containers_private.h"
17 #include "ecmascript/ecma_vm.h"
18 #include "ecmascript/ecma_runtime_call_info.h"
19 #include "ecmascript/js_tagged_value.h"
20 #include "ecmascript/js_api/js_api_bitvector.h"
21 #include "ecmascript/global_env.h"
22 #include "ecmascript/object_factory.h"
23 #include "ecmascript/tests/test_helper.h"
24 #include "ecmascript/containers/containers_errors.h"
25
26 using namespace panda;
27 using namespace panda::ecmascript;
28
29 namespace panda::test {
30 class JSAPIBitVectorTest : public testing::Test {
31 public:
SetUpTestCase()32 static void SetUpTestCase()
33 {
34 GTEST_LOG_(INFO) << "SetUpTestCase";
35 }
36
TearDownTestCase()37 static void TearDownTestCase()
38 {
39 GTEST_LOG_(INFO) << "TearDownCase";
40 }
41
SetUp()42 void SetUp() override
43 {
44 TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
45 }
46
TearDown()47 void TearDown() override
48 {
49 TestHelper::DestroyEcmaVMWithScope(instance, scope);
50 }
51
52 EcmaVM *instance {nullptr};
53 EcmaHandleScope *scope {nullptr};
54 JSThread *thread {nullptr};
55
56 class TestClass : public base::BuiltinsBase {
57 public:
ComputeElementIdAndBitId(uint32_t index)58 static std::pair<uint32_t, uint32_t> ComputeElementIdAndBitId(uint32_t index)
59 {
60 uint32_t elementId = index >> 6;
61 uint32_t bitId = index & 0x3FULL;
62 return std::make_pair(elementId, bitId);
63 }
GetBit(std::vector<std::bitset<JSAPIBitVector::BIT_SET_LENGTH>> * elements,uint32_t index)64 static JSTaggedValue GetBit(std::vector<std::bitset<JSAPIBitVector::BIT_SET_LENGTH>> *elements, uint32_t index)
65 {
66 std::pair<uint32_t, uint32_t> pair = ComputeElementIdAndBitId(index);
67 uint32_t elementId = pair.first;
68 uint32_t bitId = pair.second;
69 int32_t bit = (*elements)[elementId].test(bitId);
70 return JSTaggedValue(bit);
71 }
72 };
73 protected:
CreateBitVector()74 JSAPIBitVector *CreateBitVector()
75 {
76 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
77 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
78
79 JSHandle<JSTaggedValue> globalObject = env->GetJSGlobalObject();
80 JSHandle<JSTaggedValue> key(factory->NewFromASCII("ArkPrivate"));
81 JSHandle<JSTaggedValue> value =
82 JSObject::GetProperty(thread, JSHandle<JSTaggedValue>(globalObject), key).GetValue();
83
84 auto objCallInfo =
85 TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
86 objCallInfo->SetFunction(JSTaggedValue::Undefined());
87 objCallInfo->SetThis(value.GetTaggedValue());
88 objCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int>(containers::ContainerTag::BitVector)));
89
90 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, objCallInfo);
91 JSTaggedValue result = containers::ContainersPrivate::Load(objCallInfo);
92 TestHelper::TearDownFrame(thread, prev);
93
94 JSHandle<JSTaggedValue> constructor(thread, result);
95 JSHandle<JSAPIBitVector> bitVector(
96 factory->NewJSObjectByConstructor(JSHandle<JSFunction>(constructor), constructor));
97 auto *newBitSetVector = new std::vector<std::bitset<JSAPIBitVector::BIT_SET_LENGTH>>();
98 JSHandle<JSNativePointer> pointer = factory->NewJSNativePointer(newBitSetVector);
99 bitVector->SetNativePointer(thread, pointer);
100 return *bitVector;
101 }
102 };
103
HWTEST_F_L0(JSAPIBitVectorTest,CreateBitVector)104 HWTEST_F_L0(JSAPIBitVectorTest, CreateBitVector)
105 {
106 JSAPIBitVector *bitVector = CreateBitVector();
107 EXPECT_TRUE(bitVector != nullptr);
108 }
109
110 /**
111 * @tc.name: Push
112 * @tc.desc:
113 * @tc.type: FUNC
114 * @tc.require:
115 */
HWTEST_F_L0(JSAPIBitVectorTest,Push)116 HWTEST_F_L0(JSAPIBitVectorTest, Push)
117 {
118 uint32_t increasedLength = 5;
119 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
120 for (uint32_t i = 0; i < increasedLength; i++) {
121 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
122 JSAPIBitVector::Push(thread, bitVector, value);
123 }
124 JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer());
125 auto elements =
126 reinterpret_cast<std::vector<std::bitset<JSAPIBitVector::BIT_SET_LENGTH>> *>(np->GetExternalPointer());
127 for (uint32_t i = 0; i < increasedLength; i++) {
128 EXPECT_EQ(TestClass::GetBit(elements, i), JSTaggedValue(1));
129 }
130 }
131
132 /**
133 * @tc.name: Pop
134 * @tc.desc:
135 * @tc.type: FUNC
136 * @tc.require:
137 */
HWTEST_F_L0(JSAPIBitVectorTest,Pop)138 HWTEST_F_L0(JSAPIBitVectorTest, Pop)
139 {
140 uint32_t increasedLength = 5;
141 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
142 for (uint32_t i = 0; i < increasedLength; i++) {
143 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
144 JSAPIBitVector::Push(thread, bitVector, value);
145 }
146 for (uint32_t i = 0; i < increasedLength; i++) {
147 JSTaggedValue res = JSAPIBitVector::Pop(thread, bitVector);
148 EXPECT_EQ(res, JSTaggedValue(1));
149 }
150 }
151
152 /**
153 * @tc.name: Set
154 * @tc.desc:
155 * @tc.type: FUNC
156 * @tc.require:
157 */
HWTEST_F_L0(JSAPIBitVectorTest,Set)158 HWTEST_F_L0(JSAPIBitVectorTest, Set)
159 {
160 uint32_t increasedLength = 5;
161 uint32_t index = 3;
162
163 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
164 for (uint32_t i = 0; i < increasedLength; i++) {
165 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(0));
166 JSAPIBitVector::Push(thread, bitVector, value);
167 }
168 JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer());
169 auto elements =
170 reinterpret_cast<std::vector<std::bitset<JSAPIBitVector::BIT_SET_LENGTH>> *>(np->GetExternalPointer());
171 JSTaggedValue res = bitVector->Set(thread, index, JSTaggedValue(1));
172 EXPECT_EQ(res, JSTaggedValue::Undefined());
173 EXPECT_EQ(TestClass::GetBit(elements, index), JSTaggedValue(1));
174 }
175
176 /**
177 * @tc.name: Get
178 * @tc.desc:
179 * @tc.type: FUNC
180 * @tc.require:
181 */
HWTEST_F_L0(JSAPIBitVectorTest,Get)182 HWTEST_F_L0(JSAPIBitVectorTest, Get)
183 {
184 uint32_t increasedLength = 5;
185 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
186 for (uint32_t i = 0; i < increasedLength; i++) {
187 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
188 JSAPIBitVector::Push(thread, bitVector, value);
189 }
190 for (uint32_t i = 0; i < increasedLength; i++) {
191 JSTaggedValue res = bitVector->Get(thread, i);
192 EXPECT_EQ(res, JSTaggedValue(1));
193 }
194 }
195
196 /**
197 * @tc.name: Has
198 * @tc.desc:
199 * @tc.type: FUNC
200 * @tc.require:
201 */
HWTEST_F_L0(JSAPIBitVectorTest,Has)202 HWTEST_F_L0(JSAPIBitVectorTest, Has)
203 {
204 uint32_t increasedLength = 5;
205 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
206 for (uint32_t i = 0; i < increasedLength; i++) {
207 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
208 JSAPIBitVector::Push(thread, bitVector, value);
209 }
210 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
211 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(0));
212 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(5));
213 bool res = JSAPIBitVector::Has(thread, bitVector, value, value1, value2);
214 EXPECT_TRUE(res);
215 }
216
217 /**
218 * @tc.name: Has_instance
219 * @tc.desc:
220 * @tc.type: FUNC
221 * @tc.require:
222 */
HWTEST_F_L0(JSAPIBitVectorTest,Has_instance)223 HWTEST_F_L0(JSAPIBitVectorTest, Has_instance)
224 {
225 uint32_t increasedLength = 5;
226 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
227 for (uint32_t i = 0; i < increasedLength; i++) {
228 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
229 JSAPIBitVector::Push(thread, bitVector, value);
230 }
231 bool res = bitVector->Has(JSTaggedValue(1));
232 EXPECT_TRUE(res);
233 }
234
235 /**
236 * @tc.name: Has_Testboundary
237 * @tc.desc:
238 * @tc.type: FUNC
239 * @tc.require:
240 */
HWTEST_F_L0(JSAPIBitVectorTest,Has_Testboundary)241 HWTEST_F_L0(JSAPIBitVectorTest, Has_Testboundary)
242 {
243 uint32_t increasedLength = 8;
244 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
245 for (uint32_t i = 0; i < increasedLength; i++) {
246 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
247 JSAPIBitVector::Push(thread, bitVector, value);
248 }
249 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(0));
250 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(7));
251 bool res = JSAPIBitVector::Has(thread, bitVector, value, value, value1);
252 EXPECT_FALSE(res);
253 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(1));
254 JSHandle<JSTaggedValue> value3(thread, JSTaggedValue(8));
255 JSAPIBitVector::Push(thread, bitVector, value2);
256 res = JSAPIBitVector::Has(thread, bitVector, value2, value, value3);
257 EXPECT_TRUE(res);
258 }
259
260 /**
261 * @tc.name: SetBitsByRange
262 * @tc.desc:
263 * @tc.type: FUNC
264 * @tc.require:
265 */
HWTEST_F_L0(JSAPIBitVectorTest,SetBitsByRange)266 HWTEST_F_L0(JSAPIBitVectorTest, SetBitsByRange)
267 {
268 uint32_t increasedLength = 5;
269 uint32_t startIndex = 1;
270 uint32_t endIndex = 4;
271 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
272 for (uint32_t i = 0; i < increasedLength; i++) {
273 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(0));
274 JSAPIBitVector::Push(thread, bitVector, value);
275 }
276 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
277 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(startIndex));
278 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(endIndex));
279 JSTaggedValue res = JSAPIBitVector::SetBitsByRange(thread, bitVector, value, value1, value2);
280 EXPECT_EQ(res, JSTaggedValue::Undefined());
281
282 JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer());
283 auto elements =
284 reinterpret_cast<std::vector<std::bitset<JSAPIBitVector::BIT_SET_LENGTH>> *>(np->GetExternalPointer());
285 for (uint32_t i = startIndex; i < endIndex; i++) {
286 EXPECT_EQ(TestClass::GetBit(elements, i), JSTaggedValue(1));
287 }
288 }
289
290 /**
291 * @tc.name: GetBitsByRange
292 * @tc.desc:
293 * @tc.type: FUNC
294 * @tc.require:
295 */
HWTEST_F_L0(JSAPIBitVectorTest,GetBitsByRange)296 HWTEST_F_L0(JSAPIBitVectorTest, GetBitsByRange)
297 {
298 uint32_t increasedLength = 5;
299 uint32_t startIndex = 1;
300 uint32_t endIndex = 4;
301 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
302 for (uint32_t i = 0; i < increasedLength; i++) {
303 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
304 JSAPIBitVector::Push(thread, bitVector, value);
305 }
306 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(startIndex));
307 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(endIndex));
308 JSTaggedValue res = JSAPIBitVector::GetBitsByRange(thread, bitVector, value1, value2);
309 JSHandle<JSAPIBitVector> getBitVector(thread, res);
310 EXPECT_EQ(getBitVector->GetLength(), endIndex - startIndex);
311 for (uint32_t i = 0; i < endIndex - startIndex; i++) {
312 EXPECT_EQ(getBitVector->Get(thread, i), JSTaggedValue(1));
313 }
314 }
315
316 /**
317 * @tc.name: SetAllBits
318 * @tc.desc:
319 * @tc.type: FUNC
320 * @tc.require:
321 */
HWTEST_F_L0(JSAPIBitVectorTest,SetAllBits)322 HWTEST_F_L0(JSAPIBitVectorTest, SetAllBits)
323 {
324 uint32_t increasedLength = 5;
325 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
326 for (uint32_t i = 0; i < increasedLength; i++) {
327 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(0));
328 JSAPIBitVector::Push(thread, bitVector, value);
329 }
330 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
331 JSTaggedValue res = JSAPIBitVector::SetAllBits(thread, bitVector, value);
332 EXPECT_EQ(res, JSTaggedValue::Undefined());
333 JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer());
334 auto elements =
335 reinterpret_cast<std::vector<std::bitset<JSAPIBitVector::BIT_SET_LENGTH>> *>(np->GetExternalPointer());
336 for (uint32_t i = 0; i < increasedLength; i++) {
337 EXPECT_EQ(TestClass::GetBit(elements, i), JSTaggedValue(1));
338 }
339 }
340
341 /**
342 * @tc.name: GetBitCountByRange
343 * @tc.desc:
344 * @tc.type: FUNC
345 * @tc.require:
346 */
HWTEST_F_L0(JSAPIBitVectorTest,GetBitCountByRange)347 HWTEST_F_L0(JSAPIBitVectorTest, GetBitCountByRange)
348 {
349 uint32_t increasedLength = 5;
350 uint32_t startIndex = 1;
351 uint32_t endIndex = 4;
352 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
353 for (uint32_t i = 0; i < increasedLength; i++) {
354 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
355 JSAPIBitVector::Push(thread, bitVector, value);
356 }
357 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
358 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(startIndex));
359 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(endIndex));
360 JSTaggedValue res = JSAPIBitVector::GetBitCountByRange(thread, bitVector, value, value1, value2);
361 EXPECT_EQ(res, JSTaggedValue(3));
362 }
363
364 /**
365 * @tc.name: GetIndexOf
366 * @tc.desc:
367 * @tc.type: FUNC
368 * @tc.require:
369 */
HWTEST_F_L0(JSAPIBitVectorTest,GetIndexOf)370 HWTEST_F_L0(JSAPIBitVectorTest, GetIndexOf)
371 {
372 uint32_t increasedLength = 5;
373 uint32_t startIndex = 1;
374 uint32_t endIndex = 4;
375 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
376 for (uint32_t i = 0; i < increasedLength; i++) {
377 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
378 JSAPIBitVector::Push(thread, bitVector, value);
379 }
380 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
381 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(startIndex));
382 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(endIndex));
383 int res = JSAPIBitVector::GetIndexOf(thread, bitVector, value, value1, value2);
384 EXPECT_EQ(res, startIndex);
385 }
386
387 /**
388 * @tc.name: GetLastIndexOf
389 * @tc.desc:
390 * @tc.type: FUNC
391 * @tc.require:
392 */
HWTEST_F_L0(JSAPIBitVectorTest,GetLastIndexOf)393 HWTEST_F_L0(JSAPIBitVectorTest, GetLastIndexOf)
394 {
395 uint32_t increasedLength = 5;
396 uint32_t startIndex = 1;
397 uint32_t endIndex = 4;
398 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
399 for (uint32_t i = 0; i < increasedLength; i++) {
400 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
401 JSAPIBitVector::Push(thread, bitVector, value);
402 }
403 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
404 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(startIndex));
405 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(endIndex));
406 int res = JSAPIBitVector::GetLastIndexOf(thread, bitVector, value, value1, value2);
407 EXPECT_EQ(res, endIndex - 1);
408 }
409
410 /**
411 * @tc.name: FlipBitByIndex
412 * @tc.desc:
413 * @tc.type: FUNC
414 * @tc.require:
415 */
HWTEST_F_L0(JSAPIBitVectorTest,FlipBitByIndex)416 HWTEST_F_L0(JSAPIBitVectorTest, FlipBitByIndex)
417 {
418 uint32_t increasedLength = 5;
419 uint32_t index = 3;
420 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
421 for (uint32_t i = 0; i < increasedLength; i++) {
422 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
423 JSAPIBitVector::Push(thread, bitVector, value);
424 }
425 JSTaggedValue res = JSAPIBitVector::FlipBitByIndex(thread, bitVector, index);
426
427 JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer());
428 auto elements =
429 reinterpret_cast<std::vector<std::bitset<JSAPIBitVector::BIT_SET_LENGTH>> *>(np->GetExternalPointer());
430 EXPECT_EQ(res, JSTaggedValue::Undefined());
431 EXPECT_EQ(TestClass::GetBit(elements, index), JSTaggedValue(0));
432 }
433
434 /**
435 * @tc.name: FlipBitsByRange
436 * @tc.desc:
437 * @tc.type: FUNC
438 * @tc.require:
439 */
HWTEST_F_L0(JSAPIBitVectorTest,FlipBitsByRange)440 HWTEST_F_L0(JSAPIBitVectorTest, FlipBitsByRange)
441 {
442 uint32_t increasedLength = 5;
443 uint32_t startIndex = 1;
444 uint32_t endIndex = 4;
445 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
446 for (uint32_t i = 0; i < increasedLength; i++) {
447 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
448 JSAPIBitVector::Push(thread, bitVector, value);
449 }
450 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(startIndex));
451 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(endIndex));
452 JSTaggedValue res = JSAPIBitVector::FlipBitsByRange(thread, bitVector, value1, value2);
453 EXPECT_EQ(res, JSTaggedValue::Undefined());
454
455 JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer());
456 auto elements =
457 reinterpret_cast<std::vector<std::bitset<JSAPIBitVector::BIT_SET_LENGTH>> *>(np->GetExternalPointer());
458 for (uint32_t i = startIndex; i < endIndex; i++) {
459 EXPECT_EQ(TestClass::GetBit(elements, i), JSTaggedValue(0));
460 }
461 }
462
463 /**
464 * @tc.name: Resize
465 * @tc.desc:
466 * @tc.type: FUNC
467 * @tc.require:
468 */
HWTEST_F_L0(JSAPIBitVectorTest,Resize)469 HWTEST_F_L0(JSAPIBitVectorTest, Resize)
470 {
471 uint32_t increasedLength = 5;
472 int newLength = 10;
473 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
474 for (uint32_t i = 0; i < increasedLength; i++) {
475 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
476 JSAPIBitVector::Push(thread, bitVector, value);
477 }
478
479 JSAPIBitVector::Resize(thread, bitVector, newLength);
480 EXPECT_EQ(bitVector->GetLength(), newLength);
481
482 JSHandle<JSNativePointer> np(thread, bitVector->GetNativePointer());
483 auto elements =
484 reinterpret_cast<std::vector<std::bitset<JSAPIBitVector::BIT_SET_LENGTH>> *>(np->GetExternalPointer());
485 for (uint32_t i = increasedLength; i < newLength; i++) {
486 EXPECT_EQ(TestClass::GetBit(elements, i), JSTaggedValue(0));
487 }
488 }
489
490 /**
491 * @tc.name: OwnKeys
492 * @tc.desc:
493 * @tc.type: FUNC
494 * @tc.require:
495 */
HWTEST_F_L0(JSAPIBitVectorTest,OwnKeys)496 HWTEST_F_L0(JSAPIBitVectorTest, OwnKeys)
497 {
498 uint32_t increasedLength = 5;
499 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
500 for (uint32_t i = 0; i < increasedLength; i++) {
501 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
502 JSAPIBitVector::Push(thread, bitVector, value);
503 }
504
505 JSHandle<TaggedArray> keys = JSAPIBitVector::OwnKeys(thread, bitVector);
506 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(*(base::NumberHelper::NumberToString(thread, JSTaggedValue(0))),
507 EcmaString::Cast(keys->Get(0).GetTaggedObject())));
508 }
509
510 /**
511 * @tc.name: GetOwnProperty
512 * @tc.desc:
513 * @tc.type: FUNC
514 * @tc.require:
515 */
HWTEST_F_L0(JSAPIBitVectorTest,GetOwnProperty)516 HWTEST_F_L0(JSAPIBitVectorTest, GetOwnProperty)
517 {
518 uint32_t increasedLength = 5;
519 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
520 for (uint32_t i = 0; i < increasedLength; i++) {
521 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
522 JSAPIBitVector::Push(thread, bitVector, value);
523 }
524
525 for (uint32_t i = 0; i < increasedLength; i++) {
526 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(i));
527 bool getOwnPropertyRes = JSAPIBitVector::GetOwnProperty(thread, bitVector, key);
528 EXPECT_EQ(getOwnPropertyRes, true);
529 }
530 }
531
532 /**
533 * @tc.name: GetIteratorObj
534 * @tc.desc:
535 * @tc.type: FUNC
536 * @tc.require:
537 */
HWTEST_F_L0(JSAPIBitVectorTest,GetIteratorObj)538 HWTEST_F_L0(JSAPIBitVectorTest, GetIteratorObj)
539 {
540 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
541 JSHandle<JSTaggedValue> iteratorObj(thread, JSAPIBitVector::GetIteratorObj(thread, bitVector));
542 EXPECT_TRUE(iteratorObj->IsJSAPIBitVectorIterator());
543 }
544
545 /**
546 * @tc.name: GetProperty
547 * @tc.desc:
548 * @tc.type: FUNC
549 * @tc.require:
550 */
HWTEST_F_L0(JSAPIBitVectorTest,GetProperty)551 HWTEST_F_L0(JSAPIBitVectorTest, GetProperty)
552 {
553 uint32_t increasedLength = 5;
554 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
555 for (uint32_t i = 0; i < increasedLength; i++) {
556 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
557 JSAPIBitVector::Push(thread, bitVector, value);
558 }
559
560 for (uint32_t i = 0; i < increasedLength; i++) {
561 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(i));
562 OperationResult getPropertyRes = JSAPIBitVector::GetProperty(thread, bitVector, key);
563 EXPECT_EQ(getPropertyRes.GetValue().GetTaggedValue(), JSTaggedValue(1));
564 }
565 }
566
567 /**
568 * @tc.name: SetProperty
569 * @tc.desc:
570 * @tc.type: FUNC
571 * @tc.require:
572 */
HWTEST_F_L0(JSAPIBitVectorTest,SetProperty)573 HWTEST_F_L0(JSAPIBitVectorTest, SetProperty)
574 {
575 uint32_t increasedLength = 5;
576 JSHandle<JSAPIBitVector> bitVector(thread, CreateBitVector());
577 for (uint32_t i = 0; i < increasedLength; i++) {
578 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(0));
579 JSAPIBitVector::Push(thread, bitVector, value);
580 }
581
582 for (uint32_t i = 0; i < increasedLength; i++) {
583 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(i));
584 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(1));
585 bool setPropertyRes = JSAPIBitVector::SetProperty(thread, bitVector, key, value);
586 EXPECT_EQ(setPropertyRes, true);
587 }
588 }
589 }