#ifdef _WIN32
#include
#endif
#include "ffpython.h"
#define TestGuard(X, Y) printf("-------%s begin-----------\n", X);try {Y;}catch(std::exception& e_){printf("exception<%s>\n", e_.what());}\
printf("-------%s end-----------\n", X);
void test_base(ffpython_t& ffpython)
{
printf("sys.version=%s\n", ffpython.get_global_var<:string>("sys", "version").c_str());
ffpython.set_global_var("fftest", "global_var", "OhNice");
printf("fftest.global_var=%s\n", ffpython.get_global_var<:string>("fftest", "global_var").c_str());
printf("os.getcwd=%s\n", ffpython.call<:string>("os", "getcwd").c_str());
printf("time.asctime=%s\n", ffpython.call<:string>("time", "asctime").c_str());
int a1 = 100; float a2 = 3.14f; std::string a3 = "OhWell";
ffpython.call("fftest", "test_base", a1, a2, a3);
}
void test_stl(ffpython_t& ffpython)
{
std::vector a1;a1.push_back(100);a1.push_back(200);
std::list<:string> a2; a2.push_back("Oh");a2.push_back("Nice");
std::vector<:list> > a3;a3.push_back(a2);
ffpython.call("fftest", "test_stl", a1, a2, a3);
}
void test_return_stl(ffpython_t& ffpython)
{
typedef std::map<:string std::list> > > ret_t;
ret_t val = ffpython.call("fftest", "test_return_stl");
}
static int print_val(int a1, float a2, const std::string& a3, const std::vector& a4)
{
printf("%s[%d,%g,%s,%d]\n", __FUNCTION__, a1, a2, a3.c_str(), (int)a4.size());
return 0;
}
struct ops_t
{
static std::list return_stl()
{
std::list ret;ret.push_back(1024);
printf("%s\n", __FUNCTION__);
return ret;
}
};
void test_register_base_class(ffpython_t& ffpython)
{
ffpython.call("fftest", "test_register_base_class");
};
class foo_t
{
public:
foo_t(int v_) :m_value(v_)
{
printf("%s\n", __FUNCTION__);
}
virtual ~foo_t()
{
printf("%s\n", __FUNCTION__);
}
int get_value() const { return m_value; }
void set_value(int v_) { m_value = v_; }
void test_stl(std::map<:string std::list> >& v_)
{
printf("%s\n", __FUNCTION__);
}
int m_value;
};
class dumy_t : public foo_t
{
public:
dumy_t(int v_) :foo_t(v_)
{
printf("%s\n", __FUNCTION__);
}
~dumy_t()
{
printf("%s\n", __FUNCTION__);
}
void dump()
{
printf("%s\n", __FUNCTION__);
}
};
static foo_t* obj_test(dumy_t* p)
{
printf("%s\n", __FUNCTION__);
return p;
}
std::string test_reg_function(ffpython_t& ffpython)
{
ffpython.reg(&print_val, "print_val")
.reg(&ops_t::return_stl, "return_stl");
ffpython.reg_class("foo_t")
.reg(&foo_t::get_value, "get_value")
.reg(&foo_t::set_value, "set_value")
.reg(&foo_t::test_stl, "test_stl")
.reg_property(&foo_t::m_value, "m_value");
ffpython.reg_class("dumy_t", "dumy_t class inherit foo_t ctor ", "foo_t")
.reg(&dumy_t::dump, "dump");
ffpython.reg(obj_test, "obj_test");
return "cppext";
}
void test_register_inherit_class(ffpython_t& ffpython)
{
ffpython.call("fftest", "test_register_inherit_class");
};
void test_cpp_obj_to_py(ffpython_t& ffpython)
{
foo_t tmp_foo(2013);
std::vector vt;
vt.push_back(&tmp_foo);
ffpython.call("fftest", "test_cpp_obj_to_py", &tmp_foo);
printf("test_cpp_obj_to_py changed m_value=%d\n", tmp_foo.m_value);
ffpython.call("fftest", "test_cpp_obj_to_py_ext", vt);
}
void test_cpp_obj_py_obj(ffpython_t& ffpython)
{
dumy_t tmp_foo(2013);
//foo_t* p = ffpython.call("fftest", "test_cpp_obj_py_obj", &tmp_foo);
//p = NULL;
}
void test_py_class_lambda(ffpython_t& ffpython)
{
PyObject* pobj = ffpython.call("fftest", "test_cpp_obj_return_py_obj");
ffpython.obj_call(pobj, "sayHi", 1, std::string("soNice"));
PyObject* pFunc= ffpython.call("fftest", "test_cpp_obj_return_py_lambda");
ffpython.call_lambda(pFunc, 112233);
Py_XDECREF(pFunc);
Py_XDECREF(pobj);
}
int main(int argc, char* argv[])
{
try {
ffpython_t ffpython(&test_reg_function);
ffpython_t::add_path("./");
ffpython_t::add_path("../");
TestGuard("test_base", test_base(ffpython));
TestGuard("test_stl", test_stl(ffpython));
ffpython.call("fftest", "test_reg_function");
TestGuard("test_register_base_class", test_register_base_class(ffpython));
TestGuard("test_register_inherit_class", test_register_inherit_class(ffpython));
TestGuard("test_cpp_obj_to_py", test_cpp_obj_to_py(ffpython));return 0;
TestGuard("test_cpp_obj_py_obj", test_cpp_obj_py_obj(ffpython));
TestGuard("test_py_class_lambda", test_py_class_lambda(ffpython));
#ifdef _WIN32
system("pause");
#endif
Py_Finalize();
}
catch(std::exception& e) {
printf("exception<%s>\n", e.what());
}
printf("main exit...\n");
return 0;
}