• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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> objFunc(thread, JSObjectTestCreate(thread));
372     JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(2));
373     JSHandle<JSTaggedValue> handleName(factory->NewFromASCII("123"));
374     JSHandle<JSTaggedValue> handleHolder(factory->NewFromASCII("12"));
375     JSHandle<JSTaggedValue> handleReceiver(factory->NewJSString(handleName));
376     // Receiver is string
377     ObjectOperator objectOperator1(thread, handleHolder, handleReceiver, handleKey);
378     objectOperator1.ReLookupPropertyInReceiver();
379     EXPECT_EQ(objectOperator1.GetIndex(), 2U);
380     EXPECT_TRUE(objectOperator1.GetValue().IsString());
381     EXPECT_EQ(objectOperator1.GetAttr().GetPropertyMetaData(), 2);
382     EXPECT_TRUE(objectOperator1.IsFastMode());
383     // Receiver is not DictionaryMode
384     JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
385     for (int i = 0; i< 3; i++) {
386         JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
387         JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newKey);
388     }
389     ObjectOperator objectOperator2(thread, handleHolder, JSHandle<JSTaggedValue>(handleObject), handleKey);
390     objectOperator2.ReLookupPropertyInReceiver();
391     EXPECT_EQ(objectOperator2.GetIndex(), 2U);
392     EXPECT_EQ(objectOperator2.GetValue().GetInt(), 2);
393     EXPECT_EQ(objectOperator2.GetAttr().GetPropertyMetaData(), 7);
394     EXPECT_TRUE(objectOperator2.IsFastMode());
395     // Receiver is DictionaryMode
396     JSObject::DeleteProperty(thread, (handleObject), handleKey);
397     ObjectOperator objectOperator3(thread, handleHolder, JSHandle<JSTaggedValue>(handleObject), handleKey);
398     objectOperator3.ReLookupPropertyInReceiver(); // no key find
399     EXPECT_EQ(objectOperator3.GetIndex(), ObjectOperator::NOT_FOUND_INDEX);
400     EXPECT_TRUE(objectOperator3.GetValue().IsUndefined());
401     EXPECT_EQ(objectOperator3.GetAttr().GetPropertyMetaData(), 0);
402     EXPECT_FALSE(objectOperator3.IsFastMode());
403 }
404 
HWTEST_F_L0(ObjectOperatorTest,ReLookupPropertyInReceiver_002)405 HWTEST_F_L0(ObjectOperatorTest, ReLookupPropertyInReceiver_002)
406 {
407     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
408     JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
409     JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
410     JSHandle<JSTaggedValue> handleKey1(thread, JSTaggedValue(0));
411     JSHandle<JSTaggedValue> handleKey2(thread, JSTaggedValue(1));
412     JSHandle<JSTaggedValue> handleHolder(factory->NewFromASCII("12"));
413     JSHandle<JSTaggedValue> globalObj = env->GetJSGlobalObject();
414     JSHandle<JSObject> handleReceiver(globalObj);
415     PropertyAttributes handleAttr(4);
416     // Receiver is JSGlobalObject(no properties)
417     ObjectOperator objectOperator1(thread, handleHolder, JSHandle<JSTaggedValue>(handleReceiver), handleKey);
418     objectOperator1.ReLookupPropertyInReceiver();
419     EXPECT_EQ(objectOperator1.GetIndex(), ObjectOperator::NOT_FOUND_INDEX);
420     EXPECT_TRUE(objectOperator1.GetValue().IsUndefined());
421     EXPECT_EQ(objectOperator1.GetAttr().GetPropertyMetaData(), 0);
422     EXPECT_FALSE(objectOperator1.IsFastMode());
423     // Receiver is JSGlobalObject(properties)
424     JSMutableHandle<GlobalDictionary> receiverDict(thread, handleReceiver->GetProperties());
425     JSHandle<GlobalDictionary> handleDict = GlobalDictionary::Create(thread, 4); // numberofElements = 4
426     receiverDict.Update(handleDict.GetTaggedValue());
427     JSHandle<PropertyBox> cellHandle = factory->NewPropertyBox(handleKey);
428     cellHandle->SetValue(thread, JSTaggedValue(4));
429     JSHandle<GlobalDictionary> handleProperties =
430         GlobalDictionary::PutIfAbsent(thread, receiverDict, handleKey, JSHandle<JSTaggedValue>(cellHandle), handleAttr);
431     handleReceiver->SetProperties(thread, handleProperties.GetTaggedValue());
432     int keyEntry = handleProperties->FindEntry(handleKey.GetTaggedValue());
433     ObjectOperator objectOperator2(thread, handleHolder, JSHandle<JSTaggedValue>(handleReceiver), handleKey);
434     objectOperator2.ReLookupPropertyInReceiver();
435     EXPECT_EQ(objectOperator2.GetIndex(), static_cast<uint32_t>(keyEntry));
436     EXPECT_TRUE(objectOperator2.GetValue().IsPropertyBox());
437     EXPECT_EQ(objectOperator2.GetAttr().GetPropertyMetaData(), handleAttr.GetPropertyMetaData());
438     EXPECT_TRUE(objectOperator2.IsFastMode());
439 }
440 
HWTEST_F_L0(ObjectOperatorTest,ReLookupPropertyInReceiver_003)441 HWTEST_F_L0(ObjectOperatorTest, ReLookupPropertyInReceiver_003)
442 {
443     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
444     JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
445     JSHandle<JSTaggedValue> handleHolder(factory->NewFromASCII("12"));
446     JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
447     JSHandle<JSTaggedValue> handleKey1(thread, JSTaggedValue(1));
448     JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
449     JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), handleKey, handleKey1);
450     JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), handleKey1, handleKey1);
451     // Receiver is not DictionaryMode
452     ObjectOperator objectOperator1(thread, handleHolder, JSHandle<JSTaggedValue>(handleObject), handleKey);
453     objectOperator1.ReLookupPropertyInReceiver();
454     EXPECT_EQ(objectOperator1.GetIndex(), 0U);
455     EXPECT_EQ(objectOperator1.GetValue().GetInt(), 1);
456     EXPECT_EQ(objectOperator1.GetAttr().GetPropertyMetaData(), 7); // default attribute
457     EXPECT_TRUE(objectOperator1.IsFastMode());
458     // Receiver is DictionaryMode
459     JSObject::DeleteProperty(thread, (handleObject), handleKey);
460     ObjectOperator objectOperator2(thread, handleHolder, JSHandle<JSTaggedValue>(handleObject), handleKey);
461     objectOperator2.ReLookupPropertyInReceiver();
462     EXPECT_EQ(objectOperator2.GetIndex(), ObjectOperator::NOT_FOUND_INDEX);
463     EXPECT_TRUE(objectOperator2.GetValue().IsUndefined());
464     EXPECT_EQ(objectOperator2.GetAttr().GetPropertyMetaData(), 0); // default attribute
465     EXPECT_FALSE(objectOperator2.IsFastMode());
466 }
467 
HWTEST_F_L0(ObjectOperatorTest,LookupProperty)468 HWTEST_F_L0(ObjectOperatorTest, LookupProperty)
469 {
470     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
471     JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(1));
472     JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(2));
473     JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
474     JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
475     JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), handleKey, handleValue);
476     JSHandle<JSObject> handleObject1 = JSObject::ObjectCreate(thread, handleObject);
477 
478     ObjectOperator objectOperator(thread, handleObject1, handleKey);
479     objectOperator.LookupProperty();
480     EXPECT_TRUE(objectOperator.IsOnPrototype());
481     EXPECT_EQ(objectOperator.GetIndex(), 1U);
482     EXPECT_EQ(objectOperator.GetAttr().GetPropertyMetaData(), 7);
483     EXPECT_EQ(objectOperator.GetValue().GetInt(), 2);
484     EXPECT_TRUE(objectOperator.IsFastMode());
485 }
486 
HWTEST_F_L0(ObjectOperatorTest,GlobalLookupProperty)487 HWTEST_F_L0(ObjectOperatorTest, GlobalLookupProperty)
488 {
489     JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
490     JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(1));
491     JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(2));
492     JSHandle<JSTaggedValue> globalObj = env->GetJSGlobalObject();
493     JSHandle<JSObject> handleGlobalObject(globalObj);
494     JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleGlobalObject), handleKey, handleValue);
495     JSHandle<JSObject> handleObject = JSObject::ObjectCreate(thread, handleGlobalObject);
496     JSHandle<JSTaggedValue> handleGlobalObj(JSHandle<JSGlobalObject>::Cast(handleObject));
497 
498     ObjectOperator objectOperator(thread, handleGlobalObj, handleKey);
499     objectOperator.GlobalLookupProperty();
500     EXPECT_TRUE(objectOperator.IsOnPrototype());
501     EXPECT_EQ(objectOperator.GetIndex(), 1U);
502     EXPECT_EQ(objectOperator.GetAttr().GetPropertyMetaData(), 7);
503     EXPECT_EQ(objectOperator.GetValue().GetInt(), 2);
504     EXPECT_TRUE(objectOperator.IsFastMode());
505 }
506 
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor1)507 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor1)
508 {
509     JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(1));
510     OperatorType type = OperatorType::PROTOTYPE_CHAIN;
511     // ObjectOperator(thread, JSHandle<JSTaggedVale>(), type)
512     ObjectOperator objectOperator1(thread, handleKey, type);
513     EXPECT_TRUE(objectOperator1.IsOnPrototype());
514     EXPECT_TRUE(objectOperator1.GetReceiver()->IsJSGlobalObject());
515     EXPECT_FALSE(objectOperator1.GetHolder()->IsJSGlobalObject());
516     type = OperatorType::OWN;
517     ObjectOperator objectOperator2(thread, handleKey, type);
518     EXPECT_FALSE(objectOperator2.IsOnPrototype());
519     EXPECT_TRUE(objectOperator2.GetReceiver()->IsJSGlobalObject());
520     EXPECT_TRUE(objectOperator2.GetHolder()->IsJSGlobalObject());
521 }
522 
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor2)523 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor2)
524 {
525     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
526     JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
527     JSHandle<JSObject> handleHolder = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
528     JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
529     OperatorType type = OperatorType::PROTOTYPE_CHAIN;
530     // ObjectOperator(thread, JSHandle<JSObject>(), JSHandle<JSTaggedVale>(), type)
531     ObjectOperator objectOperator1(thread, handleHolder, handleKey, type);
532     EXPECT_TRUE(objectOperator1.IsOnPrototype());
533     type = OperatorType::OWN;
534     ObjectOperator objectOperator2(thread, handleHolder, handleKey, type);
535     EXPECT_FALSE(objectOperator2.IsOnPrototype());
536 }
537 
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor3)538 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor3)
539 {
540     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
541     JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
542     JSHandle<JSTaggedValue> symbolFunc = env->GetSymbolFunction();
543     JSHandle<JSTaggedValue> handleHolder(thread, symbolFunc.GetTaggedValue());
544     JSHandle<JSTaggedValue> handleReceiver(thread, symbolFunc.GetTaggedValue());
545     JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
546     OperatorType type = OperatorType::PROTOTYPE_CHAIN;
547     // ObjectOperator(thread, JSHandle<JSTaggedVale>(), JSHandle<JSTaggedVale>(), type)
548     ObjectOperator objectOperator1(thread, handleHolder, handleKey, type);
549     EXPECT_TRUE(objectOperator1.IsOnPrototype());
550     type = OperatorType::OWN;
551     ObjectOperator objectOperator2(thread, handleHolder, handleKey, type);
552     EXPECT_FALSE(objectOperator2.IsOnPrototype());
553 }
554 
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor4)555 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor4)
556 {
557     JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
558     JSHandle<JSTaggedValue> stringFunc = env->GetStringFunction();
559     JSHandle<JSTaggedValue> handleHolder(thread, stringFunc.GetTaggedValue());
560     JSHandle<JSTaggedValue> handleReceiver(thread, stringFunc.GetTaggedValue());
561     OperatorType type = OperatorType::PROTOTYPE_CHAIN;
562     // ObjectOperator(thread, JSHandle<JSTaggedVale>(), JSHandle<JSTaggedVale>(), type)
563     ObjectOperator objectOperator1(thread, handleHolder, handleReceiver, type);
564     EXPECT_TRUE(objectOperator1.IsOnPrototype());
565     type = OperatorType::OWN;
566     ObjectOperator objectOperator2(thread, handleHolder, handleReceiver, type);
567     EXPECT_FALSE(objectOperator2.IsOnPrototype());
568 }
569 
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor5)570 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor5)
571 {
572     JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
573     JSHandle<JSTaggedValue> boolFunc = env->GetBooleanFunction();
574     JSHandle<JSTaggedValue> handleHolder(thread, boolFunc.GetTaggedValue());
575     uint32_t index = 1;
576     OperatorType type = OperatorType::PROTOTYPE_CHAIN;
577     // ObjectOperator(thread, JSHandle<JSTaggedVale>(), index, type)
578     ObjectOperator objectOperator1(thread, handleHolder, index, type);
579     EXPECT_TRUE(objectOperator1.IsOnPrototype());
580     type = OperatorType::OWN;
581     ObjectOperator objectOperator2(thread, handleHolder, index, type);
582     EXPECT_FALSE(objectOperator2.IsOnPrototype());
583 }
584 
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor6)585 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor6)
586 {
587     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
588     JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
589     JSHandle<JSTaggedValue> numFunc = env->GetNumberFunction();
590     JSHandle<JSTaggedValue> handleReceiver(thread, numFunc.GetTaggedValue());
591     JSHandle<JSTaggedValue> handleName(factory->NewFromASCII("name"));
592     OperatorType type = OperatorType::PROTOTYPE_CHAIN;
593     // ObjectOperator(thread, JSTaggedVale(), JSTaggedValue(), type)
594     ObjectOperator objectOperator1(thread, handleReceiver.GetTaggedValue(), handleName.GetTaggedValue(), type);
595     EXPECT_FALSE(objectOperator1.IsOnPrototype());
596     type = OperatorType::OWN;
597     ObjectOperator objectOperator2(thread, handleReceiver.GetTaggedValue(), handleName.GetTaggedValue(), type);
598     EXPECT_FALSE(objectOperator2.IsOnPrototype());
599 }
600 
HWTEST_F_L0(ObjectOperatorTest,ObjectOperator_Constructor7)601 HWTEST_F_L0(ObjectOperatorTest, ObjectOperator_Constructor7)
602 {
603     JSHandle<JSTaggedValue> handleReceiver(thread, JSTaggedValue(1));
604     JSHandle<JSTaggedValue> handleName(thread, JSTaggedValue(2));
605     PropertyAttributes handleAttr(4);
606     // ObjectOperator(thread, JSTaggedVale(), JSTaggedValue(), PropertyAttributes())
607     ObjectOperator objectOperator(thread, handleReceiver.GetTaggedValue(), handleName.GetTaggedValue(), handleAttr);
608     EXPECT_EQ(objectOperator.GetReceiver()->GetInt(), 1);
609     EXPECT_EQ(objectOperator.GetAttr().GetPropertyMetaData(), 4);
610     EXPECT_EQ(objectOperator.GetKey()->GetInt(), 2);
611 }
612 
HWTEST_F_L0(ObjectOperatorTest,UpdateDateValue_001)613 HWTEST_F_L0(ObjectOperatorTest, UpdateDateValue_001)
614 {
615     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
616     JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
617     JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
618     JSHandle<JSTaggedValue> handleKey2(thread, JSTaggedValue(2));
619     JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(4));
620     JSHandle<JSTaggedValue> handleValue1(thread, JSTaggedValue(5));
621     ObjectOperator objectOperator1(thread, handleValue);
622     objectOperator1.SetIndex(1);
623 
624     // object is not DictionaryMode
625     JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
626     for (int i = 0; i< 3; i++) {
627         JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
628         JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newKey);
629     }
630     EXPECT_TRUE(objectOperator1.UpdateDataValue(handleObject, handleValue, false));
631     auto *resultElements =TaggedArray::Cast(handleObject->GetElements().GetTaggedObject());
632     EXPECT_EQ(resultElements->Get(objectOperator1.GetIndex()).GetInt(), 4);
633 
634     // object is DictionaryMode
635     JSObject::DeleteProperty(thread, handleObject, handleKey2);
636     EXPECT_TRUE(objectOperator1.UpdateDataValue(handleObject, handleValue1, false));
637     auto *resultDict = NumberDictionary::Cast(handleObject->GetElements().GetTaggedObject());
638     EXPECT_EQ(resultDict->GetValue(objectOperator1.GetIndex()).GetInt(), 5);
639 
640     // objcet value is InternalAccessor
641     JSHandle<AccessorData> handleAccessorData = factory->NewAccessorData();
642     JSHandle<JSNativePointer> handleSetter = factory->NewJSNativePointer(reinterpret_cast<void *>(TestBoolSetter));
643     handleAccessorData->SetSetter(thread, handleSetter.GetTaggedValue());
644     JSHandle<JSTaggedValue> handleValue2(handleAccessorData);
645     ObjectOperator objectOperator2(thread, handleKey);
646     objectOperator2.SetValue(handleAccessorData.GetTaggedValue());
647     objectOperator2.SetIndex(1);
648     EXPECT_TRUE(objectOperator2.UpdateDataValue(handleObject, handleValue, true));
649 }
650 
HWTEST_F_L0(ObjectOperatorTest,UpdateDataValue_002)651 HWTEST_F_L0(ObjectOperatorTest, UpdateDataValue_002)
652 {
653     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
654     JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
655     JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
656     JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
657     JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(100));
658     // object is JSGlobalObject
659     JSHandle<JSTaggedValue> globalObj = env->GetJSGlobalObject();
660     JSHandle<JSObject> handleGlobalObject(globalObj);
661 
662     JSMutableHandle<GlobalDictionary> holderDict(thread, handleGlobalObject->GetProperties());
663     JSHandle<GlobalDictionary> handleDict = GlobalDictionary::Create(thread, 4); // numberofElements = 4
664     holderDict.Update(handleDict.GetTaggedValue());
665     JSHandle<PropertyBox> cellHandle = factory->NewPropertyBox(handleKey);
666     cellHandle->SetValue(thread, JSTaggedValue(4));
667     JSHandle<GlobalDictionary> handleProperties =
668         GlobalDictionary::PutIfAbsent(thread, holderDict, handleKey,
669                                       JSHandle<JSTaggedValue>(cellHandle), PropertyAttributes(4));
670     handleGlobalObject->SetProperties(thread, handleProperties.GetTaggedValue()); // Set Properties
671     int keyEntry = handleProperties->FindEntry(handleKey.GetTaggedValue());
672 
673     ObjectOperator objectOperator(thread, handleGlobalObject, handleKey);
674     objectOperator.SetIndex(keyEntry);
675     EXPECT_TRUE(objectOperator.UpdateDataValue(handleGlobalObject, handleValue, false));
676     auto *resultDict = GlobalDictionary::Cast(handleGlobalObject->GetProperties().GetTaggedObject());
677     PropertyBox *resultCell = resultDict->GetBox(objectOperator.GetIndex());
678     EXPECT_EQ(resultCell->GetValue().GetInt(), 100);
679 }
680 
HWTEST_F_L0(ObjectOperatorTest,UpdateDataValue_003)681 HWTEST_F_L0(ObjectOperatorTest, UpdateDataValue_003)
682 {
683     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
684     JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
685     JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(4));
686     JSHandle<JSTaggedValue> handleValue1(thread, JSTaggedValue(3));
687     JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
688     JSHandle<EcmaString> handleKey1 = factory->NewFromASCII("value");
689     JSHandle<JSTaggedValue> handleKey2(factory->NewFromASCII("value1"));
690 
691     ObjectOperator objectOperator(thread, handleKey);
692     objectOperator.SetIndex(1);
693     PropertyDescriptor handleDesc(thread);
694     PropertyAttributes handleAttr(handleDesc);
695     handleAttr.SetIsInlinedProps(true);
696     objectOperator.SetAttr(PropertyAttributes(handleDesc));
697 
698     // object is not DictionaryMode
699     JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
700     for (int i = 0; i < 10; i++) {
701         JSHandle<JSTaggedValue> newValue(thread, JSTaggedValue(i));
702         JSHandle<EcmaString> newString =
703             factory->ConcatFromString(handleKey1, JSTaggedValue::ToString(thread, newValue));
704         JSHandle<JSTaggedValue> newKey(thread, newString.GetTaggedValue());
705         JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newValue);
706     }
707     EXPECT_TRUE(objectOperator.UpdateDataValue(handleObject, handleValue1, false));
708     TaggedArray *resultElements1 = TaggedArray::Cast(handleObject->GetProperties().GetTaggedObject());
709     EXPECT_EQ(resultElements1->Get(objectOperator.GetIndex()).GetInt(), 3);
710 
711     // object is DictionaryMode
712     JSObject::DeleteProperty(thread, handleObject, handleKey2);
713     EXPECT_TRUE(objectOperator.UpdateDataValue(handleObject, handleValue, false));
714     TaggedArray *resultElements2 = TaggedArray::Cast(handleObject->GetProperties().GetTaggedObject());
715     auto *resultDict = NumberDictionary::Cast(resultElements2);
716     EXPECT_EQ(resultDict->GetValue(objectOperator.GetIndex()).GetInt(), 4);
717 }
718 
HWTEST_F_L0(ObjectOperatorTest,WriteDataProperty_001)719 HWTEST_F_L0(ObjectOperatorTest, WriteDataProperty_001)
720 {
721     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
722     JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
723     JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(2));
724     JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(4));
725     uint32_t index = 1;
726     PropertyDescriptor handleDesc(thread);
727     ObjectOperator objectOperator(thread, handleKey);
728     PropertyAttributes handleAttr(4);
729     handleDesc.SetConfigurable(true); // Desc Set Configurable
730     objectOperator.SetAttr(PropertyAttributes(3));
731     objectOperator.SetIndex(index);
732     // object class is not DictionaryElement and object is Element
733     JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
734     for (int i = 0; i< 3; i++) {
735         JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
736         JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newKey);
737     }
738     EXPECT_TRUE(objectOperator.WriteDataProperty(handleObject, handleDesc));
739     auto resultDict = NumberDictionary::Cast(handleObject->GetElements().GetTaggedObject());
740     int resultEntry = resultDict->FindEntry(JSTaggedValue(index));
741     int resultAttrValue = resultDict->GetAttributes(resultEntry).GetPropertyMetaData();
742 
743     EXPECT_EQ(objectOperator.GetAttr().GetPropertyMetaData(), resultAttrValue);
744     EXPECT_EQ(objectOperator.GetAttr().GetDictionaryOrder(), 1U);
745     EXPECT_TRUE(objectOperator.GetAttr().IsConfigurable());
746     EXPECT_EQ(objectOperator.GetIndex(), static_cast<uint32_t>(resultEntry));
747     EXPECT_FALSE(objectOperator.IsFastMode());
748     EXPECT_TRUE(objectOperator.IsTransition());
749 }
750 
HWTEST_F_L0(ObjectOperatorTest,WriteDataProperty_002)751 HWTEST_F_L0(ObjectOperatorTest, WriteDataProperty_002)
752 {
753     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
754     JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
755     JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
756     JSHandle<JSTaggedValue> handleValue1(thread, JSTaggedValue(1));
757     JSHandle<JSTaggedValue> handleValue2(thread, JSTaggedValue(2));
758     JSHandle<PropertyBox> cellHandle1 = factory->NewPropertyBox(handleValue1);
759     JSHandle<PropertyBox> cellHandle2 = factory->NewPropertyBox(handleValue2);
760     PropertyDescriptor handleDesc(thread);
761     handleDesc.SetConfigurable(true);
762     PropertyAttributes handleAttr(2);
763     handleAttr.SetConfigurable(true);
764     // object is JSGlobalObject and not Element
765     JSHandle<JSTaggedValue> globalObj = env->GetJSGlobalObject();
766     JSHandle<JSObject> handleGlobalObject(globalObj);
767     ObjectOperator objectOperator(thread, handleGlobalObject, handleKey);
768 
769     JSMutableHandle<GlobalDictionary> globalDict(thread, handleGlobalObject->GetProperties());
770     JSHandle<GlobalDictionary> handleDict = GlobalDictionary::Create(thread, 4);
771     globalDict.Update(handleDict.GetTaggedValue());
772     JSHandle<GlobalDictionary> handleProperties = GlobalDictionary::PutIfAbsent(
773         thread, globalDict, handleKey, JSHandle<JSTaggedValue>(cellHandle1), PropertyAttributes(4));
774     handleProperties->SetAttributes(thread, handleAttr.GetDictionaryOrder(), handleAttr);
775     handleProperties->SetValue(thread, handleAttr.GetDictionaryOrder(), cellHandle2.GetTaggedValue());
776     handleGlobalObject->SetProperties(thread, handleProperties.GetTaggedValue());
777     objectOperator.SetIndex(handleProperties->FindEntry(handleKey.GetTaggedValue()));
778 
779     EXPECT_TRUE(objectOperator.WriteDataProperty(handleGlobalObject, handleDesc));
780     auto resultDict = GlobalDictionary::Cast(handleGlobalObject->GetProperties().GetTaggedObject());
781     EXPECT_EQ(resultDict->GetAttributes(objectOperator.GetIndex()).GetPropertyMetaData(), 4);
782     EXPECT_TRUE(resultDict->GetAttributes(objectOperator.GetIndex()).IsConfigurable());
783 
784     int resultEntry = resultDict->GetAttributes(objectOperator.GetIndex()).GetDictionaryOrder();
785     EXPECT_EQ(resultDict->GetAttributes(resultEntry).GetBoxType(), PropertyBoxType::MUTABLE);
786     EXPECT_EQ(resultDict->GetValue(resultEntry).GetInt(), 1);
787 }
788 
HWTEST_F_L0(ObjectOperatorTest,WriteDataProperty_003)789 HWTEST_F_L0(ObjectOperatorTest, WriteDataProperty_003)
790 {
791     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
792     JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
793     JSHandle<JSTaggedValue> handleKey(factory->NewFromASCII("key"));
794     JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(2));
795     PropertyDescriptor handleDesc(thread, handleValue);
796     handleDesc.SetSetter(handleValue); // Desc is AccessorDescriptor
797     handleDesc.SetGetter(handleValue);
798     // object is not DictionaryMode and not Element
799     JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
800     for (int i = 0; i< 3; i++) {
801         JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
802         JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newKey);
803     }
804     JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), handleKey, handleValue);
805     ObjectOperator objectOperator1(thread, handleKey);
806     objectOperator1.SetAttr(PropertyAttributes(1));
807 
808     EXPECT_TRUE(objectOperator1.WriteDataProperty(handleObject, handleDesc));
809     auto resultDict = NameDictionary::Cast(handleObject->GetProperties().GetTaggedObject());
810     int resultEntry = resultDict->FindEntry(handleKey.GetTaggedValue());
811     EXPECT_TRUE(resultDict->GetValue(resultEntry).IsAccessorData());
812     EXPECT_EQ(resultDict->GetAttributes(resultEntry).GetValue(), objectOperator1.GetAttr().GetValue());
813     // object is DictionaryMode and not Element
814     JSObject::DeleteProperty(thread, (handleObject), handleKey);
815     JSHandle<JSTaggedValue> handleSetter(factory->NewJSNativePointer(reinterpret_cast<void *>(TestDefinedSetter)));
816     JSHandle<AccessorData> handleAccessorData = factory->NewAccessorData();
817     handleDesc.SetSetter(handleSetter);
818     ObjectOperator objectOperator2(thread, handleKey);
819     objectOperator2.SetAttr(PropertyAttributes(handleDesc));
820     objectOperator2.SetValue(handleAccessorData.GetTaggedValue());
821     EXPECT_TRUE(objectOperator2.WriteDataProperty(handleObject, handleDesc));
822     JSHandle<AccessorData> resultAccessorData(thread, objectOperator2.GetValue());
823     EXPECT_EQ(resultAccessorData->GetGetter().GetInt(), 2);
824     EXPECT_TRUE(resultAccessorData->GetSetter().IsJSNativePointer());
825 }
826 
HWTEST_F_L0(ObjectOperatorTest,Property_Add_001)827 HWTEST_F_L0(ObjectOperatorTest, Property_Add_001)
828 {
829     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
830     JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
831     JSHandle<JSTaggedValue> handleKey(thread, JSTaggedValue(2));
832     JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(3));
833     int32_t elementIndex = 2;
834     PropertyAttributes handleAttr(elementIndex);
835     // object is JSArray and Element
836     JSHandle<JSArray> handleArr = factory->NewJSArray();
837     handleArr->SetArrayLength(thread, (elementIndex - 1));
838     JSHandle<JSTaggedValue> handleArrObj(thread, handleArr.GetTaggedValue());
839     ObjectOperator objectOperator1(thread, handleArrObj, elementIndex);
840     EXPECT_TRUE(objectOperator1.AddProperty(JSHandle<JSObject>(handleArrObj), handleValue, handleAttr));
841     EXPECT_EQ(handleArr->GetArrayLength(), 3U); // (elementIndex - 1) + 2
842     // object is DictionaryElement and Element
843     JSHandle<JSObject> handleObject = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
844     for (int i = 0; i< 3; i++) {
845         JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
846         JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject), newKey, newKey);
847     }
848     JSObject::DeleteProperty(thread, (handleObject), handleKey); // Delete key2
849     ObjectOperator objectOperator2(thread, JSHandle<JSTaggedValue>(handleObject), elementIndex);
850     EXPECT_TRUE(objectOperator2.AddProperty(handleObject, handleValue, handleAttr));
851     auto resultDict = NumberDictionary::Cast(handleObject->GetElements().GetTaggedObject());
852     int resultEntry = resultDict->FindEntry(JSTaggedValue(static_cast<uint32_t>(elementIndex)));
853     EXPECT_EQ(resultDict->GetKey(resultEntry).GetInt(), elementIndex);
854     EXPECT_EQ(resultDict->GetValue(resultEntry).GetInt(), 3);
855 }
856 
HWTEST_F_L0(ObjectOperatorTest,Property_Add_002)857 HWTEST_F_L0(ObjectOperatorTest, Property_Add_002)
858 {
859     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
860     JSHandle<JSTaggedValue> objFunc(thread, JSObjectTestCreate(thread));
861     JSHandle<JSTaggedValue> handleString(factory->NewFromASCII("key"));
862     JSHandle<JSTaggedValue> handleValue(thread, JSTaggedValue(3));
863     int32_t elementIndex = 4;
864     PropertyAttributes handleDefaultAttr(elementIndex);
865     PropertyAttributes handleAttr(elementIndex);
866     handleDefaultAttr.SetDefaultAttributes();
867     // object is not DictionaryMode and DefaultAttr
868     JSHandle<JSObject> handleObject1 = factory->NewJSObjectByConstructor(JSHandle<JSFunction>(objFunc), objFunc);
869     for (int i = 0; i< 3; i++) {
870         JSHandle<JSTaggedValue> newKey(thread, JSTaggedValue(i));
871         JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(handleObject1), newKey, newKey);
872     }
873     ObjectOperator objectOperator(thread, JSHandle<JSTaggedValue>(handleObject1), elementIndex);
874     EXPECT_TRUE(objectOperator.AddProperty(handleObject1, handleValue, handleDefaultAttr));
875     TaggedArray *resultArray = TaggedArray::Cast(handleObject1->GetElements().GetTaggedObject());
876     EXPECT_EQ(resultArray->Get(elementIndex).GetInt(), 3);
877     EXPECT_EQ(resultArray->GetLength(), 7U);
878     EXPECT_EQ(handleObject1->GetJSHClass()->GetElementRepresentation(), Representation::INT);
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