OpenHarmony-v4.1-Release/s

/**
 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <gtest/gtest.h>
#include <algorithm>
#include <cstddef>
#include <cstdlib>
#include <fstream>
#include <ios>
#include <memory>
#include <optional>
#include <sstream>
#include <string>

#include "../linker_context.h"
#include "assembler/assembly-field.h"
#include "assembler/assembly-function.h"
#include "assembler/assembly-program.h"
#include "assembler/assembly-record.h"
#include "assembler/assembly-emitter.h"
#include "assembler/assembly-parser.h"
#include "assembler/ins_create_api.h"
#include "libpandafile/file_item_container.h"
#include "libpandafile/file_writer.h"
#include "include/runtime_options.h"
#include "linker.h"
#include "runtime/include/runtime.h"
#include "source_lang_enum.h"

namespace {
using Config = panda::static_linker::Config;
using Result = panda::static_linker::Result;
using panda::static_linker::DefaultConfig;
using panda::static_linker::Link;

constexpr size_t TEST_REPEAT_COUNT = 10;

std::pair<int, std::string> ExecPanda(const std::string &file)
{
    auto opts = panda::RuntimeOptions {};
    auto boot = opts.GetBootPandaFiles();
    for (auto &a : boot) {
        a.insert(0, "../");
    }
    opts.SetBootPandaFiles(std::move(boot));

    opts.SetLoadRuntimes({"core"});

    opts.SetPandaFiles({file});
    if (!panda::Runtime::Create(opts)) {
        return {1, "can't create runtime"};
    }

    auto *runtime = panda::Runtime::GetCurrent();

    std::stringstream strBuf;
    auto old = std::cout.rdbuf(strBuf.rdbuf());
    auto reset = [&old](auto *cout) { cout->rdbuf(old); };
    auto guard = std::unique_ptr<std::ostream, decltype(reset)>(&std::cout, reset);

    auto res = runtime->ExecutePandaFile(file, "_GLOBAL::main", {});
    auto ret = std::pair<int, std::string> {};
    if (!res) {
        ret = {1, "error " + std::to_string((int)res.Error())};
    } else {
        ret = {0, strBuf.str()};
    }

    if (!panda::Runtime::Destroy()) {
        return {1, "can't destroy runtime"};
    }

    return ret;
}

template <bool IS_BINARY>
bool ReadFile(const std::string &path, std::conditional_t<IS_BINARY, std::vector<char>, std::string> &out)
{
    auto f = std::ifstream(path, IS_BINARY ? std::ios_base::binary : std::ios_base::in);
    if (!f.is_open() || f.bad()) {
        return false;
    }

    out.clear();

    out.assign((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
    return true;
}

// removes comments
void NormalizeGold(std::string &gold)
{
    std::string_view in = gold;
    std::string out;
    out.reserve(gold.size());
    while (!in.empty()) {
        auto nxtNl = in.find('\n');
        if (in[0] == '#') {
            if (nxtNl == std::string::npos) {
                break;
            }
            in = in.substr(nxtNl + 1);
            continue;
        }
        if (nxtNl == std::string::npos) {
            out += in;
            break;
        }
        out += in.substr(0, nxtNl + 1);
        in = in.substr(nxtNl + 1);
    }
    gold = std::move(out);
}

std::optional<std::string> Build(const std::string &path)
{
    std::string prog;

    if (!ReadFile<false>(path + ".pa", prog)) {
        return "can't read file " + path + ".pa";
    }
    panda::pandasm::Parser p;
    auto res = p.Parse(prog, path + ".pa");
    if (p.ShowError().err != panda::pandasm::Error::ErrorType::ERR_NONE) {
        return p.ShowError().message + "\n" + p.ShowError().wholeLine;
    }

    if (!res.HasValue()) {
        return "no parsed value";
    }

    auto writer = panda::panda_file::FileWriter(path + ".abc");
    if (!panda::pandasm::AsmEmitter::Emit(&writer, res.Value())) {
        return "can't emit";
    }

    return std::nullopt;
}

void TestSingle(const std::string &path, bool isGood = true, const Config &conf = panda::static_linker::DefaultConfig(),
                bool *succeded = nullptr, Result *saveResult = nullptr)
{
    const auto pathPrefix = "data/single/";
    ASSERT_EQ(Build(pathPrefix + path), std::nullopt);
    auto gold = std::string {};
    ASSERT_TRUE(ReadFile<false>(pathPrefix + path + ".gold", gold));

    NormalizeGold(gold);

    const auto out = pathPrefix + path + ".linked.abc";
    auto linkRes = Link(conf, out, {pathPrefix + path + ".abc"});

    ASSERT_EQ(linkRes.errors.empty(), isGood);

    if (isGood) {
        auto res = ExecPanda(out);
        ASSERT_EQ(res.first, 0);
        ASSERT_EQ(res.second, gold);
    }

    if (succeded != nullptr) {
        *succeded = true;
    }

    if (saveResult != nullptr) {
        *saveResult = std::move(linkRes);
    }
}

void TestMultiple(const std::string &path, std::vector<std::string> perms, bool isGood = true,
                  const Config &conf = panda::static_linker::DefaultConfig(), Result *expected = nullptr)
{
    std::sort(perms.begin(), perms.end());

    const auto pathPrefix = "data/multi/" + path + "/";

    for (const auto &p : perms) {
        ASSERT_EQ(Build(pathPrefix + p), std::nullopt);
    }

    auto gold = std::string {};

    if (isGood) {
        ASSERT_TRUE(ReadFile<false>(pathPrefix + "out.gold", gold));
        NormalizeGold(gold);
    }

    auto out = std::string {};
    auto files = std::vector<std::string> {};

    std::optional<std::vector<char>> expectedFile;

    auto performTest = [&out, &pathPrefix, &files, &perms, &conf, &isGood, &expected, &expectedFile,
                        &gold](size_t iteration) {
        out = pathPrefix + "linked.";
        files.clear();

        for (const auto &f : perms) {
            out += f;
            out += ".";
            files.emplace_back(pathPrefix + f + ".abc");
        }
        out += "it";
        out += std::to_string(iteration);
        out += ".abc";

        SCOPED_TRACE(out);

        auto linkRes = Link(conf, out, files);
        if (linkRes.errors.empty() != isGood) {
            auto errs = std::string();
            for (auto &err : linkRes.errors) {
                errs += err;
                errs += "\n";
            }
            ASSERT_EQ(linkRes.errors.empty(), isGood) << errs;
        }

        if (expected != nullptr) {
            ASSERT_EQ(linkRes.stats.deduplicatedForeigners, expected->stats.deduplicatedForeigners);
        }

        if (isGood) {
            std::vector<char> gotFile;
            ASSERT_TRUE(ReadFile<true>(out, gotFile));
            if (!expectedFile.has_value()) {
                expectedFile = std::move(gotFile);
            } else {
                (void)iteration;
                ASSERT_EQ(expectedFile.value(), gotFile) << "on iteration: " << iteration;
            }

            auto res = ExecPanda(out);
            ASSERT_EQ(res.first, 0);
            ASSERT_EQ(res.second, gold);
        }
    };

    do {
        expectedFile = std::nullopt;
        for (size_t iteration = 0; iteration < TEST_REPEAT_COUNT; iteration++) {
            performTest(iteration);
        }
    } while (std::next_permutation(perms.begin(), perms.end()));
}
}  // namespace

TEST(linkertests, HelloWorld)
{
    TestSingle("hello_world");
}

TEST(linkertests, LitArray)
{
    TestSingle("lit_array");
}

TEST(linkertests, Exceptions)
{
    TestSingle("exceptions");
}

TEST(linkertests, ForeignMethod)
{
    TestMultiple("fmethod", {"1", "2"});
}

TEST(linkertests, ForeignField)
{
    TestMultiple("ffield", {"1", "2"});
}

TEST(linkertests, BadForeignField)
{
    TestMultiple("bad_ffield", {"1", "2"}, false);
}

TEST(linkertests, BadClassRedefinition)
{
    TestMultiple("bad_class_redefinition", {"1", "2"}, false);
}

TEST(linkertests, BadFFieldType)
{
    TestMultiple("bad_ffield_type", {"1", "2"}, false);
}

TEST(linkertests, FMethodOverloaded)
{
    TestMultiple("fmethod_overloaded", {"1", "2"});
}

TEST(linkertests, FMethodOverloaded2)
{
    TestMultiple("fmethod_overloaded_2", {"1", "2", "3", "4"});
}

TEST(linkertests, BadFMethodOverloaded)
{
    TestMultiple("bad_fmethod_overloaded", {"1", "2"}, false);
}

TEST(linkertests, DeduplicatedField)
{
    auto res = Result {};
    res.stats.deduplicatedForeigners = 1;
    TestMultiple("dedup_field", {"1", "2"}, true, DefaultConfig(), &res);
}

TEST(linkertests, DeduplicatedMethod)
{
    auto res = Result {};
    res.stats.deduplicatedForeigners = 1;
    TestMultiple("dedup_method", {"1", "2"}, true, DefaultConfig(), &res);
}

TEST(linkertests, UnresolvedInGlobal)
{
    TestSingle("unresolved_global", false);
    auto conf = DefaultConfig();
    conf.remainsPartial = {std::string(panda::panda_file::ItemContainer::GetGlobalClassName())};
    TestSingle("unresolved_global", true, conf);
}

TEST(linkertests, DeduplicateLineNumberNrogram)
{
    auto succ = false;
    auto res = Result {};
    TestSingle("lnp_dedup", true, DefaultConfig(), &succ, &res);
    ASSERT_TRUE(succ);
    ASSERT_EQ(res.stats.debugCount, 1);
}

TEST(linkertests, StripDebugInfo)
{
    auto succ = false;
    auto res = Result {};
    auto conf = DefaultConfig();
    conf.stripDebugInfo = true;
    TestSingle("hello_world", true, conf, &succ, &res);
    ASSERT_TRUE(succ);
    ASSERT_EQ(res.stats.debugCount, 0);
}

TEST(linkertests, FieldOverload)
{
    auto conf = DefaultConfig();
    conf.partial.emplace("LFor;");
    TestMultiple("ffield_overloaded", {"1", "2"}, true, conf);
}

TEST(linkertests, ForeignBase)
{
#ifdef PANDA_WITH_ETS
    constexpr auto LANG = panda::panda_file::SourceLang::ETS;
    auto makeRecord = [](panda::pandasm::Program &prog, const std::string &name) {
        return &prog.recordTable.emplace(name, panda::pandasm::Record(name, LANG)).first->second;
    };

    const std::string basePath = "data/multi/ForeignBase.1.abc";
    const std::string dervPath = "data/multi/ForeignBase.2.abc";

    {
        panda::pandasm::Program progBase;
        auto base = makeRecord(progBase, "Base");
        auto fld = panda::pandasm::Field(LANG);
        fld.name = "fld";
        fld.type = panda::pandasm::Type("i32", 0);
        base->fieldList.push_back(std::move(fld));

        ASSERT_TRUE(panda::pandasm::AsmEmitter::Emit(basePath, progBase));
    }

    {
        panda::pandasm::Program progDer;
        auto base = makeRecord(progDer, "Base");
        base->metadata->SetAttribute("external");

        auto derv = makeRecord(progDer, "Derv");
        ASSERT_EQ(derv->metadata->SetAttributeValue("ets.extends", "Base"), std::nullopt);
        std::ignore = derv;
        auto fld = panda::pandasm::Field(LANG);
        fld.name = "fld";
        fld.type = panda::pandasm::Type("i32", 0);
        fld.metadata->SetAttribute("external");
        derv->fieldList.push_back(std::move(fld));

        auto func = panda::pandasm::Function("main", LANG);
        func.regsNum = 1;
        func.returnType = panda::pandasm::Type("void", 0);
        func.AddInstruction(panda::pandasm::Create_NEWOBJ(0, "Derv"));
        func.AddInstruction(panda::pandasm::Create_LDOBJ(0, "Derv.fld"));
        func.AddInstruction(panda::pandasm::Create_RETURN_VOID());

        progDer.functionTable.emplace(func.name, std::move(func));

        ASSERT_TRUE(panda::pandasm::AsmEmitter::Emit(dervPath, progDer));
    }

    auto res = Link(DefaultConfig(), "data/multi/ForeignBase.linked.abc", {basePath, dervPath});
    ASSERT_TRUE(res.errors.empty()) << res.errors.front();
#endif
}