diff --git a/firmware/2lib/2ui.c b/firmware/2lib/2ui.c
index adf0786..b7a9cad 100644
--- a/firmware/2lib/2ui.c
+++ b/firmware/2lib/2ui.c
@@ -74,85 +74,6 @@
 /* Menu navigation actions */
 
 /**
- * Update selected_item, taking into account disabled indices (from
- * disabled_item_mask).  The selection does not wrap, meaning that we block
- * on the 0 or max index when we hit the top or bottom of the menu.
- */
-vb2_error_t menu_up_action(struct vb2_ui_context *ui)
-{
-	int item;
-
-	if (!DETACHABLE && ui->key == VB_BUTTON_VOL_UP_SHORT_PRESS)
-		return VB2_REQUEST_UI_CONTINUE;
-
-	item = ui->state.selected_item - 1;
-	while (item >= 0 &&
-	       ((1 << item) & ui->state.disabled_item_mask))
-		item--;
-	/* Only update if item is valid */
-	if (item >= 0)
-		ui->state.selected_item = item;
-
-	return VB2_REQUEST_UI_CONTINUE;
-}
-
-vb2_error_t menu_down_action(struct vb2_ui_context *ui)
-{
-	int item;
-
-	if (!DETACHABLE && ui->key == VB_BUTTON_VOL_DOWN_SHORT_PRESS)
-		return VB2_REQUEST_UI_CONTINUE;
-
-	item = ui->state.selected_item + 1;
-	while (item < ui->state.screen->num_items &&
-	       ((1 << item) & ui->state.disabled_item_mask))
-		item++;
-	/* Only update if item is valid */
-	if (item < ui->state.screen->num_items)
-		ui->state.selected_item = item;
-
-	return VB2_REQUEST_UI_CONTINUE;
-}
-
-/**
- * Navigate to the target screen of the current menu item selection.
- */
-vb2_error_t vb2_ui_menu_select_action(struct vb2_ui_context *ui)
-{
-	const struct vb2_menu_item *menu_item;
-
-	if (!DETACHABLE && ui->key == VB_BUTTON_POWER_SHORT_PRESS)
-		return VB2_REQUEST_UI_CONTINUE;
-
-	if (ui->state.screen->num_items == 0)
-		return VB2_REQUEST_UI_CONTINUE;
-
-	menu_item = &ui->state.screen->items[ui->state.selected_item];
-
-	if (menu_item->action) {
-		VB2_DEBUG("Menu item <%s> run action\n", menu_item->text);
-		return menu_item->action(ui);
-	} else if (menu_item->target) {
-		VB2_DEBUG("Menu item <%s> to target screen %#x\n",
-			  menu_item->text, menu_item->target);
-		return vb2_ui_change_screen(ui, menu_item->target);
-	}
-
-	VB2_DEBUG("Menu item <%s> no action or target screen\n",
-		  menu_item->text);
-	return VB2_REQUEST_UI_CONTINUE;
-}
-
-/**
- * Return back to the previous screen.
- */
-vb2_error_t vb2_ui_back_action(struct vb2_ui_context *ui)
-{
-	/* TODO(kitching): Return to previous screen instead of root screen. */
-	return vb2_ui_change_screen(ui, ui->root_screen->id);
-}
-
-/**
  * Context-dependent keyboard shortcut Ctrl+D.
  *
  * - Manual recovery mode: Change to dev mode transition screen.
@@ -180,22 +101,31 @@
 /* Action lookup tables */
 
 static struct input_action action_table[] = {
-	{ VB_KEY_UP,				menu_up_action },
-	{ VB_KEY_DOWN,				menu_down_action },
-	{ VB_KEY_ENTER,  			vb2_ui_menu_select_action },
-	{ VB_BUTTON_VOL_UP_SHORT_PRESS, 	menu_up_action },
-	{ VB_BUTTON_VOL_DOWN_SHORT_PRESS, 	menu_down_action },
-	{ VB_BUTTON_POWER_SHORT_PRESS, 		vb2_ui_menu_select_action },
-	{ VB_KEY_ESC, 			 	vb2_ui_back_action },
+	/* Common navigation (keyboard) */
+	{ VB_KEY_UP,				vb2_ui_menu_prev },
+	{ VB_KEY_DOWN,				vb2_ui_menu_next },
+	{ VB_KEY_ENTER,  			vb2_ui_menu_select },
+	{ VB_KEY_ESC, 			 	vb2_ui_change_root },
+
+	/* Common navigation (detachable) */
+	{ VB_BUTTON_VOL_UP_SHORT_PRESS, 	vb2_ui_menu_prev },
+	{ VB_BUTTON_VOL_DOWN_SHORT_PRESS, 	vb2_ui_menu_next },
+	{ VB_BUTTON_POWER_SHORT_PRESS, 		vb2_ui_menu_select },
+
+	/* Context-specific: developer and recovery */
 	{ VB_KEY_CTRL('D'),		 	ctrl_d_action },
-	{ VB_BUTTON_VOL_DOWN_LONG_PRESS,
-	  vb2_ui_developer_mode_boot_internal_action },
+
+	/* Context-specific: recovery mode */
 	{ VB_BUTTON_VOL_UP_DOWN_COMBO_PRESS,	change_to_dev_screen_action },
 	{ ' ',					vb2_ui_recovery_to_dev_action },
+
+	/* Context-specific: developer mode */
 	{ VB_KEY_CTRL('U'),
 	  vb2_ui_developer_mode_boot_external_action },
 	{ VB_BUTTON_VOL_UP_LONG_PRESS,
 	  vb2_ui_developer_mode_boot_external_action },
+	{ VB_BUTTON_VOL_DOWN_LONG_PRESS,
+	  vb2_ui_developer_mode_boot_internal_action },
 };
 
 vb2_error_t (*input_action_lookup(int key))(struct vb2_ui_context *ui)
