GPIO: fix unit test issue on ESP32-S2

Also rename some test variables.

components/driver/test/test_gpio.c

@@ -21,16 +21,24 @@
 #endif
 
 #define WAKE_UP_IGNORE 1  // gpio_wakeup function development is not completed yet, set it deprecated.
+
 #if CONFIG_IDF_TARGET_ESP32
-#define GPIO_OUTPUT_IO   18  // default output GPIO
-#define GPIO_INPUT_IO   19  // default input GPIO
-#define GPIO_OUTPUT_MAX GPIO_NUM_34
+#define TEST_GPIO_EXT_OUT_IO        18  // default output GPIO
+#define TEST_GPIO_EXT_IN_IO         19  // default input GPIO
+#define TEST_GPIO_OUTPUT_PIN        23
+#define TEST_GPIO_INPUT_ONLY_PIN    34
+#define TEST_GPIO_OUTPUT_MAX        GPIO_NUM_34
 #elif CONFIG_IDF_TARGET_ESP32S2
 // ESP32_S2 DEVKIC uses IO19 and IO20 as USB functions, so it is necessary to avoid using IO19, otherwise GPIO io pull up/down function cannot pass
-#define GPIO_OUTPUT_IO   18  // default output GPIO
-#define GPIO_INPUT_IO   21  // default input GPIO
-#define GPIO_OUTPUT_MAX GPIO_NUM_46
+// Also the first version of ESP32-S2-Saola has pullup issue on GPIO18, which is tied to 3V3 on the
+// runner. Also avoid using GPIO18.
+#define TEST_GPIO_EXT_OUT_IO        17  // default output GPIO
+#define TEST_GPIO_EXT_IN_IO         21  // default input GPIO
+#define TEST_GPIO_OUTPUT_PIN        26
+#define TEST_GPIO_INPUT_ONLY_PIN    46
+#define TEST_GPIO_OUTPUT_MAX        GPIO_NUM_46
 #endif
+
 static volatile int disable_intr_times = 0;  // use this to calculate how many times it go into interrupt
 static volatile int level_intr_times = 0;  // use this to get how many times the level interrupt happened
 static volatile int edge_intr_times = 0;   // use this to get how many times the edge interrupt happened
@@ -38,6 +46,7 @@ static volatile int edge_intr_times = 0;   // use this to get how many times the
 static bool wake_up_result = false;  // use this to judge the wake up event happen or not
 #endif
 
+
 /**
  * do some initialization operation in this function
  * @param num: it is the destination GPIO wanted to be initialized
@@ -45,7 +54,7 @@ static bool wake_up_result = false;  // use this to judge the wake up event happ
  */
 static gpio_config_t init_io(gpio_num_t num)
 {
-    TEST_ASSERT(num < GPIO_OUTPUT_MAX);
+    TEST_ASSERT(num < TEST_GPIO_OUTPUT_MAX);
     gpio_config_t io_conf;
     io_conf.intr_type = GPIO_PIN_INTR_DISABLE;
     io_conf.mode = GPIO_MODE_OUTPUT;
@@ -81,11 +90,11 @@ static void gpio_isr_level_handler2(void* arg)
     level_intr_times++;
     ets_printf("GPIO[%d] intr, val: %d\n", gpio_num, gpio_get_level(gpio_num));
     if(gpio_get_level(gpio_num)) {
-        gpio_set_level(GPIO_OUTPUT_IO, 0);
+        gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
     }else{
-        gpio_set_level(GPIO_OUTPUT_IO, 1);
+        gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
     }
-    ets_printf("GPIO[%d] intr, val: %d, level_intr_times = %d\n", GPIO_OUTPUT_IO, gpio_get_level(GPIO_OUTPUT_IO), level_intr_times);
+    ets_printf("GPIO[%d] intr, val: %d, level_intr_times = %d\n", TEST_GPIO_EXT_OUT_IO, gpio_get_level(TEST_GPIO_EXT_OUT_IO), level_intr_times);
     ets_printf("GPIO[%d] intr, val: %d, level_intr_times = %d\n", gpio_num, gpio_get_level(gpio_num), level_intr_times);
 }
 #endif
