/*

** Copyright (C) 2020 SoftBank Robotics Europe

** See COPYING for the license

*/

#include <qipython/pyobject.hpp>

#include <qipython/common.hpp>

#include <qipython/pyguard.hpp>

#include <qipython/pyproperty.hpp>

#include <qipython/pysignal.hpp>

#include <qipython/pyfuture.hpp>

#include <pybind11/pybind11.h>

#include <pybind11/embed.h>

#include <gtest/gtest.h>

#include <gmock/gmock-matchers.h>

#include <gmock/gmock.h>

#include <boost/optional/optional_io.hpp>

#include "common.hpp"

namespace py = pybind11;

using namespace qi::py;

#define TEST_PYTHON_OBJECT_UID \

R"(b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14")"

namespace

{

constexpr const auto declareTypeAWithUid = R"py(

class A(object):

__qi_objectuid__ = )py" TEST_PYTHON_OBJECT_UID;

constexpr const std::array<std::uint8_t, 20> testUidData =

{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };

const auto testUid = *qi::deserializeObjectUid(testUidData);

}

struct ReadObjectUidTest : qi::py::test::Execute, testing::Test {};

TEST_F(ReadObjectUidTest, ReturnsEmptyIfAbsent)

{

GILAcquire lock;

const auto a = eval("object()");

auto objectUid = qi::py::detail::readObjectUid(a);

EXPECT_FALSE(objectUid);

}

TEST_F(ReadObjectUidTest, ReturnsValueIfPresent)

{

GILAcquire lock;

exec(declareTypeAWithUid);

auto a = eval("A()");

auto objectUid = qi::py::detail::readObjectUid(a);

ASSERT_TRUE(objectUid);

EXPECT_THAT(qi::serializeObjectUid<std::vector<std::uint8_t>>(*objectUid),

testing::ElementsAreArray(testUidData));

}

struct WriteObjectUidTest : qi::py::test::Execute, testing::Test

{

static constexpr const std::array<std::uint8_t, 20> data =

{ 10, 20, 30, 40, 50, 60, 70, 80, 90, 100,

110, 120, 130, 140, 150, 160, 170, 180, 190, 200 };

const qi::ObjectUid uid = *qi::deserializeObjectUid(data);

};

constexpr const std::array<std::uint8_t, 20> WriteObjectUidTest::data;

TEST_F(WriteObjectUidTest, CanBeReadAfterWritten)

{

GILAcquire lock;

exec(R"(

class A(object):

pass

)");

auto a = eval("A()");

qi::py::detail::writeObjectUid(a, uid);

auto uidRead = qi::py::detail::readObjectUid(a);

ASSERT_TRUE(uidRead);

EXPECT_EQ(uid, *uidRead);

}

TEST_F(WriteObjectUidTest, CanBeReadAfterOverwritten)

{

GILAcquire lock;

exec(declareTypeAWithUid);

auto a = eval("A()");

auto uidRead = qi::py::detail::readObjectUid(a);

EXPECT_TRUE(uidRead);

EXPECT_NE(uid, uidRead);

qi::py::detail::writeObjectUid(a, uid);

uidRead = qi::py::detail::readObjectUid(a);

ASSERT_TRUE(uidRead);

EXPECT_EQ(uid, *uidRead);

}

struct ToObjectTest : qi::py::test::Execute, testing::Test

{

ToObjectTest()

{

constexpr const auto declareType = R"py(

class Cookies(object):

def __init__(self, count=1):

self.count = count

self.__qi_objectuid__ = )py" TEST_PYTHON_OBJECT_UID R"py(

t = type(self)

t.prepare.__qi_signature__ = "([s])"

t.prepare.__qi_return_signature__ = "s"

t.must_not_be_bound.__qi_signature__ = "DONOTBIND"

t.unnamed.__qi_name__ = "do_nothing"

@staticmethod

def bake_instructions(temp, dura):

return "Your cookies must be baked at {} degrees for {} minutes." \

.format(temp, dura)

def bake(self, temp, dura):

return [(temp, dura) for i in range(self.count)]

def prepare_with(self, recipe, *ingredients):

return "To prepare {} cookies according to {} recipe, " \

"you need {} as ingredients.".format(self.count,

recipe,

", ".join(ingredients))

def prepare(self, ingredients):

return "Put {} in a bowl".format(", ".join(ingredients))

def must_not_be_bound(self):

pass

def unnamed(self):

return "This function does nothing."

)py";

exec(declareType);

}

template<typename... Args>

qi::AnyObject makeObject(Args&&... args)

{

GILAcquire lock;

const auto type = locals()["Cookies"];

return qi::py::toObject(type(std::forward<Args>(args)...));

}

};

TEST_F(ToObjectTest, StaticMethodCanBeCalled)

{

auto obj = makeObject();

const auto res = obj.call<std::string>("bake_instructions", 180, 20);

EXPECT_EQ("Your cookies must be baked at 180 degrees for 20 minutes.", res);

}

TEST_F(ToObjectTest, MemberMethodCanBeCalled)