@@ -208,7 +138,77 @@
 }
 
 /*****************************************************************************/
-/* Core UI functions */
+/* Menu navigation functions */
+
+vb2_error_t vb2_ui_menu_prev(struct vb2_ui_context *ui)
+{
+	int item;
+
+	if (!DETACHABLE && ui->key == VB_BUTTON_VOL_UP_SHORT_PRESS)
+		return VB2_REQUEST_UI_CONTINUE;
+
+	item = ui->state.selected_item - 1;
+	while (item >= 0 &&
+	       ((1 << item) & ui->state.disabled_item_mask))
+		item--;
+	/* Only update if item is valid */
+	if (item >= 0)
+		ui->state.selected_item = item;
+
+	return VB2_REQUEST_UI_CONTINUE;
+}
+
+vb2_error_t vb2_ui_menu_next(struct vb2_ui_context *ui)
+{
+	int item;
+
+	if (!DETACHABLE && ui->key == VB_BUTTON_VOL_DOWN_SHORT_PRESS)
+		return VB2_REQUEST_UI_CONTINUE;
+
+	item = ui->state.selected_item + 1;
+	while (item < ui->state.screen->num_items &&
+	       ((1 << item) & ui->state.disabled_item_mask))
+		item++;
+	/* Only update if item is valid */
+	if (item < ui->state.screen->num_items)
+		ui->state.selected_item = item;
+
+	return VB2_REQUEST_UI_CONTINUE;
+}
+
+vb2_error_t vb2_ui_menu_select(struct vb2_ui_context *ui)
+{
+	const struct vb2_menu_item *menu_item;
+
+	if (!DETACHABLE && ui->key == VB_BUTTON_POWER_SHORT_PRESS)
+		return VB2_REQUEST_UI_CONTINUE;
+
+	if (ui->state.screen->num_items == 0)
+		return VB2_REQUEST_UI_CONTINUE;
+
+	menu_item = &ui->state.screen->items[ui->state.selected_item];
+
+	if (menu_item->action) {
+		VB2_DEBUG("Menu item <%s> run action\n", menu_item->text);
+		return menu_item->action(ui);
+	} else if (menu_item->target) {
+		VB2_DEBUG("Menu item <%s> to target screen %#x\n",
+			  menu_item->text, menu_item->target);
+		return vb2_ui_change_screen(ui, menu_item->target);
+	}
+
+	VB2_DEBUG("Menu item <%s> no action or target screen\n",
+		  menu_item->text);
+	return VB2_REQUEST_UI_CONTINUE;
+}
+
+/*****************************************************************************/
+/* Screen navigation functions */
+
+vb2_error_t vb2_ui_change_root(struct vb2_ui_context *ui)
+{
+	return vb2_ui_change_screen(ui, ui->root_screen->id);
+}
 
 vb2_error_t vb2_ui_change_screen(struct vb2_ui_context *ui, enum vb2_screen id)
 {
@@ -234,6 +234,9 @@
 	return VB2_REQUEST_UI_CONTINUE;
 }
 