@@ -94,10 +103,10 @@ static void gpio_isr_level_handler2(void* arg)
 // get result of waking up or not
 static void sleep_wake_up(void *arg)
 {
-    gpio_config_t io_config = init_io(GPIO_INPUT_IO);
+    gpio_config_t io_config = init_io(TEST_GPIO_EXT_IN_IO);
     io_config.mode = GPIO_MODE_INPUT;
     gpio_config(&io_config);
-    TEST_ESP_OK(gpio_wakeup_enable(GPIO_INPUT_IO, GPIO_INTR_HIGH_LEVEL));
+    TEST_ESP_OK(gpio_wakeup_enable(TEST_GPIO_EXT_IN_IO, GPIO_INTR_HIGH_LEVEL));
     esp_light_sleep_start();
     wake_up_result = true;
 }
@@ -105,12 +114,12 @@ static void sleep_wake_up(void *arg)
 // wake up light sleep event
 static void trigger_wake_up(void *arg)
 {
-    gpio_config_t io_config = init_io(GPIO_OUTPUT_IO);
+    gpio_config_t io_config = init_io(TEST_GPIO_EXT_OUT_IO);
     gpio_config(&io_config);
-    gpio_set_level(GPIO_OUTPUT_IO, 0);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
     gpio_install_isr_service(0);
-    gpio_isr_handler_add(GPIO_OUTPUT_IO, gpio_isr_level_handler, (void*) GPIO_INPUT_IO);
-    gpio_set_level(GPIO_OUTPUT_IO, 1);
+    gpio_isr_handler_add(TEST_GPIO_EXT_OUT_IO, gpio_isr_level_handler, (void*) TEST_GPIO_EXT_IN_IO);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
     vTaskDelay(100 / portTICK_RATE_MS);
 }
 #endif
@@ -159,27 +168,15 @@ TEST_CASE("GPIO config parameters test", "[gpio]")
     io_config.pin_bit_mask = ((uint64_t)1<<GPIO_NUM_MAX);
     TEST_ASSERT(gpio_config(&io_config) == ESP_ERR_INVALID_ARG);
 
-#if CONFIG_IDF_TARGET_ESP32
-    io_config.pin_bit_mask = (uint64_t)1<<23;
+    io_config.pin_bit_mask = ((uint64_t)1<<TEST_GPIO_OUTPUT_PIN);
     TEST_ESP_OK(gpio_config(&io_config));
 
-    io_config.pin_bit_mask = ((uint64_t)1 << 34);
+    io_config.pin_bit_mask = ((uint64_t)1 << TEST_GPIO_INPUT_ONLY_PIN);
     io_config.mode = GPIO_MODE_INPUT;
     TEST_ESP_OK(gpio_config(&io_config));
     io_config.mode = GPIO_MODE_OUTPUT;
-    // ESP32 34-39 input only, once set as output should log something
+    // The pin is input only, once set as output should log something
     TEST_ASSERT(gpio_config(&io_config) == ESP_ERR_INVALID_ARG);
-#elif CONFIG_IDF_TARGET_ESP32S2
-    io_config.pin_bit_mask = (uint64_t)1<<26;
-    TEST_ESP_OK(gpio_config(&io_config));
-
-    io_config.pin_bit_mask = ((uint64_t)1 << 46);
-    io_config.mode = GPIO_MODE_INPUT;
-    TEST_ESP_OK(gpio_config(&io_config));
-    io_config.mode = GPIO_MODE_OUTPUT;
-    // ESP32-S2 46 input only, once set as output should log something
-    TEST_ASSERT(gpio_config(&io_config) == ESP_ERR_INVALID_ARG);
-#endif
 
 }
 
@@ -189,69 +186,69 @@ TEST_CASE("GPIO rising edge interrupt test", "[gpio][test_env=UT_T1_GPIO]")
 {
     edge_intr_times = 0;  // set it as 0 prepare to test
     //init input and output gpio
-    gpio_config_t output_io = init_io(GPIO_OUTPUT_IO);
-    gpio_config_t input_io = init_io(GPIO_INPUT_IO);
+    gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
+    gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
     input_io.intr_type = GPIO_INTR_POSEDGE;
     input_io.mode = GPIO_MODE_INPUT;
     input_io.pull_up_en = 1;
     TEST_ESP_OK(gpio_config(&output_io));
     TEST_ESP_OK(gpio_config(&input_io));
-    TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0));
+    TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0));
 
     //rising edge intr
-    TEST_ESP_OK(gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_POSEDGE));
+    TEST_ESP_OK(gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_POSEDGE));
     TEST_ESP_OK(gpio_install_isr_service(0));
-    gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_edge_handler, (void*)GPIO_INPUT_IO);
-    TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 1));
+    gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_edge_handler, (void*)TEST_GPIO_EXT_IN_IO);
+    TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1));
     TEST_ASSERT_EQUAL_INT(edge_intr_times, 1);
     vTaskDelay(100 / portTICK_RATE_MS);
