content / test / gpu / gpu_tests / skia_gold_integration_test_base.py [blame]

# Copyright 2019 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from datetime import date
import logging
import os
import re
import shutil
import sys
import tempfile
from typing import Any, Dict, List, Optional
import unittest

from gpu_tests import color_profile_manager
from gpu_tests import common_browser_args as cba
from gpu_tests import common_typing as ct
from gpu_tests import gpu_helper
from gpu_tests import gpu_integration_test
from gpu_tests import skia_gold_matching_algorithms as algo

from skia_gold_common import skia_gold_properties as sgp
from skia_gold_common import skia_gold_session as sgs
from skia_gold_common import skia_gold_session_manager as sgsm

import gpu_path_util

from py_utils import cloud_storage

from telemetry.util import image_util

TEST_DATA_DIRS = [
    gpu_path_util.GPU_DATA_DIR,
    os.path.join(gpu_path_util.CHROMIUM_SRC_DIR, 'media', 'test', 'data'),
]

SKIA_GOLD_CORPUS = 'chrome-gpu'


class _ImageParameters():
  def __init__(self):
    # Parameters for cloud storage reference images.
    self.vendor_id: Optional[int] = None
    self.device_id: Optional[int] = None
    self.vendor_string: Optional[str] = None
    self.device_string: Optional[str] = None
    self.msaa: bool = False
    self.model_name: Optional[str] = None
    self.driver_version: Optional[str] = None
    self.driver_vendor: Optional[str] = None
    self.display_server: Optional[str] = None
    self.skia_graphite_status: Optional[str] = None


# This and its subclasses could potentially be switched to using dataclasses,
# but due to Python's method resolution order, inheritance breaks if a parent
# class has fields with defaults and a child class has fields without defaults.
# This might be possible to resolve with kw_only, but that requires at least
# Python 3.10.
# The third party attrs module supposedly handles this situation
# (https://stackoverflow.com/a/53085935), but attempting to do so on version
# 21.4.0 fails.
class SkiaGoldTestCase():
  """Base class for any Gold-enabled test case definition.

  Only information used within SkiaGoldIntegrationTestBase should be stored
  here. Additional information should be stored in the appropriate subclass.
  """
  # pylint: disable=too-many-arguments
  def __init__(
      self,
      name: str,
      gpu_process_disabled: bool = False,
      grace_period_end: Optional[date] = None,
      matching_algorithm: Optional[algo.SkiaGoldMatchingAlgorithm] = None,
      refresh_after_finish: bool = False):
    """
    Args:
      name: A string containing the name of the test.
      gpu_process_disabled: Whether the test runs with the GPU process disabled.
      grace_period_end: An optional datetime.date, before which Gold comparison
          failures will be ignored. This allows a newly added test to be
          exempted for a (hopefully) short period after being added. This is so
          that any slightly different different but valid images that get
          produced by the CI builders can be triaged without turning the
          builders red.
      matching_algorithm: A
          skia_gold_matching_algoriths.SkiaGoldMatchingAlgorithm that specifies
          which matching algorithm Skia Gold should use for the test. Defaults
          to exact matching.
      refresh_after_finish: Whether to refresh the entire page after the test
          finishes.
    """
    self.name = name
    self.gpu_process_disabled = gpu_process_disabled
    self.grace_period_end = grace_period_end
    self.matching_algorithm = (matching_algorithm
                               or algo.ExactMatchingAlgorithm())
    self.refresh_after_finish = refresh_after_finish

  #pylint: enable=too-many-arguments