+/*****************************************************************************/
+/* Core UI loop */
+
 vb2_error_t ui_loop(struct vb2_context *ctx, enum vb2_screen root_screen_id,
 		    vb2_error_t (*global_action)(struct vb2_ui_context *ui))
 {
diff --git a/firmware/2lib/2ui_screens.c b/firmware/2lib/2ui_screens.c
index 90a1020..2c8f57b 100644
--- a/firmware/2lib/2ui_screens.c
+++ b/firmware/2lib/2ui_screens.c
@@ -67,7 +67,7 @@
 	},
 	[ADVANCED_OPTIONS_ITEM_BACK] = {
 		.text = "Back",
-		.action = vb2_ui_back_action,
+		.action = vb2_ui_change_root,
 	},
 };
 
@@ -132,12 +132,12 @@
 {
 	if (vb2_get_sd(ui->ctx)->flags & VB2_SD_FLAG_DEV_MODE_ENABLED) {
 		VB2_DEBUG("Dev mode already enabled?\n");
-		return vb2_ui_back_action(ui);
+		return vb2_ui_change_root(ui);
 	}
 
 	if (!PHYSICAL_PRESENCE_KEYBOARD && vb2ex_physical_presence_pressed()) {
 		VB2_DEBUG("Presence button stuck?\n");
-		return vb2_ui_back_action(ui);
+		return vb2_ui_change_root(ui);
 	}
 
 	/* Disable "Confirm" button for other physical presence types. */
@@ -163,7 +163,7 @@
 
 	if (ui->key == ' ') {
 		VB2_DEBUG("SPACE means cancel dev mode transition\n");
-		return vb2_ui_back_action(ui);
+		return vb2_ui_change_root(ui);
 	}
 
 	if (PHYSICAL_PRESENCE_KEYBOARD) {
@@ -209,7 +209,7 @@
 	},
 	[RECOVERY_TO_DEV_ITEM_CANCEL] = {
 		.text = "Cancel",
-		.action = vb2_ui_back_action,
+		.action = vb2_ui_change_root,
 	},
 };
 
@@ -332,7 +332,7 @@
 	if (use_short && elapsed > 2 * VB_USEC_PER_SEC) {
 		VB2_DEBUG("Booting default target after 2s\n");
 		ui->disable_timer = 1;
-		return vb2_ui_menu_select_action(ui);
+		return vb2_ui_menu_select(ui);
 	}
 
 	/* Otherwise, beep at 20 and 20.5 seconds. */
@@ -346,7 +346,7 @@
 	if (elapsed > 30 * VB_USEC_PER_SEC) {
 		VB2_DEBUG("Booting default target after 30s\n");
 		ui->disable_timer = 1;
-		return vb2_ui_menu_select_action(ui);
+		return vb2_ui_menu_select(ui);
 	}
 
 	return VB2_REQUEST_UI_CONTINUE;
@@ -398,7 +398,7 @@
 	},
 	{
 		.text = "Cancel",
-		.action = vb2_ui_back_action,
+		.action = vb2_ui_change_root,
 	},
 };
 
diff --git a/firmware/2lib/include/2ui.h b/firmware/2lib/include/2ui.h
index 73dd1c7..35716bb 100644
--- a/firmware/2lib/include/2ui.h
+++ b/firmware/2lib/include/2ui.h
@@ -95,6 +95,68 @@
 const struct vb2_screen_info *vb2_get_screen_info(enum vb2_screen id);
 
 /*****************************************************************************/