-    gpio_isr_handler_remove(GPIO_INPUT_IO);
+    gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO);
     gpio_uninstall_isr_service();
 }
 
 TEST_CASE("GPIO falling edge interrupt test", "[gpio][test_env=UT_T1_GPIO]")
 {
     edge_intr_times = 0;
-    gpio_config_t output_io = init_io(GPIO_OUTPUT_IO);
-    gpio_config_t input_io = init_io(GPIO_INPUT_IO);
+    gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
+    gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
     input_io.intr_type = GPIO_INTR_POSEDGE;
     input_io.mode = GPIO_MODE_INPUT;
     input_io.pull_up_en = 1;
     TEST_ESP_OK(gpio_config(&output_io));
     TEST_ESP_OK(gpio_config(&input_io));
-    TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 1));
+    TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1));
 
-    gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_NEGEDGE);
+    gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_NEGEDGE);
     gpio_install_isr_service(0);
-    gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_edge_handler, (void*) GPIO_INPUT_IO);
-    gpio_set_level(GPIO_OUTPUT_IO, 0);
+    gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_edge_handler, (void*) TEST_GPIO_EXT_IN_IO);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
     vTaskDelay(100 / portTICK_RATE_MS);
     TEST_ASSERT_EQUAL_INT(edge_intr_times, 1);
     vTaskDelay(100 / portTICK_RATE_MS);
-    gpio_isr_handler_remove(GPIO_INPUT_IO);
+    gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO);
     gpio_uninstall_isr_service();
 }
 
 TEST_CASE("GPIO both rising and falling edge interrupt test", "[gpio][test_env=UT_T1_GPIO]")
 {
     edge_intr_times = 0;
-    gpio_config_t output_io = init_io(GPIO_OUTPUT_IO);
-    gpio_config_t input_io = init_io(GPIO_INPUT_IO);
+    gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
+    gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
     input_io.intr_type = GPIO_INTR_POSEDGE;
     input_io.mode = GPIO_MODE_INPUT;
     input_io.pull_up_en = 1;
     TEST_ESP_OK(gpio_config(&output_io));
     TEST_ESP_OK(gpio_config(&input_io));
-    TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0));
+    TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0));
     int level = 0;
 
-    gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_ANYEDGE);
+    gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_ANYEDGE);
     gpio_install_isr_service(0);
-    gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_edge_handler, (void*) GPIO_INPUT_IO);
+    gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_edge_handler, (void*) TEST_GPIO_EXT_IN_IO);
     // for rising edge in GPIO_INTR_ANYEDGE
     while(1) {
         level = level + 1;
-        gpio_set_level(GPIO_OUTPUT_IO, level*0.2);
+        gpio_set_level(TEST_GPIO_EXT_OUT_IO, level*0.2);
         if(level > 10) {
             break;
         }
@@ -261,7 +258,7 @@ TEST_CASE("GPIO both rising and falling edge interrupt test", "[gpio][test_env=U
     // for falling rdge in GPIO_INTR_ANYEDGE
     while(1) {
         level = level - 1;
-        gpio_set_level(GPIO_OUTPUT_IO, level/5);
+        gpio_set_level(TEST_GPIO_EXT_OUT_IO, level/5);
         if(level < 0) {
             break;
         }
@@ -270,29 +267,29 @@ TEST_CASE("GPIO both rising and falling edge interrupt test", "[gpio][test_env=U
     vTaskDelay(100 / portTICK_RATE_MS);
     TEST_ASSERT_EQUAL_INT(edge_intr_times, 2);
     vTaskDelay(100 / portTICK_RATE_MS);
-    gpio_isr_handler_remove(GPIO_INPUT_IO);
+    gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO);
     gpio_uninstall_isr_service();
 }
 
 TEST_CASE("GPIO input high level trigger, cut the interrupt source exit interrupt test", "[gpio][test_env=UT_T1_GPIO]")
 {
     level_intr_times=0;
-    gpio_config_t output_io = init_io(GPIO_OUTPUT_IO);
-    gpio_config_t input_io = init_io(GPIO_INPUT_IO);
+    gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
+    gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
     input_io.intr_type = GPIO_INTR_POSEDGE;
     input_io.mode = GPIO_MODE_INPUT;
     input_io.pull_up_en = 1;
     TEST_ESP_OK(gpio_config(&output_io));
     TEST_ESP_OK(gpio_config(&input_io));
-    TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0));
+    TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0));
 
-    gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_HIGH_LEVEL);
+    gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_HIGH_LEVEL);
     gpio_install_isr_service(0);
