1 /*
2 * Copyright (c) 2022 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/object_operator.h"
17 #include "ecmascript/ecma_string.h"
18 #include "ecmascript/global_env.h"
19 #include "ecmascript/global_dictionary-inl.h"
20 #include "ecmascript/js_array.h"
21 #include "ecmascript/property_attributes.h"
22 #include "ecmascript/tagged_array.h"
23 #include "ecmascript/tagged_dictionary.h"
24 #include "ecmascript/tests/test_helper.h"
25
26 using namespace panda::ecmascript;
27
28 namespace panda::test {
29 class ObjectOperatorTest : public testing::Test {
30 public:
SetUpTestCase()31 static void SetUpTestCase()
32 {
33 GTEST_LOG_(INFO) << "SetUpTestCase";
34 }
35
TearDownTestCase()36 static void TearDownTestCase()
37 {
38 GTEST_LOG_(INFO) << "TearDownCase";
39 }
40
SetUp()41 void SetUp() override
42 {
43 TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
44 }
45
TearDown()46 void TearDown() override
47 {
48 TestHelper::DestroyEcmaVMWithScope(instance, scope);
49 }
50
51 EcmaVM *instance {nullptr};
52 ecmascript::EcmaHandleScope *scope {nullptr};
53 JSThread *thread {nullptr};
54 };
55
HWTEST_F_L0(ObjectOperatorTest,SetAttr)56 HWTEST_F_L0(ObjectOperatorTest, SetAttr)
57 {
58 JSHandle<JSTaggedValue> handleValue1(thread, JSTaggedValue(1));
59 JSHandle<JSTaggedValue> handleValue2(thread, JSTaggedValue(2));
60
61 ObjectOperator objectOperator1(thread, handleValue1);
62 ObjectOperator objectOperator2(thread, handleValue2);
63 uint32_t handleAttr1 = 2;
64
65 objectOperator1.SetAttr(handleAttr1);
66 EXPECT_EQ(objectOperator1.GetAttr().GetPropertyMetaData(), 2);
67 EXPECT_FALSE(objectOperator1.IsPrimitiveAttr());
68
69 PropertyAttributes handleAttr2(JSTaggedValue(0));
70 objectOperator2.SetAttr(handleAttr2);
71 EXPECT_TRUE(objectOperator2.IsPrimitiveAttr());
72 }
73
HWTEST_F_L0(ObjectOperatorTest,SetFastMode)74 HWTEST_F_L0(ObjectOperatorTest, SetFastMode)
75 {
76 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(1));
77 ObjectOperator objectOperator(thread, handleValue);
78
79 EXPECT_FALSE(objectOperator.IsFastMode());
80 objectOperator.SetFastMode(false);
81 EXPECT_FALSE(objectOperator.IsFastMode());
82
83 objectOperator.SetFastMode(true);
84 EXPECT_TRUE(objectOperator.IsFastMode());
85 }
86
HWTEST_F_L0(ObjectOperatorTest,SetIsOnPrototype)87 HWTEST_F_L0(ObjectOperatorTest, SetIsOnPrototype)
88 {
89 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(1));
90 ObjectOperator objectOperator(thread, handleValue);
91
92 EXPECT_TRUE(objectOperator.IsOnPrototype());
93 objectOperator.SetIsOnPrototype(true);
94 EXPECT_TRUE(objectOperator.IsOnPrototype());
95
96 objectOperator.SetIsOnPrototype(false);
97 EXPECT_FALSE(objectOperator.IsOnPrototype());
98 }
99
HWTEST_F_L0(ObjectOperatorTest,SetHasReceiver)100 HWTEST_F_L0(ObjectOperatorTest, SetHasReceiver)
101 {
102 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(1));
103 ObjectOperator objectOperator(thread, handleValue);
104
105 EXPECT_FALSE(objectOperator.HasReceiver());
106 objectOperator.SetHasReceiver(true);
107 EXPECT_TRUE(objectOperator.HasReceiver());
108
109 objectOperator.SetHasReceiver(false);
110 EXPECT_FALSE(objectOperator.HasReceiver());
111 }
112
HWTEST_F_L0(ObjectOperatorTest,SetIsTransition)113 HWTEST_F_L0(ObjectOperatorTest, SetIsTransition)
114 {
115 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(1));
116 ObjectOperator objectOperator(thread, handleValue);
117
118 EXPECT_FALSE(objectOperator.IsTransition());
119 objectOperator.SetIsTransition(true);
120 EXPECT_TRUE(objectOperator.IsTransition());
121
122 objectOperator.SetIsTransition(false);
123 EXPECT_FALSE(objectOperator.IsTransition());
124 }
125
HWTEST_F_L0(ObjectOperatorTest,SetIndex)126 HWTEST_F_L0(ObjectOperatorTest, SetIndex)
127 {
128 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(1));
129 ObjectOperator objectOperator(thread, handleValue);
130
131 uint32_t index = 1;
132 objectOperator.SetIndex(index);
133 EXPECT_EQ(objectOperator.GetIndex(), 1U);
134 EXPECT_TRUE(objectOperator.IsFound());
135
136 objectOperator.SetIndex(ObjectOperator::NOT_FOUND_INDEX);
137 EXPECT_FALSE(objectOperator.IsFound());
138 }
139
HWTEST_F_L0(ObjectOperatorTest,SetValue)140 HWTEST_F_L0(ObjectOperatorTest, SetValue)
141 {
142 JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(1));
143 JSHandle<JSTaggedValue> handleValue1(thread, JSTaggedValue(2));
144 JSHandle<JSTaggedValue> handleValue2(thread, JSTaggedValue(3));
145 ObjectOperator objectOperator(thread, handleKey);
146
147 EXPECT_TRUE(objectOperator.GetValue().IsUndefined());
148 objectOperator.SetValue(handleValue1.GetTaggedValue());
149 EXPECT_EQ(objectOperator.GetValue().GetInt(), 2);
150
151 objectOperator.SetValue(handleValue2.GetTaggedValue());
152 EXPECT_EQ(objectOperator.GetValue().GetInt(), 3);
153 }
154
HWTEST_F_L0(ObjectOperatorTest,SetAsDefaultAttr)155 HWTEST_F_L0(ObjectOperatorTest, SetAsDefaultAttr)
156 {
157 JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(1));
158 ObjectOperator objectOperator(thread, handleKey);
159 objectOperator.SetAsDefaultAttr();
160 EXPECT_EQ(objectOperator.GetIndex(), ObjectOperator::NOT_FOUND_INDEX);
161 EXPECT_TRUE(objectOperator.GetValue().IsUndefined());
162 EXPECT_FALSE(objectOperator.IsFastMode());
163 EXPECT_FALSE(objectOperator.IsTransition());
164 EXPECT_EQ(objectOperator.GetAttr().GetPropertyMetaData(), 7);
165 }
166
HWTEST_F_L0(ObjectOperatorTest,GetHolder)167 HWTEST_F_L0(ObjectOperatorTest, GetHolder)
168 {
169 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
170
171 JSHandle<JSObject> handleHolder = factory->NewEmptyJSObject();
172 JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(1));
173 ObjectOperator objectOperator(thread, handleHolder, handleKey);
174
175 EXPECT_TRUE(objectOperator.HasHolder());
176 EXPECT_TRUE(objectOperator.GetHolder().GetTaggedValue().IsECMAObject());
177 }
178
HWTEST_F_L0(ObjectOperatorTest,GetReceiver)179 HWTEST_F_L0(ObjectOperatorTest, GetReceiver)
180 {
181 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
182
183 JSHandle<EcmaString> handleNameString = factory->NewFromASCII("name");
184 JSHandle<JSTaggedValue> handleReceiver(thread, JSTaggedValue(1));
185
186 ObjectOperator objectOperator(thread, handleReceiver.GetTaggedValue(), handleNameString.GetTaggedValue());
187 EXPECT_EQ(objectOperator.GetReceiver()->GetInt(), 1);
188 }
189
HWTEST_F_L0(ObjectOperatorTest,GetElementIndex)190 HWTEST_F_L0(ObjectOperatorTest, GetElementIndex)
191 {
192 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
193
194 JSHandle<JSTaggedValue> handleKey1(thread, JSTaggedValue(1));
195 JSHandle<JSTaggedValue> handleKey2(thread, JSTaggedValue(2.0));
196 JSHandle<JSTaggedValue> handleKey3(factory->NewFromASCII("2"));
197
198 ObjectOperator objectOperator1(thread, handleKey1);
199 ObjectOperator objectOperator2(thread, handleKey2);
200 ObjectOperator objectOperator3(thread, handleKey3);
201
202 EXPECT_EQ(objectOperator1.GetElementIndex(), 1U);
203 EXPECT_EQ(objectOperator2.GetElementIndex(), 2U);
204 EXPECT_EQ(objectOperator3.GetElementIndex(), 2U);
205 }
206
HWTEST_F_L0(ObjectOperatorTest,GetKey)207 HWTEST_F_L0(ObjectOperatorTest, GetKey)
208 {
209 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
210
211 JSHandle<JSTaggedValue> handleKey1(thread, JSTaggedValue(1));
212 JSHandle<JSTaggedValue> handleKey2(factory->NewFromASCII("name"));
213
214 ObjectOperator objectOperator1(thread, handleKey1);
215 ObjectOperator objectOperator2(thread, handleKey2);
216
217 EXPECT_TRUE(objectOperator1.GetKey()->IsUndefined());
218 EXPECT_TRUE(objectOperator1.IsElement());
219
220 EXPECT_FALSE(objectOperator2.GetKey()->IsUndefined());
221 EXPECT_FALSE(objectOperator2.IsElement());
222 }
223
HWTEST_F_L0(ObjectOperatorTest,GetThread)224 HWTEST_F_L0(ObjectOperatorTest, GetThread)
225 {
226 JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(1));
227 ObjectOperator objectOperator(thread, handleKey);
228 EXPECT_TRUE(objectOperator.GetThread() != nullptr);
229 }
230
TestDefinedGetter(EcmaRuntimeCallInfo * argv)231 JSTaggedValue TestDefinedGetter([[maybe_unused]] EcmaRuntimeCallInfo *argv)
232 {
233 // 12 : test case
234 return JSTaggedValue(12);
235 }
236
TestDefinedSetter(EcmaRuntimeCallInfo * argv)237 JSTaggedValue TestDefinedSetter([[maybe_unused]] EcmaRuntimeCallInfo *argv)
238 {
239 // 12 : test case
240 return JSTaggedValue(12);
241 }
242
TestBoolSetter(JSThread * thread,JSHandle<JSObject> & jsObject,JSHandle<JSTaggedValue> & value,bool success)243 bool TestBoolSetter([[maybe_unused]] JSThread *thread,
244 [[maybe_unused]] JSHandle<JSObject> &jsObject,
245 [[maybe_unused]] JSHandle<JSTaggedValue> &value,
246 [[maybe_unused]] bool success)
247 {
248 return true;
249 }
JSObjectTestCreate(JSThread * thread)250 static JSFunction *JSObjectTestCreate(JSThread *thread)
251 {
252 JSHandle<GlobalEnv> globalEnv = thread->GetEcmaVM()->GetGlobalEnv();
253 return globalEnv->GetObjectFunction().GetObject<JSFunction>();
254 }
255
HWTEST_F_L0(ObjectOperatorTest,ToPropertyDescriptor)256 HWTEST_F_L0(ObjectOperatorTest, ToPropertyDescriptor)
257 {
258 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
259 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("property"));
260 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(1));
261 JSHandle<AccessorData> handleAccessor = factory->NewAccessorData();
262 JSHandle<AccessorData> handleInternalAccessor =
263 factory->NewInternalAccessor(nullptr, reinterpret_cast<void *>(TestDefinedGetter));
264 JSHandle<JSTaggedValue> handleHolder(factory->NewEmptyJSObject());
265
266 PropertyDescriptor handleDesc(thread);
267 handleDesc.SetGetter(handleValue);
268 handleDesc.SetSetter(handleValue);
269 PropertyDescriptor handleDesc1(thread);
270 handleDesc1.SetWritable(true);
271 PropertyDescriptor handleDesc2(thread);
272 handleDesc2.SetConfigurable(true);
273 handleDesc2.SetEnumerable(true);
274 PropertyDescriptor handleDesc3(thread);
275 PropertyAttributes handleAttr(handleDesc);
276
277 ObjectOperator objectOperator(thread, handleHolder, handleKey);
278 objectOperator.SetIndex(1);
279 // object is not IsAccessorDescriptor
280 objectOperator.ToPropertyDescriptor(handleDesc1);
281 EXPECT_TRUE(!handleDesc1.IsWritable());
282 EXPECT_TRUE(handleDesc1.GetValue()->IsUndefined());
283 // object is IsAccessorDescriptor
284 objectOperator.SetAttr(handleAttr);
285 objectOperator.SetValue(handleAccessor.GetTaggedValue());
286 objectOperator.ToPropertyDescriptor(handleDesc2);
287 EXPECT_FALSE(handleDesc2.IsEnumerable());
288 EXPECT_FALSE(handleDesc2.IsConfigurable());
289 EXPECT_TRUE(handleDesc2.GetGetter()->IsUndefined());
290 EXPECT_TRUE(handleDesc2.GetSetter()->IsUndefined());
291
292 objectOperator.SetValue(handleInternalAccessor.GetTaggedValue());
293 objectOperator.ToPropertyDescriptor(handleDesc3);
294 EXPECT_EQ(handleDesc3.GetValue()->GetInt(), 12);
295 }
296
HWTEST_F_L0(ObjectOperatorTest,handleKey)297 HWTEST_F_L0(ObjectOperatorTest, handleKey)
298 {
299 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
300
301 JSHandle<JSTaggedValue> handleString(factory->NewFromASCII("key"));
302 JSHandle<JSTaggedValue> handleObject(factory->NewEmptyJSObject());
303 JSHandle<JSTaggedValue> handleSymbol(factory->NewJSSymbol());
304 JSHandle<JSTaggedValue> handleKey1(thread, JSTaggedValue(-1));
305 JSHandle<JSTaggedValue> handleKey2(thread, JSTaggedValue(-1.11));
306 JSHandle<JSTaggedValue> handleKey3(thread, handleString.GetTaggedValue());
307 JSHandle<JSTaggedValue> handleKey4(thread, handleSymbol.GetTaggedValue());
308 JSHandle<JSTaggedValue> handleKey5(thread, handleObject.GetTaggedValue());
309 JSHandle<JSTaggedValue> handleKey6(thread, JSTaggedValue(1.11));
310
311 ObjectOperator objectOperator1(thread, handleKey1);
312 ObjectOperator objectOperator2(thread, handleKey2);
313 ObjectOperator objectOperator3(thread, handleKey3);
314 ObjectOperator objectOperator4(thread, handleKey4);
315 ObjectOperator objectOperator5(thread, handleKey5);
316 ObjectOperator objectOperator6(thread, handleKey6);
317
318 JSHandle<EcmaString> handleEcmaStrTo1(objectOperator1.GetKey());
319 EXPECT_STREQ("-1", EcmaStringAccessor(handleEcmaStrTo1).ToCString().c_str());
320
321 JSHandle<EcmaString> handleEcmaStrTo2(objectOperator2.GetKey());
322 EXPECT_STREQ("-1.11", EcmaStringAccessor(handleEcmaStrTo2).ToCString().c_str());
323
324 EcmaString *str1 = EcmaString::Cast(objectOperator3.GetKey()->GetTaggedObject());
325 EXPECT_TRUE(EcmaStringAccessor(str1).IsInternString());
326
327 EXPECT_TRUE(objectOperator4.GetKey()->IsSymbol());
328
329 EcmaString *str2 = EcmaString::Cast(objectOperator5.GetKey()->GetTaggedObject());
330 EXPECT_TRUE(EcmaStringAccessor(str2).IsInternString());
331
332 JSHandle<EcmaString> handleEcmaStrTo3(objectOperator6.GetKey());
333 EXPECT_STREQ("1.11", EcmaStringAccessor(handleEcmaStrTo3).ToCString().c_str());
334 }
335
HWTEST_F_L0(ObjectOperatorTest,FastGetValue)336 HWTEST_F_L0(ObjectOperatorTest, FastGetValue)
337 {
338 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
339 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
340
341 JSHandle<EcmaString> handleNameString = factory->NewFromASCII("name");
342 JSHandle<AccessorData> handleAccessorData = factory->NewAccessorData();
343 JSHandle<JSTaggedValue> handleReceiver(thread, JSTaggedValue(123));
344 JSHandle<JSTaggedValue> handleValue1(factory->NewPropertyBox(handleReceiver));
345 JSHandle<JSTaggedValue> handleValue2(handleAccessorData);
346 JSHandle<JSTaggedValue> handleValue3(thread, JSTaggedValue(1));
347
348 ObjectOperator objectOperator1(thread, handleValue3);
349 objectOperator1.SetIndex(1);
350 objectOperator1.SetValue(handleValue1.GetTaggedValue());
351 EXPECT_EQ(objectOperator1.FastGetValue()->GetInt(), 123);
352
353 // op for fast path
354 ObjectOperator objectOperator2(thread, handleReceiver.GetTaggedValue(), handleNameString.GetTaggedValue());
355 objectOperator2.SetIndex(1);
356 objectOperator2.SetValue(handleValue2.GetTaggedValue());
357 PropertyDescriptor handleDesc(thread);
358 handleDesc.SetGetter(handleValue2);
359 handleDesc.SetSetter(handleValue2);
360 objectOperator2.SetAttr(PropertyAttributes(handleDesc));
361 EXPECT_TRUE(objectOperator2.FastGetValue()->IsUndefined());
362
363 JSHandle<JSFunction> handleGetter = factory->NewJSFunction(env, reinterpret_cast<void *>(TestDefinedGetter));
364 handleAccessorData->SetGetter(thread, handleGetter.GetTaggedValue());
365 EXPECT_EQ(objectOperator2.FastGetValue()->GetInt(), 12);
366 }
367
HWTEST_F_L0(ObjectOperatorTest,ReLookupPropertyInReceiver_001)368 HWTEST_F_L0(ObjectOperatorTest, ReLookupPropertyInReceiver_001)
369 {
370 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
371 JSHandle<JSTaggedValue> undefined = thread->GlobalConstants()->GetHandledUndefined();
372 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
373 JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(2));
374 JSHandle<JSTaggedValue> handleName(factory->NewFromASCII("123"));
375 JSHandle<JSTaggedValue> handleHolder(factory->NewFromASCII("12"));
376 JSHandle<JSTaggedValue> handleReceiver(factory->NewJSString(handleName, undefined));
377 // Receiver is string
378 ObjectOperator objectOperator1(thread, handleHolder, handleReceiver, handleKey);
379 objectOperator1.ReLookupPropertyInReceiver();
380 EXPECT_EQ(objectOperator1.GetIndex(), 2U);
381 EXPECT_TRUE(objectOperator1.GetValue().IsString());
382 EXPECT_EQ(objectOperator1.GetAttr().GetPropertyMetaData(), 2);
383 EXPECT_TRUE(objectOperator1.IsFastMode());
384 // Receiver is not DictionaryMode
385 JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
386 for (int i = 0; i< 3; i++) {
387 JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
388 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newKey);
389 }
390 ObjectOperator objectOperator2(thread, handleHolder, JSHandle<JSTaggedValue>(handleObject), handleKey);
391 objectOperator2.ReLookupPropertyInReceiver();
392 EXPECT_EQ(objectOperator2.GetIndex(), 2U);
393 EXPECT_EQ(objectOperator2.GetValue().GetInt(), 2);
394 EXPECT_EQ(objectOperator2.GetAttr().GetPropertyMetaData(), 7);
395 EXPECT_TRUE(objectOperator2.IsFastMode());
396 // Receiver is DictionaryMode
397 JSObject::DeleteProperty(thread, (handleObject), handleKey);
398 ObjectOperator objectOperator3(thread, handleHolder, JSHandle<JSTaggedValue>(handleObject), handleKey);
399 objectOperator3.ReLookupPropertyInReceiver(); // no key find
400 EXPECT_EQ(objectOperator3.GetIndex(), ObjectOperator::NOT_FOUND_INDEX);
401 EXPECT_TRUE(objectOperator3.GetValue().IsUndefined());
402 EXPECT_EQ(objectOperator3.GetAttr().GetPropertyMetaData(), 0);
403 EXPECT_FALSE(objectOperator3.IsFastMode());
404 }
405
HWTEST_F_L0(ObjectOperatorTest,ReLookupPropertyInReceiver_002)406 HWTEST_F_L0(ObjectOperatorTest, ReLookupPropertyInReceiver_002)
407 {
408 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
409 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
410 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
411 JSHandle<JSTaggedValue> handleKey1(thread, JSTaggedValue(0));
412 JSHandle<JSTaggedValue> handleKey2(thread, JSTaggedValue(1));
413 JSHandle<JSTaggedValue> handleHolder(factory->NewFromASCII("12"));
414 JSHandle<JSTaggedValue> globalObj = env->GetJSGlobalObject();
415 JSHandle<JSObject> handleReceiver(globalObj);
416 PropertyAttributes handleAttr(4);
417 // Receiver is JSGlobalObject(no properties)
418 ObjectOperator objectOperator1(thread, handleHolder, JSHandle<JSTaggedValue>(handleReceiver), handleKey);
419 objectOperator1.ReLookupPropertyInReceiver();
420 EXPECT_EQ(objectOperator1.GetIndex(), ObjectOperator::NOT_FOUND_INDEX);
421 EXPECT_TRUE(objectOperator1.GetValue().IsUndefined());
422 EXPECT_EQ(objectOperator1.GetAttr().GetPropertyMetaData(), 0);
423 EXPECT_FALSE(objectOperator1.IsFastMode());
424 // Receiver is JSGlobalObject(properties)
425 JSMutableHandle<GlobalDictionary> receiverDict(thread, handleReceiver->GetProperties());
426 JSHandle<GlobalDictionary> handleDict = GlobalDictionary::Create(thread, 4); // numberofElements = 4
427 receiverDict.Update(handleDict.GetTaggedValue());
428 JSHandle<PropertyBox> cellHandle = factory->NewPropertyBox(handleKey);
429 cellHandle->SetValue(thread, JSTaggedValue(4));
430 JSHandle<GlobalDictionary> handleProperties =
431 GlobalDictionary::PutIfAbsent(thread, receiverDict, handleKey, JSHandle<JSTaggedValue>(cellHandle), handleAttr);
432 handleReceiver->SetProperties(thread, handleProperties.GetTaggedValue());
433 int keyEntry = handleProperties->FindEntry(handleKey.GetTaggedValue());
434 ObjectOperator objectOperator2(thread, handleHolder, JSHandle<JSTaggedValue>(handleReceiver), handleKey);
435 objectOperator2.ReLookupPropertyInReceiver();
436 EXPECT_EQ(objectOperator2.GetIndex(), static_cast<uint32_t>(keyEntry));
437 EXPECT_TRUE(objectOperator2.GetValue().IsPropertyBox());
438 EXPECT_EQ(objectOperator2.GetAttr().GetPropertyMetaData(), handleAttr.GetPropertyMetaData());
439 EXPECT_TRUE(objectOperator2.IsFastMode());
440 }
441
HWTEST_F_L0(ObjectOperatorTest,ReLookupPropertyInReceiver_003)442 HWTEST_F_L0(ObjectOperatorTest, ReLookupPropertyInReceiver_003)
443 {
444 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
445 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
446 JSHandle<JSTaggedValue> handleHolder(factory->NewFromASCII("12"));
447 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
448 JSHandle<JSTaggedValue> handleKey1(thread, JSTaggedValue(1));
449 JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
450 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), handleKey, handleKey1);
451 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), handleKey1, handleKey1);
452 // Receiver is not DictionaryMode
453 ObjectOperator objectOperator1(thread, handleHolder, JSHandle<JSTaggedValue>(handleObject), handleKey);
454 objectOperator1.ReLookupPropertyInReceiver();
455 EXPECT_EQ(objectOperator1.GetIndex(), 0U);
456 EXPECT_EQ(objectOperator1.GetValue().GetInt(), 1);
457 EXPECT_EQ(objectOperator1.GetAttr().GetPropertyMetaData(), 7); // default attribute
458 EXPECT_TRUE(objectOperator1.IsFastMode());
459 // Receiver is DictionaryMode
460 JSObject::DeleteProperty(thread, (handleObject), handleKey);
461 ObjectOperator objectOperator2(thread, handleHolder, JSHandle<JSTaggedValue>(handleObject), handleKey);
462 objectOperator2.ReLookupPropertyInReceiver();
463 EXPECT_EQ(objectOperator2.GetIndex(), ObjectOperator::NOT_FOUND_INDEX);
464 EXPECT_TRUE(objectOperator2.GetValue().IsUndefined());
465 EXPECT_EQ(objectOperator2.GetAttr().GetPropertyMetaData(), 0); // default attribute
466 EXPECT_FALSE(objectOperator2.IsFastMode());
467 }
468
HWTEST_F_L0(ObjectOperatorTest,LookupProperty)469 HWTEST_F_L0(ObjectOperatorTest, LookupProperty)
470 {
471 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
472 JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(1));
473 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(2));
474 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
475 JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
476 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), handleKey, handleValue);
477 JSHandle<JSObject> handleObject1 = JSObject::ObjectCreate(thread, handleObject);
478
479 ObjectOperator objectOperator(thread, handleObject1, handleKey);
480 objectOperator.LookupProperty();
481 EXPECT_TRUE(objectOperator.IsOnPrototype());
482 EXPECT_EQ(objectOperator.GetIndex(), 1U);
483 EXPECT_EQ(objectOperator.GetAttr().GetPropertyMetaData(), 7);
484 EXPECT_EQ(objectOperator.GetValue().GetInt(), 2);
485 EXPECT_TRUE(objectOperator.IsFastMode());
486 }
487
HWTEST_F_L0(ObjectOperatorTest,GlobalLookupProperty)488 HWTEST_F_L0(ObjectOperatorTest, GlobalLookupProperty)
489 {
490 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
491 JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(1));
492 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(2));
493 JSHandle<JSTaggedValue> globalObj = env->GetJSGlobalObject();
494 JSHandle<JSObject> handleGlobalObject(globalObj);
495 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleGlobalObject), handleKey, handleValue);
496 JSHandle<JSObject> handleObject = JSObject::ObjectCreate(thread, handleGlobalObject);
497 JSHandle<JSTaggedValue> handleGlobalObj(JSHandle<JSGlobalObject>::Cast(handleObject));
498
499 ObjectOperator objectOperator(thread, handleGlobalObj, handleKey);
500 objectOperator.GlobalLookupProperty();
501 EXPECT_TRUE(objectOperator.IsOnPrototype());
502 EXPECT_EQ(objectOperator.GetIndex(), 1U);
503 EXPECT_EQ(objectOperator.GetAttr().GetPropertyMetaData(), 7);
504 EXPECT_EQ(objectOperator.GetValue().GetInt(), 2);
505 EXPECT_TRUE(objectOperator.IsFastMode());
506 }
507
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor1)508 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor1)
509 {
510 JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(1));
511 OperatorType type = OperatorType::PROTOTYPE_CHAIN;
512 // ObjectOperator(thread, JSHandle<JSTaggedVale>(), type)
513 ObjectOperator objectOperator1(thread, handleKey, type);
514 EXPECT_TRUE(objectOperator1.IsOnPrototype());
515 EXPECT_TRUE(objectOperator1.GetReceiver()->IsJSGlobalObject());
516 EXPECT_FALSE(objectOperator1.GetHolder()->IsJSGlobalObject());
517 type = OperatorType::OWN;
518 ObjectOperator objectOperator2(thread, handleKey, type);
519 EXPECT_FALSE(objectOperator2.IsOnPrototype());
520 EXPECT_TRUE(objectOperator2.GetReceiver()->IsJSGlobalObject());
521 EXPECT_TRUE(objectOperator2.GetHolder()->IsJSGlobalObject());
522 }
523
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor2)524 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor2)
525 {
526 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
527 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
528 JSHandle<JSObject> handleHolder = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
529 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
530 OperatorType type = OperatorType::PROTOTYPE_CHAIN;
531 // ObjectOperator(thread, JSHandle<JSObject>(), JSHandle<JSTaggedVale>(), type)
532 ObjectOperator objectOperator1(thread, handleHolder, handleKey, type);
533 EXPECT_TRUE(objectOperator1.IsOnPrototype());
534 type = OperatorType::OWN;
535 ObjectOperator objectOperator2(thread, handleHolder, handleKey, type);
536 EXPECT_FALSE(objectOperator2.IsOnPrototype());
537 }
538
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor3)539 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor3)
540 {
541 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
542 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
543 JSHandle<JSTaggedValue> symbolFunc = env->GetSymbolFunction();
544 JSHandle<JSTaggedValue> handleHolder(thread, symbolFunc.GetTaggedValue());
545 JSHandle<JSTaggedValue> handleReceiver(thread, symbolFunc.GetTaggedValue());
546 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
547 OperatorType type = OperatorType::PROTOTYPE_CHAIN;
548 // ObjectOperator(thread, JSHandle<JSTaggedVale>(), JSHandle<JSTaggedVale>(), type)
549 ObjectOperator objectOperator1(thread, handleHolder, handleKey, type);
550 EXPECT_TRUE(objectOperator1.IsOnPrototype());
551 type = OperatorType::OWN;
552 ObjectOperator objectOperator2(thread, handleHolder, handleKey, type);
553 EXPECT_FALSE(objectOperator2.IsOnPrototype());
554 }
555
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor4)556 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor4)
557 {
558 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
559 JSHandle<JSTaggedValue> stringFunc = env->GetStringFunction();
560 JSHandle<JSTaggedValue> handleHolder(thread, stringFunc.GetTaggedValue());
561 JSHandle<JSTaggedValue> handleReceiver(thread, stringFunc.GetTaggedValue());
562 OperatorType type = OperatorType::PROTOTYPE_CHAIN;
563 // ObjectOperator(thread, JSHandle<JSTaggedVale>(), JSHandle<JSTaggedVale>(), type)
564 ObjectOperator objectOperator1(thread, handleHolder, handleReceiver, type);
565 EXPECT_TRUE(objectOperator1.IsOnPrototype());
566 type = OperatorType::OWN;
567 ObjectOperator objectOperator2(thread, handleHolder, handleReceiver, type);
568 EXPECT_FALSE(objectOperator2.IsOnPrototype());
569 }
570
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor5)571 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor5)
572 {
573 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
574 JSHandle<JSTaggedValue> boolFunc = env->GetBooleanFunction();
575 JSHandle<JSTaggedValue> handleHolder(thread, boolFunc.GetTaggedValue());
576 uint32_t index = 1;
577 OperatorType type = OperatorType::PROTOTYPE_CHAIN;
578 // ObjectOperator(thread, JSHandle<JSTaggedVale>(), index, type)
579 ObjectOperator objectOperator1(thread, handleHolder, index, type);
580 EXPECT_TRUE(objectOperator1.IsOnPrototype());
581 type = OperatorType::OWN;
582 ObjectOperator objectOperator2(thread, handleHolder, index, type);
583 EXPECT_FALSE(objectOperator2.IsOnPrototype());
584 }
585
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor6)586 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor6)
587 {
588 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
589 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
590 JSHandle<JSTaggedValue> numFunc = env->GetNumberFunction();
591 JSHandle<JSTaggedValue> handleReceiver(thread, numFunc.GetTaggedValue());
592 JSHandle<JSTaggedValue> handleName(factory->NewFromASCII("name"));
593 OperatorType type = OperatorType::PROTOTYPE_CHAIN;
594 // ObjectOperator(thread, JSTaggedVale(), JSTaggedValue(), type)
595 ObjectOperator objectOperator1(thread, handleReceiver.GetTaggedValue(), handleName.GetTaggedValue(), type);
596 EXPECT_FALSE(objectOperator1.IsOnPrototype());
597 type = OperatorType::OWN;
598 ObjectOperator objectOperator2(thread, handleReceiver.GetTaggedValue(), handleName.GetTaggedValue(), type);
599 EXPECT_FALSE(objectOperator2.IsOnPrototype());
600 }
601
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor7)602 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor7)
603 {
604 JSHandle<JSTaggedValue> handleReceiver(thread, JSTaggedValue(1));
605 JSHandle<JSTaggedValue> handleName(thread, JSTaggedValue(2));
606 PropertyAttributes handleAttr(4);
607 // ObjectOperator(thread, JSTaggedVale(), JSTaggedValue(), PropertyAttributes())
608 ObjectOperator objectOperator(thread, handleReceiver.GetTaggedValue(), handleName.GetTaggedValue(), handleAttr);
609 EXPECT_EQ(objectOperator.GetReceiver()->GetInt(), 1);
610 EXPECT_EQ(objectOperator.GetAttr().GetPropertyMetaData(), 4);
611 EXPECT_EQ(objectOperator.GetKey()->GetInt(), 2);
612 }
613
HWTEST_F_L0(ObjectOperatorTest,UpdateDateValue_001)614 HWTEST_F_L0(ObjectOperatorTest, UpdateDateValue_001)
615 {
616 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
617 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
618 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
619 JSHandle<JSTaggedValue> handleKey2(thread, JSTaggedValue(2));
620 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(4));
621 JSHandle<JSTaggedValue> handleValue1(thread, JSTaggedValue(5));
622 ObjectOperator objectOperator1(thread, handleValue);
623 objectOperator1.SetIndex(1);
624
625 // object is not DictionaryMode
626 JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
627 for (int i = 0; i< 3; i++) {
628 JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
629 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newKey);
630 }
631 EXPECT_TRUE(objectOperator1.UpdateDataValue(handleObject, handleValue, false));
632 auto *resultElements =TaggedArray::Cast(handleObject->GetElements().GetTaggedObject());
633 EXPECT_EQ(resultElements->Get(objectOperator1.GetIndex()).GetInt(), 4);
634
635 // object is DictionaryMode
636 JSObject::DeleteProperty(thread, handleObject, handleKey2);
637 EXPECT_TRUE(objectOperator1.UpdateDataValue(handleObject, handleValue1, false));
638 auto *resultDict = NumberDictionary::Cast(handleObject->GetElements().GetTaggedObject());
639 EXPECT_EQ(resultDict->GetValue(objectOperator1.GetIndex()).GetInt(), 5);
640
641 // objcet value is InternalAccessor
642 JSHandle<AccessorData> handleAccessorData = factory->NewAccessorData();
643 JSHandle<JSNativePointer> handleSetter = factory->NewJSNativePointer(reinterpret_cast<void *>(TestBoolSetter));
644 handleAccessorData->SetSetter(thread, handleSetter.GetTaggedValue());
645 JSHandle<JSTaggedValue> handleValue2(handleAccessorData);
646 ObjectOperator objectOperator2(thread, handleKey);
647 objectOperator2.SetValue(handleAccessorData.GetTaggedValue());
648 objectOperator2.SetIndex(1);
649 EXPECT_TRUE(objectOperator2.UpdateDataValue(handleObject, handleValue, true));
650 }
651
HWTEST_F_L0(ObjectOperatorTest,UpdateDataValue_002)652 HWTEST_F_L0(ObjectOperatorTest, UpdateDataValue_002)
653 {
654 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
655 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
656 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
657 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
658 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(100));
659 // object is JSGlobalObject
660 JSHandle<JSTaggedValue> globalObj = env->GetJSGlobalObject();
661 JSHandle<JSObject> handleGlobalObject(globalObj);
662
663 JSMutableHandle<GlobalDictionary> holderDict(thread, handleGlobalObject->GetProperties());
664 JSHandle<GlobalDictionary> handleDict = GlobalDictionary::Create(thread, 4); // numberofElements = 4
665 holderDict.Update(handleDict.GetTaggedValue());
666 JSHandle<PropertyBox> cellHandle = factory->NewPropertyBox(handleKey);
667 cellHandle->SetValue(thread, JSTaggedValue(4));
668 JSHandle<GlobalDictionary> handleProperties =
669 GlobalDictionary::PutIfAbsent(thread, holderDict, handleKey,
670 JSHandle<JSTaggedValue>(cellHandle), PropertyAttributes(4));
671 handleGlobalObject->SetProperties(thread, handleProperties.GetTaggedValue()); // Set Properties
672 int keyEntry = handleProperties->FindEntry(handleKey.GetTaggedValue());
673
674 ObjectOperator objectOperator(thread, handleGlobalObject, handleKey);
675 objectOperator.SetIndex(keyEntry);
676 EXPECT_TRUE(objectOperator.UpdateDataValue(handleGlobalObject, handleValue, false));
677 auto *resultDict = GlobalDictionary::Cast(handleGlobalObject->GetProperties().GetTaggedObject());
678 PropertyBox *resultCell = resultDict->GetBox(objectOperator.GetIndex());
679 EXPECT_EQ(resultCell->GetValue().GetInt(), 100);
680 }
681
HWTEST_F_L0(ObjectOperatorTest,UpdateDataValue_003)682 HWTEST_F_L0(ObjectOperatorTest, UpdateDataValue_003)
683 {
684 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
685 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
686 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(4));
687 JSHandle<JSTaggedValue> handleValue1(thread, JSTaggedValue(3));
688 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
689 JSHandle<EcmaString> handleKey1 = factory->NewFromASCII("value");
690 JSHandle<JSTaggedValue> handleKey2(factory->NewFromASCII("value1"));
691
692 ObjectOperator objectOperator(thread, handleKey);
693 objectOperator.SetIndex(1);
694 PropertyDescriptor handleDesc(thread);
695 PropertyAttributes handleAttr(handleDesc);
696 handleAttr.SetIsInlinedProps(true);
697 objectOperator.SetAttr(PropertyAttributes(handleDesc));
698
699 // object is not DictionaryMode
700 JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
701 for (int i = 0; i < 10; i++) {
702 JSHandle<JSTaggedValue> newValue(thread, JSTaggedValue(i));
703 JSHandle<EcmaString> newString =
704 factory->ConcatFromString(handleKey1, JSTaggedValue::ToString(thread, newValue));
705 JSHandle<JSTaggedValue> newKey(thread, newString.GetTaggedValue());
706 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newValue);
707 }
708 EXPECT_TRUE(objectOperator.UpdateDataValue(handleObject, handleValue1, false));
709 TaggedArray *resultElements1 = TaggedArray::Cast(handleObject->GetProperties().GetTaggedObject());
710 EXPECT_EQ(resultElements1->Get(objectOperator.GetIndex()).GetInt(), 3);
711
712 // object is DictionaryMode
713 JSObject::DeleteProperty(thread, handleObject, handleKey2);
714 EXPECT_TRUE(objectOperator.UpdateDataValue(handleObject, handleValue, false));
715 TaggedArray *resultElements2 = TaggedArray::Cast(handleObject->GetProperties().GetTaggedObject());
716 auto *resultDict = NumberDictionary::Cast(resultElements2);
717 EXPECT_EQ(resultDict->GetValue(objectOperator.GetIndex()).GetInt(), 4);
718 }
719
HWTEST_F_L0(ObjectOperatorTest,WriteDataProperty_001)720 HWTEST_F_L0(ObjectOperatorTest, WriteDataProperty_001)
721 {
722 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
723 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
724 JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(2));
725 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(4));
726 uint32_t index = 1;
727 PropertyDescriptor handleDesc(thread);
728 ObjectOperator objectOperator(thread, handleKey);
729 PropertyAttributes handleAttr(4);
730 handleDesc.SetConfigurable(true); // Desc Set Configurable
731 objectOperator.SetAttr(PropertyAttributes(3));
732 objectOperator.SetIndex(index);
733 // object class is not DictionaryElement and object is Element
734 JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
735 for (int i = 0; i< 3; i++) {
736 JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
737 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newKey);
738 }
739 EXPECT_TRUE(objectOperator.WriteDataProperty(handleObject, handleDesc));
740 auto resultDict = NumberDictionary::Cast(handleObject->GetElements().GetTaggedObject());
741 int resultEntry = resultDict->FindEntry(JSTaggedValue(index));
742 int resultAttrValue = resultDict->GetAttributes(resultEntry).GetPropertyMetaData();
743
744 EXPECT_EQ(objectOperator.GetAttr().GetPropertyMetaData(), resultAttrValue);
745 EXPECT_EQ(objectOperator.GetAttr().GetDictionaryOrder(), 1U);
746 EXPECT_TRUE(objectOperator.GetAttr().IsConfigurable());
747 EXPECT_EQ(objectOperator.GetIndex(), static_cast<uint32_t>(resultEntry));
748 EXPECT_FALSE(objectOperator.IsFastMode());
749 EXPECT_TRUE(objectOperator.IsTransition());
750 }
751
HWTEST_F_L0(ObjectOperatorTest,WriteDataProperty_002)752 HWTEST_F_L0(ObjectOperatorTest, WriteDataProperty_002)
753 {
754 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
755 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
756 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
757 JSHandle<JSTaggedValue> handleValue1(thread, JSTaggedValue(1));
758 JSHandle<JSTaggedValue> handleValue2(thread, JSTaggedValue(2));
759 JSHandle<PropertyBox> cellHandle1 = factory->NewPropertyBox(handleValue1);
760 JSHandle<PropertyBox> cellHandle2 = factory->NewPropertyBox(handleValue2);
761 PropertyDescriptor handleDesc(thread);
762 handleDesc.SetConfigurable(true);
763 PropertyAttributes handleAttr(2);
764 handleAttr.SetConfigurable(true);
765 // object is JSGlobalObject and not Element
766 JSHandle<JSTaggedValue> globalObj = env->GetJSGlobalObject();
767 JSHandle<JSObject> handleGlobalObject(globalObj);
768 ObjectOperator objectOperator(thread, handleGlobalObject, handleKey);
769
770 JSMutableHandle<GlobalDictionary> globalDict(thread, handleGlobalObject->GetProperties());
771 JSHandle<GlobalDictionary> handleDict = GlobalDictionary::Create(thread, 4);
772 globalDict.Update(handleDict.GetTaggedValue());
773 JSHandle<GlobalDictionary> handleProperties = GlobalDictionary::PutIfAbsent(
774 thread, globalDict, handleKey, JSHandle<JSTaggedValue>(cellHandle1), PropertyAttributes(4));
775 handleProperties->SetAttributes(thread, handleAttr.GetDictionaryOrder(), handleAttr);
776 handleProperties->SetValue(thread, handleAttr.GetDictionaryOrder(), cellHandle2.GetTaggedValue());
777 handleGlobalObject->SetProperties(thread, handleProperties.GetTaggedValue());
778 objectOperator.SetIndex(handleProperties->FindEntry(handleKey.GetTaggedValue()));
779
780 EXPECT_TRUE(objectOperator.WriteDataProperty(handleGlobalObject, handleDesc));
781 auto resultDict = GlobalDictionary::Cast(handleGlobalObject->GetProperties().GetTaggedObject());
782 EXPECT_EQ(resultDict->GetAttributes(objectOperator.GetIndex()).GetPropertyMetaData(), 4);
783 EXPECT_TRUE(resultDict->GetAttributes(objectOperator.GetIndex()).IsConfigurable());
784
785 int resultEntry = resultDict->GetAttributes(objectOperator.GetIndex()).GetDictionaryOrder();
786 EXPECT_EQ(resultDict->GetAttributes(resultEntry).GetBoxType(), PropertyBoxType::MUTABLE);
787 EXPECT_EQ(resultDict->GetValue(resultEntry).GetInt(), 1);
788 }
789
HWTEST_F_L0(ObjectOperatorTest,WriteDataProperty_003)790 HWTEST_F_L0(ObjectOperatorTest, WriteDataProperty_003)
791 {
792 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
793 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
794 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
795 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(2));
796 PropertyDescriptor handleDesc(thread, handleValue);
797 handleDesc.SetSetter(handleValue); // Desc is AccessorDescriptor
798 handleDesc.SetGetter(handleValue);
799 // object is not DictionaryMode and not Element
800 JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
801 for (int i = 0; i< 3; i++) {
802 JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
803 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newKey);
804 }
805 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), handleKey, handleValue);
806 ObjectOperator objectOperator1(thread, handleKey);
807 objectOperator1.SetAttr(PropertyAttributes(1));
808
809 EXPECT_TRUE(objectOperator1.WriteDataProperty(handleObject, handleDesc));
810 auto resultDict = NameDictionary::Cast(handleObject->GetProperties().GetTaggedObject());
811 int resultEntry = resultDict->FindEntry(handleKey.GetTaggedValue());
812 EXPECT_TRUE(resultDict->GetValue(resultEntry).IsAccessorData());
813 EXPECT_EQ(resultDict->GetAttributes(resultEntry).GetValue(), objectOperator1.GetAttr().GetValue());
814 // object is DictionaryMode and not Element
815 JSObject::DeleteProperty(thread, (handleObject), handleKey);
816 JSHandle<JSTaggedValue> handleSetter(factory->NewJSNativePointer(reinterpret_cast<void *>(TestDefinedSetter)));
817 JSHandle<AccessorData> handleAccessorData = factory->NewAccessorData();
818 handleDesc.SetSetter(handleSetter);
819 ObjectOperator objectOperator2(thread, handleKey);
820 objectOperator2.SetAttr(PropertyAttributes(handleDesc));
821 objectOperator2.SetValue(handleAccessorData.GetTaggedValue());
822 EXPECT_TRUE(objectOperator2.WriteDataProperty(handleObject, handleDesc));
823 JSHandle<AccessorData> resultAccessorData(thread, objectOperator2.GetValue());
824 EXPECT_EQ(resultAccessorData->GetGetter().GetInt(), 2);
825 EXPECT_TRUE(resultAccessorData->GetSetter().IsJSNativePointer());
826 }
827
HWTEST_F_L0(ObjectOperatorTest,Property_Add_001)828 HWTEST_F_L0(ObjectOperatorTest, Property_Add_001)
829 {
830 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
831 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
832 JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(2));
833 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(3));
834 int32_t elementIndex = 2;
835 PropertyAttributes handleAttr(elementIndex);
836 // object is JSArray and Element
837 JSHandle<JSArray> handleArr = factory->NewJSArray();
838 handleArr->SetArrayLength(thread, (elementIndex - 1));
839 JSHandle<JSTaggedValue> handleArrObj(thread, handleArr.GetTaggedValue());
840 ObjectOperator objectOperator1(thread, handleArrObj, elementIndex);
841 EXPECT_TRUE(objectOperator1.AddProperty(JSHandle<JSObject>(handleArrObj), handleValue, handleAttr));
842 EXPECT_EQ(handleArr->GetArrayLength(), 3U); // (elementIndex - 1) + 2
843 // object is DictionaryElement and Element
844 JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
845 for (int i = 0; i< 3; i++) {
846 JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
847 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newKey);
848 }
849 JSObject::DeleteProperty(thread, (handleObject), handleKey); // Delete key2
850 ObjectOperator objectOperator2(thread, JSHandle<JSTaggedValue>(handleObject), elementIndex);
851 EXPECT_TRUE(objectOperator2.AddProperty(handleObject, handleValue, handleAttr));
852 auto resultDict = NumberDictionary::Cast(handleObject->GetElements().GetTaggedObject());
853 int resultEntry = resultDict->FindEntry(JSTaggedValue(static_cast<uint32_t>(elementIndex)));
854 EXPECT_EQ(resultDict->GetKey(resultEntry).GetInt(), elementIndex);
855 EXPECT_EQ(resultDict->GetValue(resultEntry).GetInt(), 3);
856 }
857
HWTEST_F_L0(ObjectOperatorTest,Property_Add_002)858 HWTEST_F_L0(ObjectOperatorTest, Property_Add_002)
859 {
860 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
861 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
862 JSHandle<JSTaggedValue> handleString(factory->NewFromASCII("key"));
863 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(3));
864 int32_t elementIndex = 4;
865 PropertyAttributes handleDefaultAttr(elementIndex);
866 PropertyAttributes handleAttr(elementIndex);
867 handleDefaultAttr.SetDefaultAttributes();
868 // object is not DictionaryMode and DefaultAttr
869 JSHandle<JSObject> handleObject1 = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
870 for (int i = 0; i< 3; i++) {
871 JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
872 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject1), newKey, newKey);
873 }
874 ObjectOperator objectOperator(thread, JSHandle<JSTaggedValue>(handleObject1), elementIndex);
875 EXPECT_TRUE(objectOperator.AddProperty(handleObject1, handleValue, handleDefaultAttr));
876 TaggedArray *resultArray = TaggedArray::Cast(handleObject1->GetElements().GetTaggedObject());
877 EXPECT_EQ(resultArray->Get(elementIndex).GetInt(), 3);
878 EXPECT_EQ(resultArray->GetLength(), 7U);
879 // object is not DictionaryMode and not DefaultAttr
880 JSHandle<JSObject> handleObject2 = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
881 for (int i = 0; i< 4; i++) {
882 JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
883 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject2), newKey, newKey);
884 }
885 EXPECT_TRUE(objectOperator.AddProperty(handleObject2, handleString, handleAttr));
886 auto resultDict = NumberDictionary::Cast(handleObject2->GetElements().GetTaggedObject());
887 int resultEntry = resultDict->FindEntry(JSTaggedValue(static_cast<uint32_t>(elementIndex)));
888 EXPECT_EQ(resultDict->GetKey(resultEntry).GetInt(), elementIndex);
889 EXPECT_TRUE(resultDict->GetValue(resultEntry).IsString());
890 }
891
HWTEST_F_L0(ObjectOperatorTest,Property_Add_003)892 HWTEST_F_L0(ObjectOperatorTest, Property_Add_003)
893 {
894 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
895 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
896 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
897 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
898 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(4));
899 int32_t handleAttrOffset = 4;
900 PropertyAttributes handleAttr(handleAttrOffset);
901 handleAttr.SetOffset(handleAttrOffset);
902 // object is JSGlobalObject and not Element
903 JSHandle<JSTaggedValue> globalObj = env->GetJSGlobalObject();
904 JSHandle<JSObject> handleGlobalObject(globalObj); // no properties
905 ObjectOperator objectOperator(thread, handleGlobalObject, handleKey);
906 EXPECT_TRUE(objectOperator.AddProperty(handleGlobalObject, handleValue, handleAttr));
907 EXPECT_EQ(objectOperator.GetAttr().GetBoxType(), PropertyBoxType::CONSTANT);
908 EXPECT_EQ(objectOperator.FastGetValue()->GetInt(), 4);
909 EXPECT_EQ(objectOperator.GetIndex(), 0U);
910 EXPECT_TRUE(objectOperator.IsFastMode());
911 EXPECT_FALSE(objectOperator.IsTransition());
912 }
913
HWTEST_F_L0(ObjectOperatorTest,Property_Add_004)914 HWTEST_F_L0(ObjectOperatorTest, Property_Add_004)
915 {
916 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
917 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
918 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
919 JSHandle<JSTaggedValue> handleKey1(thread, JSTaggedValue(1));
920 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(4));
921 JSHandle<JSTaggedValue> handledUndefinedVal(thread, JSTaggedValue::Undefined());
922 int32_t handleAttrOffset = 4;
923 PropertyAttributes handleAttr(handleAttrOffset);
924 handleAttr.SetOffset(handleAttrOffset);
925 // object is not DictionaryMode and not Element
926 JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
927 for (int i = 0; i< 4; i++) {
928 JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
929 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newKey);
930 }
931 EXPECT_EQ(handleObject->GetJSHClass()->GetInlinedProperties(), 4U);
932 ObjectOperator objectOperator(thread, handleObject, handleKey);
933 EXPECT_TRUE(objectOperator.AddProperty(handleObject, handleValue, handleAttr));
934 EXPECT_EQ(objectOperator.GetAttr().GetPropertyMetaData(), 4);
935 EXPECT_EQ(objectOperator.GetValue().GetInt(), 4);
936 EXPECT_EQ(objectOperator.GetIndex(), 0U); // 0 = 4 - 4
937 EXPECT_TRUE(objectOperator.IsFastMode());
938 EXPECT_TRUE(objectOperator.IsTransition());
939 // object is DictionaryMode and not Element
940 JSObject::DeleteProperty(thread, (handleObject), handleKey);
941 EXPECT_TRUE(objectOperator.AddProperty(handleObject, handledUndefinedVal, handleAttr));
942 EXPECT_EQ(objectOperator.GetAttr().GetPropertyMetaData(), 4);
943 EXPECT_TRUE(objectOperator.GetValue().IsUndefined());
944 EXPECT_EQ(objectOperator.GetIndex(), 0U);
945 EXPECT_FALSE(objectOperator.IsFastMode());
946 EXPECT_FALSE(objectOperator.IsTransition());
947 }
948
HWTEST_F_L0(ObjectOperatorTest,Property_DeleteElement1)949 HWTEST_F_L0(ObjectOperatorTest, Property_DeleteElement1)
950 {
951 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
952 JSHandle<JSTaggedValue> handleKey0(thread, JSTaggedValue(0));
953 JSHandle<JSTaggedValue> handleKey1(thread, JSTaggedValue(1));
954 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(2));
955 uint32_t index = 1; // key value
956 PropertyAttributes handleAttr(index);
957
958 // object is not DictionaryMode
959 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
960 JSHandle<JSObject> handleObject1 =
961 factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
962 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject1), handleKey0, handleKey0);
963 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject1), handleKey1, handleKey1);
964 TaggedArray *handleElements = TaggedArray::Cast(handleObject1->GetElements().GetTaggedObject());
965 EXPECT_EQ(handleElements->Get(index).GetInt(), 1);
966
967 ObjectOperator objectOperator1(thread, JSHandle<JSTaggedValue>(handleObject1), index);
968 objectOperator1.DeletePropertyInHolder();
969 TaggedArray *resultElements = TaggedArray::Cast(handleObject1->GetElements().GetTaggedObject());
970 EXPECT_EQ(resultElements->Get(index).GetInt(), 0);
971 auto resultDict1 = NumberDictionary::Cast(handleObject1->GetElements().GetTaggedObject());
972 EXPECT_TRUE(resultDict1->IsDictionaryMode());
973 EXPECT_TRUE(JSObject::GetProperty(thread, handleObject1, handleKey1).GetValue()->IsUndefined());
974 // object is DictionaryMode
975 JSHandle<JSObject> handleObject2 =
976 factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
977 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject2), handleKey0, handleKey0);
978 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject2), handleKey1, handleKey1);
979 JSObject::DeleteProperty(thread, (handleObject2), handleKey1);
980 ObjectOperator objectOperator2(thread, JSHandle<JSTaggedValue>(handleObject2), index - 1);
981 objectOperator2.DeletePropertyInHolder();
982 auto resultDict2 = NumberDictionary::Cast(handleObject2->GetElements().GetTaggedObject());
983 EXPECT_TRUE(resultDict2->GetKey(index - 1U).IsUndefined());
984 EXPECT_TRUE(resultDict2->GetValue(index - 1U).IsUndefined());
985 EXPECT_TRUE(JSObject::GetProperty(thread, handleObject2, handleKey0).GetValue()->IsUndefined());
986 EXPECT_TRUE(JSObject::GetProperty(thread, handleObject2, handleKey1).GetValue()->IsUndefined());
987 }
988
HWTEST_F_L0(ObjectOperatorTest,Property_DeleteElement2)989 HWTEST_F_L0(ObjectOperatorTest, Property_DeleteElement2)
990 {
991 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
992 JSHandle<JSTaggedValue> globalObj = env->GetJSGlobalObject();
993 JSHandle<JSObject> handleGlobalObject(globalObj);
994 JSHandle<NumberDictionary> handleDict = NumberDictionary::Create(thread, 4);
995 handleGlobalObject->SetElements(thread, handleDict.GetTaggedValue());
996 handleGlobalObject->GetClass()->SetIsDictionaryElement(true);
997 for (int i = 0; i < 10000; i++) {
998 JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(i));
999 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(i));
1000 JSObject::SetProperty(thread, globalObj, handleKey, handleValue);
1001 JSObject::DeleteProperty(thread, handleGlobalObject, handleKey);
1002 }
1003 auto resultDict = NumberDictionary::Cast(handleGlobalObject->GetElements().GetTaggedObject());
1004 EXPECT_EQ(resultDict->Size(), 4);
1005 }
1006
HWTEST_F_L0(ObjectOperatorTest,Property_DeleteProperty)1007 HWTEST_F_L0(ObjectOperatorTest, Property_DeleteProperty)
1008 {
1009 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1010 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
1011 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
1012 JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
1013 JSHandle<JSTaggedValue> handleKey0(thread, JSTaggedValue(0));
1014 JSHandle<JSTaggedValue> handleKey1(thread, JSTaggedValue(1));
1015 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(33));
1016 // object is JSGlobalObject
1017 JSHandle<JSTaggedValue> globalObj = env->GetJSGlobalObject();
1018 JSHandle<JSObject> handleGlobalObject(globalObj);
1019 JSMutableHandle<GlobalDictionary> globalDict(thread, handleGlobalObject->GetProperties());
1020 JSHandle<GlobalDictionary> handleDict = GlobalDictionary::Create(thread, 4);
1021 globalDict.Update(handleDict.GetTaggedValue());
1022 JSHandle<PropertyBox> cellHandle = factory->NewPropertyBox(handleKey);
1023 cellHandle->SetValue(thread, handleValue.GetTaggedValue());
1024 JSHandle<GlobalDictionary> handleProperties = GlobalDictionary::PutIfAbsent(
1025 thread, globalDict, handleKey, JSHandle<JSTaggedValue>(cellHandle), PropertyAttributes(12));
1026 handleGlobalObject->SetProperties(thread, handleProperties.GetTaggedValue());
1027 ObjectOperator objectOperator1(thread, handleGlobalObject, handleKey);
1028
1029 objectOperator1.DeletePropertyInHolder();
1030 auto resultDict = GlobalDictionary::Cast(handleGlobalObject->GetProperties().GetTaggedObject());
1031 // key not found
1032 EXPECT_EQ(resultDict->FindEntry(handleKey.GetTaggedValue()), -1);
1033 EXPECT_EQ(resultDict->GetAttributes(objectOperator1.GetIndex()).GetValue(), 0U);
1034 // object is not DictionaryMode
1035 JSHandle<JSObject> handleObject =
1036 factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
1037 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), handleKey, handleKey1);
1038 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), handleKey0, handleKey0);
1039 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), handleKey1, handleKey1);
1040 ObjectOperator objectOperator2(thread, handleObject, handleKey);
1041 objectOperator2.DeletePropertyInHolder();
1042 auto resultDict1 = NameDictionary::Cast(handleObject->GetProperties().GetTaggedObject());
1043 // key not found
1044 EXPECT_EQ(resultDict1->FindEntry(handleKey.GetTaggedValue()), -1);
1045 }
1046
HWTEST_F_L0(ObjectOperatorTest,Define_SetterAndGettetr)1047 HWTEST_F_L0(ObjectOperatorTest, Define_SetterAndGettetr)
1048 {
1049 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
1050 JSHandle<AccessorData> handleAccessorData = factory->NewAccessorData();
1051 JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(0));
1052 JSHandle<JSTaggedValue> handleValue1(thread, JSTaggedValue(2));
1053 JSHandle<EcmaString> handleKey(factory->NewFromASCII("value"));
1054 JSHandle<JSTaggedValue> handleKey1(factory->NewFromASCII("key"));
1055 JSHandle<JSTaggedValue> handleKey2(factory->NewFromASCII("value1"));
1056 // object is not DictionaryMode
1057 JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
1058 JSHandle<JSObject> handleObject =
1059 factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
1060 for (int i = 0; i < 10; i++) {
1061 JSHandle<JSTaggedValue> newValue(thread, JSTaggedValue(i));
1062 JSHandle<EcmaString> newString =
1063 factory->ConcatFromString(handleKey, JSTaggedValue::ToString(thread, newValue));
1064 JSHandle<JSTaggedValue> newKey(thread, newString.GetTaggedValue());
1065 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newValue);
1066 }
1067 // object is not Element
1068 ObjectOperator objectOperator(thread, handleObject, handleKey1);
1069 objectOperator.SetIndex(1);
1070 objectOperator.SetValue(handleAccessorData.GetTaggedValue());
1071 PropertyDescriptor handleDesc(thread, handleValue);
1072 handleDesc.SetSetter(handleValue);
1073 handleDesc.SetGetter(handleValue);
1074 objectOperator.SetAttr(PropertyAttributes(handleDesc));
1075 objectOperator.DefineSetter(handleValue1);
1076 objectOperator.DefineGetter(handleValue);
1077
1078 JSHandle<JSObject> resultObj1(objectOperator.GetReceiver());
1079 TaggedArray *properties = TaggedArray::Cast(resultObj1->GetProperties().GetTaggedObject());
1080 JSHandle<AccessorData> resultAccessorData1(thread, properties->Get(objectOperator.GetIndex()));
1081 EXPECT_EQ(resultAccessorData1->GetGetter().GetInt(), 0);
1082 EXPECT_EQ(resultAccessorData1->GetSetter().GetInt(), 2);
1083 // object is DictionaryMode
1084 JSObject::DeleteProperty(thread, handleObject, handleKey2);
1085 objectOperator.DefineSetter(handleValue);
1086 objectOperator.DefineGetter(handleValue1);
1087 JSHandle<JSObject> resultObj2(objectOperator.GetReceiver());
1088 auto resultDict = NameDictionary::Cast(resultObj2->GetProperties().GetTaggedObject());
1089 JSHandle<AccessorData> resultAccessorData2(thread, resultDict->GetValue(objectOperator.GetIndex()));
1090 EXPECT_EQ(resultAccessorData2->GetGetter().GetInt(), 2);
1091 EXPECT_EQ(resultAccessorData2->GetSetter().GetInt(), 0);
1092 }
1093 } // namespace panda::test
1094