--- /dev/null
+/*
+ * 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 com.android.cts.stub.R;
+
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.ToBeFixed;
+
+import org.xmlpull.v1.XmlPullParser;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Rect;
+import android.test.ActivityInstrumentationTestCase2;
+import android.test.UiThreadTest;
+import android.util.AttributeSet;
+import android.util.Xml;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.View.MeasureSpec;
+import android.view.ViewGroup.LayoutParams;
+import android.view.animation.cts.DelayedCheck;
+import android.widget.ScrollView;
+import android.widget.TextView;
+
+/**
+ * Test {@link ScrollView}.
+ */
+@TestTargetClass(ScrollView.class)
+public class ScrollViewTest extends ActivityInstrumentationTestCase2<ScrollViewStubActivity> {
+ // view dpi constants. Must match those defined in scroll_view layout
+ private static final int ITEM_WIDTH_DPI = 250;
+ private static final int ITEM_HEIGHT_DPI = 100;
+ private static final int ITEM_COUNT = 15;
+ private static final int PAGE_WIDTH_DPI = 100;
+ private static final int PAGE_HEIGHT_DPI = 100;
+ private static final int TOLERANCE = 2;
+
+ private int mItemWidth;
+ private int mItemHeight;
+ private int mPageWidth;
+ private int mPageHeight;
+ private int mScrollBottom;
+ private int mScrollRight;
+
+ private MyScrollView mScrollView;
+ private Activity mActivity;
+
+ public ScrollViewTest() {
+ super("com.android.cts.stub", ScrollViewStubActivity.class);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ mActivity = getActivity();
+ mScrollView = (MyScrollView) mActivity.findViewById(R.id.scroll_view);
+
+ // calculate pixel positions from dpi constants.
+ final float density = getActivity().getResources().getDisplayMetrics().density;
+ mItemWidth = (int) (ITEM_WIDTH_DPI * density);
+ mItemHeight = (int) (ITEM_HEIGHT_DPI * density);
+ mPageWidth = (int) (PAGE_WIDTH_DPI * density);
+ mPageHeight = (int) (PAGE_HEIGHT_DPI * density);
+
+ mScrollBottom = mItemHeight * ITEM_COUNT - mPageHeight;
+ mScrollRight = mItemWidth - mPageWidth;
+ }
+
+ @TestTargets({
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "ScrollView",
+ args = {Context.class}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "ScrollView",
+ args = {Context.class, AttributeSet.class}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "ScrollView",
+ args = {Context.class, AttributeSet.class, int.class}
+ )
+ })
+ public void testConstructor() {
+ XmlPullParser parser = mActivity.getResources().getLayout(R.layout.scrollview_layout);
+ AttributeSet attrs = Xml.asAttributeSet(parser);
+ new ScrollView(mActivity);
+
+ new ScrollView(mActivity, attrs);
+
+ new ScrollView(mActivity, attrs, 0);
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getMaxScrollAmount",
+ args = {}
+ )
+ public void testGetMaxScrollAmount() {
+ // the value is half of total layout height
+ ScrollView scrollView = new ScrollView(mActivity);
+ scrollView.layout(0, 0, 100, 200);
+ assertEquals((200 - 0) / 2, scrollView.getMaxScrollAmount());
+
+ scrollView.layout(0, 0, 150, 100);
+ assertEquals((100 - 0) / 2, scrollView.getMaxScrollAmount());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "addView",
+ args = {View.class}
+ )
+ @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete."
+ + " @throws clause should be added into javadoc of "
+ + "ScrollView#addView(View) when there is already one child in the view.")
+ public void testAddView() {
+ ScrollView scrollView = new ScrollView(mActivity);
+ TextView child0 = new TextView(mActivity);
+ scrollView.addView(child0);
+ assertSame(child0, scrollView.getChildAt(0));
+
+ assertEquals(1, scrollView.getChildCount());
+ TextView child1 = new TextView(mActivity);
+ try {
+ scrollView.addView(child1);
+ fail("ScrollView can host only one direct child");
+ } catch (IllegalStateException e) {
+ // expected
+ }
+ assertEquals(1, scrollView.getChildCount());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "addView",
+ args = {View.class, int.class}
+ )
+ @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete."
+ + " @throws clause should be added into javadoc of "
+ + "ScrollView#addView(View, int) when there is already one child in the view.")
+ public void testAddViewWithIndex() {
+ ScrollView scrollView = new ScrollView(mActivity);
+ TextView child0 = new TextView(mActivity);
+ scrollView.addView(child0, 0);
+ assertSame(child0, scrollView.getChildAt(0));
+
+ assertEquals(1, scrollView.getChildCount());
+ TextView child1 = new TextView(mActivity);
+ try {
+ scrollView.addView(child1, 1);
+ fail("ScrollView can host only one direct child");
+ } catch (IllegalStateException e) {
+ // expected
+ }
+ assertEquals(1, scrollView.getChildCount());
+
+ scrollView.removeAllViews();
+ scrollView = new ScrollView(mActivity);
+ scrollView.addView(child0, -1);
+ assertSame(child0, scrollView.getChildAt(0));
+
+ assertEquals(1, scrollView.getChildCount());
+ child1 = new TextView(mActivity);
+ try {
+ scrollView.addView(child1, -1);
+ fail("ScrollView can host only one direct child");
+ } catch (IllegalStateException e) {
+ // expected
+ }
+ assertEquals(1, scrollView.getChildCount());
+
+ scrollView.removeAllViews();
+ scrollView = new ScrollView(mActivity);
+ try {
+ scrollView.addView(child0, 1);
+ fail("ScrollView can host only one direct child");
+ } catch (IndexOutOfBoundsException e) {
+ // expected
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "addView",
+ args = {View.class, LayoutParams.class}
+ )
+ @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete."
+ + " @throws clause should be added into javadoc of "
+ + "ScrollView#addView(View, LayoutParams) when there is already"
+ + " one child in the view or the layoutparams is null")
+ public void testAddViewWithLayoutParams() {
+ ScrollView scrollView = new ScrollView(mActivity);
+ TextView child0 = new TextView(mActivity);
+ scrollView.addView(child0, new ViewGroup.LayoutParams(200, 100));
+ assertSame(child0, scrollView.getChildAt(0));
+ assertEquals(200, child0.getLayoutParams().width);
+ assertEquals(100, child0.getLayoutParams().height);
+
+ assertEquals(1, scrollView.getChildCount());
+ TextView child1 = new TextView(mActivity);
+ try {
+ scrollView.addView(child1, new ViewGroup.LayoutParams(200, 100));
+ fail("ScrollView can host only one direct child");
+ } catch (IllegalStateException e) {
+ // expected
+ }
+ assertEquals(1, scrollView.getChildCount());
+
+ scrollView.removeAllViews();
+ scrollView = new ScrollView(mActivity);
+ child0 = new TextView(mActivity);
+ try {
+ scrollView.addView(child0, null);
+ fail("The LayoutParams should not be null!");
+ } catch (NullPointerException e) {
+ // expected
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "addView",
+ args = {View.class, int.class, LayoutParams.class}
+ )
+ @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete."
+ + " @throws clause should be added into javadoc of "
+ + "ScrollView#addView(View, int, LayoutParams) when there is already"
+ + " one child in the view or the layoutparams is null")
+ public void testAddViewWithIndexAndLayoutParams() {
+ ScrollView scrollView = new ScrollView(mActivity);
+ TextView child0 = new TextView(mActivity);
+ scrollView.addView(child0, 0, new ViewGroup.LayoutParams(200, 100));
+ assertSame(child0, scrollView.getChildAt(0));
+ assertEquals(200, child0.getLayoutParams().width);
+ assertEquals(100, child0.getLayoutParams().height);
+
+ assertEquals(1, scrollView.getChildCount());
+ TextView child1 = new TextView(mActivity);
+ try {
+ scrollView.addView(child1, 0, new ViewGroup.LayoutParams(200, 100));
+ fail("ScrollView can host only one direct child");
+ } catch (IllegalStateException e) {
+ // expected
+ }
+ assertEquals(1, scrollView.getChildCount());
+
+ scrollView.removeAllViews();
+ scrollView = new ScrollView(mActivity);
+ child0 = new TextView(mActivity);
+ try {
+ scrollView.addView(child0, null);
+ fail("The LayoutParams should not be null!");
+ } catch (NullPointerException e) {
+ // expected
+ }
+
+ scrollView.removeAllViews();
+ scrollView = new ScrollView(mActivity);
+ scrollView.addView(child0, -1, new ViewGroup.LayoutParams(300, 150));
+ assertSame(child0, scrollView.getChildAt(0));
+ assertEquals(300, child0.getLayoutParams().width);
+ assertEquals(150, child0.getLayoutParams().height);
+
+ assertEquals(1, scrollView.getChildCount());
+ child1 = new TextView(mActivity);
+ try {
+ scrollView.addView(child1, -1, new ViewGroup.LayoutParams(200, 100));
+ fail("ScrollView can host only one direct child");
+ } catch (IllegalStateException e) {
+ // expected
+ }
+ assertEquals(1, scrollView.getChildCount());
+
+ scrollView.removeAllViews();
+ scrollView = new ScrollView(mActivity);
+ try {
+ scrollView.addView(child0, 1, new ViewGroup.LayoutParams(200, 100));
+ fail("ScrollView can host only one direct child");
+ } catch (IndexOutOfBoundsException e) {
+ // expected
+ }
+ }
+
+ @TestTargets({
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "isFillViewport",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "setFillViewport",
+ args = {boolean.class}
+ )
+ })
+ public void testAccessFillViewport() {
+ ScrollView scrollView = new ScrollView(mActivity);
+ assertFalse(scrollView.isFillViewport());
+ scrollView.layout(0, 0, 100, 100);
+ assertFalse(scrollView.isLayoutRequested());
+
+ scrollView.setFillViewport(false);
+ assertFalse(scrollView.isFillViewport());
+ assertFalse(scrollView.isLayoutRequested());
+
+ scrollView.setFillViewport(true);
+ assertTrue(scrollView.isFillViewport());
+ assertTrue(scrollView.isLayoutRequested());
+
+ scrollView.layout(0, 0, 100, 100);
+ assertFalse(mScrollView.isLayoutRequested());
+
+ scrollView.setFillViewport(false);
+ assertFalse(scrollView.isFillViewport());
+ assertTrue(scrollView.isLayoutRequested());
+ }
+
+ @TestTargets({
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "isSmoothScrollingEnabled",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "setSmoothScrollingEnabled",
+ args = {boolean.class}
+ )
+ })
+ public void testAccessSmoothScrollingEnabled() throws Throwable {
+ assertTrue(mScrollView.isSmoothScrollingEnabled());
+
+ // scroll immediately
+ mScrollView.setSmoothScrollingEnabled(false);
+ assertFalse(mScrollView.isSmoothScrollingEnabled());
+
+ runTestOnUiThread(new Runnable() {
+ public void run() {
+ mScrollView.fullScroll(View.FOCUS_DOWN);
+ }
+ });
+
+ assertEquals(mScrollBottom, mScrollView.getScrollY(), TOLERANCE);
+
+ runTestOnUiThread(new Runnable() {
+ public void run() {
+ mScrollView.fullScroll(View.FOCUS_UP);
+ }
+ });
+ assertEquals(0, mScrollView.getScrollY());
+
+ // smooth scroll
+ mScrollView.setSmoothScrollingEnabled(true);
+ assertTrue(mScrollView.isSmoothScrollingEnabled());
+
+ runTestOnUiThread(new Runnable() {
+ public void run() {
+ mScrollView.fullScroll(View.FOCUS_DOWN);
+ }
+ });
+ delayedCheckSmoothScrolling(0, 0, 0, mScrollBottom);
+ assertEquals(mScrollBottom, mScrollView.getScrollY(), TOLERANCE);
+
+ runTestOnUiThread(new Runnable() {
+ public void run() {
+ mScrollView.fullScroll(View.FOCUS_UP);
+ }
+ });
+ delayedCheckSmoothScrolling(0, 0, mScrollBottom, 0);
+ assertEquals(0, mScrollView.getScrollY());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "measureChild",
+ args = {View.class, int.class, int.class}
+ )
+ public void testMeasureChild() {
+ MyScrollView scrollView = new MyScrollView(mActivity);
+
+ MyView child = new MyView(mActivity);
+ child.setBackgroundDrawable(null);
+ child.setPadding(0, 0, 0, 0);
+ child.setMinimumHeight(30);
+ child.setLayoutParams(new ViewGroup.LayoutParams(100, 100));
+ child.measure(MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY),
+ MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY));
+
+ assertEquals(100, child.getMeasuredHeight());
+ assertEquals(100, child.getMeasuredWidth());
+
+ scrollView.measureChild(child, MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY),
+ MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY));
+
+ assertEquals(30, child.getMeasuredHeight());
+ assertEquals(100, child.getMeasuredWidth());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "measureChildWithMargins",
+ args = {View.class, int.class, int.class, int.class, int.class}
+ )
+ public void testMeasureChildWithMargins() {
+ MyScrollView mockScrollView = new MyScrollView(mActivity);
+
+ MyView child = new MyView(mActivity);
+ child.setBackgroundDrawable(null);
+ child.setPadding(0, 0, 0, 0);
+ child.setMinimumHeight(30);
+ child.setLayoutParams(new ViewGroup.MarginLayoutParams(100, 100));
+ child.measure(MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY),
+ MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY));
+
+ assertEquals(100, child.getMeasuredHeight());
+ assertEquals(100, child.getMeasuredWidth());
+
+ mockScrollView.measureChildWithMargins(child,
+ MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY), 5,
+ MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY), 5);
+
+ assertEquals(30, child.getMeasuredHeight());
+ assertEquals(100, child.getMeasuredWidth());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "pageScroll",
+ args = {int.class}
+ )
+ @UiThreadTest
+ public void testPageScroll() {
+ mScrollView.setSmoothScrollingEnabled(false);
+ assertEquals(0, mScrollView.getScrollY());
+
+ assertTrue(mScrollView.pageScroll(View.FOCUS_DOWN));
+ assertEquals(mPageHeight, mScrollView.getScrollY(), TOLERANCE);
+
+ assertTrue(mScrollView.pageScroll(View.FOCUS_DOWN));
+ assertEquals(mPageHeight * 2, mScrollView.getScrollY(), TOLERANCE);
+
+ mScrollView.scrollTo(mPageWidth, mScrollBottom);
+ assertFalse(mScrollView.pageScroll(View.FOCUS_DOWN));
+ assertEquals(mScrollBottom, mScrollView.getScrollY(), TOLERANCE);
+
+ assertTrue(mScrollView.pageScroll(View.FOCUS_UP));
+ assertEquals(mScrollBottom - mPageHeight, mScrollView.getScrollY(), TOLERANCE);
+
+ assertTrue(mScrollView.pageScroll(View.FOCUS_UP));
+ assertEquals(mScrollBottom -mPageHeight * 2, mScrollView.getScrollY(), TOLERANCE);
+
+ mScrollView.scrollTo(mPageWidth, 0);
+ assertFalse(mScrollView.pageScroll(View.FOCUS_UP));
+ assertEquals(0, mScrollView.getScrollY());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "fullScroll",
+ args = {int.class}
+ )
+ @UiThreadTest
+ public void testFullScroll() {
+ mScrollView.setSmoothScrollingEnabled(false);
+ assertEquals(0, mScrollView.getScrollY());
+
+ assertTrue(mScrollView.fullScroll(View.FOCUS_DOWN));
+ assertEquals(mScrollBottom, mScrollView.getScrollY());
+
+ assertFalse(mScrollView.fullScroll(View.FOCUS_DOWN));
+ assertEquals(mScrollBottom, mScrollView.getScrollY());
+
+ assertTrue(mScrollView.fullScroll(View.FOCUS_UP));
+ assertEquals(0, mScrollView.getScrollY());
+
+ assertFalse(mScrollView.fullScroll(View.FOCUS_UP));
+ assertEquals(0, mScrollView.getScrollY());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "arrowScroll",
+ args = {int.class}
+ )
+ @UiThreadTest
+ public void testArrowScroll() {
+ mScrollView.setSmoothScrollingEnabled(false);
+ assertEquals(0, mScrollView.getScrollY());
+
+ int y = mScrollView.getScrollY();
+ while (mScrollBottom != y) {
+ assertTrue(mScrollView.arrowScroll(View.FOCUS_DOWN));
+ assertTrue(y <= mScrollView.getScrollY());
+ y = mScrollView.getScrollY();
+ }
+
+ assertFalse(mScrollView.arrowScroll(View.FOCUS_DOWN));
+ assertEquals(mScrollBottom, mScrollView.getScrollY());
+
+ y = mScrollView.getScrollY();
+ while (0 != y) {
+ assertTrue(mScrollView.arrowScroll(View.FOCUS_UP));
+ assertTrue(y >= mScrollView.getScrollY());
+ y = mScrollView.getScrollY();
+ }
+
+ assertFalse(mScrollView.arrowScroll(View.FOCUS_UP));
+ assertEquals(0, mScrollView.getScrollY());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "smoothScrollBy",
+ args = {int.class, int.class}
+ )
+ public void testSmoothScrollBy() throws Throwable {
+ assertEquals(0, mScrollView.getScrollX());
+ assertEquals(0, mScrollView.getScrollY());
+
+ runTestOnUiThread(new Runnable() {
+ public void run() {
+ mScrollView.smoothScrollBy(mScrollRight, mScrollBottom);
+ }
+ });
+ // smoothScrollBy doesn't scroll in X
+ delayedCheckSmoothScrolling(0, 0, 0, mScrollBottom);
+ assertEquals(0, mScrollView.getScrollX());
+ assertEquals(mScrollBottom, mScrollView.getScrollY());
+
+ runTestOnUiThread(new Runnable() {
+ public void run() {
+ mScrollView.smoothScrollBy(-mScrollRight, -mScrollBottom);
+ }
+ });
+ delayedCheckSmoothScrolling(mScrollRight, 0, mScrollBottom, 0);
+ assertEquals(0, mScrollView.getScrollX());
+ assertEquals(0, mScrollView.getScrollY());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "smoothScrollTo",
+ args = {int.class, int.class}
+ )
+ public void testSmoothScrollTo() throws Throwable {
+ assertEquals(0, mScrollView.getScrollX());
+ assertEquals(0, mScrollView.getScrollY());
+
+ runTestOnUiThread(new Runnable() {
+ public void run() {
+ mScrollView.smoothScrollTo(mScrollRight, mScrollBottom);
+ }
+ });
+ // smoothScrollTo doesn't scroll in X
+ delayedCheckSmoothScrolling(0, 0, 0, mScrollBottom);
+ assertEquals(0, mScrollView.getScrollX());
+ assertEquals(mScrollBottom, mScrollView.getScrollY());
+
+ runTestOnUiThread(new Runnable() {
+ public void run() {
+ mScrollView.smoothScrollTo(mPageWidth, mPageHeight);
+ }
+ });
+ delayedCheckSmoothScrolling(0, 0, mScrollBottom, mPageHeight);
+ assertEquals(0, mScrollView.getScrollX());
+ assertEquals(mPageHeight, mScrollView.getScrollY());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "computeScrollDeltaToGetChildRectOnScreen",
+ args = {android.graphics.Rect.class}
+ )
+ public void testComputeScrollDeltaToGetChildRectOnScreen() {
+ mScrollView.setSmoothScrollingEnabled(false);
+ int edge = mScrollView.getVerticalFadingEdgeLength();
+
+ // Rect's height is smaller than scroll view
+ Rect rect = new Rect(0, 0, 0, 0);
+ assertEquals(0, mScrollView.computeScrollDeltaToGetChildRectOnScreen(rect));
+
+ rect = new Rect(0, edge, 0, mPageHeight);
+ assertEquals(0, mScrollView.computeScrollDeltaToGetChildRectOnScreen(rect));
+
+ mScrollView.scrollTo(0, 0);
+ rect = new Rect(0, edge + 1, 0, mPageHeight);
+ assertEquals(edge, mScrollView.computeScrollDeltaToGetChildRectOnScreen(rect));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "computeVerticalScrollRange",
+ args = {}
+ )
+ public void testComputeVerticalScrollRange() {
+ assertTrue(mScrollView.getChildCount() > 0);
+ assertEquals(mItemHeight * ITEM_COUNT,
+ mScrollView.computeVerticalScrollRange(), TOLERANCE);
+
+ MyScrollView myScrollView = new MyScrollView(mActivity);
+ assertEquals(0, myScrollView.getChildCount());
+ assertEquals(0, myScrollView.computeVerticalScrollRange());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "requestChildFocus",
+ args = {View.class, View.class}
+ )
+ @UiThreadTest
+ public void testRequestChildFocus() {
+ mScrollView.setSmoothScrollingEnabled(false);
+
+ View firstChild = mScrollView.findViewById(R.id.first_child);
+ View lastChild = mScrollView.findViewById(R.id.last_child);
+ firstChild.requestFocus();
+
+ int scrollY = mScrollView.getScrollY();
+ mScrollView.requestChildFocus(lastChild, lastChild);
+ // check scrolling to the child which wants focus
+ assertTrue(mScrollView.getScrollY() > scrollY);
+
+ scrollY = mScrollView.getScrollY();
+ mScrollView.requestChildFocus(firstChild, firstChild);
+ // check scrolling to the child which wants focus
+ assertTrue(mScrollView.getScrollY() < scrollY);
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "requestChildRectangleOnScreen",
+ args = {View.class, Rect.class, boolean.class}
+ )
+ @UiThreadTest
+ public void testRequestChildRectangleOnScreen() {
+ mScrollView.setSmoothScrollingEnabled(false);
+ int edge = mScrollView.getVerticalFadingEdgeLength();
+
+ View child = mScrollView.findViewById(R.id.first_child);
+ int orgRectSize = (int)(10 * getActivity().getResources().getDisplayMetrics().density);
+ final Rect originalRect = new Rect(0, 0, orgRectSize, orgRectSize);
+ final Rect newRect = new Rect(mItemWidth - orgRectSize, mItemHeight - orgRectSize,
+ mItemWidth, mItemHeight);
+
+ assertFalse(mScrollView.requestChildRectangleOnScreen(child, originalRect, true));
+ assertEquals(0, mScrollView.getScrollX());
+ assertEquals(0, mScrollView.getScrollY());
+
+ assertTrue(mScrollView.requestChildRectangleOnScreen(child, newRect, true));
+ assertEquals(0, mScrollView.getScrollX());
+ assertEquals(edge, mScrollView.getScrollY());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ notes = "The method is simply called to make sure no exception is thrown.",
+ method = "requestLayout",
+ args = {}
+ )
+ @UiThreadTest
+ public void testRequestLayout() {
+ mScrollView.requestLayout();
+
+ assertTrue(mScrollView.isLayoutRequested());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "fling",
+ args = {int.class}
+ )
+ @ToBeFixed(bug = "1695243", explanation = "As javadoc says, scrolls towards the top "
+ + "when velocityY is positive. But it scrolls to bottom actually.")
+ public void testFling() throws Throwable {
+ mScrollView.setSmoothScrollingEnabled(true);
+ assertEquals(0, mScrollView.getScrollY());
+
+ // fling towards bottom
+ runTestOnUiThread(new Runnable() {
+ public void run() {
+ mScrollView.fling(2000);
+ }
+ });
+ delayedCheckFling(0, true);
+
+ final int currentY = mScrollView.getScrollY();
+ // fling towards top
+ runTestOnUiThread(new Runnable() {
+ public void run() {
+ mScrollView.fling(-2000);
+ }
+ });
+ delayedCheckFling(currentY, false);
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "scrollTo",
+ args = {int.class, int.class}
+ )
+ @UiThreadTest
+ public void testScrollTo() {
+ mScrollView.setSmoothScrollingEnabled(false);
+
+ mScrollView.scrollTo(10, 10);
+ assertEquals(10, mScrollView.getScrollY());
+ assertEquals(10, mScrollView.getScrollX());
+
+ mScrollView.scrollTo(mPageWidth, mPageHeight);
+ assertEquals(mPageHeight, mScrollView.getScrollY());
+ assertEquals(mPageWidth, mScrollView.getScrollX());
+
+ mScrollView.scrollTo(mScrollRight, mScrollBottom);
+ assertEquals(mScrollBottom, mScrollView.getScrollY());
+ assertEquals(mScrollRight, mScrollView.getScrollX());
+
+ // reach the top and left
+ mScrollView.scrollTo(-10, -10);
+ assertEquals(0, mScrollView.getScrollY());
+ assertEquals(0, mScrollView.getScrollX());
+ }
+
+ @TestTargets({
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getTopFadingEdgeStrength",
+ args = {}
+ ),
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getBottomFadingEdgeStrength",
+ args = {}
+ )
+ })
+ public void testGetVerticalFadingEdgeStrengths() {
+ assertTrue(mScrollView.getChildCount() > 0);
+ assertTrue(mScrollView.getTopFadingEdgeStrength() <= 1.0f);
+ assertTrue(mScrollView.getTopFadingEdgeStrength() >= 0.0f);
+ assertTrue(mScrollView.getBottomFadingEdgeStrength() <= 1.0f);
+ assertTrue(mScrollView.getBottomFadingEdgeStrength() >= 0.0f);
+
+ MyScrollView myScrollView = new MyScrollView(mActivity);
+ assertEquals(0, myScrollView.getChildCount());
+ assertTrue(mScrollView.getTopFadingEdgeStrength() <= 1.0f);
+ assertTrue(mScrollView.getTopFadingEdgeStrength() >= 0.0f);
+ assertTrue(mScrollView.getBottomFadingEdgeStrength() <= 1.0f);
+ assertTrue(mScrollView.getBottomFadingEdgeStrength() >= 0.0f);
+ }
+
+ @TestTargetNew(
+ level = TestLevel.NOT_NECESSARY,
+ method = "onLayout",
+ args = {boolean.class, int.class, int.class, int.class, int.class}
+ )
+ public void testOnLayout() {
+ // onLayout() is implementation details, do NOT test
+ }
+
+ @TestTargetNew(
+ level = TestLevel.NOT_NECESSARY,
+ method = "onMeasure",
+ args = {int.class, int.class}
+ )
+ public void testOnMeasure() {
+ // onMeasure() is implementation details, do NOT test
+ }
+
+ @TestTargetNew(
+ level = TestLevel.NOT_NECESSARY,
+ method = "executeKeyEvent",
+ args = {KeyEvent.class}
+ )
+ public void testExecuteKeyEvent() {
+ // executeKeyEvent() is implementation details, do NOT test
+ }
+
+ @TestTargetNew(
+ level = TestLevel.NOT_NECESSARY,
+ method = "onRequestFocusInDescendants",
+ args = {int.class, Rect.class}
+ )
+ public void testOnRequestFocusInDescendants() {
+ // onRequestFocusInDescendants() is implementation details, do NOT test
+ }
+
+ @TestTargetNew(
+ level = TestLevel.NOT_NECESSARY,
+ method = "onSizeChanged",
+ args = {int.class, int.class, int.class, int.class}
+ )
+ public void testOnSizeChanged() {
+ // onSizeChanged() is implementation details, do NOT test
+ }
+
+ @TestTargetNew(
+ level = TestLevel.NOT_NECESSARY,
+ method = "dispatchKeyEvent",
+ args = {KeyEvent.class}
+ )
+ public void testDispatchKeyEvent() {
+ // dispatchKeyEvent() is implementation details, do NOT test
+ }
+
+ @TestTargetNew(
+ level = TestLevel.NOT_NECESSARY,
+ method = "onInterceptTouchEvent",
+ args = {MotionEvent.class}
+ )
+ public void testOnInterceptTouchEvent() {
+ // onInterceptTouchEvent() is implementation details, do NOT test
+ }
+
+ @TestTargetNew(
+ level = TestLevel.NOT_NECESSARY,
+ method = "onTouchEvent",
+ args = {MotionEvent.class}
+ )
+ public void testOnTouchEvent() {
+ // onTouchEvent() is implementation details, do NOT test
+ }
+
+ @TestTargetNew(
+ level = TestLevel.NOT_NECESSARY,
+ method = "computeScroll",
+ args = {}
+ )
+ public void testComputeScroll() {
+ // computeScroll() is implementation details, do NOT test
+ }
+
+ private boolean isInRange(int current, int from, int to) {
+ if (from < to) {
+ return current >= from && current <= to;
+ }
+ return current <= from && current >= to;
+ }
+
+ private void delayedCheckSmoothScrolling(final int fromX, final int toX,
+ final int fromY, final int toY) {
+
+ if (fromX == toX && fromY == toY) {
+ return;
+ }
+
+ if (fromY != toY) {
+ new DelayedCheck() {
+ @Override
+ protected boolean check() {
+ return isInRange(mScrollView.getScrollY(), fromY, toY);
+ }
+ }.run();
+ }
+
+ if (fromX != toX) {
+ new DelayedCheck() {
+ @Override
+ protected boolean check() {
+ return isInRange(mScrollView.getScrollX(), fromX, toX);
+ }
+ }.run();
+ }
+
+ new DelayedCheck() {
+ @Override
+ protected boolean check() {
+ return toX == mScrollView.getScrollX() && toY == mScrollView.getScrollY();
+ }
+ }.run();
+ }
+
+ private void delayedCheckFling(final int startPosition, final boolean movingDown) {
+ new DelayedCheck() {
+ @Override
+ protected boolean check() {
+ if (movingDown) {
+ return mScrollView.getScrollY() > startPosition;
+ }
+ return mScrollView.getScrollY() < startPosition;
+ }
+ };
+
+ new DelayedCheck() {
+ private int mPreviousScrollY = mScrollView.getScrollY();
+
+ @Override
+ protected boolean check() {
+ if (mScrollView.getScrollY() == mPreviousScrollY) {
+ return true;
+ } else {
+ mPreviousScrollY = mScrollView.getScrollY();
+ return false;
+ }
+ }
+ }.run();
+ }
+
+ private static class MyView extends View {
+ public MyView(Context context) {
+ super(context);
+ }
+ }
+}
OSDN Git Service
