| /* |
| * Copyright (C) 2017 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.junit.Assume.assumeTrue; |
| |
| import android.app.Activity; |
| import android.content.Context; |
| import android.content.res.TypedArray; |
| import android.graphics.Bitmap; |
| import android.graphics.Canvas; |
| import android.graphics.Color; |
| import android.graphics.Insets; |
| import android.graphics.Point; |
| import android.graphics.PointF; |
| import android.graphics.drawable.ColorDrawable; |
| import android.graphics.drawable.Drawable; |
| import android.util.DisplayMetrics; |
| import android.view.ContextThemeWrapper; |
| import android.view.Gravity; |
| import android.view.SurfaceHolder; |
| import android.view.SurfaceView; |
| import android.view.View; |
| import android.widget.HorizontalScrollView; |
| import android.widget.LinearLayout; |
| import android.widget.LinearLayout.LayoutParams; |
| import android.widget.Magnifier; |
| import android.widget.ScrollView; |
| |
| import androidx.test.annotation.UiThreadTest; |
| import androidx.test.filters.SmallTest; |
| import androidx.test.InstrumentationRegistry; |
| import androidx.test.rule.ActivityTestRule; |
| import androidx.test.runner.AndroidJUnit4; |
| |
| import com.android.compatibility.common.util.PollingCheck; |
| import com.android.compatibility.common.util.WidgetTestUtils; |
| |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.TimeUnit; |
| |
| /** |
| * Tests for {@link Magnifier}. |
| */ |
| @SmallTest |
| @RunWith(AndroidJUnit4.class) |
| public class MagnifierTest { |
| private static final String TIME_LIMIT_EXCEEDED = |
| "Completing the magnifier operation took too long"; |
| private static final float PIXEL_COMPARISON_DELTA = 1f; |
| private static final float WINDOW_ELEVATION = 10f; |
| |
| private Activity mActivity; |
| private LinearLayout mLayout; |
| private View mView; |
| private Magnifier mMagnifier; |
| private DisplayMetrics mDisplayMetrics; |
| |
| @Rule |
| public ActivityTestRule<MagnifierCtsActivity> mActivityRule = |
| new ActivityTestRule<>(MagnifierCtsActivity.class); |
| |
| @Before |
| public void setup() throws Throwable { |
| mActivity = mActivityRule.getActivity(); |
| PollingCheck.waitFor(mActivity::hasWindowFocus); |
| |
| mDisplayMetrics = mActivity.getResources().getDisplayMetrics(); |
| // Do not run the tests, unless the device screen is big enough to fit a magnifier |
| // having the default size. |
| assumeTrue(isScreenBigEnough()); |
| |
| mLayout = mActivity.findViewById(R.id.magnifier_activity_centered_view_layout); |
| mView = mActivity.findViewById(R.id.magnifier_centered_view); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mLayout, null); |
| |
| mMagnifier = new Magnifier.Builder(mView) |
| .setSize(mView.getWidth() / 2, mView.getHeight() / 2) |
| .build(); |
| mActivityRule.runOnUiThread(() -> { |
| // Elevate the application window to have non-zero insets inside surface. |
| mActivityRule.getActivity().getWindow().setElevation(WINDOW_ELEVATION); |
| }); |
| } |
| |
| private boolean isScreenBigEnough() { |
| // Get the size of the screen in dp. |
| final float dpScreenWidth = mDisplayMetrics.widthPixels / mDisplayMetrics.density; |
| final float dpScreenHeight = mDisplayMetrics.heightPixels / mDisplayMetrics.density; |
| // Get the size of the magnifier window in dp. |
| final PointF dpMagnifier = Magnifier.getMagnifierDefaultSize(); |
| |
| return dpScreenWidth >= dpMagnifier.x * 1.1 && dpScreenHeight >= dpMagnifier.y * 1.1; |
| } |
| |
| //***** Tests for constructor *****// |
| |
| @Test |
| public void testConstructor() { |
| new Magnifier(new View(mActivity)); |
| } |
| |
| @Test(expected = NullPointerException.class) |
| public void testConstructor_NPE() { |
| new Magnifier(null); |
| } |
| |
| //***** Tests for builder *****// |
| |
| @Test |
| public void testBuilder_setsPropertiesCorrectly_whenTheyAreValid() { |
| final int magnifierWidth = 90; |
| final int magnifierHeight = 120; |
| final float zoom = 1.5f; |
| final int sourceToMagnifierHorizontalOffset = 10; |
| final int sourceToMagnifierVerticalOffset = -100; |
| final float cornerRadius = 20.0f; |
| final float elevation = 15.0f; |
| final boolean enableClipping = false; |
| final Drawable overlay = new ColorDrawable(Color.BLUE); |
| |
| final Magnifier.Builder builder = new Magnifier.Builder(mView) |
| .setSize(magnifierWidth, magnifierHeight) |
| .setInitialZoom(zoom) |
| .setDefaultSourceToMagnifierOffset(sourceToMagnifierHorizontalOffset, |
| sourceToMagnifierVerticalOffset) |
| .setCornerRadius(cornerRadius) |
| .setInitialZoom(zoom) |
| .setElevation(elevation) |
| .setOverlay(overlay) |
| .setClippingEnabled(enableClipping); |
| final Magnifier magnifier = builder.build(); |
| |
| assertEquals(magnifierWidth, magnifier.getWidth()); |
| assertEquals(magnifierHeight, magnifier.getHeight()); |
| assertEquals(zoom, magnifier.getZoom(), 0f); |
| assertEquals(Math.round(magnifierWidth / zoom), magnifier.getSourceWidth()); |
| assertEquals(Math.round(magnifierHeight / zoom), magnifier.getSourceHeight()); |
| assertEquals(sourceToMagnifierHorizontalOffset, |
| magnifier.getDefaultHorizontalSourceToMagnifierOffset()); |
| assertEquals(sourceToMagnifierVerticalOffset, |
| magnifier.getDefaultVerticalSourceToMagnifierOffset()); |
| assertEquals(cornerRadius, magnifier.getCornerRadius(), 0f); |
| assertEquals(elevation, magnifier.getElevation(), 0f); |
| assertEquals(enableClipping, magnifier.isClippingEnabled()); |
| assertEquals(overlay, magnifier.getOverlay()); |
| } |
| |
| @Test(expected = NullPointerException.class) |
| public void testBuilder_throwsException_whenViewIsNull() { |
| new Magnifier.Builder(null); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testBuilder_throwsException_whenWidthIsInvalid() { |
| new Magnifier.Builder(mView).setSize(0, 10); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testBuilder_throwsException_whenHeightIsInvalid() { |
| new Magnifier.Builder(mView).setSize(10, 0); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testBuilder_throwsException_whenZoomIsZero() { |
| new Magnifier.Builder(mView).setInitialZoom(0f); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testBuilder_throwsException_whenZoomIsNegative() { |
| new Magnifier.Builder(mView).setInitialZoom(-1f); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testBuilder_throwsException_whenElevationIsInvalid() { |
| new Magnifier.Builder(mView).setElevation(-1f); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testBuilder_throwsException_whenCornerRadiusIsNegative() { |
| new Magnifier.Builder(mView).setCornerRadius(-1f); |
| } |
| |
| //***** Tests for default parameters *****// |
| |
| private int dpToPixelSize(float dp) { |
| return (int) (dp * mDisplayMetrics.density + 0.5f); |
| } |
| |
| private float dpToPixel(float dp) { |
| return dp * mDisplayMetrics.density; |
| } |
| |
| @Test |
| public void testMagnifierDefaultParameters_withDeprecatedConstructor() { |
| final Magnifier magnifier = new Magnifier(mView); |
| |
| final int width = dpToPixelSize(100f); |
| assertEquals(width, magnifier.getWidth()); |
| final int height = dpToPixelSize(48f); |
| assertEquals(height, magnifier.getHeight()); |
| final float elevation = dpToPixel(4f); |
| assertEquals(elevation, magnifier.getElevation(), 0.01f); |
| final float zoom = 1.25f; |
| assertEquals(zoom, magnifier.getZoom(), 0.01f); |
| final int verticalOffset = -dpToPixelSize(42f); |
| assertEquals(verticalOffset, magnifier.getDefaultVerticalSourceToMagnifierOffset()); |
| final int horizontalOffset = dpToPixelSize(0f); |
| assertEquals(horizontalOffset, magnifier.getDefaultHorizontalSourceToMagnifierOffset()); |
| final Context deviceDefaultContext = new ContextThemeWrapper(mView.getContext(), |
| android.R.style.Theme_DeviceDefault); |
| final TypedArray ta = deviceDefaultContext.obtainStyledAttributes( |
| new int[]{android.R.attr.dialogCornerRadius}); |
| final float dialogCornerRadius = ta.getDimension(0, 0); |
| ta.recycle(); |
| assertEquals(dialogCornerRadius, magnifier.getCornerRadius(), 0.01f); |
| final boolean isClippingEnabled = true; |
| assertEquals(isClippingEnabled, magnifier.isClippingEnabled()); |
| final int overlayColor = 0x0EFFFFFF; |
| assertEquals(overlayColor, ((ColorDrawable) magnifier.getOverlay()).getColor()); |
| } |
| |
| @Test |
| public void testMagnifierDefaultParameters_withBuilder() { |
| final Magnifier magnifier = new Magnifier.Builder(mView).build(); |
| |
| final int width = dpToPixelSize(100f); |
| assertEquals(width, magnifier.getWidth()); |
| final int height = dpToPixelSize(48f); |
| assertEquals(height, magnifier.getHeight()); |
| final float elevation = dpToPixel(4f); |
| assertEquals(elevation, magnifier.getElevation(), 0.01f); |
| final float zoom = 1.25f; |
| assertEquals(zoom, magnifier.getZoom(), 0.01f); |
| final int verticalOffset = -dpToPixelSize(42f); |
| assertEquals(verticalOffset, magnifier.getDefaultVerticalSourceToMagnifierOffset()); |
| final int horizontalOffset = dpToPixelSize(0f); |
| assertEquals(horizontalOffset, magnifier.getDefaultHorizontalSourceToMagnifierOffset()); |
| final float dialogCornerRadius = dpToPixel(2f); |
| assertEquals(dialogCornerRadius, magnifier.getCornerRadius(), 0.01f); |
| final boolean isClippingEnabled = true; |
| assertEquals(isClippingEnabled, magnifier.isClippingEnabled()); |
| final int overlayColor = 0x00FFFFFF; |
| assertEquals(overlayColor, ((ColorDrawable) magnifier.getOverlay()).getColor()); |
| } |
| |
| @Test |
| @UiThreadTest |
| public void testSizeAndZoom_areValid() { |
| mMagnifier = new Magnifier(mView); |
| // Size should be positive. |
| assertTrue(mMagnifier.getWidth() > 0); |
| assertTrue(mMagnifier.getHeight() > 0); |
| // Source size should be positive. |
| assertTrue(mMagnifier.getSourceWidth() > 0); |
| assertTrue(mMagnifier.getSourceHeight() > 0); |
| // The magnified view region should be zoomed in, not out. |
| assertTrue(mMagnifier.getZoom() > 1.0f); |
| } |
| |
| |
| //***** Tests for #show() *****// |
| |
| @Test |
| public void testShow() throws Throwable { |
| final float xCenter = mView.getWidth() / 2f; |
| final float yCenter = mView.getHeight() / 2f; |
| showMagnifier(xCenter, yCenter); |
| |
| final int[] viewLocationInWindow = new int[2]; |
| mView.getLocationInWindow(viewLocationInWindow); |
| |
| // Check the coordinates of the content being copied. |
| final Point sourcePosition = mMagnifier.getSourcePosition(); |
| assertNotNull(sourcePosition); |
| assertEquals(xCenter + viewLocationInWindow[0], |
| sourcePosition.x + mMagnifier.getSourceWidth() / 2f, PIXEL_COMPARISON_DELTA); |
| assertEquals(yCenter + viewLocationInWindow[1], |
| sourcePosition.y + mMagnifier.getSourceHeight() / 2f, PIXEL_COMPARISON_DELTA); |
| |
| // Check the coordinates of the magnifier. |
| final Point magnifierPosition = mMagnifier.getPosition(); |
| assertNotNull(magnifierPosition); |
| assertEquals(sourcePosition.x + mMagnifier.getDefaultHorizontalSourceToMagnifierOffset() |
| - mMagnifier.getWidth() / 2f + mMagnifier.getSourceWidth() / 2f, |
| magnifierPosition.x, PIXEL_COMPARISON_DELTA); |
| assertEquals(sourcePosition.y + mMagnifier.getDefaultVerticalSourceToMagnifierOffset() |
| - mMagnifier.getHeight() / 2f + mMagnifier.getSourceHeight() / 2f, |
| magnifierPosition.y, PIXEL_COMPARISON_DELTA); |
| } |
| |
| @Test |
| public void testShow_doesNotCrash_whenCalledWithExtremeCoordinates() throws Throwable { |
| showMagnifier(Integer.MIN_VALUE, Integer.MIN_VALUE); |
| showMagnifier(Integer.MIN_VALUE, Integer.MAX_VALUE); |
| showMagnifier(Integer.MAX_VALUE, Integer.MIN_VALUE); |
| showMagnifier(Integer.MAX_VALUE, Integer.MAX_VALUE); |
| } |
| |
| @Test |
| public void testShow_withDecoupledMagnifierPosition() throws Throwable { |
| final float xCenter = mView.getWidth() / 2; |
| final float yCenter = mView.getHeight() / 2; |
| |
| final int xMagnifier = -20; |
| final int yMagnifier = -10; |
| showMagnifier(xCenter, yCenter, xMagnifier, yMagnifier); |
| |
| final int[] viewLocationInWindow = new int[2]; |
| mView.getLocationInWindow(viewLocationInWindow); |
| final Point magnifierPosition = mMagnifier.getPosition(); |
| assertNotNull(magnifierPosition); |
| assertEquals( |
| viewLocationInWindow[0] + xMagnifier - mMagnifier.getWidth() / 2, |
| magnifierPosition.x, PIXEL_COMPARISON_DELTA); |
| assertEquals( |
| viewLocationInWindow[1] + yMagnifier - mMagnifier.getHeight() / 2, |
| magnifierPosition.y, PIXEL_COMPARISON_DELTA); |
| } |
| |
| @Test |
| public void testShow_whenPixelCopyFails() throws Throwable { |
| WidgetTestUtils.runOnMainAndLayoutSync(mActivityRule, () -> { |
| mActivity.setContentView(R.layout.magnifier_activity_centered_surfaceview_layout); |
| }, false /*forceLayout*/); |
| final View view = mActivity.findViewById(R.id.magnifier_centered_view); |
| |
| runOnUiThreadAndWaitForCompletion(() -> mMagnifier = new Magnifier.Builder(view).build()); |
| // The PixelCopy will fail as no draw has been done so far to the SurfaceView. |
| showMagnifier(0f, 0f); |
| |
| assertNull(mMagnifier.getPosition()); |
| assertNull(mMagnifier.getSourcePosition()); |
| assertNull(mMagnifier.getContent()); |
| } |
| |
| //***** Tests for #dismiss() *****// |
| |
| @Test |
| public void testDismiss_doesNotCrash() throws Throwable { |
| showMagnifier(0, 0); |
| final CountDownLatch latch = new CountDownLatch(1); |
| mActivityRule.runOnUiThread(() -> { |
| mMagnifier.dismiss(); |
| mMagnifier.dismiss(); |
| mMagnifier.show(0, 0); |
| mMagnifier.dismiss(); |
| mMagnifier.dismiss(); |
| latch.countDown(); |
| }); |
| assertTrue(TIME_LIMIT_EXCEEDED, latch.await(2, TimeUnit.SECONDS)); |
| } |
| |
| //***** Tests for #update() *****// |
| |
| @Test |
| public void testUpdate_doesNotCrash() throws Throwable { |
| showMagnifier(0, 0); |
| final CountDownLatch latch = new CountDownLatch(1); |
| mActivityRule.runOnUiThread(() -> { |
| mMagnifier.update(); |
| mMagnifier.update(); |
| mMagnifier.show(10, 10); |
| mMagnifier.update(); |
| mMagnifier.update(); |
| mMagnifier.dismiss(); |
| mMagnifier.update(); |
| latch.countDown(); |
| }); |
| assertTrue(TIME_LIMIT_EXCEEDED, latch.await(2, TimeUnit.SECONDS)); |
| } |
| |
| @Test |
| public void testMagnifierContent_refreshesAfterUpdate() throws Throwable { |
| prepareFourQuadrantsScenario(); |
| |
| // Show the magnifier at the center of the activity. |
| showMagnifier(mLayout.getWidth() / 2, mLayout.getHeight() / 2); |
| |
| final Bitmap initialBitmap = mMagnifier.getContent() |
| .copy(mMagnifier.getContent().getConfig(), true); |
| assertFourQuadrants(initialBitmap); |
| |
| // Make the one quadrant white. |
| final View quadrant1 = |
| mActivity.findViewById(R.id.magnifier_activity_four_quadrants_layout_quadrant_1); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, quadrant1, () -> { |
| quadrant1.setBackground(null); |
| }); |
| |
| // Update the magnifier. |
| runAndWaitForMagnifierOperationComplete(mMagnifier::update); |
| |
| final Bitmap newBitmap = mMagnifier.getContent(); |
| assertFourQuadrants(newBitmap); |
| assertFalse(newBitmap.sameAs(initialBitmap)); |
| } |
| |
| //***** Tests for the position of the magnifier *****// |
| |
| @Test |
| public void testWindowPosition_isClampedInsideMainApplicationWindow_topLeft() throws Throwable { |
| prepareFourQuadrantsScenario(); |
| |
| // Magnify the center of the activity in a magnifier outside bounds. |
| showMagnifier(mLayout.getWidth() / 2, mLayout.getHeight() / 2, |
| -mMagnifier.getWidth(), -mMagnifier.getHeight()); |
| |
| // The window should have been positioned to the top left of the activity, |
| // such that it does not overlap system insets. |
| final Insets systemInsets = mLayout.getRootWindowInsets().getSystemWindowInsets(); |
| final Point magnifierCoords = mMagnifier.getPosition(); |
| assertNotNull(magnifierCoords); |
| assertEquals(systemInsets.left, magnifierCoords.x, PIXEL_COMPARISON_DELTA); |
| assertEquals(systemInsets.top, magnifierCoords.y, PIXEL_COMPARISON_DELTA); |
| } |
| |
| @Test |
| public void testWindowPosition_isClampedInsideMainApplicationWindow_bottomRight() |
| throws Throwable { |
| prepareFourQuadrantsScenario(); |
| |
| // Magnify the center of the activity in a magnifier outside bounds. |
| showMagnifier(mLayout.getWidth() / 2, mLayout.getHeight() / 2, |
| mLayout.getRootView().getWidth() + mMagnifier.getWidth(), |
| mLayout.getRootView().getHeight() + mMagnifier.getHeight()); |
| |
| // The window should have been positioned to the bottom right of the activity. |
| final Insets systemInsets = mLayout.getRootWindowInsets().getSystemWindowInsets(); |
| final Point magnifierCoords = mMagnifier.getPosition(); |
| assertNotNull(magnifierCoords); |
| assertEquals(mLayout.getRootView().getWidth() |
| - systemInsets.right - mMagnifier.getWidth(), |
| magnifierCoords.x, PIXEL_COMPARISON_DELTA); |
| assertEquals(mLayout.getRootView().getHeight() |
| - systemInsets.bottom - mMagnifier.getHeight(), |
| magnifierCoords.y, PIXEL_COMPARISON_DELTA); |
| } |
| |
| @Test |
| public void testWindowPosition_isNotClamped_whenClampingFlagIsOff_topLeft() throws Throwable { |
| prepareFourQuadrantsScenario(); |
| mMagnifier = new Magnifier.Builder(mLayout) |
| .setClippingEnabled(false) |
| .build(); |
| |
| // Magnify the center of the activity in a magnifier outside bounds. |
| showMagnifier(mLayout.getWidth() / 2, mLayout.getHeight() / 2, |
| -mMagnifier.getWidth(), -mMagnifier.getHeight()); |
| |
| // The window should have not been clamped. |
| final Point magnifierCoords = mMagnifier.getPosition(); |
| final int[] magnifiedViewPosition = new int[2]; |
| mLayout.getLocationInWindow(magnifiedViewPosition); |
| assertNotNull(magnifierCoords); |
| assertEquals(magnifiedViewPosition[0] - 3 * mMagnifier.getWidth() / 2, magnifierCoords.x, |
| PIXEL_COMPARISON_DELTA); |
| assertEquals(magnifiedViewPosition[1] - 3 * mMagnifier.getHeight() / 2, magnifierCoords.y, |
| PIXEL_COMPARISON_DELTA); |
| } |
| |
| @Test |
| public void testWindowPosition_isNotClamped_whenClampingFlagIsOff_bottomRight() |
| throws Throwable { |
| prepareFourQuadrantsScenario(); |
| mMagnifier = new Magnifier.Builder(mLayout) |
| .setClippingEnabled(false) |
| .setSize(40, 40) |
| .build(); |
| |
| // Magnify the center of the activity in a magnifier outside bounds. |
| showMagnifier(mLayout.getWidth() / 2, mLayout.getHeight() / 2, |
| mLayout.getRootView().getWidth() + mMagnifier.getWidth(), |
| mLayout.getRootView().getHeight() + mMagnifier.getHeight()); |
| |
| // The window should have not been clamped. |
| final Point magnifierCoords = mMagnifier.getPosition(); |
| final int[] magnifiedViewPosition = new int[2]; |
| mLayout.getLocationInWindow(magnifiedViewPosition); |
| assertNotNull(magnifierCoords); |
| assertEquals(magnifiedViewPosition[0] + mLayout.getRootView().getWidth() |
| + mMagnifier.getWidth() / 2, magnifierCoords.x, PIXEL_COMPARISON_DELTA); |
| assertEquals(magnifiedViewPosition[1] + mLayout.getRootView().getHeight() |
| + mMagnifier.getHeight() / 2, magnifierCoords.y, PIXEL_COMPARISON_DELTA); |
| } |
| |
| @Test |
| public void testWindowPosition_isCorrect_whenADefaultContentToMagnifierOffsetIsUsed() |
| throws Throwable { |
| prepareFourQuadrantsScenario(); |
| final int horizontalOffset = 5; |
| final int verticalOffset = -10; |
| mMagnifier = new Magnifier.Builder(mLayout) |
| .setSize(20, 10) /* make magnifier small to avoid having it clamped */ |
| .setDefaultSourceToMagnifierOffset(horizontalOffset, verticalOffset) |
| .build(); |
| |
| // Magnify the center of the activity in a magnifier outside bounds. |
| showMagnifier(mLayout.getWidth() / 2, mLayout.getHeight() / 2); |
| |
| final Point magnifierCoords = mMagnifier.getPosition(); |
| final Point sourceCoords = mMagnifier.getSourcePosition(); |
| assertNotNull(magnifierCoords); |
| assertEquals(sourceCoords.x + mMagnifier.getSourceWidth() / 2f + horizontalOffset, |
| magnifierCoords.x + mMagnifier.getWidth() / 2f, PIXEL_COMPARISON_DELTA); |
| assertEquals(sourceCoords.y + mMagnifier.getSourceHeight() / 2f + verticalOffset, |
| magnifierCoords.y + mMagnifier.getHeight() / 2f, PIXEL_COMPARISON_DELTA); |
| } |
| |
| @Test |
| @UiThreadTest |
| public void testWindowPosition_isNull_whenMagnifierIsNotShowing() { |
| mMagnifier = new Magnifier.Builder(mLayout) |
| .setSize(20, 10) /* make magnifier small to avoid having it clamped */ |
| .build(); |
| |
| // No #show has been requested, so the position should be null. |
| assertNull(mMagnifier.getPosition()); |
| // #show should make the position not null. |
| mMagnifier.show(0, 0); |
| assertNotNull(mMagnifier.getPosition()); |
| // #dismiss should make the position null. |
| mMagnifier.dismiss(); |
| assertNull(mMagnifier.getPosition()); |
| } |
| |
| //***** Tests for the position of the content copied to the magnifier *****// |
| |
| @Test |
| @UiThreadTest |
| public void testSourcePosition_isNull_whenMagnifierIsNotShowing() { |
| mMagnifier = new Magnifier.Builder(mLayout) |
| .setSize(20, 10) /* make magnifier small to avoid having it clamped */ |
| .build(); |
| |
| // No #show has been requested, so the source position should be null. |
| assertNull(mMagnifier.getSourcePosition()); |
| // #show should make the source position not null. |
| mMagnifier.show(0, 0); |
| assertNotNull(mMagnifier.getSourcePosition()); |
| // #dismiss should make the source position null. |
| mMagnifier.dismiss(); |
| assertNull(mMagnifier.getSourcePosition()); |
| } |
| |
| @Test |
| public void testSourcePosition_respectsMaxVisibleBounds_inHorizontalScrollableContainer() |
| throws Throwable { |
| WidgetTestUtils.runOnMainAndLayoutSync(mActivityRule, () -> { |
| mActivity.setContentView(R.layout.magnifier_activity_scrollable_views_layout); |
| }, false /*forceLayout*/); |
| final View view = mActivity |
| .findViewById(R.id.magnifier_activity_horizontally_scrolled_view); |
| final HorizontalScrollView container = (HorizontalScrollView) mActivity |
| .findViewById(R.id.horizontal_scroll_container); |
| final Magnifier.Builder builder = new Magnifier.Builder(view) |
| .setSize(100, 100) |
| .setInitialZoom(20f) /* 5x5 source size */ |
| .setSourceBounds( |
| Magnifier.SOURCE_BOUND_MAX_VISIBLE, |
| Magnifier.SOURCE_BOUND_MAX_IN_SURFACE, |
| Magnifier.SOURCE_BOUND_MAX_VISIBLE, |
| Magnifier.SOURCE_BOUND_MAX_IN_SURFACE |
| ); |
| |
| runOnUiThreadAndWaitForCompletion(() -> { |
| mMagnifier = builder.build(); |
| // Scroll halfway horizontally. |
| container.scrollTo(view.getWidth() / 2, 0); |
| }); |
| |
| final int[] containerPosition = new int[2]; |
| container.getLocationInWindow(containerPosition); |
| |
| // Try to copy from an x to the left of the currently visible region. |
| showMagnifier(view.getWidth() / 4, 0); |
| Point sourcePosition = mMagnifier.getSourcePosition(); |
| assertNotNull(sourcePosition); |
| assertEquals(containerPosition[0], sourcePosition.x, PIXEL_COMPARISON_DELTA); |
| |
| // Try to copy from an x to the right of the currently visible region. |
| showMagnifier(3 * view.getWidth() / 4, 0); |
| sourcePosition = mMagnifier.getSourcePosition(); |
| assertNotNull(sourcePosition); |
| assertEquals(containerPosition[0] + container.getWidth() - mMagnifier.getSourceWidth(), |
| sourcePosition.x, PIXEL_COMPARISON_DELTA); |
| } |
| |
| @Test |
| public void testSourcePosition_respectsMaxVisibleBounds_inVerticalScrollableContainer() |
| throws Throwable { |
| WidgetTestUtils.runOnMainAndLayoutSync(mActivityRule, () -> { |
| mActivity.setContentView(R.layout.magnifier_activity_scrollable_views_layout); |
| }, false /*forceLayout*/); |
| final View view = mActivity.findViewById(R.id.magnifier_activity_vertically_scrolled_view); |
| final ScrollView container = (ScrollView) mActivity |
| .findViewById(R.id.vertical_scroll_container); |
| final Magnifier.Builder builder = new Magnifier.Builder(view) |
| .setSize(100, 100) |
| .setInitialZoom(10f) /* 10x10 source size */ |
| .setSourceBounds( |
| Magnifier.SOURCE_BOUND_MAX_IN_SURFACE, |
| Magnifier.SOURCE_BOUND_MAX_VISIBLE, |
| Magnifier.SOURCE_BOUND_MAX_IN_SURFACE, |
| Magnifier.SOURCE_BOUND_MAX_VISIBLE |
| ); |
| |
| runOnUiThreadAndWaitForCompletion(() -> { |
| mMagnifier = builder.build(); |
| // Scroll halfway vertically. |
| container.scrollTo(0, view.getHeight() / 2); |
| }); |
| |
| final int[] containerPosition = new int[2]; |
| container.getLocationInWindow(containerPosition); |
| |
| // Try to copy from an y above the currently visible region. |
| showMagnifier(0, view.getHeight() / 4); |
| Point sourcePosition = mMagnifier.getSourcePosition(); |
| assertNotNull(sourcePosition); |
| assertEquals(containerPosition[1], sourcePosition.y, PIXEL_COMPARISON_DELTA); |
| |
| // Try to copy from an x below the currently visible region. |
| showMagnifier(0, 3 * view.getHeight() / 4); |
| sourcePosition = mMagnifier.getSourcePosition(); |
| assertNotNull(sourcePosition); |
| assertEquals(containerPosition[1] + container.getHeight() - mMagnifier.getSourceHeight(), |
| sourcePosition.y, PIXEL_COMPARISON_DELTA); |
| } |
| |
| @Test |
| public void testSourcePosition_respectsMaxInSurfaceBounds() throws Throwable { |
| WidgetTestUtils.runOnMainAndLayoutSync(mActivityRule, () -> { |
| mActivity.setContentView(R.layout.magnifier_activity_centered_view_layout); |
| }, false /*forceLayout*/); |
| final View view = mActivity.findViewById(R.id.magnifier_centered_view); |
| final Magnifier.Builder builder = new Magnifier.Builder(view) |
| .setSize(100, 100) |
| .setInitialZoom(5f) /* 20x20 source size */ |
| .setSourceBounds( |
| Magnifier.SOURCE_BOUND_MAX_IN_SURFACE, |
| Magnifier.SOURCE_BOUND_MAX_IN_SURFACE, |
| Magnifier.SOURCE_BOUND_MAX_IN_SURFACE, |
| Magnifier.SOURCE_BOUND_MAX_IN_SURFACE |
| ); |
| |
| runOnUiThreadAndWaitForCompletion(() -> mMagnifier = builder.build()); |
| |
| final int[] viewPosition = new int[2]; |
| view.getLocationInWindow(viewPosition); |
| |
| // Copy content centered on relative position (0, 0) and expect the top left |
| // corner of the source NOT to have been pulled to coincide with (0, 0) of the view. |
| showMagnifier(0, 0); |
| Point sourcePosition = mMagnifier.getSourcePosition(); |
| assertNotNull(sourcePosition); |
| assertEquals(viewPosition[0] - mMagnifier.getSourceWidth() / 2, sourcePosition.x, |
| PIXEL_COMPARISON_DELTA); |
| assertEquals(viewPosition[1] - mMagnifier.getSourceHeight() / 2, sourcePosition.y, |
| PIXEL_COMPARISON_DELTA); |
| |
| // Copy content centered on the bottom right corner of the view and expect the top left |
| // corner of the source NOT to have been pulled inside the view. |
| showMagnifier(view.getWidth(), view.getHeight()); |
| sourcePosition = mMagnifier.getSourcePosition(); |
| assertNotNull(sourcePosition); |
| assertEquals(viewPosition[0] + view.getWidth() - mMagnifier.getSourceWidth() / 2, |
| sourcePosition.x, PIXEL_COMPARISON_DELTA); |
| assertEquals(viewPosition[1] + view.getHeight() - mMagnifier.getSourceHeight() / 2, |
| sourcePosition.y, PIXEL_COMPARISON_DELTA); |
| |
| final int[] viewPositionInSurface = new int[2]; |
| view.getLocationInSurface(viewPositionInSurface); |
| // Copy content centered on the top left corner of the main app surface and expect the top |
| // left corner of the source to have been pulled to the top left corner of the surface. |
| showMagnifier(-viewPositionInSurface[0], -viewPositionInSurface[1]); |
| sourcePosition = mMagnifier.getSourcePosition(); |
| assertNotNull(sourcePosition); |
| assertEquals(0, sourcePosition.x - viewPosition[0] + viewPositionInSurface[0], |
| PIXEL_COMPARISON_DELTA); |
| assertEquals(0, sourcePosition.y - viewPosition[1] + viewPositionInSurface[1], |
| PIXEL_COMPARISON_DELTA); |
| |
| // Copy content below and to the right of the bottom right corner of the main app surface |
| // and expect the source to have been pulled inside the surface at its bottom right. |
| showMagnifier(2 * view.getRootView().getWidth(), 2 * view.getRootView().getHeight()); |
| sourcePosition = mMagnifier.getSourcePosition(); |
| assertNotNull(sourcePosition); |
| assertTrue( |
| sourcePosition.x < 2 * view.getRootView().getWidth() - mMagnifier.getSourceWidth()); |
| assertTrue(sourcePosition.x > view.getRootView().getWidth() - mMagnifier.getSourceWidth()); |
| assertTrue(sourcePosition.y |
| < 2 * view.getRootView().getHeight() - mMagnifier.getSourceHeight()); |
| assertTrue(sourcePosition.y |
| > view.getRootView().getHeight() - mMagnifier.getSourceHeight()); |
| } |
| |
| @Test |
| public void testSourcePosition_respectsMaxInSurfaceBounds_forSurfaceView() throws Throwable { |
| InstrumentationRegistry.getInstrumentation().waitForIdleSync(); |
| WidgetTestUtils.runOnMainAndLayoutSync(mActivityRule, () -> { |
| mActivity.setContentView(R.layout.magnifier_activity_centered_surfaceview_layout); |
| }, false /* forceLayout */); |
| WidgetTestUtils.runOnMainAndLayoutSync(mActivityRule, () -> { |
| // Draw something in the SurfaceView for the Magnifier to copy. |
| final View view = mActivity.findViewById(R.id.magnifier_centered_view); |
| final SurfaceHolder surfaceHolder = ((SurfaceView) view).getHolder(); |
| final Canvas canvas = surfaceHolder.lockHardwareCanvas(); |
| canvas.drawColor(Color.BLUE); |
| surfaceHolder.unlockCanvasAndPost(canvas); |
| }, false /* forceLayout */); |
| final View view = mActivity.findViewById(R.id.magnifier_centered_view); |
| final Magnifier.Builder builder = new Magnifier.Builder(view) |
| .setSize(100, 100) |
| .setInitialZoom(5f) /* 20x20 source size */ |
| .setSourceBounds( |
| Magnifier.SOURCE_BOUND_MAX_IN_SURFACE, |
| Magnifier.SOURCE_BOUND_MAX_IN_SURFACE, |
| Magnifier.SOURCE_BOUND_MAX_IN_SURFACE, |
| Magnifier.SOURCE_BOUND_MAX_IN_SURFACE |
| ); |
| |
| runOnUiThreadAndWaitForCompletion(() -> mMagnifier = builder.build()); |
| |
| // Copy content centered on relative position (0, 0) and expect the top left |
| // corner of the source to have been pulled to coincide with (0, 0) of the view |
| // (since the view coincides with the surface content is copied from). |
| showMagnifier(0, 0); |
| Point sourcePosition = mMagnifier.getSourcePosition(); |
| assertNotNull(sourcePosition); |
| assertEquals(0, sourcePosition.x, PIXEL_COMPARISON_DELTA); |
| assertEquals(0, sourcePosition.y, PIXEL_COMPARISON_DELTA); |
| |
| // Copy content centered on the bottom right corner of the view and expect the top left |
| // corner of the source to have been pulled inside the surface view. |
| showMagnifier(view.getWidth(), view.getHeight()); |
| sourcePosition = mMagnifier.getSourcePosition(); |
| assertNotNull(sourcePosition); |
| assertEquals(view.getWidth() - mMagnifier.getSourceWidth(), sourcePosition.x); |
| assertEquals(view.getHeight() - mMagnifier.getSourceHeight(), sourcePosition.y); |
| |
| // Copy content from the center of the surface view and expect no clamping to be done. |
| showMagnifier(view.getWidth() / 2, view.getHeight() / 2); |
| sourcePosition = mMagnifier.getSourcePosition(); |
| assertNotNull(sourcePosition); |
| assertEquals(view.getWidth() / 2 - mMagnifier.getSourceWidth() / 2, sourcePosition.x, |
| PIXEL_COMPARISON_DELTA); |
| assertEquals(view.getHeight() / 2 - mMagnifier.getSourceHeight() / 2, sourcePosition.y, |
| PIXEL_COMPARISON_DELTA); |
| } |
| |
| @Test |
| public void testSourceBounds_areAdjustedWhenInvalid() throws Throwable { |
| WidgetTestUtils.runOnMainAndLayoutSync(mActivityRule, () -> { |
| mActivity.setContentView(R.layout.magnifier_activity_centered_view_layout); |
| }, false /*forceLayout*/); |
| final View view = mActivity.findViewById(R.id.magnifier_centered_view); |
| final Insets systemInsets = view.getRootWindowInsets().getSystemWindowInsets(); |
| final Magnifier.Builder builder = new Magnifier.Builder(view) |
| .setSize(2 * view.getWidth() + systemInsets.right, |
| 2 * view.getHeight() + systemInsets.bottom) |
| .setInitialZoom(1f) /* source double the size of the view + right/bottom insets */ |
| .setSourceBounds(/* invalid bounds */ |
| Magnifier.SOURCE_BOUND_MAX_VISIBLE, |
| Magnifier.SOURCE_BOUND_MAX_VISIBLE, |
| Magnifier.SOURCE_BOUND_MAX_VISIBLE, |
| Magnifier.SOURCE_BOUND_MAX_VISIBLE |
| ); |
| |
| runOnUiThreadAndWaitForCompletion(() -> mMagnifier = builder.build()); |
| |
| final int[] viewPosition = new int[2]; |
| view.getLocationInWindow(viewPosition); |
| |
| // Make sure that the left and top bounds are respected, since this is possible |
| // for this source size, when the view is centered. |
| showMagnifier(0, 0); |
| Point sourcePosition = mMagnifier.getSourcePosition(); |
| assertEquals(viewPosition[0], sourcePosition.x, PIXEL_COMPARISON_DELTA); |
| assertEquals(viewPosition[1], sourcePosition.y, PIXEL_COMPARISON_DELTA); |
| |
| // Move the magnified view to the top left of the screen, and make sure that |
| // the top and left bounds are still respected. |
| mActivityRule.runOnUiThread(() -> { |
| final LinearLayout layout = |
| mActivity.findViewById(R.id.magnifier_activity_centered_view_layout); |
| layout.setGravity(Gravity.TOP | Gravity.LEFT); |
| }); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, view, null); |
| view.getLocationInWindow(viewPosition); |
| |
| showMagnifier(0, 0); |
| sourcePosition = mMagnifier.getSourcePosition(); |
| assertEquals(viewPosition[0], sourcePosition.x, PIXEL_COMPARISON_DELTA); |
| assertEquals(viewPosition[1], sourcePosition.y, PIXEL_COMPARISON_DELTA); |
| |
| // Move the magnified view to the bottom right of the layout, and expect the top and left |
| // bounds to have been shifted such that the source sits inside the surface. |
| mActivityRule.runOnUiThread(() -> { |
| final LinearLayout layout = |
| mActivity.findViewById(R.id.magnifier_activity_centered_view_layout); |
| layout.setGravity(Gravity.BOTTOM | Gravity.RIGHT); |
| }); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, view, null); |
| view.getLocationInSurface(viewPosition); |
| |
| showMagnifier(0, 0); |
| sourcePosition = mMagnifier.getSourcePosition(); |
| assertEquals(viewPosition[0] - view.getWidth(), sourcePosition.x, PIXEL_COMPARISON_DELTA); |
| assertEquals(viewPosition[1] - view.getHeight(), sourcePosition.y, PIXEL_COMPARISON_DELTA); |
| } |
| |
| //***** Tests for zoom change *****// |
| |
| @Test |
| public void testZoomChange() throws Throwable { |
| // Setup. |
| final View view = new View(mActivity); |
| final int width = 300; |
| final int height = 270; |
| final Magnifier.Builder builder = new Magnifier.Builder(view) |
| .setSize(width, height) |
| .setInitialZoom(1.0f); |
| mMagnifier = builder.build(); |
| final float newZoom = 1.5f; |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, view, () -> { |
| mLayout.addView(view, new LayoutParams(200, 200)); |
| mMagnifier.setZoom(newZoom); |
| }); |
| assertEquals((int) (width / newZoom), mMagnifier.getSourceWidth()); |
| assertEquals((int) (height / newZoom), mMagnifier.getSourceHeight()); |
| |
| // Show. |
| showMagnifier(200, 200); |
| |
| // Check bitmap size. |
| assertNotNull(mMagnifier.getOriginalContent()); |
| assertEquals((int) (width / newZoom), mMagnifier.getOriginalContent().getWidth()); |
| assertEquals((int) (height / newZoom), mMagnifier.getOriginalContent().getHeight()); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testZoomChange_throwsException_whenZoomIsZero() { |
| final View view = new View(mActivity); |
| new Magnifier(view).setZoom(0f); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testZoomChange_throwsException_whenZoomIsNegative() { |
| final View view = new View(mActivity); |
| new Magnifier(view).setZoom(-1f); |
| } |
| |
| //***** Tests for overlay *****// |
| |
| @Test |
| public void testOverlay_isDrawn() throws Throwable { |
| final Magnifier.Builder builder = new Magnifier.Builder(mView) |
| .setSize(50, 50) |
| .setOverlay(new ColorDrawable(Color.BLUE)); |
| runOnUiThreadAndWaitForCompletion(() -> mMagnifier = builder.build()); |
| |
| showMagnifier(0, 0); |
| // Assert that the content has the correct size and is all blue. |
| final Bitmap content = mMagnifier.getContent(); |
| assertNotNull(content); |
| assertEquals(mMagnifier.getWidth(), content.getWidth()); |
| assertEquals(mMagnifier.getHeight(), content.getHeight()); |
| for (int i = 0; i < content.getWidth(); ++i) { |
| for (int j = 0; j < content.getHeight(); ++j) { |
| assertEquals(Color.BLUE, content.getPixel(i, j)); |
| } |
| } |
| } |
| |
| @Test |
| public void testOverlay_redrawsOnInvalidation() throws Throwable { |
| final ColorDrawable overlay = new ColorDrawable(Color.BLUE); |
| final Magnifier.Builder builder = new Magnifier.Builder(mView) |
| .setSize(50, 50) |
| .setOverlay(overlay); |
| runOnUiThreadAndWaitForCompletion(() -> mMagnifier = builder.build()); |
| |
| showMagnifier(0, 0); |
| overlay.setColor(Color.WHITE); |
| // Assert that the content has the correct size and is all blue. |
| final Bitmap content = mMagnifier.getContent(); |
| assertNotNull(content); |
| assertEquals(mMagnifier.getWidth(), content.getWidth()); |
| assertEquals(mMagnifier.getHeight(), content.getHeight()); |
| for (int i = 0; i < content.getWidth(); ++i) { |
| for (int j = 0; j < content.getHeight(); ++j) { |
| assertEquals(Color.WHITE, content.getPixel(i, j)); |
| } |
| } |
| } |
| |
| @Test |
| public void testOverlay_isNotVisible_whenSetToNull() throws Throwable { |
| final Magnifier.Builder builder = new Magnifier.Builder(mView) |
| .setSize(50, 50) |
| .setInitialZoom(10f) /* 5x5 source size */ |
| .setOverlay(null); |
| runOnUiThreadAndWaitForCompletion(() -> mMagnifier = builder.build()); |
| |
| showMagnifier(mView.getWidth() / 2, mView.getHeight() / 2); |
| // Assert that the content has the correct size and is all the view color. |
| final Bitmap content = mMagnifier.getContent(); |
| assertNotNull(content); |
| assertEquals(mMagnifier.getWidth(), content.getWidth()); |
| assertEquals(mMagnifier.getHeight(), content.getHeight()); |
| final int viewColor = mView.getContext().getResources().getColor( |
| android.R.color.holo_blue_bright, null); |
| for (int i = 0; i < content.getWidth(); ++i) { |
| for (int j = 0; j < content.getHeight(); ++j) { |
| assertEquals(viewColor, content.getPixel(i, j)); |
| } |
| } |
| } |
| |
| //***** Helper methods / classes *****// |
| |
| private void showMagnifier(float sourceX, float sourceY) throws Throwable { |
| runAndWaitForMagnifierOperationComplete(() -> mMagnifier.show(sourceX, sourceY)); |
| } |
| |
| private void showMagnifier(float sourceX, float sourceY, float magnifierX, float magnifierY) |
| throws Throwable { |
| runAndWaitForMagnifierOperationComplete(() -> mMagnifier.show(sourceX, sourceY, |
| magnifierX, magnifierY)); |
| } |
| |
| private void runAndWaitForMagnifierOperationComplete(final Runnable lambda) throws Throwable { |
| final CountDownLatch latch = new CountDownLatch(1); |
| mMagnifier.setOnOperationCompleteCallback(latch::countDown); |
| mActivityRule.runOnUiThread(lambda); |
| assertTrue(TIME_LIMIT_EXCEEDED, latch.await(2, TimeUnit.SECONDS)); |
| } |
| |
| private void runOnUiThreadAndWaitForCompletion(final Runnable lambda) throws Throwable { |
| final CountDownLatch latch = new CountDownLatch(1); |
| mActivityRule.runOnUiThread(() -> { |
| lambda.run(); |
| latch.countDown(); |
| }); |
| assertTrue(TIME_LIMIT_EXCEEDED, latch.await(2, TimeUnit.SECONDS)); |
| } |
| |
| /** |
| * Sets the activity to contain four equal quadrants coloured differently and |
| * instantiates a magnifier. This method should not be called on the UI thread. |
| */ |
| private void prepareFourQuadrantsScenario() throws Throwable { |
| WidgetTestUtils.runOnMainAndLayoutSync(mActivityRule, () -> { |
| mActivity.setContentView(R.layout.magnifier_activity_four_quadrants_layout); |
| mLayout = mActivity.findViewById(R.id.magnifier_activity_four_quadrants_layout); |
| mMagnifier = new Magnifier(mLayout); |
| }, false /*forceLayout*/); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mLayout, null); |
| } |
| |
| /** |
| * Asserts that the current bitmap contains four different dominant colors, which |
| * are (almost) equally distributed. The test takes into account an amount of |
| * noise, possible consequence of upscaling and filtering the magnified content. |
| * |
| * @param bitmap the bitmap to be checked |
| */ |
| private void assertFourQuadrants(final Bitmap bitmap) { |
| final int expectedQuadrants = 4; |
| final int totalPixels = bitmap.getWidth() * bitmap.getHeight(); |
| |
| final Map<Integer, Integer> colorCount = new HashMap<>(); |
| for (int x = 0; x < bitmap.getWidth(); ++x) { |
| for (int y = 0; y < bitmap.getHeight(); ++y) { |
| final int currentColor = bitmap.getPixel(x, y); |
| colorCount.put(currentColor, colorCount.getOrDefault(currentColor, 0) + 1); |
| } |
| } |
| assertTrue(colorCount.size() >= expectedQuadrants); |
| |
| final List<Integer> counts = new ArrayList<>(colorCount.values()); |
| Collections.sort(counts); |
| |
| int quadrantsTotal = 0; |
| for (int i = counts.size() - expectedQuadrants; i < counts.size(); ++i) { |
| quadrantsTotal += counts.get(i); |
| } |
| assertTrue(1.0f * (totalPixels - quadrantsTotal) / totalPixels <= 0.1f); |
| |
| for (int i = counts.size() - expectedQuadrants; i < counts.size(); ++i) { |
| final float proportion = 1.0f |
| * Math.abs(expectedQuadrants * counts.get(i) - quadrantsTotal) / quadrantsTotal; |
| assertTrue(proportion <= 0.1f); |
| } |
| } |
| } |
