| /* |
| * Copyright (C) 2008 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.mock; |
| import static org.mockito.Mockito.reset; |
| import static org.mockito.Mockito.times; |
| import static org.mockito.Mockito.verify; |
| import static org.mockito.Mockito.verifyZeroInteractions; |
| |
| import android.app.Activity; |
| import android.app.Instrumentation; |
| import android.content.Context; |
| import android.content.res.Configuration; |
| import android.os.Parcelable; |
| 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.util.AttributeSet; |
| import android.view.KeyEvent; |
| import android.view.View; |
| import android.view.autofill.AutofillValue; |
| import android.widget.TimePicker; |
| |
| import com.android.compatibility.common.util.CtsKeyEventUtil; |
| import com.android.compatibility.common.util.CtsTouchUtils; |
| |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| |
| import java.util.ArrayList; |
| import java.util.Calendar; |
| import java.util.Collections; |
| import java.util.GregorianCalendar; |
| import java.util.concurrent.atomic.AtomicInteger; |
| |
| /** |
| * Test {@link TimePicker}. |
| */ |
| @MediumTest |
| @RunWith(AndroidJUnit4.class) |
| public class TimePickerTest { |
| private Instrumentation mInstrumentation; |
| private Activity mActivity; |
| private TimePicker mTimePicker; |
| |
| @Rule |
| public ActivityTestRule<TimePickerCtsActivity> mActivityRule = |
| new ActivityTestRule<>(TimePickerCtsActivity.class); |
| |
| @Before |
| public void setup() { |
| mInstrumentation = InstrumentationRegistry.getInstrumentation(); |
| mActivity = mActivityRule.getActivity(); |
| mTimePicker = (TimePicker) mActivity.findViewById(R.id.timepicker_clock); |
| } |
| |
| @Test |
| public void testConstructors() { |
| AttributeSet attrs = mActivity.getResources().getLayout(R.layout.timepicker); |
| assertNotNull(attrs); |
| |
| new TimePicker(mActivity); |
| |
| new TimePicker(mActivity, attrs); |
| new TimePicker(mActivity, null); |
| |
| new TimePicker(mActivity, attrs, 0); |
| new TimePicker(mActivity, null, 0); |
| new TimePicker(mActivity, attrs, 0); |
| new TimePicker(mActivity, null, android.R.attr.timePickerStyle); |
| new TimePicker(mActivity, null, 0, android.R.style.Widget_Material_TimePicker); |
| new TimePicker(mActivity, null, 0, android.R.style.Widget_Material_Light_TimePicker); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testConstructorNullContext1() { |
| new TimePicker(null); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testConstructorNullContext2() { |
| AttributeSet attrs = mActivity.getResources().getLayout(R.layout.timepicker); |
| new TimePicker(null, attrs); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testConstructorNullContext3() { |
| AttributeSet attrs = mActivity.getResources().getLayout(R.layout.timepicker); |
| new TimePicker(null, attrs, 0); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetEnabled() { |
| assertTrue(mTimePicker.isEnabled()); |
| |
| mTimePicker.setEnabled(false); |
| assertFalse(mTimePicker.isEnabled()); |
| assertNull(mTimePicker.getAutofillValue()); |
| assertEquals(View.AUTOFILL_TYPE_NONE, mTimePicker.getAutofillType()); |
| |
| mTimePicker.setEnabled(true); |
| assertTrue(mTimePicker.isEnabled()); |
| assertNotNull(mTimePicker.getAutofillValue()); |
| assertEquals(View.AUTOFILL_TYPE_DATE, mTimePicker.getAutofillType()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAutofill() { |
| mTimePicker.setEnabled(true); |
| |
| final AtomicInteger numberOfListenerCalls = new AtomicInteger(); |
| mTimePicker.setOnTimeChangedListener((v, h, m) -> numberOfListenerCalls.incrementAndGet()); |
| |
| final Calendar calendar = new GregorianCalendar(); |
| calendar.set(Calendar.HOUR_OF_DAY, 4); |
| calendar.set(Calendar.MINUTE, 20); |
| |
| final AutofillValue autofilledValue = AutofillValue.forDate(calendar.getTimeInMillis()); |
| mTimePicker.autofill(autofilledValue); |
| assertEquals(autofilledValue, mTimePicker.getAutofillValue()); |
| assertEquals(4, mTimePicker.getHour()); |
| assertEquals(20, mTimePicker.getMinute()); |
| assertEquals(1, numberOfListenerCalls.get()); |
| |
| // Make sure autofill() is ignored when value is null. |
| numberOfListenerCalls.set(0); |
| mTimePicker.autofill((AutofillValue) null); |
| assertEquals(autofilledValue, mTimePicker.getAutofillValue()); |
| assertEquals(4, mTimePicker.getHour()); |
| assertEquals(20, mTimePicker.getMinute()); |
| assertEquals(0, numberOfListenerCalls.get()); |
| |
| // Make sure autofill() is ignored when value is not a date. |
| numberOfListenerCalls.set(0); |
| mTimePicker.autofill(AutofillValue.forText("Y U NO IGNORE ME?")); |
| assertEquals(autofilledValue, mTimePicker.getAutofillValue()); |
| assertEquals(4, mTimePicker.getHour()); |
| assertEquals(20, mTimePicker.getMinute()); |
| assertEquals(0, numberOfListenerCalls.get()); |
| |
| // Make sure getAutofillValue() is reset when value is manually filled. |
| mTimePicker.autofill(autofilledValue); // 04:20 |
| mTimePicker.setHour(10); |
| calendar.setTimeInMillis(mTimePicker.getAutofillValue().getDateValue()); |
| assertEquals(10, calendar.get(Calendar.HOUR)); |
| mTimePicker.autofill(autofilledValue); // 04:20 |
| mTimePicker.setMinute(8); |
| calendar.setTimeInMillis(mTimePicker.getAutofillValue().getDateValue()); |
| assertEquals(8, calendar.get(Calendar.MINUTE)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetOnTimeChangedListener() { |
| // On time change listener is notified on every call to setCurrentHour / setCurrentMinute. |
| // We want to make sure that before we register our listener, we initialize the time picker |
| // to the time that is explicitly different from the values we'll be testing for in both |
| // hour and minute. Otherwise if the test happens to run at the time that ends in |
| // "minuteForTesting" minutes, we'll get two onTimeChanged callbacks with identical values. |
| final int initialHour = 10; |
| final int initialMinute = 38; |
| final int hourForTesting = 13; |
| final int minuteForTesting = 50; |
| |
| mTimePicker.setHour(initialHour); |
| mTimePicker.setMinute(initialMinute); |
| |
| // Now register the listener |
| TimePicker.OnTimeChangedListener mockOnTimeChangeListener = |
| mock(TimePicker.OnTimeChangedListener.class); |
| mTimePicker.setOnTimeChangedListener(mockOnTimeChangeListener); |
| mTimePicker.setCurrentHour(Integer.valueOf(hourForTesting)); |
| mTimePicker.setCurrentMinute(Integer.valueOf(minuteForTesting)); |
| // We're expecting two onTimeChanged callbacks, one with new hour and one with new |
| // hour+minute |
| verify(mockOnTimeChangeListener, times(1)).onTimeChanged( |
| mTimePicker, hourForTesting, initialMinute); |
| verify(mockOnTimeChangeListener, times(1)).onTimeChanged( |
| mTimePicker, hourForTesting, minuteForTesting); |
| |
| // set the same hour as current |
| reset(mockOnTimeChangeListener); |
| mTimePicker.setCurrentHour(Integer.valueOf(hourForTesting)); |
| verifyZeroInteractions(mockOnTimeChangeListener); |
| |
| mTimePicker.setCurrentHour(Integer.valueOf(hourForTesting + 1)); |
| verify(mockOnTimeChangeListener, times(1)).onTimeChanged( |
| mTimePicker, hourForTesting + 1, minuteForTesting); |
| |
| // set the same minute as current |
| reset(mockOnTimeChangeListener); |
| mTimePicker.setCurrentMinute(minuteForTesting); |
| verifyZeroInteractions(mockOnTimeChangeListener); |
| |
| reset(mockOnTimeChangeListener); |
| mTimePicker.setCurrentMinute(minuteForTesting + 1); |
| verify(mockOnTimeChangeListener, times(1)).onTimeChanged( |
| mTimePicker, hourForTesting + 1, minuteForTesting + 1); |
| |
| // change time picker mode |
| reset(mockOnTimeChangeListener); |
| mTimePicker.setIs24HourView(!mTimePicker.is24HourView()); |
| verifyZeroInteractions(mockOnTimeChangeListener); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAccessCurrentHour() { |
| // AM/PM mode |
| mTimePicker.setIs24HourView(false); |
| |
| mTimePicker.setCurrentHour(0); |
| assertEquals(Integer.valueOf(0), mTimePicker.getCurrentHour()); |
| |
| mTimePicker.setCurrentHour(12); |
| assertEquals(Integer.valueOf(12), mTimePicker.getCurrentHour()); |
| |
| mTimePicker.setCurrentHour(13); |
| assertEquals(Integer.valueOf(13), mTimePicker.getCurrentHour()); |
| |
| mTimePicker.setCurrentHour(23); |
| assertEquals(Integer.valueOf(23), mTimePicker.getCurrentHour()); |
| |
| // for 24 hour mode |
| mTimePicker.setIs24HourView(true); |
| |
| mTimePicker.setCurrentHour(0); |
| assertEquals(Integer.valueOf(0), mTimePicker.getCurrentHour()); |
| |
| mTimePicker.setCurrentHour(13); |
| assertEquals(Integer.valueOf(13), mTimePicker.getCurrentHour()); |
| |
| mTimePicker.setCurrentHour(23); |
| assertEquals(Integer.valueOf(23), mTimePicker.getCurrentHour()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAccessHour() { |
| // AM/PM mode |
| mTimePicker.setIs24HourView(false); |
| |
| mTimePicker.setHour(0); |
| assertEquals(0, mTimePicker.getHour()); |
| |
| mTimePicker.setHour(12); |
| assertEquals(12, mTimePicker.getHour()); |
| |
| mTimePicker.setHour(13); |
| assertEquals(13, mTimePicker.getHour()); |
| |
| mTimePicker.setHour(23); |
| assertEquals(23, mTimePicker.getHour()); |
| |
| // for 24 hour mode |
| mTimePicker.setIs24HourView(true); |
| |
| mTimePicker.setHour(0); |
| assertEquals(0, mTimePicker.getHour()); |
| |
| mTimePicker.setHour(13); |
| assertEquals(13, mTimePicker.getHour()); |
| |
| mTimePicker.setHour(23); |
| assertEquals(23, mTimePicker.getHour()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAccessIs24HourView() { |
| assertFalse(mTimePicker.is24HourView()); |
| |
| mTimePicker.setIs24HourView(true); |
| assertTrue(mTimePicker.is24HourView()); |
| |
| mTimePicker.setIs24HourView(false); |
| assertFalse(mTimePicker.is24HourView()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAccessCurrentMinute() { |
| mTimePicker.setCurrentMinute(0); |
| assertEquals(Integer.valueOf(0), mTimePicker.getCurrentMinute()); |
| |
| mTimePicker.setCurrentMinute(12); |
| assertEquals(Integer.valueOf(12), mTimePicker.getCurrentMinute()); |
| |
| mTimePicker.setCurrentMinute(33); |
| assertEquals(Integer.valueOf(33), mTimePicker.getCurrentMinute()); |
| |
| mTimePicker.setCurrentMinute(59); |
| assertEquals(Integer.valueOf(59), mTimePicker.getCurrentMinute()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAccessMinute() { |
| mTimePicker.setMinute(0); |
| assertEquals(0, mTimePicker.getMinute()); |
| |
| mTimePicker.setMinute(12); |
| assertEquals(12, mTimePicker.getMinute()); |
| |
| mTimePicker.setMinute(33); |
| assertEquals(33, mTimePicker.getMinute()); |
| |
| mTimePicker.setMinute(59); |
| assertEquals(59, mTimePicker.getMinute()); |
| } |
| |
| @Test |
| public void testGetBaseline() { |
| assertEquals(-1, mTimePicker.getBaseline()); |
| } |
| |
| @Test |
| public void testOnSaveInstanceStateAndOnRestoreInstanceState() { |
| MyTimePicker source = new MyTimePicker(mActivity); |
| MyTimePicker dest = new MyTimePicker(mActivity); |
| int expectHour = (dest.getCurrentHour() + 10) % 24; |
| int expectMinute = (dest.getCurrentMinute() + 10) % 60; |
| source.setCurrentHour(expectHour); |
| source.setCurrentMinute(expectMinute); |
| |
| Parcelable p = source.onSaveInstanceState(); |
| dest.onRestoreInstanceState(p); |
| |
| assertEquals(Integer.valueOf(expectHour), dest.getCurrentHour()); |
| assertEquals(Integer.valueOf(expectMinute), dest.getCurrentMinute()); |
| } |
| |
| private boolean isWatch() { |
| return (mActivity.getResources().getConfiguration().uiMode |
| & Configuration.UI_MODE_TYPE_MASK) == Configuration.UI_MODE_TYPE_WATCH; |
| } |
| |
| @Test |
| public void testKeyboardTabTraversalModeClock() throws Throwable { |
| if (isWatch()) { |
| return; |
| } |
| mTimePicker = (TimePicker) mActivity.findViewById(R.id.timepicker_clock); |
| |
| mActivityRule.runOnUiThread(() -> mTimePicker.setIs24HourView(false)); |
| mInstrumentation.waitForIdleSync(); |
| verifyTimePickerKeyboardTraversal( |
| true /* goForward */, |
| false /* is24HourView */); |
| verifyTimePickerKeyboardTraversal( |
| false /* goForward */, |
| false /* is24HourView */); |
| |
| mActivityRule.runOnUiThread(() -> mTimePicker.setIs24HourView(true)); |
| mInstrumentation.waitForIdleSync(); |
| verifyTimePickerKeyboardTraversal( |
| true /* goForward */, |
| true /* is24HourView */); |
| verifyTimePickerKeyboardTraversal( |
| false /* goForward */, |
| true /* is24HourView */); |
| } |
| |
| @Test |
| public void testKeyboardTabTraversalModeSpinner() throws Throwable { |
| if (isWatch()) { |
| return; |
| } |
| mTimePicker = (TimePicker) mActivity.findViewById(R.id.timepicker_spinner); |
| |
| mActivityRule.runOnUiThread(() -> mTimePicker.setIs24HourView(false)); |
| mInstrumentation.waitForIdleSync(); |
| |
| // Spinner time-picker doesn't explicitly define a focus order. Just make sure inputs |
| // are able to be traversed (added to focusables). |
| ArrayList<View> focusables = new ArrayList<>(); |
| mTimePicker.addFocusables(focusables, View.FOCUS_FORWARD); |
| assertTrue(focusables.contains(mTimePicker.getHourView())); |
| assertTrue(focusables.contains(mTimePicker.getMinuteView())); |
| assertTrue(focusables.contains(mTimePicker.getAmView())); |
| focusables.clear(); |
| |
| mActivityRule.runOnUiThread(() -> mTimePicker.setIs24HourView(true)); |
| mInstrumentation.waitForIdleSync(); |
| mTimePicker.addFocusables(focusables, View.FOCUS_FORWARD); |
| assertTrue(focusables.contains(mTimePicker.getHourView())); |
| assertTrue(focusables.contains(mTimePicker.getMinuteView())); |
| } |
| |
| @Test |
| public void testKeyboardInputModeClockAmPm() throws Throwable { |
| if (isWatch()) { |
| return; |
| } |
| final int initialHour = 6; |
| final int initialMinute = 59; |
| prepareForKeyboardInput(initialHour, initialMinute, false /* is24hFormat */, |
| true /* isClockMode */); |
| |
| // Input valid hour. |
| assertEquals(initialHour, mTimePicker.getHour()); |
| CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mTimePicker.getHourView()); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_1); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_0); |
| assertEquals(10, mTimePicker.getHour()); |
| assertTrue(mTimePicker.getMinuteView().hasFocus()); |
| |
| // Input valid minute. |
| assertEquals(initialMinute, mTimePicker.getMinute()); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_4); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_3); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| assertEquals(43, mTimePicker.getMinute()); |
| assertTrue(mTimePicker.getAmView().hasFocus()); |
| |
| // Accepting AM changes nothing. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_ENTER); |
| assertEquals(10, mTimePicker.getHour()); |
| assertEquals(43, mTimePicker.getMinute()); |
| |
| // Focus PM radio. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| assertTrue(mTimePicker.getPmView().hasFocus()); |
| // Still nothing has changed. |
| assertEquals(10, mTimePicker.getHour()); |
| assertEquals(43, mTimePicker.getMinute()); |
| // Select PM and verify the hour has changed. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_ENTER); |
| assertEquals(22, mTimePicker.getHour()); |
| assertEquals(43, mTimePicker.getMinute()); |
| // Set AM again. |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, mTimePicker, |
| KeyEvent.KEYCODE_TAB, KeyEvent.KEYCODE_SHIFT_LEFT); |
| assertTrue(mTimePicker.getAmView().hasFocus()); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_ENTER); |
| assertEquals(10, mTimePicker.getHour()); |
| |
| // Re-focus the hour view. |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, mTimePicker, |
| KeyEvent.KEYCODE_TAB, KeyEvent.KEYCODE_SHIFT_LEFT); |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, mTimePicker, |
| KeyEvent.KEYCODE_TAB, KeyEvent.KEYCODE_SHIFT_LEFT); |
| assertTrue(mTimePicker.getHourView().hasFocus()); |
| |
| // Input an invalid value (larger than 12). |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_1); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_3); |
| // Force setting the hour by moving to minute. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| // After sending 1 and 3 only 1 is accepted. |
| assertEquals(1, mTimePicker.getHour()); |
| assertEquals(43, mTimePicker.getMinute()); |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, mTimePicker, |
| KeyEvent.KEYCODE_TAB, KeyEvent.KEYCODE_SHIFT_LEFT); |
| // The hour view still has focus. |
| assertTrue(mTimePicker.getHourView().hasFocus()); |
| |
| // This time send a valid hour (11). |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_1); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_1); |
| // The value is valid. |
| assertEquals(11, mTimePicker.getHour()); |
| assertEquals(43, mTimePicker.getMinute()); |
| |
| verifyModeClockMinuteInput(); |
| } |
| |
| @Test |
| public void testKeyboardInputModeClock24H() throws Throwable { |
| if (isWatch()) { |
| return; |
| } |
| final int initialHour = 6; |
| final int initialMinute = 59; |
| prepareForKeyboardInput(initialHour, initialMinute, true /* is24hFormat */, |
| true /* isClockMode */); |
| |
| // Input valid hour. |
| assertEquals(initialHour, mTimePicker.getHour()); |
| CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mTimePicker.getHourView()); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_1); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_0); |
| assertEquals(10, mTimePicker.getHour()); |
| assertTrue(mTimePicker.getMinuteView().hasFocus()); |
| |
| // Input valid minute. |
| assertEquals(initialMinute, mTimePicker.getMinute()); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_4); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_3); |
| assertEquals(43, mTimePicker.getMinute()); |
| |
| // Re-focus the hour view. |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, mTimePicker, |
| KeyEvent.KEYCODE_TAB, KeyEvent.KEYCODE_SHIFT_LEFT); |
| assertTrue(mTimePicker.getHourView().hasFocus()); |
| |
| // Input an invalid value (larger than 24). |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_2); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_5); |
| // Force setting the hour by moving to minute. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| // After sending 2 and 5 only 2 is accepted. |
| assertEquals(2, mTimePicker.getHour()); |
| assertEquals(43, mTimePicker.getMinute()); |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, mTimePicker, |
| KeyEvent.KEYCODE_TAB, KeyEvent.KEYCODE_SHIFT_LEFT); |
| // The hour view still has focus. |
| assertTrue(mTimePicker.getHourView().hasFocus()); |
| |
| // This time send a valid hour. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_2); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_3); |
| // The value is valid. |
| assertEquals(23, mTimePicker.getHour()); |
| assertEquals(43, mTimePicker.getMinute()); |
| |
| verifyModeClockMinuteInput(); |
| } |
| |
| @Test |
| public void testKeyboardInputModeSpinnerAmPm() throws Throwable { |
| if (isWatch()) { |
| return; |
| } |
| final int initialHour = 6; |
| final int initialMinute = 59; |
| prepareForKeyboardInput(initialHour, initialMinute, false /* is24hFormat */, |
| false /* isClockMode */); |
| |
| // when testing on device with lower resolution, the Spinner mode time picker may not show |
| // completely, which will cause case fail, so in this case remove the clock time picker to |
| // focus on the test of Spinner mode |
| final TimePicker clock = mActivity.findViewById(R.id.timepicker_clock); |
| mActivityRule.runOnUiThread(() -> clock.setVisibility(View.GONE)); |
| |
| assertEquals(initialHour, mTimePicker.getHour()); |
| mActivityRule.runOnUiThread(() -> mTimePicker.getHourView().requestFocus()); |
| mInstrumentation.waitForIdleSync(); |
| |
| // Input invalid hour. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_1); |
| // None of the keys below should be accepted after 1 was pressed. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_3); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_4); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_5); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| // Since only 0, 1 or 2 are accepted for AM/PM hour mode after pressing 1, we expect the |
| // hour value to be 1. |
| assertEquals(1, mTimePicker.getHour()); |
| assertFalse(mTimePicker.getHourView().hasFocus()); |
| |
| // Go back to hour view and input valid hour. |
| mActivityRule.runOnUiThread(() -> mTimePicker.getHourView().requestFocus()); |
| mInstrumentation.waitForIdleSync(); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_1); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_1); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| assertEquals(11, mTimePicker.getHour()); |
| assertFalse(mTimePicker.getHourView().hasFocus()); |
| |
| // Go back to hour view and exercise UP and DOWN keys. |
| mActivityRule.runOnUiThread(() -> mTimePicker.getHourView().requestFocus()); |
| mInstrumentation.waitForIdleSync(); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_DOWN); |
| assertEquals(12, mTimePicker.getHour()); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_UP); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_UP); |
| assertEquals(10, mTimePicker.getHour()); |
| |
| // Minute input testing. |
| assertEquals(initialMinute, mTimePicker.getMinute()); |
| verifyModeSpinnerMinuteInput(); |
| |
| // Reset to values preparing to test the AM/PM picker. |
| mActivityRule.runOnUiThread(() -> { |
| mTimePicker.setHour(6); |
| mTimePicker.setMinute(initialMinute); |
| }); |
| mInstrumentation.waitForIdleSync(); |
| // In spinner mode the AM view and PM view are the same. |
| assertEquals(mTimePicker.getAmView(), mTimePicker.getPmView()); |
| mActivityRule.runOnUiThread(() -> mTimePicker.getAmView().requestFocus()); |
| mInstrumentation.waitForIdleSync(); |
| assertTrue(mTimePicker.getAmView().hasFocus()); |
| assertEquals(6, mTimePicker.getHour()); |
| // Pressing A changes nothing. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_A); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| assertEquals(6, mTimePicker.getHour()); |
| assertEquals(initialMinute, mTimePicker.getMinute()); |
| // Pressing P switches to PM. |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, mTimePicker, |
| KeyEvent.KEYCODE_TAB, KeyEvent.KEYCODE_SHIFT_LEFT); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_P); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| assertEquals(18, mTimePicker.getHour()); |
| assertEquals(initialMinute, mTimePicker.getMinute()); |
| // Pressing P again changes nothing. |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, mTimePicker, |
| KeyEvent.KEYCODE_TAB, KeyEvent.KEYCODE_SHIFT_LEFT); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_P); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| assertEquals(18, mTimePicker.getHour()); |
| assertEquals(initialMinute, mTimePicker.getMinute()); |
| // Pressing A switches to AM. |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, mTimePicker, |
| KeyEvent.KEYCODE_TAB, KeyEvent.KEYCODE_SHIFT_LEFT); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_A); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| assertEquals(6, mTimePicker.getHour()); |
| assertEquals(initialMinute, mTimePicker.getMinute()); |
| // Given that we are already set to AM, pressing UP changes nothing. |
| mActivityRule.runOnUiThread(() -> mTimePicker.getAmView().requestFocus()); |
| mInstrumentation.waitForIdleSync(); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_UP); |
| assertEquals(6, mTimePicker.getHour()); |
| assertEquals(initialMinute, mTimePicker.getMinute()); |
| mActivityRule.runOnUiThread(() -> mTimePicker.getAmView().requestFocus()); |
| mInstrumentation.waitForIdleSync(); |
| // Pressing down switches to PM. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_DOWN); |
| assertEquals(18, mTimePicker.getHour()); |
| assertEquals(initialMinute, mTimePicker.getMinute()); |
| mActivityRule.runOnUiThread(() -> mTimePicker.getAmView().requestFocus()); |
| mInstrumentation.waitForIdleSync(); |
| // Given that we are set to PM, pressing DOWN again changes nothing. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_DOWN); |
| assertEquals(18, mTimePicker.getHour()); |
| assertEquals(initialMinute, mTimePicker.getMinute()); |
| mActivityRule.runOnUiThread(() -> mTimePicker.getAmView().requestFocus()); |
| mInstrumentation.waitForIdleSync(); |
| // Pressing UP switches to AM. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_UP); |
| assertEquals(6, mTimePicker.getHour()); |
| assertEquals(initialMinute, mTimePicker.getMinute()); |
| } |
| |
| @Test |
| public void testKeyboardInputModeSpinner24H() throws Throwable { |
| if (isWatch()) { |
| return; |
| } |
| final int initialHour = 6; |
| final int initialMinute = 59; |
| prepareForKeyboardInput(initialHour, initialMinute, true /* is24hFormat */, |
| false /* isClockMode */); |
| |
| // when testing on device with lower resolution, the Spinner mode time picker may not show |
| // completely, which will cause case fail, so in this case remove the clock time picker to |
| // focus on the test of Spinner mode |
| final TimePicker clock = mActivity.findViewById(R.id.timepicker_clock); |
| mActivityRule.runOnUiThread(() -> clock.setVisibility(View.GONE)); |
| |
| assertEquals(initialHour, mTimePicker.getHour()); |
| mActivityRule.runOnUiThread(() -> mTimePicker.getHourView().requestFocus()); |
| mInstrumentation.waitForIdleSync(); |
| |
| // Input invalid hour. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_2); |
| // None of the keys below should be accepted after 2 was pressed. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_4); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_5); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_6); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| // Only 2 is accepted (as the only 0, 1, 2, and 3 can form valid hours after pressing 2). |
| assertEquals(2, mTimePicker.getHour()); |
| assertFalse(mTimePicker.getHourView().hasFocus()); |
| |
| // Go back to hour view and input valid hour. |
| mActivityRule.runOnUiThread(() -> mTimePicker.getHourView().requestFocus()); |
| mInstrumentation.waitForIdleSync(); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_2); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_3); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| assertEquals(23, mTimePicker.getHour()); |
| assertFalse(mTimePicker.getHourView().hasFocus()); |
| |
| // Go back to hour view and exercise UP and DOWN keys. |
| mActivityRule.runOnUiThread(() -> mTimePicker.getHourView().requestFocus()); |
| mInstrumentation.waitForIdleSync(); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_DOWN); |
| assertEquals(0 /* 24 */, mTimePicker.getHour()); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_UP); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_UP); |
| assertEquals(22, mTimePicker.getHour()); |
| |
| // Minute input testing. |
| assertEquals(initialMinute, mTimePicker.getMinute()); |
| verifyModeSpinnerMinuteInput(); |
| } |
| |
| private void verifyModeClockMinuteInput() { |
| assertTrue(mTimePicker.getMinuteView().hasFocus()); |
| // Send a invalid minute. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_6); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_7); |
| // Sent 6 and 7 but only 6 was valid. |
| assertEquals(6, mTimePicker.getMinute()); |
| // No matter what other invalid values we send, the minute is unchanged and the focus is |
| // kept. |
| // 61 invalid. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_1); |
| assertTrue(mTimePicker.getMinuteView().hasFocus()); |
| // 62 invalid. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_2); |
| assertTrue(mTimePicker.getMinuteView().hasFocus()); |
| // 63 invalid. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_3); |
| assertTrue(mTimePicker.getMinuteView().hasFocus()); |
| assertEquals(6, mTimePicker.getMinute()); |
| // Refocus. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, mTimePicker, |
| KeyEvent.KEYCODE_TAB, KeyEvent.KEYCODE_SHIFT_LEFT); |
| assertTrue(mTimePicker.getMinuteView().hasFocus()); |
| |
| // In the end pass a valid minute. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_5); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_9); |
| assertEquals(59, mTimePicker.getMinute()); |
| } |
| |
| private void verifyModeSpinnerMinuteInput() throws Throwable { |
| mActivityRule.runOnUiThread(() -> mTimePicker.getMinuteView().requestFocus()); |
| mInstrumentation.waitForIdleSync(); |
| assertTrue(mTimePicker.getMinuteView().hasFocus()); |
| |
| // Input invalid minute. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_6); |
| // None of the keys below should be accepted after 6 was pressed. |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_3); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_4); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_5); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| // Only 6 is accepted (as the only valid minute value that starts with 6 is 6 itself). |
| assertEquals(6, mTimePicker.getMinute()); |
| |
| // Go back to minute view and input valid minute. |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, mTimePicker, |
| KeyEvent.KEYCODE_TAB, KeyEvent.KEYCODE_SHIFT_LEFT); |
| assertTrue(mTimePicker.getMinuteView().hasFocus()); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_4); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_8); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_TAB); |
| assertEquals(48, mTimePicker.getMinute()); |
| |
| // Go back to minute view and exercise UP and DOWN keys. |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, mTimePicker, |
| KeyEvent.KEYCODE_TAB, KeyEvent.KEYCODE_SHIFT_LEFT); |
| assertTrue(mTimePicker.getMinuteView().hasFocus()); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_DOWN); |
| assertEquals(49, mTimePicker.getMinute()); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_UP); |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, mTimePicker, KeyEvent.KEYCODE_DPAD_UP); |
| assertEquals(47, mTimePicker.getMinute()); |
| } |
| |
| private void prepareForKeyboardInput(int initialHour, int initialMinute, boolean is24hFormat, |
| boolean isClockMode) throws Throwable { |
| mTimePicker = isClockMode |
| ? (TimePicker) mActivity.findViewById(R.id.timepicker_clock) |
| : (TimePicker) mActivity.findViewById(R.id.timepicker_spinner); |
| |
| mActivityRule.runOnUiThread(() -> { |
| /* hide one of the widgets to assure they fit onto the screen */ |
| if (isClockMode) { |
| mActivity.findViewById(R.id.timepicker_spinner).setVisibility(View.GONE); |
| } else { |
| mActivity.findViewById(R.id.timepicker_clock).setVisibility(View.GONE); |
| } |
| mTimePicker.setIs24HourView(is24hFormat); |
| mTimePicker.setHour(initialHour); |
| mTimePicker.setMinute(initialMinute); |
| mTimePicker.requestFocus(); |
| }); |
| mInstrumentation.waitForIdleSync(); |
| } |
| |
| private void verifyTimePickerKeyboardTraversal(boolean goForward, boolean is24HourView) |
| throws Throwable { |
| ArrayList<View> forwardViews = new ArrayList<>(); |
| String summary = (goForward ? " forward " : " backward ") |
| + "traversal, is24HourView=" + is24HourView; |
| assertNotNull("Unexpected NULL hour view for" + summary, mTimePicker.getHourView()); |
| forwardViews.add(mTimePicker.getHourView()); |
| assertNotNull("Unexpected NULL minute view for" + summary, mTimePicker.getMinuteView()); |
| forwardViews.add(mTimePicker.getMinuteView()); |
| if (!is24HourView) { |
| assertNotNull("Unexpected NULL AM view for" + summary, mTimePicker.getAmView()); |
| forwardViews.add(mTimePicker.getAmView()); |
| assertNotNull("Unexpected NULL PM view for" + summary, mTimePicker.getPmView()); |
| forwardViews.add(mTimePicker.getPmView()); |
| } |
| |
| if (!goForward) { |
| Collections.reverse(forwardViews); |
| } |
| |
| final int viewsSize = forwardViews.size(); |
| for (int i = 0; i < viewsSize; i++) { |
| final View currentView = forwardViews.get(i); |
| String afterKeyCodeFormattedString = ""; |
| int goForwardKeyCode = KeyEvent.KEYCODE_TAB; |
| int modifierKeyCodeToHold = KeyEvent.KEYCODE_SHIFT_LEFT; |
| |
| if (i == 0) { |
| // Make sure we always start by focusing the 1st element in the list. |
| mActivityRule.runOnUiThread(currentView::requestFocus); |
| } else { |
| if (goForward) { |
| afterKeyCodeFormattedString = " after pressing=" |
| + KeyEvent.keyCodeToString(goForwardKeyCode); |
| } else { |
| afterKeyCodeFormattedString = " after pressing=" |
| + KeyEvent.keyCodeToString(modifierKeyCodeToHold) |
| + "+" + KeyEvent.keyCodeToString(goForwardKeyCode) + " for" + summary; |
| } |
| } |
| |
| assertTrue("View='" + currentView + "'" + " with index " + i + " is not enabled" |
| + afterKeyCodeFormattedString + " for" + summary, currentView.isEnabled()); |
| assertTrue("View='" + currentView + "'" + " with index " + i + " is not focused" |
| + afterKeyCodeFormattedString + " for" + summary, currentView.isFocused()); |
| |
| if (i < viewsSize - 1) { |
| if (goForward) { |
| CtsKeyEventUtil.sendKeyDownUp(mInstrumentation, currentView, goForwardKeyCode); |
| } else { |
| CtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation, currentView, |
| goForwardKeyCode, modifierKeyCodeToHold); |
| } |
| } |
| } |
| } |
| |
| private class MyTimePicker extends TimePicker { |
| public MyTimePicker(Context context) { |
| super(context); |
| } |
| |
| @Override |
| protected void onRestoreInstanceState(Parcelable state) { |
| super.onRestoreInstanceState(state); |
| } |
| |
| @Override |
| protected Parcelable onSaveInstanceState() { |
| return super.onSaveInstanceState(); |
| } |
| } |
| } |