+/* Menu navigation functions */
+
+/**
+ * Move selection to the previous menu item.
+ *
+ * Update selected_item, taking into account disabled indices (from
+ * disabled_item_mask).  The selection does not wrap, meaning that we block
+ * on 0 when we hit the start of the menu.
+ *
+ * @param ui		UI context pointer
+ * @return VB2_REQUEST_UI_CONTINUE, or error code on error.
+ */
+vb2_error_t vb2_ui_menu_prev(struct vb2_ui_context *ui);
+
+/**
+ * Move selection to the next menu item.
+ *
+ * Update selected_item, taking into account disabled indices (from
+ * disabled_item_mask).  The selection does not wrap, meaning that we block
+ * on the max index when we hit the end of the menu.
+ *
+ * @param ui		UI context pointer
+ * @return VB2_REQUEST_UI_CONTINUE, or error code on error.
+ */
+vb2_error_t vb2_ui_menu_next(struct vb2_ui_context *ui);
+
+/**
+ * Select the current menu item.
+ *
+ * If the current menu item has an action associated with it, run the action.
+ * Otherwise, navigate to the target screen.  If neither of these are set, then
+ * selecting the menu item is a no-op.
+ *
+ * @param ui		UI context pointer
+ * @return VB2_REQUEST_UI_CONTINUE, or error code on error.
+ */
+vb2_error_t vb2_ui_menu_select(struct vb2_ui_context *ui);
+
+/*****************************************************************************/
+/* Screen navigation functions */
+
+/**
+ * Return back to the root screen.
+ *
+ * Return to the root screen originally provided to the ui_loop() function.
+ *
+ * @param ui		UI context pointer
+ * @return VB2_REQUEST_UI_CONTINUE, or error code on error.
+ */
+vb2_error_t vb2_ui_change_root(struct vb2_ui_context *ui);
+
+/**
+ * Change to the given screen.
+ *
+ * If the screen is not found, the request is ignored.
+ *
+ * @param ui		UI context pointer
+ * @return VB2_REQUEST_UI_CONTINUE, or error code on error.
+ */
+vb2_error_t vb2_ui_change_screen(struct vb2_ui_context *ui, enum vb2_screen id);
+
+/*****************************************************************************/
 /* UI loops */
 
 /**
diff --git a/firmware/2lib/include/2ui_private.h b/firmware/2lib/include/2ui_private.h
index 891c041..96caf64 100644
--- a/firmware/2lib/include/2ui_private.h
+++ b/firmware/2lib/include/2ui_private.h
@@ -17,8 +17,6 @@
 	vb2_error_t (*action)(struct vb2_ui_context *ui);
 };
 
-vb2_error_t menu_up_action(struct vb2_ui_context *ui);
-vb2_error_t menu_down_action(struct vb2_ui_context *ui);
 vb2_error_t ctrl_d_action(struct vb2_ui_context *ui);
 vb2_error_t change_to_dev_screen_action(struct vb2_ui_context *ui);
 vb2_error_t (*input_action_lookup(int key))(struct vb2_ui_context *ui);
diff --git a/tests/vb2_ui_action_tests.c b/tests/vb2_ui_action_tests.c
index 166830c..3d34d76 100644
--- a/tests/vb2_ui_action_tests.c
+++ b/tests/vb2_ui_action_tests.c
@@ -375,16 +375,16 @@
 }
 
 /* Tests */
