From a04b91ee3c17ba2a8e42a11007f21be831d564fa Mon Sep 17 00:00:00 2001 From: Tiger Oakes Date: Fri, 14 Aug 2020 16:44:09 -0700 Subject: [PATCH] =?UTF-8?q?FNX-14513=20=E2=81=83=20For=20#12862:=20Use=20c?= =?UTF-8?q?oncept-menu=20in=20library=20(#13332)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../fenix/library/LibrarySiteItemView.kt | 14 +-- .../library/bookmarks/BookmarkItemMenu.kt | 110 +++++++++++------- .../viewholders/BookmarkFolderViewHolder.kt | 2 +- .../viewholders/BookmarkItemViewHolder.kt | 2 +- .../viewholders/BookmarkNodeViewHolder.kt | 29 +++-- .../BookmarkSeparatorViewHolder.kt | 2 +- .../fenix/library/history/HistoryItemMenu.kt | 62 ++++++---- .../viewholders/HistoryListItemViewHolder.kt | 3 +- .../library/bookmarks/BookmarkItemMenuTest.kt | 98 ++++++++++++++++ .../library/history/HistoryItemMenuTest.kt | 76 ++++++++++++ 10 files changed, 307 insertions(+), 91 deletions(-) create mode 100644 app/src/test/java/org/mozilla/fenix/library/bookmarks/BookmarkItemMenuTest.kt create mode 100644 app/src/test/java/org/mozilla/fenix/library/history/HistoryItemMenuTest.kt diff --git a/app/src/main/java/org/mozilla/fenix/library/LibrarySiteItemView.kt b/app/src/main/java/org/mozilla/fenix/library/LibrarySiteItemView.kt index 6c6b1915d..a90fb4231 100644 --- a/app/src/main/java/org/mozilla/fenix/library/LibrarySiteItemView.kt +++ b/app/src/main/java/org/mozilla/fenix/library/LibrarySiteItemView.kt @@ -13,8 +13,8 @@ import android.widget.TextView import androidx.constraintlayout.widget.ConstraintLayout import androidx.core.view.isVisible import kotlinx.android.synthetic.main.library_site_item.view.* -import mozilla.components.browser.menu.BrowserMenu -import mozilla.components.browser.menu.BrowserMenuBuilder +import mozilla.components.concept.menu.MenuController +import mozilla.components.concept.menu.Orientation import org.mozilla.fenix.R import org.mozilla.fenix.ext.components import org.mozilla.fenix.ext.increaseTapArea @@ -48,10 +48,6 @@ interface SelectionHolder { val selectedItems: Set } -interface LibraryItemMenu { - val menuBuilder: BrowserMenuBuilder -} - class LibrarySiteItemView @JvmOverloads constructor( context: Context, attrs: AttributeSet? = null, @@ -102,11 +98,11 @@ class LibrarySiteItemView @JvmOverloads constructor( context.components.core.icons.loadIntoView(favicon, url) } - fun attachMenu(menu: LibraryItemMenu) { + fun attachMenu(menuController: MenuController) { overflow_menu.setOnClickListener { - menu.menuBuilder.build(context).show( + menuController.show( anchor = it, - orientation = BrowserMenu.Orientation.DOWN + orientation = Orientation.DOWN ) } } diff --git a/app/src/main/java/org/mozilla/fenix/library/bookmarks/BookmarkItemMenu.kt b/app/src/main/java/org/mozilla/fenix/library/bookmarks/BookmarkItemMenu.kt index 7473ef740..5d0c93d66 100644 --- a/app/src/main/java/org/mozilla/fenix/library/bookmarks/BookmarkItemMenu.kt +++ b/app/src/main/java/org/mozilla/fenix/library/bookmarks/BookmarkItemMenu.kt @@ -5,65 +5,89 @@ package org.mozilla.fenix.library.bookmarks import android.content.Context -import mozilla.components.browser.menu.BrowserMenuBuilder -import mozilla.components.browser.menu.item.SimpleBrowserMenuItem -import mozilla.components.concept.storage.BookmarkNode +import androidx.annotation.VisibleForTesting +import mozilla.components.browser.menu2.BrowserMenuController +import mozilla.components.concept.menu.MenuController +import mozilla.components.concept.menu.candidate.TextMenuCandidate +import mozilla.components.concept.menu.candidate.TextStyle import mozilla.components.concept.storage.BookmarkNodeType +import mozilla.components.support.ktx.android.content.getColorFromAttr import org.mozilla.fenix.R -import org.mozilla.fenix.library.LibraryItemMenu -import org.mozilla.fenix.theme.ThemeManager class BookmarkItemMenu( private val context: Context, - private val item: BookmarkNode, - private val onItemTapped: (BookmarkItemMenu.Item) -> Unit = {} -) : LibraryItemMenu { + private val onItemTapped: (Item) -> Unit +) { - sealed class Item { - object Edit : Item() - object Select : Item() - object Copy : Item() - object Share : Item() - object OpenInNewTab : Item() - object OpenInPrivateTab : Item() - object Delete : Item() + enum class Item { + Edit, + Copy, + Share, + OpenInNewTab, + OpenInPrivateTab, + Delete; } - override val menuBuilder by lazy { BrowserMenuBuilder(menuItems) } + val menuController: MenuController by lazy { BrowserMenuController() } - private val menuItems by lazy { - listOfNotNull( - if (item.type in listOf(BookmarkNodeType.ITEM, BookmarkNodeType.FOLDER)) { - SimpleBrowserMenuItem(context.getString(R.string.bookmark_menu_edit_button)) { - onItemTapped.invoke(BookmarkItemMenu.Item.Edit) + @VisibleForTesting + internal fun menuItems(itemType: BookmarkNodeType): List { + return listOfNotNull( + if (itemType != BookmarkNodeType.SEPARATOR) { + TextMenuCandidate( + text = context.getString(R.string.bookmark_menu_edit_button) + ) { + onItemTapped.invoke(Item.Edit) } - } else null, - if (item.type == BookmarkNodeType.ITEM) { - SimpleBrowserMenuItem(context.getString(R.string.bookmark_menu_copy_button)) { - onItemTapped.invoke(BookmarkItemMenu.Item.Copy) + } else { + null + }, + if (itemType == BookmarkNodeType.ITEM) { + TextMenuCandidate( + text = context.getString(R.string.bookmark_menu_copy_button) + ) { + onItemTapped.invoke(Item.Copy) } - } else null, - if (item.type == BookmarkNodeType.ITEM) { - SimpleBrowserMenuItem(context.getString(R.string.bookmark_menu_share_button)) { - onItemTapped.invoke(BookmarkItemMenu.Item.Share) + } else { + null + }, + if (itemType == BookmarkNodeType.ITEM) { + TextMenuCandidate( + text = context.getString(R.string.bookmark_menu_share_button) + ) { + onItemTapped.invoke(Item.Share) } - } else null, - if (item.type == BookmarkNodeType.ITEM) { - SimpleBrowserMenuItem(context.getString(R.string.bookmark_menu_open_in_new_tab_button)) { - onItemTapped.invoke(BookmarkItemMenu.Item.OpenInNewTab) + } else { + null + }, + if (itemType == BookmarkNodeType.ITEM) { + TextMenuCandidate( + text = context.getString(R.string.bookmark_menu_open_in_new_tab_button) + ) { + onItemTapped.invoke(Item.OpenInNewTab) } - } else null, - if (item.type == BookmarkNodeType.ITEM) { - SimpleBrowserMenuItem(context.getString(R.string.bookmark_menu_open_in_private_tab_button)) { - onItemTapped.invoke(BookmarkItemMenu.Item.OpenInPrivateTab) + } else { + null + }, + if (itemType == BookmarkNodeType.ITEM) { + TextMenuCandidate( + text = context.getString(R.string.bookmark_menu_open_in_private_tab_button) + ) { + onItemTapped.invoke(Item.OpenInPrivateTab) } - } else null, - SimpleBrowserMenuItem( - context.getString(R.string.bookmark_menu_delete_button), - textColorResource = ThemeManager.resolveAttribute(R.attr.destructive, context) + } else { + null + }, + TextMenuCandidate( + text = context.getString(R.string.bookmark_menu_delete_button), + textStyle = TextStyle(color = context.getColorFromAttr(R.attr.destructive)) ) { - onItemTapped.invoke(BookmarkItemMenu.Item.Delete) + onItemTapped.invoke(Item.Delete) } ) } + + fun updateMenu(itemType: BookmarkNodeType) { + menuController.submitList(menuItems(itemType)) + } } diff --git a/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkFolderViewHolder.kt b/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkFolderViewHolder.kt index 8c6eda9af..9d62e3bcd 100644 --- a/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkFolderViewHolder.kt +++ b/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkFolderViewHolder.kt @@ -44,7 +44,7 @@ class BookmarkFolderViewHolder( setSelectionListeners(item, mode) if (!item.inRoots()) { - setupMenu(item) + updateMenu(item.type) if (payload.modeChanged) { if (mode is BookmarkFragmentState.Mode.Selecting) { containerView.overflowView.hideAndDisable() diff --git a/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkItemViewHolder.kt b/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkItemViewHolder.kt index ec1a9a5b4..1af60ec26 100644 --- a/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkItemViewHolder.kt +++ b/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkItemViewHolder.kt @@ -37,7 +37,7 @@ class BookmarkItemViewHolder( override fun bind(item: BookmarkNode, mode: BookmarkFragmentState.Mode, payload: BookmarkPayload) { this.item = item - setupMenu(item) + updateMenu(item.type) if (payload.modeChanged) { if (mode is BookmarkFragmentState.Mode.Selecting) { diff --git a/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkNodeViewHolder.kt b/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkNodeViewHolder.kt index 751323467..e04f713fa 100644 --- a/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkNodeViewHolder.kt +++ b/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkNodeViewHolder.kt @@ -5,29 +5,32 @@ package org.mozilla.fenix.library.bookmarks.viewholders import androidx.recyclerview.widget.RecyclerView -import kotlinx.android.extensions.LayoutContainer import mozilla.components.concept.storage.BookmarkNode +import mozilla.components.concept.storage.BookmarkNodeType import org.mozilla.fenix.library.LibrarySiteItemView import org.mozilla.fenix.library.SelectionHolder import org.mozilla.fenix.library.bookmarks.BookmarkFragmentState import org.mozilla.fenix.library.bookmarks.BookmarkItemMenu import org.mozilla.fenix.library.bookmarks.BookmarkPayload import org.mozilla.fenix.library.bookmarks.BookmarkViewInteractor +import org.mozilla.fenix.utils.Do /** * Base class for bookmark node view holders. */ abstract class BookmarkNodeViewHolder( - override val containerView: LibrarySiteItemView, + protected val containerView: LibrarySiteItemView, private val interactor: BookmarkViewInteractor -) : RecyclerView.ViewHolder(containerView), LayoutContainer { +) : RecyclerView.ViewHolder(containerView) { abstract var item: BookmarkNode? + private lateinit var menu: BookmarkItemMenu - abstract fun bind( - item: BookmarkNode, - mode: BookmarkFragmentState.Mode - ) + init { + setupMenu() + } + + abstract fun bind(item: BookmarkNode, mode: BookmarkFragmentState.Mode) abstract fun bind( item: BookmarkNode, @@ -39,11 +42,11 @@ abstract class BookmarkNodeViewHolder( containerView.setSelectionInteractor(item, selectionHolder, interactor) } - protected fun setupMenu(item: BookmarkNode) { - val bookmarkItemMenu = BookmarkItemMenu(containerView.context, item) { - when (it) { + private fun setupMenu() { + menu = BookmarkItemMenu(containerView.context) { menuItem -> + val item = this.item ?: return@BookmarkItemMenu + Do exhaustive when (menuItem) { BookmarkItemMenu.Item.Edit -> interactor.onEditPressed(item) - BookmarkItemMenu.Item.Select -> interactor.select(item) BookmarkItemMenu.Item.Copy -> interactor.onCopyPressed(item) BookmarkItemMenu.Item.Share -> interactor.onSharePressed(item) BookmarkItemMenu.Item.OpenInNewTab -> interactor.onOpenInNormalTab(item) @@ -52,6 +55,8 @@ abstract class BookmarkNodeViewHolder( } } - containerView.attachMenu(bookmarkItemMenu) + containerView.attachMenu(menu.menuController) } + + protected fun updateMenu(itemType: BookmarkNodeType) = menu.updateMenu(itemType) } diff --git a/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkSeparatorViewHolder.kt b/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkSeparatorViewHolder.kt index d1789fa94..2000f7581 100644 --- a/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkSeparatorViewHolder.kt +++ b/app/src/main/java/org/mozilla/fenix/library/bookmarks/viewholders/BookmarkSeparatorViewHolder.kt @@ -26,7 +26,7 @@ class BookmarkSeparatorViewHolder( ) { this.item = item containerView.displayAs(LibrarySiteItemView.ItemType.SEPARATOR) - setupMenu(item) + updateMenu(item.type) } override fun bind( diff --git a/app/src/main/java/org/mozilla/fenix/library/history/HistoryItemMenu.kt b/app/src/main/java/org/mozilla/fenix/library/history/HistoryItemMenu.kt index 7e638c786..d4e99d5f9 100644 --- a/app/src/main/java/org/mozilla/fenix/library/history/HistoryItemMenu.kt +++ b/app/src/main/java/org/mozilla/fenix/library/history/HistoryItemMenu.kt @@ -5,43 +5,61 @@ package org.mozilla.fenix.library.history import android.content.Context -import mozilla.components.browser.menu.BrowserMenuBuilder -import mozilla.components.browser.menu.item.SimpleBrowserMenuItem +import androidx.annotation.VisibleForTesting +import mozilla.components.browser.menu2.BrowserMenuController +import mozilla.components.concept.menu.MenuController +import mozilla.components.concept.menu.candidate.TextMenuCandidate +import mozilla.components.concept.menu.candidate.TextStyle +import mozilla.components.support.ktx.android.content.getColorFromAttr import org.mozilla.fenix.R -import org.mozilla.fenix.library.LibraryItemMenu -import org.mozilla.fenix.theme.ThemeManager class HistoryItemMenu( private val context: Context, - private val onItemTapped: (Item) -> Unit = {} -) : LibraryItemMenu { - sealed class Item { - object Copy : Item() - object Share : Item() - object OpenInNewTab : Item() - object OpenInPrivateTab : Item() - object Delete : Item() + private val onItemTapped: (Item) -> Unit +) { + + enum class Item { + Copy, + Share, + OpenInNewTab, + OpenInPrivateTab, + Delete; } - override val menuBuilder by lazy { BrowserMenuBuilder(menuItems) } + val menuController: MenuController by lazy { + BrowserMenuController().apply { + submitList(menuItems()) + } + } - private val menuItems by lazy { - listOfNotNull( - SimpleBrowserMenuItem(context.getString(R.string.history_menu_copy_button)) { + @VisibleForTesting + internal fun menuItems(): List { + return listOf( + TextMenuCandidate( + text = context.getString(R.string.history_menu_copy_button) + ) { onItemTapped.invoke(Item.Copy) }, - SimpleBrowserMenuItem(context.getString(R.string.history_menu_share_button)) { + TextMenuCandidate( + text = context.getString(R.string.history_menu_share_button) + ) { onItemTapped.invoke(Item.Share) }, - SimpleBrowserMenuItem(context.getString(R.string.history_menu_open_in_new_tab_button)) { + TextMenuCandidate( + text = context.getString(R.string.history_menu_open_in_new_tab_button) + ) { onItemTapped.invoke(Item.OpenInNewTab) }, - SimpleBrowserMenuItem(context.getString(R.string.history_menu_open_in_private_tab_button)) { + TextMenuCandidate( + text = context.getString(R.string.history_menu_open_in_private_tab_button) + ) { onItemTapped.invoke(Item.OpenInPrivateTab) }, - SimpleBrowserMenuItem( - context.getString(R.string.history_delete_item), - textColorResource = ThemeManager.resolveAttribute(R.attr.destructive, context) + TextMenuCandidate( + text = context.getString(R.string.history_delete_item), + textStyle = TextStyle( + color = context.getColorFromAttr(R.attr.destructive) + ) ) { onItemTapped.invoke(Item.Delete) } diff --git a/app/src/main/java/org/mozilla/fenix/library/history/viewholders/HistoryListItemViewHolder.kt b/app/src/main/java/org/mozilla/fenix/library/history/viewholders/HistoryListItemViewHolder.kt index 762f72aa9..f833507e9 100644 --- a/app/src/main/java/org/mozilla/fenix/library/history/viewholders/HistoryListItemViewHolder.kt +++ b/app/src/main/java/org/mozilla/fenix/library/history/viewholders/HistoryListItemViewHolder.kt @@ -110,7 +110,6 @@ class HistoryListItemViewHolder( private fun setupMenu() { val historyMenu = HistoryItemMenu(itemView.context) { val item = this.item ?: return@HistoryItemMenu - Do exhaustive when (it) { HistoryItemMenu.Item.Copy -> historyInteractor.onCopyPressed(item) HistoryItemMenu.Item.Share -> historyInteractor.onSharePressed(item) @@ -120,7 +119,7 @@ class HistoryListItemViewHolder( } } - itemView.history_layout.attachMenu(historyMenu) + itemView.history_layout.attachMenu(historyMenu.menuController) } companion object { diff --git a/app/src/test/java/org/mozilla/fenix/library/bookmarks/BookmarkItemMenuTest.kt b/app/src/test/java/org/mozilla/fenix/library/bookmarks/BookmarkItemMenuTest.kt new file mode 100644 index 000000000..8840e2451 --- /dev/null +++ b/app/src/test/java/org/mozilla/fenix/library/bookmarks/BookmarkItemMenuTest.kt @@ -0,0 +1,98 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +package org.mozilla.fenix.library.bookmarks + +import android.content.Context +import androidx.appcompat.view.ContextThemeWrapper +import io.mockk.mockk +import io.mockk.verify +import mozilla.components.concept.menu.candidate.TextStyle +import mozilla.components.concept.storage.BookmarkNodeType +import mozilla.components.support.ktx.android.content.getColorFromAttr +import mozilla.components.support.test.robolectric.testContext +import org.junit.Assert.assertEquals +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.mozilla.fenix.R +import org.mozilla.fenix.helpers.FenixRobolectricTestRunner +import org.mozilla.fenix.library.bookmarks.BookmarkItemMenu.Item + +@RunWith(FenixRobolectricTestRunner::class) +class BookmarkItemMenuTest { + + private lateinit var context: Context + private lateinit var onItemTapped: (Item) -> Unit + private lateinit var menu: BookmarkItemMenu + + @Before + fun setup() { + context = ContextThemeWrapper(testContext, R.style.NormalTheme) + onItemTapped = mockk(relaxed = true) + menu = BookmarkItemMenu(context, onItemTapped) + } + + @Test + fun `delete item has special styling`() { + val deleteItem = menu.menuItems(BookmarkNodeType.SEPARATOR).last() + assertEquals("Delete", deleteItem.text) + assertEquals( + TextStyle(color = context.getColorFromAttr(R.attr.destructive)), + deleteItem.textStyle + ) + + deleteItem.onClick() + verify { onItemTapped(Item.Delete) } + } + + @Test + fun `edit item appears for folders`() { + val folderItems = menu.menuItems(BookmarkNodeType.FOLDER) + assertEquals(2, folderItems.size) + val (edit, delete) = folderItems + + assertEquals("Edit", edit.text) + edit.onClick() + verify { onItemTapped(Item.Edit) } + + assertEquals("Delete", delete.text) + } + + @Test + fun `all item appears for sites`() { + val siteItems = menu.menuItems(BookmarkNodeType.ITEM) + assertEquals(6, siteItems.size) + val (edit, copy, share, openInNewTab, openInPrivateTab, delete) = siteItems + + assertEquals("Edit", edit.text) + assertEquals("Copy", copy.text) + assertEquals("Share", share.text) + assertEquals("Open in new tab", openInNewTab.text) + assertEquals("Open in private tab", openInPrivateTab.text) + assertEquals("Delete", delete.text) + + edit.onClick() + verify { onItemTapped(Item.Edit) } + + copy.onClick() + verify { onItemTapped(Item.Copy) } + + share.onClick() + verify { onItemTapped(Item.Share) } + + openInNewTab.onClick() + verify { onItemTapped(Item.OpenInNewTab) } + + openInPrivateTab.onClick() + verify { onItemTapped(Item.OpenInPrivateTab) } + + delete.onClick() + verify { onItemTapped(Item.Delete) } + } + + private operator fun List.component6(): T { + return get(5) + } +} diff --git a/app/src/test/java/org/mozilla/fenix/library/history/HistoryItemMenuTest.kt b/app/src/test/java/org/mozilla/fenix/library/history/HistoryItemMenuTest.kt new file mode 100644 index 000000000..356c464d8 --- /dev/null +++ b/app/src/test/java/org/mozilla/fenix/library/history/HistoryItemMenuTest.kt @@ -0,0 +1,76 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +package org.mozilla.fenix.library.history + +import android.content.Context +import androidx.appcompat.view.ContextThemeWrapper +import io.mockk.mockk +import io.mockk.verify +import mozilla.components.concept.menu.candidate.TextStyle +import mozilla.components.support.ktx.android.content.getColorFromAttr +import mozilla.components.support.test.robolectric.testContext +import org.junit.Assert.assertEquals +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.mozilla.fenix.R +import org.mozilla.fenix.helpers.FenixRobolectricTestRunner +import org.mozilla.fenix.library.history.HistoryItemMenu.Item + +@RunWith(FenixRobolectricTestRunner::class) +class HistoryItemMenuTest { + + private lateinit var context: Context + private lateinit var onItemTapped: (Item) -> Unit + private lateinit var menu: HistoryItemMenu + + @Before + fun setup() { + context = ContextThemeWrapper(testContext, R.style.NormalTheme) + onItemTapped = mockk(relaxed = true) + menu = HistoryItemMenu(context, onItemTapped) + } + + @Test + fun `delete item has special styling`() { + val deleteItem = menu.menuItems().last() + assertEquals("Delete", deleteItem.text) + assertEquals( + TextStyle(color = context.getColorFromAttr(R.attr.destructive)), + deleteItem.textStyle + ) + + deleteItem.onClick() + verify { onItemTapped(Item.Delete) } + } + + @Test + fun `builds menu items`() { + val items = menu.menuItems() + assertEquals(5, items.size) + val (copy, share, openInNewTab, openInPrivateTab, delete) = items + + assertEquals("Copy", copy.text) + assertEquals("Share", share.text) + assertEquals("Open in new tab", openInNewTab.text) + assertEquals("Open in private tab", openInPrivateTab.text) + assertEquals("Delete", delete.text) + + copy.onClick() + verify { onItemTapped(Item.Copy) } + + share.onClick() + verify { onItemTapped(Item.Share) } + + openInNewTab.onClick() + verify { onItemTapped(Item.OpenInNewTab) } + + openInPrivateTab.onClick() + verify { onItemTapped(Item.OpenInPrivateTab) } + + delete.onClick() + verify { onItemTapped(Item.Delete) } + } +}