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 
25 using namespace panda::ecmascript;
26 using namespace panda::ecmascript::builtins;
27 
28 namespace panda::test {
29 class BuiltinsSendableArrayBufferTest : public BaseTestWithScope<false> {
30 };
31 
32 
SendableArrayBufferSliceTest(JSThread *thread, JSTaggedValue start, JSTaggedValue end, JSTaggedValue res)33 void 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)
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, Constructor1)60 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, Constructor2)77 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, byteLength1)86 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, species1)102 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, slice1)118 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, slice2)125 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, slice3)132 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, slice4)139 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, slice5)152 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, slice6)169 HWTEST_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())
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, IsView1)187 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, IsView2)209 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, IsView3)231 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, IsDetachBuffer1)255 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, IsDetachBuffer2)264 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, IsDetachBuffer3)275 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, AllocateSendableArrayBuffer1)286 HWTEST_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
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, AllocateSendableArrayBuffer2)298 HWTEST_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 
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, CloneArrayBuffer1)308 HWTEST_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 
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, CloneArrayBuffer2)321 HWTEST_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 
HWTEST_F_L0(BuiltinsSendableArrayBufferTest, CloneArrayBuffer3)345 HWTEST_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