✨ feat(TSG-11870): 修改测试用例

22 files changed, 919 insertions, 2372 deletions

diff --git a/gtest/CMakeLists.txt b/gtest/CMakeLists.txt
index 2a1aad1..466ad53 100644
--- a/gtest/CMakeLists.txt
+++ b/gtest/CMakeLists.txt
@@ -1,10 +1,24 @@
 cmake_minimum_required(VERSION 2.6)
-project(gtest_tsg_lua)
-aux_source_directory(. SRCS)
+project(gtest_elua)
+# aux_source_directory(. SRCS)
+file(GLOB SRCS
+	"gtest_lua_remove_cmd.cpp"
+	"gtest_lua_timeout.cpp"
+	"gtest_tsg_destroy_lua.cpp"
+	"gtest_tsg_lua_cache_exec.cpp"
+	"gtest_tsg_lua_cache_script_bytecode_file.cpp"
+	"gtest_tsg_lua_cache_script_file.cpp"
+	"gtest_tsg_lua_cache_script.cpp"
+	"gtest_tsg_lua_register_function.cpp"
+	"gtest_tsg_lua_uncache_script.cpp"
+	"gtest_tsg_lua_vm_create.cpp"
+	"gtest_tsg_lua_exec_with_context.cpp"
+	"gtest_get_weixinnum.cpp"
+)
+
 
 include_directories("../src")
 include_directories("${CMAKE_BINARY_DIR}/support/GoogleTest/include/")
-#link_directories("/opt/MESA/lib")
 link_directories("${CMAKE_BINARY_DIR}/src/")
 link_directories("${CMAKE_BINARY_DIR}/support/GoogleTest/lib/")
 link_directories("${CMAKE_BINARY_DIR}/support/luajit2/src/luajit2/src/")
@@ -12,16 +26,16 @@ link_directories("${CMAKE_BINARY_DIR}/support/luajit2/src/luajit2/src/")
 #link_libraries(libluajit.a tsglua gtest gtest_main pthread)
 
 add_definitions(-g -W -Wall)
-add_executable(gtest_tsg_lua ${SRCS})
+add_executable(gtest_elua ${SRCS})
 if (BUILD_STATIC_LIB)
-	add_dependencies(gtest_tsg_lua ${lib_name}_static gtest)
-	target_link_libraries(gtest_tsg_lua ${lib_name}_static gtest gtest_main pthread)
+	add_dependencies(gtest_elua ${lib_name}_static gtest)
+	target_link_libraries(gtest_elua ${lib_name}_static gtest gtest_main pthread)
 else()
-	add_dependencies(gtest_tsg_lua ${lib_name}_shared gtest)
-	target_link_libraries(gtest_tsg_lua ${lib_name}_shared gtest gtest_main pthread)
+	add_dependencies(gtest_elua ${lib_name}_shared gtest)
+	target_link_libraries(gtest_elua ${lib_name}_shared gtest gtest_main pthread)
 endif()
-#target_link_libraries(gtest_tsg_lua tsglua gtest gtest_main pthread)
+#target_link_libraries(gtest_elua tsglua gtest gtest_main pthread)
 
 add_test(NAME SOFT_LINK COMMAND sh -c "ln -sf ${CMAKE_CURRENT_SOURCE_DIR}/script" "${CMAKE_CURRENT_BINARY_DIR}/script")
-add_test(NAME LUA_TEST COMMAND gtest_tsg_lua)
+add_test(NAME LUA_TEST COMMAND gtest_elua)
 
diff --git a/gtest/gtest_get_weixinnum.cpp b/gtest/gtest_get_weixinnum.cpp
index 1be9be2..630fa78 100644
--- a/gtest/gtest_get_weixinnum.cpp
+++ b/gtest/gtest_get_weixinnum.cpp
@@ -1,5 +1,5 @@
 #include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
+#include "elua.h"
 
 static char *get_file_to_buffer(const char *file, int *len)
 {
@@ -29,91 +29,51 @@ static char *get_file_to_buffer(const char *file, int *len)
     return NULL;
 }
 
