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