#include"test_base.h"
#include<string>
#include <stdio.h>
#include <windows.h>
#include <map>
#include <iostream>
#include "huagao/hgscanner_error.h"
#include "sane/sane_option_definitions.h";
static struct Test_Map
{
	const wchar_t* name;	// DIAL_SWITCH
	const wchar_t* title;	// 歪斜检测
}Test_Map_NO[] =
{
	{HGPDTTOOLDB_NAME_DIAL_SWITCH						,HGPDTTOOLDB_TITLE_DIAL_SWITCH},
	{HGPDTTOOLDB_NAME_ROCKER_SWITCH						,HGPDTTOOLDB_TITLE_ROCKER_SWITCH},
	{HGPDTTOOLDB_NAME_BOOT_STATUS						,HGPDTTOOLDB_TITLE_BOOT_STATUS},
	{HGPDTTOOLDB_NAME_LCD_DISPLAY						,HGPDTTOOLDB_TITLE_LCD_DISPLAY},
	{HGPDTTOOLDB_NAME_KEY_FUNCTION						,HGPDTTOOLDB_TITLE_KEY_FUNCTION},
	{HGPDTTOOLDB_NAME_COUNTING_MODE						,HGPDTTOOLDB_TITLE_COUNTING_MODE},
	{HGPDTTOOLDB_NAME_CIS_ORIGINAL_IMAGE				,HGPDTTOOLDB_TITLE_CIS_ORIGINAL_IMAGE},
	{HGPDTTOOLDB_NAME_HOST_FAN							,HGPDTTOOLDB_TITLE_HOST_FAN},
	{HGPDTTOOLDB_NAME_SCAN_WORKING_STATUS				,HGPDTTOOLDB_TITLE_SCAN_WORKING_STATUS},
	{HGPDTTOOLDB_NAME_USB_PC_INTERFACE					,HGPDTTOOLDB_TITLE_USB_PC_INTERFACE},
	{HGPDTTOOLDB_NAME_LED_LIGHT							,HGPDTTOOLDB_TITLE_LED_LIGHT},
	{HGPDTTOOLDB_NAME_RESET								,HGPDTTOOLDB_TITLE_RESET},
	{HGPDTTOOLDB_NAME_PAPER_FEED						,HGPDTTOOLDB_TITLE_PAPER_FEED},
	{HGPDTTOOLDB_NAME_SCANNING_SENSOR					,HGPDTTOOLDB_TITLE_SCANNING_SENSOR},
	{HGPDTTOOLDB_NAME_PLACE_CORRECTION_PAPER			,HGPDTTOOLDB_TITLE_PLACE_CORRECTION_PAPER},
	{HGPDTTOOLDB_NAME_AUTO_FLAT_FIELD					,HGPDTTOOLDB_TITLE_AUTO_FLAT_FIELD},
	{HGPDTTOOLDB_NAME_IMAGE_COLOR_QUALITY				,HGPDTTOOLDB_TITLE_IMAGE_QUALITY},
	{HGPDTTOOLDB_NAME_COLORCARD_IMAGEING_QUALITY		,HGPDTTOOLDB_TITLE_COLORCARD_IMAGEING_QUALITY},
	{HGPDTTOOLDB_NAME_COLORCARD_BIAS_IMAGEING_QUALITY	,HGPDTTOOLDB_TITLE_COLORCARD_BIAS_IMAGEING_QUALITY},
	{HGPDTTOOLDB_NAME_CLARITY_QUALITY					,HGPDTTOOLDB_TITLE_CLARITY_QUALITY},
	{HGPDTTOOLDB_NAME_GET_DISTORTION_VAL				,HGPDTTOOLDB_TITLE_DISTORTION},
	{HGPDTTOOLDB_NAME_SEPARATER_MOTOR					,HGPDTTOOLDB_TITLE_SEPARATER_MOTOR},
	{HGPDTTOOLDB_NAME_CLEAR_PAPER_PATH					,HGPDTTOOLDB_TITLE_CLEAR_PAPER_PATH},
	{HGPDTTOOLDB_NAME_SKEW_DETECTION					,HGPDTTOOLDB_TITLE_SKEW_DETECTION},
	{HGPDTTOOLDB_NAME_ULTRASONIC_MODULE					,HGPDTTOOLDB_TITLE_ULTRASONIC_MODULE},
	{HGPDTTOOLDB_NAME_COVER_SENSOR						,HGPDTTOOLDB_TITLE_COVER_SENSOR	},
	{HGPDTTOOLDB_NAME_REBOOT_DEVICE						,HGPDTTOOLDB_TITLE_REBOOT_DEVICE},
	{HGPDTTOOLDB_NAME_MECH_PAPER_FEEDING_INCLINATION	,HGPDTTOOLDB_TITLE_MECH_PAPER_FEEDING_INCLINATION},
	{HGPDTTOOLDB_NAME_CLEAR_ROLLER_COUNT				,HGPDTTOOLDB_TITLE_CLEAR_ROLLER_COUNT},
	{HGPDTTOOLDB_NAME_CLEAR_HISTORY_COUNT				,HGPDTTOOLDB_TITLE_CLEAR_HISTORY_COUNT},
	{HGPDTTOOLDB_NAME_PAPER_SEPARATION_STRENGTH			,HGPDTTOOLDB_TITLE_PAPER_SEPARATION_STRENGTH},
	{HGPDTTOOLDB_NAME_CONFIGURE_SPEED_MODE				,HGPDTTOOLDB_TITLE_CONFIGURE_SPEED_MODE},
	{HGPDTTOOLDB_NAME_DORMANCY							,HGPDTTOOLDB_TITLE_DORMANCY},
	{HGPDTTOOLDB_NAME_GET_DEVICE_CONFIG					,HGPDTTOOLDB_TITLE_GET_DEVICE_CONFIG},
	{HGPDTTOOLDB_NAME_GET_DEVICE_CPU_DISK				,HGPDTTOOLDB_TITLE_GET_DEVICE_CPU_DISK},
	{HGPDTTOOLDB_NAME_BACKUP							,HGPDTTOOLDB_TITLE_BACKUP},
	{HGPDTTOOLDB_NAME_SHUTDOWN							,HGPDTTOOLDB_TITLE_SHUTDOWN},
	{HGPDTTOOLDB_NAME_SET_FIRMWARE_LANGUAGE				,HGPDTTOOLDB_TITLE_SET_FIRMWARE_LANGUAGE},
	{HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_200DPI		,HGPDTTOOLDB_TITLE_IMAGE_CORRECTION_RGB_200DPI},
	{HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_200DPI		,HGPDTTOOLDB_TITLE_IMAGE_CORRECTION_GRAY_200DPI},
	{HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_300DPI		,HGPDTTOOLDB_TITLE_IMAGE_CORRECTION_RGB_300DPI},
	{HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_300DPI		,HGPDTTOOLDB_TITLE_IMAGE_CORRECTION_GRAY_300DPI},
	{HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_600DPI		,HGPDTTOOLDB_TITLE_IMAGE_CORRECTION_RGB_600DPI},
	{HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_600DPI		,HGPDTTOOLDB_TITLE_IMAGE_CORRECTION_GRAY_600DPI}
};