-TEST(tsg_lua_get_weixinnum, exec_cache_script)
+TEST(elua_get_weixinnum, exec_cache_script)
 {
-	tsg_lua_handle L = NULL;
+	elua_vm *L = NULL;
     int script_len;
     int data_len;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    memset(out, 0, 255);
+    
+    char buff[1024];
+    struct elua_data output;
+    output.len = 1024;
+    output.type = STRING;
+    output.string = buff; 
 
-	L = tsg_lua_vm_create();
+	L = elua_create_vm(NULL);
 	const char *script = get_file_to_buffer("./script/handle_weixinnum.lua", &script_len);
-	int script_id = tsg_lua_cache_script(L, script, script_len);
+	struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
 	const char *data = get_file_to_buffer("./script/weixin_id_ios_20200423_004.pcap", &data_len);
-	int ret = tsg_lua_cache_exec(L, script_id, data, data_len, out, &out_len, &out_type);
+	int ret = elua_execute_script(escript, data, data_len, NULL, NULL, &output);
     free((void *)data);
     free((void *)script);
 
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(10, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("1955740780", out);
+    EXPECT_EQ(10, output.len);
+    EXPECT_EQ(STRING, output.type);
+    EXPECT_STREQ("1955740780", output.string);
 }
 
-TEST(tsg_lua_get_weixinnum, exec_cache_file)
+TEST(elua_get_weixinnum, exec_cache_script_file)
 {
-	tsg_lua_handle L = NULL;
+	elua_vm *L = NULL;
     int data_len;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    memset(out, 0, 255);
-	L = tsg_lua_vm_create();
-	int script_id = tsg_lua_cache_script_file(L, "./script/handle_weixinnum.lua");
-	const char *data = get_file_to_buffer("./script/weixin_id_ios_20200423_004.pcap", &data_len);
-	int ret = tsg_lua_cache_exec(L, script_id, data, data_len, out, &out_len, &out_type);
-    free((void *)data);
-
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(10, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("1955740780", out);
-}
-
-TEST(tsg_lua_get_weixinnum, exec_script)
-{
-	tsg_lua_handle L = NULL;
-    int script_len;
-    int data_len;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    memset(out, 0, 255);
-	L = tsg_lua_vm_create();
-	const char *script = get_file_to_buffer("./script/handle_weixinnum.lua", &script_len);
-	const char *data = get_file_to_buffer("./script/weixin_id_ios_20200423_004.pcap", &data_len);
-	int ret = tsg_lua_exec(L, script, script_len, data, data_len, out, &out_len, &out_type);
-    free((void *)data);
-    free((void *)script);
-
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(10, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("1955740780", out);
-}
-
-TEST(tsg_lua_get_weixinnum, exec_file)
-{
-	tsg_lua_handle L = NULL;
-    int data_len;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    memset(out, 0, 255);
-	L = tsg_lua_vm_create();
-	const char *script = "./script/handle_weixinnum.lua";
+    
+    char buff[1024];
+    memset(buff, 0, 255);
+    struct elua_data output;
+    output.len = 1024;
+    output.type = STRING;
+    output.string = buff;
+	L = elua_create_vm(NULL);
+	struct elua_script *escript = elua_cache_script_file(L, "./script/handle_weixinnum.lua", 0);
 	const char *data = get_file_to_buffer("./script/weixin_id_ios_20200423_004.pcap", &data_len);
-	int ret = tsg_lua_exec_file(L, script, data, data_len, out, &out_len, &out_type);
+	int ret = elua_execute_script(escript, data, data_len, NULL, NULL, &output);
     free((void *)data);
 
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(10, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("1955740780", out);
+    EXPECT_EQ(10, output.len);
+    EXPECT_EQ(STRING, output.type);
+    EXPECT_STREQ("1955740780", output.string);
 }
\ No newline at end of file
diff --git a/gtest/gtest_lua_remove_cmd.cpp b/gtest/gtest_lua_remove_cmd.cpp
index df0c5f1..2cc28df 100644
--- a/gtest/gtest_lua_remove_cmd.cpp
+++ b/gtest/gtest_lua_remove_cmd.cpp
@@ -1,17 +1,22 @@
 #include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
+#include "elua.h"
 
 TEST(lua_remove_cmd, normal)
 {
-	tsg_lua_handle L = tsg_lua_vm_create_with_name("TEST");
+	elua_vm *L = elua_create_vm(NULL);
 	ASSERT_TRUE(L);
+	char buff[1024];
+	elua_data out;
+	out.type = STRING;
+	out.integer = 1024;
+	out.string = buff;
 
-	lua_remove_cmd(L, "print");
+	elua_remove_function(L, "print");
 
-	char out[1204];
-	size_t len = 1024;
-	size_t type = STRING;
-	int ret = tsg_lua_exec_file(L, "./script/remove_print.lua", "remove print", strlen("remove print"), out, &len, &type);
-	EXPECT_EQ(ret, ERR_SCRIPT_EXEC_ERROR);
-	
+	struct elua_script *escript = elua_cache_script_file(L, "./script/remove_print.lua", 0);
+	int ret = elua_execute_script(escript, "remove print", strlen("remove print"), NULL, NULL, &out);
+	EXPECT_EQ(ret, -1);
+
+	const char *errmsg = "[elua_call_script:1074] [string \"./script/remove_print.lua\"]:3: attempt to call global \'print\' (a nil value).";
+	EXPECT_STREQ(elua_get_last_error_string(L), errmsg);
 }
\ No newline at end of file
diff --git a/gtest/gtest_lua_timeout.cpp b/gtest/gtest_lua_timeout.cpp
index 88dcd78..a5ecf9c 100644
--- a/gtest/gtest_lua_timeout.cpp
+++ b/gtest/gtest_lua_timeout.cpp
@@ -1,6 +1,6 @@
 #include <gtest/gtest.h>
 #include <time.h>
-#include "tsg_lua_interface.h"
+#include "elua.h"
 
 static long mstime()
 {
@@ -9,7 +9,7 @@ static long mstime()
     return now.tv_sec * 1000 + now.tv_nsec/1000000;
 }
 
-static int count_set(tsg_lua_handle L)
+static int count_set(elua_vm *L)
 {
 	int num = 0;
 	for (int i = 0; i < 10000; i++)
@@ -19,91 +19,106 @@ static int count_set(tsg_lua_handle L)
 			num++;
 		}
 	}
-	int *count = (int *)lua_get_userdata(L);
+	int *count = (int *)elua_get_execute_userdata(L);
 	*count = num;
 	return 0;
 }
 
-TEST(lua_time_out, lua)
+TEST(elua_time_out, lua)
 {
-	tsg_lua_handle L = tsg_lua_vm_create_with_name("TEST");
+	elua_vm *L = elua_create_vm("TEST");
 	
 	const char *ud = "hello world.";
-    	const char *script = "./script/lua_time_out.lua";
-	lua_data_t in;
-	in.data = (char *)"This is a test";
-	in.len = strlen(in.data);
-	lua_arg_t out;
+    	const char *script = "./script/elua_time_out.lua";
+	
+	char *buff= (char *)"This is a test";
+	int  len = strlen(buff);
+	elua_data out;
 	out.type = STRING;
-	out.len = 1024;
-	out.str = (char *)calloc(1, 1024);
+	out.integer = 1024;
+	out.string = (char *)calloc(1, 1024);
 	long tt, elapsed;
+	int ret = 0;
+
+	struct elua_script *escript = elua_cache_script_file(L, script, 10);
 
-	int ret = lua_exec_file(L, script, in, (void *)ud, NULL, 10, &out);
-	EXPECT_EQ(ERR_SCRIPT_TIMEOUT, ret);
-	bzero(out.str, 1024);
+	ret = elua_execute_script(escript, buff, len, (void *)ud, NULL, &out);
+	EXPECT_EQ(ret, -1);
+	EXPECT_STREQ(elua_get_last_error_string(L), "[elua_call_script:1074] Lua script killed by time out..");
+	bzero(out.string, 1024);
 
+	struct elua_script *escript0 = elua_cache_script_file(L, script, 0);
 	tt = mstime();
-	ret = lua_exec_file(L, script, in, (void *)ud, NULL, 0, &out);
+	ret = elua_execute_script(escript0, buff, len, (void *)ud, NULL, &out);
 	elapsed = mstime() - tt;
 	EXPECT_EQ(0, ret);
 	EXPECT_LE(10, elapsed);
-	EXPECT_EQ(in.len, out.len);
+	EXPECT_EQ(len, out.len);
 	EXPECT_EQ(STRING, out.type);
-	EXPECT_STREQ(in.data, out.str);
-	bzero(out.str, 1024);
+	EXPECT_STREQ(buff, out.string);
+	bzero(out.string, 1024);
 
-	ret = lua_exec_file(L, script, in, (void *)ud, NULL, 10, &out);
-	EXPECT_EQ(ERR_SCRIPT_TIMEOUT, ret);
-	bzero(out.str, 1024);
+	ret = elua_execute_script(escript, buff, len, (void *)ud, NULL, &out);
+	EXPECT_EQ(ret, -1);
+	EXPECT_STREQ(elua_get_last_error_string(L), "[elua_call_script:1074] Lua script killed by time out..");
+	bzero(out.string, 1024);
 
-	tsg_destory_lua(L);
-	free(out.str);
+	elua_cleanup_script(escript);
+	elua_cleanup_script(escript0);
+	elua_destroy_vm(L);
+	free(out.string);
 }
 
-TEST(lua_time_out, c)
+TEST(elua_time_out, c)
 {
-	tsg_lua_handle L = tsg_lua_vm_create_with_name("TEST");
+	elua_vm *L = elua_create_vm("TEST");
 	
 	int count = 10;
     	const char *script = "./script/c_time_out.lua";
-	lua_data_t in;
-	in.data = (char *)"This is a test";
-	in.len = strlen(in.data);
-	lua_arg_t out;
+	
+	char *buff= (char *)"This is a test";
+	int  len = strlen(buff);
+	
+	struct elua_data out;
 	out.type = STRING;
-	out.len = 1024;
-	out.str = (char *)calloc(1, 1024);
+	out.integer = 1024;
+	out.string = (char *)calloc(1, 1024);
 	long tt, elapsed;
 
-	lua_register_function(L, NULL, "set_count", count_set);
+	elua_register_cbinding(L, NULL, "set_count", count_set);
+	struct elua_script *escript = elua_cache_script_file(L, script, 10);
 	tt = mstime();
-	int ret = lua_exec_file(L, script, in, (void *)&count, NULL, 10, &out);
+	int ret = elua_execute_script(escript, buff, len, (void *)&count, NULL, &out);
 	elapsed = mstime() - tt;
-	EXPECT_EQ(ERR_SCRIPT_TIMEOUT, ret);
+	EXPECT_EQ(-1, ret);
+	EXPECT_STREQ(elua_get_last_error_string(L), "[elua_call_script:1074] Lua script killed by time out..");
 	EXPECT_LE(10, elapsed);
 	EXPECT_EQ(10000000, count);
-	bzero(out.str, 1024);
+	bzero(out.string, 1024);
 
+	struct elua_script *escript0 = elua_cache_script_file(L, script, 0);
 	tt = mstime();
-	ret = lua_exec_file(L, script, in, (void *)&count, NULL, 0, &out);
+	ret = elua_execute_script(escript0, buff, len, (void *)&count, NULL, &out);
 	elapsed = mstime() - tt;
 	EXPECT_EQ(0, ret);
 	EXPECT_LE(10, elapsed);
-	EXPECT_EQ(in.len, out.len);
+	EXPECT_EQ(len, out.len);
 	EXPECT_EQ(STRING, out.type);
-	EXPECT_STREQ(in.data, out.str);
+	EXPECT_STREQ(buff, out.string);
 	EXPECT_EQ(10000000, count);
-	bzero(out.str, 1024);
+	bzero(out.string, 1024);
 
 	tt = mstime();
-	ret = lua_exec_file(L, script, in, (void *)&count, NULL, 10, &out);
+	ret = elua_execute_script(escript, buff, len, (void *)&count, NULL, &out);
 	elapsed = mstime() - tt;
-	EXPECT_EQ(ERR_SCRIPT_TIMEOUT, ret);
+	EXPECT_EQ(-1, ret);
+	EXPECT_STREQ(elua_get_last_error_string(L), "[elua_call_script:1074] Lua script killed by time out..");
 	EXPECT_LE(10, elapsed);
 	EXPECT_EQ(10000000, count);
-	bzero(out.str, 1024);
+	bzero(out.string, 1024);
 
-	tsg_destory_lua(L);
-	free(out.str);
+	elua_cleanup_script(escript0);
+	elua_cleanup_script(escript);
+	elua_destroy_vm(L);
+	free(out.string);
 }
\ No newline at end of file
diff --git a/gtest/gtest_tsg_destory_lua.cpp b/gtest/gtest_tsg_destory_lua.cpp
index 026e497..027cfa0 100644
--- a/gtest/gtest_tsg_destory_lua.cpp
+++ b/gtest/gtest_tsg_destory_lua.cpp
@@ -1,26 +1,27 @@
 /*************************************************************************
-    > File Name: gtest_tsg_lua_vm_create.cpp
+    > File Name: gtest_elua_create_vm.cpp
     > Author: pxz
     > Created Time: Sun 19 Jul 2020 01:27:13 PM CST
  ************************************************************************/
 #include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
+#include "elua.h"
 
-/* tsg_destory_lua */
-TEST(tsg_destory_lua, normal)
+/* elua_destroy_vm */
+TEST(elua_destroy_vm, normal)
 {
-    tsg_lua_handle L = NULL;
-    L = tsg_lua_vm_create();
-    int ret = tsg_destory_lua(L);
+    elua_vm *L = NULL;
+    L = elua_create_vm(NULL);
+    int ret = elua_destroy_vm(L);
 
     EXPECT_EQ(0, ret);
 }
 
-TEST(tsg_destory_lua, lua_vm_isnull)
+TEST(elua_destroy_vm, lua_vm_isnull)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    int ret = tsg_destory_lua(L);
+    int ret = elua_destroy_vm(L);
 
-    EXPECT_EQ(ERR_LUAVM_ISNULL, ret);
+    EXPECT_EQ(-1, ret);
+    EXPECT_STREQ(elua_get_last_error_string(L), "The vm is invalid.");
 }
diff --git a/gtest/gtest_tsg_lua_cache_exec.cpp b/gtest/gtest_tsg_lua_cache_exec.cpp
index 9907fc5..ed1099c 100644
--- a/gtest/gtest_tsg_lua_cache_exec.cpp
+++ b/gtest/gtest_tsg_lua_cache_exec.cpp
@@ -1,328 +1,298 @@
 /*************************************************************************
-    > File Name: gtest_tsg_lua_cache_exec.cpp
+    > File Name: gtest_elua_execute_script.cpp
     > Author: pxz
     > Created Time: Sun 19 Jul 2020 01:28:20 PM CST
  ************************************************************************/
 #include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
+#include "elua.h"
 static const char *data = "hello world";
 
-/* tsg_lua_cache_exec */
-TEST(tsg_lua_cache_exec, normal_return_string)
+/* elua_execute_script */
+TEST(elua_execute_script, normal_return_string)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_string_normal.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
+     
+    int len = strlen(data);
+    struct elua_data out;
+    char buff[1024];
+    out.type = STRING;
+    out.integer = 1204;
+    out.string = buff;
+
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+    int ret = elua_execute_script(escript, data, len, NULL, NULL, &out);
     
     /* check */
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(11, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("hello world", out);
+    EXPECT_EQ(11, out.len);
+    EXPECT_EQ(STRING, out.type);
+    EXPECT_STREQ("hello world", out.string);
 }
 
-TEST(tsg_lua_cache_exec, normal_return_boolean)
+TEST(elua_execute_script, normal_return_boolean)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = BOOLEAN;
-    L = tsg_lua_vm_create();
+    elua_vm *L = NULL;
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_boolean_normal.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
+     
+    struct elua_data out;
+
+    char *buff = (char *)data;
+    int len = strlen(data);
+    out.type = BOOLEAN;
+
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+    int ret = elua_execute_script(escript, buff, len, NULL, NULL, &out);
     
     /* check */
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(1, out_len);
-    EXPECT_EQ(BOOLEAN, out_type);
-    EXPECT_EQ(true, out[0]);
+    EXPECT_EQ(4, out.len);
+    EXPECT_EQ(BOOLEAN, out.type);
+    EXPECT_EQ(true, out.true_or_false);
 }
 
-TEST(tsg_lua_cache_exec, normal_return_integer)
+TEST(elua_execute_script, normal_return_integer)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = INTEGER;
-    L = tsg_lua_vm_create();
+    elua_vm *L = NULL;
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_integer_normal.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
+     
+    struct elua_data out;
+
+    char *buff = (char *)data;
+    int len = strlen(data);
+    out.type = INTEGER;
+
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+    int ret = elua_execute_script(escript, buff, len, NULL, NULL, &out);
     
     /* check */
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(8, out_len);
-    EXPECT_EQ(INTEGER, out_type);
-    EXPECT_EQ(7, *(long int *)out);
+    EXPECT_EQ(8, out.len);
+    EXPECT_EQ(INTEGER, out.type);
+    EXPECT_EQ(7, out.integer);
 }
 
-TEST(tsg_lua_cache_exec, lua_vm_isnull)
+TEST(elua_execute_script, lua_vm_isnull)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    elua_vm *L = NULL;
     
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_string_normal.lua";
-    memset(out, 0, sizeof(out));
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     L = NULL;
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
+     
+    struct elua_data out;
+
+    char *buff = (char *)data;
+    int len = strlen(data);
+    out.type = INTEGER;
     
+    int ret = elua_execute_script(escript, buff, len, NULL, NULL, &out);
     /* check */
-    EXPECT_EQ(ERR_LUAVM_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
+    EXPECT_EQ(-1, ret);
+    EXPECT_STREQ("The vm is invalid.", elua_get_last_error_string(L));
 }
 
-TEST(tsg_lua_cache_exec, script_id_invaild)
+TEST(elua_execute_script, script_id_invaild)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    L = tsg_lua_vm_create();
-    memset(out, 0, 255);
-    int script_id = 0;
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
+    elua_vm *L = NULL;
+    L = elua_create_vm(NULL);
+    struct elua_script *escript = 0;
+     
+    struct elua_data out;
+
+    char *buff = (char *)data;
+    int len = strlen(data);
+    out.type = INTEGER;
+    int ret = elua_execute_script(escript, buff, len, NULL, NULL, &out);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_ID_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
+    EXPECT_EQ(-1, ret);
+    EXPECT_STREQ(elua_get_last_error_string(L), "");
 }
 