-static void menu_up_action_tests(void)
+static void menu_prev_tests(void)
 {
-	VB2_DEBUG("Testing menu_up_action...\n");
+	VB2_DEBUG("Testing menu_prev...\n");
 
 	/* Valid action */
 	reset_common_data();
 	mock_state->screen = &mock_screen_menu;
 	mock_state->selected_item = 2;
 	mock_ui_context.key = VB_KEY_UP;
-	TEST_EQ(menu_up_action(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
+	TEST_EQ(vb2_ui_menu_prev(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
 		"valid action");
 	screen_state_eq(mock_state, MOCK_SCREEN_MENU, 1, MOCK_IGNORE);
 
@@ -394,7 +394,7 @@
 	mock_state->selected_item = 2;
 	mock_state->disabled_item_mask = 0x0a;  /* 0b01010 */
 	mock_ui_context.key = VB_KEY_UP;
-	TEST_EQ(menu_up_action(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
+	TEST_EQ(vb2_ui_menu_prev(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
 		"valid action with mask");
 	screen_state_eq(mock_state, MOCK_SCREEN_MENU, 0, MOCK_IGNORE);
 
@@ -403,7 +403,7 @@
 	mock_state->screen = &mock_screen_menu;
 	mock_state->selected_item = 0;
 	mock_ui_context.key = VB_KEY_UP;
-	TEST_EQ(menu_up_action(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
+	TEST_EQ(vb2_ui_menu_prev(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
 		"invalid action (blocked)");
 	screen_state_eq(mock_state, MOCK_SCREEN_MENU, 0, MOCK_IGNORE);
 
@@ -413,7 +413,7 @@
 	mock_state->selected_item = 2;
 	mock_state->disabled_item_mask = 0x0b;  /* 0b01011 */
 	mock_ui_context.key = VB_KEY_UP;
-	TEST_EQ(menu_up_action(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
+	TEST_EQ(vb2_ui_menu_prev(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
 		"invalid action (blocked by mask)");
 	screen_state_eq(mock_state, MOCK_SCREEN_MENU, 2, MOCK_IGNORE);
 
@@ -423,7 +423,7 @@
 		mock_state->screen = &mock_screen_menu;
 		mock_state->selected_item = 2;
 		mock_ui_context.key = VB_BUTTON_VOL_UP_SHORT_PRESS;
-		TEST_EQ(menu_up_action(&mock_ui_context),
+		TEST_EQ(vb2_ui_menu_prev(&mock_ui_context),
 			VB2_REQUEST_UI_CONTINUE,
 			"ignore volume-up when not DETACHABLE");
 		screen_state_eq(mock_state, MOCK_SCREEN_MENU, 2, MOCK_IGNORE);
@@ -432,16 +432,16 @@
 	VB2_DEBUG("...done.\n");
 }
 
-static void menu_down_action_tests(void)
+static void menu_next_tests(void)
 {
-	VB2_DEBUG("Testing menu_down_action...\n");
+	VB2_DEBUG("Testing menu_next...\n");
 
 	/* Valid action */
 	reset_common_data();
 	mock_state->screen = &mock_screen_menu;
 	mock_state->selected_item = 2;
 	mock_ui_context.key = VB_KEY_DOWN;
-	TEST_EQ(menu_down_action(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
+	TEST_EQ(vb2_ui_menu_next(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
 		"valid action");
 	screen_state_eq(mock_state, MOCK_SCREEN_MENU, 3, MOCK_IGNORE);
 
@@ -451,7 +451,7 @@
 	mock_state->selected_item = 2;
 	mock_state->disabled_item_mask = 0x0a;  /* 0b01010 */
 	mock_ui_context.key = VB_KEY_DOWN;
-	TEST_EQ(menu_down_action(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
+	TEST_EQ(vb2_ui_menu_next(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
 		"valid action with mask");
 	screen_state_eq(mock_state, MOCK_SCREEN_MENU, 4, MOCK_IGNORE);
 
@@ -460,7 +460,7 @@
 	mock_state->screen = &mock_screen_menu;
 	mock_state->selected_item = 4;
 	mock_ui_context.key = VB_KEY_DOWN;
-	TEST_EQ(menu_down_action(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
+	TEST_EQ(vb2_ui_menu_next(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
 		"invalid action (blocked)");
 	screen_state_eq(mock_state, MOCK_SCREEN_MENU, 4, MOCK_IGNORE);
 
@@ -470,7 +470,7 @@
 	mock_state->selected_item = 2;
 	mock_state->disabled_item_mask = 0x1a;  /* 0b11010 */
 	mock_ui_context.key = VB_KEY_DOWN;
-	TEST_EQ(menu_down_action(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
+	TEST_EQ(vb2_ui_menu_next(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
 		"invalid action (blocked by mask)");
 	screen_state_eq(mock_state, MOCK_SCREEN_MENU, 2, MOCK_IGNORE);
 
@@ -480,7 +480,7 @@
 		mock_state->screen = &mock_screen_menu;
 		mock_state->selected_item = 2;
 		mock_ui_context.key = VB_BUTTON_VOL_DOWN_SHORT_PRESS;
-		TEST_EQ(menu_down_action(&mock_ui_context),
+		TEST_EQ(vb2_ui_menu_next(&mock_ui_context),
 			VB2_REQUEST_UI_CONTINUE,
 			"ignore volume-down when not DETACHABLE");
 		screen_state_eq(mock_state, MOCK_SCREEN_MENU, 2, MOCK_IGNORE);
@@ -489,20 +489,20 @@
 	VB2_DEBUG("...done.\n");
 }
 
-static void menu_select_action_tests(void)
+static void menu_select_tests(void)
 {
 	int i, target_id;
 	char test_name[256];
 
-	VB2_DEBUG("Testing menu_select_action...\n");
+	VB2_DEBUG("Testing menu_select...\n");
 
 	/* select action with no item screen */
 	reset_common_data();
 	mock_state->screen = &mock_screen_base;
 	mock_ui_context.key = VB_KEY_ENTER;
-	TEST_EQ(vb2_ui_menu_select_action(&mock_ui_context),
+	TEST_EQ(vb2_ui_menu_select(&mock_ui_context),
 		VB2_REQUEST_UI_CONTINUE,
-		"menu_select_action with no item screen");
+		"vb2_ui_menu_select with no item screen");
 	screen_state_eq(mock_state, MOCK_SCREEN_BASE, 0, MOCK_IGNORE);
 
 	/* Try to select target 0..3 */
@@ -513,7 +513,7 @@
 		mock_state->screen = &mock_screen_menu;
 		mock_state->selected_item = i;
 		mock_ui_context.key = VB_KEY_ENTER;
-		TEST_EQ(vb2_ui_menu_select_action(&mock_ui_context),
+		TEST_EQ(vb2_ui_menu_select(&mock_ui_context),
 			VB2_REQUEST_UI_CONTINUE, test_name);
 		screen_state_eq(mock_state, target_id, 0, MOCK_IGNORE);
 	}
@@ -523,7 +523,7 @@
 	mock_state->screen = &mock_screen_menu;
 	mock_state->selected_item = 4;
 	mock_ui_context.key = VB_KEY_ENTER;
-	TEST_EQ(vb2_ui_menu_select_action(&mock_ui_context),
+	TEST_EQ(vb2_ui_menu_select(&mock_ui_context),
 		VB2_REQUEST_UI_CONTINUE,
 		"select no target");
 	screen_state_eq(mock_state, MOCK_SCREEN_MENU, 4, MOCK_IGNORE);
@@ -534,7 +534,7 @@
 		mock_state->screen = &mock_screen_menu;
 		mock_state->selected_item = 1;
 		mock_ui_context.key = VB_BUTTON_POWER_SHORT_PRESS;
-		TEST_EQ(vb2_ui_menu_select_action(&mock_ui_context),
+		TEST_EQ(vb2_ui_menu_select(&mock_ui_context),
 			VB2_REQUEST_UI_CONTINUE,
 			"ignore power button short press when not DETACHABLE");
 		screen_state_eq(mock_state, MOCK_SCREEN_MENU, 1, MOCK_IGNORE);
@@ -707,9 +707,9 @@
 int main(void)
 {
 	/* Input actions */
-	menu_up_action_tests();
-	menu_down_action_tests();
-	menu_select_action_tests();
+	menu_prev_tests();
+	menu_next_tests();
+	menu_select_tests();
 
 	/* Global actions */
 	try_recovery_action_tests();
diff --git a/tests/vb2_ui_utility_tests.c b/tests/vb2_ui_utility_tests.c
index 0a7e459..6fdaffc 100644
--- a/tests/vb2_ui_utility_tests.c
+++ b/tests/vb2_ui_utility_tests.c
@@ -244,16 +244,15 @@
 	VB2_DEBUG("...done.\n");
 }
 
-static void vb2_ui_back_action_tests(void)
+static void vb2_ui_change_root_tests(void)
 {
-	VB2_DEBUG("Testing vb2_ui_back_action...\n");
+	VB2_DEBUG("Testing vb2_ui_change_root...\n");
 
-	/* TODO: back to previous screen instead of root screen */
 	/* Back to root screen */
 	reset_common_data();
 	mock_ui_context.root_screen = &mock_screen_root;
 	mock_ui_context.key = VB_KEY_ESC;
-	TEST_EQ(vb2_ui_back_action(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
+	TEST_EQ(vb2_ui_change_root(&mock_ui_context), VB2_REQUEST_UI_CONTINUE,
 		"back to root screen");
 	screen_state_eq(mock_state, MOCK_SCREEN_ROOT, MOCK_IGNORE, MOCK_IGNORE);
 
@@ -290,7 +289,7 @@
 int main(void)
 {
 	check_shutdown_request_tests();
-	vb2_ui_back_action_tests();
+	vb2_ui_change_root_tests();
 	change_screen_tests();
 
 	return gTestSuccess ? 0 : 255;
