| /* | |
| * Copyright 2011 Google Inc. | |
| * | |
| * 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 com.google.gwt.touch.client; | |
| import com.google.gwt.core.client.Duration; | |
| import com.google.gwt.core.client.Scheduler.RepeatingCommand; | |
| import com.google.gwt.dom.client.NativeEvent; | |
| import com.google.gwt.dom.client.Touch; | |
| import com.google.gwt.event.dom.client.TouchEvent; | |
| import com.google.gwt.event.dom.client.TouchStartEvent; | |
| import com.google.gwt.junit.client.GWTTestCase; | |
| import com.google.gwt.touch.client.TouchScroller.TemporalPoint; | |
| import com.google.gwt.user.client.ui.HasScrolling; | |
| import com.google.gwt.user.client.ui.Label; | |
| import com.google.gwt.user.client.ui.RootPanel; | |
| import com.google.gwt.user.client.ui.ScrollPanel; | |
| /** | |
| * Tests for {@link TouchScroller}. | |
| * | |
| * <p> | |
| * Many of the tests in this class can run even in HtmlUnit and browsers that do | |
| * not support touch events because we create mock touch events. | |
| * </p> | |
| */ | |
| public class TouchScrollTest extends GWTTestCase { | |
| /** | |
| * A custom {@link ScrollPanel} that doesn't rely on the DOM to calculate its | |
| * vertical and horizontal position. Allows testing in HtmlUnit. | |
| */ | |
| private static class CustomScrollPanel extends ScrollPanel { | |
| private final int maxHorizontalScrollPosition; | |
| private final int maxVerticalScrollPosition; | |
| private final int minHorizontalScrollPosition; | |
| private final int minVerticalScrollPosition; | |
| private int horizontalScrollPosition; | |
| private int verticalScrollPosition; | |
| /** | |
| * Construct a new {@link CustomScrollPanel} using 0 as the minimum vertical | |
| * and horizontal scroll position and INTEGER.MAX_VALUE as the maximum | |
| * positions. | |
| */ | |
| public CustomScrollPanel() { | |
| this.minVerticalScrollPosition = 0; | |
| this.maxVerticalScrollPosition = 5000; | |
| this.minHorizontalScrollPosition = 0; | |
| this.maxHorizontalScrollPosition = 5000; | |
| } | |
| @Override | |
| public int getHorizontalScrollPosition() { | |
| return horizontalScrollPosition; | |
| } | |
| @Override | |
| public int getMaximumHorizontalScrollPosition() { | |
| return maxHorizontalScrollPosition; | |
| } | |
| @Override | |
| public int getMaximumVerticalScrollPosition() { | |
| return maxVerticalScrollPosition; | |
| } | |
| @Override | |
| public int getMinimumHorizontalScrollPosition() { | |
| return minHorizontalScrollPosition; | |
| } | |
| @Override | |
| public int getMinimumVerticalScrollPosition() { | |
| return minVerticalScrollPosition; | |
| } | |
| @Override | |
| public int getVerticalScrollPosition() { | |
| return verticalScrollPosition; | |
| } | |
| @Override | |
| public void setHorizontalScrollPosition(int position) { | |
| this.horizontalScrollPosition = position; | |
| super.setHorizontalScrollPosition(position); | |
| } | |
| @Override | |
| public void setVerticalScrollPosition(int position) { | |
| this.verticalScrollPosition = position; | |
| super.setVerticalScrollPosition(position); | |
| } | |
| } | |
| /** | |
| * A custom touch event. | |
| */ | |
| private static class CustomTouchEvent extends TouchStartEvent { | |
| } | |
| /** | |
| * A {@link TouchScroller} that overrides drag events. | |
| */ | |
| private static class CustomTouchScroller extends TouchScroller { | |
| private boolean setupBustClickHandlerCalled; | |
| private boolean removeBustClickHandlerCalled; | |
| private boolean removeAttachHandlerCalled; | |
| private boolean onDragEndCalled; | |
| private boolean onDragMoveCalled; | |
| private boolean onDragStartCalled; | |
| public CustomTouchScroller(HasScrolling widget) { | |
| super(); | |
| setTargetWidget(widget); | |
| } | |
| public void assertOnDragEndCalled(boolean expected) { | |
| assertEquals(expected, onDragEndCalled); | |
| onDragEndCalled = false; | |
| } | |
| public void assertOnDragMoveCalled(boolean expected) { | |
| assertEquals(expected, onDragMoveCalled); | |
| onDragMoveCalled = false; | |
| } | |
| public void assertOnDragStartCalled(boolean expected) { | |
| assertEquals(expected, onDragStartCalled); | |
| onDragStartCalled = false; | |
| } | |
| public void assertSetupBustClickHandlerCalled(boolean expected) { | |
| assertEquals(expected, setupBustClickHandlerCalled); | |
| setupBustClickHandlerCalled = false; | |
| } | |
| public void assertRemoveBustClickHandlerCalled(boolean expected) { | |
| assertEquals(expected, removeBustClickHandlerCalled); | |
| removeBustClickHandlerCalled = false; | |
| } | |
| public void assertRemoveAttachHandlerCalled(boolean expected) { | |
| assertEquals(expected, removeAttachHandlerCalled); | |
| removeAttachHandlerCalled = false; | |
| } | |
| @Override | |
| protected void onDragEnd(TouchEvent<?> event) { | |
| assertFalse("onDragEnd called twice", onDragEndCalled); | |
| super.onDragEnd(event); | |
| onDragEndCalled = true; | |
| } | |
| @Override | |
| protected void onDragMove(TouchEvent<?> event) { | |
| assertFalse("onDragMove called twice", onDragMoveCalled); | |
| super.onDragMove(event); | |
| onDragMoveCalled = true; | |
| } | |
| @Override | |
| protected void onDragStart(TouchEvent<?> event) { | |
| assertFalse("onDragStart called twice", onDragStartCalled); | |
| super.onDragStart(event); | |
| onDragStartCalled = true; | |
| } | |
| @Override | |
| protected void setupBustClickHandler() { | |
| super.setupBustClickHandler(); | |
| setupBustClickHandlerCalled = true; | |
| } | |
| @Override | |
| protected void removeBustClickHandler() { | |
| super.removeBustClickHandler(); | |
| removeBustClickHandlerCalled = true; | |
| } | |
| @Override | |
| protected void removeAttachHandler() { | |
| super.removeAttachHandler(); | |
| removeAttachHandlerCalled = true; | |
| } | |
| } | |
| /** | |
| * Create a mock native touch event that contains no touches. | |
| * | |
| * @return an empty mock touch event | |
| */ | |
| private static native NativeEvent createNativeTouchEvent() /*-{ | |
| // Create a real event so standard event methods are available. | |
| var touches = []; | |
| return { | |
| "changedTouches" : touches, | |
| "targetTouches" : touches, | |
| "touches" : touches, | |
| "preventDefault" : function() {} // Called by TouchScroller. | |
| }; | |
| }-*/; | |
| /** | |
| * Create a mock {@link Touch} for the specified x and y coordinate. | |
| * | |
| * @param x the x coordinate | |
| * @param y the y coordinate | |
| * @return a mock touch | |
| */ | |
| private static native Touch createTouch(int x, int y) /*-{ | |
| return { | |
| "clientX" : x, | |
| "clientY" : y, | |
| "identifier" : 0, | |
| "pageX" : x, | |
| "pageY" : y, | |
| "screenX" : x, | |
| "screenY" : y, | |
| "target" : null | |
| }; | |
| }-*/; | |
| /** | |
| * Create a mock TouchEndEvent. Touch end events do not have any touches. | |
| * | |
| * @return a mock TouchEndEvent | |
| */ | |
| private static TouchEvent<?> createTouchEndEvent() { | |
| CustomTouchEvent event = new CustomTouchEvent(); | |
| event.setNativeEvent(createNativeTouchEvent()); | |
| return event; | |
| } | |
| /** | |
| * Create a mock TouchMoveEvent for the specified x and y coordinate. | |
| * | |
| * @param x the x coordinate | |
| * @param y the y coordinate | |
| * @return a mock TouchMoveEvent | |
| */ | |
| private static TouchEvent<?> createTouchMoveEvent(int x, int y) { | |
| // TouchScroller doesn't care about the actual event subclass. | |
| return createTouchStartEvent(x, y); | |
| } | |
| /** | |
| * Create a mock {@link TouchStartEvent} for the specified x and y coordinate. | |
| * | |
| * @param x the x coordinate | |
| * @param y the y coordinate | |
| * @return a mock {@link TouchStartEvent} | |
| */ | |
| private static TouchEvent<?> createTouchStartEvent(int x, int y) { | |
| CustomTouchEvent event = new CustomTouchEvent(); | |
| NativeEvent nativeEvent = createNativeTouchEvent(); | |
| nativeEvent.getTouches().push(createTouch(x, y)); | |
| event.setNativeEvent(nativeEvent); | |
| return event; | |
| } | |
| private CustomTouchScroller scroller; | |
| private CustomScrollPanel scrollPanel; | |
| @Override | |
| public String getModuleName() { | |
| return "com.google.gwt.touch.Touch"; | |
| } | |
| public void testCalculateEndVlocity() { | |
| // Two points at the same time should return null. | |
| TemporalPoint from = new TemporalPoint(new Point(100.0, 200.0), 0); | |
| TemporalPoint sameTime = new TemporalPoint(new Point(100.0, 100.0), 0); | |
| assertNull(scroller.calculateEndVelocity(from, sameTime)); | |
| // Two different points should return a velocity. | |
| TemporalPoint to = new TemporalPoint(new Point(250.0, 150.0), 25); | |
| assertEquals(new Point(-6.0, 2.0), scroller.calculateEndVelocity(from, to)); | |
| } | |
| public void testCreateIfSupported() { | |
| // createIfSupported() | |
| TouchScroller scroller = TouchScroller.createIfSupported(); | |
| if (TouchScroller.isSupported()) { | |
| assertNotNull("TouchScroll not created, but touch is supported", scroller); | |
| assertNull(scroller.getTargetWidget()); | |
| } else { | |
| assertNull("TouchScroll created, but touch is not supported", scroller); | |
| } | |
| // createIfSupported(HasScrolling) | |
| HasScrolling target = new ScrollPanel(); | |
| scroller = TouchScroller.createIfSupported(target); | |
| if (TouchScroller.isSupported()) { | |
| assertNotNull("TouchScroll not created, but touch is supported", scroller); | |
| assertEquals(target, scroller.getTargetWidget()); | |
| } else { | |
| assertNull("TouchScroll created, but touch is not supported", scroller); | |
| } | |
| } | |
| public void testDeferToNativeScrollingBottom() { | |
| testDeferToNativeScrolling(0, scrollPanel.getMaximumVerticalScrollPosition(), 0, -100); | |
| } | |
| public void testDeferToNativeScrollingLeft() { | |
| testDeferToNativeScrolling(0, 0, 100, 0); | |
| } | |
| public void testDeferToNativeScrollingRight() { | |
| testDeferToNativeScrolling(scrollPanel.getMaximumHorizontalScrollPosition(), 0, -100, 0); | |
| } | |
| public void testDeferToNativeScrollingTop() { | |
| testDeferToNativeScrolling(0, 0, 0, 100); | |
| } | |
| /** | |
| * Test that touch events correctly initiate drag events. | |
| */ | |
| public void testDragSequence() { | |
| // Disable momentum for this test. | |
| scroller.setMomentum(null); | |
| // Initial state. | |
| assertFalse(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| // Start touching. | |
| scroller.onTouchStart(createTouchStartEvent(0, 0)); | |
| scroller.assertOnDragStartCalled(false); | |
| assertTrue(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| // Move, but not enough to drag. | |
| scroller.onTouchMove(createTouchMoveEvent(-1, 0)); | |
| scroller.assertOnDragStartCalled(false); | |
| scroller.assertOnDragMoveCalled(false); | |
| assertTrue(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| // Move. | |
| scroller.onTouchMove(createTouchMoveEvent(-100, 0)); | |
| scroller.assertOnDragStartCalled(true); | |
| scroller.assertOnDragMoveCalled(true); | |
| assertTrue(scroller.isTouching()); | |
| assertTrue(scroller.isDragging()); | |
| // Move again. | |
| scroller.onTouchMove(createTouchMoveEvent(-200, 0)); | |
| scroller.assertOnDragStartCalled(false); // drag already started. | |
| scroller.assertOnDragMoveCalled(true); | |
| assertTrue(scroller.isTouching()); | |
| assertTrue(scroller.isDragging()); | |
| // End. | |
| scroller.onTouchEnd(createTouchEndEvent()); | |
| scroller.assertOnDragStartCalled(false); | |
| scroller.assertOnDragMoveCalled(false); | |
| scroller.assertOnDragEndCalled(true); | |
| assertFalse(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| } | |
| /** | |
| * Test that the bust click/attach event handler is removed from the old | |
| * widget. | |
| */ | |
| public void testHandlersRemovedFromOldWidget() { | |
| CustomScrollPanel newScrollPanel = new CustomScrollPanel(); | |
| // Initial state. | |
| scroller.assertRemoveBustClickHandlerCalled(true); | |
| scroller.assertRemoveAttachHandlerCalled(true); | |
| // Replace the old widget (scrollPanel) with the new widget (newScrollPanel) | |
| scroller.setTargetWidget(newScrollPanel); | |
| // Verify that the bust click handler and attach event handler are removed. | |
| scroller.assertRemoveBustClickHandlerCalled(true); | |
| scroller.assertRemoveAttachHandlerCalled(true); | |
| // Remove the old widget (scrollPanel) from the root panel. | |
| RootPanel.get().remove(scrollPanel); | |
| // Verify that removing the old widget doesn't cause removeBustClickHandler | |
| // from being called. | |
| scroller.assertRemoveBustClickHandlerCalled(false); | |
| } | |
| /** | |
| * Test that when momentum ends, the momentum command is set to null (and | |
| * isMomentumActive() returns false). | |
| */ | |
| public void testMomentumEnd() { | |
| // Use a short lived momentum. | |
| scroller.setMomentum(new DefaultMomentum() { | |
| @Override | |
| public boolean updateState(State state) { | |
| // Immediately end momentum. | |
| return false; | |
| } | |
| }); | |
| // Start a drag sequence. | |
| double millis = Duration.currentTimeMillis(); | |
| scroller.getRecentTouchPosition().setTemporalPoint(new Point(0, 0), millis); | |
| scroller.getLastTouchPosition().setTemporalPoint(new Point(100, 100), millis + 100); | |
| // End the drag sequence. | |
| scroller.onDragEnd(createTouchEndEvent()); | |
| scroller.assertOnDragEndCalled(true); | |
| assertFalse(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| assertTrue(scroller.isMomentumActive()); | |
| // Force momentum to run, which causes it to end. | |
| getMomentumCommand(scroller).execute(); | |
| assertFalse(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| assertFalse(scroller.isMomentumActive()); | |
| } | |
| public void testOnDragEnd() { | |
| // Start a drag sequence. | |
| double millis = Duration.currentTimeMillis(); | |
| scroller.getRecentTouchPosition().setTemporalPoint(new Point(0, 0), millis); | |
| scroller.getLastTouchPosition().setTemporalPoint(new Point(100, 100), millis + 100); | |
| // End the drag sequence. | |
| scroller.onDragEnd(createTouchEndEvent()); | |
| assertTrue(scroller.isMomentumActive()); | |
| } | |
| public void testOnDragEndNoMomentum() { | |
| // Disable momentum for this test. | |
| scroller.setMomentum(null); | |
| // Start a drag sequence. | |
| double millis = Duration.currentTimeMillis(); | |
| scroller.getRecentTouchPosition().setTemporalPoint(new Point(0, 0), millis); | |
| scroller.getLastTouchPosition().setTemporalPoint(new Point(100, 100), millis + 100); | |
| // End the drag sequence. | |
| scroller.onDragEnd(createTouchEndEvent()); | |
| assertFalse(scroller.isMomentumActive()); | |
| } | |
| public void testOnDragMove() { | |
| // Disable momentum for this test. | |
| scroller.setMomentum(null); | |
| // Start at 100x100; | |
| scrollPanel.setHorizontalScrollPosition(100); | |
| scrollPanel.setVerticalScrollPosition(150); | |
| // Start touching. | |
| scroller.onTouchStart(createTouchStartEvent(0, 0)); | |
| // Drag in a positive direction (negative scroll). | |
| TouchEvent<?> touchMove = createTouchMoveEvent(40, 50); | |
| scroller.onTouchMove(touchMove); | |
| scroller.assertOnDragMoveCalled(true); | |
| assertEquals(60, scrollPanel.getHorizontalScrollPosition()); | |
| assertEquals(100, scrollPanel.getVerticalScrollPosition()); | |
| // Drag in a negative direction (positive scroll). | |
| touchMove = createTouchMoveEvent(-20, -30); | |
| scroller.onTouchMove(touchMove); | |
| scroller.assertOnDragMoveCalled(true); | |
| assertEquals(120, scrollPanel.getHorizontalScrollPosition()); | |
| assertEquals(180, scrollPanel.getVerticalScrollPosition()); | |
| } | |
| /** | |
| * Test that touch end events are ignored if not touching. | |
| */ | |
| public void testOnTouchEndIgnored() { | |
| // Disable momentum for this test. | |
| scroller.setMomentum(null); | |
| // Initial state. | |
| assertFalse(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| // Verify that an extraneous touch end event is ignored. | |
| scroller.onTouchEnd(createTouchEndEvent()); | |
| assertFalse(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| } | |
| /** | |
| * Test that we handle touch end events that occur without initiating a drag | |
| * sequence. | |
| */ | |
| public void testOnTouchEndWithoutDrag() { | |
| // Disable momentum for this test. | |
| scroller.setMomentum(null); | |
| // Initial state. | |
| assertFalse(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| // Start touching. | |
| scroller.onTouchStart(createTouchStartEvent(0, 0)); | |
| scroller.assertOnDragStartCalled(false); | |
| assertTrue(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| // Move, but not enough to drag. | |
| scroller.onTouchMove(createTouchMoveEvent(1, 0)); | |
| scroller.assertOnDragStartCalled(false); | |
| scroller.assertOnDragMoveCalled(false); | |
| assertTrue(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| // End. | |
| scroller.onTouchEnd(createTouchEndEvent()); | |
| scroller.assertOnDragStartCalled(false); | |
| scroller.assertOnDragMoveCalled(false); | |
| scroller.assertOnDragEndCalled(false); | |
| assertFalse(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| } | |
| /** | |
| * Test that touch move events are ignored if not touching. | |
| */ | |
| public void testOnTouchMoveIgnored() { | |
| // Disable momentum for this test. | |
| scroller.setMomentum(null); | |
| // Initial state. | |
| assertFalse(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| // Verify that an extraneous touchmove event is ignored. | |
| scroller.onTouchMove(createTouchMoveEvent(0, 0)); | |
| assertFalse(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| } | |
| /** | |
| * Test that touch start events cancel any active momentum. | |
| */ | |
| public void testOnTouchCancelsMomentum() { | |
| // Start momentum. | |
| double millis = Duration.currentTimeMillis(); | |
| scroller.getRecentTouchPosition().setTemporalPoint(new Point(0, 0), millis); | |
| scroller.getLastTouchPosition().setTemporalPoint(new Point(100, 100), millis + 100); | |
| scroller.onDragEnd(createTouchEndEvent()); | |
| assertTrue(scroller.isMomentumActive()); | |
| // Touch again. | |
| scroller.onTouchStart(createTouchStartEvent(0, 0)); | |
| assertFalse(scroller.isMomentumActive()); | |
| } | |
| /** | |
| * Test that touch start events are ignored if already touching. | |
| */ | |
| public void testOnTouchStartIgnored() { | |
| scroller.setMomentum(null); // Disable momentum for this test. | |
| // Initial state. | |
| assertFalse(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| // Start touching. | |
| scroller.onTouchStart(createTouchStartEvent(0, 0)); | |
| scroller.assertOnDragStartCalled(false); | |
| assertTrue(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| // Verify that additional start events do not cause errors. | |
| scroller.onTouchStart(createTouchStartEvent(0, 0)); | |
| scroller.assertOnDragStartCalled(false); | |
| assertTrue(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| } | |
| /** | |
| * Test that the setupBustClickHandler is called when the widget is detached | |
| * and re-attached. | |
| */ | |
| public void testSetupBustClickHandler() { | |
| // Initial state. | |
| scroller.assertRemoveBustClickHandlerCalled(true); | |
| scroller.assertRemoveAttachHandlerCalled(true); | |
| scroller.assertSetupBustClickHandlerCalled(true); | |
| RootPanel.get().remove(scrollPanel); | |
| // Verify that the bust click handler is removed. | |
| scroller.assertRemoveBustClickHandlerCalled(true); | |
| RootPanel.get().add(scrollPanel); | |
| // Verify that the bust click handler is setup. | |
| scroller.assertSetupBustClickHandlerCalled(true); | |
| } | |
| @Override | |
| protected void gwtSetUp() throws Exception { | |
| // Create and attach a widget that has scrolling. | |
| scrollPanel = new CustomScrollPanel(); | |
| scrollPanel.setPixelSize(500, 500); | |
| Label content = new Label("Content"); | |
| content.setPixelSize(10000, 10000); | |
| RootPanel.get().add(scrollPanel); | |
| // Disabled touch scrolling because we will add our own scroller. | |
| scrollPanel.setTouchScrollingDisabled(true); | |
| // Add scrolling support. | |
| scroller = new CustomTouchScroller(scrollPanel); | |
| } | |
| /** | |
| * A replacement for JUnit's {@link #tearDown()} method. This method runs once | |
| * per test method in your subclass, just after your each test method runs and | |
| * can be used to perform cleanup. Override this method instead of | |
| * {@link #tearDown()}. This method is run even in pure Java mode (non-GWT). | |
| * | |
| * @see #setForcePureJava | |
| */ | |
| @Override | |
| protected void gwtTearDown() throws Exception { | |
| // Detach the widget. | |
| RootPanel.get().remove(scrollPanel.asWidget()); | |
| scrollPanel = null; | |
| scroller = null; | |
| } | |
| /** | |
| * Get the momentum command from the specified {@link TouchScroller}. | |
| */ | |
| private native RepeatingCommand getMomentumCommand(TouchScroller scroller) /*-{ | |
| return scroller.@com.google.gwt.touch.client.TouchScroller::momentumCommand; | |
| }-*/; | |
| /** | |
| * Test that {@link TouchScroller} defers to native scrolling if the | |
| * scrollable widget is already scrolled as far as it can go. | |
| * | |
| * @param hStart the starting horizontal scroll position | |
| * @param vStart the starting vertical scroll position | |
| * @param xEnd the ending x touch coordinate | |
| * @param yEnd the ending y touch coordinate | |
| */ | |
| private void testDeferToNativeScrolling(int hStart, int vStart, int xEnd, int yEnd) { | |
| // Disable momentum for this test. | |
| scroller.setMomentum(null); | |
| // Scroll to the left. | |
| scrollPanel.setHorizontalScrollPosition(hStart); | |
| scrollPanel.setVerticalScrollPosition(vStart); | |
| // Start touching. | |
| scroller.onTouchStart(createTouchStartEvent(0, 0)); | |
| scroller.assertOnDragStartCalled(false); | |
| assertTrue(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| // Move to the left. | |
| scroller.onTouchMove(createTouchMoveEvent(xEnd, yEnd)); | |
| scroller.assertOnDragStartCalled(false); | |
| scroller.assertOnDragMoveCalled(false); | |
| assertFalse(scroller.isTouching()); | |
| assertFalse(scroller.isDragging()); | |
| } | |
| } |