static std::string StringToUtf(std::string strValue)
{
	int nwLen = MultiByteToWideChar(CP_UTF8, 0, strValue.c_str(), -1, NULL, 0);
	wchar_t* pwBuf = new wchar_t[nwLen + 1];//加上末尾'\0'
	memset(pwBuf, 0, nwLen * 2 + 2);
	MultiByteToWideChar(CP_UTF8, 0, strValue.c_str(), strValue.length(), pwBuf, nwLen);
	int nLen = WideCharToMultiByte(CP_ACP, 0, pwBuf, -1, NULL, NULL, NULL, NULL);
	char* pBuf = new char[nLen + 1];
	memset(pBuf, 0, nLen + 1);
	WideCharToMultiByte(CP_ACP, 0, pwBuf, nwLen, pBuf, nLen, NULL, NULL);
	std::string retStr = pBuf;
	delete[]pBuf;
	delete[]pwBuf;
	return retStr;
}
static int str_to_wchar(std::string str, wchar_t* s, size_t* strlen)
{
	if (str.empty())
		return ERROR_INSUFFICIENT_BUFFER;

	size_t size = str.length();
	int len = 0;
	len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, NULL, 0);
	if (*strlen < len)
	{
		*strlen = len;
		return ERROR_INSUFFICIENT_BUFFER;
	}
	MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, s, len);
	return 0;
}
static int wchar_to_char(std::string &str, wchar_t* s, size_t* strlen)
{
	if (!s)
		return ERROR_INSUFFICIENT_BUFFER;

	int len = WideCharToMultiByte(CP_ACP, 0, s, -1, NULL, 0, NULL, NULL);
	if (*strlen < len)
	{
		*strlen = len;
		return ERROR_INSUFFICIENT_BUFFER;
	}

	WideCharToMultiByte(CP_ACP, 0, s, -1, (char *)str.c_str(), len, NULL, NULL);
	return 0;
}
int get_json_config_file()
{
	int len = 0;
	char exePath[256];
	char* buf = NULL;
	GetModuleFileNameA(NULL, exePath, 255);
	(strrchr(exePath, '\\'))[1] = 0;	//去掉执行的文件名。

	strcat(exePath, "DLLs\\G302.hsc");
	FILE* fp = fopen(exePath, "rb");
	if (fp == NULL)
	{
		return -1;
	}
	fseek(fp, 0, SEEK_END);
	len = ftell(fp);
	fseek(fp, 0, SEEK_SET);
	buf = new char[len];
	if (!buf)
	{
		fclose(fp);
		return -1;
	}
	memset(buf, 0, len);
	fread(buf, len, 1, fp);
	fclose(fp);
	std::cout << buf << std::endl;
}
static std::wstring set_test_name_ =L"";
//bool is_distortion_get_image = false;
//bool is_distortion_get_image_abnormal = false;
std::atomic<bool> is_distortion_get_image_abnormal(false);
std::atomic<bool> is_distortion_get_image(false);
class test
{
	ui_helper* helper_;
	int fw_;
	
	/*设置vid pid*/
	int test_set_vidpid(void* data)
	{
		unsigned int len = sizeof(int);
		int set_vidpid = *((int*)data),
			get_vidpid = 0,
			ret = SCANNER_ERR_OK;
		ret = helper_->io_control(IO_CTRL_CODE_SET_VIDPID, &set_vidpid, &len);
		if (ret == SCANNER_ERR_OK)
		{
			ret = helper_->io_control(IO_CTRL_CODE_GET_VIDPID, &get_vidpid, &len);
			if (set_vidpid == get_vidpid)
				helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置vidpid成功", true);
			else
				helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置vidpid失败", false);
		}
		return ret;
	}
	/*设置序列号*/
	int test_set_serial_num(void* data)
	{
		wchar_t* sn = (wchar_t*)data;
	
		std::string set_sn,
			get_sn;
		int ret = SCANNER_ERR_OK;
		size_t len = 0;
		ret = wchar_to_char(set_sn, sn, &len);
		if (ret == ERROR_INSUFFICIENT_BUFFER)
		{
			set_sn.resize(len);
			ret = wchar_to_char(set_sn, sn, &len);
		}
		unsigned int setlen = set_sn.size(),
			getlen = 0;

		ret = helper_->io_control(IO_CTRL_CODE_SET_SERIAL, &set_sn[0], &setlen);

		if (ret != SCANNER_ERR_OK)return  ret;

		helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置序列号完成", true);

		return ret;
	}
	/* 设置休眠 */
	int test_dormancy(void* data)
	{
		const wchar_t sleep_buf[8] = { 0,5,10,20,30,60,120,240 };
		int sleep_time = *((int*)data);
		SANE_Power power;
		unsigned int len = sizeof(SANE_Power);

		for (size_t i = 0; i < 8; i++)
		{
			if (sleep_buf[i] == sleep_time)
			{
				power = (SANE_Power)i;
				break;
			}
			else
				power = SANE_POWER_NONE;
		}
		int ret = helper_->io_control(IO_CTRL_CODE_SET_POWER_LEVEL, &power, &len);
		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}
		int gettime = 0;
		unsigned int timelen = sizeof(int*);

		ret = helper_->io_control(IO_CTRL_CODE_GET_POWER_LEVEL, &gettime, &timelen);

		if (gettime == INT_MAX || gettime == -1)
			gettime = 0;
		else
			gettime /= 60;

		if (sleep_time == gettime)
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置休眠时间成功", true);
		else
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置休眠时间失败", false);
		return ret;
	}
	/*获取固件版本号*/
	std::string get_firmware_version()
	{
		std::string fw = "";
		unsigned int len = 0;
		int ret = helper_->io_control(IO_CTRL_CODE_GET_HARDWARE_VERSION, &fw[0], &len);
		fw.resize(len);
		ret = helper_->io_control(IO_CTRL_CODE_GET_HARDWARE_VERSION, &fw[0], &len);

		return fw;
	}
	/* 配置速度模式 */
	int test_configure_speed_mode(void* data)
	{
		unsigned int len = sizeof(int);
		int speed_mode = *((int*)data);
		bool type = false;
		const char G139[6] = { 60,70,80,90,110 };
		const char G239[6] = { 90,100,110,120,130 };
		const char G300[6] = { 40,50,60,70,80,90 };
		const char G306[6] = { 30,40,50,60,70 };
		const char G400[6] = { 40,50,60,70,80 };

		std::string fv(get_firmware_version());
		if (fv.empty())
		{
			return -1;
		}
		std::string str = fv.substr(0, 2);
		std::string str2 = fv.substr(3, 1);

		//139和239设备直接设置实际速度，其它设备设置速度模式为1 2 3 4 5
		if (str2 == "Z" && speed_mode >= 30 && speed_mode <= 70)
		{
			for (size_t i = 0; i < sizeof(G306) / sizeof(G306[0]); i++)
			{
				if (G306[i] == speed_mode)
				{
					speed_mode = i + 1;
					break;
				}
			}
		}
		else if (str == "G3" && speed_mode >= 40 && speed_mode <= 90)
		{
			for (size_t i = 0; i < sizeof(G300) / sizeof(G300[0]); i++)
			{
				if (G300[i] == speed_mode)
				{
					speed_mode = i + 1;
					break;
				}
			}
		}
		else if (str == "G4" && speed_mode >= 40 && speed_mode <= 80)
		{
			for (size_t i = 0; i < sizeof(G400) / sizeof(G400[0]); i++)
			{
				if (G400[i] == speed_mode)
				{
					speed_mode = i + 1;
					break;
				}
			}
		}

		int ret = helper_->io_control(IO_CTRL_CODE_SET_SPEED_MODE, &speed_mode, &len);
		return ret;
	}