class SkiaGoldIntegrationTestBase(gpu_integration_test.GpuIntegrationTest):
  """Base class for all tests that upload results to Skia Gold."""
  _error_image_cloud_storage_bucket = 'chromium-browser-gpu-tests'

  # This information is class-scoped, so that it can be shared across
  # invocations of tests; but it's zapped every time the browser is
  # restarted with different command line arguments.
  _image_parameters: Optional[_ImageParameters] = None

  _skia_gold_temp_dir: Optional[str] = None
  _skia_gold_session_manager: Optional[sgsm.SkiaGoldSessionManager] = None
  _skia_gold_properties: Optional[sgp.SkiaGoldProperties] = None

  # Loaded from disk at a later point.
  _dom_automation_controller_script: Optional[str] = None

  @classmethod
  def SetUpProcess(cls) -> None:
    super(SkiaGoldIntegrationTestBase, cls).SetUpProcess()
    options = cls.GetOriginalFinderOptions()
    color_profile_manager.ForceUntilExitSRGB(
        options.dont_restore_color_profile_after_test)
    cls.CustomizeBrowserArgs([])
    cls.StartBrowser()
    cls.SetStaticServerDirs(cls._GetStaticServerDirs())
    cls._skia_gold_temp_dir = tempfile.mkdtemp()

  @classmethod
  def _GetStaticServerDirs(cls) -> List[str]:
    return TEST_DATA_DIRS

  @classmethod
  def _SetClassVariablesFromOptions(cls, options: ct.ParsedCmdArgs) -> None:
    super()._SetClassVariablesFromOptions(options)
    if not cls._dom_automation_controller_script:
      with open(
          os.path.join(gpu_path_util.GPU_TEST_HARNESS_JAVASCRIPT_DIR,
                       'websocket_heartbeat.js')) as f:
        cls._dom_automation_controller_script = f.read()
      cls._dom_automation_controller_script += '\n'
      with open(
          os.path.join(gpu_path_util.GPU_TEST_HARNESS_JAVASCRIPT_DIR,
                       'dom_automation_controller.js')) as f:
        cls._dom_automation_controller_script += f.read()

  @classmethod
  def GetSkiaGoldProperties(cls) -> sgp.SkiaGoldProperties:
    if not cls._skia_gold_properties:
      cls._skia_gold_properties = sgp.SkiaGoldProperties(
          cls.GetOriginalFinderOptions())
    return cls._skia_gold_properties

  @classmethod
  def GetSkiaGoldSessionManager(cls) -> sgsm.SkiaGoldSessionManager:
    if not cls._skia_gold_session_manager:
      cls._skia_gold_session_manager = sgsm.SkiaGoldSessionManager(
          cls._skia_gold_temp_dir, cls.GetSkiaGoldProperties())
    return cls._skia_gold_session_manager

  @classmethod
  def GenerateBrowserArgs(cls, additional_args: List[str]) -> List[str]:
    """Adds default arguments to |additional_args|.

    See the parent class' method documentation for additional information.
    """
    default_args = super(SkiaGoldIntegrationTestBase,
                         cls).GenerateBrowserArgs(additional_args)
    default_args.extend([cba.ENABLE_GPU_BENCHMARKING, cba.TEST_TYPE_GPU])
    force_color_profile_arg = [
        arg for arg in default_args if arg.startswith('--force-color-profile=')
    ]
    if not force_color_profile_arg:
      default_args.extend([
          cba.FORCE_COLOR_PROFILE_SRGB,
          cba.ENSURE_FORCED_COLOR_PROFILE,
      ])
    return default_args

  @classmethod
  def StopBrowser(cls) -> None:
    super(SkiaGoldIntegrationTestBase, cls).StopBrowser()
    cls.ResetGpuInfo()

  @classmethod
  def TearDownProcess(cls) -> None:
    super(SkiaGoldIntegrationTestBase, cls).TearDownProcess()
    shutil.rmtree(cls._skia_gold_temp_dir)
    cls._skia_gold_session_manager = None

  @classmethod
  def AddCommandlineArgs(cls, parser: ct.CmdArgParser) -> None:
    super(SkiaGoldIntegrationTestBase, cls).AddCommandlineArgs(parser)
    parser.add_argument('--git-revision', help='Chrome revision being tested.')
    parser.add_argument(
        '--test-machine-name',
        default='',
        help=('Name of the test machine. Specifying this argument causes this '
              'script to upload failure images and diffs to cloud storage '
              'directly, instead of relying on the '
              'archive_gpu_pixel_test_results.py script.'))
    parser.add_argument(
        '--dont-restore-color-profile-after-test',
        action='store_true',
        default=False,
        help=("(Mainly on Mac) don't restore the system's original color "
              'profile after the test completes; leave the system using the '
              'sRGB color profile. See http://crbug.com/784456.'))
    parser.add_argument('--gerrit-issue',
                        default='',
                        help='For Skia Gold integration. Gerrit issue ID.')
    parser.add_argument(
        '--gerrit-patchset',
        default='',
        help='For Skia Gold integration. Gerrit patch set number.')
    parser.add_argument('--buildbucket-id',
                        default='',
                        help='For Skia Gold integration. Buildbucket build ID.')
    parser.add_argument(
        '--no-skia-gold-failure',
        action='store_true',
        default=False,
        help=('For Skia Gold integration. Always report that the test passed '
              'even if the Skia Gold image comparison reported a failure, but '
              'otherwise perform the same steps as usual.'))
    # Telemetry is *still* using optparse instead of argparse, so we can't have
    # these two options in a mutually exclusive group.
    # TODO(crbug.com/40807291): Use a mutually exclusive group once the
    # optparse -> argparse migration is complete.
    parser.add_argument(
        '--local-pixel-tests',
        action='store_true',
        default=None,
        help=('Specifies to run the test harness in local run mode or not. '
              'When run in local mode, uploading to Gold is disabled and links '
              'to help with local debugging are output. Running in local mode '
              'also implies --no-luci-auth. If both this and '
              '--no-local-pixel-tests are left unset, the test harness will '
              'attempt to detect whether it is running on a workstation or not '
              'and set this option accordingly.'))
    parser.add_argument(
        '--no-local-pixel-tests',
        action='store_false',
        dest='local_pixel_tests',
        help=('Specifies to run the test harness in non-local (bot) mode. When '
              'run in this mode, data is actually uploaded to Gold and triage '
              'links are generated. If both this and --local-pixel-tests are '
              'left unset, the test harness will attempt to detect whether it '
              'is running on a workstation or not and set this option '
              'accordingly.'))
    parser.add_argument(
        '--skia-gold-local-png-write-directory',
        help=('Specifies a directory to save local image diffs to instead of '
              'the default of a temporary directory. Only has an effect when '
              'running tests locally, not on a bot.'))
    parser.add_argument(
        '--no-luci-auth',
        action='store_true',
        default=False,
        help=("Don't use the service account provided by LUCI for "
              'authentication for Skia Gold, instead relying on gsutil to be '
              'pre-authenticated. Meant for testing locally instead of on the '
              'bots.'))
    parser.add_argument(
        '--service-account',
        help=('Specifies the service account to use instead of using '
              'LUCI_CONTEXT or whatever is configured in gsutil. Implies '
              '--no-luci-auth. Only meant for use in Skylab where the tests '
              'are automated but do not have LUCI_CONTEXT available.'))
    parser.add_argument(
        '--bypass-skia-gold-functionality',
        action='store_true',
        default=False,
        help=('Bypass all interaction with Skia Gold, effectively disabling '
              'the image comparison portion of any tests that use Gold. Only '
              'meant to be used in case a Gold outage occurs and cannot be '
              'fixed quickly.'))

  @classmethod
  def ResetGpuInfo(cls) -> None:
    cls._image_parameters = None

  @classmethod
  def GetImageParameters(cls, test_case: SkiaGoldTestCase) -> _ImageParameters:
    if not cls._image_parameters:
      cls._ComputeGpuInfo(test_case)
    return cls._image_parameters

  @classmethod
  def _ComputeGpuInfo(cls, test_case: SkiaGoldTestCase) -> None:
    if cls._image_parameters:
      return
    browser = cls.browser
    system_info = browser.GetSystemInfo()
    if not system_info:
      raise Exception('System info must be supported by the browser')
    if not system_info.gpu:
      raise Exception('GPU information was absent')
    device = system_info.gpu.devices[0]
    cls._image_parameters = _ImageParameters()
    params = cls._image_parameters
    if device.vendor_id and device.device_id:
      params.vendor_id = device.vendor_id
      params.device_id = device.device_id
    elif device.vendor_string and device.device_string:
      params.vendor_string = device.vendor_string
      params.device_string = device.device_string
    elif test_case.gpu_process_disabled:
      # Match the vendor and device IDs that the browser advertises
      # when the software renderer is active.
      params.vendor_id = 65535
      params.device_id = 65535
    else:
      raise Exception('GPU device information was incomplete')
    # TODO(senorblanco): This should probably be checking
    # for the presence of the extensions in system_info.gpu_aux_attributes
    # in order to check for MSAA, rather than sniffing the blocklist.
    params.msaa = not (('disable_chromium_framebuffer_multisample' in
                        system_info.gpu.driver_bug_workarounds) or
                       ('disable_multisample_render_to_texture' in system_info.
                        gpu.driver_bug_workarounds))
    params.model_name = system_info.model_name
    params.driver_version = device.driver_version
    params.driver_vendor = device.driver_vendor
    params.display_server = gpu_helper.GetDisplayServer(browser.browser_type)
    params.skia_graphite_status = gpu_helper.GetSkiaGraphiteStatus(
        system_info.gpu)

  @classmethod
  def _UploadBitmapToCloudStorage(cls,
                                  bucket: str,
                                  name: str,
                                  bitmap: Any,
                                  public: bool = False) -> None:
    # This sequence of steps works on all platforms to write a temporary
    # PNG to disk, following the pattern in bitmap_unittest.py. The key to
    # avoiding PermissionErrors seems to be to not actually try to write to
    # the temporary file object, but to re-open its name for all operations.
    temp_file = tempfile.NamedTemporaryFile(suffix='.png').name
    image_util.WritePngFile(bitmap, temp_file)
    cloud_storage.Insert(bucket, name, temp_file, publicly_readable=public)

  # Not used consistently, but potentially useful for debugging issues on the
  # bots, so kept around for future use.
  @classmethod
  def _UploadGoldErrorImageToCloudStorage(cls, image_name: str,
                                          screenshot: ct.Screenshot) -> None:
    revision = cls.GetSkiaGoldProperties().git_revision
    machine_name = re.sub(r'\W+', '_',
                          cls.GetOriginalFinderOptions().test_machine_name)
    base_bucket = '%s/gold_failures' % (cls._error_image_cloud_storage_bucket)
    image_name_with_revision_and_machine = '%s_%s_%s.png' % (
        image_name, machine_name, revision)
    cls._UploadBitmapToCloudStorage(
        base_bucket,
        image_name_with_revision_and_machine,
        screenshot,
        public=True)

  @staticmethod
  def _UrlToImageName(url: str) -> str:
    image_name = re.sub(r'^(http|https|file)://(/*)', '', url)
    image_name = re.sub(r'\.\./', '', image_name)
    image_name = re.sub(r'(\.|/|-)', '_', image_name)
    return image_name

  def GetGoldJsonKeys(self, test_case: SkiaGoldTestCase) -> Dict[str, str]:
    """Get all the JSON metadata that will be passed to goldctl."""
    img_params = self.GetImageParameters(test_case)
    # The frequently changing last part of the ANGLE driver version (revision of
    # some sort?) messes a bit with inexact matching since each revision will
    # be treated as a separate trace, so strip it off.
    _StripAngleRevisionFromDriver(img_params)
    # When running under the validating decoder, the device string is reported
    # as the actual device, while under the passthrough decoder it is an ANGLE
    # string that contains the device and some additional information. This
    # difference can be annoying when trying to set up forwarding rules for the
    # public Gold instance, so only use the actual device.
    _ConvertAngleDeviceStringToActualDevice(img_params)
    # All values need to be strings, otherwise goldctl fails.
    gpu_keys = {
        'vendor_id':
        _ToHexOrNone(img_params.vendor_id),
        'device_id':
        _ToHexOrNone(img_params.device_id),
        'vendor_string':
        _ToNonEmptyStrOrNone(img_params.vendor_string),
        'device_string':
        _ToNonEmptyStrOrNone(img_params.device_string),
        'msaa':
        str(img_params.msaa),
        'model_name':
        _ToNonEmptyStrOrNone(img_params.model_name),
        'os':
        _ToNonEmptyStrOrNone(self.browser.platform.GetOSName()),
        'os_version':
        _ToNonEmptyStrOrNone(self.browser.platform.GetOSVersionName()),
        'os_version_detail_string':
        _ToNonEmptyStrOrNone(self.browser.platform.GetOSVersionDetailString()),
        'driver_version':
        _ToNonEmptyStrOrNone(img_params.driver_version),
        'driver_vendor':
        _ToNonEmptyStrOrNone(img_params.driver_vendor),
        'display_server':
        _ToNonEmptyStrOrNone(img_params.display_server),
        'combined_hardware_identifier':
        _GetCombinedHardwareIdentifier(img_params),
        'browser_type':
        _ToNonEmptyStrOrNone(self.browser.browser_type),
        'skia_graphite_status':
        _ToNonEmptyStrOrNone(img_params.skia_graphite_status),
    }
    # If we have a grace period active, then the test is potentially flaky.
    # Include a pair that will cause Gold to ignore any untriaged images, which
    # will prevent it from automatically commenting on unrelated CLs that happen
    # to produce a new image.
    if _GracePeriodActive(test_case):
      # This is put in the regular keys dict instead of the optional one because
      # ignore rules do not apply to optional keys.
      gpu_keys['ignore'] = '1'
    return gpu_keys

  # pylint: disable=no-self-use
  def GetGoldOptionalKeys(self) -> Dict[str, str]:
    """Get all the optional JSON metadata that will be passed to goldctl.

    This optional data is unrelated to the configurations that images are
    produced on, e.g. a comment that will be surfaced in Gold's UI.
    """
    return {}

  # pylint: enable=no-self-use

  def _UploadTestResultToSkiaGold(self, image_name: str,
                                  screenshot: ct.Screenshot,
                                  test_case: SkiaGoldTestCase) -> None:
    """Compares the given image using Skia Gold and uploads the result.

    No uploading is done if the test is being run in local run mode. Compares
    the given screenshot to baselines provided by Gold, raising an Exception if
    a match is not found.

    Args:
      image_name: the name of the image being checked.
      screenshot: the image being checked as a Telemetry Bitmap.
      test_case: the GPU SkiaGoldTestCase object for the test.
    """
    # Write screenshot to PNG file on local disk.
    png_temp_file = tempfile.NamedTemporaryFile(
        suffix='.png', dir=self._skia_gold_temp_dir).name
    image_util.WritePngFile(screenshot, png_temp_file)

    gpu_keys = self.GetGoldJsonKeys(test_case)
    gold_session = self.GetSkiaGoldSessionManager().GetSkiaGoldSession(
        gpu_keys, corpus=SKIA_GOLD_CORPUS)
    gold_properties = self.GetSkiaGoldProperties()
    use_luci = not (gold_properties.local_pixel_tests
                    or gold_properties.no_luci_auth)
    optional_keys = self.GetGoldOptionalKeys()

    status, error = gold_session.RunComparison(
        name=image_name,
        png_file=png_temp_file,
        inexact_matching_args=test_case.matching_algorithm.GetCmdline(),
        use_luci=use_luci,
        service_account=gold_properties.service_account,
        optional_keys=optional_keys)
    if not status:
      return

    status_codes =\
        self.GetSkiaGoldSessionManager().GetSessionClass().StatusCodes
    if status == status_codes.AUTH_FAILURE:
      logging.error('Gold authentication failed with output %s', error)
    elif status == status_codes.INIT_FAILURE:
      logging.error('Gold initialization failed with output %s', error)
    elif status == status_codes.COMPARISON_FAILURE_REMOTE:
      public_triage_link, internal_triage_link = gold_session.GetTriageLinks(
          image_name)
      if not public_triage_link or not internal_triage_link:
        logging.error('Failed to get triage links for %s, raw output: %s',
                      image_name, error)
        logging.error('Reason for no triage links: %s',
                      gold_session.GetTriageLinkOmissionReason(image_name))
      elif gold_properties.IsTryjobRun():
        self.artifacts.CreateLink('public_triage_link_for_entire_cl',
                                  public_triage_link)
        self.artifacts.CreateLink('internal_triage_link_for_entire_cl',
                                  internal_triage_link)
      else:
        self.artifacts.CreateLink('public_gold_triage_link', public_triage_link)
        self.artifacts.CreateLink('internal_gold_triage_link',
                                  internal_triage_link)
    elif status == status_codes.COMPARISON_FAILURE_LOCAL:
      logging.error('Local comparison failed. Local diff files:')
      _OutputLocalDiffFiles(gold_session, image_name)
    elif status == status_codes.LOCAL_DIFF_FAILURE:
      logging.error(
          'Local comparison failed and an error occurred during diff '
          'generation: %s', error)
      # There might be some files, so try outputting them.
      logging.error('Local diff files:')
      _OutputLocalDiffFiles(gold_session, image_name)
    else:
      logging.error(
          'Given unhandled SkiaGoldSession StatusCode %s with error %s', status,
          error)
    if self._ShouldReportGoldFailure(test_case):
      raise Exception(
          'goldctl command returned non-zero exit code, see above for details. '
          'This probably just means that the test produced an image that has '
          'not been triaged as positive.')

  def _ShouldReportGoldFailure(self, test_case: SkiaGoldTestCase) -> bool:
    """Determines if a Gold failure should actually be surfaced.

    Args:
      test_case: The GPU SkiaGoldTestCase object for the test.

    Returns:
      True if the failure should be surfaced, i.e. the test should fail,
      otherwise False.
    """
    parsed_options = self.GetOriginalFinderOptions()
    # Don't surface if we're explicitly told not to.
    if parsed_options.no_skia_gold_failure:
      return False
    # Don't surface if the test was recently added and we're still within its
    # grace period.
    if _GracePeriodActive(test_case):
      return False
    return True

  @classmethod
  def GenerateGpuTests(cls, options: ct.ParsedCmdArgs) -> ct.TestGenerator:
    del options
    raise NotImplementedError(
        'GenerateGpuTests must be overridden in a subclass')

  def RunActualGpuTest(self, test_path: str, args: ct.TestArgs) -> None:
    raise NotImplementedError(
        'RunActualGpuTest must be overridden in a subclass')


