| /* |
| * 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 androidx.appcompat.app; |
| |
| import static android.support.test.espresso.Espresso.onData; |
| import static android.support.test.espresso.Espresso.onView; |
| import static android.support.test.espresso.action.ViewActions.click; |
| import static android.support.test.espresso.assertion.PositionAssertions.isBelow; |
| import static android.support.test.espresso.assertion.ViewAssertions.doesNotExist; |
| import static android.support.test.espresso.assertion.ViewAssertions.matches; |
| import static android.support.test.espresso.matcher.LayoutMatchers.hasEllipsizedText; |
| import static android.support.test.espresso.matcher.RootMatchers.isDialog; |
| import static android.support.test.espresso.matcher.ViewMatchers.hasSibling; |
| import static android.support.test.espresso.matcher.ViewMatchers.isAssignableFrom; |
| import static android.support.test.espresso.matcher.ViewMatchers.isCompletelyDisplayed; |
| import static android.support.test.espresso.matcher.ViewMatchers.isDescendantOfA; |
| import static android.support.test.espresso.matcher.ViewMatchers.isDisplayed; |
| import static android.support.test.espresso.matcher.ViewMatchers.withId; |
| import static android.support.test.espresso.matcher.ViewMatchers.withText; |
| |
| import static org.hamcrest.Matchers.instanceOf; |
| import static org.hamcrest.Matchers.not; |
| import static org.hamcrest.core.AllOf.allOf; |
| import static org.hamcrest.core.Is.is; |
| 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.ArgumentMatchers.anyLong; |
| 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 android.content.Context; |
| import android.content.DialogInterface; |
| import android.graphics.drawable.ColorDrawable; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.support.test.annotation.UiThreadTest; |
| import android.support.test.espresso.Espresso; |
| import android.support.test.espresso.ViewInteraction; |
| import android.support.test.filters.LargeTest; |
| import android.support.test.filters.MediumTest; |
| import android.support.test.filters.SmallTest; |
| import android.support.test.rule.ActivityTestRule; |
| import android.text.TextUtils; |
| import android.util.TypedValue; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.widget.ArrayAdapter; |
| import android.widget.Button; |
| import android.widget.CheckedTextView; |
| import android.widget.ImageView; |
| import android.widget.ListAdapter; |
| import android.widget.ListView; |
| |
| import androidx.annotation.ColorInt; |
| import androidx.annotation.StringRes; |
| import androidx.appcompat.test.R; |
| import androidx.appcompat.testutils.TestUtilsMatchers; |
| |
| import org.hamcrest.Matcher; |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.mockito.ArgumentCaptor; |
| |
| /** |
| * Tests in this class make a few assumptions about the underlying implementation of |
| * <code>AlertDialog</code>. While the assumptions don't go all the way down to individual |
| * <code>R.id</code> references or very specific layout arrangements, internal refactoring |
| * of <code>AlertDialog</code> might require corresponding restructuring of the matching |
| * tests. Specifically: |
| * |
| * <ul> |
| * <li>Testing <code>setIcon</code> API assumes that the icon is displayed by a separate |
| * <code>ImageView</code> which is a sibling of a title view.</li> |
| * <li>Testing <code>setMultiChoiceItems</code> API assumes that each item in the list |
| * is rendered by a single <code>CheckedTextView</code>.</li> |
| * <li>Testing <code>setSingleChoiceItems</code> API assumes that each item in the list |
| * is rendered by a single <code>CheckedTextView</code>.</li> |
| * </ul> |
| */ |
| public class AlertDialogTest { |
| @Rule |
| public final ActivityTestRule<AlertDialogTestActivity> mActivityTestRule; |
| |
| private Button mButton; |
| |
| private AlertDialog mAlertDialog; |
| |
| public AlertDialogTest() { |
| mActivityTestRule = new ActivityTestRule<>(AlertDialogTestActivity.class); |
| } |
| |
| @Before |
| public void setUp() { |
| final AlertDialogTestActivity activity = mActivityTestRule.getActivity(); |
| mButton = (Button) activity.findViewById(R.id.test_button); |
| } |
| |
| @After |
| public void tearDown() throws Throwable { |
| if ((mAlertDialog != null) && mAlertDialog.isShowing()) { |
| mActivityTestRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mAlertDialog.hide(); |
| } |
| }); |
| } |
| } |
| |
| private void wireBuilder(final AlertDialog.Builder builder) { |
| mButton.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| mAlertDialog = builder.show(); |
| } |
| }); |
| } |
| |
| @Test |
| @SmallTest |
| @UiThreadTest |
| public void testBuilderTheme() { |
| final Context context = mActivityTestRule.getActivity(); |
| final AlertDialog dialog = new AlertDialog.Builder(context, R.style.Theme_TextColors) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content) |
| .create(); |
| |
| final TypedValue tv = new TypedValue(); |
| dialog.getContext().getTheme().resolveAttribute(android.R.attr.textColorPrimary, tv, true); |
| assertEquals(0xFF0000FF, tv.data); |
| } |
| |
| @Test |
| @MediumTest |
| public void testBasicContent() { |
| final Context context = mActivityTestRule.getActivity(); |
| AlertDialog.Builder builder = new AlertDialog.Builder(context) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content); |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Test that we're showing a dialog with vertically stacked title and content |
| final String expectedTitle = context.getString(R.string.alert_dialog_title); |
| final String expectedMessage = context.getString(R.string.alert_dialog_content); |
| onView(withText(expectedTitle)).inRoot(isDialog()).check(matches(isDisplayed())); |
| onView(withText(expectedMessage)).inRoot(isDialog()).check(matches(isDisplayed())); |
| onView(withText(expectedMessage)).inRoot(isDialog()).check( |
| isBelow(withText(expectedTitle))); |
| |
| assertNull("No list view", mAlertDialog.getListView()); |
| |
| assertEquals("Positive button not shown", View.GONE, |
| mAlertDialog.getButton(AlertDialog.BUTTON_POSITIVE).getVisibility()); |
| assertEquals("Negative button not shown", View.GONE, |
| mAlertDialog.getButton(AlertDialog.BUTTON_NEGATIVE).getVisibility()); |
| assertEquals("Neutral button not shown", View.GONE, |
| mAlertDialog.getButton(AlertDialog.BUTTON_NEUTRAL).getVisibility()); |
| } |
| |
| // Tests for message logic |
| |
| @Test |
| @MediumTest |
| public void testMessageString() { |
| final String dialogMessage = "Dialog message"; |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(dialogMessage); |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| onView(withText(dialogMessage)).inRoot(isDialog()).check(matches(isDisplayed())); |
| } |
| |
| @Test |
| @MediumTest |
| public void testMessageStringPostCreation() throws Throwable { |
| final String dialogInitialMessage = "Initial message"; |
| final String dialogUpdatedMessage = "Updated message"; |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(dialogInitialMessage); |
| wireBuilder(builder); |
| |
| // Click the button to show the dialog and check that it shows the initial message |
| onView(withId(R.id.test_button)).perform(click()); |
| onView(withText(dialogInitialMessage)).inRoot(isDialog()).check(matches(isDisplayed())); |
| |
| // Update the dialog message |
| mActivityTestRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mAlertDialog.setMessage(dialogUpdatedMessage); |
| } |
| }); |
| // Check that the old message is not showing |
| onView(withText(dialogInitialMessage)).inRoot(isDialog()).check(doesNotExist()); |
| // and that the new message is showing |
| onView(withText(dialogUpdatedMessage)).inRoot(isDialog()).check(matches(isDisplayed())); |
| } |
| |
| // Tests for custom title logic |
| |
| /** |
| * Helper method to verify that setting custom title hides the default title and shows |
| * the custom title above the dialog message. |
| */ |
| private void verifyCustomTitle() { |
| final Context context = mActivityTestRule.getActivity(); |
| |
| // Test that we're showing a dialog with vertically stacked custom title and content |
| final String title = context.getString(R.string.alert_dialog_title); |
| final String expectedCustomTitle = context.getString(R.string.alert_dialog_custom_title); |
| final String expectedMessage = context.getString(R.string.alert_dialog_content); |
| |
| // Check that the default title is not showing |
| onView(withText(title)).inRoot(isDialog()).check(doesNotExist()); |
| // Check that the custom title is fully displayed with no text eliding and is |
| // stacked above the message |
| onView(withText(expectedCustomTitle)).inRoot(isDialog()).check( |
| matches(isCompletelyDisplayed())); |
| onView(withText(expectedCustomTitle)).inRoot(isDialog()).check( |
| matches(not(hasEllipsizedText()))); |
| onView(withText(expectedMessage)).inRoot(isDialog()).check(matches(isDisplayed())); |
| onView(withText(expectedMessage)).inRoot(isDialog()).check( |
| isBelow(withText(expectedCustomTitle))); |
| } |
| |
| @Test |
| @MediumTest |
| public void testCustomTitle() { |
| final Context context = mActivityTestRule.getActivity(); |
| final LayoutInflater inflater = LayoutInflater.from(context); |
| AlertDialog.Builder builder = new AlertDialog.Builder(context) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content) |
| .setCustomTitle(inflater.inflate(R.layout.alert_dialog_custom_title, null, false)); |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| verifyCustomTitle(); |
| } |
| |
| @Test |
| @MediumTest |
| public void testCustomTitlePostCreation() { |
| final Context context = mActivityTestRule.getActivity(); |
| final LayoutInflater inflater = LayoutInflater.from(context); |
| final AlertDialog.Builder builder = new AlertDialog.Builder(context) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content); |
| |
| mButton.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| mAlertDialog = builder.create(); |
| |
| // Configure custom title |
| mAlertDialog.setCustomTitle(inflater.inflate( |
| R.layout.alert_dialog_custom_title, null, false)); |
| |
| mAlertDialog.show(); |
| } |
| }); |
| |
| // Click the button to create the dialog, configure custom title and show the dialog |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| verifyCustomTitle(); |
| } |
| |
| // Tests for custom view logic |
| |
| /** |
| * Helper method to verify that setting custom view shows the content of that view. |
| */ |
| private void verifyCustomView() { |
| final Context context = mActivityTestRule.getActivity(); |
| |
| // Test that we're showing a dialog with vertically stacked custom title and content |
| final String expectedCustomText1 = context.getString(R.string.alert_dialog_custom_text1); |
| final String expectedCustomText2 = context.getString(R.string.alert_dialog_custom_text2); |
| |
| // Check that we're showing the content of our custom view |
| onView(withId(R.id.alert_dialog_custom_view)).inRoot(isDialog()).check( |
| matches(isCompletelyDisplayed())); |
| onView(withText(expectedCustomText1)).inRoot(isDialog()).check( |
| matches(isCompletelyDisplayed())); |
| onView(withText(expectedCustomText1)).inRoot(isDialog()).check( |
| matches(not(hasEllipsizedText()))); |
| onView(withText(expectedCustomText2)).inRoot(isDialog()).check( |
| matches(isCompletelyDisplayed())); |
| onView(withText(expectedCustomText2)).inRoot(isDialog()).check( |
| matches(not(hasEllipsizedText()))); |
| } |
| |
| @Test |
| @MediumTest |
| public void testCustomView() { |
| final Context context = mActivityTestRule.getActivity(); |
| final LayoutInflater inflater = LayoutInflater.from(context); |
| AlertDialog.Builder builder = new AlertDialog.Builder(context) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content) |
| .setView(inflater.inflate(R.layout.alert_dialog_custom_view, null, false)); |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| verifyCustomView(); |
| } |
| |
| @Test |
| @MediumTest |
| public void testCustomViewById() { |
| final Context context = mActivityTestRule.getActivity(); |
| AlertDialog.Builder builder = new AlertDialog.Builder(context) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content) |
| .setView(R.layout.alert_dialog_custom_view); |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| verifyCustomView(); |
| } |
| |
| @Test |
| @MediumTest |
| public void testCustomViewPostCreation() { |
| final Context context = mActivityTestRule.getActivity(); |
| final LayoutInflater inflater = LayoutInflater.from(context); |
| final AlertDialog.Builder builder = new AlertDialog.Builder(context) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content); |
| |
| mButton.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| mAlertDialog = builder.create(); |
| |
| // Configure custom view |
| mAlertDialog.setView(inflater.inflate( |
| R.layout.alert_dialog_custom_view, null, false)); |
| |
| mAlertDialog.show(); |
| } |
| }); |
| |
| // Click the button to create the dialog, configure custom view and show the dialog |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| verifyCustomView(); |
| } |
| |
| // Tests for cancel logic |
| |
| @Test |
| @MediumTest |
| public void testCancelCancelableDialog() { |
| DialogInterface.OnCancelListener mockCancelListener = |
| mock(DialogInterface.OnCancelListener.class); |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content) |
| .setCancelable(true) |
| .setOnCancelListener(mockCancelListener); |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Emulate a tap on the device BACK button |
| Espresso.pressBack(); |
| |
| // Since our dialog is cancelable, check that the cancel listener has been invoked |
| verify(mockCancelListener, times(1)).onCancel(mAlertDialog); |
| } |
| |
| @Test |
| @MediumTest |
| public void testCancelNonCancelableDialog() { |
| DialogInterface.OnCancelListener mockCancelListener = |
| mock(DialogInterface.OnCancelListener.class); |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content) |
| .setCancelable(false) |
| .setOnCancelListener(mockCancelListener); |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Emulate a tap on the device BACK button |
| Espresso.pressBack(); |
| |
| // Since our dialog is not cancelable, check that the cancel listener has not been invoked |
| verify(mockCancelListener, never()).onCancel(mAlertDialog); |
| } |
| |
| // Tests for items content logic (simple, single-choice, multi-choice) |
| |
| private void verifySimpleItemsContent(String[] expectedContent, |
| DialogInterface.OnClickListener onClickListener) { |
| final int expectedCount = expectedContent.length; |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| final ListView listView = mAlertDialog.getListView(); |
| assertNotNull("List view is shown", listView); |
| |
| final ListAdapter listAdapter = listView.getAdapter(); |
| assertEquals("List has " + expectedCount + " entries", |
| expectedCount, listAdapter.getCount()); |
| for (int i = 0; i < expectedCount; i++) { |
| assertEquals("List entry #" + i, expectedContent[i], listAdapter.getItem(i)); |
| } |
| |
| // Test that all items are showing |
| onView(withText("Dialog title")).inRoot(isDialog()).check(matches(isDisplayed())); |
| for (int i = 0; i < expectedCount; i++) { |
| onData(allOf(is(instanceOf(String.class)), is(expectedContent[i]))).inRoot(isDialog()). |
| check(matches(isDisplayed())); |
| } |
| |
| // Verify that our click listener hasn't been called yet |
| verify(onClickListener, never()).onClick(any(DialogInterface.class), any(int.class)); |
| // Test that a click on an item invokes the registered listener |
| int indexToClick = expectedCount - 2; |
| onData(allOf(is(instanceOf(String.class)), is(expectedContent[indexToClick]))). |
| inRoot(isDialog()).perform(click()); |
| verify(onClickListener, times(1)).onClick(mAlertDialog, indexToClick); |
| } |
| |
| @Test |
| @MediumTest |
| public void testCustomAdapter() { |
| final Context context = mActivityTestRule.getActivity(); |
| final String[] content = context.getResources().getStringArray(R.array.alert_dialog_items); |
| final DialogInterface.OnClickListener mockClickListener = |
| mock(DialogInterface.OnClickListener.class); |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setAdapter( |
| new ArrayAdapter<>(context, android.R.layout.simple_list_item_1, content), |
| mockClickListener); |
| wireBuilder(builder); |
| |
| verifySimpleItemsContent(content, mockClickListener); |
| } |
| |
| @Test |
| @MediumTest |
| public void testSimpleItemsFromRuntimeArray() { |
| final String[] content = new String[] { "Alice", "Bob", "Charlie", "Delta" }; |
| final DialogInterface.OnClickListener mockClickListener = |
| mock(DialogInterface.OnClickListener.class); |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setItems(content, mockClickListener); |
| wireBuilder(builder); |
| |
| verifySimpleItemsContent(content, mockClickListener); |
| } |
| |
| @Test |
| @MediumTest |
| public void testSimpleItemsFromResourcesArray() { |
| final DialogInterface.OnClickListener mockClickListener = |
| mock(DialogInterface.OnClickListener.class); |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setItems(R.array.alert_dialog_items, mockClickListener); |
| wireBuilder(builder); |
| |
| verifySimpleItemsContent(mActivityTestRule.getActivity().getResources().getStringArray( |
| R.array.alert_dialog_items), mockClickListener); |
| } |
| |
| /** |
| * Helper method to verify the state of the multi-choice items list. It gets the String |
| * array of content and verifies that: |
| * |
| * 1. The items in the array are rendered as CheckedTextViews inside a ListView |
| * 2. Each item in the array is displayed |
| * 3. Checked state of each row in the ListView corresponds to the matching entry in the |
| * passed boolean array |
| */ |
| private void verifyMultiChoiceItemsState(String[] expectedContent, |
| boolean[] checkedTracker) { |
| final int expectedCount = expectedContent.length; |
| |
| final ListView listView = mAlertDialog.getListView(); |
| assertNotNull("List view is shown", listView); |
| |
| final ListAdapter listAdapter = listView.getAdapter(); |
| assertEquals("List has " + expectedCount + " entries", |
| expectedCount, listAdapter.getCount()); |
| for (int i = 0; i < expectedCount; i++) { |
| assertEquals("List entry #" + i, expectedContent[i], listAdapter.getItem(i)); |
| } |
| |
| for (int i = 0; i < expectedCount; i++) { |
| Matcher checkedStateMatcher = checkedTracker[i] ? TestUtilsMatchers.isCheckedTextView() : |
| TestUtilsMatchers.isNonCheckedTextView(); |
| // Check that the corresponding row is rendered as CheckedTextView with expected |
| // checked state. |
| onData(allOf(is(instanceOf(String.class)), is(expectedContent[i]))).inRoot(isDialog()). |
| check(matches(allOf( |
| isDisplayed(), |
| isAssignableFrom(CheckedTextView.class), |
| isDescendantOfA(isAssignableFrom(ListView.class)), |
| checkedStateMatcher))); |
| } |
| } |
| |
| private void verifyMultiChoiceItemsContent(String[] expectedContent, |
| final boolean[] checkedTracker) { |
| final int expectedCount = expectedContent.length; |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| final ListView listView = mAlertDialog.getListView(); |
| assertNotNull("List view is shown", listView); |
| |
| final ListAdapter listAdapter = listView.getAdapter(); |
| assertEquals("List has " + expectedCount + " entries", |
| expectedCount, listAdapter.getCount()); |
| for (int i = 0; i < expectedCount; i++) { |
| assertEquals("List entry #" + i, expectedContent[i], listAdapter.getItem(i)); |
| } |
| |
| // Test that all items are showing |
| onView(withText("Dialog title")).inRoot(isDialog()).check(matches(isDisplayed())); |
| verifyMultiChoiceItemsState(expectedContent, checkedTracker); |
| |
| // We're going to click item #1 and test that the click listener has been invoked to |
| // update the original state array |
| boolean[] expectedAfterClick1 = checkedTracker.clone(); |
| expectedAfterClick1[1] = !expectedAfterClick1[1]; |
| onData(allOf(is(instanceOf(String.class)), is(expectedContent[1]))). |
| inRoot(isDialog()).perform(click()); |
| verifyMultiChoiceItemsState(expectedContent, expectedAfterClick1); |
| |
| // Now click item #1 again and test that the click listener has been invoked to update the |
| // original state array again |
| expectedAfterClick1[1] = !expectedAfterClick1[1]; |
| onData(allOf(is(instanceOf(String.class)), is(expectedContent[1]))). |
| inRoot(isDialog()).perform(click()); |
| verifyMultiChoiceItemsState(expectedContent, expectedAfterClick1); |
| |
| // Now we're going to click the last item and test that the click listener has been invoked |
| // to update the original state array |
| boolean[] expectedAfterClickLast = checkedTracker.clone(); |
| expectedAfterClickLast[expectedCount - 1] = !expectedAfterClickLast[expectedCount - 1]; |
| onData(allOf(is(instanceOf(String.class)), is(expectedContent[expectedCount - 1]))). |
| inRoot(isDialog()).perform(click()); |
| verifyMultiChoiceItemsState(expectedContent, expectedAfterClickLast); |
| } |
| |
| @Test |
| @MediumTest |
| public void testMultiChoiceItemsFromRuntimeArray() { |
| final String[] content = new String[] { "Alice", "Bob", "Charlie", "Delta" }; |
| final boolean[] checkedTracker = new boolean[] { false, true, false, false }; |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMultiChoiceItems( |
| content, checkedTracker, |
| new DialogInterface.OnMultiChoiceClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which, |
| boolean isChecked) { |
| checkedTracker[which] = isChecked; |
| } |
| }); |
| wireBuilder(builder); |
| |
| // Pass the same boolean[] array as used for initialization since our click listener |
| // will be updating its content. |
| verifyMultiChoiceItemsContent(content, checkedTracker); |
| } |
| |
| @Test |
| @MediumTest |
| public void testMultiChoiceItemsFromResourcesArray() { |
| final boolean[] checkedTracker = new boolean[] { true, false, true, false }; |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMultiChoiceItems(R.array.alert_dialog_items, checkedTracker, |
| new DialogInterface.OnMultiChoiceClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which, |
| boolean isChecked) { |
| checkedTracker[which] = isChecked; |
| } |
| }); |
| wireBuilder(builder); |
| |
| verifyMultiChoiceItemsContent( |
| mActivityTestRule.getActivity().getResources().getStringArray( |
| R.array.alert_dialog_items), |
| checkedTracker); |
| } |
| |
| /** |
| * Helper method to verify the state of the single-choice items list. It gets the String |
| * array of content and verifies that: |
| * |
| * 1. The items in the array are rendered as CheckedTextViews inside a ListView |
| * 2. Each item in the array is displayed |
| * 3. Only one row in the ListView is checked, and that corresponds to the passed |
| * integer index. |
| */ |
| private void verifySingleChoiceItemsState(String[] expectedContent, |
| int currentlyExpectedSelectionIndex) { |
| final int expectedCount = expectedContent.length; |
| |
| final ListView listView = mAlertDialog.getListView(); |
| assertNotNull("List view is shown", listView); |
| |
| final ListAdapter listAdapter = listView.getAdapter(); |
| assertEquals("List has " + expectedCount + " entries", |
| expectedCount, listAdapter.getCount()); |
| for (int i = 0; i < expectedCount; i++) { |
| assertEquals("List entry #" + i, expectedContent[i], listAdapter.getItem(i)); |
| } |
| |
| for (int i = 0; i < expectedCount; i++) { |
| Matcher checkedStateMatcher = (i == currentlyExpectedSelectionIndex) ? |
| TestUtilsMatchers.isCheckedTextView() : |
| TestUtilsMatchers.isNonCheckedTextView(); |
| // Check that the corresponding row is rendered as CheckedTextView with expected |
| // checked state. |
| onData(allOf(is(instanceOf(String.class)), is(expectedContent[i]))).inRoot(isDialog()). |
| check(matches(allOf( |
| isDisplayed(), |
| isAssignableFrom(CheckedTextView.class), |
| isDescendantOfA(isAssignableFrom(ListView.class)), |
| checkedStateMatcher))); |
| } |
| } |
| |
| private void verifySingleChoiceItemsContent(String[] expectedContent, |
| int initialSelectionIndex, DialogInterface.OnClickListener onClickListener) { |
| final int expectedCount = expectedContent.length; |
| int currentlyExpectedSelectionIndex = initialSelectionIndex; |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Test that all items are showing |
| onView(withText("Dialog title")).inRoot(isDialog()).check(matches(isDisplayed())); |
| verifySingleChoiceItemsState(expectedContent, currentlyExpectedSelectionIndex); |
| |
| // We're going to click the first unselected item and test that the click listener has |
| // been invoked. |
| currentlyExpectedSelectionIndex = (currentlyExpectedSelectionIndex == 0) ? 1 : 0; |
| onData(allOf(is(instanceOf(String.class)), |
| is(expectedContent[currentlyExpectedSelectionIndex]))). |
| inRoot(isDialog()).perform(click()); |
| verify(onClickListener, times(1)).onClick(mAlertDialog, currentlyExpectedSelectionIndex); |
| verifySingleChoiceItemsState(expectedContent, currentlyExpectedSelectionIndex); |
| |
| // Now click the same item again and test that the selection has not changed |
| onData(allOf(is(instanceOf(String.class)), |
| is(expectedContent[currentlyExpectedSelectionIndex]))). |
| inRoot(isDialog()).perform(click()); |
| verify(onClickListener, times(2)).onClick(mAlertDialog, currentlyExpectedSelectionIndex); |
| verifySingleChoiceItemsState(expectedContent, currentlyExpectedSelectionIndex); |
| |
| // Now we're going to click the last item and test that the click listener has been invoked |
| // to update the original state array |
| currentlyExpectedSelectionIndex = expectedCount - 1; |
| onData(allOf(is(instanceOf(String.class)), |
| is(expectedContent[currentlyExpectedSelectionIndex]))). |
| inRoot(isDialog()).perform(click()); |
| verify(onClickListener, times(1)).onClick(mAlertDialog, currentlyExpectedSelectionIndex); |
| verifySingleChoiceItemsState(expectedContent, currentlyExpectedSelectionIndex); |
| } |
| |
| @Test |
| @LargeTest |
| public void testSingleChoiceItemsFromRuntimeArray() { |
| final String[] content = new String[] { "Alice", "Bob", "Charlie", "Delta" }; |
| final DialogInterface.OnClickListener mockClickListener = |
| mock(DialogInterface.OnClickListener.class); |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setSingleChoiceItems(content, 2, mockClickListener); |
| wireBuilder(builder); |
| |
| verifySingleChoiceItemsContent(content, 2, mockClickListener); |
| } |
| |
| @Test |
| @LargeTest |
| public void testSingleChoiceItemsFromResourcesArray() { |
| final DialogInterface.OnClickListener mockClickListener = |
| mock(DialogInterface.OnClickListener.class); |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setSingleChoiceItems(R.array.alert_dialog_items, 1, mockClickListener); |
| wireBuilder(builder); |
| |
| verifySingleChoiceItemsContent(new String[] { "Albania", "Belize", "Chad", "Djibouti" }, 1, |
| mockClickListener); |
| } |
| |
| // Tests for icon logic |
| |
| @Test |
| @MediumTest |
| public void testIconResource() { |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content) |
| .setIcon(R.drawable.test_drawable_red); |
| |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Find the title icon as a visible view that is the sibling of our title |
| ViewInteraction titleIconInteraction = onView(allOf( |
| isAssignableFrom(ImageView.class), |
| isDisplayed(), |
| hasSibling(withText("Dialog title")))); |
| // And check that it's the expected red color |
| titleIconInteraction.check(matches(TestUtilsMatchers.drawable(0xFFFF6030))); |
| } |
| |
| @Test |
| @MediumTest |
| public void testIconResourceChangeAfterInitialSetup() throws Throwable { |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content) |
| .setIcon(R.drawable.test_drawable_red); |
| |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Emulate background loading of the new icon |
| Thread.sleep(1000); |
| |
| // Change the icon |
| mActivityTestRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mAlertDialog.setIcon(R.drawable.test_drawable_green); |
| } |
| }); |
| |
| // Find the title icon as a visible view that is the sibling of our title |
| ViewInteraction titleIconInteraction = onView(allOf( |
| isAssignableFrom(ImageView.class), |
| isDisplayed(), |
| hasSibling(withText("Dialog title")))); |
| // And check that it's the expected (newly set) green color |
| titleIconInteraction.check(matches(TestUtilsMatchers.drawable(0xFF50E080))); |
| } |
| |
| @Test |
| @MediumTest |
| public void testIconResourceChangeWithNoInitialSetup() throws Throwable { |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content); |
| |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Emulate background loading of the new icon |
| Thread.sleep(1000); |
| |
| // Change the icon |
| mActivityTestRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mAlertDialog.setIcon(R.drawable.test_drawable_green); |
| } |
| }); |
| |
| // Find the title icon as a visible view that is the sibling of our title |
| ViewInteraction titleIconInteraction = onView(allOf( |
| isAssignableFrom(ImageView.class), |
| isDisplayed(), |
| hasSibling(withText("Dialog title")))); |
| // And check that it's the expected (newly set) green color |
| titleIconInteraction.check(matches(TestUtilsMatchers.drawable(0xFF50E080))); |
| } |
| |
| @Test |
| @MediumTest |
| public void testIconResourceRemoveAfterInitialSetup() throws Throwable { |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content) |
| .setIcon(R.drawable.test_drawable_red); |
| |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Emulate background resetting of the icon |
| Thread.sleep(1000); |
| |
| // Change the icon |
| mActivityTestRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mAlertDialog.setIcon(0); |
| } |
| }); |
| |
| // Find the title icon as a visible view that is the sibling of our title |
| ViewInteraction titleIconInteraction = onView(allOf( |
| isAssignableFrom(ImageView.class), |
| isDisplayed(), |
| hasSibling(withText("Dialog title")))); |
| // And check that we couldn't find the title icon (since it's expected to be GONE) |
| titleIconInteraction.check(doesNotExist()); |
| } |
| |
| @Test |
| @MediumTest |
| public void testIconDrawable() { |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content) |
| .setIcon(new TestDrawable(0xFF807060, 40, 40)); |
| |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Find the title icon as a visible view that is the sibling of our title |
| ViewInteraction titleIconInteraction = onView(allOf( |
| isAssignableFrom(ImageView.class), |
| isDisplayed(), |
| hasSibling(withText("Dialog title")))); |
| // And check that it's the expected red color |
| titleIconInteraction.check(matches(TestUtilsMatchers.drawable(0xFF807060))); |
| } |
| |
| @Test |
| @MediumTest |
| public void testIconResourceDrawableAfterInitialSetup() throws Throwable { |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content) |
| .setIcon(new TestDrawable(0xFF807060, 40, 40)); |
| |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Emulate background loading of the new icon |
| Thread.sleep(1000); |
| |
| // Change the icon |
| mActivityTestRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mAlertDialog.setIcon(new TestDrawable(0xFF503090, 40, 40)); |
| } |
| }); |
| |
| // Find the title icon as a visible view that is the sibling of our title |
| ViewInteraction titleIconInteraction = onView(allOf( |
| isAssignableFrom(ImageView.class), |
| isDisplayed(), |
| hasSibling(withText("Dialog title")))); |
| // And check that it's the expected (newly set) green color |
| titleIconInteraction.check(matches(TestUtilsMatchers.drawable(0xFF503090))); |
| } |
| |
| @Test |
| @MediumTest |
| public void testIconDrawableChangeWithNoInitialSetup() throws Throwable { |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content); |
| |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Emulate background loading of the new icon |
| Thread.sleep(1000); |
| |
| // Change the icon |
| mActivityTestRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mAlertDialog.setIcon(new TestDrawable(0xFF503090, 40, 40)); |
| } |
| }); |
| |
| // Find the title icon as a visible view that is the sibling of our title |
| ViewInteraction titleIconInteraction = onView(allOf( |
| isAssignableFrom(ImageView.class), |
| isDisplayed(), |
| hasSibling(withText("Dialog title")))); |
| // And check that it's the expected (newly set) green color |
| titleIconInteraction.check(matches(TestUtilsMatchers.drawable(0xFF503090))); |
| } |
| |
| @Test |
| @MediumTest |
| public void testIconDrawableRemoveAfterInitialSetup() throws Throwable { |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setMessage(R.string.alert_dialog_content) |
| .setIcon(new TestDrawable(0xFF807060, 40, 40)); |
| |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Emulate background resetting of the icon |
| Thread.sleep(1000); |
| |
| // Change the icon |
| mActivityTestRule.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mAlertDialog.setIcon(null); |
| } |
| }); |
| |
| // Find the title icon as a visible view that is the sibling of our title |
| ViewInteraction titleIconInteraction = onView(allOf( |
| isAssignableFrom(ImageView.class), |
| isDisplayed(), |
| hasSibling(withText("Dialog title")))); |
| // And check that we couldn't find the title icon (since it's expected to be GONE) |
| titleIconInteraction.check(doesNotExist()); |
| } |
| |
| // Tests for buttons logic |
| |
| /** |
| * Helper method to verify visibility and text content of dialog buttons. Gets expected texts |
| * for three buttons (positive, negative and neutral) and for each button verifies that: |
| * |
| * If the text is null or empty, that the button is GONE |
| * If the text is not empty, that the button is VISIBLE and shows the corresponding text |
| */ |
| private void verifyButtonContent(String expectedPositiveButtonText, |
| String expectedNegativeButtonText, String expectedNeutralButtonText) { |
| assertTrue("Dialog is showing", mAlertDialog.isShowing()); |
| |
| final Button positiveButton = mAlertDialog.getButton(AlertDialog.BUTTON_POSITIVE); |
| final Button negativeButton = mAlertDialog.getButton(AlertDialog.BUTTON_NEGATIVE); |
| final Button neutralButton = mAlertDialog.getButton(AlertDialog.BUTTON_NEUTRAL); |
| |
| if (TextUtils.isEmpty(expectedPositiveButtonText)) { |
| assertEquals("Positive button not shown", View.GONE, positiveButton.getVisibility()); |
| } else { |
| assertEquals("Positive button shown", View.VISIBLE, positiveButton.getVisibility()); |
| assertEquals("Positive button text", expectedPositiveButtonText, |
| positiveButton.getText()); |
| } |
| |
| if (TextUtils.isEmpty(expectedNegativeButtonText)) { |
| assertEquals("Negative button not shown", View.GONE, negativeButton.getVisibility()); |
| } else { |
| assertEquals("Negative button shown", View.VISIBLE, negativeButton.getVisibility()); |
| assertEquals("Negative button text", expectedNegativeButtonText, |
| negativeButton.getText()); |
| } |
| |
| if (TextUtils.isEmpty(expectedNeutralButtonText)) { |
| assertEquals("Neutral button not shown", View.GONE, neutralButton.getVisibility()); |
| } else { |
| assertEquals("Neutral button shown", View.VISIBLE, neutralButton.getVisibility()); |
| assertEquals("Neutral button text", expectedNeutralButtonText, |
| neutralButton.getText()); |
| } |
| } |
| |
| /** |
| * Helper method to verify dialog state after a button has been clicked. |
| */ |
| private void verifyPostButtonClickState(int whichButtonClicked, |
| DialogInterface.OnDismissListener onDismissListener, |
| Handler messageHandler) { |
| // Verify that a Message with expected 'what' field has been posted on our mock handler |
| ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); |
| verify(messageHandler, times(1)).sendMessageDelayed( |
| messageArgumentCaptor.capture(), anyLong()); |
| assertEquals("Button clicked", whichButtonClicked, messageArgumentCaptor.getValue().what); |
| // Verify that the dialog is no longer showing |
| assertFalse("Dialog is not showing", mAlertDialog.isShowing()); |
| if (onDismissListener != null) { |
| // And that our mock listener has been called when the dialog was dismissed |
| verify(onDismissListener, times(1)).onDismiss(mAlertDialog); |
| } |
| } |
| |
| /** |
| * Helper method to verify dialog state after a button has been clicked. |
| */ |
| private void verifyPostButtonClickState(int whichButtonClicked, |
| DialogInterface.OnClickListener onClickListener, |
| DialogInterface.OnDismissListener onDismissListener) { |
| if (onClickListener != null) { |
| verify(onClickListener, times(1)).onClick(mAlertDialog, whichButtonClicked); |
| } |
| assertFalse("Dialog is not showing", mAlertDialog.isShowing()); |
| if (onDismissListener != null) { |
| verify(onDismissListener, times(1)).onDismiss(mAlertDialog); |
| } |
| } |
| |
| /** |
| * Helper method to verify button-related logic for setXXXButton on AlertDialog.Builder |
| * that gets CharSequence parameter. This method configures the dialog buttons based |
| * on the passed texts (some of which may be null or empty, in which case the corresponding |
| * button is not configured), tests the buttons visibility and texts, simulates a click |
| * on the specified button and then tests the post-click dialog state. |
| */ |
| private void verifyDialogButtons(String positiveButtonText, String negativeButtonText, |
| String neutralButtonText, int whichButtonToClick) { |
| final AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title); |
| // Configure buttons with non-empty texts |
| DialogInterface.OnClickListener mockClickListener = |
| mock(DialogInterface.OnClickListener.class); |
| if (!TextUtils.isEmpty(positiveButtonText)) { |
| builder.setPositiveButton(positiveButtonText, mockClickListener); |
| } |
| if (!TextUtils.isEmpty(negativeButtonText)) { |
| builder.setNegativeButton(negativeButtonText, mockClickListener); |
| } |
| if (!TextUtils.isEmpty(neutralButtonText)) { |
| builder.setNeutralButton(neutralButtonText, mockClickListener); |
| } |
| // Set a dismiss listener to verify that the dialog is dismissed on clicking any button |
| DialogInterface.OnDismissListener mockDismissListener = |
| mock(DialogInterface.OnDismissListener.class); |
| builder.setOnDismissListener(mockDismissListener); |
| |
| // Wire the builder to the button click and click that button to show the dialog |
| wireBuilder(builder); |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Check that the dialog is showing the configured buttons |
| verifyButtonContent(positiveButtonText, negativeButtonText, neutralButtonText); |
| |
| // Click the specified button and verify the post-click state |
| String textOfButtonToClick = null; |
| switch (whichButtonToClick) { |
| case DialogInterface.BUTTON_POSITIVE: |
| textOfButtonToClick = positiveButtonText; |
| break; |
| case DialogInterface.BUTTON_NEGATIVE: |
| textOfButtonToClick = negativeButtonText; |
| break; |
| case DialogInterface.BUTTON_NEUTRAL: |
| textOfButtonToClick = neutralButtonText; |
| break; |
| } |
| onView(withText(textOfButtonToClick)).inRoot(isDialog()).perform(click()); |
| verifyPostButtonClickState(whichButtonToClick, mockClickListener, mockDismissListener); |
| } |
| |
| /** |
| * Helper method to verify button-related logic for setXXXButton on AlertDialog.Builder |
| * that gets string resource ID parameter. This method configures the dialog buttons based |
| * on the passed texts (some of which may be null or empty, in which case the corresponding |
| * button is not configured), tests the buttons visibility and texts, simulates a click |
| * on the specified button and then tests the post-click dialog state. |
| */ |
| private void verifyDialogButtons(@StringRes int positiveButtonTextResId, |
| @StringRes int negativeButtonTextResId, |
| @StringRes int neutralButtonTextResId, int whichButtonToClick) { |
| Context context = mActivityTestRule.getActivity(); |
| String positiveButtonText = null; |
| String negativeButtonText = null; |
| String neutralButtonText = null; |
| |
| final AlertDialog.Builder builder = new AlertDialog.Builder(context) |
| .setTitle(R.string.alert_dialog_title); |
| DialogInterface.OnClickListener mockClickListener = |
| mock(DialogInterface.OnClickListener.class); |
| // Configure buttons with non-zero text resource IDs |
| if (positiveButtonTextResId != 0) { |
| positiveButtonText = context.getString(positiveButtonTextResId); |
| builder.setPositiveButton(positiveButtonTextResId, mockClickListener); |
| } |
| if (negativeButtonTextResId != 0) { |
| negativeButtonText = context.getString(negativeButtonTextResId); |
| builder.setNegativeButton(negativeButtonTextResId, mockClickListener); |
| } |
| if (neutralButtonTextResId != 0) { |
| neutralButtonText = context.getString(neutralButtonTextResId); |
| builder.setNeutralButton(neutralButtonTextResId, mockClickListener); |
| } |
| // Set a dismiss listener to verify that the dialog is dismissed on clicking any button |
| DialogInterface.OnDismissListener mockDismissListener = |
| mock(DialogInterface.OnDismissListener.class); |
| builder.setOnDismissListener(mockDismissListener); |
| |
| // Wire the builder to the button click and click that button to show the dialog |
| wireBuilder(builder); |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Check that the dialog is showing the configured buttons |
| verifyButtonContent(positiveButtonText, negativeButtonText, neutralButtonText); |
| |
| // Click the specified button and verify the post-click state |
| String textOfButtonToClick = null; |
| switch (whichButtonToClick) { |
| case DialogInterface.BUTTON_POSITIVE: |
| textOfButtonToClick = positiveButtonText; |
| break; |
| case DialogInterface.BUTTON_NEGATIVE: |
| textOfButtonToClick = negativeButtonText; |
| break; |
| case DialogInterface.BUTTON_NEUTRAL: |
| textOfButtonToClick = neutralButtonText; |
| break; |
| } |
| onView(withText(textOfButtonToClick)).inRoot(isDialog()).perform(click()); |
| verifyPostButtonClickState(whichButtonToClick, mockClickListener, mockDismissListener); |
| } |
| |
| /** |
| * Helper method to verify button-related logic for setButton on AlertDialog after the |
| * dialog has been create()'d. This method configures the dialog buttons based |
| * on the passed texts (some of which may be null or empty, in which case the corresponding |
| * button is not configured), tests the buttons visibility and texts, simulates a click |
| * on the specified button and then tests the post-click dialog state. |
| */ |
| private void verifyDialogButtonsPostCreation(final String positiveButtonText, |
| final String negativeButtonText, final String neutralButtonText, |
| int whichButtonToClick) { |
| final AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title); |
| // Set a dismiss listener to verify that the dialog is dismissed on clicking any button |
| DialogInterface.OnDismissListener mockDismissListener = |
| mock(DialogInterface.OnDismissListener.class); |
| builder.setOnDismissListener(mockDismissListener); |
| |
| final DialogInterface.OnClickListener mockClickListener = |
| mock(DialogInterface.OnClickListener.class); |
| |
| mButton.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| mAlertDialog = builder.create(); |
| // Configure buttons with non-empty texts |
| if (!TextUtils.isEmpty(positiveButtonText)) { |
| mAlertDialog.setButton(DialogInterface.BUTTON_POSITIVE, positiveButtonText, |
| mockClickListener); |
| } |
| if (!TextUtils.isEmpty(negativeButtonText)) { |
| mAlertDialog.setButton(DialogInterface.BUTTON_NEGATIVE, negativeButtonText, |
| mockClickListener); |
| } |
| if (!TextUtils.isEmpty(neutralButtonText)) { |
| mAlertDialog.setButton(DialogInterface.BUTTON_NEUTRAL, neutralButtonText, |
| mockClickListener); |
| } |
| |
| mAlertDialog.show(); |
| } |
| }); |
| |
| // Click the button to create the dialog, configure the buttons and show the dialog |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Check that the dialog is showing the configured buttons |
| verifyButtonContent(positiveButtonText, negativeButtonText, neutralButtonText); |
| |
| // Click the specified button and verify the post-click state |
| String textOfButtonToClick = null; |
| switch (whichButtonToClick) { |
| case DialogInterface.BUTTON_POSITIVE: |
| textOfButtonToClick = positiveButtonText; |
| break; |
| case DialogInterface.BUTTON_NEGATIVE: |
| textOfButtonToClick = negativeButtonText; |
| break; |
| case DialogInterface.BUTTON_NEUTRAL: |
| textOfButtonToClick = neutralButtonText; |
| break; |
| } |
| onView(withText(textOfButtonToClick)).inRoot(isDialog()).perform(click()); |
| verifyPostButtonClickState(whichButtonToClick, mockClickListener, null); |
| } |
| |
| /** |
| * Helper method to verify button-related logic for setButton on AlertDialog after the |
| * dialog has been create()'d. This method configures the dialog buttons based |
| * on the passed texts (some of which may be null or empty, in which case the corresponding |
| * button is not configured), tests the buttons visibility and texts, simulates a click |
| * on the specified button and then tests the post-click dialog state. |
| */ |
| private void verifyDialogButtonsPostCreationMessage(final String positiveButtonText, |
| final String negativeButtonText, final String neutralButtonText, |
| int whichButtonToClick) { |
| final AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title); |
| // Set a dismiss listener to verify that the dialog is dismissed on clicking any button |
| DialogInterface.OnDismissListener mockDismissListener = |
| mock(DialogInterface.OnDismissListener.class); |
| builder.setOnDismissListener(mockDismissListener); |
| |
| final Handler mockMessageHandler = mock(Handler.class); |
| mButton.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| mAlertDialog = builder.create(); |
| // Configure buttons with non-empty texts |
| if (!TextUtils.isEmpty(positiveButtonText)) { |
| mAlertDialog.setButton(DialogInterface.BUTTON_POSITIVE, positiveButtonText, |
| Message.obtain(mockMessageHandler, DialogInterface.BUTTON_POSITIVE)); |
| } |
| if (!TextUtils.isEmpty(negativeButtonText)) { |
| mAlertDialog.setButton(DialogInterface.BUTTON_NEGATIVE, negativeButtonText, |
| Message.obtain(mockMessageHandler, DialogInterface.BUTTON_NEGATIVE)); |
| } |
| if (!TextUtils.isEmpty(neutralButtonText)) { |
| mAlertDialog.setButton(DialogInterface.BUTTON_NEUTRAL, neutralButtonText, |
| Message.obtain(mockMessageHandler, DialogInterface.BUTTON_NEUTRAL)); |
| } |
| |
| mAlertDialog.show(); |
| } |
| }); |
| |
| // Click the button to create the dialog, configure the buttons and show the dialog |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Check that the dialog is showing the configured buttons |
| verifyButtonContent(positiveButtonText, negativeButtonText, neutralButtonText); |
| |
| // Click the specified button and verify the post-click state |
| String textOfButtonToClick = null; |
| switch (whichButtonToClick) { |
| case DialogInterface.BUTTON_POSITIVE: |
| textOfButtonToClick = positiveButtonText; |
| break; |
| case DialogInterface.BUTTON_NEGATIVE: |
| textOfButtonToClick = negativeButtonText; |
| break; |
| case DialogInterface.BUTTON_NEUTRAL: |
| textOfButtonToClick = neutralButtonText; |
| break; |
| } |
| onView(withText(textOfButtonToClick)).inRoot(isDialog()).perform(click()); |
| verifyPostButtonClickState(whichButtonToClick, mockDismissListener, mockMessageHandler); |
| } |
| |
| @Test |
| @MediumTest |
| public void testButtonVisibility() { |
| final String positiveButtonText = "Positive button"; |
| final String negativeButtonText = "Negative button"; |
| final String neutralButtonText = "Neutral button"; |
| AlertDialog.Builder builder = new AlertDialog.Builder(mActivityTestRule.getActivity()) |
| .setTitle(R.string.alert_dialog_title) |
| .setPositiveButton(positiveButtonText, null) |
| .setNegativeButton(negativeButtonText, null) |
| .setNeutralButton(neutralButtonText, null); |
| wireBuilder(builder); |
| |
| onView(withId(R.id.test_button)).perform(click()); |
| |
| // Positive button should be fully displayed with no text eliding |
| onView(withText(positiveButtonText)).inRoot(isDialog()).check( |
| matches(isCompletelyDisplayed())); |
| onView(withText(positiveButtonText)).inRoot(isDialog()).check( |
| matches(not(hasEllipsizedText()))); |
| |
| // Negative button should be fully displayed with no text eliding |
| onView(withText(negativeButtonText)).inRoot(isDialog()).check( |
| matches(isCompletelyDisplayed())); |
| onView(withText(negativeButtonText)).inRoot(isDialog()).check( |
| matches(not(hasEllipsizedText()))); |
| |
| // Neutral button should be fully displayed with no text eliding |
| onView(withText(neutralButtonText)).inRoot(isDialog()).check( |
| matches(isCompletelyDisplayed())); |
| onView(withText(neutralButtonText)).inRoot(isDialog()).check( |
| matches(not(hasEllipsizedText()))); |
| } |
| |
| @Test |
| @LargeTest |
| public void testButtons() { |
| // Positive-only button |
| verifyDialogButtons("Positive", null, null, AlertDialog.BUTTON_POSITIVE); |
| verifyDialogButtons(R.string.alert_dialog_positive_button, 0, 0, |
| AlertDialog.BUTTON_POSITIVE); |
| verifyDialogButtonsPostCreation("Post positive", null, null, AlertDialog.BUTTON_POSITIVE); |
| verifyDialogButtonsPostCreationMessage("Message positive", null, null, |
| AlertDialog.BUTTON_POSITIVE); |
| |
| // Negative-only button |
| verifyDialogButtons(null, "Negative", null, AlertDialog.BUTTON_NEGATIVE); |
| verifyDialogButtons(0, R.string.alert_dialog_negative_button, 0, |
| AlertDialog.BUTTON_NEGATIVE); |
| verifyDialogButtonsPostCreation(null, "Post negative", null, AlertDialog.BUTTON_NEGATIVE); |
| verifyDialogButtonsPostCreationMessage(null, "Message negative", null, |
| AlertDialog.BUTTON_NEGATIVE); |
| |
| // Neutral-only button |
| verifyDialogButtons(null, null, "Neutral", AlertDialog.BUTTON_NEUTRAL); |
| verifyDialogButtons(0, 0, R.string.alert_dialog_neutral_button, AlertDialog.BUTTON_NEUTRAL); |
| verifyDialogButtonsPostCreation(null, null, "Post neutral", AlertDialog.BUTTON_NEUTRAL); |
| verifyDialogButtonsPostCreationMessage(null, null, "Message neutral", |
| AlertDialog.BUTTON_NEUTRAL); |
| |
| // Show positive and negative, click positive |
| verifyDialogButtons(R.string.alert_dialog_positive_button, |
| R.string.alert_dialog_negative_button, 0, AlertDialog.BUTTON_POSITIVE); |
| |
| // Show positive and neutral, click neutral |
| verifyDialogButtons("Positive", null, "Neutral", AlertDialog.BUTTON_NEUTRAL); |
| |
| // Show negative and neutral, click negative |
| verifyDialogButtonsPostCreationMessage(null, "Message negative", |
| "Message neutral", AlertDialog.BUTTON_NEGATIVE); |
| |
| // Show all, click positive |
| verifyDialogButtonsPostCreation("Post positive", "Post negative", "Post neutral", |
| AlertDialog.BUTTON_POSITIVE); |
| } |
| |
| private static class TestDrawable extends ColorDrawable { |
| private int mWidth; |
| private int mHeight; |
| |
| public TestDrawable(@ColorInt int color, int width, int height) { |
| super(color); |
| mWidth = width; |
| mHeight = height; |
| } |
| |
| @Override |
| public int getIntrinsicWidth() { |
| return mWidth; |
| } |
| |
| @Override |
| public int getIntrinsicHeight() { |
| return mHeight; |
| } |
| } |
| } |