-    gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_level_handler2, (void*) GPIO_INPUT_IO);
-    gpio_set_level(GPIO_OUTPUT_IO, 1);
+    gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_level_handler2, (void*) TEST_GPIO_EXT_IN_IO);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
     vTaskDelay(100 / portTICK_RATE_MS);
     TEST_ASSERT_EQUAL_INT_MESSAGE(level_intr_times, 1, "go into high-level interrupt more than once with cur interrupt source way");
-    gpio_isr_handler_remove(GPIO_INPUT_IO);
+    gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO);
     gpio_uninstall_isr_service();
 
 }
@@ -300,80 +297,80 @@ TEST_CASE("GPIO input high level trigger, cut the interrupt source exit interrup
 TEST_CASE("GPIO low level interrupt test", "[gpio][test_env=UT_T1_GPIO]")
 {
     disable_intr_times=0;
-    gpio_config_t output_io = init_io(GPIO_OUTPUT_IO);
-    gpio_config_t input_io = init_io(GPIO_INPUT_IO);
+    gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
+    gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
     input_io.intr_type = GPIO_INTR_POSEDGE;
     input_io.mode = GPIO_MODE_INPUT;
     input_io.pull_up_en = 1;
     TEST_ESP_OK(gpio_config(&output_io));
     TEST_ESP_OK(gpio_config(&input_io));
-    TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 1));
+    TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1));
 
-    gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_LOW_LEVEL);
+    gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_LOW_LEVEL);
     gpio_install_isr_service(0);
-    gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_level_handler, (void*) GPIO_INPUT_IO);
-    gpio_set_level(GPIO_OUTPUT_IO, 0);
-    printf("get level:%d\n",gpio_get_level(GPIO_INPUT_IO));
+    gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_level_handler, (void*) TEST_GPIO_EXT_IN_IO);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
+    printf("get level:%d\n",gpio_get_level(TEST_GPIO_EXT_IN_IO));
     vTaskDelay(100 / portTICK_RATE_MS);
     TEST_ASSERT_EQUAL_INT_MESSAGE(disable_intr_times, 1, "go into low-level interrupt more than once with disable way");
-    gpio_isr_handler_remove(GPIO_INPUT_IO);
+    gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO);
     gpio_uninstall_isr_service();
 }
 
 TEST_CASE("GPIO multi-level interrupt test, to cut the interrupt source exit interrupt ", "[gpio][test_env=UT_T1_GPIO]")
 {
     level_intr_times=0;
-    gpio_config_t output_io = init_io(GPIO_OUTPUT_IO);
-    gpio_config_t input_io = init_io(GPIO_INPUT_IO);
+    gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
+    gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
     input_io.intr_type = GPIO_INTR_POSEDGE;
     input_io.mode = GPIO_MODE_INPUT;
     input_io.pull_up_en = 1;
     TEST_ESP_OK(gpio_config(&output_io));
     TEST_ESP_OK(gpio_config(&input_io));
-    TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0));
+    TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0));
 
-    gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_HIGH_LEVEL);
+    gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_HIGH_LEVEL);
     gpio_install_isr_service(0);
-    gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_level_handler2, (void*) GPIO_INPUT_IO);
-    gpio_set_level(GPIO_OUTPUT_IO, 1);
+    gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_level_handler2, (void*) TEST_GPIO_EXT_IN_IO);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
     vTaskDelay(100 / portTICK_RATE_MS);
     TEST_ASSERT_EQUAL_INT_MESSAGE(level_intr_times, 1, "go into high-level interrupt more than once with cur interrupt source way");
-    gpio_set_level(GPIO_OUTPUT_IO, 1);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
     vTaskDelay(200 / portTICK_RATE_MS);
     TEST_ASSERT_EQUAL_INT_MESSAGE(level_intr_times, 2, "go into high-level interrupt more than once with cur interrupt source way");
-    gpio_isr_handler_remove(GPIO_INPUT_IO);
+    gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO);
     gpio_uninstall_isr_service();
 }
 
 TEST_CASE("GPIO enable and disable interrupt test", "[gpio][test_env=UT_T1_GPIO]")
 {
     disable_intr_times = 0;
-    gpio_config_t output_io = init_io(GPIO_OUTPUT_IO);
-    gpio_config_t input_io = init_io(GPIO_INPUT_IO);
+    gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
+    gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
     input_io.intr_type = GPIO_INTR_POSEDGE;
     input_io.mode = GPIO_MODE_INPUT;
     input_io.pull_up_en = 1;
     TEST_ESP_OK(gpio_config(&output_io));
     TEST_ESP_OK(gpio_config(&input_io));
 
-    TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0)); // Because of GPIO_INTR_HIGH_LEVEL interrupt, 0 must be set first
-    TEST_ESP_OK(gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_HIGH_LEVEL));
+    TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0)); // Because of GPIO_INTR_HIGH_LEVEL interrupt, 0 must be set first
+    TEST_ESP_OK(gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_HIGH_LEVEL));
     TEST_ESP_OK(gpio_install_isr_service(0));