{

auto obj = makeObject(12);

const auto res = obj.call<std::vector<std::pair<int, int>>>("bake", 180, 20);

const std::vector<std::pair<int, int>> expected(12, std::make_pair(180, 20));

EXPECT_EQ(expected, res);

}

TEST_F(ToObjectTest, MemberVariadicMethodCanBeCalled)

{

auto obj = makeObject(16);

const auto res =

obj.call<std::string>("prepare_with", "grandma's", "150g of wheat",

"100g of sugar", "2 eggs");

EXPECT_EQ(

"To prepare 16 cookies according to grandma's recipe, you need 150g of "

"wheat, 100g of sugar, 2 eggs as ingredients.",

res);

}

TEST_F(ToObjectTest, MethodWithExplicitSignature)

{

auto obj = makeObject();

const auto metaObj = obj.metaObject();

const auto methods = metaObj.findMethod("prepare");

ASSERT_EQ(1, methods.size());

const auto method = methods[0];

EXPECT_EQ(qi::Signature("([s])"), method.parametersSignature());

EXPECT_EQ(qi::Signature("s"), method.returnSignature());

}

TEST_F(ToObjectTest, MethodWithExplicitBindForbiddance)

{

auto obj = makeObject();

const auto metaObj = obj.metaObject();

const auto methods = metaObj.findMethod("must_not_be_bound");

ASSERT_TRUE(methods.empty());

}

TEST_F(ToObjectTest, MethodWithOverridenName)

{

auto obj = makeObject();

auto res = obj.call<std::string>("do_nothing");

EXPECT_EQ("This function does nothing.", res);

}

TEST_F(ToObjectTest, ObjectUidIsReused)

{

auto obj = makeObject();

EXPECT_EQ(testUid, obj.uid());

}

struct ObjectTest : testing::Test

{

void SetUp() override

{

object = boost::make_shared<Muffins>();

GILAcquire lock;

pyObject = qi::py::toPyObject(object);

ASSERT_TRUE(pyObject);

}

void TearDown() override

{

GILAcquire lock;

pyObject.release().dec_ref();

}

struct Muffins

{

std::string count(int i)

{

std::ostringstream oss;

oss << "You have " << i << " muffins.";

return oss.str();

}

qi::Property<int> bakedCount;

qi::Signal<int, std::string> baked;

};

qi::Object<Muffins> object;

py::object pyObject;

};

QI_REGISTER_OBJECT(ObjectTest::Muffins, count, bakedCount, baked)

TEST_F(ObjectTest, IsValid)

{

GILAcquire lock;

{

EXPECT_TRUE(py::bool_(pyObject));

EXPECT_TRUE(py::bool_(pyObject.attr("isValid")()));

}

{

const auto pyObject = qi::py::toPyObject(qi::py::Object{});

// It still returns a non null Python object.

ASSERT_TRUE(pyObject);

EXPECT_FALSE(py::bool_(pyObject));

EXPECT_FALSE(py::bool_(pyObject.attr("isValid")()));

}

}

TEST_F(ObjectTest, Call)

{

GILAcquire lock;

const auto res = pyObject.attr("call")("count", 832).cast<std::string>();

EXPECT_EQ("You have 832 muffins.", res);

}

TEST_F(ObjectTest, Async)

{

GILAcquire lock;

{

const auto res = qi::py::test::toFutOf<std::string>(

py::cast<qi::py::Future>(pyObject.attr("async")("count", 2356)));

GILRelease unlock;

ASSERT_TRUE(test::finishesWithValue(res));

EXPECT_EQ("You have 2356 muffins.", res.value());

}

{

const auto res = qi::py::test::toFutOf<std::string>(py::cast<qi::py::Future>(

pyObject.attr("call")("count", 32897, py::arg("_async") = true)));

GILRelease unlock;

ASSERT_TRUE(test::finishesWithValue(res));

EXPECT_EQ("You have 32897 muffins.", res.value());

}

}

using ToPyObjectTest = ObjectTest;

TEST_F(ToPyObjectTest, MethodCanBeCalled)

{

GILAcquire lock;

{

const auto res = pyObject.attr("count")(8).cast<std::string>();

EXPECT_EQ("You have 8 muffins.", res);

}

// Can also be called asynchronously.

{

const auto res = qi::py::test::toFutOf<std::string>(py::cast<qi::py::Future>(

pyObject.attr("count")(5, py::arg("_async") = true)));

GILRelease unlock;

ASSERT_TRUE(test::finishesWithValue(res));

EXPECT_EQ("You have 5 muffins.", res.value());

}

}

TEST_F(ToPyObjectTest, PropertyIsExposed)

{

GILAcquire lock;

const py::object prop = pyObject.attr("bakedCount");

EXPECT_TRUE(qi::py::isProperty(prop));

}

TEST_F(ToPyObjectTest, SignalIsExposed)

{

GILAcquire lock;

const py::object sig = pyObject.attr("baked");

EXPECT_TRUE(qi::py::isSignal(sig));

}

TEST_F(ToPyObjectTest, FutureAsObjectIsReturnedAsPyFuture)

{

GILAcquire lock;

const auto res = pyObject.attr("count")(8).cast<std::string>();

EXPECT_EQ("You have 8 muffins.", res);

}