-TEST(tsg_lua_cache_exec, input_isnull)
+TEST(elua_execute_script, input_isnull)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    char *input = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_string_normal.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, input, strlen(data), out, &out_len, &out_type);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+    struct elua_data out;
+    out.type = INTEGER;
+    int ret = elua_execute_script(escript, NULL, strlen(data), NULL, NULL, &out);
     
     /* check */
-    EXPECT_EQ(ERR_INPUT_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
+    EXPECT_EQ(-1, ret);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_execute_script:1168] input or input_len is invaild.");
 }
 
-TEST(tsg_lua_cache_exec, in_len_invaild)
+TEST(elua_execute_script, in_len_invaild)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_string_normal.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, data, 0, out, &out_len, &out_type);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+
+     
+    struct elua_data out;
+
+    char *buff = (char *)data;
+    int len = 0;
+    out.type = INTEGER;
+    int ret = elua_execute_script(escript, buff, len, NULL, NULL, &out);
     
     /* check */
-    EXPECT_EQ(ERR_IN_LEN_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
+    EXPECT_EQ(-1, ret);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_execute_script:1168] input or input_len is invaild.");
 }
 
-TEST(tsg_lua_cache_exec, string_expected_but_nil)
+TEST(elua_execute_script, string_expected_but_nil)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/string_expected_but_nil.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+
+     
+    struct elua_data out;
+
+    char *buff = (char *)data;
+    int len = strlen(data);
+    out.type = INTEGER;
+    int ret = elua_execute_script(escript, buff, len, NULL, NULL, &out);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_NIL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
+    EXPECT_EQ(-1, ret);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_call_script:1074] [string \"./script/string_expected_but_nil.lua\"]:1: bad argument #1 to 'len' (string expected, got nil).");
 }
 
-TEST(tsg_lua_cache_exec, string_expected_but_boolean)
+TEST(elua_execute_script, string_expected_but_boolean)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/string_expected_but_boolean.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+     
+    struct elua_data out;
+
+    char *buff = (char *)data;
+    int len = strlen(data);
+    out.type = INTEGER;
+    int ret = elua_execute_script(escript, buff, len, NULL, NULL, &out);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_BOOL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
+    EXPECT_EQ(-1, ret);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_call_script:1074] [string \"./script/string_expected_but_boolean.lua\"]:2: bad argument #1 to 'len' (string expected, got boolean).");
 }
 
-TEST(tsg_lua_cache_exec, call_global_but_nil)
+TEST(elua_execute_script, call_global_but_nil)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/call_global_but_nil.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+     
+    struct elua_data out;
+
+    char *buff = (char *)data;
+    int len = strlen(data);
+    out.type = INTEGER;
+    int ret = elua_execute_script(escript, buff, len, NULL, NULL, &out);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_CALL_GLOBAL_BUT_NIL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
+    EXPECT_EQ(-1, ret);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_call_script:1074] [string \"./script/call_global_but_nil.lua\"]:1: attempt to call global 'tablefunc' (a nil value).");
 }
 
 
-// TEST(tsg_lua_cache_exec, return_too_few)
-// {
-//     tsg_lua_handle L = NULL;
-//     char out[255];
-//     size_t out_len = 0;
-//     size_t out_type = STRING;
-
-//     L = tsg_lua_vm_create();
-//     const char *script = "./script/return_too_few.lua";
-//     memset(out, 0, 255);
-//     int script_id = tsg_lua_cache_script_file(L, script);
-//     int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
-    
-//     /* check */
-//     EXPECT_EQ(ERR_SCRIPT_RETURN_TOO_FEW, ret);
-//     EXPECT_EQ(0, out_len);
-//     EXPECT_EQ(STRING, out_type);
-//     EXPECT_STREQ("", out);
-// }
-
-TEST(tsg_lua_cache_exec, return_too_much)
+TEST(elua_execute_script, return_too_much)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_too_much.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RETURN_TOO_MUCH, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+     
+    struct elua_data out;
 
-TEST(tsg_lua_cache_exec, return_type_nil)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_type_invaild.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
+    char *buff = (char *)data;
+    int len = strlen(data);
+    out.type = INTEGER;
+    int ret = elua_execute_script(escript, buff, len, NULL, NULL, &out);
     
     /* check */
-    EXPECT_EQ(ERR_RETUNR_NIL, ret);
-    EXPECT_EQ(5, out_len);
-    EXPECT_EQ(NIL, out_type);
-    EXPECT_STREQ("", out);
+    EXPECT_EQ(-1, ret);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_vm_return_value:1107] the script return too many values, the num of value is 3, 5.");
 }
 
-TEST(tsg_lua_cache_exec, return_length_iszero)
+TEST(elua_execute_script, return_length_iszero)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_length_iszero.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+     
+    struct elua_data out;
+
+    char *buff = (char *)data;
+    int len = strlen(data);
+    out.type = INTEGER;
+    int ret = elua_execute_script(escript, buff, len, NULL, NULL, &out);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_RETURN_LEN_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
+    EXPECT_EQ(-1, ret);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_vm_return_value:1101] script out_len is 0.");
 }
 
-TEST(tsg_lua_cache_exec, string_expected_but_table)
+TEST(elua_execute_script, string_expected_but_table)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/string_expected_but_table.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+     
+    struct elua_data out;
+
+    char *buff = (char *)data;
+    int len = strlen(data);
+    out.type = INTEGER;
+    int ret = elua_execute_script(escript, buff, len, NULL, NULL, &out);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_TABLE, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
+    EXPECT_EQ(-1, ret);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_call_script:1074] [string \"./script/string_expected_but_table.lua\"]:2: bad argument #1 to 'len' (string expected, got table).");
 }
 
-TEST(tsg_lua_cache_exec, normal_return_string_sharp)
+TEST(elua_execute_script, normal_return_string_sharp)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_string_normal_sharp.lua";
-    memset(out, 0, 255);
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_cache_exec(L, script_id, data, strlen(data), out, &out_len, &out_type);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+     
+    struct elua_data out;
+    out.type = STRING;
+    out.len = 1024;
+    char buff[1024];
+    out.string = buff;
+
+    int len = strlen(data);
+    int ret = elua_execute_script(escript, data, len, NULL, NULL, &out);
     
     /* check */
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(11, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("hello world", out);
+    EXPECT_EQ(len, out.len);
+    EXPECT_STREQ(data, out.string);
 }
\ No newline at end of file
diff --git a/gtest/gtest_tsg_lua_cache_script.cpp b/gtest/gtest_tsg_lua_cache_script.cpp
index ae3590e..d8b7204 100644
--- a/gtest/gtest_tsg_lua_cache_script.cpp
+++ b/gtest/gtest_tsg_lua_cache_script.cpp
@@ -1,10 +1,10 @@
 /*************************************************************************
-    > File Name: gtest_tsg_lua_cache_script.cpp
+    > File Name: gtest_elua_cache_script.cpp
     > Author: pxz
     > Created Time: Sun 19 Jul 2020 01:28:20 PM CST
  ************************************************************************/
 #include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
+#include "elua.h"
 
 static size_t script_len;
 static char buffer[4096];
@@ -25,157 +25,169 @@ static char *get_script_buffer(const char *script)
     }
     return NULL;
 }
-/* tsg_lua_cache_script */
-TEST(tsg_lua_cache_script, normal)
+/* elua_cache_script */
+TEST(elua_cache_script, normal)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = get_script_buffer("./script/return_string_normal.lua");
-    int script_id = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(1, script_id);
+    EXPECT_NE((void *)NULL, escript);
 }
 
-TEST(tsg_lua_cache_script, lua_vm_isnull)
+TEST(elua_cache_script, lua_vm_isnull)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
     const char *script = get_script_buffer("./script/return_string_normal.lua");
-    int script_id = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(ERR_LUAVM_ISNULL, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "The vm is invalid.");
 }
 
-TEST(tsg_lua_cache_script, script_isnull)
+TEST(elua_cache_script, script_isnull)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = NULL;
-    int script_id = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_ISNULL, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_cache_script:703] Parameter error.");
 }
-TEST(tsg_lua_cache_script, do_expected)
+TEST(elua_cache_script, do_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = get_script_buffer("./script/do_expected.lua");
-    int script_id = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_DO_EXPECTED, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_load_buff:667] [string \"string\"]:3: 'do' expected near 'return'.");
 }
 
-TEST(tsg_lua_cache_script, then_expected)
+TEST(elua_cache_script, then_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = get_script_buffer("./script/then_expected.lua");
-    int script_id = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_THEN_EXPECTED, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_load_buff:667] [string \"string\"]:2: 'then' expected near 'str'.");
 }
 
-TEST(tsg_lua_cache_script, end_expected)
+TEST(elua_cache_script, end_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = get_script_buffer("./script/end_expected.lua");
-    int script_id = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_END_EXPECTED, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_load_buff:667] [string \"string\"]:4: 'end' expected (to close 'function' at line 1) near '<eof>'.");
 }
 
-TEST(tsg_lua_cache_script, eof_expected)
+TEST(elua_cache_script, eof_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = get_script_buffer("./script/eof_expected.lua");
-    int script_id = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_EOF_EXPECTED, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_load_buff:667] [string \"string\"]:5: '<eof>' expected near 'end'.");
 }
 
-TEST(tsg_lua_cache_script, equal_in_expected)
+TEST(elua_cache_script, equal_in_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = get_script_buffer("./script/equal_in_expected.lua");
-    int script_id = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_EQUAL_IN_EXPECTED, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_load_buff:667] [string \"string\"]:3: '=' or 'in' expected near 'return'.");
 }
 
-TEST(tsg_lua_cache_script, unexpected_symbol)
+TEST(elua_cache_script, unexpected_symbol)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = get_script_buffer("./script/unexpected_symbol.lua");
-    int script_id = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_UNEXPECTED_SYMBOL, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_load_buff:667] [string \"string\"]:1: unexpected symbol near '-'.");
 }
 
-TEST(tsg_lua_cache_script, name_expected)
+TEST(elua_cache_script, name_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = get_script_buffer("./script/name_expected.lua");
-    int ret = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_NAME_EXPECTED, ret);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_load_buff:667] [string \"string\"]:2: '<name>' expected near 'do'.");
 }
 
-TEST(tsg_lua_cache_script, right_curves_bracket_expected)
+TEST(elua_cache_script, right_curves_bracket_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = get_script_buffer("./script/right_curves_bracket_expected.lua");
-    int ret = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_RIGHT_CURVES_BRACKET_EXPECTED, ret);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_load_buff:667] [string \"string\"]:2: ')' expected (to close '(' at line 1) near 'return'.");
 }
 
-TEST(tsg_lua_cache_script, right_curly_bracket_expected)
+TEST(elua_cache_script, right_curly_bracket_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = get_script_buffer("./script/right_curly_bracket_expected.lua");
-    int ret = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_RIGHT_CURLY_BRACKET_EXPECTED, ret);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_load_buff:667] [string \"string\"]:3: '}' expected near ')'.");
 }
 
-TEST(tsg_lua_cache_script, return_string_normal_sharp)
+TEST(elua_cache_script, return_string_normal_sharp)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = get_script_buffer("./script/return_string_normal_sharp.lua");
-    int script_id = tsg_lua_cache_script(L, script, script_len);
+    struct elua_script *escript = elua_cache_script(L, script, script_len, 0);
     
     /* check */
