Add internal CAPIs to auto testsubmit/tizen/20200825.014022submit/tizen/20200824.103034accepted/tizen/unified/20200825.142852

ex)
device_touchscreen_disable
device_touchscreen_enable
device_display_get_brightness_state
device_display_get_max_brightness_state
device_display_set_brightness_state
device_display_change_state_by_reason
device_multi_led_get_number
device_multi_led_control
device_battery_get_info_direct
device_pmqos_app_launch_home
device_pmqos_homescreen
device_get_reboot_mode

Change-Id: I3f45437591ed29c9477851b138d51d9fd5864295
Signed-off-by: lokilee73 <changjoo.lee@samsung.com>

10 files changed, 484 insertions, 73 deletions

diff --git a/src/auto-test/CMakeLists.txt b/src/auto-test/CMakeLists.txt
index 56238659..3631df5d 100644
--- a/src/auto-test/CMakeLists.txt
+++ b/src/auto-test/CMakeLists.txt
@@ -25,8 +25,15 @@ SET(SRCS
 	battery-monitor-test.c
 	udev.c
 	brightness.c
+	boot.c
+	touchscreen.c
+	pmqos.c
 )
 
+INCLUDE(FindPkgConfig)
+pkg_check_modules(pkgs REQUIRED
+		capi-system-device)
+
 FOREACH(flag ${pkgs_CFLAGS})
 	SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
 ENDFOREACH(flag)
diff --git a/src/auto-test/auto-test.conf b/src/auto-test/auto-test.conf
index 6ae94442..c7fa5106 100644
--- a/src/auto-test/auto-test.conf
+++ b/src/auto-test/auto-test.conf
@@ -1,4 +1,5 @@
 [mobile]
+booting=1
 battery-monitor=0
 battery=1
 display=1
@@ -9,8 +10,11 @@ extcon=1
 ir=1
 time=1
 udev=1
+touchscreen=1
+pmqos=1
 
 [wearable]
+booting=1
 battery-monitor=1
 battery=1
 display=1
@@ -22,8 +26,11 @@ extcon=1
 ir=0
 time=1
 udev=1
+touchscreen=1
+pmqos=1
 
 [tv]
+booting=0
 battery-monitor=0
 battery=0
 display=1
@@ -34,8 +41,11 @@ extcon=1
 ir=0
 time=1
 udev=1
+touchscreen=0
+pmqos=0
 
 [common]
+booting=1
 battery-monitor=0
 battery=0
 display=1
@@ -46,3 +56,5 @@ extcon=1
 ir=0
 time=1
 udev=1
+touchscreen=1
+pmqos=1
\ No newline at end of file
diff --git a/src/auto-test/battery.c b/src/auto-test/battery.c
index ebb3bd20..4ebf33e4 100644
--- a/src/auto-test/battery.c
+++ b/src/auto-test/battery.c
@@ -18,6 +18,7 @@
 #include <stdio.h>
 #include "test.h"
 #include <vconf.h>
+#include <device/battery-internal.h>
 
 #define METHOD_BATTERY_TIMETOFULL       "TimeToFull"
 #define METHOD_BATTERY_TIMETOEMPTY      "TimeToEmpty"
@@ -31,6 +32,7 @@
 #define METHOD_BATTERY_ISFULL           "IsFull"
 #define METHOD_BATTERY_HEALTH           "GetHealth"
 #define METHOD_BATTERY_GETINFO          "GetBatteryInfo"
+#define METHOD_BATTERY_GETINFO_DIRECT   "GetBatteryInfoDirect"
 #define METHOD_BATTERY_POWERSUPPLY      "power_supply"
 #define METHOD_BATTERY_GET_POWERSUPPLY  "get_power_supply"
 
@@ -441,6 +443,15 @@ static bool get_battery_info()
 	return ret;
 }
 
