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/js_api/js_api_queue.h"
17 #include "ecmascript/containers/containers_private.h"
18 #include "ecmascript/global_env.h"
19 #include "ecmascript/tests/ecma_test_common.h"
20
21 using namespace panda::ecmascript;
22
23 namespace panda::test {
24 class JSAPIQueueTest : public BaseTestWithScope<false> {
25 protected:
CreateQueue(int capacaty=JSAPIQueue::DEFAULT_CAPACITY_LENGTH)26 JSHandle<JSAPIQueue> CreateQueue(int capacaty = JSAPIQueue::DEFAULT_CAPACITY_LENGTH)
27 {
28 return EcmaContainerCommon::CreateQueue(thread, capacaty);
29 }
30
TestCommon(JSMutableHandle<JSTaggedValue> & value,std::string & queueValue,uint32_t len)31 JSHandle<JSAPIQueue> TestCommon(JSMutableHandle<JSTaggedValue>& value, std::string& queueValue, uint32_t len)
32 {
33 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
34 JSHandle<JSAPIQueue> jsQueue = CreateQueue();
35 for (uint32_t i = 0; i < len; i++) {
36 std::string ivalue = queueValue + std::to_string(i);
37 value.Update(factory->NewFromStdString(ivalue).GetTaggedValue());
38 JSAPIQueue::Add(thread, jsQueue, value);
39 }
40 return jsQueue;
41 }
42 };
43
HWTEST_F_L0(JSAPIQueueTest,queueCreate)44 HWTEST_F_L0(JSAPIQueueTest, queueCreate)
45 {
46 JSHandle<JSAPIQueue> jsQueue = CreateQueue();
47 EXPECT_TRUE(*jsQueue != nullptr);
48 }
49
HWTEST_F_L0(JSAPIQueueTest,AddAndHasAndSetAndGet)50 HWTEST_F_L0(JSAPIQueueTest, AddAndHasAndSetAndGet)
51 {
52 constexpr uint32_t DEFAULT_LENGTH = 8;
53 JSMutableHandle<JSTaggedValue> value(thread, JSTaggedValue::Undefined());
54 std::string queueValue("queuevalue");
55 JSHandle<JSAPIQueue> jsQueue = TestCommon(value, queueValue, DEFAULT_LENGTH);
56 EXPECT_EQ(jsQueue->GetSize(thread), DEFAULT_LENGTH);
57 EXPECT_EQ(JSAPIQueue::GetArrayLength(thread, jsQueue), DEFAULT_LENGTH);
58
59 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
60 // test Set, Has and Get
61 std::string ivalue = queueValue + std::to_string(10);
62 value.Update(factory->NewFromStdString(ivalue).GetTaggedValue());
63 EXPECT_FALSE(jsQueue->Has(thread, value.GetTaggedValue()));
64 jsQueue->Set(thread, 0, value.GetTaggedValue());
65 EXPECT_EQ(jsQueue->Get(thread, 0), value.GetTaggedValue());
66 EXPECT_TRUE(jsQueue->Has(thread, value.GetTaggedValue()));
67
68 // test Get exception
69 JSTaggedValue result = jsQueue->Get(thread, DEFAULT_LENGTH);
70 EXPECT_EQ(result, JSTaggedValue::Exception());
71 EXPECT_EXCEPTION();
72 }
73
HWTEST_F_L0(JSAPIQueueTest,PopFirstAndGetFirst)74 HWTEST_F_L0(JSAPIQueueTest, PopFirstAndGetFirst)
75 {
76 constexpr uint32_t DEFAULT_LENGTH = 8;
77 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
78 JSMutableHandle<JSTaggedValue> value(thread, JSTaggedValue::Undefined());
79 JSHandle<JSAPIQueue> jsQueue = CreateQueue();
80
81 // test GetFirst and pop of empty queue
82 EXPECT_EQ(JSAPIQueue::GetFirst(thread, jsQueue), JSTaggedValue::Undefined());
83 EXPECT_EQ(JSAPIQueue::Pop(thread, jsQueue), JSTaggedValue::Undefined());
84
85 std::string queueValue("queuevalue");
86 for (uint32_t i = 0; i < DEFAULT_LENGTH; i++) {
87 std::string ivalue = queueValue + std::to_string(i);
88 value.Update(factory->NewFromStdString(ivalue).GetTaggedValue());
89 JSAPIQueue::Add(thread, jsQueue, value);
90 }
91
92 // test GetFirst
93 EXPECT_EQ(JSAPIQueue::GetArrayLength(thread, jsQueue), DEFAULT_LENGTH);
94 std::string firstValue = queueValue + std::to_string(0U);
95 value.Update(factory->NewFromStdString(firstValue).GetTaggedValue());
96 EXPECT_TRUE(JSTaggedValue::SameValue(thread,
97 JSHandle<JSTaggedValue>(thread, JSAPIQueue::GetFirst(thread, jsQueue)), value));
98 // test Pop
99 for (uint32_t i = 0; i < DEFAULT_LENGTH; i++) {
100 std::string ivalue = queueValue + std::to_string(i);
101 value.Update(factory->NewFromStdString(ivalue).GetTaggedValue());
102 EXPECT_TRUE(JSTaggedValue::SameValue(thread,
103 JSHandle<JSTaggedValue>(thread, JSAPIQueue::Pop(thread, jsQueue)), value));
104 EXPECT_EQ(JSAPIQueue::GetArrayLength(thread, jsQueue), (DEFAULT_LENGTH - i - 1U));
105 }
106 }
107
HWTEST_F_L0(JSAPIQueueTest,OwnKeys)108 HWTEST_F_L0(JSAPIQueueTest, OwnKeys)
109 {
110 constexpr uint32_t DEFAULT_LENGTH = 8;
111 JSMutableHandle<JSTaggedValue> value(thread, JSTaggedValue::Undefined());
112
113 std::string queueValue("queuevalue");
114 JSHandle<JSAPIQueue> jsQueue = TestCommon(value, queueValue, DEFAULT_LENGTH);
115
116 JSHandle<TaggedArray> arrayKey = JSAPIQueue::OwnKeys(thread, jsQueue);
117 EXPECT_EQ(arrayKey->GetLength(), DEFAULT_LENGTH);
118 for (int32_t i = 0; i < static_cast<int32_t>(DEFAULT_LENGTH); i++) {
119 ASSERT_TRUE(EcmaStringAccessor::StringsAreEqual(thread,
120 *(base::NumberHelper::NumberToString(thread, JSTaggedValue(i))),
121 EcmaString::Cast(arrayKey->Get(thread, i).GetTaggedObject())));
122 }
123 }
124
HWTEST_F_L0(JSAPIQueueTest,GetNextPosition)125 HWTEST_F_L0(JSAPIQueueTest, GetNextPosition)
126 {
127 constexpr uint32_t DEFAULT_LENGTH = 8;
128 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
129 JSMutableHandle<JSTaggedValue> value(thread, JSTaggedValue::Undefined());
130 std::string queueValue("queuevalue");
131 JSHandle<JSAPIQueue> jsQueue = TestCommon(value, queueValue, DEFAULT_LENGTH);
132 // test GetNextPosition
133 EXPECT_EQ(jsQueue->GetSize(thread), DEFAULT_LENGTH);
134 for (uint32_t i = 0; i < DEFAULT_LENGTH;) {
135 std::string ivalue = queueValue + std::to_string(i);
136 value.Update(factory->NewFromStdString(ivalue).GetTaggedValue());
137 EXPECT_EQ(jsQueue->Get(thread, i), value.GetTaggedValue());
138 i = jsQueue->GetNextPosition(thread, i);
139 }
140 }
141
HWTEST_F_L0(JSAPIQueueTest,GetOwnProperty)142 HWTEST_F_L0(JSAPIQueueTest, GetOwnProperty)
143 {
144 constexpr uint32_t DEFAULT_LENGTH = 8;
145 JSMutableHandle<JSTaggedValue> value(thread, JSTaggedValue::Undefined());
146 std::string queueValue("queuevalue");
147 JSHandle<JSAPIQueue> jsQueue = TestCommon(value, queueValue, DEFAULT_LENGTH);
148 // test GetOwnProperty
149 int testInt = 1;
150 JSHandle<JSTaggedValue> queueKey1(thread, JSTaggedValue(testInt));
151 EXPECT_TRUE(JSAPIQueue::GetOwnProperty(thread, jsQueue, queueKey1));
152 testInt = 9;
153 JSHandle<JSTaggedValue> queueKey2(thread, JSTaggedValue(testInt));
154 EXPECT_FALSE(JSAPIQueue::GetOwnProperty(thread, jsQueue, queueKey2));
155 EXPECT_EXCEPTION();
156
157 // test GetOwnProperty exception
158 JSHandle<JSTaggedValue> undefined(thread, JSTaggedValue::Undefined());
159 EXPECT_FALSE(JSAPIQueue::GetOwnProperty(thread, jsQueue, undefined));
160 EXPECT_EXCEPTION();
161 }
162
163 /**
164 * @tc.name: GetProperty
165 * @tc.desc:
166 * @tc.type: FUNC
167 * @tc.require:
168 */
HWTEST_F_L0(JSAPIQueueTest,GetProperty)169 HWTEST_F_L0(JSAPIQueueTest, GetProperty)
170 {
171 JSHandle<JSAPIQueue> jsQueue = CreateQueue();
172 uint32_t elementsNums = 8;
173 for (uint32_t i = 0; i < elementsNums; i++) {
174 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(i));
175 JSAPIQueue::Add(thread, jsQueue, value);
176 }
177 for (uint32_t i = 0; i < elementsNums; i++) {
178 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(i));
179 OperationResult getPropertyRes = JSAPIQueue::GetProperty(thread, jsQueue, key);
180 EXPECT_EQ(getPropertyRes.GetValue().GetTaggedValue(), JSTaggedValue(i));
181 }
182 }
183
184 /**
185 * @tc.name: SetProperty
186 * @tc.desc:
187 * @tc.type: FUNC
188 * @tc.require:
189 */
HWTEST_F_L0(JSAPIQueueTest,SetProperty)190 HWTEST_F_L0(JSAPIQueueTest, SetProperty)
191 {
192 JSHandle<JSAPIQueue> jsQueue = CreateQueue();
193 uint32_t elementsNums = 8;
194 for (uint32_t i = 0; i < elementsNums; i++) {
195 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(i));
196 JSAPIQueue::Add(thread, jsQueue, value);
197 }
198 for (uint32_t i = 0; i < elementsNums; i++) {
199 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(i));
200 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(i * 2)); // 2 : It means double
201 bool setPropertyRes = JSAPIQueue::SetProperty(thread, jsQueue, key, value);
202 EXPECT_EQ(setPropertyRes, true);
203 }
204 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(-1));
205 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(-1));
206 EXPECT_FALSE(JSAPIQueue::SetProperty(thread, jsQueue, key, value));
207 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(elementsNums));
208 EXPECT_FALSE(JSAPIQueue::SetProperty(thread, jsQueue, key1, value));
209 }
210
211 /**
212 * @tc.name: GrowCapacity
213 * @tc.desc:
214 * @tc.type: FUNC
215 * @tc.require:
216 */
HWTEST_F_L0(JSAPIQueueTest,GrowCapacity)217 HWTEST_F_L0(JSAPIQueueTest, GrowCapacity)
218 {
219 JSHandle<JSAPIQueue> jsQueue = CreateQueue(0);
220 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(0));
221 JSHandle<TaggedArray> element(thread, jsQueue->GetElements(thread));
222 EXPECT_EQ(element->GetLength(), 0U);
223 JSAPIQueue::Add(thread, jsQueue, value);
224 JSHandle<TaggedArray> newElement(thread, jsQueue->GetElements(thread));
225 EXPECT_EQ(newElement->GetLength(), static_cast<uint32_t>(JSAPIQueue::DEFAULT_CAPACITY_LENGTH));
226 }
227 } // namespace panda::test
228