-    EXPECT_EQ(1, script_id);
+    EXPECT_NE((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "");
 }
\ No newline at end of file
diff --git a/gtest/gtest_tsg_lua_cache_script_bytecode_file.cpp b/gtest/gtest_tsg_lua_cache_script_bytecode_file.cpp
index 0abf7a3..b09487d 100644
--- a/gtest/gtest_tsg_lua_cache_script_bytecode_file.cpp
+++ b/gtest/gtest_tsg_lua_cache_script_bytecode_file.cpp
@@ -1,43 +1,45 @@
 /*************************************************************************
-    > File Name: gtest_tsg_lua_cache_script_file.cpp
+    > File Name: gtest_elua_cache_script_file.cpp
     > Author: pxz
     > Created Time: Sun 19 Jul 2020 01:28:20 PM CST
  ************************************************************************/
 #include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
+#include "elua.h"
 
-/* tsg_lua_cache_script_file */
-TEST(tsg_lua_cache_script_bytecode_file, normal)
+/* elua_cache_script_file */
+TEST(elua_cache_script_bytecode_file, normal)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_string_normal.luajit";
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(1, script_id);
+    EXPECT_NE((void *)NULL, escript);
 }
 
-TEST(tsg_lua_cache_script_bytecode_file, lua_vm_isnull)
+TEST(elua_cache_script_bytecode_file, lua_vm_isnull)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
     const char *script = "./script/return_string_normal.luajit";
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_LUAVM_ISNULL, script_id);
+    EXPECT_EQ(NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "The vm is invalid.");
 }
 
-TEST(tsg_lua_cache_script_bytecode_file, script_isnull)
+TEST(elua_cache_script_bytecode_file, script_isnull)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = NULL;
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_ISNULL, script_id);
+    EXPECT_EQ(NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_cache_script_file:765] Parameter error.");
 }
diff --git a/gtest/gtest_tsg_lua_cache_script_file.cpp b/gtest/gtest_tsg_lua_cache_script_file.cpp
index 4b57b98..24b4d99 100644
--- a/gtest/gtest_tsg_lua_cache_script_file.cpp
+++ b/gtest/gtest_tsg_lua_cache_script_file.cpp
@@ -1,175 +1,174 @@
 /*************************************************************************
-    > File Name: gtest_tsg_lua_cache_script_file.cpp
+    > File Name: gtest_elua_cache_script_file.cpp
     > Author: pxz
     > Created Time: Sun 19 Jul 2020 01:28:20 PM CST
  ************************************************************************/
 #include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
+#include "elua.h"
 
-/* tsg_lua_cache_script_file */
-TEST(tsg_lua_cache_script_file, normal)
+/* elua_cache_script_file */
+TEST(elua_cache_script_file, normal)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_string_normal.lua";
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(1, script_id);
+    EXPECT_NE((void *)NULL, escript);
 }
 
-TEST(tsg_lua_cache_script_file, lua_vm_isnull)
+TEST(elua_cache_script_file, lua_vm_isnull)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
     const char *script = "./script/return_string_normal.lua";
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_LUAVM_ISNULL, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "The vm is invalid.");
 }
 
-TEST(tsg_lua_cache_script_file, script_isnull)
+TEST(elua_cache_script_file, script_isnull)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = NULL;
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_ISNULL, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_cache_script_file:765] Parameter error.");
 }
-#if 0
-TEST(tsg_lua_cache_script_file, function_invaild)
-{
-    tsg_lua_handle L = NULL;
 
-    L = tsg_lua_vm_create();
-    const char *script = "./script/function_invaild.lua";
-    int script_id = tsg_lua_cache_script_file(L, script);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_FUNCTION_INVAILD, script_id);
-}
-#endif
-TEST(tsg_lua_cache_script_file, do_expected)
+TEST(elua_cache_script_file, do_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/do_expected.lua";
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_DO_EXPECTED, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_cache_script_file:844] [string \"./script/do_expected.lua\"]:3: 'do' expected near 'return'.");
 }
 
-TEST(tsg_lua_cache_script_file, then_expected)
+TEST(elua_cache_script_file, then_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/then_expected.lua";
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_THEN_EXPECTED, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_cache_script_file:844] [string \"./script/then_expected.lua\"]:2: 'then' expected near 'str'.");
 }
 
-TEST(tsg_lua_cache_script_file, end_expected)
+TEST(elua_cache_script_file, end_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/end_expected.lua";
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_END_EXPECTED, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_cache_script_file:844] [string \"./script/end_expected.lua\"]:5: 'end' expected (to close 'function' at line 1) near '<eof>'.");
 }
 
-TEST(tsg_lua_cache_script_file, eof_expected)
+TEST(elua_cache_script_file, eof_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/eof_expected.lua";
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_EOF_EXPECTED, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_cache_script_file:844] [string \"./script/eof_expected.lua\"]:6: '<eof>' expected near 'end'.");
 }
 
-TEST(tsg_lua_cache_script_file, equal_in_expected)
+TEST(elua_cache_script_file, equal_in_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/equal_in_expected.lua";
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_EQUAL_IN_EXPECTED, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_cache_script_file:844] [string \"./script/equal_in_expected.lua\"]:3: '=' or 'in' expected near 'return'.");
 }
 
-TEST(tsg_lua_cache_script_file, unexpected_symbol)
+TEST(elua_cache_script_file, unexpected_symbol)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/unexpected_symbol.lua";
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_UNEXPECTED_SYMBOL, script_id);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_cache_script_file:844] [string \"./script/unexpected_symbol.lua\"]:1: unexpected symbol near '-'.");
 }
 
-TEST(tsg_lua_cache_script_file, name_expected)
+TEST(elua_cache_script_file, name_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/name_expected.lua";
-    int ret = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_NAME_EXPECTED, ret);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_cache_script_file:844] [string \"./script/name_expected.lua\"]:2: '<name>' expected near 'do'.");
 }
 
-TEST(tsg_lua_cache_script_file, right_curves_bracket_expected)
+TEST(elua_cache_script_file, right_curves_bracket_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/right_curves_bracket_expected.lua";
-    int ret = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_RIGHT_CURVES_BRACKET_EXPECTED, ret);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_cache_script_file:844] [string \"./script/right_curves_bracket_expected.lua\"]:2: ')' expected (to close '(' at line 1) near 'return'.");
 }
 
-TEST(tsg_lua_cache_script_file, right_curly_bracket_expected)
+TEST(elua_cache_script_file, right_curly_bracket_expected)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/right_curly_bracket_expected.lua";
-    int ret = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(ERR_SCRIPT_RIGHT_CURLY_BRACKET_EXPECTED, ret);
+    EXPECT_EQ((void *)NULL, escript);
+    EXPECT_STREQ(elua_get_last_error_string(L), "[elua_cache_script_file:844] [string \"./script/right_curly_bracket_expected.lua\"]:3: '}' expected near ')'.");
 }
 
-TEST(tsg_lua_cache_script_file, sharp)
+TEST(elua_cache_script_file, sharp)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_string_normal_sharp.lua";
-    int script_id = tsg_lua_cache_script_file(L, script);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
     
     /* check */
-    EXPECT_EQ(1, script_id);
+    EXPECT_NE((void *)NULL, escript);
 }