+static bool get_battery_info_direct(struct device_battery_info *info)
+{
+	int ret;
+
+	ret = device_battery_get_info_direct(info);
+
+	return capi_result(METHOD_BATTERY_GETINFO_DIRECT, ret);
+}
+
 static int change_charge_status_to_enum(const char *env_value)
 {
 	int len, ret;
@@ -846,6 +857,7 @@ void battery_test_all(int *success, int *fail)
 	int f = 0;
 	int rsp[12];
 	char *power_source = NULL;
+	struct device_battery_info info;
 
 	(get_battery_time_to_full())    ? s++ : f++;
 	(get_battery_time_to_empty())   ? s++ : f++;
@@ -860,6 +872,7 @@ void battery_test_all(int *success, int *fail)
 	(get_battery_is_full())         ? s++ : f++;
 	(get_battery_health())          ? s++ : f++;
 	(get_battery_info())            ? s++ : f++;
+	(get_battery_info_direct(&info))     ? s++ : f++;
 
 	for (int index = 0; index < ARRAY_SIZE(power_supply_types); index++) {
 		(set_battery_power_supply(index) &&
@@ -894,6 +907,7 @@ static int battery_unit(int argc, char **argv)
 {
 	int rsp[12];
 	char *power_source = NULL;
+	struct device_battery_info info;
 
 	if (argc < 4) {
 		int success = 0;
@@ -925,6 +939,8 @@ static int battery_unit(int argc, char **argv)
 		get_battery_health();
 	} else if (0 == strcasecmp(argv[3], METHOD_BATTERY_GETINFO)) {
 		get_battery_info();
+	} else if (0 == strcasecmp(argv[3], METHOD_BATTERY_GETINFO_DIRECT)) {
+		get_battery_info_direct(&info);
 	} else if (0 == strcasecmp(argv[3], METHOD_BATTERY_POWERSUPPLY)) {
 		for (int index = 0; index < ARRAY_SIZE(power_supply_types); index++) {
 			set_battery_power_supply(index);
diff --git a/src/auto-test/boot.c b/src/auto-test/boot.c
new file mode 100644
index 00000000..d589f8c2
--- /dev/null
+++ b/src/auto-test/boot.c
@@ -0,0 +1,86 @@
+/*
+ * test
+ *
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "test.h"
+#include <device/booting-internal.h>
+
+#define METHOD_GET_REBOOT_MODE		"GetRebootMode"
+
+static bool get_reboot_mode(void)
+{
+	int ret;
+
+	ret = device_get_reboot_mode();
+
+	return capi_reboot_result(METHOD_GET_REBOOT_MODE, ret);
+}
+
+static void booting_test_all(int *success, int *fail)
+{
+	int s = 0;
+	int f = 0;
+
+	(get_reboot_mode())		? s++ : f++;
+
+	if (NULL != success)    *success = s;
+	if (NULL != fail)       *fail = f;
+}
+
+static void booting_init(void *data)
+{
+	int success = 0;
+	int fail = 0;
+
+	_I("start test");
+
+	booting_test_all(&success, &fail);
+
+	_I("Total: %d, Success: %d, Fail: %d", success+fail, success, fail);
+}
+
+static void booting_exit(void *data)
+{
+	_I("end test");
+}
+
+static int booting_unit(int argc, char **argv)
+{
+	if (argc < 4) {
+		int success = 0;
+		int fail = 0;
+
+		_I("start test");
+		booting_test_all(&success, &fail);
+		_I("Total: %d, Success: %d, Fail: %d", success+fail, success, fail);
+	} else if (0 == strcasecmp(argv[3], METHOD_GET_REBOOT_MODE)) {
+		get_reboot_mode();
+	} else {
+		_E("Unknown test case!!!");
+	}
+
+	return 0;
+}
+
+static const struct test_ops booting_test_ops = {
+	.priority = TEST_PRIORITY_NORMAL,
+	.name     = "booting",
+	.init     = booting_init,
+	.exit    = booting_exit,
+	.unit    = booting_unit,
+};
+
+TEST_OPS_REGISTER(&booting_test_ops)
diff --git a/src/auto-test/display.c b/src/auto-test/display.c
index 9b5e2f34..c2494f51 100644
--- a/src/auto-test/display.c
+++ b/src/auto-test/display.c
@@ -18,7 +18,7 @@
 #include <stdio.h>
 #include <error.h>
 #include <tzplatform_config.h>
-
+#include <device/display-internal.h>
 
 #include "test.h"
 
@@ -49,8 +49,10 @@
 #define METHOD_DISPLAY_ACTORCONTROL			"ActorControl"
 #define METHOD_DISPLAY_START				"start"
 #define METHOD_DISPLAY_STOP					"stop"
+#define METHOD_CHANGE_STATE_BY_REASON		"ChangeStateByReason"
 
 #define PM_STATE_LOG_FILE			"/var/log/pm_state.log"
+#define PALM_STR				"palm"
 
 static bool get_display_method(const char *method, GVariant *param, int *value)
 {
@@ -129,70 +131,6 @@ static bool set_display_method_noreply(const char *method, GVariant *var)
 	return TRUE;
 }
 
-static bool get_display_brightness(int *brightness)
-{
-	return get_display_method(METHOD_DISPLAY_GETBRIGHTNESS, g_variant_new("(i)", 0), brightness);
-}
-
-static bool set_display_brightness(int brightness)
-{
-	GVariant *msg;
-	int getbrightness = -1;
-	int val = 0;
-	bool ret = FALSE;
-
-	msg = dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME,
-						DEVICED_PATH_DISPLAY,
-						DEVICED_INTERFACE_DISPLAY,
-						METHOD_DISPLAY_SETBRIGHTNESS,
-						g_variant_new("(ii)", 0, brightness));
-	if (!msg) {
-		_E("fail : no reply");
-		return ret;
-	}
-
-	if (!dh_get_param_from_var(msg, "(i)", &val)) {
-		_E("fail : no message");
-		goto out;
-	}
-
-	if (0 != val) { //setbrightness fail
-		if ((brightness <= 0) && (val == -EPERM)) {
-			_I("success : can't set brightness (%d) lower than zero", brightness);
-			ret = TRUE;
-		} else if (val == -EPERM) {
-			_E("fail : please check display api capability or brightness_automatic setting.");
-		} else {
-			_E("fail : return fail %d", val);
-		}
-		goto out;
-	} else {
-		if (brightness <= 0) {
-			_E("fail : can't set brightness (%d) lower than zero, but returned success", brightness);
-			goto out;
-		}
-	}
-
-	if (!get_display_brightness(&getbrightness)) {
-		_E("fail : can't get brightness");
-	} else {
-		if (brightness == getbrightness) {
-			_I("success : %d", getbrightness);
-			ret = TRUE;
-		} else {
-			_E("fail : set brightness %d, but current brightness is %d", brightness, getbrightness);
-		}
-	}
-out:
-	g_variant_unref(msg);
-	return ret;
-}
-
-static bool get_display_maxbrightness()
-{
-	return get_display_method(METHOD_DISPLAY_GETMAXBRIGHTNESS, g_variant_new("(i)", 0), NULL);
-}
-
 static bool set_display_maxbrightness(int brightness)
 {
 	return set_display_method(METHOD_DISPLAY_SETMAXBRIGHTNESS, g_variant_new("(i)", brightness));
@@ -414,6 +352,61 @@ static bool set_display_actorcontrol(char *command, int actor, int caps)
 	return set_display_method(METHOD_DISPLAY_ACTORCONTROL, g_variant_new("(sii)", command, actor, caps));
 }
 
+static bool get_display_brightness_state(display_state_e state, int *brightness)
+{
+	int ret;
+
+	ret = device_display_get_brightness_state(0, state, brightness);
+
+	return capi_result(METHOD_DISPLAY_GETBRIGHTNESS, ret);
+}
+
+static bool get_display_max_brightness_state(display_state_e state, int *brightness)
+{
+	int ret;
+
+	ret = device_display_get_max_brightness_state(0, state, brightness);
+
+	return capi_result(METHOD_DISPLAY_GETMAXBRIGHTNESS, ret);
+}
+
+static bool set_display_brightness_state(display_state_e state, int brightness)
+{
+	int ret;
+	int getbrightness;
+
+	ret = device_display_set_brightness_state(0, state, brightness);
+	if (!capi_result(METHOD_DISPLAY_SETBRIGHTNESS, ret))
+		return FALSE;
+
+	if (state == DISPLAY_STATE_NORMAL)
+		set_display_changestate("lcdon");
+	else if (state == DISPLAY_STATE_SCREEN_DIM)
+		set_display_changestate("lcddim");
+	else {
+		_E("fail: unknown state(%d)", state);
+		return FALSE;
+	}
+
+	ret = device_display_get_brightness_state(0, state, &getbrightness);
+	if (!capi_result(METHOD_DISPLAY_SETBRIGHTNESS, ret))
+		return FALSE;
+
+	if (brightness != getbrightness)
+		return FALSE;
+
+	return TRUE;
+}
+
+static bool set_display_state_by_reason(display_state_e type, const char *reason, int timeout, device_dbus_pending_cb cb)
+{
+	int ret;
+
+	ret = device_display_change_state_by_reason(type, reason, timeout, cb);
+
+	return capi_result(METHOD_CHANGE_STATE_BY_REASON, ret);
+}
+
 static bool set_display_start()
 {
 	return set_display_method_noreply(METHOD_DISPLAY_START, NULL);
@@ -428,11 +421,14 @@ void display_test_all(int *success, int *fail)
 {
 	int s = 0;
 	int f = 0;
-
-	(get_display_brightness(NULL))		? s++ : f++;
-	(set_display_brightness(67))		? s++ : f++;
-	(set_display_brightness(0))			? s++ : f++;
-	(get_display_maxbrightness())		? s++ : f++;
+	int brt = 0;
+
+	(get_display_brightness_state(DISPLAY_STATE_NORMAL, &brt))	       ? s++ : f++;
+	(get_display_brightness_state(DISPLAY_STATE_SCREEN_DIM, &brt))	   ? s++ : f++;
+	(set_display_brightness_state(DISPLAY_STATE_NORMAL, 100))          ? s++ : f++;
+	(set_display_brightness_state(DISPLAY_STATE_SCREEN_DIM, 1))        ? s++ : f++;
+	(get_display_max_brightness_state(DISPLAY_STATE_NORMAL, &brt))				? s++ : f++;
+	(get_display_max_brightness_state(DISPLAY_STATE_SCREEN_DIM, &brt))			? s++ : f++;
 	(set_display_maxbrightness(80))		? s++ : f++;	//not support, always success.
 	(set_display_holdbrightness(30))	? s++ : f++;
 	(set_display_releasebrightness())	? s++ : f++;
@@ -462,6 +458,7 @@ void display_test_all(int *success, int *fail)
 	(set_display_actorcontrol("reset", 4, 1<<3)) ? s++ : f++;
 	(set_display_stop())				? s++ : f++;
 	(set_display_start())				? s++ : f++;
+	(set_display_state_by_reason(DISPLAY_STATE_SCREEN_OFF, PALM_STR, 0, __cb)) ? s++ : f++;
 
 	if (NULL != success)    *success = s;
 	if (NULL != fail)       *fail = f;
@@ -487,6 +484,8 @@ static void display_exit(void *data)
 
 static int display_unit(int argc, char **argv)
 {
+	int brt = 0;
+
 	if (argc < 4) {
 		int success = 0;
 		int fail = 0;
@@ -494,11 +493,14 @@ static int display_unit(int argc, char **argv)
 		display_test_all(&success, &fail);
 		_I("Total: %d, Success: %d, Fail: %d", success+fail, success, fail);
 	} else if (0 == strcasecmp(argv[3], METHOD_DISPLAY_GETBRIGHTNESS)) {
-		get_display_brightness(NULL);
+		get_display_brightness_state(DISPLAY_STATE_NORMAL, &brt);
+		get_display_brightness_state(DISPLAY_STATE_SCREEN_DIM, &brt);
 	} else if (0 == strcasecmp(argv[3], METHOD_DISPLAY_SETBRIGHTNESS)) {
-		set_display_brightness(atoi(argv[4]));
+		set_display_brightness_state(DISPLAY_STATE_NORMAL, 100);
+		set_display_brightness_state(DISPLAY_STATE_SCREEN_DIM, 1);
 	} else if (0 == strcasecmp(argv[3], METHOD_DISPLAY_GETMAXBRIGHTNESS)) {
-		get_display_maxbrightness();
+		get_display_max_brightness_state(DISPLAY_STATE_NORMAL, &brt);
+		get_display_max_brightness_state(DISPLAY_STATE_SCREEN_DIM, &brt);
 	} else if (0 == strcasecmp(argv[3], METHOD_DISPLAY_SETMAXBRIGHTNESS)) {
 		set_display_maxbrightness(atoi(argv[4]));
 	} else if (0 == strcasecmp(argv[3], METHOD_DISPLAY_HOLDBRIGHTNESS)) {
@@ -519,6 +521,8 @@ static int display_unit(int argc, char **argv)
 //		set_display_lockstate_nopt(argv[4], argv[5], argv[6], atoi(argv[7]));
 //	} else if (0 == strcasecmp(argv[3], METHOD_DISPLAY_UNLOCKSTATE)) {
 //		set_display_lockstate_nopt(argv[4], argv[5]);
+	} else if (0 == strcasecmp(argv[3], METHOD_CHANGE_STATE_BY_REASON)) {
+		set_display_state_by_reason(DISPLAY_STATE_SCREEN_OFF, PALM_STR, 0, __cb);
 	} else if (0 == strcasecmp(argv[3], METHOD_DISPLAY_SETLCDTIMEOUT)) {
 		set_display_lcdtimeout(atoi(argv[4]), atoi(argv[5]), atoi(argv[6]));
 	} else if (0 == strcasecmp(argv[3], METHOD_DISPLAY_CUSTOMLCDON)) {
diff --git a/src/auto-test/led.c b/src/auto-test/led.c
index 79cfae35..7e4356d1 100644
--- a/src/auto-test/led.c
+++ b/src/auto-test/led.c
@@ -19,6 +19,7 @@
 
 #include "test.h"
 #include <stdio.h>
+#include <device/led-internal.h>
 
 #define METHOD_LED_PLAYCUSTOM				"playcustom"
 #define METHOD_LED_STOPCUSTOM				"stopcustom"
@@ -26,12 +27,16 @@
 #define METHOD_LED_GETBRIGHTNESS			"GetBrightness"
 #define METHOD_LED_GETMAXBRIGHTNESS			"GetMaxBrightness"
 #define METHOD_LED_SETBRIGHTNESS			"SetBrightness"
+#define METHOD_MULTI_LED_GETNUMBER			"GetNumOfLeds"
+#define METHOD_MULTI_LED_CONTROL			"MultiLedControl"
 
 #define RED 0xff0000
 #define GREEN 0x00ff00
 #define BLUE 0x0000ff
 #define DEFAULT_FLAG	(1 << 0)
 
+static unsigned int color[] = {BLUE,BLUE,BLUE,BLUE,BLUE,BLUE,BLUE,BLUE,BLUE,BLUE,BLUE,BLUE,BLUE};
+
 static bool get_led_method(const char *method)
 {
 	GVariant *msg;
@@ -116,6 +121,25 @@ static bool set_led_stopcustom()
 	return set_led_method(METHOD_LED_STOPCUSTOM, NULL);
 }
 
+static bool get_multi_led_number(void)
+{
+	int ret;
+	int number_of_led;
+
+	ret = device_multi_led_get_number(&number_of_led);
+
+	return capi_result(METHOD_MULTI_LED_GETNUMBER, ret);
+}
+
+static bool set_multi_led_control(unsigned int color[])
+{
+	int ret;
+
+	ret = device_multi_led_control(color);
+
+	return capi_result(METHOD_MULTI_LED_CONTROL, ret);
+}
+
 void led_test_all(int *success, int *fail)
 {
 	int s = 0;
@@ -127,6 +151,8 @@ void led_test_all(int *success, int *fail)
 	(get_led_brightness())			? s++ : f++;
 	(set_led_playcustom(1, 0, RED, DEFAULT_FLAG))	? s++ : f++;
 	(set_led_stopcustom())			? s++ : f++;
+	(get_multi_led_number())		? s++ : f++;
+	(set_multi_led_control(color))		? s++ : f++;
 
 	if (NULL != success)    *success = s;
 	if (NULL != fail)       *fail = f;
@@ -165,6 +191,10 @@ static int led_unit(int argc, char **argv)
 		set_led_brightness(atoi(argv[4]), atoi(argv[5]));
 	} else if (0 == strcasecmp(argv[3], METHOD_LED_PLAYCUSTOM)) {
 		set_led_playcustom(atoi(argv[4]), atoi(argv[5]), strtoul(argv[6], NULL, 16), DEFAULT_FLAG);
+	} else if (0 == strcasecmp(argv[3], METHOD_MULTI_LED_GETNUMBER)) {
+		get_multi_led_number();
+	} else if (0 == strcasecmp(argv[3], METHOD_MULTI_LED_CONTROL)) {
+		set_multi_led_control(color);
 	} else if (0 == strcasecmp(argv[3], METHOD_LED_STOPCUSTOM)) {
 		set_led_stopcustom();
 	} else {
diff --git a/src/auto-test/pmqos.c b/src/auto-test/pmqos.c
new file mode 100644
index 00000000..de871b31
--- /dev/null
+++ b/src/auto-test/pmqos.c
@@ -0,0 +1,99 @@
+/*
+ * test
+ *
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "test.h"
+#include <device/pmqos-internal.h>
+
+#define METHOD_APP_LAUNCH_HOME		"AppLaunchHome"
+#define METHOD_HOMESCREEN		"HomeScreen"
+
+static bool pmqos_app_launch_home(void)
+{
+	int ret;
+
+	ret = device_pmqos_app_launch_home(3000);
+
+	return capi_result(METHOD_APP_LAUNCH_HOME, ret);
+}
+
+static bool pmqos_homescreen(void)
+{
+	int ret;
+
+	ret = device_pmqos_homescreen(3000);
+
+	return capi_result(METHOD_HOMESCREEN, ret);
+}
+
+static void pmqos_test_all(int *success, int *fail)
+{
+	int s = 0;
+	int f = 0;
+
+	(pmqos_app_launch_home())	? s++ : f++;
+	(pmqos_homescreen())		? s++ : f++;
+
+	if (NULL != success)    	*success = s;
+	if (NULL != fail)       	*fail = f;
+}
+
+static void pmqos_init(void *data)
+{
+	int success = 0;
+	int fail = 0;
+
+	_I("start test");
+
+	pmqos_test_all(&success, &fail);
+
+	_I("Total: %d, Success: %d, Fail: %d", success+fail, success, fail);
+}
+
+static void pmqos_exit(void *data)
+{
+	_I("end test");
+}
+
+static int pmqos_unit(int argc, char **argv)
+{
+	if (argc < 4) {
+		int success = 0;
+		int fail = 0;
+
+		_I("start test");
+		pmqos_test_all(&success, &fail);
+		_I("Total: %d, Success: %d, Fail: %d", success+fail, success, fail);
+	} else if (0 == strcasecmp(argv[3], METHOD_APP_LAUNCH_HOME)) {
+		pmqos_app_launch_home();
+	} else if (0 == strcasecmp(argv[3], METHOD_HOMESCREEN)) {
+		pmqos_homescreen();
+	} else {
+		_E("Unknown test case!!!");
+	}
+
+	return 0;
+}
+
+static const struct test_ops pmqos_test_ops = {
+	.priority = TEST_PRIORITY_NORMAL,
+	.name     = "pmqos",
+	.init     = pmqos_init,
+	.exit    = pmqos_exit,
+	.unit    = pmqos_unit,
+};
+
+TEST_OPS_REGISTER(&pmqos_test_ops)
diff --git a/src/auto-test/test.c b/src/auto-test/test.c
index 57106d83..794bb740 100644
--- a/src/auto-test/test.c
+++ b/src/auto-test/test.c
@@ -81,3 +81,56 @@ void test_exit(void *data)
 			d->exit(data);
 	}
 }
+
+void __cb(void *data, GVariant *result, GError *err)
+{
+	int temp = 0;
+
+   if (!result)
+     {
+        _E("Can't get result of touchscreen request.:%s", err->message);
+        return;
+     }
+
+	if (!dh_get_param_from_var(result, "(i)", &temp)) {
+		_E("Failed to get variant(%s): no call back message", g_variant_get_type_string(result));
+		goto out;
+	}
+	_I("replay message(%d)", temp);
+
+out:
+	g_variant_unref(result);
+}
+
+bool capi_result(const char *method, int val)
+{
+	bool ret;
+
+	if (val == DEVICE_ERROR_NOT_SUPPORTED) {
+		_I("Not supported feature! (%s): %d", method, val);
+		ret = TRUE;
+	} else if (val < 0) {
+		_E("fail (%s): returned fail (%d)", method, val);
+		ret = FALSE;
+	} else {
+		_I("success (%s): %d", method, val);
+		ret = TRUE;
+	}
+
+	return ret;
+}
+
+bool capi_reboot_result(const char *method, int val)
+{
+	bool ret = FALSE;
+
+	if (val == NORMAL_BOOT || val == SILENT_BOOT) {
+		_I("success (%s): %d", method, val);
+		ret = TRUE;
+	} else {
+		_E("fail (%s): returned fail (%d)", method, val);
+		ret = FALSE;
+	}
+
+	return ret;
+}
diff --git a/src/auto-test/test.h b/src/auto-test/test.h
index b324511b..65dbd440 100644
--- a/src/auto-test/test.h
+++ b/src/auto-test/test.h
@@ -24,6 +24,8 @@
 #include <errno.h>
 #include <sys/stat.h>
 #include <libsyscommon/dbus-system.h>
+#include <device-error.h>
+#include <device/booting-internal.h>
 
 #include "core/list.h"
 #include "core/common.h"
@@ -103,4 +105,7 @@ void remove_test(const struct test_ops *c);
 const struct test_ops *find_test(const char *name);
 void config_test();
 void _R(const char *format, ...);
+void __cb(void *data, GVariant *result, GError *err);
+bool capi_result(const char *method, int val);
+bool capi_reboot_result(const char *method, int val);
 #endif
diff --git a/src/auto-test/touchscreen.c b/src/auto-test/touchscreen.c
new file mode 100644
index 00000000..88e370ec
--- /dev/null
+++ b/src/auto-test/touchscreen.c
@@ -0,0 +1,99 @@
+/*
+ * test
+ *
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "test.h"
+#include <device/touchscreen-internal.h>
+
+#define METHOD_TOUCHSCREEN_ENABLE  	"Enable"
+#define METHOD_TOUCHSCREEN_DISABLE 	"Disable"
+
+static bool touchscreen_disable(void)
+{
+	int ret;
+
+	ret = device_touchscreen_disable(__cb);
+
+	return capi_result(METHOD_TOUCHSCREEN_DISABLE, ret);
+}
+
+static bool touchscreen_enable(void)
+{
+	int ret;
+
+	ret = device_touchscreen_enable(__cb);
+
+	return capi_result(METHOD_TOUCHSCREEN_ENABLE, ret);
+}
+
+static void touchscreen_test_all(int *success, int *fail)
+{
+	int s = 0;
+	int f = 0;
+
+	(touchscreen_disable())		? s++ : f++;
+	(touchscreen_enable())		? s++ : f++;
+
+	if (NULL != success)		*success = s;
+	if (NULL != fail)		*fail = f;
+}
+
+static void touchscreen_init(void *data)
+{
+	int success = 0;
+	int fail = 0;
+
+	_I("start test");
+
+	touchscreen_test_all(&success, &fail);
+
+	_I("Total: %d, Success: %d, Fail: %d", success+fail, success, fail);
+}
+
+static void touchscreen_exit(void *data)
+{
+	_I("end test");
+}
+
+static int touchscreen_unit(int argc, char **argv)
+{
+	if (argc < 4) {
+		int success = 0;
+		int fail = 0;
+
+		_I("start test");
+		touchscreen_test_all(&success, &fail);
+		_I("Total: %d, Success: %d, Fail: %d", success+fail, success, fail);
+	} else if (0 == strcasecmp(argv[3], METHOD_TOUCHSCREEN_ENABLE)) {
+		touchscreen_enable();
+	} else if (0 == strcasecmp(argv[3], METHOD_TOUCHSCREEN_DISABLE)) {
+		touchscreen_disable();
+	} else {
+		_E("Unknown test case!!!");
+	}
+
+	return 0;
+}
+
+static const struct test_ops touchscreen_test_ops = {
+	.priority = TEST_PRIORITY_NORMAL,
+	.name     = "touchscreen",
+	.init     = touchscreen_init,
+	.exit     = touchscreen_exit,
+	.unit     = touchscreen_unit,
+};
+
+TEST_OPS_REGISTER(&touchscreen_test_ops)