-    TEST_ESP_OK(gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_level_handler, (void*) GPIO_INPUT_IO));
-    TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 1));
-    TEST_ESP_OK(gpio_isr_handler_remove(GPIO_INPUT_IO));
-    TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0));
+    TEST_ESP_OK(gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_level_handler, (void*) TEST_GPIO_EXT_IN_IO));
+    TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1));
+    TEST_ESP_OK(gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO));
+    TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0));
     TEST_ASSERT_EQUAL_INT_MESSAGE(disable_intr_times, 1, "go into high-level interrupt more than once with disable way");
 
     // not install service now
     vTaskDelay(100 / portTICK_RATE_MS);
-    TEST_ESP_OK(gpio_intr_disable(GPIO_INPUT_IO));
-    TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 1));
+    TEST_ESP_OK(gpio_intr_disable(TEST_GPIO_EXT_IN_IO));
+    TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1));
     TEST_ASSERT_EQUAL_INT_MESSAGE(disable_intr_times, 1, "disable interrupt does not work, still go into interrupt!");
 
     gpio_uninstall_isr_service();  //uninstall the service
-    TEST_ASSERT(gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_level_handler, (void*) GPIO_INPUT_IO) == ESP_ERR_INVALID_STATE);
-    TEST_ASSERT(gpio_isr_handler_remove(GPIO_INPUT_IO) == ESP_ERR_INVALID_STATE);
+    TEST_ASSERT(gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_level_handler, (void*) TEST_GPIO_EXT_IN_IO) == ESP_ERR_INVALID_STATE);
+    TEST_ASSERT(gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO) == ESP_ERR_INVALID_STATE);
 }
 #endif //DISABLED_FOR_TARGETS(ESP32S2)
 
@@ -384,37 +381,28 @@ TEST_CASE("GPIO set gpio output level test", "[gpio][ignore]")
     gpio_config_t io_conf;
     io_conf.intr_type = GPIO_PIN_INTR_DISABLE;
     io_conf.mode = GPIO_MODE_OUTPUT;
-    io_conf.pin_bit_mask = (1<<GPIO_OUTPUT_IO);
+    io_conf.pin_bit_mask = (1<<TEST_GPIO_EXT_OUT_IO);
     io_conf.pull_down_en = 0;
     io_conf.pull_up_en = 0;
     gpio_config(&io_conf);
 
-    io_conf.pin_bit_mask = (1<<GPIO_INPUT_IO);
+    io_conf.pin_bit_mask = (1<<TEST_GPIO_EXT_IN_IO);
     io_conf.mode = GPIO_MODE_INPUT;
     gpio_config(&io_conf);
 
-    gpio_set_level(GPIO_OUTPUT_IO, 0);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
     // tested voltage is around 0v
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "get level error! the level should be low!");
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "get level error! the level should be low!");
     vTaskDelay(1000 / portTICK_RATE_MS);
-    gpio_set_level(GPIO_OUTPUT_IO, 1);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
     // tested voltage is around 3.3v
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 1, "get level error! the level should be high!");
-
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 1, "get level error! the level should be high!");
 
-#if CONFIG_IDF_TARGET_ESP32
-    //ESP32 IO34-39 are just used for input
-    io_conf.pin_bit_mask = ((uint64_t)1<<34);
+    //This IO is just used for input
+    io_conf.pin_bit_mask = ((uint64_t)1<<TEST_GPIO_INPUT_ONLY_PIN);
     io_conf.mode = GPIO_MODE_OUTPUT;
     gpio_config(&io_conf);
     TEST_ASSERT(gpio_config(&io_conf) == ESP_ERR_INVALID_ARG);
-#elif CONFIG_IDF_TARGET_ESP32S2
-    //ESP32-S2 IO46 are just used for input
-    io_conf.pin_bit_mask = ((uint64_t)1<<46);
-    io_conf.mode = GPIO_MODE_OUTPUT;
-    gpio_config(&io_conf);
-    TEST_ASSERT(gpio_config(&io_conf) == ESP_ERR_INVALID_ARG);
-#endif
 }
 
 // gpio17 connects to 3.3v pin, gpio19 connects to the GND pin
