| # Copyright 2024 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| """Unittests for crop_actions.py""" |
| |
| import unittest |
| |
| from telemetry.util import image_util |
| |
| from gpu_tests import crop_actions as ca |
| |
| WHITE = (255, 255, 255) |
| RED = (255, 0, 0) |
| GREEN = (0, 255, 0) |
| |
| |
| class FixedRectCropActionUnittest(unittest.TestCase): |
| |
| def testInit(self): |
| """Tests constructor checks.""" |
| with self.assertRaises(AssertionError): |
| ca.FixedRectCropAction(-1, 0, 1, 1) |
| with self.assertRaises(AssertionError): |
| ca.FixedRectCropAction(0, -1, 1, 1) |
| with self.assertRaises(AssertionError): |
| ca.FixedRectCropAction(0, 0, 0, 1) |
| with self.assertRaises(AssertionError): |
| ca.FixedRectCropAction(0, 0, 1, 0) |
| |
| def testCropTopLeft(self): |
| """Tests that cropping works properly when done at the top left bounds.""" |
| image_width = 20 |
| # 20 x 2 green image with a single red pixel in the top left. |
| # yapf: disable |
| pixels = [*RED, *(GREEN * (image_width - 1)), |
| *(GREEN * image_width)] |
| # yapf: enable |
| image = image_util.FromRGBPixels(20, 2, pixels, bpp=3) |
| action = ca.FixedRectCropAction(0, 0, 1, 1) |
| cropped_image = action.CropScreenshot(image, 1, '', '') |
| expected_image = image_util.FromRGBPixels(1, 1, [*RED], bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| def testCropCenter(self): |
| """Tests that cropping works properly when not along any bounds.""" |
| image_width = 20 |
| # 20 x 3 green image with a single red pixel one column/row away from the |
| # top left. |
| # yapf: disable |
| pixels = [*(GREEN * image_width), |
| *GREEN, *RED, *(GREEN * (image_width - 2)), |
| *(GREEN * image_width)] |
| # yapf: enable |
| image = image_util.FromRGBPixels(20, 3, pixels, bpp=3) |
| action = ca.FixedRectCropAction(1, 1, 2, 2) |
| cropped_image = action.CropScreenshot(image, 1, '', '') |
| expected_image = image_util.FromRGBPixels(1, 1, [*RED], bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| def testCropScrollbarRemoved(self): |
| """Tests that right columns are auto-removed to avoid scrollbars.""" |
| image_width = 20 |
| # 20 x 1 green image. |
| pixels = [*(GREEN * image_width)] |
| image = image_util.FromRGBPixels(20, 1, pixels, bpp=3) |
| action = ca.FixedRectCropAction(0, 0, 20, 1) |
| cropped_image = action.CropScreenshot(image, 1, '', '') |
| expected_width = image_width - ca.FixedRectCropAction.SCROLLBAR_WIDTH |
| expected_pixels = [*(GREEN * expected_width)] |
| expected_image = image_util.FromRGBPixels(expected_width, |
| 1, |
| expected_pixels, |
| bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| def testBoundsClamping(self): |
| """Tests that the bottom right coordinates are automatically clamped.""" |
| image_width = 20 |
| # 20 x 1 green image. |
| pixels = [*(GREEN * image_width)] |
| image = image_util.FromRGBPixels(20, 1, pixels, bpp=3) |
| action = ca.FixedRectCropAction(0, 0, 999999, 999999) |
| cropped_image = action.CropScreenshot(image, 1, '', '') |
| expected_width = image_width - ca.FixedRectCropAction.SCROLLBAR_WIDTH |
| expected_pixels = [*(GREEN * expected_width)] |
| expected_image = image_util.FromRGBPixels(expected_width, |
| 1, |
| expected_pixels, |
| bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| def testNoneBounds(self): |
| """Tests that None can be used to specify the bottom right coordinates.""" |
| image_width = 20 |
| # 20 x 1 green image. |
| pixels = [*(GREEN * image_width)] |
| image = image_util.FromRGBPixels(20, 1, pixels, bpp=3) |
| action = ca.FixedRectCropAction(0, 0, None, None) |
| cropped_image = action.CropScreenshot(image, 1, '', '') |
| expected_width = image_width - ca.FixedRectCropAction.SCROLLBAR_WIDTH |
| expected_pixels = [*(GREEN * expected_width)] |
| expected_image = image_util.FromRGBPixels(expected_width, |
| 1, |
| expected_pixels, |
| bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| def testDprScaling(self): |
| """Tests that crop bounds are scaled by DPR.""" |
| image_width = 20 |
| # 20 x 5 green image with a group of 4 red pixels towards the top left. |
| # yapf: disable |
| pixels = [ |
| *(GREEN * image_width), |
| *(GREEN * image_width), |
| *GREEN, *GREEN, *RED, *RED, *(GREEN * (image_width - 4)), |
| *GREEN, *GREEN, *RED, *RED, *(GREEN * (image_width - 4)), |
| *(GREEN * image_width), |
| ] |
| # yapf: enable |
| image = image_util.FromRGBPixels(20, 5, pixels, bpp=3) |
| action = ca.FixedRectCropAction(1, 1, 2, 2) |
| cropped_image = action.CropScreenshot(image, 2.4, '', '') |
| expected_pixels = [*(RED * 4)] |
| expected_image = image_util.FromRGBPixels(2, 2, expected_pixels, bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| def testNegativeBounds(self): |
| """Tests that negative numbers can be used to specify offsets.""" |
| image_width = 20 |
| # 20 x 5 green image with a group of 4 red pixels towards the top left. |
| # yapf: disable |
| pixels = [ |
| *(GREEN * image_width), |
| *(GREEN * image_width), |
| *GREEN, *GREEN, *RED, *RED, *(GREEN * (image_width - 4)), |
| *GREEN, *GREEN, *RED, *RED, *(GREEN * (image_width - 4)), |
| *(GREEN * image_width), |
| ] |
| # yapf: enable |
| image = image_util.FromRGBPixels(20, 5, pixels, bpp=3) |
| action = ca.FixedRectCropAction(2, 2, -16, -1) |
| cropped_image = action.CropScreenshot(image, 1, '', '') |
| expected_pixels = [*(RED * 4)] |
| expected_image = image_util.FromRGBPixels(2, 2, expected_pixels, bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| |
| class NonWhiteContentCropAction(unittest.TestCase): |
| |
| def testNoWhiteContent(self): |
| """Tests behavior when there is no white content to remove.""" |
| # 3 x 3 green image. |
| pixels = [*(GREEN * 9)] |
| image = image_util.FromRGBPixels(3, 3, pixels, bpp=3) |
| action = ca.NonWhiteContentCropAction() |
| cropped_image = action.CropScreenshot(image, 1, '', '') |
| expected_image = image_util.FromRGBPixels(3, 3, pixels, bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| def testSomeWhiteContent(self): |
| """Tests behavior when there is some white content to remove.""" |
| # 4 x 4 white image with red pixels in the middle. |
| # yapf: disable |
| pixels = [*WHITE, *WHITE, *WHITE, *WHITE, |
| *WHITE, *RED, *RED, *WHITE, |
| *WHITE, *RED, *RED, *WHITE, |
| *WHITE, *WHITE, *WHITE, *WHITE] |
| # yapf: enable |
| image = image_util.FromRGBPixels(4, 4, pixels, bpp=3) |
| action = ca.NonWhiteContentCropAction() |
| cropped_image = action.CropScreenshot(image, 1, '', '') |
| expected_image = image_util.FromRGBPixels(2, 2, [*(RED * 4)], bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| def testSomeWhiteContentSinglePixel(self): |
| """Checks for off-by-one errors when only a single pixel isn't white.""" |
| # 3 x 3 white image with a red pixel in the middle. |
| # yapf: disable |
| pixels = [*WHITE, *WHITE, *WHITE, |
| *WHITE, *RED, *WHITE, |
| *WHITE, *WHITE, *WHITE] |
| # yapf: enable |
| image = image_util.FromRGBPixels(3, 3, pixels, bpp=3) |
| action = ca.NonWhiteContentCropAction() |
| cropped_image = action.CropScreenshot(image, 1, '', '') |
| expected_image = image_util.FromRGBPixels(1, 1, [*RED], bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| def testAllWhiteContent(self): |
| """Tests that trying to crop all white content is an error.""" |
| pixels = [*WHITE] |
| image = image_util.FromRGBPixels(1, 1, pixels, bpp=3) |
| action = ca.NonWhiteContentCropAction() |
| with self.assertRaisesRegex( |
| RuntimeError, |
| 'Attempted to crop to non-white content in an all white image'): |
| action.CropScreenshot(image, 1, '', '') |
| |
| def testInitialCrop(self): |
| """Tests that a provided initial crop is used first.""" |
| image_width = 20 |
| # A 20 x 3 image with one red and one green pixel. |
| # yapf: disable |
| pixels = [ |
| *WHITE, *WHITE, *WHITE, *(WHITE * (image_width - 3)), |
| *WHITE, *RED, *WHITE, *(WHITE * (image_width - 3)), |
| *WHITE, *WHITE, *GREEN, *(WHITE * (image_width - 3)), |
| ] |
| # yapf: enable |
| image = image_util.FromRGBPixels(20, 3, pixels, bpp=3) |
| # This should crop out the green pixel. |
| initial_crop = ca.FixedRectCropAction(0, 0, 2, 2) |
| action = ca.NonWhiteContentCropAction(initial_crop=initial_crop) |
| cropped_image = action.CropScreenshot(image, 1, '', '') |
| expected_image = image_util.FromRGBPixels(1, 1, [*RED], bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| def testMacCrop(self): |
| """Tests that some bottom rows are cropped on Mac due to rounded corners.""" |
| image_height = 30 |
| pixels = [*(RED * image_height)] |
| image = image_util.FromRGBPixels(1, image_height, pixels, bpp=3) |
| action = ca.NonWhiteContentCropAction() |
| cropped_image = action.CropScreenshot(image, 1, '', 'mac') |
| expected_image = image_util.FromRGBPixels(1, |
| 10, |
| [*(RED * (image_height - 20))], |
| bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| def testOffWhiteCrop(self): |
| """Tests cropping of the first row on devices that produce off-white.""" |
| pixels = [*(RED * 9)] |
| image = image_util.FromRGBPixels(3, 3, pixels, bpp=3) |
| action = ca.NonWhiteContentCropAction() |
| cropped_image = action.CropScreenshot(image, 1, 'SM-A236B', '') |
| expected_image = image_util.FromRGBPixels(3, 2, [*(RED * 6)], bpp=3) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
| |
| def testCropWithAlpha(self): |
| """Tests that cropping works when an alpha channel is provided.""" |
| white = (255, 255, 255, 255) |
| red = (255, 0, 0, 255) |
| # The same pixel data as testSomeWhiteContent, but with an alpha channel. |
| # 4 x 4 white image with red pixels in the middle. |
| # yapf: disable |
| pixels = [*white, *white, *white, *white, |
| *white, *red, *red, *white, |
| *white, *red, *red, *white, |
| *white, *white, *white, *white] |
| # yapf: enable |
| image = image_util.FromRGBPixels(4, 4, pixels, bpp=4) |
| action = ca.NonWhiteContentCropAction() |
| cropped_image = action.CropScreenshot(image, 1, '', '') |
| expected_image = image_util.FromRGBPixels(2, 2, [*(red * 4)], bpp=4) |
| self.assertTrue( |
| image_util.AreEqual(cropped_image, |
| expected_image, |
| tolerance=0, |
| likely_equal=True)) |
