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

#!/usr/bin/env vpython3
# Copyright 2022 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from typing import Any, Callable, Dict, List, Optional, Tuple, Union
import unittest
from unittest import mock

import dataclasses  # Built-in, but pylint gives an ordering false positive.

from gpu_tests import common_typing as ct
from gpu_tests import gpu_helper
from telemetry.internal.platform import gpu_info


# pylint: disable=too-many-arguments
def CreateGpuDeviceDict(vendor_id: Optional[int] = None,
                        device_id: Optional[int] = None,
                        sub_sys_id: Optional[int] = None,
                        revision: Optional[int] = None,
                        vendor_string: Optional[str] = None,
                        device_string: Optional[str] = None,
                        driver_vendor: Optional[str] = None,
                        driver_version: Optional[str] = None
                        ) -> Dict[str, Union[str, int]]:
  return {
      'vendor_id':
      vendor_id or 0,
      'device_id':
      device_id or 0,
      'sub_sys_id':
      sub_sys_id or 0,
      'revision':
      revision or 0,
      'vendor_string':
      'vendor_string' if vendor_string is None else vendor_string,
      'device_string':
      'device_string' if device_string is None else device_string,
      'driver_vendor':
      'driver_vendor' if driver_vendor is None else driver_vendor,
      'driver_version':
      'driver_version' if driver_version is None else driver_version,
  }


# pylint: enable=too-many-arguments


@dataclasses.dataclass
class TagHelperTestCase():
  """Struct-like class for defining a tag helper test case."""
  expected_result: Any
  device_dict: Dict[str, Union[str, int]] = ct.EmptyDict()
  aux_attributes: Dict[str, Any] = ct.EmptyDict()
  feature_status: Dict[str, str] = ct.EmptyDict()
  extra_browser_args: List[str] = ct.EmptyList()


