content/test/gpu/gpu_tests/test_expectations.py

   1 # Copyright 2013 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import fnmatch
   6
   7 OS_MODIFIERS = ['win', 'xp', 'vista', 'win7',
   8                 'mac', 'leopard', 'snowleopard', 'lion', 'mountainlion',
   9                 'mavericks', 'yosemite', 'linux', 'chromeos', 'android']
  10 GPU_MODIFIERS = ['amd', 'arm', 'broadcom', 'hisilicon', 'intel', 'imagination',
  11                  'nvidia', 'qualcomm', 'vivante']
  12 CONFIG_MODIFIERS = ['debug', 'release']
  13
  14 class _Expectation(object):
  15   def __init__(self, expectation, parent_expectations,
  16       pattern, conditions=None, bug=None):
  17     self.expectation = expectation.lower()
  18     self.name_pattern = pattern
  19     self.url_pattern = pattern
  20     self.bug = bug
  21
  22     self.os_conditions = []
  23     self.gpu_conditions = []
  24     self.config_conditions = []
  25     self.device_id_conditions = []
  26     # These are made legal by TestExpectations.IsValidUserDefinedCondition.
  27     self.user_defined_conditions = []
  28
  29     # Make sure that non-absolute paths are searchable
  30     if not '://' in self.url_pattern:
  31       self.url_pattern = '*/' + self.url_pattern
  32
  33     if conditions:
  34       for c in conditions:
  35         if isinstance(c, tuple):
  36           c0 = c[0].lower()
  37           if c0 in GPU_MODIFIERS:
  38             self.device_id_conditions.append((c0, c[1]))
  39           elif parent_expectations.IsValidUserDefinedCondition(c0):
  40             self.user_defined_conditions.append((c0, c[1]))
  41           else:
  42             raise ValueError('Unknown expectation condition: "%s"' % c0)
  43         else:
  44           condition = c.lower()
  45           if condition in OS_MODIFIERS:
  46             self.os_conditions.append(condition)
  47           elif condition in GPU_MODIFIERS:
  48             self.gpu_conditions.append(condition)
  49           elif condition in CONFIG_MODIFIERS:
  50             self.config_conditions.append(condition)
  51           elif parent_expectations.IsValidUserDefinedCondition(condition):
  52             self.user_defined_conditions.append(condition)
  53           else:
  54             raise ValueError('Unknown expectation condition: "%s"' % condition)
  55
  56 class TestExpectations(object):
  57   """A class which defines the expectations for a page set test execution"""
  58
  59   def __init__(self):
  60     self.expectations = []
  61     self.SetExpectations()
  62
  63   def SetExpectations(self):
  64     """Called on creation. Override to set up custom expectations."""
  65     pass
  66
  67   def Fail(self, url_pattern, conditions=None, bug=None):
  68     self._Expect('fail', url_pattern, conditions, bug)
  69
  70   def Skip(self, url_pattern, conditions=None, bug=None):
  71     self._Expect('skip', url_pattern, conditions, bug)
  72
  73   def _Expect(self, expectation, url_pattern, conditions=None, bug=None):
  74     self.expectations.append(self.CreateExpectation(expectation, url_pattern,
  75                                                     conditions, bug))
  76
  77   def CreateExpectation(self, expectation, url_pattern, conditions=None,
  78                         bug=None):
  79     return _Expectation(expectation, self, url_pattern, conditions, bug)
  80
  81   def GetExpectationForPage(self, browser, page):
  82     for e in self.expectations:
  83       if self.ExpectationAppliesToPage(e, browser, page):
  84         return e.expectation
  85     return 'pass'
  86
  87   def ExpectationAppliesToPage(self, expectation, browser, page):
  88     matches_url = fnmatch.fnmatch(page.url, expectation.url_pattern)
  89     matches_name = page.name and fnmatch.fnmatch(page.name,
  90                                                  expectation.name_pattern)
  91     if matches_url or matches_name:
  92       if self.ModifiersApply(browser, expectation):
  93         return True
  94     return False
  95
  96   def _GetGpuVendorString(self, gpu_info):
  97     if gpu_info:
  98       primary_gpu = gpu_info.devices[0]
  99       if primary_gpu:
 100         vendor_string = primary_gpu.vendor_string.lower()
 101         vendor_id = primary_gpu.vendor_id
 102         if vendor_string:
 103           return vendor_string.split(' ')[0]
 104         elif vendor_id == 0x10DE:
 105           return 'nvidia'
 106         elif vendor_id == 0x1002:
 107           return 'amd'
 108         elif vendor_id == 0x8086:
 109           return 'intel'
 110
 111     return 'unknown_gpu'
 112
 113   def _GetGpuDeviceId(self, gpu_info):
 114     if gpu_info:
 115       primary_gpu = gpu_info.devices[0]
 116       if primary_gpu:
 117         return primary_gpu.device_id or primary_gpu.device_string
 118
 119     return 0
 120
 121   def ModifiersApply(self, browser, expectation):
 122     """Determines if the conditions for an expectation apply to this system.
 123     Can be overridden by subclasses to support new user-defined conditions.
 124
 125     Args:
 126       browser: the currently running browser.
 127       expectation: a object which is guaranteed to have the property
 128           "user_defined_conditions" defined, which is an array of
 129           strings or tuples specified in the test expectations for
 130           which IsValidUserDefinedCondition returned true.
 131
 132     """
 133     platform = browser.platform
 134     os_matches = (not expectation.os_conditions or
 135         platform.GetOSName() in expectation.os_conditions or
 136         platform.GetOSVersionName() in expectation.os_conditions)
 137
 138     gpu_matches = True
 139
 140     # TODO(kbr): factor out all of the GPU-related conditions into
 141     # GpuTestExpectations, including unit tests.
 142     if browser.supports_system_info:
 143       gpu_info = browser.GetSystemInfo().gpu
 144       gpu_vendor = self._GetGpuVendorString(gpu_info)
 145       gpu_device_id = self._GetGpuDeviceId(gpu_info)
 146       gpu_matches = ((not expectation.gpu_conditions and
 147           not expectation.device_id_conditions) or
 148           gpu_vendor in expectation.gpu_conditions or
 149           (gpu_vendor, gpu_device_id) in expectation.device_id_conditions)
 150
 151     return os_matches and gpu_matches
 152
 153   def IsValidUserDefinedCondition(self, _condition):
 154     """Returns true if the given condition should be treated as a
 155     valid user-defined condition.
 156
 157     Args:
 158       _condition: a string. Returning true causes a new entry to be
 159           added to the user_defined_expectations for the expectation
 160           currently being parsed. The entry added may be either the
 161           simple string of the condition, or a tuple if the condition
 162           represents the name of a new GPU type and there was an
 163           associated device ID in the expectation.
 164     """
 165     return False