\ No newline at end of file
diff --git a/gtest/gtest_tsg_lua_exec.cpp b/gtest/gtest_tsg_lua_exec.cpp
deleted file mode 100644
index d69366e..0000000
--- a/gtest/gtest_tsg_lua_exec.cpp
+++ /dev/null
@@ -1,520 +0,0 @@
-/*************************************************************************
-    > File Name: gtest_tsg_lua_exec.cpp
-    > Author: pxz
-    > Created Time: Sun 19 Jul 2020 01:28:20 PM CST
- ************************************************************************/
-#include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
-static const char *data = "hello world";
-
-static char buffer[4096];
-static char *get_script_buffer(const char *script)
-{
-    FILE *fp = fopen(script, "r");
-    if (fp)
-    {
-        int num = fread(buffer, 1, 4096, fp);
-        if (num != 0)
-        {
-            buffer[num] = 0;
-            fclose(fp);
-            return buffer;
-        }
-        fclose(fp);
-    }
-    return NULL;
-}
-
-/* tsg_lua_exec */
-TEST(tsg_lua_exec, normal_return_string)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    memset(out, 0, 255);
-    const char *script = get_script_buffer("./script/return_string_normal.lua");
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(11, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("hello world", out);
-}
-
-TEST(tsg_lua_exec, normal_return_boolean)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = BOOLEAN;
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_boolean_normal.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(1, out_len);
-    EXPECT_EQ(BOOLEAN, out_type);
-    EXPECT_EQ(true, out[0]);
-}
-
-TEST(tsg_lua_exec, normal_return_integer)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = INTEGER;
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_integer_normal.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(8, out_len);
-    EXPECT_EQ(INTEGER, out_type);
-    EXPECT_EQ(7, *(long int *)out);
-}
-
-TEST(tsg_lua_exec, lua_vm_isnull)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    
-    const char *script = get_script_buffer("./script/return_string_normal.lua");
-    memset(out, 0, sizeof(out));
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_LUAVM_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, script_isnull)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    L = tsg_lua_vm_create();
-    const char *script = NULL;
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, 0, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, input_isnull)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    char *input = NULL;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_string_normal.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), input, 0, out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_INPUT_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, in_len_invaild)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_string_normal.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, 0, out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_IN_LEN_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, end_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/end_expected.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_END_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, then_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/then_expected.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_THEN_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, do_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/do_expected.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_DO_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, eof_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/eof_expected.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_EOF_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, equal_in_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/equal_in_expected.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_EQUAL_IN_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, unexpected_symbol)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/unexpected_symbol.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_UNEXPECTED_SYMBOL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, name_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/name_expected.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_NAME_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, right_curves_bracket_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/right_curves_bracket_expected.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RIGHT_CURVES_BRACKET_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, right_curly_bracket_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/right_curly_bracket_expected.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RIGHT_CURLY_BRACKET_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, string_expected_but_nil)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/string_expected_but_nil.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_NIL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, string_expected_but_boolean)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/string_expected_but_boolean.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_BOOL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, string_expected_but_table)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/string_expected_but_table.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_TABLE, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, call_global_but_nil)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/call_global_but_nil.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_CALL_GLOBAL_BUT_NIL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-
-// TEST(tsg_lua_exec, return_too_few)
-// {
-//     tsg_lua_handle L = NULL;
-//     char out[255];
-//     size_t out_len = 0;
-//     size_t out_type = STRING;
-
-//     L = tsg_lua_vm_create();
-//     const char *script = get_script_buffer("./script/return_too_few.lua");
-//     memset(out, 0, 255);
-//     int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-//     /* check */
-//     EXPECT_EQ(ERR_SCRIPT_RETURN_TOO_FEW, ret);
-//     EXPECT_EQ(0, out_len);
-//     EXPECT_EQ(STRING, out_type);
-//     EXPECT_STREQ("", out);
-// }
-
-TEST(tsg_lua_exec, return_too_much)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_too_much.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RETURN_TOO_MUCH, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, return_type_nil)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_type_invaild.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_RETUNR_NIL, ret);
-    EXPECT_EQ(5, out_len);
-    EXPECT_EQ(NIL, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec, return_length_iszero)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_length_iszero.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RETURN_LEN_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-#if 0
-TEST(tsg_lua_exec, function_invaild)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/function_invaild.lua");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_FUNCTION_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-#endif
-
-TEST(tsg_lua_exec, sharp)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    memset(out, 0, 255);
-    const char *script = get_script_buffer("./script/return_string_normal_sharp.lua");
-    int ret = tsg_lua_exec(L, script, strlen(script), data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(11, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("hello world", out);
-}
diff --git a/gtest/gtest_tsg_lua_exec_bytecode.cpp b/gtest/gtest_tsg_lua_exec_bytecode.cpp
deleted file mode 100644
index 2975753..0000000
--- a/gtest/gtest_tsg_lua_exec_bytecode.cpp
+++ /dev/null
@@ -1,331 +0,0 @@
-/*************************************************************************
-    > File Name: gtest_tsg_lua_exec.cpp
-    > Author: pxz
-    > Created Time: Sun 19 Jul 2020 01:28:20 PM CST
- ************************************************************************/
-#include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
-
-static const char *data = "hello world";
-static size_t script_len;
-static char buffer[4096];
-static char *get_script_buffer(const char *script)
-{
-    FILE *fp = fopen(script, "r");
-    if (fp)
-    {
-        int num = fread(buffer, 1, 4096, fp);
-        if (num != 0)
-        {
-            buffer[num] = 0;
-            script_len = num;
-            fclose(fp);
-            return buffer;
-        }
-        fclose(fp);
-    }
-    return NULL;
-}
-
-/* tsg_lua_exec */
-TEST(tsg_lua_exec_bytecode, normal_return_string)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    memset(out, 0, 255);
-    const char *script = get_script_buffer("./script/return_string_normal.luajit");
-    int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(11, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("hello world", out);
-}
-
-TEST(tsg_lua_exec_bytecode, normal_return_boolean)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = BOOLEAN;
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_boolean_normal.luajit");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(1, out_len);
-    EXPECT_EQ(BOOLEAN, out_type);
-    EXPECT_EQ(true, out[0]);
-}
-
-TEST(tsg_lua_exec_bytecode, normal_return_integer)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = INTEGER;
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_integer_normal.luajit");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(8, out_len);
-    EXPECT_EQ(INTEGER, out_type);
-    EXPECT_EQ(7, *(long int *)out);
-}
-
-TEST(tsg_lua_exec_bytecode, lua_vm_isnull)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    
-    const char *script = get_script_buffer("./script/return_string_normal.luajit");
-    memset(out, 0, sizeof(out));
-    int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_LUAVM_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode, script_isnull)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    L = tsg_lua_vm_create();
-    const char *script = NULL;
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, 0, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode, input_isnull)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    char *input = NULL;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_string_normal.luajit");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, script_len, input, 0, out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_INPUT_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode, in_len_invaild)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_string_normal.luajit");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, script_len, data, 0, out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_IN_LEN_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode, string_expected_but_nil)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/string_expected_but_nil.luajit");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_NIL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode, string_expected_but_boolean)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/string_expected_but_boolean.luajit");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_BOOL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode, string_expected_but_table)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/string_expected_but_table.luajit");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_TABLE, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode, call_global_but_nil)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/call_global_but_nil.luajit");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_CALL_GLOBAL_BUT_NIL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-
-// TEST(tsg_lua_exec_bytecode, return_too_few)
-// {
-//     tsg_lua_handle L = NULL;
-//     char out[255];
-//     size_t out_len = 0;
-//     size_t out_type = STRING;
-
-//     L = tsg_lua_vm_create();
-//     const char *script = get_script_buffer("./script/return_too_few.luajit");
-//     memset(out, 0, 255);
-//     int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-//     /* check */
-//     EXPECT_EQ(ERR_SCRIPT_RETURN_TOO_FEW, ret);
-//     EXPECT_EQ(0, out_len);
-//     EXPECT_EQ(STRING, out_type);
-//     EXPECT_STREQ("", out);
-// }
-
-TEST(tsg_lua_exec_bytecode, return_too_much)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_too_much.luajit");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RETURN_TOO_MUCH, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode, return_type_nil)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_type_invaild.luajit");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_RETUNR_NIL, ret);
-    EXPECT_EQ(5, out_len);
-    EXPECT_EQ(NIL, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode, return_length_iszero)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = get_script_buffer("./script/return_length_iszero.luajit");
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RETURN_LEN_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode, normal_return_string_sharp)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    memset(out, 0, 255);
-    const char *script = get_script_buffer("./script/return_string_normal_sharp.luajit");
-    int ret = tsg_lua_exec(L, script, script_len, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(11, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("hello world", out);
-}
\ No newline at end of file
diff --git a/gtest/gtest_tsg_lua_exec_bytecode_file.cpp b/gtest/gtest_tsg_lua_exec_bytecode_file.cpp
deleted file mode 100644
index 6e82120..0000000
--- a/gtest/gtest_tsg_lua_exec_bytecode_file.cpp
+++ /dev/null
@@ -1,311 +0,0 @@
-/*************************************************************************
-    > File Name: gtest_tsg_lua_exec_file.cpp
-    > Author: pxz
-    > Created Time: Sun 19 Jul 2020 01:28:20 PM CST
- ************************************************************************/
-#include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
-static const char *data = "hello world";
-
-/* tsg_lua_exec_file */
-TEST(tsg_lua_exec_bytecode_file, normal_return_string)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_string_normal.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(11, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("hello world", out);
-}
-
-TEST(tsg_lua_exec_bytecode_file, normal_return_boolean)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = BOOLEAN;
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_boolean_normal.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(1, out_len);
-    EXPECT_EQ(BOOLEAN, out_type);
-    EXPECT_EQ(true, out[0]);
-}
-
-TEST(tsg_lua_exec_bytecode_file, normal_return_integer)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = INTEGER;
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_integer_normal.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(8, out_len);
-    EXPECT_EQ(INTEGER, out_type);
-    EXPECT_EQ(7, *(long int *)out);
-}
-
-TEST(tsg_lua_exec_bytecode_file, lua_vm_isnull)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    
-    const char *script = "./script/return_string_normal.luajit";
-    memset(out, 0, sizeof(out));
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_LUAVM_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode_file, script_isnull)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    L = tsg_lua_vm_create();
-    const char *script = NULL;
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode_file, input_isnull)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    char *input = NULL;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_string_normal.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, input, 0, out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_INPUT_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode_file, in_len_invaild)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_string_normal.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, 0, out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_IN_LEN_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode_file, string_expected_but_nil)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/string_expected_but_nil.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_NIL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode_file, string_expected_but_boolean)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/string_expected_but_boolean.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_BOOL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode_file, string_expected_but_table)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/string_expected_but_table.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_TABLE, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode_file, call_global_but_nil)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/call_global_but_nil.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_CALL_GLOBAL_BUT_NIL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-
-// TEST(tsg_lua_exec_bytecode_file, return_too_few)
-// {
-//     tsg_lua_handle L = NULL;
-//     char out[255];
-//     size_t out_len = 0;
-//     size_t out_type = STRING;
-
-//     L = tsg_lua_vm_create();
-//     const char *script = "./script/return_too_few.luajit";
-//     memset(out, 0, 255);
-//     int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-//     /* check */
-//     EXPECT_EQ(ERR_SCRIPT_RETURN_TOO_FEW, ret);
-//     EXPECT_EQ(0, out_len);
-//     EXPECT_EQ(STRING, out_type);
-//     EXPECT_STREQ("", out);
-// }
-
-TEST(tsg_lua_exec_bytecode_file, return_too_much)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_too_much.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RETURN_TOO_MUCH, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode_file, return_type_invaild)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_type_invaild.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_RETUNR_NIL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(NIL, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode_file, return_length_iszero)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_length_iszero.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RETURN_LEN_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_bytecode_file, normal_return_string_sharp)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_string_normal_sharp.luajit";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(11, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("hello world", out);
-}
diff --git a/gtest/gtest_tsg_lua_exec_file.cpp b/gtest/gtest_tsg_lua_exec_file.cpp
deleted file mode 100644
index 31ff6d4..0000000
--- a/gtest/gtest_tsg_lua_exec_file.cpp
+++ /dev/null
@@ -1,503 +0,0 @@
-/*************************************************************************
-    > File Name: gtest_tsg_lua_exec_file.cpp
-    > Author: pxz
-    > Created Time: Sun 19 Jul 2020 01:28:20 PM CST
- ************************************************************************/
-#include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
-
-static const char *data = "hello world";
-
-/* tsg_lua_exec_file */
-TEST(tsg_lua_exec_file, normal_return_string)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_string_normal.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(11, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("hello world", out);
-}
-
-TEST(tsg_lua_exec_file, normal_return_boolean)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = BOOLEAN;
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_boolean_normal.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(1, out_len);
-    EXPECT_EQ(BOOLEAN, out_type);
-    EXPECT_EQ(true, out[0]);
-}
-
-TEST(tsg_lua_exec_file, normal_return_integer)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = INTEGER;
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_integer_normal.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(8, out_len);
-    EXPECT_EQ(INTEGER, out_type);
-    EXPECT_EQ(7, *(long int *)out);
-}
-
-TEST(tsg_lua_exec_file, lua_vm_isnull)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    
-    const char *script = "./script/return_string_normal.lua";
-    memset(out, 0, sizeof(out));
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_LUAVM_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, script_isnull)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    L = tsg_lua_vm_create();
-    const char *script = NULL;
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, input_isnull)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-    char *input = NULL;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_string_normal.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, input, 0, out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_INPUT_ISNULL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, in_len_invaild)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_string_normal.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, 0, out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_IN_LEN_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, end_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/end_expected.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_END_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, then_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/then_expected.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_THEN_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, do_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/do_expected.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_DO_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, eof_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/eof_expected.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_EOF_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, equal_in_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/equal_in_expected.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_EQUAL_IN_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, unexpected_symbol)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/unexpected_symbol.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_UNEXPECTED_SYMBOL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, name_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/name_expected.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_NAME_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, right_curves_bracket_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/right_curves_bracket_expected.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RIGHT_CURVES_BRACKET_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, right_curly_bracket_expected)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/right_curly_bracket_expected.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RIGHT_CURLY_BRACKET_EXPECTED, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, string_expected_but_nil)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/string_expected_but_nil.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_NIL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, string_expected_but_boolean)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/string_expected_but_boolean.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_BOOL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, string_expected_but_table)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/string_expected_but_table.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_STRING_EXPECTED_BUT_TABLE, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, call_global_but_nil)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/call_global_but_nil.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_CALL_GLOBAL_BUT_NIL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-
-// TEST(tsg_lua_exec_file, return_too_few)
-// {
-//     tsg_lua_handle L = NULL;
-//     char out[255];
-//     size_t out_len = 0;
-//     size_t out_type = STRING;
-
-//     L = tsg_lua_vm_create();
-//     const char *script = "./script/return_too_few.lua";
-//     memset(out, 0, 255);
-//     int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-//     /* check */
-//     EXPECT_EQ(ERR_SCRIPT_RETURN_TOO_FEW, ret);
-//     EXPECT_EQ(0, out_len);
-//     EXPECT_EQ(STRING, out_type);
-//     EXPECT_STREQ("", out);
-// }
-
-TEST(tsg_lua_exec_file, return_too_much)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_too_much.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RETURN_TOO_MUCH, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, return_type_nil)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_type_invaild.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_RETUNR_NIL, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(NIL, out_type);
-    EXPECT_STREQ("", out);
-}
-
-TEST(tsg_lua_exec_file, return_length_iszero)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_length_iszero.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_RETURN_LEN_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-#if 0
-TEST(tsg_lua_exec_file, function_invaild)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/function_invaild.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(ERR_SCRIPT_FUNCTION_INVAILD, ret);
-    EXPECT_EQ(0, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("", out);
-}
-#endif
-
-TEST(tsg_lua_exec_file, normal_return_string_sharp)
-{
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_string_normal_sharp.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, data, strlen(data), out, &out_len, &out_type);
-    
-    /* check */
-    EXPECT_EQ(0, ret);
-    EXPECT_EQ(11, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("hello world", out);
-}
\ No newline at end of file
diff --git a/gtest/gtest_tsg_lua_exec_with_context.cpp b/gtest/gtest_tsg_lua_exec_with_context.cpp
index 0b3d454..dc52575 100644
--- a/gtest/gtest_tsg_lua_exec_with_context.cpp
+++ b/gtest/gtest_tsg_lua_exec_with_context.cpp
@@ -1,5 +1,5 @@
 #include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