class TagHelpersUnittest(unittest.TestCase):

  def runTagHelperTestWithIndex(
      self, tc: TagHelperTestCase,
      test_method: Callable[[Optional[gpu_info.GPUInfo], int], Any]) -> None:
    """Helper method for running a single tag helper test case w/ index."""
    info = gpu_info.GPUInfo([CreateGpuDeviceDict(**tc.device_dict)],
                            tc.aux_attributes, tc.feature_status, None)
    self.assertEqual(test_method(info, 0), tc.expected_result)

  def runTagHelperTest(self, tc: TagHelperTestCase,
                       test_method: Callable[[Optional[gpu_info.GPUInfo]], Any]
                       ) -> None:
    """Helper method for running a single tag helper test case w/o index."""
    info = gpu_info.GPUInfo([CreateGpuDeviceDict(**tc.device_dict)],
                            tc.aux_attributes, tc.feature_status, None)
    self.assertEqual(test_method(info), tc.expected_result)

  def testGetGpuVendorString(self) -> None:
    """Tests all code paths for the GetGpuVendorString() method."""
    cases = [
        # Explicit ID -> AMD.
        TagHelperTestCase(
            'amd', {
                'vendor_id': 0x1002,
                'device_string': 'ANGLE (ANGLE gpu, 1, 2)',
                'vendor_string': 'Vendor_gpu 1 2'
            }),
        # Explicit ID -> Intel.
        TagHelperTestCase(
            'intel', {
                'vendor_id': 0x8086,
                'device_string': 'ANGLE (ANGLE gpu, 1, 2)',
                'vendor_string': 'Vendor_gpu 1 2'
            }),
        # Explicit ID -> NVIDIA.
        TagHelperTestCase(
            'nvidia', {
                'vendor_id': 0x10DE,
                'device_string': 'ANGLE (ANGLE gpu, 1, 2)',
                'vendor_string': 'Vendor_gpu 1 2'
            }),
        # ANGLE vendor string.
        TagHelperTestCase(
            'angle gpu', {
                'device_string': 'ANGLE (ANGLE gpu, 1, 2)',
                'vendor_string': 'Vendor_gpu 1 2'
            }),
        # Vendor string.
        TagHelperTestCase('vendor_gpu', {'vendor_string': 'Vendor_gpu 1 2'}),
        # Defined info but unknown.
        TagHelperTestCase('unknown_gpu', {'vendor_string': ''}),
    ]

    for tc in cases:
      self.runTagHelperTestWithIndex(tc, gpu_helper.GetGpuVendorString)

    # Undefined info.
    self.assertEqual(gpu_helper.GetGpuVendorString(None, 0), 'unknown_gpu')

  def testGetGpuDeviceId(self) -> None:
    """Tests all code paths for the GetGpuDeviceId() method."""
    cases = [
        # Explicit device.
        TagHelperTestCase(0xFFFF, {
            'device_id': 0xFFFF,
            'device_string': 'ANGLE (Vendor, Device, Driver)'
        }),
        # ANGLE device string.
        TagHelperTestCase('Device',
                          {'device_string': 'ANGLE (Vendor, Device, Driver)'}),
        # Device string.
        TagHelperTestCase('Some device', {'device_string': 'Some device'}),
    ]

    for tc in cases:
      self.runTagHelperTestWithIndex(tc, gpu_helper.GetGpuDeviceId)

    # Undefined info.
    self.assertEqual(gpu_helper.GetGpuDeviceId(None, 0), 0)

  def testIntelMasks(self) -> None:
    """Tests the masking methods for determining Intel generation."""
    # Sample of real IDs taken from
    # https://dgpu-docs.intel.com/devices/hardware-table.html
    # Note that 12th gen is referred to as "Xe" or "XeHPG.
    gen_9_ids = {0x1923, 0x3184, 0x3EA4, 0x591C, 0x5A85, 0x9BC8}
    # 0x4F and 0xA7-prefixed samples missing since none were listed.
    gen_12_ids = {0x4C8A, 0x9A40, 0x4905, 0x4680, 0x5690}

    for pci_id in gen_9_ids:
      self.assertTrue(gpu_helper.IsIntelGen9(pci_id))
      self.assertFalse(gpu_helper.IsIntelGen12(pci_id))

    for pci_id in gen_12_ids:
      self.assertTrue(gpu_helper.IsIntelGen12(pci_id))
      self.assertFalse(gpu_helper.IsIntelGen9(pci_id))

  def testGetGpuDriverVendor(self) -> None:
    """Tests all code paths for the GetGpuDriverVendor() method."""
    # Explicit vendor.
    self.runTagHelperTest(
        TagHelperTestCase('vendor', {'driver_vendor': 'vendor'}),
        gpu_helper.GetGpuDriverVendor)
    # Undefined info.
    self.assertEqual(gpu_helper.GetGpuDriverVendor(None), None)

  def testGetGpuDriverVersion(self) -> None:
    """Tests all code paths for the GetGpuDriverVersion() method."""
    # Explicit version.
    self.runTagHelperTest(
        TagHelperTestCase('Some version', {'driver_version': 'Some version'}),
        gpu_helper.GetGpuDriverVersion)
    # Undefined info.
    self.assertEqual(gpu_helper.GetGpuDriverVersion(None), None)

  def testGetANGLERenderer(self) -> None:
    """Tests all code paths for the GetANGLERenderer() method."""
    cases = [
        # No aux attributes.
        TagHelperTestCase('angle-disabled'),
        # Non-ANGLE renderer.
        TagHelperTestCase('angle-disabled',
                          aux_attributes={'gl_renderer': 'renderer'}),
        # D3D11.
        TagHelperTestCase('angle-d3d11',
                          aux_attributes={'gl_renderer': 'ANGLE Direct3D11'}),
        # D3D9.
        TagHelperTestCase('angle-d3d9',
                          aux_attributes={'gl_renderer': 'ANGLE Direct3D9'}),
        # OpenGL ES.
        TagHelperTestCase('angle-opengles',
                          aux_attributes={'gl_renderer': 'ANGLE OpenGL ES'}),
        # OpenGL.
        TagHelperTestCase('angle-opengl',
                          aux_attributes={'gl_renderer': 'ANGLE OpenGL'}),
        # Metal.
        TagHelperTestCase('angle-metal',
                          aux_attributes={'gl_renderer': 'ANGLE Metal'}),
        # SwiftShader, explicitly test that it's chosen over Vulkan.
        TagHelperTestCase(
            'angle-swiftshader',
            aux_attributes={'gl_renderer': 'ANGLE Vulkan SwiftShader'}),
        # Vulkan.
        TagHelperTestCase('angle-vulkan',
                          aux_attributes={'gl_renderer': 'ANGLE Vulkan'}),
    ]

    for tc in cases:
      self.runTagHelperTest(tc, gpu_helper.GetANGLERenderer)

    # Undefined info.
    self.assertEqual(gpu_helper.GetANGLERenderer(None), 'angle-disabled')

  def testGetCommandDecoder(self) -> None:
    """Tests all code paths for the GetcommandDecoder() method."""
    cases = [
        # No aux attributes.
        TagHelperTestCase('no_passthrough'),
        # Validating.
        TagHelperTestCase('no_passthrough',
                          aux_attributes={'passthrough_cmd_decoder': False}),
        # Passthrough.
        TagHelperTestCase('passthrough',
                          aux_attributes={'passthrough_cmd_decoder': True}),
    ]

    for tc in cases:
      self.runTagHelperTest(tc, gpu_helper.GetCommandDecoder)

    # Undefined info.
    self.assertEqual(gpu_helper.GetCommandDecoder(None), 'no_passthrough')

  def testGetSkiaGraphiteStatus(self) -> None:
    """Tests all the code paths for the GetSkiaGraphiteStatus() method."""
    cases = [
        # No feature status.
        TagHelperTestCase('graphite-disabled'),
        # Feature status off.
        TagHelperTestCase('graphite-disabled',
                          feature_status={'skia_graphite': 'disabled'}),
        # Feature status on.
        TagHelperTestCase('graphite-enabled',
                          feature_status={'skia_graphite': 'enabled_on'}),
    ]

    for tc in cases:
      self.runTagHelperTest(tc, gpu_helper.GetSkiaGraphiteStatus)

    # Undefined info.
    self.assertEqual(gpu_helper.GetSkiaGraphiteStatus(None),
                     'graphite-disabled')

  def testGetSkiaRenderer(self) -> None:
    """Tests all code paths for the GetSkiaRenderer() method."""
    cases = [
        # No feature status.
        TagHelperTestCase('renderer-software'),
        # No GPU Compositing.
        TagHelperTestCase('renderer-software',
                          feature_status={'gpu_compositing': 'disabled'}),
        # No renderer.
        TagHelperTestCase('renderer-software',
                          feature_status={'gpu_compositing': 'enabled'}),
        # Vulkan Skia Renderer.
        TagHelperTestCase('renderer-skia-vulkan',
                          feature_status={
                              'gpu_compositing': 'enabled',
                              'vulkan': 'enabled_on',
                              'opengl': 'enabled_on'
                          }),
        # GL Skia Renderer.
        TagHelperTestCase('renderer-skia-gl',
                          feature_status={
                              'gpu_compositing': 'enabled',
                              'vulkan': 'enabled_off',
                              'opengl': 'enabled_on'
                          }),
    ]

    for tc in cases:
      self.runTagHelperTest(tc, gpu_helper.GetSkiaRenderer)

    # Undefined info.
    self.assertEqual(gpu_helper.GetSkiaRenderer(None), 'renderer-software')

  def testGetDisplayServer(self) -> None:
    """Tests all code paths for the GetDisplayServer() method."""
    with mock.patch('gpu_tests.util.host_information.IsLinux',
                    return_value=True):
      # Remote platforms.
      for browser_type in gpu_helper.REMOTE_BROWSER_TYPES:
        self.assertEqual(gpu_helper.GetDisplayServer(browser_type), None)
      # X.
      with mock.patch.dict('os.environ', {}, clear=True):
        self.assertEqual(gpu_helper.GetDisplayServer(''), 'display-server-x')
      # Wayland.
      with mock.patch.dict('os.environ', {'WAYLAND_DISPLAY': '1'}, clear=True):
        self.assertEqual(gpu_helper.GetDisplayServer(''),
                         'display-server-wayland')

    with mock.patch('gpu_tests.util.host_information.IsLinux',
                    return_value=False):
      self.assertEqual(gpu_helper.GetDisplayServer(''), None)

  def testGetOOPCanvasStatus(self) -> None:
    """Tests all the code paths for the GetOOPCanvasStatus() method."""
    cases = [
        # No feature status.
        TagHelperTestCase('no-oop-c'),
        # Feature status off.
        TagHelperTestCase(
            'no-oop-c',
            feature_status={'canvas_oop_rasterization': 'enabled_off'}),
        # Feature status on.
        TagHelperTestCase(
            'oop-c', feature_status={'canvas_oop_rasterization': 'enabled_on'}),
    ]

    for tc in cases:
      self.runTagHelperTest(tc, gpu_helper.GetOOPCanvasStatus)

    # Undefined info.
    self.assertEqual(gpu_helper.GetOOPCanvasStatus(None), 'no-oop-c')

  def testGetAsanStatus(self) -> None:
    """Tests all code paths for the GetAsanStatus() method."""
    cases = [
        # No aux attributes.
        TagHelperTestCase('no-asan'),
        # Built without ASan.
        TagHelperTestCase('no-asan', aux_attributes={'is_asan': False}),
        # Built with ASan.
        TagHelperTestCase('asan', aux_attributes={'is_asan': True}),
    ]

    for tc in cases:
      self.runTagHelperTest(tc, gpu_helper.GetAsanStatus)

    # Undefined info.
    self.assertEqual(gpu_helper.GetAsanStatus(None), 'no-asan')

  def testGetTargetCpuStatus(self) -> None:
    """Tests all code paths for the GetTargetCpuStatus() method."""
    cases = [
        # No aux attributes.
        TagHelperTestCase('target-cpu-unknown'),
        # Target CPU specified.
        TagHelperTestCase('target-cpu-32',
                          aux_attributes={'target_cpu_bits': 32}),
    ]

    for tc in cases:
      self.runTagHelperTest(tc, gpu_helper.GetTargetCpuStatus)

    # Undefined info.
    self.assertEqual(gpu_helper.GetTargetCpuStatus(None), 'target-cpu-unknown')

  def testGetClangCoverage(self) -> None:
    """Tests all code paths for the GetClangCoverage() method."""
    cases = [
        # No aux attributes.
        TagHelperTestCase('no-clang-coverage'),
        # Built without Clang coverage.
        TagHelperTestCase('no-clang-coverage',
                          aux_attributes={'is_clang_coverage': False}),
        # Built with Clang coverage.
        TagHelperTestCase('clang-coverage',
                          aux_attributes={'is_clang_coverage': True}),
    ]

    for tc in cases:
      self.runTagHelperTest(tc, gpu_helper.GetClangCoverage)

    # Undefined info.
    self.assertEqual(gpu_helper.GetClangCoverage(None), 'no-clang-coverage')