@@ -443,24 +431,24 @@ TEST_CASE("GPIO get input level test", "[gpio][ignore]")
 TEST_CASE("GPIO io pull up/down function", "[gpio]")
 {
     // First, ensure that the output IO will not affect the level
-    gpio_config_t  io_conf = init_io(GPIO_OUTPUT_IO);
+    gpio_config_t  io_conf = init_io(TEST_GPIO_EXT_OUT_IO);
     gpio_config(&io_conf);
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT);
-    io_conf = init_io(GPIO_INPUT_IO);
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT);
+    io_conf = init_io(TEST_GPIO_EXT_IN_IO);
     gpio_config(&io_conf);
-    gpio_set_direction(GPIO_INPUT_IO, GPIO_MODE_INPUT);
-    TEST_ESP_OK(gpio_pullup_en(GPIO_INPUT_IO));  // pull up first
+    gpio_set_direction(TEST_GPIO_EXT_IN_IO, GPIO_MODE_INPUT);
+    TEST_ESP_OK(gpio_pullup_en(TEST_GPIO_EXT_IN_IO));  // pull up first
     vTaskDelay(100 / portTICK_RATE_MS);
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 1, "gpio_pullup_en error, it can't pull up");
-    TEST_ESP_OK(gpio_pulldown_dis(GPIO_INPUT_IO)); //can't be pull down
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 1, "gpio_pullup_en error, it can't pull up");
+    TEST_ESP_OK(gpio_pulldown_dis(TEST_GPIO_EXT_IN_IO)); //can't be pull down
     vTaskDelay(100 / portTICK_RATE_MS);
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 1, "gpio_pulldown_dis error, it can pull down");
-    TEST_ESP_OK(gpio_pulldown_en(GPIO_INPUT_IO)); // can be pull down now
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 1, "gpio_pulldown_dis error, it can pull down");
+    TEST_ESP_OK(gpio_pulldown_en(TEST_GPIO_EXT_IN_IO)); // can be pull down now
     vTaskDelay(100 / portTICK_RATE_MS);
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "gpio_pulldown_en error, it can't pull down");
-    TEST_ESP_OK(gpio_pullup_dis(GPIO_INPUT_IO)); // can't be pull up
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "gpio_pulldown_en error, it can't pull down");
+    TEST_ESP_OK(gpio_pullup_dis(TEST_GPIO_EXT_IN_IO)); // can't be pull up
     vTaskDelay(100 / portTICK_RATE_MS);
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "gpio_pullup_dis error, it can pull up");
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "gpio_pullup_dis error, it can pull up");
 }
 
 #if !TEMPORARY_DISABLED_FOR_TARGETS(ESP32S2)
@@ -468,71 +456,71 @@ TEST_CASE("GPIO io pull up/down function", "[gpio]")
 TEST_CASE("GPIO output and input mode test", "[gpio][test_env=UT_T1_GPIO]")
 {
     //ESP32 connect io18 and io19, ESP32-S2 connect io18 and io21
-    gpio_config_t output_io = init_io(GPIO_OUTPUT_IO);
-    gpio_config_t input_io = init_io(GPIO_INPUT_IO);
+    gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
+    gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
     gpio_config(&output_io);
     gpio_config(&input_io);
-    int level = gpio_get_level(GPIO_INPUT_IO);
+    int level = gpio_get_level(TEST_GPIO_EXT_IN_IO);
 
     //disable mode
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_DISABLE);
-    gpio_set_direction(GPIO_INPUT_IO, GPIO_MODE_OUTPUT);
-    gpio_set_level(GPIO_OUTPUT_IO, !level);
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), level, "direction GPIO_MODE_DISABLE set error, it can output");
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_DISABLE);
+    gpio_set_direction(TEST_GPIO_EXT_IN_IO, GPIO_MODE_OUTPUT);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, !level);
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), level, "direction GPIO_MODE_DISABLE set error, it can output");
 
     //input mode and output mode
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_OUTPUT);
-    gpio_set_direction(GPIO_INPUT_IO, GPIO_MODE_INPUT);
-    gpio_set_level(GPIO_OUTPUT_IO, 1);
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 1, "direction GPIO_MODE_OUTPUT set error, it can't output");
-    gpio_set_level(GPIO_OUTPUT_IO, 0);
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_OUTPUT);
+    gpio_set_direction(TEST_GPIO_EXT_IN_IO, GPIO_MODE_INPUT);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 1, "direction GPIO_MODE_OUTPUT set error, it can't output");
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
 
     // open drain mode(output), can just output low level
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_OUTPUT_OD);
-    gpio_set_direction(GPIO_INPUT_IO, GPIO_MODE_INPUT);
-    gpio_set_level(GPIO_OUTPUT_IO, 1);
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
-    gpio_set_level(GPIO_OUTPUT_IO, 0);
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_OUTPUT_OD);
+    gpio_set_direction(TEST_GPIO_EXT_IN_IO, GPIO_MODE_INPUT);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
 
     // open drain mode(output and input), can just output low level
     // output test
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT_OUTPUT_OD);
-    gpio_set_direction(GPIO_INPUT_IO, GPIO_MODE_INPUT);
-    gpio_set_level(GPIO_OUTPUT_IO, 1);
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
-    gpio_set_level(GPIO_OUTPUT_IO, 0);
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT_OUTPUT_OD);
+    gpio_set_direction(TEST_GPIO_EXT_IN_IO, GPIO_MODE_INPUT);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
 
     // GPIO_MODE_INPUT_OUTPUT mode
     // output test