+#include "elua.h"
 
 static char buffer[4096];
 static char *get_script_buffer(const char *script)
@@ -19,162 +19,164 @@ static char *get_script_buffer(const char *script)
     return NULL;
 }
 
-int get_userdata(tsg_lua_handle L)
+int get_userdata(elua_vm *L)
 {
-	void *ud = lua_get_userdata(L);
-	c_push_string_into_lua(L, (const char *)ud, strlen((const char *)ud));
+	void *ud = elua_get_execute_userdata(L);
+	struct elua_data edata;
+	edata.type = STRING;
+	edata.string = (char *)ud;
+	edata.len = strlen((char *)ud);
+	elua_cbinding_set_output_params(L, &edata, 1);
 	return 1;
 }
 
-TEST(lua_exec_file, normal)
+TEST(lua_execute_file, normal)
 {
-	tsg_lua_handle L = tsg_lua_vm_create_with_name("TEST");
+	elua_vm *L = elua_create_vm("TEST");
 	
 	const char *ud = "hello world.";
     	const char *script = "./script/exec_with_context.lua";
-	lua_data_t in;
-	in.data = (char *)"This is a test";
-	in.len = strlen(in.data);
-	lua_arg_t out;
+	char *input = (char *)"This is a test";
+	int len = strlen(input);
+	struct elua_data out;
 	out.type = STRING;
 	out.len = 1024;
-	out.str = (char *)calloc(1, 1024);
+	out.string = (char *)calloc(1, 1024);
 
-	lua_register_function(L, "get", "get_userdata", get_userdata);
-	lua_script_context context = NULL;
-	context = lua_script_context_malloc(L);
-	int ret = lua_exec_file(L, script, in, (void *)ud, context, 0, &out);
+	elua_register_cbinding(L, "get", "get_userdata", get_userdata);
+	elua_context *context = NULL;
+	context = elua_create_context(L, "context");
+	struct elua_script *escript = elua_cache_script_file(L, script, 0);
+	int ret = elua_execute_script(escript, input, len, (void *)ud, context, &out);
 	const char *str = "userdata:hello world., context.count:1, context.message:This is first called";
 	EXPECT_EQ(0, ret);
 	EXPECT_EQ(strlen(str), out.len);
 	EXPECT_EQ(STRING, out.type);
-	EXPECT_STREQ(str, out.str);
-	bzero(out.str, 1024);
+	EXPECT_STREQ(str, out.string);
+	bzero(out.string, 1024);
 
 	ud = "hello lua.";
-	ret = lua_exec_file(L, script, in, (void *)ud, context, 0, &out);
+	ret = elua_execute_script(escript, input, len, (void *)ud, context, &out);
 	str = "userdata:hello lua., context.count:2, context.message:This is not first called";
 	EXPECT_EQ(0, ret);
 	EXPECT_EQ(strlen(str), out.len);
 	EXPECT_EQ(STRING, out.type);
-	EXPECT_STREQ(str, out.str);
-	bzero(out.str, 1024);
+	EXPECT_STREQ(str, out.string);
+	bzero(out.string, 1024);
 
-	lua_script_context context2 = NULL;
-	context2 = lua_script_context_malloc(L);
-	ret = lua_exec_file(L, script, in, (void *)ud, context2, 0, &out);
+	elua_context *context2 = NULL;
+	context2 = elua_create_context(L, "context");
+	ret = elua_execute_script(escript, input, len, (void *)ud, context2, &out);
 	str = "userdata:hello lua., context.count:1, context.message:This is first called";
 	EXPECT_EQ(0, ret);
 	EXPECT_EQ(strlen(str), out.len);
 	EXPECT_EQ(STRING, out.type);
-	EXPECT_STREQ(str, out.str);
-	bzero(out.str, 1024);
+	EXPECT_STREQ(str, out.string);
+	bzero(out.string, 1024);
 
-	lua_script_context_free(L, context);
-	lua_script_context_free(L, context2);
-	tsg_destory_lua(L);
-	free(out.str);
+	elua_destroy_context(context);
+	elua_destroy_context(context2);
+	elua_destroy_vm(L);
+	free(out.string);
 }
 
 TEST(lua_exec, normal)
 {
-	tsg_lua_handle L = tsg_lua_vm_create_with_name("TEST");
+	elua_vm *L = elua_create_vm("TEST");
 	
 	const char *ud = "hello world.";
-	lua_data_t in;
-	in.data = (char *)"This is a test";
-	in.len = strlen(in.data);
-	lua_arg_t out;
+	char *input = (char *)"This is a test";
+	int len = strlen(input);
+	struct elua_data out;
 	out.type = STRING;
-	out.len = 1024;
-	out.str = (char *)calloc(1, 1024);
-	lua_data_t script;
-	script.data = get_script_buffer("./script/exec_with_context.lua");
-	script.len = strlen(script.data);
-
-	lua_register_function(L, "get", "get_userdata", get_userdata);
-	lua_script_context context = NULL;
-	context = lua_script_context_malloc(L);
-	int ret = lua_exec(L, script, in, (void *)ud, context, 0, &out);
+	out.integer = 1024;
+	out.string = (char *)calloc(1, 1024);
+	char *script = get_script_buffer("./script/exec_with_context.lua");
+	int script_len = strlen(script);
+	elua_script *escript = elua_cache_script(L, script, script_len, 0);
+
+	elua_register_cbinding(L, "get", "get_userdata", get_userdata);
+	elua_context *context = NULL;
+	context = elua_create_context(L, "context");
+	int ret = elua_execute_script(escript, input, len, (void *)ud, context, &out);
 	const char *str = "userdata:hello world., context.count:1, context.message:This is first called";
 	EXPECT_EQ(0, ret);
 	EXPECT_EQ(strlen(str), out.len);
 	EXPECT_EQ(STRING, out.type);
-	EXPECT_STREQ(str, out.str);
-	bzero(out.str, 1024);
+	EXPECT_STREQ(str, out.string);
+	bzero(out.string, 1024);
 
 	ud = "hello lua.";
-	ret = lua_exec(L, script, in, (void *)ud, context, 0, &out);
+	ret = elua_execute_script(escript, input, len, (void *)ud, context, &out);
 	str = "userdata:hello lua., context.count:2, context.message:This is not first called";
 	EXPECT_EQ(0, ret);
 	EXPECT_EQ(strlen(str), out.len);
 	EXPECT_EQ(STRING, out.type);
-	EXPECT_STREQ(str, out.str);
-	bzero(out.str, 1024);
+	EXPECT_STREQ(str, out.string);
+	bzero(out.string, 1024);
 
-	lua_script_context context2 = NULL;
-	context2 = lua_script_context_malloc(L);
-	ret = lua_exec(L, script, in, (void *)ud, context2, 0, &out);
+	elua_context *context2 = NULL;
+	context2 = elua_create_context(L, "context");
+	ret = elua_execute_script(escript, input, len, (void *)ud, context2, &out);
 	str = "userdata:hello lua., context.count:1, context.message:This is first called";
 	EXPECT_EQ(0, ret);
 	EXPECT_EQ(strlen(str), out.len);
 	EXPECT_EQ(STRING, out.type);
-	EXPECT_STREQ(str, out.str);
-	bzero(out.str, 1024);
+	EXPECT_STREQ(str, out.string);
+	bzero(out.string, 1024);
 
-	lua_script_context_free(L, context);
-	lua_script_context_free(L, context2);
-	tsg_destory_lua(L);
-	free(out.str);
+	elua_destroy_context(context);
+	elua_destroy_context(context2);
+	elua_destroy_vm(L);
+	free(out.string);
 }
 
-TEST(lua_cache_exec, normal)
+TEST(elua_execute_script, normal)
 {
-	tsg_lua_handle L = tsg_lua_vm_create_with_name("TEST");
+	elua_vm *L = elua_create_vm("TEST");
 	
 	const char *ud = "hello world.";
-	lua_data_t in;
-	in.data = (char *)"This is a test";
-	in.len = strlen(in.data);
-	lua_arg_t out;
+	char *input = (char *)"This is a test";
+	int len = strlen(input);
+	struct elua_data out;
 	out.type = STRING;
-	out.len = 1024;
-	out.str = (char *)calloc(1, 1024);
+	out.integer = 1024;
+	out.string = (char *)calloc(1, 1024);
 	const char *script = get_script_buffer("./script/exec_with_context.lua");
-	int script_id = tsg_lua_cache_script(L, script, strlen(script));
+	struct elua_script *escript = elua_cache_script(L, script, strlen(script), 0);
 
-	lua_register_function(L, "get", "get_userdata", get_userdata);
-	lua_script_context context = NULL;
-	context = lua_script_context_malloc(L);
-	int ret = lua_cache_exec(L, script_id, in, (void *)ud, context, 0, &out);
+	elua_register_cbinding(L, "get", "get_userdata", get_userdata);
+	elua_context *context = NULL;
+	context = elua_create_context(L, "context");
+	int ret = elua_execute_script(escript, input, len, (void *)ud, context, &out);
 	const char *str = "userdata:hello world., context.count:1, context.message:This is first called";
 	EXPECT_EQ(0, ret);
 	EXPECT_EQ(strlen(str), out.len);
 	EXPECT_EQ(STRING, out.type);
-	EXPECT_STREQ(str, out.str);
-	bzero(out.str, 1024);
+	EXPECT_STREQ(str, out.string);
+	bzero(out.string, 1024);
 
 	ud = "hello lua.";
-	ret = lua_cache_exec(L, script_id, in, (void *)ud, context, 0, &out);
+	ret = elua_execute_script(escript, input, len, (void *)ud, context, &out);
 	str = "userdata:hello lua., context.count:2, context.message:This is not first called";
 	EXPECT_EQ(0, ret);
 	EXPECT_EQ(strlen(str), out.len);
 	EXPECT_EQ(STRING, out.type);
-	EXPECT_STREQ(str, out.str);
-	bzero(out.str, 1024);
+	EXPECT_STREQ(str, out.string);
+	bzero(out.string, 1024);
 
-	lua_script_context context2 = NULL;
-	context2 = lua_script_context_malloc(L);
-	ret = lua_cache_exec(L, script_id, in, (void *)ud, context2, 0, &out);
+	elua_context *context2 = NULL;
+	context2 = elua_create_context(L, "context");
+	ret = elua_execute_script(escript, input, len, (void *)ud, context2, &out);
 	str = "userdata:hello lua., context.count:1, context.message:This is first called";
 	EXPECT_EQ(0, ret);
 	EXPECT_EQ(strlen(str), out.len);
 	EXPECT_EQ(STRING, out.type);
-	EXPECT_STREQ(str, out.str);
-	bzero(out.str, 1024);
+	EXPECT_STREQ(str, out.string);
+	bzero(out.string, 1024);
 
-	lua_script_context_free(L, context);
-	lua_script_context_free(L, context2);
-	tsg_destory_lua(L);
-	free(out.str);
+	elua_destroy_context(context);
+	elua_destroy_context(context2);
+	elua_destroy_vm(L);
+	free(out.string);
 }
