1 /*
2 * Copyright (c) 2022 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_sharedarraybuffer.h"
17
18 #include "ecmascript/ecma_runtime_call_info.h"
19 #include "ecmascript/ecma_vm.h"
20 #include "ecmascript/global_env.h"
21 #include "ecmascript/js_arraybuffer.h"
22 #include "ecmascript/js_handle.h"
23 #include "ecmascript/js_tagged_value.h"
24 #include "ecmascript/tests/test_helper.h"
25 #include "ecmascript/builtins/builtins_arraybuffer.h"
26
27 using namespace panda::ecmascript;
28 using namespace panda::ecmascript::builtins;
29 using BuiltinsArrayBuffer = builtins::BuiltinsArrayBuffer;
30
31 namespace panda::test {
32 class BuiltinsSharedArrayBufferTest : public testing::Test {
33 public:
SetUpTestCase()34 static void SetUpTestCase()
35 {
36 GTEST_LOG_(INFO) << "SetUpTestCase";
37 }
38
TearDownTestCase()39 static void TearDownTestCase()
40 {
41 GTEST_LOG_(INFO) << "TearDownCase";
42 }
43
SetUp()44 void SetUp() override
45 {
46 TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
47 }
48
TearDown()49 void TearDown() override
50 {
51 TestHelper::DestroyEcmaVMWithScope(instance, scope);
52 }
53
54 EcmaVM *instance {nullptr};
55 EcmaHandleScope *scope {nullptr};
56 JSThread *thread {nullptr};
57 };
58
CreateBuiltinsSharedArrayBuffer(JSThread * thread,int32_t length)59 JSTaggedValue CreateBuiltinsSharedArrayBuffer(JSThread *thread, int32_t length)
60 {
61 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
62 JSHandle<JSFunction> sharedArrayBuffer(thread, env->GetSharedArrayBufferFunction().GetTaggedValue());
63 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
64 // 6 : test case
65 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, sharedArrayBuffer.GetTaggedValue(), 6);
66 ecmaRuntimeCallInfo->SetFunction(sharedArrayBuffer.GetTaggedValue());
67 ecmaRuntimeCallInfo->SetThis(globalObject.GetTaggedValue());
68 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(length));
69
70 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
71 JSTaggedValue result = BuiltinsSharedArrayBuffer::SharedArrayBufferConstructor(ecmaRuntimeCallInfo);
72 TestHelper::TearDownFrame(thread, prev);
73 return result;
74 }
75
CreateJSArrayBuffer(JSThread * thread)76 JSArrayBuffer *CreateJSArrayBuffer(JSThread *thread)
77 {
78 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
79 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
80 JSHandle<JSTaggedValue> target = env->GetArrayBufferFunction();
81 JSHandle<JSArrayBuffer> jsArrayBuffer =
82 JSHandle<JSArrayBuffer>::Cast(factory->NewJSObjectByConstructor(JSHandle<JSFunction>(target), target));
83 return *jsArrayBuffer;
84 }
85
86 // new ArrayBuffer(20)
HWTEST_F_L0(BuiltinsSharedArrayBufferTest,Constructor1)87 HWTEST_F_L0(BuiltinsSharedArrayBufferTest, Constructor1)
88 {
89 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
90 JSHandle<JSFunction> sharedArrayBuffer(thread, env->GetSharedArrayBufferFunction().GetTaggedValue());
91 JSHandle<JSObject> globalObject(thread, env->GetGlobalObject());
92 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, sharedArrayBuffer.GetTaggedValue(), 6);
93 ecmaRuntimeCallInfo->SetFunction(sharedArrayBuffer.GetTaggedValue());
94 ecmaRuntimeCallInfo->SetThis(globalObject.GetTaggedValue());
95 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(20)));
96
97 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
98 JSTaggedValue result = BuiltinsSharedArrayBuffer::SharedArrayBufferConstructor(ecmaRuntimeCallInfo);
99 ASSERT_TRUE(result.IsECMAObject());
100 }
101
102 // (new ArrayBuffer(18)).byteLength
HWTEST_F_L0(BuiltinsSharedArrayBufferTest,byteLength1)103 HWTEST_F_L0(BuiltinsSharedArrayBufferTest, byteLength1)
104 {
105 JSTaggedValue tagged = CreateBuiltinsSharedArrayBuffer(thread, 18);
106 JSHandle<JSArrayBuffer> arrBuf(thread, JSArrayBuffer::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 = BuiltinsSharedArrayBuffer::GetByteLength(ecmaRuntimeCallInfo);
113 ASSERT_EQ(result.GetRawData(), JSTaggedValue(18).GetRawData());
114 }
115
116 // (new ArrayBuffer(10)).slice(1, 5).bytelength
HWTEST_F_L0(BuiltinsSharedArrayBufferTest,slice1)117 HWTEST_F_L0(BuiltinsSharedArrayBufferTest, slice1)
118 {
119 JSTaggedValue tagged = CreateBuiltinsSharedArrayBuffer(thread, 10);
120 JSHandle<JSArrayBuffer> arrBuf(thread, JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
121 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
122 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
123 ecmaRuntimeCallInfo->SetThis(arrBuf.GetTaggedValue());
124 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
125 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
126
127 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
128 JSTaggedValue result1 = BuiltinsSharedArrayBuffer::Slice(ecmaRuntimeCallInfo);
129 TestHelper::TearDownFrame(thread, prev);
130 JSHandle<JSArrayBuffer> arrBuf1(thread,
131 JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(result1.GetRawData())));
132 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
133 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
134 ecmaRuntimeCallInfo1->SetThis(arrBuf1.GetTaggedValue());
135 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
136 JSTaggedValue result2 = BuiltinsSharedArrayBuffer::GetByteLength(ecmaRuntimeCallInfo1);
137 TestHelper::TearDownFrame(thread, prev);
138 ASSERT_EQ(result2.GetRawData(), JSTaggedValue(4).GetRawData());
139
140 // IsShared false
141 JSTaggedValue tagged1 = CreateBuiltinsSharedArrayBuffer(thread, 10);
142 JSHandle<JSArrayBuffer> arrBuf2(thread, JSArrayBuffer::Cast(
143 reinterpret_cast<TaggedObject *>(tagged1.GetRawData())));
144 arrBuf2->SetShared(false);
145 auto ecmaRuntimeCallInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
146 ecmaRuntimeCallInfo2->SetFunction(JSTaggedValue::Undefined());
147 ecmaRuntimeCallInfo2->SetThis(arrBuf2.GetTaggedValue());
148 ecmaRuntimeCallInfo2->SetCallArg(0, JSTaggedValue(static_cast<int32_t>(1)));
149 ecmaRuntimeCallInfo2->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(5)));
150
151 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo2);
152 JSTaggedValue result3 = BuiltinsSharedArrayBuffer::Slice(ecmaRuntimeCallInfo2);
153 TestHelper::TearDownFrame(thread, prev);
154 EXPECT_TRUE(thread->HasPendingException());
155 EXPECT_EQ(result3, JSTaggedValue::Exception());
156 thread->ClearException();
157 }
158
HWTEST_F_L0(BuiltinsSharedArrayBufferTest,IsSharedArrayBuffer)159 HWTEST_F_L0(BuiltinsSharedArrayBufferTest, IsSharedArrayBuffer)
160 {
161 JSTaggedValue tagged = CreateBuiltinsSharedArrayBuffer(thread, 10);
162 JSHandle<JSArrayBuffer> arrBuf(thread,
163 JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged.GetRawData())));
164 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
165 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
166 ecmaRuntimeCallInfo->SetThis(arrBuf.GetTaggedValue());
167 ecmaRuntimeCallInfo->SetCallArg(0, arrBuf.GetTaggedValue()); // JSTaggedValue(static_cast<int32_t>(1))
168
169 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
170 JSTaggedValue result = BuiltinsSharedArrayBuffer::IsSharedArrayBuffer(ecmaRuntimeCallInfo);
171 TestHelper::TearDownFrame(thread, prev);
172 ASSERT_EQ(result, JSTaggedValue::True());
173 // Is Not ECMAObject
174 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
175 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
176 ecmaRuntimeCallInfo->SetThis(arrBuf.GetTaggedValue());
177 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Undefined());
178
179 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
180 result = BuiltinsSharedArrayBuffer::IsSharedArrayBuffer(ecmaRuntimeCallInfo);
181 TestHelper::TearDownFrame(thread, prev);
182 ASSERT_EQ(result, JSTaggedValue::False());
183 // Is Not sharedbuffer
184 JSHandle<JSArrayBuffer> jsArrayBuffer(thread, CreateJSArrayBuffer(thread));
185 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
186 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
187 ecmaRuntimeCallInfo->SetThis(arrBuf.GetTaggedValue());
188 ecmaRuntimeCallInfo->SetCallArg(0, jsArrayBuffer.GetTaggedValue());
189
190 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
191 result = BuiltinsSharedArrayBuffer::IsSharedArrayBuffer(ecmaRuntimeCallInfo);
192 TestHelper::TearDownFrame(thread, prev);
193 ASSERT_EQ(result, JSTaggedValue::False());
194
195 // sharedbuffer IsNull
196 JSTaggedValue tagged1 = CreateBuiltinsSharedArrayBuffer(thread, 0);
197 JSHandle<JSArrayBuffer> arrBuf1(thread,
198 JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged1.GetRawData())));
199 arrBuf1->SetArrayBufferData(thread, JSTaggedValue::Null());
200 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
201 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
202 ecmaRuntimeCallInfo->SetThis(arrBuf.GetTaggedValue());
203 ecmaRuntimeCallInfo->SetCallArg(0, arrBuf1.GetTaggedValue());
204
205 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
206 result = BuiltinsSharedArrayBuffer::IsSharedArrayBuffer(ecmaRuntimeCallInfo);
207 TestHelper::TearDownFrame(thread, prev);
208 ASSERT_EQ(result, JSTaggedValue::False());
209
210 // ArrayBuffer is not shared
211 JSTaggedValue tagged2 = CreateBuiltinsSharedArrayBuffer(thread, 0);
212 JSHandle<JSArrayBuffer> arrBuf2(thread,
213 JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged2.GetRawData())));
214 arrBuf2->SetShared(false);
215 ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
216 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
217 ecmaRuntimeCallInfo->SetThis(arrBuf.GetTaggedValue());
218 ecmaRuntimeCallInfo->SetCallArg(0, arrBuf2.GetTaggedValue());
219
220 prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
221 JSTaggedValue result1 = BuiltinsSharedArrayBuffer::IsSharedArrayBuffer(ecmaRuntimeCallInfo);
222 TestHelper::TearDownFrame(thread, prev);
223 ASSERT_EQ(result1, JSTaggedValue::False());
224 }
225
HWTEST_F_L0(BuiltinsSharedArrayBufferTest,IsShared)226 HWTEST_F_L0(BuiltinsSharedArrayBufferTest, IsShared)
227 {
228 // is not SharedBuffer
229 JSHandle<JSArrayBuffer> jsArrayBuffer(thread, CreateJSArrayBuffer(thread));
230 bool result = BuiltinsSharedArrayBuffer::IsShared(jsArrayBuffer.GetTaggedValue());
231 ASSERT_EQ(result, false);
232 // no BufferData
233 JSTaggedValue tagged1 = CreateBuiltinsSharedArrayBuffer(thread, 0);
234 JSHandle<JSArrayBuffer> arrBuf1(thread,
235 JSArrayBuffer::Cast(reinterpret_cast<TaggedObject *>(tagged1.GetRawData())));
236 arrBuf1->SetArrayBufferData(thread, JSTaggedValue::Null());
237 bool result1 = BuiltinsSharedArrayBuffer::IsShared(arrBuf1.GetTaggedValue());
238 ASSERT_EQ(result1, false);
239 }
240 } // namespace panda::test
241