class ReplaceTagsUnittest(unittest.TestCase):
  def testSubstringReplacement(self) -> None:
    tags = ['some_tag', 'some-nvidia-corporation', 'another_tag']
    self.assertEqual(gpu_helper.ReplaceTags(tags),
                     ['some_tag', 'some-nvidia', 'another_tag'])

  def testRegexReplacement(self) -> None:
    tags = [
        'some_tag',
        'google-Vulkan-1.3.0-(SwiftShader-Device-(LLVM-10.0.0)-(0x0000C0DE))',
        'another_tag'
    ]
    self.assertEqual(gpu_helper.ReplaceTags(tags),
                     ['some_tag', 'google-vulkan', 'another_tag'])


class EvaluateVersionComparisonUnittest(unittest.TestCase):
  def testWindowsIntelUncomparableVersions(self) -> None:
    """Tests Windows Intel comparison when versions cannot be compared."""
    non_ne_operations = ('eq', 'ge', 'gt', 'le', 'lt')
    # Versions should only be comparable with 4 elements.
    self.assertTrue(
        gpu_helper.EvaluateVersionComparison('1.2.3', 'ne', '1.2.3', 'win',
                                             'intel'))
    for op in non_ne_operations:
      self.assertFalse(
          gpu_helper.EvaluateVersionComparison('1.2.3', op, '1.2.3', 'win',
                                               'intel'))
    self.assertTrue(
        gpu_helper.EvaluateVersionComparison('1.2.3.4.5', 'ne', '1.2.3.4.5',
                                             'win', 'intel'))
    for op in non_ne_operations:
      self.assertFalse(
          gpu_helper.EvaluateVersionComparison('1.2.3.4.5', op, '1.2.3.4.5',
                                               'win', 'intel'))

  def testWindowsIntelOnlyLastTwoPartsUsed(self) -> None:
    """Tests that only the last two version parts are used on Windows Intel."""
    self.assertTrue(
        gpu_helper.EvaluateVersionComparison('1.2.3.4', 'eq', '2.3.3.4', 'win',
                                             'intel'))
    self.assertFalse(
        gpu_helper.EvaluateVersionComparison('1.2.3.4', 'eq', '2.3.5.4', 'win',
                                             'intel'))

  def testInvalidOperation(self) -> None:
    """Tests that an error is raised when using an invalid operation."""
    with self.assertRaisesRegex(Exception, 'Invalid operation: foo'):
      gpu_helper.EvaluateVersionComparison('1.2.3.4', 'foo', '2.3.4.5')

  def testEqual(self) -> None:
    """Tests that equality operations work as expected."""
    eq_operations = ('eq', 'ge', 'le')
    for op in eq_operations:
      # Purely numerical.
      self.assertTrue(
          gpu_helper.EvaluateVersionComparison('1.2.3.4', op, '1.2.3.4'))

      # Numerical + suffix.
      self.assertTrue(
          gpu_helper.EvaluateVersionComparison('1a.2b.3c.4a', op,
                                               '1a.2b.3c.4a'))

      # Mismatched length implies 0.
      self.assertTrue(gpu_helper.EvaluateVersionComparison(
          '1.2.0.0', op, '1.2'))
      self.assertTrue(gpu_helper.EvaluateVersionComparison(
          '1.2', op, '1.2.0.0'))

      # Failure to parse gets skipped unless in the reference version.
      self.assertTrue(
          gpu_helper.EvaluateVersionComparison('1.2..4', op, '1.2.3.4'))
      with self.assertRaises(AssertionError):
        gpu_helper.EvaluateVersionComparison('1.2.3.4', op, '1.2..4')

  def testNotEqual(self) -> None:
    """Tests that the not equal operation works as expected."""
    true_cases = (
        # Purely numerical.
        ('1.2.3.4', '1.2.3'),
        ('1.2.3', '1.2.3.4'),
        # Same suffix, different numerical.
        ('2a.2b.3c.4d', '1a.2b.3c.4d'),
        ('1a.3b.3c.4d', '1a.2b.3c.4d'),
        ('1a.2b.4c.4d', '1a.2b.3c.4d'),
        ('1a.2b.3c.5d', '1a.2b.3c.4d'),
        # Same numerical, different suffix.
        ('1b.2b.3c.4d', '1a.2b.3c.4d'),
        ('1a.2c.3c.4d', '1a.2b.3c.4d'),
        ('1a.2b.3d.4d', '1a.2b.3c.4d'),
        ('1a.2b.3c.4e', '1a.2b.3c.4d'),
    )
    false_cases = (
        # Numerical.
        ('1.2.3.4', '1.2.3.4'),
        # Numerical + suffix.
        ('1a.2b.3c.4d', '1a.2b.3c.4d'),
    )
    for left, right in true_cases:
      self.assertTrue(gpu_helper.EvaluateVersionComparison(left, 'ne', right))
      self.assertTrue(gpu_helper.EvaluateVersionComparison(right, 'ne', left))
    for left, right in false_cases:
      self.assertFalse(gpu_helper.EvaluateVersionComparison(left, 'ne', right))
      self.assertFalse(gpu_helper.EvaluateVersionComparison(right, 'ne', left))

  def testGreater(self) -> None:
    """Tests that greater operations work as expected."""
    gt_operations = ('gt', 'ge')
    for op in gt_operations:
      for left, right in GetGreaterTestCases():
        self.assertTrue(gpu_helper.EvaluateVersionComparison(left, op, right))
        self.assertFalse(gpu_helper.EvaluateVersionComparison(right, op, left))

  def testLess(self) -> None:
    """Tests that less operations work as expected."""
    lt_operations = ('lt', 'le')
    for op in lt_operations:
      # Less than test cases are simply the inverse of greater than test cases,
      # so just reverse the order.
      for right, left in GetGreaterTestCases():
        self.assertTrue(gpu_helper.EvaluateVersionComparison(left, op, right))
        self.assertFalse(gpu_helper.EvaluateVersionComparison(right, op, left))


def GetGreaterTestCases() -> Tuple[Tuple[str, str], ...]:
  return (
      # Purely numerical.
      ('2.2.3.4', '1.2.3.4'),
      ('1.3.3.4', '1.2.3.4'),
      ('1.2.4.4', '1.2.3.4'),
      ('1.2.3.5', '1.2.3.4'),
      # Same suffix, different numerical.
      ('2a.2b.3c.4d', '1a.2b.3c.4d'),
      ('1a.3b.3c.4d', '1a.2b.3c.4d'),
      ('1a.2b.4c.4d', '1a.2b.3c.4d'),
      ('1a.2b.3c.5d', '1a.2b.3c.4d'),
      # Same numerical, different suffix.
      ('1b.2b.3c.4d', '1a.2b.3c.4d'),
      ('1a.2c.3c.4d', '1a.2b.3c.4d'),
      ('1a.2b.3d.4d', '1a.2b.3c.4d'),
      ('1a.2b.3c.4e', '1a.2b.3c.4d'),
  )


if __name__ == '__main__':
  unittest.main(verbosity=2)