1 /*
2 * Copyright (c) 2021 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/builtins/builtins_reflect.h"
17
18 #include "ecmascript/ecma_runtime_call_info.h"
19 #include "ecmascript/ecma_string.h"
20 #include "ecmascript/ecma_vm.h"
21 #include "ecmascript/global_env.h"
22 #include "ecmascript/js_array.h"
23 #include "ecmascript/js_function.h"
24 #include "ecmascript/js_object-inl.h"
25 #include "ecmascript/js_primitive_ref.h"
26 #include "ecmascript/tagged_array-inl.h"
27 #include "ecmascript/object_factory.h"
28 #include "ecmascript/tests/test_helper.h"
29
30 using namespace panda::ecmascript;
31 using namespace panda::ecmascript::builtins;
32 using BuiltinsBase = panda::ecmascript::base::BuiltinsBase;
33 using JSArray = panda::ecmascript::JSArray;
34
35 namespace panda::test {
36 class BuiltinsReflectTest : public testing::Test {
37 public:
SetUpTestCase()38 static void SetUpTestCase()
39 {
40 GTEST_LOG_(INFO) << "SetUpTestCase";
41 }
42
TearDownTestCase()43 static void TearDownTestCase()
44 {
45 GTEST_LOG_(INFO) << "TearDownCase";
46 }
47
SetUp()48 void SetUp() override
49 {
50 TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
51 }
52
TearDown()53 void TearDown() override
54 {
55 TestHelper::DestroyEcmaVMWithScope(instance, scope);
56 }
57
58 EcmaVM *instance {nullptr};
59 EcmaHandleScope *scope {nullptr};
60 JSThread *thread {nullptr};
61 };
62
63 // use for create a JSObject of test
TestObjectCreate(JSThread * thread)64 static JSHandle<JSFunction> TestObjectCreate(JSThread *thread)
65 {
66 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
67 return JSHandle<JSFunction>::Cast(env->GetObjectFunction());
68 }
69
70 // native function for test Reflect.apply
TestReflectApply(EcmaRuntimeCallInfo * argv)71 JSTaggedValue TestReflectApply(EcmaRuntimeCallInfo *argv)
72 {
73 auto thread = argv->GetThread();
74 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
75
76 int result = 0;
77 for (uint32_t index = 0; index < argv->GetArgsNumber(); ++index) {
78 result += BuiltinsBase::GetCallArg(argv, index).GetTaggedValue().GetInt();
79 }
80 JSHandle<JSTaggedValue> thisValue = BuiltinsBase::GetThis(argv);
81
82 JSTaggedValue testA = JSObject::GetProperty(thread, thisValue,
83 JSHandle<JSTaggedValue>(factory->NewFromASCII("test_reflect_apply_a"))).GetValue().GetTaggedValue();
84 JSTaggedValue testB = JSObject::GetProperty(thread, thisValue,
85 JSHandle<JSTaggedValue>(factory->NewFromASCII("test_reflect_apply_b"))).GetValue().GetTaggedValue();
86
87 result = result + testA.GetInt() + testB.GetInt();
88 return BuiltinsBase::GetTaggedInt(result);
89 }
90
91 // Reflect.apply (target, thisArgument, argumentsList)
HWTEST_F_L0(BuiltinsReflectTest,ReflectApply)92 HWTEST_F_L0(BuiltinsReflectTest, ReflectApply)
93 {
94 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
95
96 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
97
98 // target
99 JSHandle<JSFunction> target = factory->NewJSFunction(env, reinterpret_cast<void *>(TestReflectApply));
100 // thisArgument
101 JSHandle<JSObject> thisArgument =
102 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
103 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(thisArgument),
104 JSHandle<JSTaggedValue>(factory->NewFromASCII("test_reflect_apply_a")),
105 JSHandle<JSTaggedValue>(thread, JSTaggedValue(11)));
106 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(thisArgument),
107 JSHandle<JSTaggedValue>(factory->NewFromASCII("test_reflect_apply_b")),
108 JSHandle<JSTaggedValue>(thread, JSTaggedValue(22)));
109 // argumentsList
110 JSHandle<JSObject> argumentsList(JSArray::ArrayCreate(thread, JSTaggedNumber(2)));
111 PropertyDescriptor desc(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(33)));
112 JSArray::DefineOwnProperty(thread, argumentsList, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0)), desc);
113
114 PropertyDescriptor desc1(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(44)));
115 JSArray::DefineOwnProperty(thread, argumentsList, JSHandle<JSTaggedValue>(thread, JSTaggedValue(1)), desc1);
116
117 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
118 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
119 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
120 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
121 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(*thisArgument));
122 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(*argumentsList));
123
124 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
125 JSTaggedValue result = BuiltinsReflect::ReflectApply(ecmaRuntimeCallInfo);
126 ASSERT_EQ(result.GetRawData(), JSTaggedValue(110).GetRawData());
127
128 JSObject::DeleteProperty(thread, (thisArgument),
129 JSHandle<JSTaggedValue>(factory->NewFromASCII("test_reflect_apply_a")));
130 JSObject::DeleteProperty(thread, (thisArgument),
131 JSHandle<JSTaggedValue>(factory->NewFromASCII("test_reflect_apply_b")));
132 TestHelper::TearDownFrame(thread, prev);
133 }
134
135 // Reflect.construct (target, argumentsList [ , newTarget])
HWTEST_F_L0(BuiltinsReflectTest,ReflectConstruct)136 HWTEST_F_L0(BuiltinsReflectTest, ReflectConstruct)
137 {
138 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
139
140 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
141
142 // target
143 JSHandle<JSFunction> target = JSHandle<JSFunction>::Cast(env->GetStringFunction());
144 // argumentsList
145 JSHandle<JSObject> argumentsList(JSArray::ArrayCreate(thread, JSTaggedNumber(1)));
146 PropertyDescriptor desc(thread,
147 JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("ReflectConstruct")));
148 JSArray::DefineOwnProperty(thread, argumentsList, JSHandle<JSTaggedValue>(thread, JSTaggedValue(0)), desc);
149
150 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
151 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
152 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
153 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
154 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(*argumentsList));
155
156 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
157 JSTaggedValue result = BuiltinsReflect::ReflectConstruct(ecmaRuntimeCallInfo);
158
159 ASSERT_TRUE(result.IsECMAObject());
160 JSHandle<JSTaggedValue> taggedResult(thread, result);
161 JSHandle<JSPrimitiveRef> refResult = JSHandle<JSPrimitiveRef>::Cast(taggedResult);
162 JSHandle<EcmaString> ruler = factory->NewFromASCII("ReflectConstruct");
163 ASSERT_EQ(EcmaStringAccessor::Compare(EcmaString::Cast(refResult->GetValue().GetTaggedObject()), *ruler), 0);
164 TestHelper::TearDownFrame(thread, prev);
165 }
166
167 // Reflect.defineProperty (target, propertyKey, attributes)
HWTEST_F_L0(BuiltinsReflectTest,ReflectDefineProperty)168 HWTEST_F_L0(BuiltinsReflectTest, ReflectDefineProperty)
169 {
170 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
171
172 // target
173 JSHandle<JSObject> target =
174 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
175 // propertyKey
176 JSHandle<JSTaggedValue> key(factory->NewFromASCII("test_reflect_define_property"));
177 // attributes
178 JSHandle<JSObject> attributes =
179 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
180 // attributes value
181 auto globalConst = thread->GlobalConstants();
182 JSHandle<JSTaggedValue> valueKey = globalConst->GetHandledValueString();
183 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(100));
184 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(attributes), valueKey, value);
185 // attributes writable
186 JSHandle<JSTaggedValue> writableKey = globalConst->GetHandledWritableString();
187 JSHandle<JSTaggedValue> writable(thread, JSTaggedValue::True());
188 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(attributes), writableKey, writable);
189 // attributes enumerable
190 JSHandle<JSTaggedValue> enumerableKey = globalConst->GetHandledEnumerableString();
191 JSHandle<JSTaggedValue> enumerable(thread, JSTaggedValue::False());
192 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(attributes), enumerableKey, enumerable);
193 // attributes configurable
194 JSHandle<JSTaggedValue> configurableKey = globalConst->GetHandledConfigurableString();
195 JSHandle<JSTaggedValue> configurable(thread, JSTaggedValue::True());
196 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(attributes), configurableKey, configurable);
197
198 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
199 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
200 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
201 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
202 ecmaRuntimeCallInfo->SetCallArg(1, key.GetTaggedValue());
203 ecmaRuntimeCallInfo->SetCallArg(2, JSTaggedValue(*attributes));
204
205 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
206 JSTaggedValue result = BuiltinsReflect::ReflectDefineProperty(ecmaRuntimeCallInfo);
207 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
208
209 PropertyDescriptor descRuler(thread);
210 JSObject::GetOwnProperty(thread, target, key, descRuler);
211 ASSERT_EQ(descRuler.GetValue()->GetInt(), 100);
212 ASSERT_EQ(descRuler.IsWritable(), true);
213 ASSERT_EQ(descRuler.IsEnumerable(), false);
214 ASSERT_EQ(descRuler.IsConfigurable(), true);
215 TestHelper::TearDownFrame(thread, prev);
216 }
217
218 // Reflect.deleteProperty (target, propertyKey)
HWTEST_F_L0(BuiltinsReflectTest,ReflectDeleteProperty)219 HWTEST_F_L0(BuiltinsReflectTest, ReflectDeleteProperty)
220 {
221 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
222
223 // target
224 JSHandle<JSObject> target =
225 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
226 // propertyKey
227 JSHandle<JSTaggedValue> key(factory->NewFromASCII("test_reflect_delete_property"));
228 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(101));
229 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(target), key, value);
230
231 PropertyDescriptor desc(thread);
232 ASSERT_EQ(JSObject::GetOwnProperty(thread, target, key, desc), true);
233
234 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
235 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
236 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
237 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
238 ecmaRuntimeCallInfo->SetCallArg(1, key.GetTaggedValue());
239
240 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
241 JSTaggedValue result = BuiltinsReflect::ReflectDeleteProperty(ecmaRuntimeCallInfo);
242 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
243 ASSERT_EQ(JSObject::GetOwnProperty(thread, target, key, desc), false);
244 TestHelper::TearDownFrame(thread, prev);
245 }
246
247 // Reflect.get (target, propertyKey [ , receiver])
HWTEST_F_L0(BuiltinsReflectTest,ReflectGet)248 HWTEST_F_L0(BuiltinsReflectTest, ReflectGet)
249 {
250 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
251
252 // target
253 JSHandle<JSObject> target =
254 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
255 // propertyKey
256 JSHandle<JSTaggedValue> key(factory->NewFromASCII("test_reflect_get"));
257 // set property
258 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(101.5));
259 JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(target), key, value);
260
261 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
262 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
263 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
264 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
265 ecmaRuntimeCallInfo->SetCallArg(1, key.GetTaggedValue());
266
267 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
268 JSTaggedValue result = BuiltinsReflect::ReflectGet(ecmaRuntimeCallInfo);
269
270 JSHandle<JSTaggedValue> resultValue(thread, result);
271 ASSERT_EQ(resultValue->GetDouble(), 101.5);
272 TestHelper::TearDownFrame(thread, prev);
273 }
274
275 // Reflect.getOwnPropertyDescriptor ( target, propertyKey )
HWTEST_F_L0(BuiltinsReflectTest,ReflectGetOwnPropertyDescriptor)276 HWTEST_F_L0(BuiltinsReflectTest, ReflectGetOwnPropertyDescriptor)
277 {
278 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
279
280 // target
281 JSHandle<JSObject> target =
282 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
283 // propertyKey
284 JSHandle<JSTaggedValue> key(factory->NewFromASCII("test_reflect_get_property_descriptor"));
285 PropertyDescriptor desc(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue(102)), true, false, true);
286 ASSERT_EQ(JSTaggedValue::DefinePropertyOrThrow(thread, JSHandle<JSTaggedValue>(target), key, desc), true);
287
288 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
289 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
290 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
291 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
292 ecmaRuntimeCallInfo->SetCallArg(1, key.GetTaggedValue());
293
294 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
295 JSTaggedValue result = BuiltinsReflect::ReflectGetOwnPropertyDescriptor(ecmaRuntimeCallInfo);
296
297 ASSERT_TRUE(result.IsECMAObject());
298
299 JSHandle<JSTaggedValue> resultObj(thread, result);
300 // test value
301 auto globalConst = thread->GlobalConstants();
302 JSHandle<JSTaggedValue> valueKey = globalConst->GetHandledValueString();
303 JSHandle<JSTaggedValue> resultValue = JSObject::GetProperty(thread, resultObj, valueKey).GetValue();
304 ASSERT_EQ(resultValue->GetInt(), 102);
305 // test writable
306 JSHandle<JSTaggedValue> writableKey = globalConst->GetHandledWritableString();
307 JSHandle<JSTaggedValue> resultWritable = JSObject::GetProperty(thread, resultObj, writableKey).GetValue();
308 ASSERT_EQ(resultWritable->ToBoolean(), true);
309 // test enumerable
310 JSHandle<JSTaggedValue> enumerableKey = globalConst->GetHandledEnumerableString();
311 JSHandle<JSTaggedValue> resultEnumerable = JSObject::GetProperty(thread, resultObj, enumerableKey).GetValue();
312 ASSERT_EQ(resultEnumerable->ToBoolean(), false);
313 // test configurable
314 JSHandle<JSTaggedValue> configurableKey = globalConst->GetHandledConfigurableString();
315 JSHandle<JSTaggedValue> resultConfigurable = JSObject::GetProperty(thread, resultObj, configurableKey).GetValue();
316 ASSERT_EQ(resultConfigurable->ToBoolean(), true);
317 TestHelper::TearDownFrame(thread, prev);
318 }
319
320 // Reflect.getPrototypeOf (target)
HWTEST_F_L0(BuiltinsReflectTest,ReflectGetPrototypeOf)321 HWTEST_F_L0(BuiltinsReflectTest, ReflectGetPrototypeOf)
322 {
323 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
324
325 JSHandle<JSObject> target =
326 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
327 JSHandle<JSObject> proto =
328 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
329
330 ASSERT_EQ(JSObject::SetPrototype(thread, target, JSHandle<JSTaggedValue>(proto)), true);
331
332 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
333 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
334 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
335 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
336
337 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
338 JSTaggedValue result = BuiltinsReflect::ReflectGetPrototypeOf(ecmaRuntimeCallInfo);
339 ASSERT_TRUE(result.IsECMAObject());
340 JSHandle<JSTaggedValue> resultObj(thread, JSTaggedValue(reinterpret_cast<TaggedObject *>(result.GetRawData())));
341 ASSERT_EQ(JSTaggedValue::SameValue(resultObj.GetTaggedValue(), proto.GetTaggedValue()), true);
342 TestHelper::TearDownFrame(thread, prev);
343 }
344
345 // Reflect.has (target, propertyKey)
HWTEST_F_L0(BuiltinsReflectTest,ReflectHas)346 HWTEST_F_L0(BuiltinsReflectTest, ReflectHas)
347 {
348 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
349
350 // target
351 JSHandle<JSObject> target =
352 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
353 // propertyKey
354 JSHandle<JSTaggedValue> key(factory->NewFromASCII("test_reflect_has"));
355 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(103));
356 ASSERT_EQ(JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(target), key, value), true);
357
358 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
359 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
360 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
361 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
362 ecmaRuntimeCallInfo->SetCallArg(1, key.GetTaggedValue());
363
364 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
365 JSTaggedValue result = BuiltinsReflect::ReflectHas(ecmaRuntimeCallInfo);
366
367 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
368 TestHelper::TearDownFrame(thread, prev);
369 }
370
371 // Reflect.isExtensible (target)
HWTEST_F_L0(BuiltinsReflectTest,ReflectIsExtensible)372 HWTEST_F_L0(BuiltinsReflectTest, ReflectIsExtensible)
373 {
374 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
375
376 // target
377 JSHandle<JSObject> target =
378 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
379 target->GetJSHClass()->SetExtensible(false);
380
381 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
382 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
383 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
384 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
385
386 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
387 JSTaggedValue result = BuiltinsReflect::ReflectIsExtensible(ecmaRuntimeCallInfo);
388
389 ASSERT_EQ(result.GetRawData(), JSTaggedValue::False().GetRawData());
390 TestHelper::TearDownFrame(thread, prev);
391 }
392
393 // Reflect.ownKeys (target)
HWTEST_F_L0(BuiltinsReflectTest,ReflectOwnKeys)394 HWTEST_F_L0(BuiltinsReflectTest, ReflectOwnKeys)
395 {
396 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
397
398 // target
399 JSHandle<JSObject> target =
400 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
401 JSHandle<JSTaggedValue> key0(factory->NewFromASCII("test_reflect_own_keys1"));
402 JSHandle<JSTaggedValue> value0(thread, JSTaggedValue(104));
403 ASSERT_EQ(JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(target), key0, value0), true);
404 JSHandle<JSTaggedValue> key1(factory->NewFromASCII("test_reflect_own_keys2"));
405 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(105));
406 ASSERT_EQ(JSObject::SetProperty(thread, JSHandle<JSTaggedValue>(target), key1, value1), true);
407
408 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
409 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
410 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
411 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
412
413 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
414 JSTaggedValue result = BuiltinsReflect::ReflectOwnKeys(ecmaRuntimeCallInfo);
415
416 ASSERT_TRUE(result.IsECMAObject());
417 JSHandle<JSTaggedValue> resultTaggedValue(thread, reinterpret_cast<TaggedObject *>(result.GetRawData()));
418 JSHandle<JSArray> resultArray = JSHandle<JSArray>::Cast(resultTaggedValue);
419 // test length
420 JSHandle<JSTaggedValue> resultLengthKey = thread->GlobalConstants()->GetHandledLengthString();
421 JSHandle<JSTaggedValue> resultLength =
422 JSObject::GetProperty(thread, JSHandle<JSTaggedValue>(resultArray), resultLengthKey).GetValue();
423 ASSERT_EQ(resultLength->GetInt(), 2);
424 // test array[0]
425 JSHandle<JSTaggedValue> resultKey0(thread, JSTaggedValue(0));
426 JSHandle<JSTaggedValue> resultValue0 =
427 JSObject::GetProperty(thread, JSHandle<JSTaggedValue>(resultArray), resultKey0).GetValue();
428 ASSERT_EQ(EcmaStringAccessor::Compare(
429 reinterpret_cast<EcmaString *>(resultValue0.GetTaggedValue().GetTaggedObject()),
430 reinterpret_cast<EcmaString *>(key0.GetTaggedValue().GetTaggedObject())),
431 0);
432 // test array[1]
433 JSHandle<JSTaggedValue> resultKey1(thread, JSTaggedValue(1));
434 JSHandle<JSTaggedValue> resultValue1 =
435 JSObject::GetProperty(thread, JSHandle<JSTaggedValue>(resultArray), resultKey1).GetValue();
436 ASSERT_EQ(EcmaStringAccessor::Compare(
437 reinterpret_cast<EcmaString *>(resultValue1.GetTaggedValue().GetTaggedObject()),
438 reinterpret_cast<EcmaString *>(key1.GetTaggedValue().GetTaggedObject())),
439 0);
440 TestHelper::TearDownFrame(thread, prev);
441 }
442
443 // Reflect.preventExtensions (target)
HWTEST_F_L0(BuiltinsReflectTest,ReflectPreventExtensions)444 HWTEST_F_L0(BuiltinsReflectTest, ReflectPreventExtensions)
445 {
446 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
447
448 // target
449 JSHandle<JSObject> target =
450 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
451 target->GetJSHClass()->SetExtensible(true);
452
453 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
454 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
455 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
456 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
457
458 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
459 JSTaggedValue result = BuiltinsReflect::ReflectPreventExtensions(ecmaRuntimeCallInfo);
460
461 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
462 ASSERT_EQ(target->IsExtensible(), false);
463 TestHelper::TearDownFrame(thread, prev);
464 }
465
466 // Reflect.set (target, propertyKey, V [ , receiver])
HWTEST_F_L0(BuiltinsReflectTest,ReflectSet)467 HWTEST_F_L0(BuiltinsReflectTest, ReflectSet)
468 {
469 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
470
471 // target
472 JSHandle<JSObject> target =
473 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
474 // propertyKey
475 JSHandle<JSTaggedValue> key(factory->NewFromASCII("test_reflect_set"));
476 // value
477 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(106));
478
479 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 10);
480 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
481 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
482 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
483 ecmaRuntimeCallInfo->SetCallArg(1, key.GetTaggedValue());
484 ecmaRuntimeCallInfo->SetCallArg(2, value.GetTaggedValue());
485
486 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
487 JSTaggedValue result = BuiltinsReflect::ReflectSet(ecmaRuntimeCallInfo);
488
489 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
490
491 JSHandle<JSTaggedValue> ruler = JSObject::GetProperty(thread, JSHandle<JSTaggedValue>(target), key).GetValue();
492 ASSERT_EQ(JSTaggedValue::ToInt32(thread, ruler), 106);
493 TestHelper::TearDownFrame(thread, prev);
494 }
495
496 // Reflect.setPrototypeOf (target, proto)
HWTEST_F_L0(BuiltinsReflectTest,ReflectSetPrototypeOf)497 HWTEST_F_L0(BuiltinsReflectTest, ReflectSetPrototypeOf)
498 {
499 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
500
501 JSHandle<JSObject> target =
502 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
503 JSHandle<JSObject> proto =
504 factory->NewJSObjectByConstructor(TestObjectCreate(thread), JSHandle<JSTaggedValue>(TestObjectCreate(thread)));
505
506 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
507 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
508 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
509 ecmaRuntimeCallInfo->SetCallArg(0, target.GetTaggedValue());
510 ecmaRuntimeCallInfo->SetCallArg(1, proto.GetTaggedValue());
511
512 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
513 JSTaggedValue result = BuiltinsReflect::ReflectSetPrototypeOf(ecmaRuntimeCallInfo);
514
515 ASSERT_EQ(result.GetRawData(), JSTaggedValue::True().GetRawData());
516 JSHandle<JSTaggedValue> resultObj(thread, target->GetJSHClass()->GetPrototype());
517 ASSERT_EQ(JSTaggedValue::SameValue(resultObj.GetTaggedValue(), proto.GetTaggedValue()), true);
518 TestHelper::TearDownFrame(thread, prev);
519 }
520 } // namespace panda::test
521