public:
	
	static int sane_ex_callback(SANE_Handle hdev, int code, void* data, unsigned int* len, void* param)
	{
		if (!hdev && !param)
		{
			return -1;
		}
		ui_helper* h= (ui_helper*)param;

		std::wstring wstr = L"";
		size_t l = 0;
		bool	type = true;
		wchar_t buf[128] =L"";
		int ret = SCANNER_ERR_OK;
		if (code != SANE_EVENT_IMAGE_OK)
		{
			ret = str_to_wchar((char*)data, (wchar_t*)wstr.c_str(), &l);
			if (ret == ERROR_INSUFFICIENT_BUFFER)
			{
				wstr.resize(l);
				ret = str_to_wchar((char*)data, (wchar_t*)wstr.c_str(), &l);
			}
			if (ret == ERROR_INSUFFICIENT_BUFFER)
			{
				type = false;

				h->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)wstr.c_str(), type);
				return -1;
			}
		}

		//std::string str = StringToUtf((char*)data);
		switch (code)
		{
		case SANE_EVENT_SCAN_FINISHED:
		{
			SANE_Bool close = false;
			unsigned int closelen = sizeof(SANE_Bool);

			if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_SKEW_DETECTION) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCANNER_ERR_DEVICE_PAPER_SKEW) != 0)
				{
					type = false;
					wcscpy(buf, L"未检测到纸张倾斜, 原因--->");
				}
			}
			else if(wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_ULTRASONIC_MODULE) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCANNER_ERR_DEVICE_DOUBLE_FEEDING) != 0)
				{
					type = false;
					wcscpy(buf, L"未检测到双张, 原因--->");
				}
			}
			else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_COVER_SENSOR) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCANNER_ERR_DEVICE_COVER_OPENNED) != 0)
				{
					type = false;;
					wcscpy(buf, L"未检测到设备开盖, 原因--->");
				}
			}
			else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PAPER_FEED) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
				{
					type = false;
					wcscpy(buf, L"走纸检测失败, 原因--->");
				}
			}
			else if(wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_AUTO_FLAT_FIELD) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCANNER_ERR_DEVICE_AUTO_FAIL_OVER) != 0)
				{
					type = false;
					wcscpy(buf, L"平场校正失败, 原因--->");
				}
			}
			else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_GET_DISTORTION_VAL) == 0 || wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_CONFIRM_DISTORTION_VAL) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0 || strcmp((char*)data, STATU_DESC_SCANNER_ERR_DEVICE_DISTORTION) == 0)
				{
					type = false;
					is_distortion_get_image = false;
					is_distortion_get_image_abnormal = true;
					wcscpy(buf, L"畸变修正值获取失败,原因--->");
				}			
				else
				{
					is_distortion_get_image = true;
					//type = true;
					//wcscpy(buf, L"畸变修正值获取完成:");
					break;
				}
			}
			else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_COLOR_QUALITY) == 0 
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_GRAY_QUALITY) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
				{
					type = false;
					wcscpy(buf, L"扫描图像质量确认失败, 原因--->");
				}
			}
			else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_SCANNING_SENSOR) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
				{
					type = false;
					wcscpy(buf, L"扫描传感器检查失败, 原因--->");
				}
			}
			else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_CIS_ORIGINAL_IMAGE) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
				{
					type = false;
					wcscpy(buf, L"CIS原图初检, 原因--->");
				}
				h->io_control(IO_CTRL_CODE_SET_CIS_IMAGE, &close, &closelen);
			}
			else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_200DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_200DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_300DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_300DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_600DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_600DPI) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
				{
					type = false;
					wcscpy(buf, L"压力测试失败, 原因--->");
				}
				else
				{
					type = true;
					wcscpy(buf, L"压力测试完成--->");
				}
			}
			else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_COLORCARD_IMAGEING_QUALITY) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
				{
					type = false;
					wcscpy(buf, L"色卡纸成像质量评估失败, 原因--->");
				}
			}
			else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_COLORCARD_BIAS_IMAGEING_QUALITY) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
				{
					type = false;
					wcscpy(buf, L"色卡纸偏色成像质量评估失败, 原因--->");
				}
			}
			else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_CLARITY_QUALITY) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
				{
					type = false;
					wcscpy(buf, L"清晰度质量评估失败, 原因--->");
				}
			}
			else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_SINGLE_PAGE_TEST) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCAN_STOPPED) != 0)
				{
					type = false;
					wcscpy(buf, L"单张测试失败, 原因--->");
				}
			}
			else if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_200DPI) == 0
			|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_200DPI) == 0
			|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_300DPI) == 0
			|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_300DPI) == 0
			|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_600DPI) == 0
			|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_600DPI) == 0)
			{
				if (strcmp((char*)data, STATU_DESC_SCANNER_ERR_IMAGE_CORRECTION_FAIL) == 0)
				{
					type = false;
				}
				else
				{
					type = true;
				}
			}

			wcscat(buf, wstr.c_str());
			//ret = h->io_control(IO_CTRL_CODE_RESTORE_SETTINGS, NULL, NULL);//结束恢复默认
			
			h->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)buf, type);
		}
		break;
		case SANE_EVENT_ERROR:
		{
			h->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)wstr.c_str(), false);
		}
		break;
		case SANE_EVENT_STATUS:
		{
			if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_AUTO_FLAT_FIELD) == 0)
			{
				h->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_FALT_INFO, (wchar_t*)wstr.c_str(), type);
			}
		}
		break;
		case SANE_EVENT_IMAGE_OK:
		{
			if (  wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_CIS_ORIGINAL_IMAGE) == 0 
				||wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_COLOR_QUALITY) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_SKEW_DETECTION) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_GRAY_QUALITY) == 0
				||wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_GET_DISTORTION_VAL) == 0
                                ||wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_CONFIRM_DISTORTION_VAL) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_SCANNING_SENSOR) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_COLORCARD_IMAGEING_QUALITY) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_COLORCARD_BIAS_IMAGEING_QUALITY) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_CLARITY_QUALITY) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_SINGLE_PAGE_TEST) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_200DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_200DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_300DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_300DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_600DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_600DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_200DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_200DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_300DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_300DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_600DPI) == 0
				|| wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_600DPI) == 0)
	
			{
				if (wcscmp(set_test_name_.c_str(), HGPDTTOOLDB_NAME_GET_DISTORTION_VAL) == 0)
				{
					is_distortion_get_image = true;
				}
				h->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_HAVE_IMAGE, data, true);	
			}
		}
		break;
		}
		return 0;
	}
	test(ui_helper* helper) :helper_(helper), fw_(0)
	{
		helper->register_sane_callback(sane_ex_callback, NULL);
		init_test_map_();
	}
	~test()
	{}

	std::map<std::wstring, int(test::*)(void *)> test_map_;
	void init_test_map_()
	{
		test_map_[WRITE_CFG_NAME] = &test::set_init_cfg;
		test_map_[HGPDTTOOLDB_NAME_SET_JSON_SN] = &test::test_set_json_serial_num;
		test_map_[HGPDTTOOLDB_NAME_CLEAR_PAPER_PATH] = &test::tset_clear_paper_path;
		test_map_[HGPDTTOOLDB_NAME_KEY_FUNCTION] = &test::test_key_funtion;
		test_map_[HGPDTTOOLDB_NAME_COUNTING_MODE] = &test::test_count_mode;
		test_map_[HGPDTTOOLDB_NAME_SKEW_DETECTION] = &test::test_skew_detection;
		test_map_[HGPDTTOOLDB_NAME_SEPARATER_MOTOR] = &test::test_separater_motor;
		test_map_[HGPDTTOOLDB_NAME_CIS_ORIGINAL_IMAGE] = &test::test_cis__original_image;
		test_map_[HGPDTTOOLDB_NAME_HOST_FAN] = &test::test_host_fan;
		test_map_[HGPDTTOOLDB_NAME_SCAN_WORKING_STATUS] = &test::test_scan_work_status;
		test_map_[HGPDTTOOLDB_NAME_USB_PC_INTERFACE] = &test::test_usb_pc_interface;
		test_map_[HGPDTTOOLDB_NAME_ULTRASONIC_MODULE] = &test::test_ultrasonic_module;
		test_map_[HGPDTTOOLDB_NAME_LED_LIGHT] = &test::test_led_light;
		test_map_[HGPDTTOOLDB_NAME_RESET] = &test::test_reset;
		test_map_[HGPDTTOOLDB_NAME_PAPER_FEED] = &test::test_paper_feed;
		test_map_[HGPDTTOOLDB_NAME_SCANNING_SENSOR] = &test::test_scanning_sensor;
		test_map_[HGPDTTOOLDB_NAME_CONFIGURE_SPEED_MODE] = &test::test_configure_speed_mode;
		test_map_[HGPDTTOOLDB_NAME_PLACE_CORRECTION_PAPER] = &test::test_place_correction_paper;
		test_map_[HGPDTTOOLDB_NAME_AUTO_FLAT_FIELD] = &test::test_auto_flat_field;
		test_map_[HGPDTTOOLDB_NAME_REBOOT_DEVICE] = &test::test_reboot_device;

		test_map_[HGPDTTOOLDB_NAME_IMAGE_COLOR_QUALITY] = &test::test_image_color_quality;
		test_map_[HGPDTTOOLDB_NAME_IMAGE_GRAY_QUALITY] = &test::test_image_gray_quality;

		test_map_[HGPDTTOOLDB_NAME_GET_DISTORTION_VAL] = &test::test_get_auto_distortion;
		test_map_[HGPDTTOOLDB_NAME_SET_DISTORTION_VAL] = &test::test_set_auto_distortion;
        test_map_[HGPDTTOOLDB_NAME_CONFIRM_DISTORTION_VAL] = &test::test_confirm_auto_distortion;
		test_map_[HGPDTTOOLDB_NAME_DORMANCY] = &test::test_dormancy;
		test_map_[HGPDTTOOLDB_NAME_PAPER_SEPARATION_STRENGTH] = &test::test_paper_separation_strength;
		test_map_[HGPDTTOOLDB_NAME_MECH_PAPER_FEEDING_INCLINATION] = &test::test_mech_paper_feeding_inclination;
		test_map_[HGPDTTOOLDB_NAME_CLEAR_ROLLER_COUNT] = &test::test_clear_roller_count;
        test_map_[HGPDTTOOLDB_NAME_CLEAR_HISTORY_COUNT] = &test::test_clear_history_count;

		test_map_[HGPDTTOOLDB_NAME_COVER_SENSOR] = &test::test_single_page_test;
		test_map_[HGPDTTOOLDB_NAME_SINGLE_PAGE_TEST] = &test::test_single_page_test;
		test_map_[HGPDTTOOLDB_NAME_COLORCARD_IMAGEING_QUALITY] = &test::test_single_page_test;
		test_map_[HGPDTTOOLDB_NAME_COLORCARD_BIAS_IMAGEING_QUALITY] = &test::test_single_page_test;
		test_map_[HGPDTTOOLDB_NAME_CLARITY_QUALITY] = &test::test_single_page_test;

		test_map_[HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_200DPI] = &test::test_pressuer_test_rgb_200dpi;
		test_map_[HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_200DPI] = &test::test_pressuer_test_gray_200dpi;
		test_map_[HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_300DPI] = &test::test_pressuer_test_rgb_300dpi;
		test_map_[HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_300DPI] = &test::test_pressuer_test_gray_300dpi;
		test_map_[HGPDTTOOLDB_NAME_PRESSUER_TEST_RGB_600DPI] = &test::test_pressuer_test_rgb_600dpi;
		test_map_[HGPDTTOOLDB_NAME_PRESSUER_TEST_GRAY_600DPI] = &test::test_pressuer_test_gray_600dpi;
		test_map_[HGPDTTOOLDB_NAME_GET_DEVICE_CONFIG] = &test::test_get_device_config;
		test_map_[HGPDTTOOLDB_NAME_GET_DEVICE_CPU_DISK] = &test::test_get_device_cpu_disk;
		test_map_[HGPDTTOOLDB_NAME_BACKUP] = &test::test_backup;
		test_map_[HGPDTTOOLDB_NAME_SHUTDOWN] = &test::test_shutdown;
		test_map_[HGPDTTOOLDB_NAME_SET_FIRMWARE_LANGUAGE] = &test::test_set_firmware_language;
		test_map_[HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_200DPI] = &test::test_image_correct_rgb_200dpi;
		test_map_[HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_200DPI] = &test::test_image_correct_gray_200dpi;
		test_map_[HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_300DPI] = &test::test_image_correct_rgb_300dpi;
		test_map_[HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_300DPI] = &test::test_image_correct_gray_300dpi;
		test_map_[HGPDTTOOLDB_NAME_IMAGE_CORRECTION_RGB_600DPI] = &test::test_image_correct_rgb_600dpi;
		test_map_[HGPDTTOOLDB_NAME_IMAGE_CORRECTION_GRAY_600DPI] = &test::test_image_correct_gray_600dpi;
	}
	int set_test(const wchar_t* name,const wchar_t* oper)
	{
		
		if (wcscmp(name, HGPDTTOOLDB_NAME_SET_JSON_SN) == 0 
			|| wcscmp(name, HGPDTTOOLDB_NAME_GET_DEVICE_CONFIG) == 0 
			|| wcscmp(name, HGPDTTOOLDB_NAME_CONFIGURE_SPEED_MODE) == 0
			|| wcscmp(name, WRITE_CFG_NAME) == 0)
		{
			std::string fw1(get_firmware_version());
			if (!fw1.empty())
			{
				if ("G1" == fw1.substr(0, 2))
					fw_ = 1;
				else if ("G2" == fw1.substr(0, 2))
					fw_ = 2;
				else if ("G3" == fw1.substr(0, 2))
					fw_ = 3;
				else if ("G4" == fw1.substr(0, 2))
					fw_ = 4;
			}
		}
		if (!name)
			return SCANNER_ERR_NO_DATA;
		set_test_name_ = name;
		int ret = SCANNER_ERR_OK;

		auto it = test_map_.find(name);

		if (it == test_map_.end())
		{
			helper_->test_callback(name, ui_helper::TEST_EVENT_NOT_FIND_TEST, NULL, false);
			return ret;
		}
		ret = (this->*test_map_[name])((void*)oper);

		const wchar_t* info = NULL;
		if (ret == SCANNER_ERR_DEVICE_NOT_SUPPORT 
			|| ret == SCANNER_ERR_IO 
			|| ret == SCANNER_ERR_TIMEOUT
			|| ret == SCANNER_ERR_NO_DATA
			)
		{
			if (ret == SCANNER_ERR_DEVICE_NOT_SUPPORT)
				info = L"设备不支持该操作";
			else if (ret == SCANNER_ERR_IO)
				info = L"IO错误";
			else if (ret == SCANNER_ERR_TIMEOUT)
				info = L"超时错误";
			else if (ret == SCANNER_ERR_NO_DATA)
				info = L"没有数据";

			helper_->test_callback(name, ui_helper::TEST_EVENT_IO_FAIL, (void*)info, ret);
		}
		return ret;
	}
