added new test suite skel and sandboxed exec

Roberto De Ioris · Roberto De Ioris · commit 2d00e802960e · 2017-02-11T12:32:41.000+01:00
diff --git a/Source/UnrealEnginePython/Private/UEPyFVector.cpp b/Source/UnrealEnginePython/Private/UEPyFVector.cpp
@@ -267,10 +267,38 @@ static int ue_py_fvector_init(ue_PyFVector *self, PyObject *args, PyObject *kwar
 	return 0;
 }
 
+static PyObject *ue_py_fvector_richcompare(ue_PyFVector *vec1, PyObject *b, int op) {
+	ue_PyFVector *vec2 = py_ue_is_fvector(b);
+	if (!vec2 || (op != Py_EQ && op != Py_NE)) {
+		return PyErr_Format(PyExc_NotImplementedError, "can only compare with another FVector");
+	}
+
+	if (op == Py_EQ) {
+		if (vec1->vec.X == vec2->vec.X &&
+			vec1->vec.Y == vec2->vec.Y &&
+			vec1->vec.Z == vec2->vec.Z) {
+			Py_INCREF(Py_True);
+			return Py_True;
+		}
+		Py_INCREF(Py_False);
+		return Py_False;
+	}
+
+	if (vec1->vec.X == vec2->vec.X &&
+		vec1->vec.Y == vec2->vec.Y &&
+		vec1->vec.Z == vec2->vec.Z) {
+		Py_INCREF(Py_False);
+		return Py_False;
+	}
+	Py_INCREF(Py_True);
+	return Py_True;
+}
+
 void ue_python_init_fvector(PyObject *ue_module) {
 	ue_PyFVectorType.tp_new = PyType_GenericNew;
 
 	ue_PyFVectorType.tp_init = (initproc)ue_py_fvector_init;
+	ue_PyFVectorType.tp_richcompare = (richcmpfunc)ue_py_fvector_richcompare;
 
 	memset(&ue_PyFVector_number_methods, 0, sizeof(PyNumberMethods));
 	ue_PyFVectorType.tp_as_number = &ue_PyFVector_number_methods;
diff --git a/Source/UnrealEnginePython/Private/UEPyIPlugin.cpp b/Source/UnrealEnginePython/Private/UEPyIPlugin.cpp
@@ -226,7 +226,7 @@ static PyGetSetDef ue_PyIPlugin_getseters[] = {
 
 static PyObject *ue_PyIPlugin_str(ue_PyIPlugin *self)
 {
-	return PyUnicode_FromFormat("<unreal_engine.EdGraphPin {'name': '%s'}>",
+	return PyUnicode_FromFormat("<unreal_engine.IPlugin {'name': '%s'}>",
 		TCHAR_TO_UTF8(*self->plugin->GetName()));
 }
 
diff --git a/Source/UnrealEnginePython/Private/UEPyModule.cpp b/Source/UnrealEnginePython/Private/UEPyModule.cpp
@@ -92,6 +92,17 @@ static PyObject *py_unreal_engine_exec(PyObject * self, PyObject * args) {
 	return Py_None;
 }
 
+static PyObject *py_unreal_engine_sandbox_exec(PyObject * self, PyObject * args) {
+	char *filename = nullptr;
+	if (!PyArg_ParseTuple(args, "s:sandbox_exec", &filename)) {
+		return NULL;
+	}
+	FUnrealEnginePythonModule &PythonModule = FModuleManager::GetModuleChecked<FUnrealEnginePythonModule>("UnrealEnginePython");
+	PythonModule.RunFileSandboxed(filename);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
 static PyObject *py_ue_get_py_proxy(ue_PyUObject *self, PyObject * args) {
 
 	ue_py_check(self);
@@ -232,6 +243,8 @@ static PyMethodDef unreal_engine_methods[] = {
 #endif
 	{ "py_exec", py_unreal_engine_exec, METH_VARARGS, "" },
 
+	{ "sandbox_exec", py_unreal_engine_sandbox_exec, METH_VARARGS, "" },
+
 	{ "get_engine_defined_action_mappings", py_unreal_engine_get_engine_defined_action_mappings, METH_VARARGS, "" },
 
 	{ "get_viewport_screenshot", py_unreal_engine_get_viewport_screenshot, METH_VARARGS, "" },
diff --git a/Source/UnrealEnginePython/Private/UnrealEnginePython.cpp b/Source/UnrealEnginePython/Private/UnrealEnginePython.cpp
@@ -61,20 +61,7 @@ bool FUnrealEnginePythonModule::PythonGILAcquire() {
 	return true;
 }
 
-void FUnrealEnginePythonModule::StartupModule()
-{
-	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
-
-	Py_Initialize();
-#if PY_MAJOR_VERSION >= 3
-	wchar_t *argv[] = { UTF8_TO_TCHAR("UnrealEngine"), NULL };
-#else
-	char *argv[] = { (char *)"UnrealEngine", NULL };
-#endif
-	PySys_SetArgv(1, argv);
-
-	PyEval_InitThreads();
-
+static void UESetupPythonInterpeter(bool verbose) {
 	unreal_engine_init_py_module();
 
 	PyObject *py_sys = PyImport_ImportModule("sys");
@@ -90,9 +77,27 @@ void FUnrealEnginePythonModule::StartupModule()
 	PyObject *py_scripts_path = PyUnicode_FromString(scripts_path);
 	PyList_Insert(py_path, 0, py_scripts_path);
 
+	if (verbose) {
+		UE_LOG(LogPython, Log, TEXT("Python VM initialized: %s"), UTF8_TO_TCHAR(Py_GetVersion()));
+		UE_LOG(LogPython, Log, TEXT("Python Scripts search path: %s"), UTF8_TO_TCHAR(scripts_path));
+	}
+}
+
+void FUnrealEnginePythonModule::StartupModule()
+{
+	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
+
+	Py_Initialize();
+#if PY_MAJOR_VERSION >= 3
+	wchar_t *argv[] = { UTF8_TO_TCHAR("UnrealEngine"), NULL };
+#else
+	char *argv[] = { (char *)"UnrealEngine", NULL };
+#endif
+	PySys_SetArgv(1, argv);
 
-	UE_LOG(LogPython, Log, TEXT("Python VM initialized: %s"), UTF8_TO_TCHAR(Py_GetVersion()));
-	UE_LOG(LogPython, Log, TEXT("Python Scripts search path: %s"), UTF8_TO_TCHAR(scripts_path));
+	PyEval_InitThreads();
+
+	UESetupPythonInterpeter(true);
 
 	PyObject *main_module = PyImport_AddModule("__main__");
 	main_dict = PyModule_GetDict(main_module);
@@ -175,9 +180,78 @@ void FUnrealEnginePythonModule::RunFile(char *filename) {
 	if (!eval_ret) {
 		unreal_engine_py_log_error();
 		return;
+	}
+#endif
+
 }
+
+// run a python script in a new sub interpreter (useful for unit tests)
+void FUnrealEnginePythonModule::RunFileSandboxed(char *filename) {
+	FScopePythonGIL gil;
+	char *full_path = filename;
+	if (!FPaths::FileExists(filename))
+	{
+		full_path = TCHAR_TO_UTF8(*FPaths::Combine(*FPaths::GameContentDir(), UTF8_TO_TCHAR("Scripts"), *FString("/"), UTF8_TO_TCHAR(filename)));
+	}
+#if PY_MAJOR_VERSION >= 3
+	FILE *fd = nullptr;
+
+#if PLATFORM_WINDOWS
+	if (fopen_s(&fd, full_path, "r") != 0) {
+		UE_LOG(LogPython, Error, TEXT("Unable to open file %s"), UTF8_TO_TCHAR(full_path));
+		return;
+	}
+#else
+	fd = fopen(full_path, "r");
+	if (!fd) {
+		UE_LOG(LogPython, Error, TEXT("Unable to open file %s"), UTF8_TO_TCHAR(full_path));
+		return;
+	}
 #endif
 
+	PyThreadState *_main = PyThreadState_Get();
+
+	PyThreadState *py_new_state = Py_NewInterpreter();
+	if (!py_new_state) {
+		UE_LOG(LogPython, Error, TEXT("Unable to create new Python interpreter"));
+		return;
+	}
+	PyThreadState_Swap(nullptr);
+	PyThreadState_Swap(py_new_state);
+
+	UESetupPythonInterpeter(false);
+
+	PyObject *m = PyImport_AddModule("__main__");
+	if (m == NULL) {
+		UE_LOG(LogPython, Error, TEXT("Unable to create new global dict"));
+		Py_EndInterpreter(py_new_state);
+		PyThreadState_Swap(_main);
+		return;
+	}
+	PyObject *global_dict = PyModule_GetDict(m);
+
+	PyObject *eval_ret = PyRun_File(fd, full_path, Py_file_input, global_dict, global_dict);
+	fclose(fd);
+	if (!eval_ret) {
+		unreal_engine_py_log_error();
+		Py_EndInterpreter(py_new_state);
+		PyThreadState_Swap(_main);
+		return;
+	}
+	Py_DECREF(eval_ret);
+#else
+	// damn, this is horrible, but it is the only way i found to avoid the CRT error :(
+	FString command = FString::Printf(TEXT("execfile(\"%s\")"), UTF8_TO_TCHAR(full_path));
+	PyObject *eval_ret = PyRun_String(TCHAR_TO_UTF8(*command), Py_file_input, global_dict, global_dict);
+	if (!eval_ret) {
+		unreal_engine_py_log_error();
+		Py_EndInterpreter(py_new_state);
+		PyThreadState_Swap(_main);
+		return;
+	}
+#endif
+	Py_EndInterpreter(py_new_state);
+	PyThreadState_Swap(_main);
 }
 
 #undef LOCTEXT_NAMESPACE
diff --git a/Source/UnrealEnginePython/Public/UnrealEnginePython.h b/Source/UnrealEnginePython/Public/UnrealEnginePython.h
@@ -19,6 +19,7 @@ class UNREALENGINEPYTHON_API FUnrealEnginePythonModule : public IModuleInterface
 
 	void RunString(char *);
 	void RunFile(char *);
+	void RunFileSandboxed(char *);
 
 private:
 	void *ue_python_gil;
diff --git a/TestingActor.uasset b/TestingActor.uasset
diff --git a/run_tests.py b/run_tests.py
@@ -0,0 +1,26 @@
+import sys
+import unittest
+import unreal_engine as ue
+import os.path
+
+# ue.sandbox_exec(ue.find_plugin('UnrealEnginePython').get_base_dir() + '/run_tests.py')
+
+# setup classic stdout/stderr
+class UnrealEngineOutput:
+    def __init__(self, logger):
+        self.logger = logger
+    def write(self, buf):
+        self.logger(buf)
+    def flush(self):
+        return
+
+sys.stdout = UnrealEngineOutput(ue.log)
+sys.stderr = UnrealEngineOutput(ue.log_error)
+
+uep_base = ue.find_plugin('UnrealEnginePython').get_base_dir()
+
+loader = unittest.TestLoader()
+tests = loader.discover(os.path.join(uep_base, 'tests'))
+
+runner = unittest.runner.TextTestRunner()
+runner.run(tests)
diff --git a/tests.py b/tests.py
diff --git a/tests/__init__.py b/tests/__init__.py
diff --git a/tests/test_transform.py b/tests/test_transform.py
@@ -0,0 +1,19 @@
+import unittest
+import unreal_engine as ue
+from unreal_engine import FVector, FRotator
+
+class TestVector(unittest.TestCase):
+
+    def test_add(self):
+        vector0 = FVector(1, 2, 3)
+        vector1 = FVector(4, 5, 6)
+        self.assertEqual( vector0 + vector1, FVector(5, 7, 9))
+
+    def test_add_negative(self):
+        vector0 = FVector(1, 2, 3)
+        vector1 = FVector(-4, -5, -6)
+        self.assertEqual( vector0 + vector1, FVector(-3, -3, -3))
+
+    def test_scale(self):
+        vector0 = FVector(1, 2, -3)
+        self.assertEqual( vector0 * 2, FVector(2, 4, -6))

Original file line number	Diff line number	Diff line change
`@@ -226,7 +226,7 @@ static PyGetSetDef ue_PyIPlugin_getseters[] = {`
`226`	`226`
`227`	`227`	`static PyObject ue_PyIPlugin_str(ue_PyIPlugin self)`
`228`	`228`	`{`
`229`		`- return PyUnicode_FromFormat("<unreal_engine.EdGraphPin {'name': '%s'}>",`
	`229`	`+ return PyUnicode_FromFormat("<unreal_engine.IPlugin {'name': '%s'}>",`
`230`	`230`	`TCHAR_TO_UTF8(*self->plugin->GetName()));`
`231`	`231`	`}`
`232`	`232`