-    level = gpio_get_level(GPIO_INPUT_IO);
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT_OUTPUT);
-    gpio_set_direction(GPIO_INPUT_IO, GPIO_MODE_INPUT);
-    gpio_set_level(GPIO_OUTPUT_IO, !level);
-    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), !level, "direction set error, it can't output");
+    level = gpio_get_level(TEST_GPIO_EXT_IN_IO);
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT_OUTPUT);
+    gpio_set_direction(TEST_GPIO_EXT_IN_IO, GPIO_MODE_INPUT);
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, !level);
+    TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), !level, "direction set error, it can't output");
 }
 
 TEST_CASE("GPIO repeate call service and isr has no memory leak test","[gpio][test_env=UT_T1_GPIO][timeout=90]")
 {
-    gpio_config_t output_io = init_io(GPIO_OUTPUT_IO);
-    gpio_config_t input_io = init_io(GPIO_INPUT_IO);
+    gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
+    gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
     input_io.intr_type = GPIO_INTR_POSEDGE;
     input_io.mode = GPIO_MODE_INPUT;
     input_io.pull_up_en = 1;
     TEST_ESP_OK(gpio_config(&output_io));
     TEST_ESP_OK(gpio_config(&input_io));
-    TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0));
+    TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0));
     //rising edge
     uint32_t size = esp_get_free_heap_size();
     for(int i=0;i<1000;i++) {
-        TEST_ESP_OK(gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_POSEDGE));
+        TEST_ESP_OK(gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_POSEDGE));
         TEST_ESP_OK(gpio_install_isr_service(0));
-        TEST_ESP_OK(gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_edge_handler, (void*)GPIO_INPUT_IO));
-        gpio_set_level(GPIO_OUTPUT_IO, 1);
-        TEST_ESP_OK(gpio_isr_handler_remove(GPIO_INPUT_IO));
-        gpio_set_level(GPIO_OUTPUT_IO, 0);
+        TEST_ESP_OK(gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_edge_handler, (void*)TEST_GPIO_EXT_IN_IO));
+        gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
+        TEST_ESP_OK(gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO));
+        gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
         gpio_uninstall_isr_service();
     }
     TEST_ASSERT_INT32_WITHIN(size, esp_get_free_heap_size(), 100);
@@ -549,8 +537,8 @@ TEST_CASE("GPIO wake up enable and disenable test", "[gpio][ignore]")
     TEST_ASSERT_TRUE(wake_up_result);
 
     wake_up_result = false;
-    TEST_ESP_OK(gpio_wakeup_disable(GPIO_INPUT_IO));
-    gpio_set_level(GPIO_OUTPUT_IO, 1);
+    TEST_ESP_OK(gpio_wakeup_disable(TEST_GPIO_EXT_IN_IO));
+    gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
     vTaskDelay(100 / portTICK_RATE_MS);
     TEST_ASSERT_FALSE(wake_up_result);
 }
