PorygonLang/tests/integration/UserDataTests.cpp

#ifdef TESTS_BUILD
#include <catch.hpp>
#include "../src/Script.hpp"
#include "../../src/UserData/UserData.hpp"
#include "../../src/UserData/UserDataStorage.hpp"
#include "../../src/UserData/UserDataValue.hpp"
#include "../../src/UserData/UserDataFunction.hpp"
#include "../../src/UserData/UserDataFunctionType.hpp"

using namespace Porygon;
using namespace Porygon::UserData;
using namespace Porygon::Utilities;

class UserDataTestObject{
public:
    int foo = 10;
    int getFoo(){
        return foo;
    }

    int Addition(int a, int b){
        return a + b;
    }

private:
    static EvalValue* GetFoo(void* obj){
        return new IntegerEvalValue(((UserDataTestObject*)obj)->foo);
    }

    static void SetFoo(void* obj, EvalValue* val){
        ((UserDataTestObject*)obj)->foo = val->EvaluateInteger();
    }

    static EvalValue* CallFooFunction(void* obj, EvalValue* parameters[], int parameterCount){
        return new IntegerEvalValue(((UserDataTestObject*)obj)->getFoo());
    }

    static EvalValue* GetFooFunction(void* obj){
        return new UserDataFunction(CallFooFunction, obj);
    }

    static EvalValue* CallAddition(void* obj, EvalValue* parameters[], int parameterCount){
        return new IntegerEvalValue(((UserDataTestObject*)obj)->Addition(
                parameters[0] -> EvaluateInteger(),
                parameters[1] -> EvaluateInteger()
                ));
    }

    static GenericFunctionScriptType* AdditionFunctionType();

    static EvalValue* GetAdditionFunction(void* obj){
        return new UserDataFunction(CallAddition, obj);
    }

public:
    static Porygon::UserData::UserData* CreateData(){
        return new Porygon::UserData::UserData({
            {
                HashedString::ConstHash("foo"),
                new UserDataField(new NumericScriptType(true, false), GetFoo, SetFoo)
            },
            {
                    HashedString::ConstHash("getFoo"),
                    new UserDataField(new UserDataFunctionType(make_shared<NumericScriptType>(true, false), {}), GetFooFunction, nullptr)
            },
            {
                    HashedString::ConstHash("Addition"),
                    new UserDataField(AdditionFunctionType(), GetAdditionFunction, nullptr)
            }
       });
    }
};

GenericFunctionScriptType* UserDataTestObject::AdditionFunctionType(){
    return new UserDataFunctionType(make_shared<NumericScriptType>(true, false),
                             vector<shared_ptr<ScriptType>>{
                                     make_shared<NumericScriptType>(true, false),
                                     make_shared<NumericScriptType>(true, false)
                             });
}

TEST_CASE( "Gets UserData value", "[integration]" ) {
    UserDataStorage::RegisterType(HashedString::ConstHash("testObject"), UserDataTestObject::CreateData());
    Script* script = Script::Create(R"(
function testFunc(testObject obj)
    return obj["foo"]
end
)");
    REQUIRE(!script->Diagnostics -> HasErrors());
    script->Evaluate();
    auto par = new UserDataTestObject();
    auto parameter = new UserDataValue(HashedString::ConstHash("testObject"), par);
    auto variable = script->CallFunction(u"testFunc", {parameter});
    REQUIRE(variable != nullptr);
    REQUIRE(variable->EvaluateInteger() == 10);
    delete par;
    delete parameter;
    delete script;
    UserDataStorage::ClearTypes();
}

TEST_CASE( "Sets UserData value", "[integration]" ) {
    UserDataStorage::RegisterType(HashedString::ConstHash("testObject"), UserDataTestObject::CreateData());
    Script* script = Script::Create(R"(
function testFunc(testObject obj)
    obj["foo"] = 5000
end
)");
    REQUIRE(!script->Diagnostics -> HasErrors());
    script->Evaluate();
    auto obj = new UserDataTestObject();
    auto parameter = new UserDataValue(HashedString::ConstHash("testObject"), obj);
    script->CallFunction(u"testFunc", {parameter});
    delete script;
    REQUIRE(obj->foo == 5000);
    delete obj;
    delete parameter;
    UserDataStorage::ClearTypes();
}

TEST_CASE( "Calls UserData function", "[integration]" ) {
    UserDataStorage::RegisterType(HashedString::ConstHash("testObject"), UserDataTestObject::CreateData());
    Script* script = Script::Create(R"(
function testFunc(testObject obj)
    return obj.getFoo()
end
)");
    REQUIRE(!script->Diagnostics -> HasErrors());
    script->Evaluate();
    auto obj = new UserDataTestObject();
    auto parameter = new UserDataValue(HashedString::ConstHash("testObject"), obj);
    auto result = script->CallFunction(u"testFunc", {parameter});
    REQUIRE(result -> EvaluateInteger() == 10);
    delete script;
    delete obj;
    delete parameter;
    UserDataStorage::ClearTypes();
}

TEST_CASE( "Calls UserData function with parameters", "[integration]" ) {
    UserDataStorage::RegisterType(HashedString::ConstHash("testObject"), UserDataTestObject::CreateData());
    Script* script = Script::Create(R"(
function testFunc(testObject obj)
    return obj.Addition(5046, 8432)
end
)");
    REQUIRE(!script->Diagnostics -> HasErrors());
    script->Evaluate();
    auto obj = new UserDataTestObject();
    auto parameter = new UserDataValue(HashedString::ConstHash("testObject"), obj);
    auto result = script->CallFunction(u"testFunc", {parameter});
    REQUIRE(result -> EvaluateInteger() == 13478);
    delete script;
    delete obj;
    delete parameter;
    UserDataStorage::ClearTypes();
}


#endif