public:

	int set_init_cfg(void *data)
	{
		const wchar_t* p = (const wchar_t*)data;
		LPWRITECFG cfg = (LPWRITECFG)p;
		unsigned int len = 0;
		int ret = SCANNER_ERR_OK;
		switch (cfg->cat)
		{
		case WRITE_CAT_VID_PID:
			ret = test_set_vidpid(cfg->val);
			break;
		case WRITE_CAT_SPEED:
			ret = test_configure_speed_mode(cfg->val);
			break;
		case WRITE_CAT_SLEEP:
			ret = test_dormancy(cfg->val);
			break;
		case WRITE_CAT_SERIALNUM:
			ret = test_set_serial_num(cfg->val);
			break;
		case WRITE_CAT_DEVS_MODEL:
			ret = test_set_devs_model (cfg->val);
			break;
		default:
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"协议未找到", false);
			break;
		}
		return ret;
	}

	/*设置序列号*/
	int test_set_json_serial_num(void* data)
	{
		int ret = SCANNER_ERR_OK,
			val = 0;
		wchar_t* sn;

		std::string set_sn,get_sn;
		size_t len = 0;
		parameter* prt = helper_->get_user_input(ui_helper::DATA_FROM_USER, ui_helper::VAL_TYPE_FLOAT, set_test_name_.c_str(), L"请设置序列号");
		if (!prt)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出序列号设置", false);
			return -1;
		}
		else
		{
			sn = (wchar_t*)prt->get_data();
			if (!sn)
			{
				helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置序列号失败", false);
				return -1;
			}
		}
		std::string fv(get_firmware_version());
		if (fv.empty())
		{
			return -1;
		}
		std::string fvv = fv.substr(0, 4);
		if (fvv != "G439" && fvv != "G239" && fvv != "G139")
		{
			fvv = fv.substr(0, 2);
		}

		ret = wchar_to_char(set_sn, sn, &len);
		if (ret == ERROR_INSUFFICIENT_BUFFER)
		{
			if (fvv == "G3" || fvv == "G4")
			{
				if (len != 14)
				{
					helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置序列号不足:14位", false);
					return -1;
				}

			}
			set_sn.resize(len);
			ret = wchar_to_char(set_sn, sn, &len);
		}
		unsigned int setlen = set_sn.size(),
			getlen = 0;

		ret = helper_->io_control(IO_CTRL_CODE_SET_SERIAL, &set_sn[0], &setlen);

		if (ret != SCANNER_ERR_OK)return  ret;

		ret = helper_->io_control(IO_CTRL_CODE_GET_SERIAL, &get_sn[0], &getlen);
		if (ret == SANE_STATUS_NO_MEM)
		{
			ret = helper_->io_control(IO_CTRL_CODE_GET_SERIAL, &get_sn[0], &getlen);
		}
		
		if (set_sn == get_sn)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置序列号完成", true);
		}
		else
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置序列号失败", true);

		}
	

		return ret;
	}
	/* 清理纸道功能确认 */
	int tset_clear_paper_path(void *data)
	{
		int ret = helper_->io_control(IO_CTRL_CODE_GET_CLEAN_PAPER_ROAD, NULL, NULL);
		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}
		helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"请确认是否清理纸道成功", true);
		return ret;
	}
	/* 按键功能检测 */
	int test_key_funtion(void *data)
	{
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;
	}
	/* 计数模式检测 */
	int test_count_mode(void *data)
	{
		SANE_Bool ismode = false;
		unsigned int len = sizeof(SANE_Bool);

		int ret = helper_->io_control(IO_CTRL_CODE_GET_IS_MODE, &ismode, &len);
		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}
		helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"请确认与液晶面板是否匹配", ismode);
		return ret;
	}
	/* 歪斜检测 */
	int test_skew_detection(void *data)
	{
		const wchar_t* NAME = set_test_name_.c_str();
		SANE_Bool type = true;
		unsigned int len = sizeof(SANE_Bool);
		int num = 0;
		void* get_data = NULL;
		parameter * ptr = helper_->get_user_input(ui_helper::DATA_FROM_USER, ui_helper::VAL_TYPE_INT, NAME,L"请歪斜放纸...设置阈值：0 - 5,值越小越容易检测,0为关闭歪斜检测");
		if (ptr)
		{
			get_data = ptr->get_data();
			if (!get_data)
			{
				helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出歪斜检测流程", false);
				return -1;
			}
			num = *((int*)get_data);
		}
		else
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出歪斜检测流程", false);
			return -1;
		}
		type = num == 0 ? false:true;
		ptr->release();
		int ret = helper_->io_control(IO_CTRL_CODE_SET_SKEW_CHECK, &type, &len);
		if (ret != SCANNER_ERR_OK)
			return ret;

		ret = helper_->io_control(IO_CTRL_CODE_SET_SKEW_CHECK_VAL, &num, &len);
		if (ret != SCANNER_ERR_OK)
			return ret;

		ret = helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
		return ret;
	}
	/* 分纸电机检测 */
	int test_separater_motor(void *data)
	{
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;
	}
	/* cis原图初检 */
	int test_cis__original_image(void *data)
	{
		const wchar_t* NAME = set_test_name_.c_str();
		SANE_Bool type = true;
		unsigned int len = sizeof(SANE_Bool);
		int ret = SCANNER_ERR_OK;

		ret = helper_->io_control(IO_CTRL_CODE_SET_CIS_IMAGE, &type, &len);
		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}
		ret = helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}
		return ret;
	}
	/* 主机风扇功能检测 */
	int test_host_fan(void *data)
	{
		return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/* 扫描工作状态 */
	int test_scan_work_status(void* data)
	{
		return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/* USB-PC接口 */
	int test_usb_pc_interface(void* data)
	{
		return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/* 超声波模块检验 */
	int test_ultrasonic_module(void *data)
	{
		const wchar_t* NAME = set_test_name_.c_str();
		SANE_Bool type = true;
		unsigned int len = sizeof(SANE_Bool);
		void* get_data = NULL;
		int ret = SCANNER_ERR_OK;
		parameter* ptr = helper_->get_user_input(ui_helper::DATA_FROM_USER, ui_helper::VAL_TYPE_BOOL, NAME, 
			L"请选择是否开启超声波检查，并且请放置双张纸");
		if (ptr)
		{
			get_data = ptr->get_data();
			if (!get_data)
			{
				helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出超声波模块检测流程", false);
				return -1;
			}
			else
				type = *((bool*)get_data);
		}
		else
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出超声波模块检测流程", false);
			return -1;
		}
		ptr->release();

		ret = helper_->io_control(IO_CTRL_CODE_SET_ULTRASONIC_MODULE, &type, &len);

		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}
		ret = helper_->io_control(IO_CTRL_CODE_TEST_SINGLE, NULL, NULL);
		return ret;
	}
	/* led灯状态检查 */
	int test_led_light(void *data)
	{
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;
	}
	/* 复位检查 */
	int test_reset(void *data)
	{
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;
	}
	/* 走纸检查 */
	int test_paper_feed(void *data) //使用单张扫描测试
	{
		return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/* 扫描传感器检查 */
	int test_scanning_sensor(void *data)
	{
		return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/* 放置校正纸 */
	int test_place_correction_paper(void *data)
	{
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;
	}
	/* 自动平场校正 */
	int test_auto_flat_field(void *data)
	{
		if (!data)
			return SCANNER_ERR_DATA_DAMAGED;
		unsigned int len = sizeof(int);
		wchar_t* p = (wchar_t*)data;
		std::string str;

		int ret = SCANNER_ERR_OK,
			dpi_type = 0;
		unsigned int llen = sizeof(int);
		size_t strl = 0;
		//ret = wchar_to_char(str, p, &strl);
		//if (ret == ERROR_INSUFFICIENT_BUFFER)
		//{
		//	str.resize(strl);
		//	ret = wchar_to_char(str, p, &strl);
		//	if (str.empty())
		//	{
		//		return SCANNER_ERR_DATA_DAMAGED;
		//	}
		//	dpi_type = atoi(str.c_str());
		//}
		return helper_->io_control(IO_CTRL_CODE_SET_AUTO_FALT, &dpi_type, &len);;
	}
	/* 重启设备 */
	int test_reboot_device(void *data)
	{
		if (!data)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设备重启中失败", false);
			return -1;
		}
		wchar_t* p = (wchar_t*)data;

		int i = _wtoi(p);
		unsigned int len = sizeof(int);
		int ret = helper_->io_control(IO_CTRL_CODE_SET_DEVS_REBOOT, &i, &len);
		helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设备重启中，请观察设备是否重启", true);
		return ret;
	}
	/* 扫描图像彩色质量确认 */
	int test_image_color_quality(void *data)
	{
		if (!data)
		{
			return SCANNER_ERR_DATA_DAMAGED;
		}
		wchar_t* p = (wchar_t*)data;
		std::string str;
		int ret = SCANNER_ERR_OK,
			dpi = 0;
		unsigned int len = sizeof(int);
		size_t strl = 0;
		ret = wchar_to_char(str, p, &strl);
		if (ret == ERROR_INSUFFICIENT_BUFFER)
		{
			str.resize(strl);
			ret = wchar_to_char(str, p, &strl);
			if (str.empty())
			{
				return SCANNER_ERR_DATA_DAMAGED;
			}
			dpi = atoi(str.c_str());
		}
		if (dpi > 0)
		{
			ret = helper_->io_control(IO_CTRL_CODE_SET_DPI, &dpi, &len);
		}
		if (ret != SCANNER_ERR_OK)
		{
			return -1;
		}
		const char* color = OPTION_VALUE_YSMS_24WCS;
		unsigned int colorlen = strlen(color);
		helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &colorlen);

		return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/* 扫描图像灰度质量确认 */
	int test_image_gray_quality(void* data)
	{
		if (!data)
		{
			return SCANNER_ERR_DATA_DAMAGED;
		}
		wchar_t* p = (wchar_t*)data;
		std::string str;
		int ret = SCANNER_ERR_OK,
			dpi = 0;
		unsigned int len = sizeof(int);
		size_t strl = 0;
		ret = wchar_to_char(str, p, &strl);
		if (ret == ERROR_INSUFFICIENT_BUFFER)
		{
			str.resize(strl);
			ret = wchar_to_char(str, p, &strl);
			if (str.empty())
			{
				return SCANNER_ERR_DATA_DAMAGED;
			}
			dpi = atoi(str.c_str());
		}
		if (dpi > 0)
		{
			ret = helper_->io_control(IO_CTRL_CODE_SET_DPI, &dpi, &len);
		}
		if (ret != SCANNER_ERR_OK)
		{
			return -1;
		}
		const char* color = OPTION_VALUE_YSMS_256JHD;
		unsigned int colorlen = strlen(color);
		helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &colorlen);
		return helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/* 获取自动计算畸变值 */
	int test_get_auto_distortion(void *data)
	{
		if (!data )
		{
			return SCANNER_ERR_DATA_DAMAGED;
		}
		wchar_t* p = (wchar_t*)data;
		std::string str;
		
		int ret = SCANNER_ERR_OK, 
			dpi = 0;
		SANE_Bool type = true;
		unsigned int len = sizeof(SANE_Bool),
					llen = sizeof(int);
		size_t strl = 0;
		ret = wchar_to_char(str, p, &strl);
		if (ret == ERROR_INSUFFICIENT_BUFFER)
		{
			str.resize(strl);
			ret = wchar_to_char(str, p, &strl);
			if (str.empty())
			{
				return SCANNER_ERR_DATA_DAMAGED;
			}
			dpi = atoi(str.c_str());
		}

		ret = helper_->io_control(IO_CTRL_CODE_GET_PAPER_ON, &type, &llen);
		if (!type)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"自动计算畸变值获取失败: 无纸", false);
			return ret;
		}
		
		if (dpi > 0)
		{
			ret = helper_->io_control(IO_CTRL_CODE_SET_DPI, &dpi, &llen);
		}
		//先默认设置1
		float distortion = 1.0;

		ret = helper_->io_control(IO_CTRL_CODE_SET_DISTORTION_DEVS_CHECK_VAL, &distortion, &len);
	
		ret = helper_->io_control(IO_CTRL_CODE_SET_DISTORTION_IMAGE, &type, &len);
		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}
		int cnt = 0;
		SANE_DISTORTION_VAL dis = { 0 };
		while (ret == SCANNER_ERR_OK)
		{
			if (is_distortion_get_image)
			{
				ret = helper_->io_control(IO_CTRL_CODE_GET_PC_DISTORTION_CHECK_VAL, &dis, &llen);
				break;
			}
			else if (cnt == 20)
				break;

			if (is_distortion_get_image_abnormal)
				break;

			Sleep(1000);
			cnt++;
		}
        if (dis.h > 0 && dis.scaleXY < 10)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_DISTORTION_VAL, (void *)&dis, true);
		}
		else
		{
            helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT,(void*)L"自动计算畸变值获取失败", false);
		}
		return ret;
	}
	int test_set_auto_distortion(void* data)
	{
		if (!data)
		{
			return SCANNER_ERR_DATA_DAMAGED;
		}
		wchar_t* p = (wchar_t*)data;
		std::string str;

		int ret = SCANNER_ERR_OK,
			dpi = 0;
		unsigned int len = sizeof(int);
		float distortion = 0.0;
		size_t strl = 0;

		ret = wchar_to_char(str, p, &strl);
		if (ret == ERROR_INSUFFICIENT_BUFFER)
		{
			str.resize(strl);
			ret = wchar_to_char(str, p, &strl);
			if (str.empty())
			{
				return SCANNER_ERR_DATA_DAMAGED;
			}
			dpi = atoi(str.c_str());
		}
		if (dpi > 0)
		{
			ret = helper_->io_control(IO_CTRL_CODE_SET_DPI, &dpi, &len);
		}

		parameter* prt = helper_->get_user_input(ui_helper::DATA_FROM_USER, ui_helper::VAL_TYPE_FLOAT, set_test_name_.c_str(), L"请设置畸变值");
		if (!prt)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出畸变值设置", false);
			return -1;
		}
		else
		{
		
			void * p = prt->get_data();
			distortion = *(float*)p;
		}
		if (distortion == 0.0)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void *)L"已退出畸变值设置", false);
			return -1;
		}
		float setdistortion = distortion;
		float getdistortion = 0;

		ret = helper_->io_control(IO_CTRL_CODE_SET_DISTORTION_DEVS_CHECK_VAL, &setdistortion, &len);
		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}

		ret = helper_->io_control(IO_CTRL_CODE_GET_DISTORTION_DEVS_CHECK_VAL, &getdistortion, &len);
		if (setdistortion == getdistortion)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置畸变值成功", true);
		}
		else
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置畸变值失败", false);
		}
		
		return ret;
	}
    int test_confirm_auto_distortion(void *data)
    {
        if (!data )
        {
            return SCANNER_ERR_DATA_DAMAGED;
        }

		float distortion = 0;
		unsigned int len = sizeof(int);

		int ret = SCANNER_ERR_OK;
		float value[3] = { 0 };
		int dpi[3] = { 200, 300, 600 };
		for (int i = 0; i < 3; i++)
		{
			ret = helper_->io_control(IO_CTRL_CODE_SET_DPI, &dpi[i], &len);
			ret = helper_->io_control(IO_CTRL_CODE_GET_DISTORTION_DEVS_CHECK_VAL, &distortion, &len);
			if (ret != SCANNER_ERR_OK)
				break;

			value[i] = distortion;
		}
		
        if (ret == SCANNER_ERR_OK)
        {		
				
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)(float*)value, true);
        }
        else
        {
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT,(void*)L"获取设备畸变值失败", false);
        }
        return ret;
    }
	/* 分纸强度检测 */
	int test_paper_separation_strength(void *data)
	{
		//parameter* ptr = helper_->get_user_input(ui_helper::DATA_FROM_USER, ui_helper::VAL_TYPE_TIPS_VAL, NAME, (wchar_t*)&info_);
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;
	}
	/* 机械走纸倾斜检测 */
	int test_mech_paper_feeding_inclination(void *data)
	{
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;
	}
	/* 清除滚轴计数 */
	int test_clear_roller_count(void *data)
	{
		SANE_Int roller_num = -1;
		const wchar_t* info = NULL;
		bool type = false;
		unsigned int len = sizeof(SANE_Int);
		int ret = helper_->io_control(IO_CTRL_CODE_SET_CLEAR_ROLLER_COUNT, NULL, NULL);
		ret = helper_->io_control(IO_CTRL_CODE_GET_ROLLER_NUM, &roller_num, &len);

		if ((roller_num == 0 && roller_num != -1))
		{
			type = true;
			info = L"清除滚轴计数成功";
		}
		else
		{
			type = false;
			info = L"清除滚轴计数失败";
		}
		helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)info, type);

		return ret;
	}
	/* 清除历史计数 */
	int test_clear_history_count(void* data)
	{
		SANE_Int num = -1;
		const wchar_t* info = NULL;
		bool type = false;
		unsigned int len = sizeof(SANE_Int);
		int ret = helper_->io_control(IO_CTRL_CODE_SET_CLEAR_HISTORY_COUNT, NULL, NULL);
                if (ret != SCANNER_ERR_OK)
                {
                        return SCANNER_ERR_DEVICE_NOT_SUPPORT;
                }
		ret = helper_->io_control(IO_CTRL_CODE_GET_HISTORY_SCAN_NUM, &num, &len);

		if ((num == 0 && num != -1))
		{
			type = true;
			info = L"清除历史计数成功";
		}
		else
		{
			type = false;
            info = L"清除历史计数失败";
		}
		helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)info, type);

		return ret;
	}
	/* 单张测试 */
	int test_single_page_test(void* data)
	{
		return  helper_->io_control(IO_CTRL_CODE_TEST_SINGLE, NULL, NULL);
	}
	/*压力测试彩色_200dpi*/
	int test_pressuer_test_rgb_200dpi(void* data)
	{
		const char* color = OPTION_VALUE_YSMS_24WCS;
		int dpi = 200;
		unsigned int len = strlen(color);
		helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void *)color, &len);
		helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &len);
		return  helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/*压力测试灰色_200dpi*/
	int test_pressuer_test_gray_200dpi(void* data)
	{
		const char* color = OPTION_VALUE_YSMS_256JHD;
		int dpi = 200;
		unsigned int len = strlen(color);
		helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &len);
		helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &len);
		return  helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/*压力测试彩色_300dpi*/
	int test_pressuer_test_rgb_300dpi(void* data)
	{
		const char* color = OPTION_VALUE_YSMS_24WCS;
		int dpi = 300;
		unsigned int len = strlen(color);
		helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &len);
		helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &len);
		return  helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/*压力测试灰色_300dpi*/
	int test_pressuer_test_gray_300dpi(void* data)
	{
		const char* color = OPTION_VALUE_YSMS_256JHD;
		int dpi = 300;
		unsigned int len = strlen(color);
		helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &len);
		helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &len);
		return  helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/*压力测试彩色_600dpi*/
	int test_pressuer_test_rgb_600dpi(void* data)
	{
		const char* color = OPTION_VALUE_YSMS_24WCS;
		int dpi = 600;
		unsigned int len = strlen(color);
		helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &len);
		helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &len);
		return  helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/*压力测试灰色_600dpi*/
	int test_pressuer_test_gray_600dpi(void* data)
	{
		const char* color = OPTION_VALUE_YSMS_256JHD;
		int dpi = 600;
		unsigned int len = strlen(color);
		helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &len);
		helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &len);
		return  helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);
	}
	/*获取设备配置*/
	int test_get_device_config(void* data)
	{
		unsigned int len = sizeof(int);
		unsigned int getlen = 0;

		int get_vidpid = 0,
			ret = SCANNER_ERR_OK;

		if (ret == SCANNER_ERR_OK)
		{
			ret = helper_->io_control(IO_CTRL_CODE_GET_VIDPID, &get_vidpid, &len);
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_VIDPID, &get_vidpid, true);
		}

		std::string set_sn, get_sn;
		std::wstring wstr;
		size_t l = 0;
		ret = helper_->io_control(IO_CTRL_CODE_GET_SERIAL, &get_sn[0], &getlen);
		if (ret == SANE_STATUS_NO_MEM)
		{
			ret = helper_->io_control(IO_CTRL_CODE_GET_SERIAL, &get_sn[0], &getlen);
			if (ret != SCANNER_ERR_OK)
			{
				return ret;
			}
			ret = str_to_wchar(get_sn.c_str(), (wchar_t*)wstr.c_str(), &l);
			if (ret == ERROR_INSUFFICIENT_BUFFER)
			{
				wstr.resize(l);
				ret = str_to_wchar(get_sn.c_str(), (wchar_t*)wstr.c_str(), &l);
			}
			if (wstr.empty())
			{
				helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_SN, (void*)L"获取序列号失败", false);
				return ret;
			}
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_SN, (void *)wstr.c_str(), true);
		}

		int gettime = 0;
		unsigned int timelen = sizeof(int*);

		ret = helper_->io_control(IO_CTRL_CODE_GET_POWER_LEVEL, &gettime, &timelen);

		if (gettime == INT_MAX || gettime == -1)
			gettime = 0;
		else
			gettime /= 60;
		helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_SLEEPTIME, (void*)&gettime, true);


		std::string fw(get_firmware_version());
		size_t fwlen= 0;
		wstr.clear();
		ret = str_to_wchar(fw.c_str(), (wchar_t*)wstr.c_str(), &fwlen);
		if (ret == ERROR_INSUFFICIENT_BUFFER)
		{
			wstr.resize(fwlen);
			ret = str_to_wchar(fw.c_str(), (wchar_t*)wstr.c_str(), &fwlen);
		}
		if (wstr.empty())
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_FW, (void*)L"获取固件号失败", false);
			return ret;
		}
		helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_FW, (void*)wstr.c_str(), true);


		std::string fvv = fw.substr(0, 4);
		if (fvv != "G439" && fvv != "G239" && fvv != "G139")
		{
			fvv = fw.substr(0, 2);
		}

		const wchar_t G139[6] = { 60,70,80,90,110 };
		const wchar_t G239[6] = { 90,100,110,120,130 };
		const wchar_t G300[6] = { 40,50,60,70 };
		const wchar_t G400[6] = { 40,50,60,70,80 };
		SANE_Int num = 0;
		unsigned int lensp = sizeof(SANE_Int);
		ret = helper_->io_control(IO_CTRL_CODE_GET_SPEED_MODE, &num, &lensp);
		int save_num = 0;

		if (fvv == "G3" || fvv == "G4" && num > 0 && num < 6)
		{
			for (size_t i = 0; i < sizeof(G400) / sizeof(G400[0]); i++)//3288设置速度模式为1 2 3 4 5
			{
				if ((num - 1) == i)
				{
					save_num = G400[i];
					break;
				}
			}
		}
		else
			save_num = num;

		helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_SP, (void*)&save_num, true);


		std::string devs_model;
		unsigned int devs_len = 0;
		l = 0;
		wstr.clear();

		ret = helper_->io_control(IO_CTRL_CODE_GET_DEVS_MODEL, &devs_model[0], &devs_len);
		if (ret == SANE_STATUS_NO_MEM)
		{
			devs_model.resize(devs_len);
			ret = helper_->io_control(IO_CTRL_CODE_GET_DEVS_MODEL, &devs_model[0], &devs_len);
		}

		ret = str_to_wchar(devs_model.c_str(), (wchar_t*)wstr.c_str(), &l);
		if (ret == ERROR_INSUFFICIENT_BUFFER)
		{
			wstr.resize(l);
			ret = str_to_wchar(devs_model.c_str(), (wchar_t*)wstr.c_str(), &l);
		}
	
		helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_CONFIG_DEVS_MODEL, wstr.empty() ? (void*)L"获取设备类型失败" : (void*)wstr.c_str(), wstr.empty() ? false : true);

		helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)(L"配置获取完成"), true);
		return ret;
	}
	/*获取设备内存和硬盘容量大小*/
	int test_get_device_cpu_disk(void* data)
	{
		int cpu = 0;
		unsigned len = 0;
		int ret = helper_->io_control(IO_CTRL_CODE_GET_DEVS_CPU, &cpu, &len);

		if (0 != cpu)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_DEVS_CPU, (void*)&cpu, true);
		}

		int disk = 0;
		unsigned len2 = 0;
		ret = helper_->io_control(IO_CTRL_CODE_GET_DEVS_DISK, &disk, &len2);

		if (0 != disk)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVEB_GET_DEVICE_DEVS_DISK, (void*)&disk, true);
		}

		if (0 == cpu || 0 == disk)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, nullptr, false);
			return -1;
		}
		else
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, nullptr, true);
			return -1;
		}

		return ret;
	}
	/* 备份设备配置 */
	int test_backup(void *data)
	{
		int val = 0;
		unsigned int len = 0;
		int ret = helper_->io_control(IO_CTRL_CODE_SET_BACKUP, &val, &len);
		if (SCANNER_ERR_OK == ret)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)(L"备份配置完成"), true);
		}
		else
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)(L"备份配置失败"), false);
			return -1;
		}
		return ret;
	}
	/* 关机 */
	int test_shutdown(void *data)
	{
		int val = 0;
		unsigned int len = 0;
		int ret = helper_->io_control(IO_CTRL_CODE_SET_DEVS_SHUTDOWN, &val, &len);
		if (SCANNER_ERR_OK != ret)
		{
			if (SCANNER_ERR_DEVICE_NOT_SUPPORT == ret)
			{
				helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)(L"设备固件不支持"), false);
			}
			else
			{
				helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)(L"关机失败"), false);
			}
			
			return -1;
		}
		return ret;
	}
	/* 设置固件语言模式 */
	int test_set_firmware_language(void* data)
	{
		int mode = 0;
		void* get_data = nullptr;

		parameter* ptr = helper_->get_user_input(ui_helper::DATA_FROM_USER, ui_helper::VAL_TYPE_TIPS_VAL, set_test_name_.c_str(), L"请设置固件语言模式");
		if (ptr)
		{
			get_data = ptr->get_data();
			if (!get_data)
			{
				helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出设置固件语言模式流程", false);
				return -1;
			}
			mode = *((int*)get_data);
		}
		else
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"已退出设置固件语言模式流程", false);
			return -1;
		}

		int ret = helper_->io_control(IO_CTRL_CODE_SET_FIRMWARE_LANGUAGE, &mode, NULL);
		if (ret != SCANNER_ERR_OK)
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"不支持设置固件语言模式", false);
			return -1;
		}
		else
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"设置固件语言模式成功，设备即将重启", true);

			int val = 0;
			unsigned int len = sizeof(int);
			int ret = helper_->io_control(IO_CTRL_CODE_SET_DEVS_REBOOT, &val, &len);
		}

		return ret;
	}
	/*设置设备型号*/
	int test_set_devs_model(void* data)
	{
		if (!data)
		{
			return SCANNER_ERR_NO_DATA;
		}
		wchar_t* sc = (wchar_t*)data;
		std::string str;
		size_t len = 0;
		int ret =wchar_to_char(str, sc, &len);
		if (ret == ERROR_INSUFFICIENT_BUFFER)
		{
			str.resize(len);
			ret = wchar_to_char(str, sc, &len);
		}
		if (str.empty())
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置设备类型失败", false);

			return -1;
		}
		unsigned int l = str.size();
		ret = helper_->io_control(IO_CTRL_CODE_SET_DEVS_MODEL, &str[0], &l);
		if (ret != SCANNER_ERR_OK)
			return  ret;

		helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_MANUAL_CONFIRMATION, (void*)L"设置设备类型成功", true);
		return ret;
	}
	int public_test_image_correct(void* data, int dpi, bool isColor)
	{
		if (!data)
		{
			return SCANNER_ERR_NO_DATA;
		}
		wchar_t* sc = (wchar_t*)data;
		std::string str;
		size_t len = 0;
		int ret = wchar_to_char(str, sc, &len);
		if (ret == ERROR_INSUFFICIENT_BUFFER)
		{
			str.resize(len);
			ret = wchar_to_char(str, sc, &len);
		}
		if (str.empty())
		{
			helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"校正失败", false);

			return -1;
		}

		unsigned int l = str.size();
		ret = helper_->io_control(IO_CTRL_CODE_SET_DPI, (void*)&dpi, &l);
		const char* color = isColor ? OPTION_VALUE_YSMS_24WCS : OPTION_VALUE_YSMS_256JHD;
		unsigned int colorlen = strlen(color);
		ret = helper_->io_control(IO_CTRL_CODE_SET_COLOR, (void*)color, &colorlen);

		SANE_Bool isOriImg = true;
		ret = ret = helper_->io_control(IO_CTRL_CODE_ORIGINAL_IMAGE, (void*)&isOriImg, &l);

		ret = helper_->io_control(IO_CTRL_CODE_SET_CORRECT_IMAGE, &str[0], &l);		
		ret = helper_->io_control(IO_CTRL_CODE_GET_IMAGE, NULL, NULL);

		if (ret != SCANNER_ERR_OK)
			return ret;

		//helper_->test_callback(set_test_name_.c_str(), ui_helper::TEST_EVENT_RESULT, (void*)L"校正完成", true);
		return ret;
	}
	int test_image_correct_rgb_200dpi(void* data)
	{
		return public_test_image_correct(data, 200, true);
	}
	int test_image_correct_gray_200dpi(void* data)
	{
		return public_test_image_correct(data, 200, false);
	}
	int test_image_correct_rgb_300dpi(void* data)
	{
		return public_test_image_correct(data, 300, true);
	}
	int test_image_correct_gray_300dpi(void* data)
	{
		return public_test_image_correct(data, 300, false);
	}
	int test_image_correct_rgb_600dpi(void* data)
	{
		return public_test_image_correct(data, 600, true);
	}
	int test_image_correct_gray_600dpi(void* data)
	{
		return public_test_image_correct(data, 600, false);
	}
private:

};


//test
static std::string jsontext1("{\"1\":{\"NAME\":\"test-8\",\"ver\":1}}");
bool have_img_ = false;

DECL_API(int) func_test_init(void* init)
{
	return 0;
}
DECL_API(int) func_test_get_list(wchar_t* buf, size_t* len)
{
	return str_to_wchar(jsontext1, buf, len);
}
DECL_API(int) func_test_go(const wchar_t* NAME, const wchar_t* oper, ui_helper* helper)
{
	if (!NAME || !oper || !helper)
	{
		return -1;
	}
	//helper->add_ref(void *data);

	is_distortion_get_image = false;
	is_distortion_get_image_abnormal = false;

	int ret = 0;
	SANE_Bool type = false;
	unsigned int len = sizeof(SANE_Bool);
	test ts(helper);

	//ret = helper->io_control(IO_CTRL_CODE_RESTORE_SETTINGS, NULL, NULL);//结束恢复默认
	return ts.set_test(NAME, oper);
}
DECL_API(int) func_test_uninit(void* uninit)
{
	return 0;
}