@@ -560,56 +548,56 @@ TEST_CASE("GPIO wake up enable and disenable test", "[gpio][ignore]")
 // ignored because the voltage needs to be tested with multimeter
 TEST_CASE("GPIO verify only the gpio with input ability can be set pull/down", "[gpio][ignore]")
 {
-    gpio_config_t  output_io = init_io(GPIO_OUTPUT_IO);
-    gpio_config_t  input_io = init_io(GPIO_INPUT_IO);
+    gpio_config_t  output_io = init_io(TEST_GPIO_EXT_OUT_IO);
+    gpio_config_t  input_io = init_io(TEST_GPIO_EXT_IN_IO);
     gpio_config(&output_io);
     input_io.mode = GPIO_MODE_INPUT;
     gpio_config(&input_io);
 
     printf("pull up test!\n");
     // pull up test
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_OUTPUT);
-    TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLUP_ONLY));
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_OUTPUT);
+    TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLUP_ONLY));
     prompt_to_continue("mode: GPIO_MODE_OUTPUT");
 
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_OUTPUT_OD);
-    TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLUP_ONLY));
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_OUTPUT_OD);
+    TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLUP_ONLY));
 
     // open drain just can output low level
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT_OUTPUT_OD);
-    TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLUP_ONLY));
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT_OUTPUT_OD);
+    TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLUP_ONLY));
     prompt_to_continue("mode: GPIO_MODE_OUTPUT_OD");
 
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT_OUTPUT);
-    TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLUP_ONLY));
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT_OUTPUT);
+    TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLUP_ONLY));
     prompt_to_continue("mode: GPIO_MODE_INPUT_OUTPUT");
 
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT);
-    TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLUP_ONLY));
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT);
+    TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLUP_ONLY));
     prompt_to_continue("mode: GPIO_MODE_INPUT");
 
     // after pull up the level is high now
     // pull down test
     printf("pull down test!\n");
 
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_OUTPUT);
-    TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLDOWN_ONLY));
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_OUTPUT);
+    TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLDOWN_ONLY));
     prompt_to_continue("mode: GPIO_MODE_OUTPUT");
 
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_OUTPUT_OD);
-    TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLDOWN_ONLY));
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_OUTPUT_OD);
+    TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLDOWN_ONLY));
     prompt_to_continue("mode: GPIO_MODE_OUTPUT_OD");
 
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT_OUTPUT_OD);
-    TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLDOWN_ONLY));
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT_OUTPUT_OD);
+    TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLDOWN_ONLY));
     prompt_to_continue("mode: GPIO_MODE_INPUT_OUTPUT_OD");
 
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT_OUTPUT);
-    TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLDOWN_ONLY));
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT_OUTPUT);
+    TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLDOWN_ONLY));
     prompt_to_continue("mode: GPIO_MODE_INPUT_OUTPUT");
 
-    gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT);
-    TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLDOWN_ONLY));
+    gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT);
+    TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLDOWN_ONLY));
     prompt_to_continue("mode: GPIO_MODE_INPUT");
 }
 
@@ -642,23 +630,23 @@ TEST_CASE("GPIO verify only the gpio with input ability can be set pull/down", "
 TEST_CASE("GPIO drive capability test", "[gpio][ignore]")
 {
     printf("weak capability test! please view the current change!\n");
-    drive_capability_set_get(GPIO_OUTPUT_IO, GPIO_DRIVE_CAP_0);
+    drive_capability_set_get(TEST_GPIO_EXT_OUT_IO, GPIO_DRIVE_CAP_0);
     prompt_to_continue("If this test finishes");
 
     printf("stronger capability test! please view the current change!\n");
-    drive_capability_set_get(GPIO_OUTPUT_IO, GPIO_DRIVE_CAP_1);
+    drive_capability_set_get(TEST_GPIO_EXT_OUT_IO, GPIO_DRIVE_CAP_1);
     prompt_to_continue("If this test finishes");
 
     printf("default capability test! please view the current change!\n");
-    drive_capability_set_get(GPIO_OUTPUT_IO, GPIO_DRIVE_CAP_2);
+    drive_capability_set_get(TEST_GPIO_EXT_OUT_IO, GPIO_DRIVE_CAP_2);
     prompt_to_continue("If this test finishes");
 
     printf("default capability2 test! please view the current change!\n");
-    drive_capability_set_get(GPIO_OUTPUT_IO, GPIO_DRIVE_CAP_DEFAULT);
+    drive_capability_set_get(TEST_GPIO_EXT_OUT_IO, GPIO_DRIVE_CAP_DEFAULT);
     prompt_to_continue("If this test finishes");
 
     printf("strongest capability test! please view the current change!\n");
-    drive_capability_set_get(GPIO_OUTPUT_IO, GPIO_DRIVE_CAP_3);
+    drive_capability_set_get(TEST_GPIO_EXT_OUT_IO, GPIO_DRIVE_CAP_3);
     prompt_to_continue("If this test finishes");
 }