def _ToHex(num: str) -> str:
  return hex(int(num))


def _ToHexOrNone(num: Optional[str]) -> str:
  return 'None' if num is None else _ToHex(num)


def _ToNonEmptyStrOrNone(val: Optional[str]) -> str:
  return 'None' if val == '' else str(val)


def _GracePeriodActive(test_case: SkiaGoldTestCase) -> bool:
  """Returns whether a grace period is currently active for a test.

  Args:
    test_case: The GPU SkiaGoldTestCase object for the test in question.

  Returns:
    True if a grace period is defined for |test_case| and has not yet expired.
    Otherwise, False.
  """
  return (test_case.grace_period_end
          and date.today() <= test_case.grace_period_end)


def _StripAngleRevisionFromDriver(img_params: _ImageParameters) -> None:
  """Strips the revision off the end of an ANGLE driver version.

  E.g. 2.1.0.b50541b2d6c4 -> 2.1.0

  Modifies the string in place. No-ops if the driver vendor is not ANGLE.

  Args:
    img_params: An _ImageParameters instance to modify.
  """
  if 'ANGLE' not in img_params.driver_vendor or not img_params.driver_version:
    return
  # Assume that we're never going to have portions of the driver we care about
  # that are longer than 8 characters.
  driver_parts = img_params.driver_version.split('.')
  kept_parts = []
  for part in driver_parts:
    if len(part) > 8:
      break
    kept_parts.append(part)
  img_params.driver_version = '.'.join(kept_parts)


