tests/tests/widget/src/android/widget/cts/MagnifierTest.java - platform/cts - Git at Google

 /*
  * 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.assertTrue;
 import static org.junit.Assume.assumeTrue;

 import android.app.Activity;
 import android.graphics.Bitmap;
 import android.graphics.PointF;
 import android.graphics.Rect;
 import android.support.test.annotation.UiThreadTest;
 import android.support.test.filters.SmallTest;
 import android.support.test.rule.ActivityTestRule;
 import android.support.test.runner.AndroidJUnit4;
 import android.util.DisplayMetrics;
 import android.view.View;
 import android.widget.LinearLayout;
 import android.widget.LinearLayout.LayoutParams;
 import android.widget.Magnifier;

 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 Activity mActivity;
     private LinearLayout mLayout;
     private Magnifier mMagnifier;

     @Rule
     public ActivityTestRule<MagnifierCtsActivity> mActivityRule =
             new ActivityTestRule<>(MagnifierCtsActivity.class);

     @Before
     public void setup() {
         mActivity = mActivityRule.getActivity();
         PollingCheck.waitFor(mActivity::hasWindowFocus);
         mLayout = mActivity.findViewById(R.id.magnifier_activity_basic_layout);

         // Do not run the tests, unless the device screen is big enough to fit the magnifier.
         assumeTrue(isScreenBigEnough());
     }

     private boolean isScreenBigEnough() {
         // Get the size of the screen in dp.
         final DisplayMetrics displayMetrics = mActivity.getResources().getDisplayMetrics();
         final float dpScreenWidth = displayMetrics.widthPixels / displayMetrics.density;
         final float dpScreenHeight = displayMetrics.heightPixels / displayMetrics.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;
     }

     @Test
     public void testConstructor() {
         new Magnifier(new View(mActivity));
     }

     @Test(expected = NullPointerException.class)
     public void testConstructor_NPE() {
         new Magnifier(null);
     }

     @Test
     @UiThreadTest
     public void testShow() {
         final View view = new View(mActivity);
         mLayout.addView(view, new LayoutParams(200, 200));
         mMagnifier = new Magnifier(view);
         // Valid coordinates.
         mMagnifier.show(0, 0);
         // Invalid coordinates, should both be clamped to 0.
         mMagnifier.show(-1, -1);
         // Valid coordinates.
         mMagnifier.show(10, 10);
         // Same valid coordinate as above, should skip making another copy request.
         mMagnifier.show(10, 10);
     }

     @Test
     @UiThreadTest
     public void testDismiss() {
         final View view = new View(mActivity);
         mLayout.addView(view, new LayoutParams(200, 200));
         mMagnifier = new Magnifier(view);
         // Valid coordinates.
         mMagnifier.show(10, 10);
         mMagnifier.dismiss();
         // Should be no-op.
         mMagnifier.dismiss();
     }

     @Test
     @UiThreadTest
     public void testUpdate() {
         final View view = new View(mActivity);
         mLayout.addView(view, new LayoutParams(200, 200));
         mMagnifier = new Magnifier(view);
         // Should be no-op.
         mMagnifier.update();
         // Valid coordinates.
         mMagnifier.show(10, 10);
         // Should not crash.
         mMagnifier.update();
         mMagnifier.dismiss();
         // Should be no-op.
         mMagnifier.update();
     }

     @Test
     @UiThreadTest
     public void testSizeAndZoom_areValid() {
         final View view = new View(mActivity);
         mLayout.addView(view, new LayoutParams(200, 200));
         mMagnifier = new Magnifier(view);
         mMagnifier.show(10, 10);
         // Size should be non-zero.
         assertTrue(mMagnifier.getWidth() > 0);
         assertTrue(mMagnifier.getHeight() > 0);
         // The magnified view region should be zoomed in, not out.
         assertTrue(mMagnifier.getZoom() > 1.0f);
     }

     @Test
     public void testWindowContent() throws Throwable {
         prepareFourQuadrantsScenario();
         final CountDownLatch latch = new CountDownLatch(1);
         mMagnifier.setOnOperationCompleteCallback(latch::countDown);

         // Show the magnifier at the center of the activity.
         mActivityRule.runOnUiThread(() -> {
             mMagnifier.show(mLayout.getWidth() / 2, mLayout.getHeight() / 2);
         });
         assertTrue(TIME_LIMIT_EXCEEDED, latch.await(1, TimeUnit.SECONDS));

         assertEquals(mMagnifier.getWidth(), mMagnifier.getContent().getWidth());
         assertEquals(mMagnifier.getHeight(), mMagnifier.getContent().getHeight());
         assertFourQuadrants(mMagnifier.getContent());
     }

     @Test
     public void testWindowPosition() throws Throwable {
         prepareFourQuadrantsScenario();
         final CountDownLatch latch = new CountDownLatch(1);
         mMagnifier.setOnOperationCompleteCallback(latch::countDown);

         // Show the magnifier at the center of the activity.
         mActivityRule.runOnUiThread(() -> {
             mMagnifier.show(mLayout.getWidth() / 2, mLayout.getHeight() / 2);
         });
         assertTrue(TIME_LIMIT_EXCEEDED, latch.await(1, TimeUnit.SECONDS));

         // Assert that the magnifier position represents a valid rectangle on screen.
         final Rect position = mMagnifier.getWindowPositionOnScreen();
         assertFalse(position.isEmpty());
         assertTrue(0 <= position.left && position.right <= mLayout.getWidth());
         assertTrue(0 <= position.top && position.bottom <= mLayout.getHeight());
     }

     @Test
     public void testWindowContent_modifiesAfterUpdate() throws Throwable {
         prepareFourQuadrantsScenario();

         // Show the magnifier at the center of the activity.
         final CountDownLatch latchForShow = new CountDownLatch(1);
         mMagnifier.setOnOperationCompleteCallback(latchForShow::countDown);
         mActivityRule.runOnUiThread(() -> {
             mMagnifier.show(mLayout.getWidth() / 2, mLayout.getHeight() / 2);
         });
         assertTrue(TIME_LIMIT_EXCEEDED, latchForShow.await(1, TimeUnit.SECONDS));

         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.
         final CountDownLatch latchForUpdate = new CountDownLatch(1);
         mMagnifier.setOnOperationCompleteCallback(latchForUpdate::countDown);
         mActivityRule.runOnUiThread(mMagnifier::update);
         assertTrue(TIME_LIMIT_EXCEEDED, latchForUpdate.await(1, TimeUnit.SECONDS));

         final Bitmap newBitmap = mMagnifier.getContent();
         assertFourQuadrants(newBitmap);
         assertFalse(newBitmap.sameAs(initialBitmap));
     }

     /**
      * 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);
         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);
         }
     }
 }
	/*
	* 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.assertTrue;
	import static org.junit.Assume.assumeTrue;

	import android.app.Activity;
	import android.graphics.Bitmap;
	import android.graphics.PointF;
	import android.graphics.Rect;
	import android.support.test.annotation.UiThreadTest;
	import android.support.test.filters.SmallTest;
	import android.support.test.rule.ActivityTestRule;
	import android.support.test.runner.AndroidJUnit4;
	import android.util.DisplayMetrics;
	import android.view.View;
	import android.widget.LinearLayout;
	import android.widget.LinearLayout.LayoutParams;
	import android.widget.Magnifier;

	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 Activity mActivity;
	private LinearLayout mLayout;
	private Magnifier mMagnifier;

	@Rule
	public ActivityTestRule<MagnifierCtsActivity> mActivityRule =
	new ActivityTestRule<>(MagnifierCtsActivity.class);

	@Before
	public void setup() {
	mActivity = mActivityRule.getActivity();
	PollingCheck.waitFor(mActivity::hasWindowFocus);
	mLayout = mActivity.findViewById(R.id.magnifier_activity_basic_layout);

	// Do not run the tests, unless the device screen is big enough to fit the magnifier.
	assumeTrue(isScreenBigEnough());
	}

	private boolean isScreenBigEnough() {
	// Get the size of the screen in dp.
	final DisplayMetrics displayMetrics = mActivity.getResources().getDisplayMetrics();
	final float dpScreenWidth = displayMetrics.widthPixels / displayMetrics.density;
	final float dpScreenHeight = displayMetrics.heightPixels / displayMetrics.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;
	}

	@Test
	public void testConstructor() {
	new Magnifier(new View(mActivity));
	}

	@Test(expected = NullPointerException.class)
	public void testConstructor_NPE() {
	new Magnifier(null);
	}

	@Test
	@UiThreadTest
	public void testShow() {
	final View view = new View(mActivity);
	mLayout.addView(view, new LayoutParams(200, 200));
	mMagnifier = new Magnifier(view);
	// Valid coordinates.
	mMagnifier.show(0, 0);
	// Invalid coordinates, should both be clamped to 0.
	mMagnifier.show(-1, -1);
	// Valid coordinates.
	mMagnifier.show(10, 10);
	// Same valid coordinate as above, should skip making another copy request.
	mMagnifier.show(10, 10);
	}

	@Test
	@UiThreadTest
	public void testDismiss() {
	final View view = new View(mActivity);
	mLayout.addView(view, new LayoutParams(200, 200));
	mMagnifier = new Magnifier(view);
	// Valid coordinates.
	mMagnifier.show(10, 10);
	mMagnifier.dismiss();
	// Should be no-op.
	mMagnifier.dismiss();
	}

	@Test
	@UiThreadTest
	public void testUpdate() {
	final View view = new View(mActivity);
	mLayout.addView(view, new LayoutParams(200, 200));
	mMagnifier = new Magnifier(view);
	// Should be no-op.
	mMagnifier.update();
	// Valid coordinates.
	mMagnifier.show(10, 10);
	// Should not crash.
	mMagnifier.update();
	mMagnifier.dismiss();
	// Should be no-op.
	mMagnifier.update();
	}

	@Test
	@UiThreadTest
	public void testSizeAndZoom_areValid() {
	final View view = new View(mActivity);
	mLayout.addView(view, new LayoutParams(200, 200));
	mMagnifier = new Magnifier(view);
	mMagnifier.show(10, 10);
	// Size should be non-zero.
	assertTrue(mMagnifier.getWidth() > 0);
	assertTrue(mMagnifier.getHeight() > 0);
	// The magnified view region should be zoomed in, not out.
	assertTrue(mMagnifier.getZoom() > 1.0f);
	}

	@Test
	public void testWindowContent() throws Throwable {
	prepareFourQuadrantsScenario();
	final CountDownLatch latch = new CountDownLatch(1);
	mMagnifier.setOnOperationCompleteCallback(latch::countDown);

	// Show the magnifier at the center of the activity.
	mActivityRule.runOnUiThread(() -> {
	mMagnifier.show(mLayout.getWidth() / 2, mLayout.getHeight() / 2);
	});
	assertTrue(TIME_LIMIT_EXCEEDED, latch.await(1, TimeUnit.SECONDS));

	assertEquals(mMagnifier.getWidth(), mMagnifier.getContent().getWidth());
	assertEquals(mMagnifier.getHeight(), mMagnifier.getContent().getHeight());
	assertFourQuadrants(mMagnifier.getContent());
	}

	@Test
	public void testWindowPosition() throws Throwable {
	prepareFourQuadrantsScenario();
	final CountDownLatch latch = new CountDownLatch(1);
	mMagnifier.setOnOperationCompleteCallback(latch::countDown);

	// Show the magnifier at the center of the activity.
	mActivityRule.runOnUiThread(() -> {
	mMagnifier.show(mLayout.getWidth() / 2, mLayout.getHeight() / 2);
	});
	assertTrue(TIME_LIMIT_EXCEEDED, latch.await(1, TimeUnit.SECONDS));

	// Assert that the magnifier position represents a valid rectangle on screen.
	final Rect position = mMagnifier.getWindowPositionOnScreen();
	assertFalse(position.isEmpty());
	assertTrue(0 <= position.left && position.right <= mLayout.getWidth());
	assertTrue(0 <= position.top && position.bottom <= mLayout.getHeight());
	}

	@Test
	public void testWindowContent_modifiesAfterUpdate() throws Throwable {
	prepareFourQuadrantsScenario();

	// Show the magnifier at the center of the activity.
	final CountDownLatch latchForShow = new CountDownLatch(1);
	mMagnifier.setOnOperationCompleteCallback(latchForShow::countDown);
	mActivityRule.runOnUiThread(() -> {
	mMagnifier.show(mLayout.getWidth() / 2, mLayout.getHeight() / 2);
	});
	assertTrue(TIME_LIMIT_EXCEEDED, latchForShow.await(1, TimeUnit.SECONDS));

	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.
	final CountDownLatch latchForUpdate = new CountDownLatch(1);
	mMagnifier.setOnOperationCompleteCallback(latchForUpdate::countDown);
	mActivityRule.runOnUiThread(mMagnifier::update);
	assertTrue(TIME_LIMIT_EXCEEDED, latchForUpdate.await(1, TimeUnit.SECONDS));

	final Bitmap newBitmap = mMagnifier.getContent();
	assertFourQuadrants(newBitmap);
	assertFalse(newBitmap.sameAs(initialBitmap));
	}

	/**
	* 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);
	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);
	}
	}
	}