diff --git a/gtest/gtest_tsg_lua_register_function.cpp b/gtest/gtest_tsg_lua_register_function.cpp
index e3388de..fc31d65 100644
--- a/gtest/gtest_tsg_lua_register_function.cpp
+++ b/gtest/gtest_tsg_lua_register_function.cpp
@@ -1,144 +1,353 @@
 /*************************************************************************
-    > File Name: gtest_tsg_lua_vm_create.cpp
+    > File Name: gtest_elua_create_vm.cpp
     > Author: pxz
     > Created Time: Sun 19 Jul 2020 01:27:13 PM CST
  ************************************************************************/
 #include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
+#include "elua.h"
 
-int get_hello(tsg_lua_handle L)
+int get_hello(elua_vm *L)
 {
-    c_push_string_into_lua(L, "hello", strlen("hello"));
+    struct elua_data ldata;
+    ldata.type = STRING;
+    ldata.string = (char *)"hello";
+    ldata.len = 5;
+    elua_cbinding_set_output_params(L, &ldata, 1);
     return 1;
 }
 
-int set_world(tsg_lua_handle L)
+int set_world(elua_vm *L)
 {
     int argc = 0;
-    lua_arg_t *argv = NULL;
     
-    c_pull_param_from_lua(L, &argc, &argv);
-    if (argc != 2 || argv == NULL || argv[0].type != STRING || argv[1].type != STRING)
+    argc = elua_cbinding_get_input_params_num(L);
+    if (argc <= 0)
     {
         return 0;
     }
 
-    char *buff = (char *)calloc(2, argv[0].len + argv[1].len + 3);
-    sprintf(buff, "%s %s.", argv[0].str, argv[1].str);
-    c_push_string_into_lua(L, buff, strlen(buff));
-    free(buff);
-    buff = NULL;
-    free_param_form_lua(argc, argv);
+    struct elua_data *argv = (struct elua_data *)calloc(argc, sizeof(struct elua_data));
+
+    for (int i = 0; i < argc; i++)
+    {
+        elua_cbinding_get_input_param(L, i+1, &argv[i]);
+    }
+
+    if (argc != 2 || argv[0].type != STRING || argv[1].type != STRING)
+    {
+        return 0;
+    }
+
+    struct elua_data retvalue;
+    retvalue.type = STRING;
+    retvalue.len = argv[0].len + argv[1].len + 2;
+    retvalue.string = (char *)calloc(1, retvalue.len);
+    sprintf(retvalue.string, "%s %s.", argv[0].string, argv[1].string);
+    elua_cbinding_set_output_params(L, &retvalue, 1);
+    free(retvalue.string);
 
     return 1;
 }
 
-int get_req_header(tsg_lua_handle L)
+int get_req_header(elua_vm *L)
 {
     const char *key[] = {"token", "User-Agent", "Accept", "Host", "Accept-Encoding", 
                     "Connection", "Content-Length", "Content-Type"};
     const char *value[] = {"c21f969b5f03d33d43e04f8f136e7682", " PostmanRuntime/7.26.8","*/*", "192.168.40.223:9098",
-                    "gzip, deflate, br", "keep-alive", "7020", "text/markdown"};
-    c_push_table_into_lua(L, key, value, 8);
+                    "gzip, deflate, br", "keep-alive", "7030", "text/markdown"};
+
+    elua_table *etab = elua_create_table(L);
+    struct elua_data ekey, evalue;
+    ekey.type = STRING;
+    evalue.type = STRING;
+
+    for (int i = 0; i < (int)(sizeof(key) / sizeof(key[0])); i++)
+    {
+        ekey.len = strlen(key[i]);
+        ekey.string = (char *)key[i];
+        evalue.len = strlen(value[i]);
+        evalue.string = (char *)value[i];
+        elua_add_table(etab, &ekey, &evalue);
+    }
+
+    struct elua_data retvalue;
+    retvalue.type = TABLE;
+    retvalue.table = etab;
+    retvalue.len = sizeof(struct elua_data);
+
+    elua_cbinding_set_output_params(L, &retvalue, 1);
+    elua_destroy_table(etab);
 
     return 1;
 }
 
-int get_rsp_header(tsg_lua_handle L)
+int get_rsp_header(elua_vm *L)
 {
     const char *key[] = {"Content-Type", "Content-Length", "Data"};
     const char *value[] = {"application/xml;charset=UTF-8", "0", "Wed, 16 Dec 2020 08:45:55 GMT"};
-    c_push_table_into_lua(L, key, value, 3);
+
+    elua_table *etab = elua_create_table(L);
+    struct elua_data ekey, evalue;
+    ekey.type = STRING;
+    evalue.type = STRING;
+
+    for (int i = 0; i < (int)(sizeof(key) / sizeof(key[0])); i++)
+    {
+        ekey.len = strlen(key[i]);
+        ekey.string = (char *)key[i];
+        evalue.len = strlen(value[i]);
+        evalue.string = (char *)value[i];
+        elua_add_table(etab, &ekey, &evalue);
+    }
+
+    struct elua_data retvalue;
+    retvalue.type = TABLE;
+    retvalue.table = etab;
+    retvalue.len = sizeof(struct elua_data);
+
+    elua_cbinding_set_output_params(L, &retvalue, 1);
+    elua_destroy_table(etab);
 
     return 1;
 }
 
-int get_result(tsg_lua_handle L)
+int get_result(elua_vm *L)
 {
-    c_push_bool_into_lua(L, false);
+    struct elua_data retvalue;
+    retvalue.type = BOOLEAN;
+    retvalue.len = sizeof(bool);
+    retvalue.true_or_false = false;
+    elua_cbinding_set_output_params(L, &retvalue, 1);
     return 1;
 }
 
-int get_nil(tsg_lua_handle L)
+int get_nil(elua_vm *L)
 {
-    c_push_nil_into_lua(L);
+    struct elua_data retvalue;
+    retvalue.type = NIL;
+    elua_cbinding_set_output_params(L, &retvalue, 1);
     return 1;   
 }
 
-int get_time(tsg_lua_handle L)
+int get_time(elua_vm *L)
 {
-    c_push_num_into_lua(L, 0x12345678);
+    struct elua_data retvalue;
+    retvalue.type = INTEGER;
+    retvalue.len = sizeof(long);
+    retvalue.integer = 0x12345678;
+    elua_cbinding_set_output_params(L, &retvalue, 1);
     return 1;
 }
 
