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 "ecmascript/ecma_vm.h"
17#include "ecmascript/global_env.h"
18#include "ecmascript/object_factory.h"
19#include "ecmascript/js_function.h"
20#include "ecmascript/js_hclass.h"
21#include "ecmascript/js_object-inl.h"
22#include "ecmascript/jspandafile/class_info_extractor.h"
23#include "ecmascript/tests/test_helper.h"
24
25using namespace panda;
26
27using namespace panda::ecmascript;
28
29namespace panda::test {
30class SharedObjectFactoryTest : public BaseTestWithScope<false> {
31};
32
33HWTEST_F_L0(SharedObjectFactoryTest, NewSModuleNamespaceTest001)
34{
35    auto vm = thread->GetEcmaVM();
36    ObjectFactory *factory = instance->GetFactory();
37    JSHandle<ModuleNamespace> np = factory->NewSModuleNamespace();
38    ModuleNamespace::PreventExtensions();
39    JSHandle<JSTaggedValue> moduleNamespaceTag = JSHandle<JSTaggedValue>::Cast(np);
40    Local<JSValueRef> moduleNamespace = JSNApiHelper::ToLocal<ModuleNamespace>(moduleNamespaceTag);
41    ASSERT_EQ(moduleNamespace->IsModuleNamespaceObject(vm), true);
42}
43
44HWTEST_F_L0(SharedObjectFactoryTest, NewSImportEntryTest001)
45{
46    ObjectFactory *factory = instance->GetFactory();
47    JSHandle<EcmaString> request = factory->NewFromASCII("request");
48    JSHandle<EcmaString> importName = factory->NewFromASCII("importName");
49    JSHandle<EcmaString> localName = factory->NewFromASCII("localName");
50
51    JSHandle<ImportEntry> entry = factory->NewSImportEntry(JSHandle<JSTaggedValue>::Cast(request),
52                                                           JSHandle<JSTaggedValue>::Cast(importName),
53                                                           JSHandle<JSTaggedValue>::Cast(localName));
54    ASSERT_EQ(entry->GetImportName().GetRawData(), JSHandle<JSTaggedValue>::Cast(importName)->GetRawData());
55    ASSERT_EQ(entry->GetLocalName().GetRawData(), JSHandle<JSTaggedValue>::Cast(localName)->GetRawData());
56    ASSERT_EQ(entry->GetModuleRequest().GetRawData(),
57              JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("request"))->GetRawData());
58}
59
60HWTEST_F_L0(SharedObjectFactoryTest, NewSLocalExportEntryTest001)
61{
62    ObjectFactory *factory = instance->GetFactory();
63    JSHandle<LocalExportEntry> entry =
64        factory->NewSLocalExportEntry(JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("exportName")),
65                                      JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("localName")), 1);
66    ASSERT_EQ(entry->GetExportName().GetRawData(),
67              JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("exportName"))->GetRawData());
68    ASSERT_EQ(entry->GetLocalName().GetRawData(),
69              JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("localName"))->GetRawData());
70}
71
72HWTEST_F_L0(SharedObjectFactoryTest, NewSIndirectExportEntryTest001)
73{
74    ObjectFactory *factory = instance->GetFactory();
75    JSHandle<IndirectExportEntry> entry = factory->NewSIndirectExportEntry(
76        JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("exportName")),
77        JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("request")),
78        JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("importName")));
79    ASSERT_EQ(entry->GetExportName().GetRawData(),
80              JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("exportName"))->GetRawData());
81    ASSERT_EQ(entry->GetImportName().GetRawData(),
82              JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("importName"))->GetRawData());
83    ASSERT_EQ(entry->GetModuleRequest().GetRawData(),
84              JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("request"))->GetRawData());
85}
86
87HWTEST_F_L0(SharedObjectFactoryTest, NewSStarExportEntryTest001)
88{
89    ObjectFactory *factory = instance->GetFactory();
90
91    JSHandle<StarExportEntry> entry =
92        factory->NewSStarExportEntry(JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("request")));
93    ASSERT_EQ(entry->GetModuleRequest().GetRawData(),
94              JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("request"))->GetRawData());
95}
96
97HWTEST_F_L0(SharedObjectFactoryTest, NewSStarExportEntryTest002)
98{
99    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
100    JSHandle<LayoutInfo> emptyLayout = factory->CreateSLayoutInfo(0);
101    JSHandle<JSTaggedValue> prototype = JSHandle<JSTaggedValue>(emptyLayout);
102    JSHandle<StarExportEntry> result = factory->NewSStarExportEntry(prototype);
103    EXPECT_FALSE(prototype->IsJSObject());
104    EXPECT_TRUE(*result != nullptr);
105}
106
107HWTEST_F_L0(SharedObjectFactoryTest, NewSResolvedIndexBindingRecordTest001)
108{
109    ObjectFactory *factory = instance->GetFactory();
110    JSHandle<ResolvedIndexBinding> record = factory->NewSResolvedIndexBindingRecord();
111    ASSERT_NE(record->GetModule().GetRawData(), JSTaggedValue::Exception().GetRawData());
112}
113
114HWTEST_F_L0(SharedObjectFactoryTest, NewSResolvedIndexBindingRecordTest002)
115{
116    ObjectFactory *factory = instance->GetFactory();
117    JSHandle<JSTaggedValue> undefinedValue = thread->GlobalConstants()->GetHandledUndefined();
118    JSHandle<SourceTextModule> ecmaModule(undefinedValue);
119    JSHandle<ResolvedIndexBinding> record = factory->NewSResolvedIndexBindingRecord(ecmaModule, 2);
120    ASSERT_NE(record->GetModule().GetRawData(), JSTaggedValue::Exception().GetRawData());
121}
122
123HWTEST_F_L0(SharedObjectFactoryTest, NewSResolvedBindingRecordTest001)
124{
125    ObjectFactory *factory = instance->GetFactory();
126    JSHandle<ResolvedRecordBinding> record = factory->NewSResolvedRecordBindingRecord();
127    JSHandle<JSTaggedValue> undefinedValue = thread->GlobalConstants()->GetHandledUndefined();
128    ASSERT_EQ(record->GetBindingName().GetRawData(), undefinedValue->GetRawData());
129}
130
131HWTEST_F_L0(SharedObjectFactoryTest, NewSResolvedBindingRecordTest002)
132{
133    ObjectFactory *factory = instance->GetFactory();
134    JSHandle<ResolvedRecordBinding> record = factory->NewSResolvedRecordBindingRecord(
135        factory->NewFromASCII("moduleRecord"),
136        JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("bindName")));
137    ASSERT_EQ(record->GetBindingName().GetRawData(),
138              JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("bindName"))->GetRawData());
139}
140
141HWTEST_F_L0(SharedObjectFactoryTest, CopySArrayTest001)
142{
143    ObjectFactory *factory = instance->GetFactory();
144    JSHandle<TaggedArray> array = factory->NewTaggedArray(5);
145    JSHandle<TaggedArray> result = factory->CopySArray(array, 5, 10);
146    for (size_t i = 0; i < 5; i++)
147    {
148        ASSERT_EQ(array->Get(i).GetRawData(), result->Get(i).GetRawData());
149    }
150    for (size_t i = 5; i < 10; i++)
151    {
152        ASSERT_EQ(result->Get(i).GetRawData(), JSTaggedValue::Hole().GetRawData());
153    }
154}
155
156HWTEST_F_L0(SharedObjectFactoryTest, CopySArrayTest002)
157{
158    ObjectFactory *factory = instance->GetFactory();
159    JSHandle<TaggedArray> array = factory->NewTaggedArray(10);
160    JSHandle<TaggedArray> result = factory->CopySArray(array, 10, 5);
161    for (size_t i = 0; i < 5; i++)
162    {
163        ASSERT_EQ(array->Get(i).GetRawData(), result->Get(i).GetRawData());
164    }
165}
166
167HWTEST_F_L0(SharedObjectFactoryTest, CopySArrayTest003)
168{
169    ObjectFactory *factory = instance->GetFactory();
170    JSHandle<TaggedArray> array = factory->NewTaggedArray(5);
171    JSHandle<TaggedArray> result = factory->CopySArray(array, 5, 0);
172    ASSERT_EQ(result->GetLength(), 0);
173}
174
175HWTEST_F_L0(SharedObjectFactoryTest, NewSClassInfoExtractorTest001)
176{
177    ObjectFactory *factory = instance->GetFactory();
178    JSHandle<ClassInfoExtractor> info =
179        factory->NewSClassInfoExtractor(JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("method")));
180    ASSERT_EQ(info->GetConstructorMethod().GetRawData(),
181              JSHandle<JSTaggedValue>::Cast(factory->NewFromASCII("method"))->GetRawData());
182}
183} // namespace panda::test