1/*
2 * Copyright (c) 2024 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 "builtin_test_util.h"
17#include "ecmascript/builtins/builtins_sendable_arraybuffer.h"
18
19#include "ecmascript/ecma_runtime_call_info.h"
20#include "ecmascript/ecma_vm.h"
21#include "ecmascript/global_env.h"
22
23#include "ecmascript/shared_objects/js_sendable_arraybuffer.h"
24
25using namespace panda::ecmascript;
26using namespace panda::ecmascript::builtins;
27
28namespace panda::test {
29class BuiltinsSendableArrayBufferTest : public BaseTestWithScope<false> {
30};
31
32
33void SendableArrayBufferSliceTest(JSThread *thread, JSTaggedValue start, JSTaggedValue end, JSTaggedValue res)
34{
35    JSTaggedValue tagged = BuiltTestUtil::CreateBuiltinsSendableArrayBuffer(thread, 10);
36    JSHandle<JSSendableArrayBuffer> arrBuf(
37        thread, JSSendableArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
38    auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
39    ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
40    ecmaRuntimeCallInfo->SetThis(arrBuf.GetTaggedValue());
41    ecmaRuntimeCallInfo->SetCallArg(0, start);
42    ecmaRuntimeCallInfo->SetCallArg(1, end);
43
44    [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
45    JSTaggedValue result1 = BuiltinsSendableArrayBuffer::Slice(ecmaRuntimeCallInfo);
46    TestHelper::TearDownFrame(thread, prev);
47    JSHandle<JSSendableArrayBuffer> arrBuf1(
48        thread, JSSendableArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(result1.GetRawData())));
49    auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
50    ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
51    ecmaRuntimeCallInfo1->SetThis(arrBuf1.GetTaggedValue());
52    prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
53    JSTaggedValue result2 = BuiltinsSendableArrayBuffer::GetByteLength(ecmaRuntimeCallInfo1);
54
55    ASSERT_EQ(result2.GetRawData(), res.GetRawData());
56    TestHelper::TearDownFrame(thread, prev);
57}
58
59// new SendableArrayBuffer(8)
60HWTEST_F_L0(BuiltinsSendableArrayBufferTest, Constructor1)
61{
62    JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
63    JSHandle<JSFunction> arrayBuffer(thread, env->GetSBuiltininArrayBufferFunction().GetTaggedValue());
64    JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
65    auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, arrayBuffer.GetTaggedValue(), 6);
66    ecmaRuntimeCallInfo->SetFunction(arrayBuffer.GetTaggedValue());
67    ecmaRuntimeCallInfo->SetThis(globalObject.GetTaggedValue());
68    ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(8)));
69
70    [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
71    JSTaggedValue result = BuiltinsSendableArrayBuffer::ArrayBufferConstructor(ecmaRuntimeCallInfo);
72    ASSERT_TRUE(result.IsECMAObject());
73    TestHelper::TearDownFrame(thread, prev);
74}
75
76// Constructor: Throw TypeError
77HWTEST_F_L0(BuiltinsSendableArrayBufferTest, Constructor2)
78{
79    auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
80    [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
81    JSTaggedValue result = BuiltinsSendableArrayBuffer::ArrayBufferConstructor(ecmaRuntimeCallInfo);
82    ASSERT_EQ(result.GetRawData(), JSTaggedValue::Exception().GetRawData());
83}
84
85// (new SendableArrayBuffer(5)).byteLength
86HWTEST_F_L0(BuiltinsSendableArrayBufferTest, byteLength1)
87{
88    JSTaggedValue tagged = BuiltTestUtil::CreateBuiltinsSendableArrayBuffer(thread, 5);
89    JSHandle<JSSendableArrayBuffer> arrBuf(
90        thread, JSSendableArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
91    auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
92    ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
93    ecmaRuntimeCallInfo->SetThis(arrBuf.GetTaggedValue());
94
95    [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
96    JSTaggedValue result = BuiltinsSendableArrayBuffer::GetByteLength(ecmaRuntimeCallInfo);
97    ASSERT_EQ(result.GetRawData(), JSTaggedValue(5).GetRawData());
98    TestHelper::TearDownFrame(thread, prev);
99}
100
101// Species
102HWTEST_F_L0(BuiltinsSendableArrayBufferTest, species1)
103{
104    JSTaggedValue tagged = BuiltTestUtil::CreateBuiltinsSendableArrayBuffer(thread, 5);
105    JSHandle<JSSendableArrayBuffer> arrBuf(
106        thread, JSSendableArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
107    auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
108    ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
109    ecmaRuntimeCallInfo->SetThis(arrBuf.GetTaggedValue());
110
111    [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
112    JSTaggedValue result = BuiltinsSendableArrayBuffer::Species(ecmaRuntimeCallInfo);
113    ASSERT_EQ(result.GetRawData(), arrBuf.GetTaggedValue().GetRawData());
114    TestHelper::TearDownFrame(thread, prev);
115}
116
117// (new SendableArrayBuffer(10)).slice(1, 5).bytelength
118HWTEST_F_L0(BuiltinsSendableArrayBufferTest, slice1)
119{
120    SendableArrayBufferSliceTest(
121        thread, JSTaggedValue(static_cast<int32_t>(1)), JSTaggedValue(static_cast<int32_t>(5)), JSTaggedValue(4));
122}
123
124// (new SendableArrayBuffer(10)).slice(-1, undefine).bytelength
125HWTEST_F_L0(BuiltinsSendableArrayBufferTest, slice2)
126{
127    SendableArrayBufferSliceTest(
128        thread, JSTaggedValue(static_cast<int32_t>(-1)), JSTaggedValue::Undefined(), JSTaggedValue(1));
129}
130
131// (new SendableArrayBuffer(10)).slice(1, -2).bytelength
132HWTEST_F_L0(BuiltinsSendableArrayBufferTest, slice3)
133{
134    SendableArrayBufferSliceTest(
135        thread, JSTaggedValue(static_cast<int32_t>(1)), JSTaggedValue(static_cast<int32_t>(-2)), JSTaggedValue(7));
136}
137
138// slice :this is not obj
139HWTEST_F_L0(BuiltinsSendableArrayBufferTest, slice4)
140{
141    auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
142    ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
143    ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
144
145    [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
146    JSTaggedValue result = BuiltinsSendableArrayBuffer::Slice(ecmaRuntimeCallInfo);
147    ASSERT_EQ(result.GetRawData(), JSTaggedValue::Exception().GetRawData());
148    TestHelper::TearDownFrame(thread, prev);
149}
150
151// slice :this is not sendable array
152HWTEST_F_L0(BuiltinsSendableArrayBufferTest, slice5)
153{
154    JSTaggedValue tagged = BuiltTestUtil::CreateBuiltinsArrayBuffer(thread, 10);
155    JSHandle<JSArrayBuffer> arrBuf(
156        thread, JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
157
158    auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
159    ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
160    ecmaRuntimeCallInfo->SetThis(arrBuf.GetTaggedValue());
161
162    [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
163    JSTaggedValue result = BuiltinsSendableArrayBuffer::Slice(ecmaRuntimeCallInfo);
164    ASSERT_EQ(result.GetRawData(), JSTaggedValue::Exception().GetRawData());
165    TestHelper::TearDownFrame(thread, prev);
166}
167
168// slice :this is detach sendable array
169HWTEST_F_L0(BuiltinsSendableArrayBufferTest, slice6)
170{
171    JSTaggedValue tagged = BuiltTestUtil::CreateBuiltinsSendableArrayBuffer(thread, 10);
172    JSHandle<JSSendableArrayBuffer> arrBuf(
173        thread, JSSendableArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
174    arrBuf->SetArrayBufferData(thread, JSTaggedValue::Null());
175
176    auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
177    ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
178    ecmaRuntimeCallInfo->SetThis(arrBuf.GetTaggedValue());
179
180    [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
181    JSTaggedValue result = BuiltinsSendableArrayBuffer::Slice(ecmaRuntimeCallInfo);
182    ASSERT_EQ(result.GetRawData(), JSTaggedValue::Exception().GetRawData());
183    TestHelper::TearDownFrame(thread, prev);
184}
185
186// IsView(new SharedTypedArray())
187HWTEST_F_L0(BuiltinsSendableArrayBufferTest, IsView1)
188{
189    ASSERT_NE(thread, nullptr);
190    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
191    [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewSTaggedArray(3));
192    array->Set(thread, 0, JSTaggedValue(2));
193    array->Set(thread, 1, JSTaggedValue(3));
194    array->Set(thread, 2, JSTaggedValue(4));
195
196    [[maybe_unused]] JSHandle<JSTaggedValue> obj =
197        JSHandle<JSTaggedValue>(thread, BuiltTestUtil::CreateSharedTypedArray(thread, array));
198    auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
199    ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
200    ecmaRuntimeCallInfo->SetThis(obj.GetTaggedValue());
201    ecmaRuntimeCallInfo->SetCallArg(0, obj.GetTaggedValue());
202    [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
203    JSTaggedValue result = BuiltinsSendableArrayBuffer::IsView(ecmaRuntimeCallInfo);
204    ASSERT_EQ(result.GetRawData(), JSTaggedValue(true).GetRawData());
205    TestHelper::TearDownFrame(thread, prev);
206}
207
208// IsView: Arg is not EcmaObj
209HWTEST_F_L0(BuiltinsSendableArrayBufferTest, IsView2)
210{
211    ASSERT_NE(thread, nullptr);
212    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
213    [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewSTaggedArray(3));
214    array->Set(thread, 0, JSTaggedValue(2));
215    array->Set(thread, 1, JSTaggedValue(3));
216    array->Set(thread, 2, JSTaggedValue(4));
217
218    [[maybe_unused]] JSHandle<JSTaggedValue> obj =
219        JSHandle<JSTaggedValue>(thread, BuiltTestUtil::CreateSharedTypedArray(thread, array));
220    auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
221    ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
222    ecmaRuntimeCallInfo->SetThis(obj.GetTaggedValue());
223    ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Undefined());
224    [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
225    JSTaggedValue result = BuiltinsSendableArrayBuffer::IsView(ecmaRuntimeCallInfo);
226    ASSERT_EQ(result.GetRawData(), JSTaggedValue(false).GetRawData());
227    TestHelper::TearDownFrame(thread, prev);
228}
229
230// IsView: arg is not dataView or SharedTypedArray
231HWTEST_F_L0(BuiltinsSendableArrayBufferTest, IsView3)
232{
233    ASSERT_NE(thread, nullptr);
234    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
235    [[maybe_unused]] JSHandle<TaggedArray> array(factory->NewSTaggedArray(3));
236    array->Set(thread, 0, JSTaggedValue(2));
237    array->Set(thread, 1, JSTaggedValue(3));
238    array->Set(thread, 2, JSTaggedValue(4));
239
240    [[maybe_unused]] JSHandle<JSTaggedValue> obj =
241        JSHandle<JSTaggedValue>(thread, BuiltTestUtil::CreateSharedTypedArray(thread, array));
242    [[maybe_unused]] JSHandle<JSTaggedValue> obj1 =
243        JSHandle<JSTaggedValue>(thread, BuiltTestUtil::CreateBuiltinsSendableArrayBuffer(thread, 3));
244    auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
245    ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
246    ecmaRuntimeCallInfo->SetThis(obj.GetTaggedValue());
247    ecmaRuntimeCallInfo->SetCallArg(0, obj1.GetTaggedValue());
248    [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
249    JSTaggedValue result = BuiltinsSendableArrayBuffer::IsView(ecmaRuntimeCallInfo);
250    ASSERT_EQ(result.GetRawData(), JSTaggedValue(false).GetRawData());
251    TestHelper::TearDownFrame(thread, prev);
252}
253
254// IsDetachBuffer: is byteArray
255HWTEST_F_L0(BuiltinsSendableArrayBufferTest, IsDetachBuffer1)
256{
257    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
258    JSHandle<ByteArray> byteArray = factory->NewByteArray(5, 8);
259    bool result = BuiltinsSendableArrayBuffer::IsDetachedBuffer(byteArray.GetTaggedValue());
260    ASSERT_EQ(JSTaggedValue(result).GetRawData(), JSTaggedValue(false).GetRawData());
261}
262
263// IsDetachBuffer: dataSlot is null
264HWTEST_F_L0(BuiltinsSendableArrayBufferTest, IsDetachBuffer2)
265{
266    JSTaggedValue tagged = BuiltTestUtil::CreateBuiltinsSendableArrayBuffer(thread, 5);
267    JSHandle<JSSendableArrayBuffer> arrBuf(
268        thread, JSSendableArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
269    arrBuf->SetArrayBufferData(thread, JSTaggedValue::Null());
270    bool result = BuiltinsSendableArrayBuffer::IsDetachedBuffer(tagged);
271    ASSERT_EQ(JSTaggedValue(result).GetRawData(), JSTaggedValue(true).GetRawData());
272}
273
274// IsDetachBuffer: dataSlot is not null
275HWTEST_F_L0(BuiltinsSendableArrayBufferTest, IsDetachBuffer3)
276{
277    JSTaggedValue tagged = BuiltTestUtil::CreateBuiltinsSendableArrayBuffer(thread, 5);
278    JSHandle<JSSendableArrayBuffer> arrBuf(
279        thread, JSSendableArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
280    arrBuf->SetArrayBufferData(thread, JSTaggedValue(1));
281    bool result = BuiltinsSendableArrayBuffer::IsDetachedBuffer(tagged);
282    ASSERT_EQ(JSTaggedValue(result).GetRawData(), JSTaggedValue(false).GetRawData());
283}
284
285// AllocateSendableArrayBuffer: bytelength is greater than INT_MAX
286HWTEST_F_L0(BuiltinsSendableArrayBufferTest, AllocateSendableArrayBuffer1)
287{
288    uint64_t byteLength = static_cast<uint64_t>(INT_MAX) + 1;
289
290    JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
291    JSHandle<JSFunction> arrayBuffer(thread, env->GetSBuiltininArrayBufferFunction().GetTaggedValue());
292    JSTaggedValue result = BuiltinsSendableArrayBuffer::AllocateSendableArrayBuffer(
293        thread, JSHandle<JSTaggedValue>(arrayBuffer), byteLength);
294    ASSERT_EQ(JSTaggedValue(result).GetRawData(), JSTaggedValue::Exception().GetRawData());
295}
296
297// AllocateSendableArrayBuffer
298HWTEST_F_L0(BuiltinsSendableArrayBufferTest, AllocateSendableArrayBuffer2)
299{
300    uint32_t byteLength = 8;
301    JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
302    JSHandle<JSFunction> arrayBuffer(thread, env->GetSBuiltininArrayBufferFunction().GetTaggedValue());
303    JSTaggedValue result = BuiltinsSendableArrayBuffer::AllocateSendableArrayBuffer(
304        thread, JSHandle<JSTaggedValue>(arrayBuffer), byteLength);
305    ASSERT_TRUE(result.IsECMAObject());
306}
307
308HWTEST_F_L0(BuiltinsSendableArrayBufferTest, CloneArrayBuffer1)
309{
310    uint32_t srcByteOffset = 0;
311    JSTaggedValue tagged = BuiltTestUtil::CreateBuiltinsSendableArrayBuffer(thread, 5);
312    JSHandle<JSSendableArrayBuffer> arrBuf(
313        thread, JSSendableArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
314    arrBuf->SetArrayBufferData(thread, JSTaggedValue::Null());
315    JSHandle<JSTaggedValue> constructor(thread, JSTaggedValue::Undefined());
316    JSTaggedValue result = BuiltinsSendableArrayBuffer::CloneArrayBuffer(
317        thread, JSHandle<JSTaggedValue>(thread, tagged), srcByteOffset, constructor);
318    ASSERT_EQ(JSTaggedValue(result).GetRawData(), JSTaggedValue::Exception().GetRawData());
319}
320
321HWTEST_F_L0(BuiltinsSendableArrayBufferTest, CloneArrayBuffer2)
322{
323    uint32_t srcByteOffset = 0;
324
325    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
326    JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
327    JSHandle<JSFunction> arrayBuffer(thread, env->GetSBuiltininArrayBufferFunction().GetTaggedValue());
328
329    JSHandle<ByteArray> byteArray = factory->NewByteArray(5, 8);
330    JSTaggedValue result = BuiltinsSendableArrayBuffer::CloneArrayBuffer(
331        thread, JSHandle<JSTaggedValue>(byteArray), srcByteOffset, JSHandle<JSTaggedValue>(arrayBuffer));
332
333    JSHandle<JSSendableArrayBuffer> arrBuf(
334        thread, JSSendableArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(result.GetRawData())));
335    auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
336    ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
337    ecmaRuntimeCallInfo1->SetThis(arrBuf.GetTaggedValue());
338    auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
339    JSTaggedValue result1 = BuiltinsSendableArrayBuffer::GetByteLength(ecmaRuntimeCallInfo1);
340
341    ASSERT_EQ(result1.GetRawData(), JSTaggedValue(40).GetRawData());
342    TestHelper::TearDownFrame(thread, prev);
343}
344
345HWTEST_F_L0(BuiltinsSendableArrayBufferTest, CloneArrayBuffer3)
346{
347    uint32_t srcByteOffset = 0;
348
349    JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
350
351    JSTaggedValue tagged = BuiltTestUtil::CreateBuiltinsSendableArrayBuffer(thread, 6);
352    JSHandle<JSFunction> arrayBuffer(thread, env->GetSBuiltininArrayBufferFunction().GetTaggedValue());
353    JSTaggedValue result = BuiltinsSendableArrayBuffer::CloneArrayBuffer(
354        thread, JSHandle<JSTaggedValue>(thread, tagged), srcByteOffset, JSHandle<JSTaggedValue>(arrayBuffer));
355
356    JSHandle<JSSendableArrayBuffer> arrBuf(
357        thread, JSSendableArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(result.GetRawData())));
358    auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
359    ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
360    ecmaRuntimeCallInfo1->SetThis(arrBuf.GetTaggedValue());
361    auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
362    JSTaggedValue result1 = BuiltinsSendableArrayBuffer::GetByteLength(ecmaRuntimeCallInfo1);
363
364    ASSERT_EQ(result1.GetRawData(), JSTaggedValue(6).GetRawData());
365    TestHelper::TearDownFrame(thread, prev);
366}
367}  // namespace panda::test
368