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#ifndef OHOS_IDL_MODULE_TEST_IDL_COMMON_H
17#define OHOS_IDL_MODULE_TEST_IDL_COMMON_H
18
19#include <gtest/gtest.h>
20#include <string>
21#define private public
22#define protected public
23#include "codegen/code_emitter.h"
24#include "codegen/code_generator.h"
25#include "codegen/rust_code_emitter.h"
26#undef private
27#undef protected
28#include "metadata/metadata_builder.h"
29#include "metadata/metadata_dumper.h"
30#include "metadata/metadata_reader.h"
31#include "metadata/metadata_serializer.h"
32#include "parser/parser.h"
33#include "util/file.h"
34#include "util/logger.h"
35#include "util/options.h"
36#include "util/string.h"
37#include "util/string_builder.h"
38#include "idl_file.h"
39#include "securec.h"
40
41namespace OHOS {
42namespace Idl {
43namespace TestCommon {
44const int ERR_FAIL = -1;
45const int ERR_OK = 0;
46
47class IdlCommon {
48public:
49    IdlCommon() = default;
50    ~IdlCommon() = default;
51
52    int Ready(int argc, char** argv)
53    {
54        Options options(argc, argv);
55        std::shared_ptr<MetaComponent> metadata = nullptr;
56
57        if (options.DoCompile()) {
58            Parser parser(options);
59            if (!parser.Parse(options.GetSourceFile())) {
60                return ERR_FAIL;
61            }
62
63            MetadataBuilder builder(parser.GetModule());
64            metadata = builder.Build();
65            metadata_ = metadata;
66            if (metadata == nullptr) {
67                return ERR_FAIL;
68            }
69        }
70
71        if (options.DoDumpMetadata()) {
72            MetadataDumper dumper(metadata.get());
73            dumper.Dump("");
74        }
75
76        if (options.DoSaveMetadata()) {
77            File metadataFile(options.GetMetadataFile(), File::WRITE);
78            if (!metadataFile.IsValid()) {
79                return ERR_FAIL;
80            }
81
82            MetadataSerializer serializer(metadata.get());
83            serializer.Serialize();
84            uintptr_t data = serializer.GetData();
85            int size = serializer.GetDataSize();
86
87            metadataFile.WriteData(reinterpret_cast<void*>(data), size);
88            metadataFile.Flush();
89            metadataFile.Close();
90        }
91
92        if (options.DoGenerateCode()) {
93            if (metadata == nullptr) {
94                String metadataFile = options.GetMetadataFile();
95                metadata = MetadataReader::ReadMetadataFromFile(metadataFile);
96                if (metadata == nullptr) {
97                    return ERR_FAIL;
98                }
99            }
100            if (options.GetTargetLanguage().Equals("rust")) {
101                this->rustCodeGen_ = std::make_shared<RustCodeEmitter>(metadata.get());
102                this->rustCodeGen_->SetDirectory(options.GetGenerationDirectory());
103            }
104        }
105        return 0;
106    }
107
108    int PrepareIdlFile(
109        const std::string &fileName, const std::string &fileContent, const std::string &fileLicense = LICENSE_CONTENT)
110    {
111        String filePath = String::Format("%s/%s", "./", fileName.c_str());
112        File file(filePath, File::WRITE);
113        if (!file.IsValid()) {
114            GTEST_LOG_(INFO) << "OPEN FILE FAIL";
115            return ERR_FAIL;
116        }
117
118        StringBuilder stringBuilder;
119        stringBuilder.Append(fileLicense.c_str());
120        stringBuilder.Append(fileContent.c_str());
121
122        String data = stringBuilder.ToString();
123        file.WriteData(data.string(), data.GetLength());
124        file.Flush();
125        file.Close();
126        return ERR_OK;
127    }
128
129    std::shared_ptr<MetaComponent> metadata_ = nullptr;
130    std::shared_ptr<RustCodeEmitter> rustCodeGen_ = nullptr;
131};
132
133class ParameterArgv {
134public:
135    ParameterArgv(const char** args, const int argc) : argc_(argc)
136    {
137        argv_ = new char* [argc_] {nullptr};
138        for (int i = 0; i < argc_; ++i) {
139            const int itemSize = strlen(args[i]);
140            argv_[i] = new char[itemSize + 1] {0};
141            if (strcpy_s(argv_[i], itemSize + 1, args[i])) {
142                GTEST_LOG_(ERROR) << "strcpy_s error [!EOK]";
143            }
144        }
145    };
146    ~ParameterArgv()
147    {
148        if (argv_ == nullptr) {
149            return;
150        }
151
152        for (int i = 0; i < argc_; ++i) {
153            if (argv_[i] == nullptr) {
154                continue;
155            }
156            delete[] argv_[i];
157            argv_[i] = nullptr;
158        }
159        delete[] argv_;
160        argv_ = nullptr;
161    };
162
163    char** GetArgv()
164    {
165        return argv_;
166    };
167
168    char** argv_;
169    const int argc_;
170};
171}
172}
173}
174#endif  // OHOS_IDL_MODULE_TEST_IDL_COMMON_H