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