-TEST(lua_register_function, normal)
+int set_repeat(elua_vm *L)
 {
-    tsg_lua_handle L = NULL;
-    char out[255];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    struct elua_data retvalue;
+    retvalue.type = INTEGER;
+    retvalue.len = sizeof(long);
+    retvalue.integer = 0x12345678;
+    elua_cbinding_set_output_params(L, &retvalue, 1);
+    retvalue.type = STRING;
+    retvalue.len = 5;
+    retvalue.string = (char *)"hello";
+    elua_cbinding_set_output_params(L, &retvalue, 1);
+
+    return 1;
+}
+
+int set_multi_type_retvalue(elua_vm *L)
+{
+    elua_table *etab = elua_create_table(L);
+    struct elua_data ekey, evalue;
+
+    char buff[1024];
+    bzero(buff, 1024);
+    for (int i = 0; i < 3; i++)
+    {
+        snprintf(buff, 1024, "test%d", i);
+        ekey.type = STRING;
+        evalue.type = INTEGER;
+        ekey.len = 5;
+        ekey.string = buff;
+        evalue.len = sizeof(int);
+        evalue.integer = i;
+        elua_add_table(etab, &ekey, &evalue);
+
+        snprintf(buff, 1024, "test%d", i);
+        ekey.type = INTEGER;
+        evalue.type = STRING;
+        ekey.len = sizeof(int);
+        ekey.integer = i;
+        evalue.len = 5;
+        evalue.string = buff;
+        elua_add_table(etab, &ekey, &evalue);
+    }
+
+    struct elua_data retvalue;
+    retvalue.type = TABLE;
+    retvalue.table = etab;
+    retvalue.len = sizeof(struct elua_data);
 
-    L = tsg_lua_vm_create();
+    elua_cbinding_set_output_params(L, &retvalue, 1);
+    elua_destroy_table(etab);
+
+    return 1;
+}
+
+TEST(elua_register_cbinding, normal)
+{
+    elua_vm *L = NULL;
+    
+    L = elua_create_vm(NULL);
     EXPECT_NE((void *)NULL, L);
-    lua_register_function(L, "get", "get_hello", get_hello);
-    lua_register_function(L, "set", "set_world", set_world);
+    elua_register_cbinding(L, "get", "get_hello", get_hello);
+    elua_register_cbinding(L, "set", "set_world", set_world);
 
+    char buff[1024];
     const char *script = "./script/call_cfunction.lua";
-    memset(out, 0, 255);
-    int ret = tsg_lua_exec_file(L, script, "hello", strlen("hello"), out, &out_len, &out_type);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+    struct elua_data output;
+    output.type = STRING;
+    output.string = buff;
+    output.len = 1024;
+    memset(buff, 0, 1024);
+    int ret = elua_execute_script(escript, "hello", strlen("hello"), NULL, NULL, &output);
 
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(12, out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ("hello world.", out);
-	tsg_destory_lua(L);
+    EXPECT_EQ(12, output.len);
+    EXPECT_EQ(STRING, output.type);
+    EXPECT_STREQ("hello world.", output.string);
+	elua_destroy_vm(L);
 }
 
-TEST(lua_register_function, get_header)
+TEST(elua_register_cbinding, get_header)
 {
-    tsg_lua_handle L = NULL;
-    char out[1024];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     EXPECT_NE((void *)NULL, L);
-    lua_register_function(L, "req", "get_header", get_req_header);
-    lua_register_function(L, "rsp", "get_header", get_rsp_header);
+    elua_register_cbinding(L, "req", "get_header", get_req_header);
+    elua_register_cbinding(L, "rsp", "get_header", get_rsp_header);
 
+    char buff[1024];
     const char *script = "./script/get_header.lua";
-    memset(out, 0, 1024);
-    int ret = tsg_lua_exec_file(L, script, "hello", strlen("hello"), out, &out_len, &out_type);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+    struct elua_data output;
+    output.type = STRING;
+    output.string = buff;
+    output.len = 1024;
+    memset(buff, 0, 1024);
+    int ret = elua_execute_script(escript, "hello", strlen("hello"), NULL, NULL, &output);
 
-    const char *result = "req_header:Host:192.168.40.223:9098,Content-Type:text/markdown,Content-Length:7020,Connection:keep-alive,Accept:*/*,User-Agent: PostmanRuntime/7.26.8,token:c21f969b5f03d33d43e04f8f136e7682,Accept-Encoding:gzip, deflate, br; rsp_header:nil,Content-Length:0,Content-Type:application/xml;charset=UTF-8,Data:Wed, 16 Dec 2020 08:45:55 GMT";
+    const char *result = "req_header:Host:192.168.40.223:9098,Content-Type:text/markdown,Content-Length:7030,Connection:keep-alive,Accept:*/*,User-Agent: PostmanRuntime/7.26.8,token:c21f969b5f03d33d43e04f8f136e7682,Accept-Encoding:gzip, deflate, br; rsp_header:Content-Length:0,Content-Type:application/xml;charset=UTF-8,Data:Wed, 16 Dec 2020 08:45:55 GMT";
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(strlen(result), out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ(result, out);
-	tsg_destory_lua(L);
+    EXPECT_EQ(strlen(result), output.len);
+    EXPECT_EQ(STRING, output.type);
+    EXPECT_STREQ(result, output.string);
+	elua_destroy_vm(L);
 }
 
-TEST(lua_register_function, other)
+TEST(elua_register_cbinding, other)
 {
-    tsg_lua_handle L = NULL;
-    char out[1024];
-    size_t out_len = 0;
-    size_t out_type = STRING;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     EXPECT_NE((void *)NULL, L);
-    lua_register_function(L, "get", "get_result", get_result);
-    lua_register_function(L, "get", "get_nil", get_nil);
-    lua_register_function(L, "get", "get_time", get_time);
+    elua_register_cbinding(L, "get", "get_result", get_result);
+    elua_register_cbinding(L, "get", "get_nil", get_nil);
+    elua_register_cbinding(L, "get", "get_time", get_time);
 
     const char *script = "./script/get_other.lua";
-    memset(out, 0, 1024);
-    int ret = tsg_lua_exec_file(L, script, "hello", strlen("hello"), out, &out_len, &out_type);
+    char buff[1024];
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+    struct elua_data output;
+    output.type = STRING;
+    output.string = buff;
+    output.len = 1024;
+    memset(buff, 0, 1024);
+    int ret = elua_execute_script(escript, "hello", strlen("hello"), NULL, NULL, &output);
+
 
     const char *result = "result:false, time:305419896, is nil";
     EXPECT_EQ(0, ret);
-    EXPECT_EQ(strlen(result), out_len);
-    EXPECT_EQ(STRING, out_type);
-    EXPECT_STREQ(result, out);
-	tsg_destory_lua(L);
+    EXPECT_EQ(strlen(result), output.len);
+    EXPECT_EQ(STRING, output.type);
+    EXPECT_STREQ(result, output.string);
+	elua_destroy_vm(L);
+}
+
+TEST(elua_register_cbinding, invalid_args)
+{
+    elua_vm *L = NULL;
+    
+    L = elua_create_vm(NULL);
+    EXPECT_NE((void *)NULL, L);
+    elua_register_cbinding(L, "get", "get_hello", get_hello);
+    elua_register_cbinding(L, "set", "set_world", set_world);
+
+    char buff[1024];
+    const char *script = "./script/call_cfunction_invalid_args.lua";
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+    struct elua_data output;
+    output.type = STRING;
+    output.string = buff;
+    output.len = 1024;
+    memset(buff, 0, 1024);
+    int ret = elua_execute_script(escript, "hello", strlen("hello"), NULL, NULL, &output);
+
+    EXPECT_EQ(0, ret);
+    EXPECT_EQ(12, output.len);
+    EXPECT_EQ(STRING, output.type);
+    EXPECT_STREQ("hello world.", output.string);
+	elua_destroy_vm(L);
 }
+
+TEST(elua_register_cbinding, set_repeat)
+{
+    elua_vm *L = NULL;
+    
+    L = elua_create_vm(NULL);
+    EXPECT_NE((void *)NULL, L);
+    elua_register_cbinding(L, NULL, "set_repeat", set_repeat);
+
+    char buff[1024];
+    const char *script = "./script/call_set_repeat.lua";
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+    struct elua_data output;
+    output.type = STRING;
+    output.string = buff;
+    output.len = 1024;
+    memset(buff, 0, 1024);
+    int ret = elua_execute_script(escript, "hello", strlen("hello"), NULL, NULL, &output);
+
+    EXPECT_EQ(0, ret);
+    EXPECT_EQ(5, output.len);
+    EXPECT_EQ(STRING, output.type);
+    EXPECT_STREQ("hello", output.string);
+	elua_destroy_vm(L);
+}
+
+TEST(elua_register_cbinding, get_value)
+{
+    elua_vm *L = NULL;
+    
+    L = elua_create_vm(NULL);
+    EXPECT_NE((void *)NULL, L);
+    elua_register_cbinding(L, NULL, "get_value", set_multi_type_retvalue);
+
+    char buff[1024];
+    const char *script = "./script/call_cfunction_get_value.lua";
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+    struct elua_data output;
+    output.type = STRING;
+    output.string = buff;
+    output.len = 1024;
+    memset(buff, 0, 1024);
+    int ret = elua_execute_script(escript, "hello", strlen("hello"), NULL, NULL, &output);
+
+    EXPECT_EQ(0, ret);
+    printf(elua_get_last_error_string(L));
+    EXPECT_EQ(47, output.len);
+    EXPECT_EQ(STRING, output.type);
+    EXPECT_STREQ("0:test0,1:test1,2:test2,test1:1,test0:0,test2:2", output.string);
+	elua_destroy_vm(L);
+}
\ No newline at end of file
diff --git a/gtest/gtest_tsg_lua_uncache_script.cpp b/gtest/gtest_tsg_lua_uncache_script.cpp
index 8d4d139..df82bba 100644
--- a/gtest/gtest_tsg_lua_uncache_script.cpp
+++ b/gtest/gtest_tsg_lua_uncache_script.cpp
@@ -1,36 +1,30 @@
 /*************************************************************************
-    > File Name: gtest_tsg_lua_cache_script_file.cpp
+    > File Name: gtest_elua_cache_script_file.cpp
     > Author: pxz
     > Created Time: Sun 19 Jul 2020 01:28:20 PM CST
  ************************************************************************/
 #include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
+#include "elua.h"
 
-/* tsg_lua_uncache_script */
-TEST(tsg_lua_uncache_script, normal)
+/* elua_cleanup_script */
+TEST(elua_cleanup_script, normal)
 {
-    tsg_lua_handle L = NULL;
+    elua_vm *L = NULL;
 
-    L = tsg_lua_vm_create();
+    L = elua_create_vm(NULL);
     const char *script = "./script/return_string_normal.lua";
-    int script_id = tsg_lua_cache_script_file(L, script);
-    int ret = tsg_lua_uncache_script(L, script_id);
+    struct elua_script *escript = elua_cache_script_file(L, script, 0);
+    int ret = elua_cleanup_script(escript);
     
     /* check */
     EXPECT_EQ(0, ret);
 }
 
-TEST(tsg_lua_uncache_script, lua_vm_isnull)
+TEST(elua_cleanup_script, script_isnull)
 {
-    tsg_lua_handle L = NULL;
-
-    L = tsg_lua_vm_create();
-    const char *script = "./script/return_string_normal.lua";
-    int script_id = tsg_lua_cache_script_file(L, script);
-    L = NULL;
-    int ret = tsg_lua_uncache_script(L, script_id);
+    int ret = elua_cleanup_script(NULL);
     
     /* check */
-    EXPECT_EQ(ERR_LUAVM_ISNULL, ret);
+    EXPECT_EQ(-1, ret);
 }
 
diff --git a/gtest/gtest_tsg_lua_vm_create.cpp b/gtest/gtest_tsg_lua_vm_create.cpp
index 8bcea40..70c58df 100644
--- a/gtest/gtest_tsg_lua_vm_create.cpp
+++ b/gtest/gtest_tsg_lua_vm_create.cpp
@@ -1,15 +1,15 @@
 /*************************************************************************
-    > File Name: gtest_tsg_lua_vm_create.cpp
+    > File Name: gtest_elua_create_vm.cpp
     > Author: pxz
     > Created Time: Sun 19 Jul 2020 01:27:13 PM CST
  ************************************************************************/
 #include <gtest/gtest.h>
-#include "tsg_lua_interface.h"
+#include "elua.h"
 
-/* tsg_lua_vm_create */
-TEST(tsg_lua_vm_create, create_normal)
+/* elua_create_vm */
+TEST(elua_create_vm, create_normal)
 {
-    tsg_lua_handle L = NULL;
-    L = tsg_lua_vm_create();
+    elua_vm *L = NULL;
+    L = elua_create_vm(NULL);
     EXPECT_NE((void *)NULL, L);
 }
diff --git a/gtest/script/call_cfunction_get_value.lua b/gtest/script/call_cfunction_get_value.lua
new file mode 100644
index 0000000..044a036
--- /dev/null
+++ b/gtest/script/call_cfunction_get_value.lua
@@ -0,0 +1,15 @@
+local data = TSG.data
+
+local value = TSG.get_value()
+
+local retvalue = nil
+print(type(value))
+for k, v in pairs(value) do
+	if not retvalue then
+		retvalue = string.format("%s:%s", tostring(k), tostring(v))
+	else
+		retvalue = string.format("%s,%s:%s", retvalue, tostring(k), tostring(v))
+	end
+end
+
+return string.len(retvalue), retvalue
\ No newline at end of file
diff --git a/gtest/script/call_cfunction_invalid_args.lua b/gtest/script/call_cfunction_invalid_args.lua
new file mode 100644
index 0000000..697139e
--- /dev/null
+++ b/gtest/script/call_cfunction_invalid_args.lua
@@ -0,0 +1,6 @@
+local data = TSG.data
+
+local str = TSG.get.get_hello("test", "Test")
+
+local ret = TSG.set.set_world(str, "world")
+return string.len(ret), ret
\ No newline at end of file
diff --git a/gtest/script/call_set_repeat.lua b/gtest/script/call_set_repeat.lua
new file mode 100644
index 0000000..7591309
--- /dev/null
+++ b/gtest/script/call_set_repeat.lua
@@ -0,0 +1,8 @@
+local data = TSG.data;
+local ret = TSG.set_repeat()
+
+if type(ret) == "string" then
+	return string.len(ret), ret
+else
+	return ret
+end
\ No newline at end of file
diff --git a/gtest/script/lua_time_out.lua b/gtest/script/elua_time_out.lua
index 112dabc..112dabc 100644
--- a/gtest/script/lua_time_out.lua
+++ b/gtest/script/elua_time_out.lua
diff --git a/gtest/script/get_header.lua b/gtest/script/get_header.lua
index 104ddd0..f770d60 100644
--- a/gtest/script/get_header.lua
+++ b/gtest/script/get_header.lua
@@ -13,7 +13,7 @@ end
 local rsp_header = nil
 header = TSG.rsp.get_header()
 for k, v in pairs(header) do
-	if not req_header then
+	if not rsp_header then
 		rsp_header = string.format("%s:%s", k, v)
 	else
 		rsp_header = string.format("%s,%s:%s", rsp_header, k, v)