| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * 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. |
| */ |
| |
| package android.widget.cts; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertTrue; |
| import static org.mockito.Mockito.any; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.never; |
| import static org.mockito.Mockito.times; |
| import static org.mockito.Mockito.verify; |
| import static org.mockito.Mockito.verifyNoMoreInteractions; |
| |
| import android.app.Instrumentation; |
| import android.graphics.Color; |
| import android.graphics.drawable.Drawable; |
| import android.os.SystemClock; |
| import android.support.test.InstrumentationRegistry; |
| import android.support.test.annotation.UiThreadTest; |
| import android.support.test.filters.MediumTest; |
| import android.support.test.rule.ActivityTestRule; |
| import android.support.test.runner.AndroidJUnit4; |
| import android.view.KeyEvent; |
| import android.view.Menu; |
| import android.view.MenuItem; |
| import android.view.View; |
| import android.widget.Toolbar; |
| import android.widget.cts.util.TestUtils; |
| |
| import com.android.compatibility.common.util.WidgetTestUtils; |
| |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| |
| @MediumTest |
| @RunWith(AndroidJUnit4.class) |
| public class ToolbarTest { |
| private Instrumentation mInstrumentation; |
| private ToolbarCtsActivity mActivity; |
| private Toolbar mMainToolbar; |
| |
| @Rule |
| public ActivityTestRule<ToolbarCtsActivity> mActivityRule = |
| new ActivityTestRule<>(ToolbarCtsActivity.class); |
| |
| @Before |
| public void setup() { |
| mInstrumentation = InstrumentationRegistry.getInstrumentation(); |
| mActivity = mActivityRule.getActivity(); |
| mMainToolbar = mActivity.getMainToolbar(); |
| } |
| |
| @Test |
| public void testConstructor() { |
| new Toolbar(mActivity); |
| |
| new Toolbar(mActivity, null); |
| |
| new Toolbar(mActivity, null, android.R.attr.toolbarStyle); |
| |
| new Toolbar(mActivity, null, 0, android.R.style.Widget_Material_Toolbar); |
| } |
| |
| @Test |
| public void testTitleAndSubtitleContent() throws Throwable { |
| // Note that this method is *not* annotated to run on the UI thread, and every |
| // call to setTitle / setSubtitle is wrapped to wait until the next draw pass |
| // of our main toolbar. While this is not strictly necessary to check the result |
| // of getTitle / getSubtitle, this logic follows the path of deferred layout |
| // and invalidation of the TextViews that show the title / subtitle in the Toolbar. |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setTitle(R.string.toolbar_title)); |
| assertEquals(mActivity.getString(R.string.toolbar_title), mMainToolbar.getTitle()); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setTitle("New title")); |
| assertEquals("New title", mMainToolbar.getTitle()); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setSubtitle(R.string.toolbar_subtitle)); |
| assertEquals(mActivity.getString(R.string.toolbar_subtitle), mMainToolbar.getSubtitle()); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setSubtitle("New subtitle")); |
| assertEquals("New subtitle", mMainToolbar.getSubtitle()); |
| } |
| |
| @Test |
| public void testTitleAndSubtitleAppearance() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setTitle(R.string.toolbar_title)); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setSubtitle(R.string.toolbar_subtitle)); |
| |
| // Since there are no APIs to get reference to the underlying implementation of |
| // title and subtitle, here we are testing that calling the relevant APIs doesn't crash |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setTitleTextColor(Color.RED)); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setSubtitleTextColor(Color.BLUE)); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setTitleTextAppearance( |
| mActivity, R.style.TextAppearance_NotColors)); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setSubtitleTextAppearance( |
| mActivity, R.style.TextAppearance_WithColor)); |
| } |
| |
| @Test |
| public void testMenuContent() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.inflateMenu(R.menu.toolbar_menu)); |
| |
| final Menu menu = mMainToolbar.getMenu(); |
| |
| assertEquals(6, menu.size()); |
| assertEquals(R.id.action_highlight, menu.getItem(0).getItemId()); |
| assertEquals(R.id.action_edit, menu.getItem(1).getItemId()); |
| assertEquals(R.id.action_delete, menu.getItem(2).getItemId()); |
| assertEquals(R.id.action_ignore, menu.getItem(3).getItemId()); |
| assertEquals(R.id.action_share, menu.getItem(4).getItemId()); |
| assertEquals(R.id.action_print, menu.getItem(5).getItemId()); |
| |
| assertFalse(mMainToolbar.hasExpandedActionView()); |
| |
| Toolbar.OnMenuItemClickListener menuItemClickListener = |
| mock(Toolbar.OnMenuItemClickListener.class); |
| mMainToolbar.setOnMenuItemClickListener(menuItemClickListener); |
| |
| menu.performIdentifierAction(R.id.action_highlight, 0); |
| verify(menuItemClickListener, times(1)).onMenuItemClick( |
| menu.findItem(R.id.action_highlight)); |
| |
| menu.performIdentifierAction(R.id.action_share, 0); |
| verify(menuItemClickListener, times(1)).onMenuItemClick( |
| menu.findItem(R.id.action_share)); |
| } |
| |
| @Test |
| public void testMenuOverflowShowHide() throws Throwable { |
| // Inflate menu and check that we're not showing overflow menu yet |
| mActivityRule.runOnUiThread(() -> mMainToolbar.inflateMenu(R.menu.toolbar_menu)); |
| assertFalse(mMainToolbar.isOverflowMenuShowing()); |
| |
| // Ask to show overflow menu and check that it's showing |
| mActivityRule.runOnUiThread(() -> mMainToolbar.showOverflowMenu()); |
| mInstrumentation.waitForIdleSync(); |
| assertTrue(mMainToolbar.isOverflowMenuShowing()); |
| |
| // Ask to hide the overflow menu and check that it's not showing |
| mActivityRule.runOnUiThread(() -> mMainToolbar.hideOverflowMenu()); |
| mInstrumentation.waitForIdleSync(); |
| assertFalse(mMainToolbar.isOverflowMenuShowing()); |
| } |
| |
| @Test |
| public void testMenuOverflowSubmenu() throws Throwable { |
| // Inflate menu and check that we're not showing overflow menu yet |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.inflateMenu(R.menu.toolbar_menu)); |
| assertFalse(mMainToolbar.isOverflowMenuShowing()); |
| |
| // Ask to show overflow menu and check that it's showing |
| mActivityRule.runOnUiThread(mMainToolbar::showOverflowMenu); |
| mInstrumentation.waitForIdleSync(); |
| assertTrue(mMainToolbar.isOverflowMenuShowing()); |
| |
| // Register a mock menu item click listener on the toolbar |
| Toolbar.OnMenuItemClickListener menuItemClickListener = |
| mock(Toolbar.OnMenuItemClickListener.class); |
| mMainToolbar.setOnMenuItemClickListener(menuItemClickListener); |
| |
| final Menu menu = mMainToolbar.getMenu(); |
| |
| // Ask to "perform" the share action and check that the menu click listener has |
| // been notified |
| mActivityRule.runOnUiThread(() -> menu.performIdentifierAction(R.id.action_share, 0)); |
| verify(menuItemClickListener, times(1)).onMenuItemClick( |
| menu.findItem(R.id.action_share)); |
| |
| // Ask to dismiss all the popups and check that we're not showing the overflow menu |
| mActivityRule.runOnUiThread(mMainToolbar::dismissPopupMenus); |
| mInstrumentation.waitForIdleSync(); |
| assertFalse(mMainToolbar.isOverflowMenuShowing()); |
| } |
| |
| @Test |
| public void testMenuOverflowIcon() throws Throwable { |
| // Inflate menu and check that we're not showing overflow menu yet |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.inflateMenu(R.menu.toolbar_menu)); |
| |
| final Drawable overflowIcon = mActivity.getDrawable(R.drawable.icon_red); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setOverflowIcon(overflowIcon)); |
| |
| final Drawable toolbarOverflowIcon = mMainToolbar.getOverflowIcon(); |
| TestUtils.assertAllPixelsOfColor("Overflow icon is red", toolbarOverflowIcon, |
| toolbarOverflowIcon.getIntrinsicWidth(), toolbarOverflowIcon.getIntrinsicHeight(), |
| true, Color.RED, 1, false); |
| } |
| |
| @Test |
| public void testActionView() throws Throwable { |
| // Inflate menu and check that we don't have an expanded action view |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.inflateMenu(R.menu.toolbar_menu_search)); |
| assertFalse(mMainToolbar.hasExpandedActionView()); |
| |
| // Expand search menu item's action view and verify that main toolbar has an expanded |
| // action view |
| final MenuItem searchMenuItem = mMainToolbar.getMenu().findItem(R.id.action_search); |
| mActivityRule.runOnUiThread(searchMenuItem::expandActionView); |
| mInstrumentation.waitForIdleSync(); |
| assertTrue(searchMenuItem.isActionViewExpanded()); |
| assertTrue(mMainToolbar.hasExpandedActionView()); |
| |
| // Collapse search menu item's action view and verify that main toolbar doesn't have an |
| // expanded action view |
| mActivityRule.runOnUiThread(searchMenuItem::collapseActionView); |
| mInstrumentation.waitForIdleSync(); |
| assertFalse(searchMenuItem.isActionViewExpanded()); |
| assertFalse(mMainToolbar.hasExpandedActionView()); |
| |
| // Expand search menu item's action view again |
| mActivityRule.runOnUiThread(searchMenuItem::expandActionView); |
| mInstrumentation.waitForIdleSync(); |
| assertTrue(searchMenuItem.isActionViewExpanded()); |
| assertTrue(mMainToolbar.hasExpandedActionView()); |
| |
| // Now collapse search menu item's action view via toolbar's API and verify that main |
| // toolbar doesn't have an expanded action view |
| mActivityRule.runOnUiThread(mMainToolbar::collapseActionView); |
| mInstrumentation.waitForIdleSync(); |
| assertFalse(searchMenuItem.isActionViewExpanded()); |
| assertFalse(mMainToolbar.hasExpandedActionView()); |
| } |
| |
| @Test |
| public void testNavigationConfiguration() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setNavigationIcon(R.drawable.icon_green)); |
| Drawable toolbarNavigationIcon = mMainToolbar.getNavigationIcon(); |
| TestUtils.assertAllPixelsOfColor("Navigation icon is green", toolbarNavigationIcon, |
| toolbarNavigationIcon.getIntrinsicWidth(), |
| toolbarNavigationIcon.getIntrinsicHeight(), |
| true, Color.GREEN, 1, false); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setNavigationIcon(mActivity.getDrawable(R.drawable.icon_blue))); |
| toolbarNavigationIcon = mMainToolbar.getNavigationIcon(); |
| TestUtils.assertAllPixelsOfColor("Navigation icon is blue", toolbarNavigationIcon, |
| toolbarNavigationIcon.getIntrinsicWidth(), |
| toolbarNavigationIcon.getIntrinsicHeight(), |
| true, Color.BLUE, 1, false); |
| |
| mActivityRule.runOnUiThread( |
| () -> mMainToolbar.setNavigationContentDescription(R.string.toolbar_navigation)); |
| assertEquals(mActivity.getResources().getString(R.string.toolbar_navigation), |
| mMainToolbar.getNavigationContentDescription()); |
| |
| mActivityRule.runOnUiThread( |
| () -> mMainToolbar.setNavigationContentDescription("Navigation legend")); |
| assertEquals("Navigation legend", mMainToolbar.getNavigationContentDescription()); |
| } |
| |
| @Test |
| public void testLogoConfiguration() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setLogo(R.drawable.icon_yellow)); |
| Drawable toolbarLogo = mMainToolbar.getLogo(); |
| TestUtils.assertAllPixelsOfColor("Logo is yellow", toolbarLogo, |
| toolbarLogo.getIntrinsicWidth(), |
| toolbarLogo.getIntrinsicHeight(), |
| true, Color.YELLOW, 1, false); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setLogo(mActivity.getDrawable(R.drawable.icon_red))); |
| toolbarLogo = mMainToolbar.getLogo(); |
| TestUtils.assertAllPixelsOfColor("Logo is red", toolbarLogo, |
| toolbarLogo.getIntrinsicWidth(), |
| toolbarLogo.getIntrinsicHeight(), |
| true, Color.RED, 1, false); |
| |
| mActivityRule.runOnUiThread( |
| () -> mMainToolbar.setLogoDescription(R.string.toolbar_logo)); |
| assertEquals(mActivity.getResources().getString(R.string.toolbar_logo), |
| mMainToolbar.getLogoDescription()); |
| |
| mActivityRule.runOnUiThread( |
| () -> mMainToolbar.setLogoDescription("Logo legend")); |
| assertEquals("Logo legend", mMainToolbar.getLogoDescription()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testContentInsetsLtr() { |
| mMainToolbar.setLayoutDirection(View.LAYOUT_DIRECTION_LTR); |
| |
| mMainToolbar.setContentInsetsAbsolute(20, 25); |
| assertEquals(20, mMainToolbar.getContentInsetLeft()); |
| assertEquals(20, mMainToolbar.getContentInsetStart()); |
| assertEquals(25, mMainToolbar.getContentInsetRight()); |
| assertEquals(25, mMainToolbar.getContentInsetEnd()); |
| |
| mMainToolbar.setContentInsetsRelative(40, 20); |
| assertEquals(40, mMainToolbar.getContentInsetLeft()); |
| assertEquals(40, mMainToolbar.getContentInsetStart()); |
| assertEquals(20, mMainToolbar.getContentInsetRight()); |
| assertEquals(20, mMainToolbar.getContentInsetEnd()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testContentInsetsRtl() { |
| mMainToolbar.setLayoutDirection(View.LAYOUT_DIRECTION_RTL); |
| |
| mMainToolbar.setContentInsetsAbsolute(20, 25); |
| assertEquals(20, mMainToolbar.getContentInsetLeft()); |
| assertEquals(25, mMainToolbar.getContentInsetStart()); |
| assertEquals(25, mMainToolbar.getContentInsetRight()); |
| assertEquals(20, mMainToolbar.getContentInsetEnd()); |
| |
| mMainToolbar.setContentInsetsRelative(40, 20); |
| assertEquals(20, mMainToolbar.getContentInsetLeft()); |
| assertEquals(40, mMainToolbar.getContentInsetStart()); |
| assertEquals(40, mMainToolbar.getContentInsetRight()); |
| assertEquals(20, mMainToolbar.getContentInsetEnd()); |
| } |
| |
| @Test |
| public void testCurrentContentInsetsLtr() throws Throwable { |
| mActivityRule.runOnUiThread( |
| () -> mMainToolbar.setLayoutDirection(View.LAYOUT_DIRECTION_LTR)); |
| |
| mActivityRule.runOnUiThread(() -> mMainToolbar.setContentInsetsRelative(20, 25)); |
| assertEquals(20, mMainToolbar.getCurrentContentInsetLeft()); |
| assertEquals(20, mMainToolbar.getCurrentContentInsetStart()); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetRight()); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetEnd()); |
| |
| mActivityRule.runOnUiThread(() -> mMainToolbar.setContentInsetStartWithNavigation(50)); |
| assertEquals(50, mMainToolbar.getContentInsetStartWithNavigation()); |
| // Since we haven't configured the navigation icon itself, the current content insets |
| // should stay the same |
| assertEquals(20, mMainToolbar.getCurrentContentInsetLeft()); |
| assertEquals(20, mMainToolbar.getCurrentContentInsetStart()); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetRight()); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetEnd()); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setNavigationIcon(R.drawable.icon_green)); |
| assertEquals(50, mMainToolbar.getContentInsetStartWithNavigation()); |
| // Since we have configured the navigation icon, and the currently set start inset with |
| // navigation is bigger than currently set start content inset, we should be getting that |
| // bigger value now |
| assertEquals(50, mMainToolbar.getCurrentContentInsetLeft()); |
| assertEquals(50, mMainToolbar.getCurrentContentInsetStart()); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetRight()); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetEnd()); |
| |
| mActivityRule.runOnUiThread(() -> mMainToolbar.setContentInsetEndWithActions(35)); |
| assertEquals(35, mMainToolbar.getContentInsetEndWithActions()); |
| // Since we haven't configured the menu content, the current content insets |
| // should stay the same |
| assertEquals(50, mMainToolbar.getCurrentContentInsetLeft()); |
| assertEquals(50, mMainToolbar.getCurrentContentInsetStart()); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetRight()); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetEnd()); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.inflateMenu(R.menu.toolbar_menu)); |
| assertEquals(35, mMainToolbar.getContentInsetEndWithActions()); |
| // Since we have configured the menu content, and the currently set start inset with |
| // navigation is bigger than currently set end content inset, we should be getting that |
| // bigger value now |
| assertEquals(50, mMainToolbar.getCurrentContentInsetLeft()); |
| assertEquals(50, mMainToolbar.getCurrentContentInsetStart()); |
| assertEquals(35, mMainToolbar.getCurrentContentInsetRight()); |
| assertEquals(35, mMainToolbar.getCurrentContentInsetEnd()); |
| } |
| |
| @Test |
| public void testCurrentContentInsetsRtl() throws Throwable { |
| mActivityRule.runOnUiThread( |
| () -> mMainToolbar.setLayoutDirection(View.LAYOUT_DIRECTION_RTL)); |
| |
| mActivityRule.runOnUiThread(() -> mMainToolbar.setContentInsetsRelative(20, 25)); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetLeft()); |
| assertEquals(20, mMainToolbar.getCurrentContentInsetStart()); |
| assertEquals(20, mMainToolbar.getCurrentContentInsetRight()); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetEnd()); |
| |
| mActivityRule.runOnUiThread(() -> mMainToolbar.setContentInsetStartWithNavigation(50)); |
| assertEquals(50, mMainToolbar.getContentInsetStartWithNavigation()); |
| // Since we haven't configured the navigation icon itself, the current content insets |
| // should stay the same |
| assertEquals(25, mMainToolbar.getCurrentContentInsetLeft()); |
| assertEquals(20, mMainToolbar.getCurrentContentInsetStart()); |
| assertEquals(20, mMainToolbar.getCurrentContentInsetRight()); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetEnd()); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.setNavigationIcon(R.drawable.icon_green)); |
| assertEquals(50, mMainToolbar.getContentInsetStartWithNavigation()); |
| // Since we have configured the navigation icon, and the currently set start inset with |
| // navigation is bigger than currently set start content inset, we should be getting that |
| // bigger value now |
| assertEquals(25, mMainToolbar.getCurrentContentInsetLeft()); |
| assertEquals(50, mMainToolbar.getCurrentContentInsetStart()); |
| assertEquals(50, mMainToolbar.getCurrentContentInsetRight()); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetEnd()); |
| |
| mActivityRule.runOnUiThread(() -> mMainToolbar.setContentInsetEndWithActions(35)); |
| assertEquals(35, mMainToolbar.getContentInsetEndWithActions()); |
| // Since we haven't configured the menu content, the current content insets |
| // should stay the same |
| assertEquals(25, mMainToolbar.getCurrentContentInsetLeft()); |
| assertEquals(50, mMainToolbar.getCurrentContentInsetStart()); |
| assertEquals(50, mMainToolbar.getCurrentContentInsetRight()); |
| assertEquals(25, mMainToolbar.getCurrentContentInsetEnd()); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.inflateMenu(R.menu.toolbar_menu)); |
| assertEquals(35, mMainToolbar.getContentInsetEndWithActions()); |
| // Since we have configured the menu content, and the currently set start inset with |
| // navigation is bigger than currently set end content inset, we should be getting that |
| // bigger value now |
| assertEquals(35, mMainToolbar.getCurrentContentInsetLeft()); |
| assertEquals(50, mMainToolbar.getCurrentContentInsetStart()); |
| assertEquals(50, mMainToolbar.getCurrentContentInsetRight()); |
| assertEquals(35, mMainToolbar.getCurrentContentInsetEnd()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testPopupTheme() { |
| mMainToolbar.setPopupTheme(R.style.ToolbarPopupTheme_Test); |
| assertEquals(R.style.ToolbarPopupTheme_Test, mMainToolbar.getPopupTheme()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testNavigationOnClickListener() { |
| View.OnClickListener mockListener = mock(View.OnClickListener.class); |
| mMainToolbar.setNavigationOnClickListener(mockListener); |
| |
| verify(mockListener, never()).onClick(any(View.class)); |
| |
| mMainToolbar.getNavigationView().performClick(); |
| verify(mockListener, times(1)).onClick(any(View.class)); |
| |
| verifyNoMoreInteractions(mockListener); |
| } |
| |
| @Test |
| public void testItemViewAttributes() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.inflateMenu(R.menu.toolbar_menu)); |
| |
| Menu menu = mMainToolbar.getMenu(); |
| |
| MenuItem menuItem1 = menu.findItem(R.id.action_highlight); |
| assertNotNull(menuItem1.getContentDescription()); |
| assertNotNull(menuItem1.getTooltipText()); |
| |
| View itemView1 = mActivity.findViewById(menuItem1.getItemId()); |
| assertEquals(menuItem1.getContentDescription(), itemView1.getContentDescription()); |
| assertEquals(menuItem1.getTooltipText(), itemView1.getTooltipText()); |
| |
| MenuItem menuItem2 = menu.findItem(R.id.action_edit); |
| assertNull(menuItem2.getContentDescription()); |
| assertNull(menuItem2.getTooltipText()); |
| |
| View itemView2 = mActivity.findViewById(menuItem2.getItemId()); |
| assertEquals(menuItem2.getTitle(), itemView2.getContentDescription()); |
| assertEquals(menuItem2.getTitle(), itemView2.getTooltipText()); |
| } |
| |
| @Test |
| public void testKeyShortcuts() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mMainToolbar, |
| () -> mMainToolbar.inflateMenu(R.menu.toolbar_menu)); |
| |
| final Boolean[] shareItemClicked = new Boolean[]{false}; |
| mMainToolbar.getMenu().findItem(R.id.action_share).setOnMenuItemClickListener( |
| item -> shareItemClicked[0] = true); |
| |
| // Make sure valid menu shortcuts get handled by toolbar menu |
| long now = SystemClock.uptimeMillis(); |
| KeyEvent handledShortcutKey = new KeyEvent(now, now, KeyEvent.ACTION_DOWN, |
| KeyEvent.KEYCODE_S, 0, KeyEvent.META_CTRL_ON); |
| mInstrumentation.runOnMainSync(() -> |
| assertTrue(mActivity.dispatchKeyShortcutEvent(handledShortcutKey)) |
| ); |
| assertTrue(shareItemClicked[0]); |
| |
| final KeyEvent unhandledShortcutKey = new KeyEvent(now, now, KeyEvent.ACTION_DOWN, |
| KeyEvent.KEYCODE_A, 0, KeyEvent.META_CTRL_ON); |
| |
| // Make sure we aren't eating unused shortcuts. |
| mInstrumentation.runOnMainSync(() -> |
| assertFalse(mActivity.dispatchKeyShortcutEvent(unhandledShortcutKey)) |
| ); |
| |
| mActivity.resetCounts(); |
| |
| // Make sure that unhandled shortcuts don't prepare menus (since toolbar is handling that). |
| mInstrumentation.sendKeySync(unhandledShortcutKey); |
| assertEquals(1, mActivity.mKeyShortcutCount); |
| assertEquals(0, mActivity.mPrepareMenuCount); |
| assertEquals(0, mActivity.mCreateMenuCount); |
| } |
| } |