def _ConvertAngleDeviceStringToActualDevice(
    img_params: _ImageParameters) -> None:
  """Converts an ANGLE device string to only have the actual device.

  E.g. ANGLE(Qualcomm, Adreno (TM) 640, OpenGL ES ...) -> Adreno (TM) 640

  Modifies the string in place. No-ops if the driver string is not ANGLE.

  Args:
    img_params: An _ImageParameters instance to modify.
  """
  device_id = gpu_helper.GetANGLEGpuDeviceId(img_params.device_string)
  if device_id:
    img_params.device_string = device_id


def _GetCombinedHardwareIdentifier(img_params: _ImageParameters) -> str:
  """Combine all relevant hardware identifiers into a single key.

  This makes Gold forwarding more precise by allowing us to forward explicit
  configurations instead of individual components.
  """
  vendor_id = _ToHexOrNone(img_params.vendor_id)
  device_id = _ToHexOrNone(img_params.device_id)
  device_string = _ToNonEmptyStrOrNone(img_params.device_string)
  combined_hw_identifiers = ('vendor_id:{vendor_id}, '
                             'device_id:{device_id}, '
                             'device_string:{device_string}')
  combined_hw_identifiers = combined_hw_identifiers.format(
      vendor_id=vendor_id, device_id=device_id, device_string=device_string)
  return combined_hw_identifiers


def _OutputLocalDiffFiles(gold_session: sgs.SkiaGoldSession,
                          image_name: str) -> None:
  """Logs the local diff image files from the given SkiaGoldSession.

  Args:
    gold_session: A skia_gold_session.SkiaGoldSession instance to pull files
        from.
    image_name: A string containing the name of the image/test that was
        compared.
  """
  given_file = gold_session.GetGivenImageLink(image_name)
  closest_file = gold_session.GetClosestImageLink(image_name)
  diff_file = gold_session.GetDiffImageLink(image_name)
  failure_message = 'Unable to retrieve link'
  logging.error('Generated image: %s', given_file or failure_message)
  logging.error('Closest image: %s', closest_file or failure_message)
  logging.error('Diff image: %s', diff_file or failure_message)


def load_tests(loader: unittest.TestLoader, tests: Any,
               pattern: Any) -> unittest.TestSuite:
  del loader, tests, pattern  # Unused.
  return gpu_integration_test.LoadAllTestsInModule(sys.modules[__name__])