Update web-platform-tests to revision 58eb04cecbbec2e18531ab440225e38944a9c444

tests/wpt/web-platform-tests/css/tools/OWNERS

@@ -0,0 +1,4 @@
+@plinss
+@kojiishi
+@jgraham
+@gsnedders

tests/wpt/web-platform-tests/css/tools/apiclient/.gitignore

@@ -0,0 +1,8 @@
+*.xcodeproj
+*.DS_Store
+local/*
+*.log
+*.pyc
+*.orig
+uritemplate-test/*
+.hg/*

tests/wpt/web-platform-tests/css/tools/apiclient/.hgignore

@@ -0,0 +1,10 @@
+syntax: glob
+*.xcodeproj
+*.DS_Store
+local/*
+*.log
+*.pyc
+*.orig
+uritemplate-test/*
+.git/*
+._*

tests/wpt/web-platform-tests/css/tools/apiclient/README.md

@@ -0,0 +1,174 @@
+apiclient
+==========
+
+Client class for calling http+json APIs in Python. Requires Python 2.7.
+
+Suports json home pages per:
+http://tools.ietf.org/html/draft-nottingham-json-home-03
+
+
+Installation
+------------
+Standard python package installation:
+
+       python setup.py install
+
+
+Usage
+-----
+Import the apiclient package and instantiate a client.
+
+       import apiclient
+
+       api = apiclient.APIClient('http://api.example.com')
+
+Call APIs:
+
+       result = api.call('foo', var1=arg1, var2=arg2)
+       print result.data
+
+
+APIClient class
+---------------
+**class apiclient.APIClient(baseURI, version = None, username = None, password = None)**
+
+The APIClient constructor takes the base URI for the api, an optional request version identifier, username and password.
+
+**APIClient.baseURI**
+
+The base URI set in the constructor, read-only.
+
+**APIClient.resourceNames**
+
+A list of available API resource names.
+
+**APIClient.resource(name)**
+
+Get a named APIResource.
+
+**APIClient.setVersion(name, version)**
+
+Set the request version identifier for a specific resource. If not set, the default version identifer will be used.
+
+**APIClient.setAccept(name, mimeType)**
+
+Set the requested Content-Type for a specific resource. If not set, 'application/json' will be used.
+
+**APIClient.get(name, [kwargs])**
+
+Perform an HTTP GET on the named resource. Any named arguments supplied may be used in computing the actual URI to call. Returns an APIResponse or None if the resource name is not known.
+
+**APIClient.postForm(name, payload = None, [kwargs])**
+
+Perform an HTTP POST on the named resource. The payload, if present, may be either a dict or sequence of two-tuples and will be form encoded. Any named arguments supplied may be used in computing the actual URI to call. Returns an APIResponse or None if the resource name is not known.
+
+**APIClient.put(name, payload = None, payloadType = None, [kwargs])**
+
+Perform an HTTP PUT on the named resource. The payload, if present, will be sent to the server using the payloadType Content-Type. The payload must be pre-encoded and will not be processed by the APIClient. Any named arguments supplied may be used in computing the actual URI to call. Returns an APIResponse or None if the resource name is not known.
+
+**APIClient.patch(name, patch = None, [kwargs])**
+
+Perform an HTTP PATCH on the named resource. The patch, if present, will be encoded in JSON and sent to the server as a 'application/json-patch'. Any named arguments supplied may be used in computing the actual URI to call. Returns an APIResponse or None if the resource name is not known.
+
+**APIClient.delete(name, [kwargs])**
+
+Perform an HTTP DELETE on the named resource. Any named arguments supplied may be used in computing the actual URI to call. Returns an APIResponse or None if the resource name is not known.
+
+
+APIResponse class
+-----------------
+**APIResponse.status**
+
+The HTTP status code of the response.
+
+**APIResponse.headers**
+
+A dict of HTTP response headers.
+
+**APIResponse.contentType**
+
+The Content-Type of the response.
+
+**APIResponse.encoding**
+
+The encoding of the response.
+
+**APIResponse.data**
+
+The body of the response. If the contentType is json, the data will be decoded into native objects.
+
+
+APIResource class
+-----------------
+Describes the properties of an available API resource.
+
+**APIResource.template**
+
+The URITemplate used when calling the resource.
+
+**APIResource.variables**
+
+A dict of variables that may be passed to the resource. Keys are variable names, values are the URI identifier of the variable, if available (see http://tools.ietf.org/html/draft-nottingham-json-home-03#section-3.1 ).
+
+**APIResource.hints**
+
+An APIHints object describing any hints for the resource (see http://tools.ietf.org/html/draft-nottingham-json-home-03#section-4 ).
+
+
+APIHints class
+--------------
+**APIHints.httpMethods**
+
+A list of HTTP methods the resource may be called with.
+
+**APIHints.formats**
+
+A dict of formats available for each HTTP method. Keys are HTTP methods, values are a list of Content-Types available.
+
+**APIHints.ranges**
+
+Not yet implemented.
+
+**APIHints.preferences**
+
+Not yet implemented.
+
+**APIHints.preconditions**
+
+Not yet implemented.
+
+**APIHints.auth**
+
+Not yet implemented.
+
+**APIHints.docs**
+
+A URI for documentation for the resource.
+
+**APIHints.status**
+
+The status of the resource.
+
+
+URITemplate class
+-----------------
+Parses and expands URITemplates per RFC 6750 (plus a few extensions).
+
+**class uritemplate.URITemplate(template)**
+
+Construct a URITemplate. Raises exceptions if malformed.
+
+**URITemplate.variables**
+
+A set of variables available in the template.
+
+**URITemplate.expand([kwargs])**
+
+Return the expanded template substituting any passed keyword arguments.
+
+
+Notes
+-----
+Resource names may be absolute URIs or relative to the base URI of the API.
+
+

tests/wpt/web-platform-tests/css/tools/apiclient/__init__.py

@@ -0,0 +1,15 @@
+# coding=utf-8
+#
+#  Copyright © 2013 Hewlett-Packard Development Company, L.P.
+#
+#  This work is distributed under the W3C® Software License [1]
+#  in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+#  [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
+#
+
+# define package for direct inclusion when not installed
+
+__all__ = ['apiclient']

tests/wpt/web-platform-tests/css/tools/apiclient/apiclient/__init__.py

@@ -0,0 +1,15 @@
+# coding=utf-8
+#
+#  Copyright © 2013 Hewlett-Packard Development Company, L.P.
+#
+#  This work is distributed under the W3C® Software License [1] 
+#  in the hope that it will be useful, but WITHOUT ANY 
+#  WARRANTY; without even the implied warranty of 
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+#
+#  [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 
+#
+
+__all__ = ['apiclient', 'uritemplate']
+
+import apiclient

tests/wpt/web-platform-tests/css/tools/apiclient/apiclient/apiclient.py

@@ -0,0 +1,283 @@
+# coding=utf-8
+#
+#  Copyright © 2013 Hewlett-Packard Development Company, L.P.
+#
+#  This work is distributed under the W3C® Software License [1]
+#  in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+#  [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
+#
+
+# Process URI templates per http://tools.ietf.org/html/rfc6570
+
+
+import urllib2
+import urlparse
+import json
+import base64
+import contextlib
+import collections
+import UserString
+
+import uritemplate
+
+class MimeType(UserString.MutableString):
+    def __init__(self, mimeType):
+        UserString.MutableString.__init__(self, mimeType)
+        self._type = None
+        self._subtype = None
+        self._structure = None
+
+        slashIndex = mimeType.find('/')
+        if (-1 < slashIndex):
+            self._type = mimeType[:slashIndex]
+            mimeType = mimeType[slashIndex + 1:]
+            plusIndex = mimeType.find('+')
+            if (-1 < plusIndex):
+                self._subtype = mimeType[:plusIndex]
+                self._structure = mimeType[plusIndex + 1:]
+            else:
+                self._structure = mimeType
+        else:
+            self._type = mimeType
+
+    def _update(self):
+        if (self._structure):
+            if (self._subtype):
+                self.data = self._type + '/' + self._subtype + '+' + self._structure
+            else:
+                self.data = self._type + '/' + self._structure
+        else:
+            self.data = self._type
+
+    def set(self, type, structure, subtype = None):
+        self._type = type
+        self._subtype = subtype
+        self._structure = structure
+        self._update()
+
+    @property
+    def type(self):
+        return self._type
+    
+    @type.setter
+    def type(self, value):
+        self._type = value
+        self._update()
+
+    @property
+    def subtype(self):
+        return self._subtype
+
+    @subtype.setter
+    def subtype(self, value):
+        self._subtype = value
+        self._update()
+
+    @property
+    def structure(self):
+        return self._structure
+
+    @structure.setter
+    def structure(self, value):
+        self._structure = value
+        self._update()
+
+
+class APIResponse(object):
+    def __init__(self, response):
+        self.status = response.getcode() if (response) else 0
+        self.headers = response.info() if (response) else {}
+        self.data = response.read() if (200 == self.status) else None
+
+        if (self.data and
+            (('json' == self.contentType.structure) or ('json-home' == self.contentType.structure))):
+            try:
+                self.data = json.loads(self.data, object_pairs_hook = collections.OrderedDict)
+            except:
+                pass
+
+    @property
+    def contentType(self):
+        contentType = self.headers.get('content-type') if (self.headers) else None
+        return MimeType(contentType.split(';')[0]) if (contentType and (';' in contentType)) else MimeType(contentType)
+    
+    @property
+    def encoding(self):
+        contentType = self.headers.get('content-type') if (self.headers) else None
+        if (contentType and (';' in contentType)):
+            encoding = contentType.split(';', 1)[1]
+            if ('=' in encoding):
+                return encoding.split('=', 1)[1].strip()
+        return 'utf-8'
+    
+
+class APIHints(object):
+    def __init__(self, data):
+        self.httpMethods = [method.upper() for method in data['allow'] if method] if ('allow' in data) else ['GET']
+        self.formats = {}
+        formats = [MimeType(format) for format in data['formats']] if ('formats' in data) else []
+        if (formats):
+            if ('GET' in self.httpMethods):
+                self.formats['GET'] = formats
+            if ('PUT' in self.httpMethods):
+                self.formats['PUT'] = formats
+    
+        if (('PATCH' in self.httpMethods) and ('accept-patch' in data)):
+            self.formats['PATCH'] = [MimeType(format) for format in data['accept-patch']]
+        if (('POST' in self.httpMethods) and ('accept-post' in data)):
+            self.formats['POST'] = [MimeType(format) for format in data['accept-post']]
+    
+        # TODO: ranges from 'accept-ranges'; preferece tokens from 'accept-prefer';
+        #       preconditions from 'precondition-req'; auth from 'auth-req'
+        self.ranges = None
+        self.preferences = None
+        self.preconditions = None
+        self.auth = None
+
+        self.docs = data.get('docs')
+        self.status = data.get('status')
+
+
+class APIResource(object):
+    def __init__(self, baseURI, uri, variables = None, hints = None):
+        try:
+            self.template = uritemplate.URITemplate(urlparse.urljoin(baseURI, uri))
+            if (variables):
+                self.variables = {variable: urlparse.urljoin(baseURI, variables[variable]) for variable in variables}
+            else:
+                self.variables = {variable: '' for variable in self.template.variables}
+            self.hints = hints
+        except Exception as e:
+            self.template = uritemplate.URITemplate('')
+            self.variables = {}
+            self.hints = None
+
+
+class APIClient(object):
+    def __init__(self, baseURI, version = None, username = None, password = None):
+        self._baseURI = baseURI
+        self.defaultVersion = version
+        self.defaultAccept = 'application/json'
+        self.username = username
+        self.password = password
+        self._resources = {}
+        self._versions = {}
+        self._accepts = {}
+        
+        self._loadHome()
+    
+
+    @property
+    def baseURI(self):
+        return self._baseURI
+    
+    def _loadHome(self):
+        home = self._callURI('GET', self.baseURI, 'application/home+json, application/json-home, application/json')
+        if (home):
+            if ('application/json' == home.contentType):
+                for name in home.data:
+                    apiKey = urlparse.urljoin(self.baseURI, name)
+                    self._resources[apiKey] = APIResource(self.baseURI, home.data[name])
+            elif (('application/home+json' == home.contentType) or
+                  ('application/json-home' == home.contentType)):
+                resources =  home.data.get('resources')
+                if (resources):
+                    for name in resources:
+                        apiKey = urlparse.urljoin(self.baseURI, name)
+                        data = resources[name]
+                        uri = data['href'] if ('href' in data) else data.get('href-template')
+                        variables = data.get('href-vars')
+                        hints = APIHints(data['hints']) if ('hints' in data) else None
+                        self._resources[apiKey] = APIResource(self.baseURI, uri, variables, hints)
+
+
+    def relativeURI(self, uri):
+        if (uri.startswith(self.baseURI)):
+            relative = uri[len(self.baseURI):]
+            if (relative.startswith('/') and not self.baseURI.endswith('/')):
+                relative = relative[1:]
+            return relative
+        return uri
+
+    @property
+    def resourceNames(self):
+        return [self.relativeURI(apiKey) for apiKey in self._resources]
+
+    def resource(self, name):
+        return self._resources.get(urlparse.urljoin(self.baseURI, name))
+    
+    def addResource(self, name, uri):
+        resource = APIResource(self.baseURI, uri)
+        apiKey = urlparse.urljoin(self.baseURI, name)
+        self._resources[apiKey] = resource
+
+    def _accept(self, resource):
+        version = None
+        if (api and (api in self._versions)):
+            version = self._versions[api]
+        if (not version):
+            version = self.defaultVersion
+        return ('application/' + version + '+json, application/json') if (version) else 'application/json'
+
+    def _callURI(self, method, uri, accept, payload = None, payloadType = None):
+        try:
+            request = urllib2.Request(uri, data = payload, headers = { 'Accept' : accept })
+            if (self.username and self.password):
+                request.add_header('Authorization', b'Basic ' + base64.b64encode(self.username + b':' + self.password))
+            if (payload and payloadType):
+                request.add_header('Content-Type', payloadType)
+            request.get_method = lambda: method
+            
+            with contextlib.closing(urllib2.urlopen(request)) as response:
+                return APIResponse(response)
+        except Exception as e:
+            pass
+        return None
+    
+    def _call(self, method, name, arguments, payload = None, payloadType = None):
+        apiKey = urlparse.urljoin(self.baseURI, name)
+        resource = self._resources.get(apiKey)
+        
+        if (resource):
+            uri = resource.template.expand(**arguments)
+            if (uri):
+                version = self._versions.get(apiKey) if (apiKey in self._versions) else self.defaultVersion
+                accept = MimeType(self._accepts(apiKey) if (apiKey in self._accepts) else self.defaultAccept)
+                if (version):
+                    accept.subtype = version
+                return self._callURI(method, uri, accept, payload, payloadType)
+        return None
+    
+    def setVersion(self, name, version):
+        apiKey = urlparse.urljoin(self.baseURI, name)
+        self._versions[apiKey] = version
+
+    def setAccept(self, name, mimeType):
+        apiKey = urlparse.urljoin(self.baseURI, name)
+        self._accepts[apiKey] = mimeType
+
+    def get(self, name, **kwargs):
+        return self._call('GET', name, kwargs)
+    
+    def post(self, name, payload = None, payloadType = None, **kwargs):
+        return self._call('POST', name, kwargs, payload, payloadType)
+
+    def postForm(self, name, payload = None, **kwargs):
+        return self._call('POST', name, kwargs, urllib.urlencode(payload), 'application/x-www-form-urlencoded')
+
+    def postJSON(self, name, payload = None, **kwargs):
+        return self._call('POST', name, kwargs, json.dumps(payload), 'application/json')
+
+    def put(self, name, payload = None, payloadType = None, **kwargs):
+        return self._call('PUT', name, kwargs, payload, payloadType)
+
+    def patch(self, name, patch = None, **kwargs):
+        return self._call('PATCH', name, kwargs, json.dumps(patch), 'application/json-patch')
+
+    def delete(self, name, **kwargs):
+        return self._call('DELETE', name, kwargs)
+
+

tests/wpt/web-platform-tests/css/tools/apiclient/apiclient/uritemplate.py

@@ -0,0 +1,379 @@
+# coding=utf-8
+#
+#  Copyright © 2013 Hewlett-Packard Development Company, L.P.
+#
+#  This work is distributed under the W3C® Software License [1]
+#  in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+#  [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
+#
+
+# Process URI templates per http://tools.ietf.org/html/rfc6570
+
+import re
+
+
+class UnsupportedExpression(Exception):
+    def __init__(self, expression):
+        self.expression = expression
+
+    def __unicode__(self):
+        return u'Unsopported expression: ' + self.expression
+
+class BadExpression(Exception):
+    def __init__(self, expression):
+        self.expression = expression
+
+    def __unicode__(self):
+        return u'Bad expression: ' + self.expression
+
+class BadVariable(Exception):
+    def __init__(self, variable):
+        self.variable = variable
+
+    def __unicode__(self):
+        return u'Bad variable: ' + self.variable
+
+class BadExpansion(Exception):
+    def __init__(self, variable):
+        self.variable = variable
+
+    def __unicode__(self):
+        return u'Bad expansion: ' + self.variable
+
+class URITemplate(object):
+    alpha = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    digit = '0123456789'
+    hexdigit = '0123456789ABCDEFabcdef'
+    genDelims = ':/?#[]@'
+    subDelims = "!$&'()*+,;="
+    varstart = alpha + digit + '_'
+    varchar = varstart + '.'
+    unreserved = alpha + digit + '-._~'
+    reserved = genDelims + subDelims
+
+    def __init__(self, template):
+        self.template = template
+
+        self.parts = []
+        parts = re.split(r'(\{[^\}]*\})', self.template)
+        for part in parts:
+            if (part):
+                if (('{' == part[0]) and ('}' == part[-1])):
+                    expression = part[1:-1]
+                    if (re.match('^([a-zA-Z0-9_]|%[0-9a-fA-F][0-9a-fA-F]).*$', expression)):
+                        self.parts.append(SimpleExpansion(expression))
+                    elif ('+' == part[1]):
+                        self.parts.append(ReservedExpansion(expression))
+                    elif ('#' == part[1]):
+                        self.parts.append(FragmentExpansion(expression))
+                    elif ('.' == part[1]):
+                        self.parts.append(LabelExpansion(expression))
+                    elif ('/' == part[1]):
+                        self.parts.append(PathExpansion(expression))
+                    elif (';' == part[1]):
+                        self.parts.append(PathStyleExpansion(expression))
+                    elif ('?' == part[1]):
+                        self.parts.append(FormStyleQueryExpansion(expression))
+                    elif ('&' == part[1]):
+                        self.parts.append(FormStyleQueryContinuation(expression))
+                    elif (part[1] in '=,!@|'):
+                        raise UnsupportedExpression(part)
+                    else:
+                        raise BadExpression(part)
+                else:
+                    if (('{' not in part) and ('}' not in part)):
+                        self.parts.append(Literal(part))
+                    else:
+                        raise BadExpression(part)
+
+    @property
+    def variables(self):
+        vars = set()
+        for part in self.parts:
+            vars.update(part.variables)
+        return vars
+    
+    def expand(self, **kwargs):
+        try:
+            expanded = [part.expand(kwargs) for part in self.parts]
+        except (BadExpansion):
+            return None
+        return ''.join([expandedPart for expandedPart in expanded if (expandedPart is not None)])
+
+    def __str__(self):
+        return self.template.encode('ascii', 'replace')
+
+    def __unicode__(self):
+        return unicode(self.template)
+
+
+class Variable(object):
+    def __init__(self, name):
+        self.name = ''
+        self.maxLength = None
+        self.explode = False
+        self.array = False
+        
+        if (name[0:1] not in URITemplate.varstart):
+            raise BadVariable(name)
+        
+        if (':' in name):
+            name, maxLength = name.split(':', 1)
+            if ((0 < len(maxLength)) and (len(maxLength) < 4)):
+                for digit in maxLength:
+                    if (digit not in URITemplate.digit):
+                        raise BadVariable(name + ':' + maxLength)
+                self.maxLength = int(maxLength)
+                if (not self.maxLength):
+                    raise BadVariable(name + ':' + maxLength)
+            else:
+                raise BadVariable(name + ':' + maxLength)
+        elif ('*' == name[-1]):
+            name = name[:-1]
+            self.explode = True
+        elif ('[]' == name[-2:]):
+            name = name[:-2]
+            self.array = True
+            self.explode = True
+        
+        index = 0
+        while (index < len(name)):
+            codepoint = name[index]
+            if (('%' == codepoint) and
+                ((index + 2) < len(name)) and
+                (name[index + 1] in URITemplate.hexdigit) and
+                (name[index + 2] in URITemplate.hexdigit)):
+                self.name += name[index:index + 3]
+                index += 2
+            elif (codepoint in URITemplate.varchar):
+                self.name += codepoint
+            else:
+                raise BadVariable(name + ((':' + self.maxLength) if (self.maxLength) else '') + ('[]' if (self.array) else ('*' if (self.explode) else '')))
+            index += 1
+
+
+class Expression(object):
+    def __init__(self):
+        pass
+    
+    @property
+    def variables(self):
+        return []
+
+    def _encode(self, value, legal, pctEncoded):
+        output = ''
+        index = 0
+        while (index < len(value)):
+            codepoint = value[index]
+            if (codepoint in legal):
+                output += codepoint
+            elif (pctEncoded and ('%' == codepoint) and
+                  ((index + 2) < len(value)) and
+                  (value[index + 1] in URITemplate.hexdigit) and
+                  (value[index + 2] in URITemplate.hexdigit)):
+                output += value[index:index + 3]
+                index += 2
+            else:
+                utf8 = codepoint.encode('utf8')
+                for byte in utf8:
+                    output += '%' + URITemplate.hexdigit[ord(byte) / 16] + URITemplate.hexdigit[ord(byte) % 16]
+            index += 1
+        return output
+
+    def _uriEncodeValue(self, value):
+        return self._encode(value, URITemplate.unreserved, False)
+
+    def _uriEncodeName(self, name):
+        return self._encode(unicode(name), URITemplate.unreserved + URITemplate.reserved, True) if (name) else ''
+    
+    def _join(self, prefix, joiner, value):
+        if (prefix):
+            return prefix + joiner + value
+        return value
+    
+    def _encodeStr(self, variable, name, value, prefix, joiner, first):
+        if (variable.maxLength):
+            if (not first):
+                raise BadExpansion(variable)
+            return self._join(prefix, joiner, self._uriEncodeValue(value[:variable.maxLength]))
+        return self._join(prefix, joiner, self._uriEncodeValue(value))
+    
+    def _encodeDictItem(self, variable, name, key, item, delim, prefix, joiner, first):
+        joiner = '=' if (variable.explode) else ','
+        if (variable.array):
+            prefix = (prefix + '[' + self._uriEncodeName(key) + ']') if (prefix and not first) else self._uriEncodeName(key)
+        else:
+            prefix = self._join(prefix, '.', self._uriEncodeName(key))
+        return self._encodeVar(variable, key, item, delim, prefix, joiner, False)
+
+    def _encodeListItem(self, variable, name, index, item, delim, prefix, joiner, first):
+        if (variable.array):
+            prefix = prefix + '[' + unicode(index) + ']' if (prefix) else ''
+            return self._encodeVar(variable, None, item, delim, prefix, joiner, False)
+        return self._encodeVar(variable, name, item, delim, prefix, '.', False)
+    
+    def _encodeVar(self, variable, name, value, delim = ',', prefix = '', joiner = '=', first = True):
+        if (isinstance(value, basestring)):
+            return self._encodeStr(variable, name, value, prefix, joiner, first)
+        elif (hasattr(value, 'keys') and hasattr(value, '__getitem__')):    # dict-like
+            if (len(value)):
+                encodedItems = [self._encodeDictItem(variable, name, key, value[key], delim, prefix, joiner, first) for key in value.keys()]
+                return delim.join([item for item in encodedItems if (item is not None)])
+            return None
+        elif (hasattr(value, '__getitem__')):   # list-like
+            if (len(value)):
+                encodedItems = [self._encodeListItem(variable, name, index, item, delim, prefix, joiner, first) for index, item in enumerate(value)]
+                return delim.join([item for item in encodedItems if (item is not None)])
+            return None
+        else:
+            return self._encodeStr(variable, name, unicode(value).lower(), prefix, joiner, first)
+
+    def expand(self, values):
+        return None
+
+
+class Literal(Expression):
+    def __init__(self, value):
+        Expression.__init__(self)
+        self.value = value
+
+    def expand(self, values):
+        return self._encode(self.value, (URITemplate.unreserved + URITemplate.reserved), True)
+
+
+class Expansion(Expression):
+    operator = ''
+    varJoiner = ','
+    
+    def __init__(self, variables):
+        Expression.__init__(self)
+        self.vars = [Variable(var) for var in variables.split(',')]
+
+    @property
+    def variables(self):
+        return [var.name for var in self.vars]
+    
+    def _expandVar(self, variable, value):
+        return self._encodeVar(variable, self._uriEncodeName(variable.name), value)
+    
+    def expand(self, values):
+        expandedVars = []
+        for var in self.vars:
+            if ((var.name in values) and (values[var.name] is not None)):
+                expandedVar = self._expandVar(var, values[var.name])
+                if (expandedVar is not None):
+                    expandedVars.append(expandedVar)
+        if (len(expandedVars)):
+            expanded = self.varJoiner.join(expandedVars)
+            if (expanded is not None):
+                return self.operator + expanded
+        return None
+    
+    
+class SimpleExpansion(Expansion):
+    def __init__(self, variables):
+        Expansion.__init__(self, variables)
+
+
+class ReservedExpansion(Expansion):
+    def __init__(self, variables):
+        Expansion.__init__(self, variables[1:])
+
+    def _uriEncodeValue(self, value):
+        return self._encode(value, (URITemplate.unreserved + URITemplate.reserved), True)
+
+
+class FragmentExpansion(ReservedExpansion):
+    operator = '#'
+    
+    def __init__(self, variables):
+        ReservedExpansion.__init__(self, variables)
+
+
+class LabelExpansion(Expansion):
+    operator = '.'
+    varJoiner = '.'
+    
+    def __init__(self, variables):
+        Expansion.__init__(self, variables[1:])
+
+    def _expandVar(self, variable, value):
+        return self._encodeVar(variable, self._uriEncodeName(variable.name), value, delim = ('.' if variable.explode else ','))
+
+
+class PathExpansion(Expansion):
+    operator = '/'
+    varJoiner = '/'
+    
+    def __init__(self, variables):
+        Expansion.__init__(self, variables[1:])
+
+    def _expandVar(self, variable, value):
+        return self._encodeVar(variable, self._uriEncodeName(variable.name), value, delim = ('/' if variable.explode else ','))
+
+
+class PathStyleExpansion(Expansion):
+    operator = ';'
+    varJoiner = ';'
+    
+    def __init__(self, variables):
+        Expansion.__init__(self, variables[1:])
+
+    def _encodeStr(self, variable, name, value, prefix, joiner, first):
+        if (variable.array):
+            if (name):
+                prefix = prefix + '[' + name + ']' if (prefix) else name
+        elif (variable.explode):
+            prefix = self._join(prefix, '.', name)
+        return Expansion._encodeStr(self, variable, name, value, prefix, joiner, first)
+    
+    def _encodeDictItem(self, variable, name, key, item, delim, prefix, joiner, first):
+        if (variable.array):
+            if (name):
+                prefix = prefix + '[' + name + ']' if (prefix) else name
+            prefix = (prefix + '[' + self._uriEncodeName(key) + ']') if (prefix and not first) else self._uriEncodeName(key)
+        elif (variable.explode):
+            prefix = self._join(prefix, '.', name) if (not first) else ''
+        else:
+            prefix = self._join(prefix, '.', self._uriEncodeName(key))
+            joiner = ','
+        return self._encodeVar(variable, self._uriEncodeName(key) if (not variable.array) else '', item, delim, prefix, joiner, False)
+
+    def _encodeListItem(self, variable, name, index, item, delim, prefix, joiner, first):
+        if (variable.array):
+            if (name):
+                prefix = prefix + '[' + name + ']' if (prefix) else name
+            return self._encodeVar(variable, unicode(index), item, delim, prefix, joiner, False)
+        return self._encodeVar(variable, name, item, delim, prefix, '=' if (variable.explode) else '.', False)
+
+    def _expandVar(self, variable, value):
+        if (variable.explode):
+            return self._encodeVar(variable, self._uriEncodeName(variable.name), value, delim = ';')
+        value = self._encodeVar(variable, self._uriEncodeName(variable.name), value, delim = ',')
+        return (self._uriEncodeName(variable.name) + '=' + value) if (value) else variable.name
+
+
+class FormStyleQueryExpansion(PathStyleExpansion):
+    operator = '?'
+    varJoiner = '&'
+    
+    def __init__(self, variables):
+        PathStyleExpansion.__init__(self, variables)
+
+    def _expandVar(self, variable, value):
+        if (variable.explode):
+            return self._encodeVar(variable, self._uriEncodeName(variable.name), value, delim = '&')
+        value = self._encodeVar(variable, self._uriEncodeName(variable.name), value, delim = ',')
+        return (self._uriEncodeName(variable.name) + '=' + value) if (value is not None) else None
+
+
+class FormStyleQueryContinuation(FormStyleQueryExpansion):
+    operator = '&'
+    
+    def __init__(self, variables):
+        FormStyleQueryExpansion.__init__(self, variables)
+
+

tests/wpt/web-platform-tests/css/tools/apiclient/setup.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+
+from distutils.core import setup
+
+setup(name='apiclient',
+      version='0.10',
+      description='Client for JSPN APIs',
+      author='Peter Linss',
+      author_email='peter.linss@hp.com',
+      url='http://github.com/plinss/apiclient/',
+      packages = ['apiclient']
+     )

tests/wpt/web-platform-tests/css/tools/apiclient/test.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+# coding=utf-8
+#
+#  Copyright © 2013 Hewlett-Packard Development Company, L.P.
+#
+#  This work is distributed under the W3C® Software License [1]
+#  in the hope that it will be useful, but WITHOUT ANY
+#  WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+#  [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
+#
+
+import sys
+import os
+import glob
+import json
+import exceptions
+import collections
+
+from apiclient import uritemplate
+from apiclient import apiclient
+
+
+def runTests(testFileSearch):
+    for testFilePath in glob.glob(testFileSearch):
+        print 'Running tests from: ' + testFilePath
+        with open(testFilePath) as testFile:
+            testData = json.load(testFile, object_pairs_hook = collections.OrderedDict)
+            for testSetName in testData:
+                print testSetName + ':'
+                testSet = testData[testSetName]
+                vars = testSet['variables']
+                for test in testSet['testcases']:
+                    expectedResult = test[1]
+                    try:
+                        template = uritemplate.URITemplate(test[0])
+                    except Exception as e:
+                        if (expectedResult):
+                            print '* FAIL: "' + test[0] + '" got: None, expected "' + expectedResult + '"'
+                        else:
+                            print '  PASS: "' + test[0] + '" == None'
+                        continue
+                    
+                    result = template.expand(**vars)
+                    if (isinstance(expectedResult, basestring)):
+                        if (expectedResult != result):
+                            print '* FAIL: "' + test[0] + '" got: "' + unicode(result) + '", expected "' + expectedResult + '"'
+                            continue
+                    elif (isinstance(expectedResult, list)):
+                        for possibleResult in expectedResult:
+                            if (possibleResult == result):
+                                break
+                        else:
+                            print '* FAIL: "' + test[0] + '" got: "' + unicode(result) + '", expected:'
+                            print " or\n".join(['    "' + possibleResult + '"' for possibleResult in expectedResult])
+                            continue
+                    elif (not expectedResult):
+                        if (result):
+                            print '* FAIL "' + test[0] + '" got: "' + unicode(result) + '", expected None'
+                            continue
+                    else:
+                        print '** Unknown expected result type: ' + repr(expectedResult)
+                    print '  PASS: "' + test[0] + '" == "' + result + '"'
+
+def debugHook(type, value, tb):
+    if hasattr(sys, 'ps1') or not sys.stderr.isatty():
+        # we are in interactive mode or we don't have a tty-like
+        # device, so we call the default hook
+        sys.__excepthook__(type, value, tb)
+    else:
+        import traceback, pdb
+        # we are NOT in interactive mode, print the exception...
+        traceback.print_exception(type, value, tb)
+        print
+        # ...then start the debugger in post-mortem mode.
+        pdb.pm()
+
+
+if __name__ == "__main__":      # called from the command line
+    sys.excepthook = debugHook
+    
+#    runTests(os.path.join('test', '*.json'))
+
+#    runTests(os.path.join('uritemplate-test', 'spec-examples.json'))
+#    runTests(os.path.join('uritemplate-test', '*.json'))
+### more tests @ https://github.com/uri-templates/uritemplate-test
+
+
+    github = apiclient.APIClient('https://api.github.com/', version = 'vnd.github.beta')
+    print github.get('user_url', user = 'plinss').data
+
+#    shepherd = apiclient.APIClient('https://api.csswg.org/shepherd/', version = 'vnd.csswg.shepherd.v1')
+    shepherd = apiclient.APIClient('https://test.linss.com/shepherd/api', version = 'vnd.csswg.shepherd.v1')
+    print shepherd.resourceNames
+    specs = shepherd.resource('specifications')
+    print specs.variables
+#    print specs.hints.docs
+    print shepherd.get('specifications', spec = 'compositing-1', anchors = False).data
+
+    suites = shepherd.resource('test_suites')
+    print suites.variables
+    print shepherd.get('test_suites', spec = 'css-shapes-1').data
+
+

tests/wpt/web-platform-tests/css/tools/apiclient/test/corners.json

@@ -0,0 +1,81 @@
+{
+  "Explode Non-composite" :
+  {
+    "level": 4,
+    "variables": {
+       "token": "12345"
+    },
+    "testcases" : [
+       ["{token}", "12345"],
+       ["{token*}", "12345"],
+       ["{.token}", ".12345"],
+       ["{.token*}", ".12345"],
+       ["{/token}", "/12345"],
+       ["{/token*}", "/12345"],
+       ["{?token}", "?token=12345"],
+       ["{?token*}", "?token=12345"]
+    ]
+  },
+  "Non-string Values" :
+  {
+    "level": 4,
+    "variables": {
+       "positive": true,
+       "negative": false,
+       "zero"    : 0,
+       "number"  : 42.24,
+       "list"    : ["one", 2, true, false, 0],
+       "dict"    : { "one": "1", "two": 2, "positive": true, "negative": false, "zero": 0 }
+    },
+    "testcases" : [
+       ["{positive}", "true"],
+       ["{positive*}", "true"],
+       ["{negative}", "false"],
+       ["{negative*}", "false"],
+       ["{zero}", "0"],
+       ["{zero*}", "0"],
+       ["{number}", "42.24"],
+       ["{number*}", "42.24"],
+       ["{.positive}", ".true"],
+       ["{.positive*}", ".true"],
+       ["{.negative}", ".false"],
+       ["{.negative*}", ".false"],
+       ["{.zero}", ".0"],
+       ["{.zero*}", ".0"],
+       ["{.number}", ".42.24"],
+       ["{.number*}", ".42.24"],
+       ["{/positive}", "/true"],
+       ["{/positive*}", "/true"],
+       ["{/negative}", "/false"],
+       ["{/negative*}", "/false"],
+       ["{/zero}", "/0"],
+       ["{/zero*}", "/0"],
+       ["{/number}", "/42.24"],
+       ["{/number*}", "/42.24"],
+       ["{?positive}", "?positive=true"],
+       ["{?positive*}", "?positive=true"],
+       ["{?negative}", "?negative=false"],
+       ["{?negative*}", "?negative=false"],
+       ["{?zero}", "?zero=0"],
+       ["{?zero*}", "?zero=0"],
+       ["{?number}", "?number=42.24"],
+       ["{?number*}", "?number=42.24"],
+       ["{list}", "one,2,true,false,0"],
+       ["{list*}", "one,2,true,false,0"],
+       ["{.list}", ".one,2,true,false,0"],
+       ["{.list*}", ".one.2.true.false.0"],
+       ["{/list}", "/one,2,true,false,0"],
+       ["{/list*}", "/one/2/true/false/0"],
+       ["{?list}", "?list=one,2,true,false,0"],
+       ["{?list*}", "?list=one&list=2&list=true&list=false&list=0"],
+       ["{dict}", "one,1,two,2,positive,true,negative,false,zero,0"],
+       ["{dict*}", "one=1,two=2,positive=true,negative=false,zero=0"],
+       ["{.dict}", ".one,1,two,2,positive,true,negative,false,zero,0"],
+       ["{.dict*}", ".one=1.two=2.positive=true.negative=false.zero=0"],
+       ["{/dict}", "/one,1,two,2,positive,true,negative,false,zero,0"],
+       ["{/dict*}", "/one=1/two=2/positive=true/negative=false/zero=0"],
+       ["{?dict}", "?dict=one,1,two,2,positive,true,negative,false,zero,0"],
+       ["{?dict*}", "?one=1&two=2&positive=true&negative=false&zero=0"]
+    ]
+  }
+}

tests/wpt/web-platform-tests/css/tools/apiclient/test/extensions.json

@@ -0,0 +1,210 @@
+{
+  "Nested Structures" :
+  {
+    "level": 5,
+    "variables": {
+       "list"  : ["one", "two", "three", "four"],
+       "dict"  : {"semi": ";", "dot": ".", "comma": ","},
+       "lists" : [["one", "two"], ["three"], "four"],
+       "dicts" : {"one": {"semi": ";", "dot": "."}, "two": {"comma": ","}},
+       "mixed" : {"list": ["one", ["two", "three"]], "dict": {"one": {"semi": ";", "dot": "."}, "two": {"comma": ","}}},
+       "dlist" : [{"semi": ";", "dot": "."}, {"comma": ","}]
+     },
+     "testcases" : [
+        ["{list}", "one,two,three,four"],
+        ["{list*}", "one,two,three,four"],
+        ["{?list}", "?list=one,two,three,four"],
+        ["{?list*}", "?list=one&list=two&list=three&list=four"],
+        ["{lists}", "one,two,three,four"],
+        ["{lists*}", "one,two,three,four"],
+        ["{?lists}", "?lists=one,two,three,four"],
+        ["{?lists*}", "?lists=one&lists=two&lists=three&lists=four"],
+        ["{dict}", [
+          "comma,%2C,dot,.,semi,%3B",
+          "comma,%2C,semi,%3B,dot,.",
+          "dot,.,comma,%2C,semi,%3B",
+          "dot,.,semi,%3B,comma,%2C",
+          "semi,%3B,comma,%2C,dot,.",
+          "semi,%3B,dot,.,comma,%2C"
+        ]],
+        ["{dict*}", [
+          "comma=%2C,dot=.,semi=%3B",
+          "comma=%2C,semi=%3B,dot=.",
+          "dot=.,comma=%2C,semi=%3B",
+          "dot=.,semi=%3B,comma=%2C",
+          "semi=%3B,comma=%2C,dot=.",
+          "semi=%3B,dot=.,comma=%2C"
+        ]],
+        ["{?dict}", [
+          "?dict=comma,%2C,dot,.,semi,%3B",
+          "?dict=comma,%2C,semi,%3B,dot,.",
+          "?dict=dot,.,comma,%2C,semi,%3B",
+          "?dict=dot,.,semi,%3B,comma,%2C",
+          "?dict=semi,%3B,comma,%2C,dot,.",
+          "?dict=semi,%3B,dot,.,comma,%2C"
+        ]],
+        ["{?dict*}", [
+          "?comma=%2C&dot=.&semi=%3B",
+          "?comma=%2C&semi=%3B&dot=.",
+          "?dot=.&comma=%2C&semi=%3B",
+          "?dot=.&semi=%3B&comma=%2C",
+          "?semi=%3B&comma=%2C&dot=.",
+          "?semi=%3B&dot=.&comma=%2C"
+        ]],
+        ["{dicts}", [
+          "two.comma,%2C,one.dot,.,one.semi,%3B",
+          "two.comma,%2C,one.semi,%3B,one.dot,.",
+          "one.dot,.,two.comma,%2C,one.semi,%3B",
+          "one.dot,.,one.semi,%3B,two.comma,%2C",
+          "one.semi,%3B,two.comma,%2C,one.dot,.",
+          "one.semi,%3B,one.dot,.,two.comma,%2C"
+        ]],
+        ["{dicts*}", [
+          "two.comma=%2C,one.dot=.,one.semi=%3B",
+          "two.comma=%2C,one.semi=%3B,one.dot=.",
+          "one.dot=.,two.comma=%2C,one.semi=%3B",
+          "one.dot=.,one.semi=%3B,two.comma=%2C",
+          "one.semi=%3B,two.comma=%2C,one.dot=.",
+          "one.semi=%3B,one.dot=.,two.comma=%2C"
+        ]],
+        ["{?dicts}", [
+          "?dicts=two.comma,%2C,one.dot,.,one.semi,%3B",
+          "?dicts=two.comma,%2C,one.semi,%3B,one.dot,.",
+          "?dicts=one.dot,.,two.comma,%2C,one.semi,%3B",
+          "?dicts=one.dot,.,one.semi,%3B,two.comma,%2C",
+          "?dicts=one.semi,%3B,two.comma,%2C,one.dot,.",
+          "?dicts=one.semi,%3B,one.dot,.,two.comma,%2C"
+        ]],
+        ["{?dicts*}", [
+          "?two.comma=%2C&one.dot=.&one.semi=%3B",
+          "?two.comma=%2C&one.semi=%3B&one.dot=.",
+          "?one.dot=.&two.comma=%2C&one.semi=%3B",
+          "?one.dot=.&one.semi=%3B&two.comma=%2C",
+          "?one.semi=%3B&two.comma=%2C&one.dot=.",
+          "?one.semi=%3B&one.dot=.&two.comma=%2C"
+        ]],
+        ["{mixed}", [
+          "list.one,list.two,list.three,dict.two.comma,%2C,dict.one.dot,.,dict.one.semi,%3B",
+          "list.one,list.two,list.three,dict.two.comma,%2C,dict.one.semi,%3B,dict.one.dot,.",
+          "list.one,list.two,list.three,dict.one.dot,.,dict.two.comma,%2C,dict.one.semi,%3B",
+          "list.one,list.two,list.three,dict.one.dot,.,dict.one.semi,%3B,dict.two.comma,%2C",
+          "list.one,list.two,list.three,dict.one.semi,%3B,dict.two.comma,%2C,dict.one.dot,.",
+          "list.one,list.two,list.three,dict.one.semi,%3B,dict.one.dot,.,dict.two.comma,%2C"
+        ]],
+        ["{mixed*}", [
+          "list.one,list.two,list.three,dict.two.comma=%2C,dict.one.dot=.,dict.one.semi=%3B",
+          "list.one,list.two,list.three,dict.two.comma=%2C,dict.one.semi=%3B,dict.one.dot=.",
+          "list.one,list.two,list.three,dict.one.dot=.,dict.two.comma=%2C,dict.one.semi=%3B",
+          "list.one,list.two,list.three,dict.one.dot=.,dict.one.semi=%3B,dict.two.comma=%2C",
+          "list.one,list.two,list.three,dict.one.semi=%3B,dict.two.comma=%2C,dict.one.dot=.",
+          "list.one,list.two,list.three,dict.one.semi=%3B,dict.one.dot=.,dict.two.comma=%2C"
+        ]],
+        ["{?mixed}", [
+          "?mixed=list.one,list.two,list.three,dict.two.comma,%2C,dict.one.dot,.,dict.one.semi,%3B",
+          "?mixed=list.one,list.two,list.three,dict.two.comma,%2C,dict.one.semi,%3B,dict.one.dot,.",
+          "?mixed=list.one,list.two,list.three,dict.one.dot,.,dict.two.comma,%2C,dict.one.semi,%3B",
+          "?mixed=list.one,list.two,list.three,dict.one.dot,.,dict.one.semi,%3B,dict.two.comma,%2C",
+          "?mixed=list.one,list.two,list.three,dict.one.semi,%3B,dict.two.comma,%2C,dict.one.dot,.",
+          "?mixed=list.one,list.two,list.three,dict.one.semi,%3B,dict.one.dot,.,dict.two.comma,%2C"
+        ]],
+        ["{?mixed*}", [
+          "?list=one&list=two&list=three&dict.two.comma=%2C&dict.one.dot=.&dict.one.semi=%3B",
+          "?list=one&list=two&list=three&dict.two.comma,%2C&dict.one.semi=%3B&dict.one.dot=.",
+          "?list=one&list=two&list=three&dict.one.dot=.&dict.two.comma=%2C&dict.one.semi=%3B",
+          "?list=one&list=two&list=three&dict.one.dot=.&dict.one.semi=%3B&dict.two.comma=%2C",
+          "?list=one&list=two&list=three&dict.one.semi=%3B&dict.two.comma=%2C&dict.one.dot=.",
+          "?list=one&list=two&list=three&dict.one.semi=%3B&dict.one.dot=.&dict.two.comma=%2C"
+        ]],
+        ["{dlist}", [
+          "dot,.,semi,%3B,comma,%2C",
+          "semi,%3B,dot,.,comma,%2C"
+        ]],
+        ["{dlist*}", [
+          "dot=.,semi=%3B,comma=%2C",
+          "semi=%3B,dot=.,comma=%2C"
+        ]],
+        ["{?dlist}", [
+          "?dlist=dot,.,semi,%3B,comma,%2C",
+          "?dlist=semi,%3B,dot,.,comma,%2C"
+        ]],
+        ["{?dlist*}", [
+          "?dlist.dot=.&dlist.semi=%3B&dlist.comma=%2C",
+          "?dlist.semi=%3B&dlist.dot=.&dlist.comma=%2C"
+        ]]
+     ]
+  },
+  "Array Modifier" :
+  {
+    "level": 5,
+    "variables": {
+       "list"  : ["one", "two", "three", "four"],
+       "dict"  : {"semi": ";", "dot": ".", "comma": ","},
+       "lists" : [["one", "two"], ["three"], "four"],
+       "dicts" : {"one": {"semi": ";", "dot": "."}, "two": {"comma": ","}},
+       "mixed" : {"list": ["one", ["two", "three"]], "dict": {"one": {"semi": ";", "dot": "."}, "two": {"comma": ","}}},
+       "dlist" : [{"semi": ";", "dot": "."}, {"comma": ","}]
+     },
+     "testcases" : [
+        ["{list[]}", "one,two,three,four"],
+        ["{?list[]}", "?list[0]=one&list[1]=two&list[2]=three&list[3]=four"],
+        ["{lists[]}", "one,two,three,four"],
+        ["{?lists[]}", "?lists[0][0]=one&lists[0][1]=two&lists[1][0]=three&lists[2]=four"],
+        ["{dict[]}", [
+          "comma=%2C,dot=.,semi=%3B",
+          "comma=%2C,semi=%3B,dot=.",
+          "dot=.,comma=%2C,semi=%3B",
+          "dot=.,semi=%3B,comma=%2C",
+          "semi=%3B,comma=%2C,dot=.",
+          "semi=%3B,dot=.,comma=%2C"
+        ]],
+        ["{?dict[]}", [
+          "?comma=%2C&dot=.&semi=%3B",
+          "?comma=%2C&semi=%3B&dot=.",
+          "?dot=.&comma=%2C&semi=%3B",
+          "?dot=.&semi=%3B&comma=%2C",
+          "?semi=%3B&comma=%2C&dot=.",
+          "?semi=%3B&dot=.&comma=%2C"
+        ]],
+        ["{dicts[]}", [
+          "two[comma]=%2C,one[dot]=.,one[semi]=%3B",
+          "two[comma]=%2C,one[semi]=%3B,one[dot]=.",
+          "one[dot]=.,two[comma]=%2C,one[semi]=%3B",
+          "one[dot]=.,one[semi]=%3B,two[comma]=%2C",
+          "one[semi]=%3B,two[comma]=%2C,one[dot]=.",
+          "one[semi]=%3B,one[dot]=.,two[comma]=%2C"
+        ]],
+        ["{?dicts[]}", [
+          "?two[comma]=%2C&one[dot]=.&one[semi]=%3B",
+          "?two[comma]=%2C&one[semi]=%3B&one[dot]=.",
+          "?one[dot]=.&two[comma]=%2C&one[semi]=%3B",
+          "?one[dot]=.&one[semi]=%3B&two[comma]=%2C",
+          "?one[semi]=%3B&two[comma]=%2C&one[dot]=.",
+          "?one[semi]=%3B&one[dot]=.&two[comma]=%2C"
+        ]],
+        ["{mixed[]}", [
+          "list[0]=one,list[1][0]=two,list[1][1]=three,dict[two][comma]=%2C,dict[one][dot]=.,dict[one][semi]=%3B",
+          "list[0]=one,list[1][0]=two,list[1][1]=three,dict[two][comma]=%2C,dict[one][semi]=%3B,dict[one][dot]=.",
+          "list[0]=one,list[1][0]=two,list[1][1]=three,dict[one][dot]=.,dict[two][comma]=%2C,dict[one][semi]=%3B",
+          "list[0]=one,list[1][0]=two,list[1][1]=three,dict[one][dot]=.,dict[one][semi]=%3B,dict[two][comma]=%2C",
+          "list[0]=one,list[1][0]=two,list[1][1]=three,dict[one][semi]=%3B,dict[two][comma]=%2C,dict[one][dot]=.",
+          "list[0]=one,list[1][0]=two,list[1][1]=three,dict[one][semi]=%3B,dict[one][dot]=.,dict[two][comma]=%2C"
+        ]],
+        ["{?mixed[]}", [
+          "?list[0]=one&list[1][0]=two&list[1][1]=three&dict[two][comma]=%2C&dict[one][dot]=.&dict[one][semi]=%3B",
+          "?list[0]=one&list[1][0]=two&list[1][1]=three&dict[two][comma]=%2C&dict[one][semi]=%3B&dict[one][dot]=.",
+          "?list[0]=one&list[1][0]=two&list[1][1]=three&dict[one][dot]=.&dict[two][comma]=%2C&dict[one][semi]=%3B",
+          "?list[0]=one&list[1][0]=two&list[1][1]=three&dict[one][dot]=.&dict[one][semi]=%3B&dict[two][comma]=%2C",
+          "?list[0]=one&list[1][0]=two&list[1][1]=three&dict[one][semi]=%3B&dict[two][comma]=%2C&dict[one][dot]=.",
+          "?list[0]=one&list[1][0]=two&list[1][1]=three&dict[one][semi]=%3B&dict[one][dot]=.&dict[two][comma]=%2C"
+        ]],
+        ["{dlist[]}", [
+          "dot=.,semi=%3B,comma=%2C",
+          "semi=%3B,dot=.,comma=%2C"
+        ]],
+        ["{?dlist[]}", [
+          "?dlist[0][dot]=.&dlist[0][semi]=%3B&dlist[1][comma]=%2C",
+          "?dlist[0][semi]=%3B&dlist[0][dot]=.&dlist[1][comma]=%2C"
+        ]]
+     ]
+  }
+}

tests/wpt/web-platform-tests/css/tools/build.py

@@ -0,0 +1,381 @@
+#!/usr/bin/env python
+
+# CSS Test Suite Build Script
+# Copyright 2011 Hewlett-Packard Development Company, L.P.
+# Initial code by fantasai, joint copyright 2010 W3C and Microsoft
+# Licensed under BSD 3-Clause: <http://www.w3.org/Consortium/Legal/2008/03-bsd-license>
+
+import sys
+import os
+import json
+import optparse
+import shutil
+from collections import defaultdict
+from apiclient import apiclient
+from w3ctestlib import Sources, Utils, Suite, Indexer
+from mercurial import ui
+
+
+
+class Builder(object):
+    def __init__(self, ui, outputPath, backupPath, ignorePaths, onlyCache):
+        self.reset(onlyCache)
+        self.ui = ui
+        self.skipDirs = ('support')
+        self.rawDirs = {'other-formats': 'other'}
+        self.sourceTree = Sources.SourceTree()
+        self.sourceCache = Sources.SourceCache(self.sourceTree)
+        self.cacheDir = 'tools/cache'
+        self.outputPath = outputPath.rstrip('/') if (outputPath) else 'dist'
+        self.backupPath = backupPath.rstrip('/') if (backupPath) else None
+        self.ignorePaths = [path.rstrip('/') for path in ignorePaths] if (ignorePaths) else []
+        self.workPath = 'build-temp'
+        self.ignorePaths += (self.outputPath, self.backupPath, self.workPath)
+
+    def reset(self, onlyCache):
+        self.useCacheOnly = onlyCache
+        self.shepherd = apiclient.apiclient.APIClient('https://api.csswg.org/shepherd/', version = 'vnd.csswg.shepherd.v1') if (not onlyCache) else None
+        self.cacheData = False
+        self.testSuiteData = {}
+        self.specificationData = {}
+        self.flagData = {}
+        self.specNames = {}
+        self.specAnchors = {}
+        self.buildSuiteNames = []
+        self.buildSpecNames = {}
+        self.testSuites = {}
+
+
+    def _loadShepherdData(self, apiName, description, **kwargs):
+        self.ui.status("Loading ", description, " information\n")
+        cacheFile = os.path.join(self.cacheDir, apiName + '.json')
+        if (not self.useCacheOnly or (not os.path.exists(cacheFile))):
+            result = self.shepherd.get(apiName, **kwargs)
+            if (result and (200 == result.status)):
+                data = {}
+                for name in result.data:    # trim leading _
+                    data[name[1:]] = result.data[name]
+                with open(cacheFile, 'w') as file:
+                    json.dump(data, file)
+                return data
+            self.ui.status("Shepherd API call failed, result: ", result.status if result else 'None', "\n")
+        if (os.path.exists(cacheFile)):
+            self.ui.status("Loading cached data.\n")
+            try:
+                with open(cacheFile, 'r') as file:
+                    return json.load(file)
+            except:
+                pass
+        return None
+
+    def _addAnchors(self, anchors, specName):
+        for anchor in anchors:
+            self.specAnchors[specName].add(anchor['uri'].lower())
+            if ('children' in anchor):
+                self._addAnchors(anchor['children'], specName)
+
+    def _normalizeScheme(self, url):
+        if (url and url.startswith('http:')):
+            return 'https:' + url[5:]
+        return url
+
+    def getSpecName(self, url):
+        if (not self.specNames):
+            for specName in self.specificationData:
+                specData = self.specificationData[specName]
+                officialURL = self._normalizeScheme(specData.get('base_uri'))
+                if (officialURL):
+                    if (officialURL.endswith('/')):
+                        officialURL = officialURL[:-1]
+                    self.specNames[officialURL.lower()] = specName
+                draftURL = self._normalizeScheme(specData.get('draft_uri'))
+                if (draftURL):
+                    if (draftURL.endswith('/')):
+                        draftURL = draftURL[:-1]
+                    self.specNames[draftURL.lower()] = specName
+                self.specAnchors[specName] = set()
+                if ('anchors' in specData):
+                    self._addAnchors(specData['anchors'], specName)
+                if ('draft_anchors' in specData):
+                    self._addAnchors(specData['draft_anchors'], specName)
+
+        url = self._normalizeScheme(url.lower())
+        for specURL in self.specNames:
+            if (url.startswith(specURL) and
+                ((url == specURL) or
+                 url.startswith(specURL + '/') or
+                 url.startswith(specURL + '#'))):
+                anchorURL = url[len(specURL):]
+                if (anchorURL.startswith('/')):
+                    anchorURL = anchorURL[1:]
+                specName = self.specNames[specURL]
+                if (anchorURL in self.specAnchors[specName]):
+                    return (specName, anchorURL)
+                return (specName, None)
+        return (None, None)
+
+    def gatherTests(self, dir):
+        dirName = os.path.basename(dir)
+        if (dirName in self.skipDirs):
+            return
+
+        self.ui.note("Scanning directory: ", dir, "\n")
+        suiteFileNames = defaultdict(set)
+        for fileName in Utils.listfiles(dir):
+            filePath = os.path.join(dir, fileName)
+            if not self.sourceTree.isTestCase(filePath):
+                continue
+
+            source = self.sourceCache.generateSource(filePath, fileName)
+            if not source.isTest():
+                continue
+
+            metaData = source.getMetadata(True)
+            if not metaData:
+                if (source.errors):
+                    self.ui.warn("Error parsing '", filePath, "': ", ' '.join(source.errors), "\n")
+                else:
+                    self.ui.warn("No metadata available for '", filePath, "'\n")
+                continue
+
+            for specURL in metaData['links']:
+                specName, anchorURL = self.getSpecName(specURL)
+                if not specName:
+                    self.ui.note("Unknown specification URL: ", specURL, "\n  in: ", filePath, "\n")
+                    continue
+
+                if not specName in self.buildSpecNames:
+                    continue
+
+                if not anchorURL:
+                    self.ui.warn("Test links to unknown specification anchor: ", specURL, "\n  in: ", filePath, "\n")
+                    continue
+
+                for testSuiteName in self.buildSpecNames[specName]:
+                    formats = self.testSuiteData[testSuiteName].get('formats')
+                    if (formats):
+                        for formatName in formats:
+                            if (((formatName) in self.formatData) and
+                                (self.formatData[formatName].get('mime_type') == source.mimetype)):
+                                suiteFileNames[testSuiteName].add(fileName)
+                                break
+                        else:
+                            self.ui.note("Test not in acceptable format: ", source.mimetype, "\n for: ", filePath, "\n")
+
+        for testSuiteName in suiteFileNames:
+            if (dirName in self.rawDirs):
+                self.testSuites[testSuiteName].addRaw(dir, self.rawDirs[dirName])
+            else:
+                self.testSuites[testSuiteName].addTestsByList(dir, suiteFileNames[testSuiteName])
+
+        for subDir in Utils.listdirs(dir):
+            subDirPath = os.path.join(dir, subDir)
+            if (not (self.sourceTree.isIgnoredDir(subDirPath) or (subDirPath in self.ignorePaths))):
+                self.gatherTests(subDirPath)
+
+
+    def _findSections(self, baseURL, anchors, sectionData, parentSectionName = ''):
+        if (anchors):
+            for anchor in anchors:
+                if ('section' in anchor):
+                    sectionData.append((baseURL + anchor['uri'], anchor['name'],
+                                        anchor['title'] if 'title' in anchor else 'Untitled'))
+                else:
+                    sectionData.append((baseURL + anchor['uri'], parentSectionName + '.#' + anchor['name'], None))
+                if ('children' in anchor):
+                    self._findSections(baseURL, anchor['children'], sectionData, anchor['name'])
+        return sectionData
+
+    def getSections(self, specName):
+        specData = self.specificationData[specName]
+        specURL = specData['base_uri'] if ('base_uri' in specData) else specData.get('draft_uri')
+        anchorData = specData['anchors'] if ('anchors' in specData) else specData['draft_anchors']
+        sectionData = []
+        self._findSections(specURL, anchorData, sectionData)
+        return sectionData
+
+    def _user(self, user):
+        if (user):
+            data = user['full_name']
+            if ('organization' in user):
+                data += ', ' + user['organization']
+            if ('uri' in user):
+                data += ', ' + user['uri']
+            elif ('email' in user):
+                data += ', &lt;' + user['email'].replace('@', ' @') + '&gt;'
+            return data
+        return 'None Yet'
+
+    def getSuiteData(self):
+        data = {}
+        for testSuiteName in self.testSuiteData:
+            testSuiteData = self.testSuiteData[testSuiteName]
+            specData = self.specificationData[testSuiteData['specs'][0]]
+            data[testSuiteName] = {
+                'title': testSuiteData['title'] if ('title' in testSuiteData) else 'Untitled',
+                'spec': specData['title'] if ('title' in specData) else specData['name'],
+                'specroot': specData['base_uri'] if ('base_uri' in specData) else specData.get('draft_uri'),
+                'draftroot': specData['draft_uri'] if ('draft_uri' in specData) else specData.get('base_uri'),
+                'owner': self._user(testSuiteData['owners'][0] if ('owners' in testSuiteData) else None),
+                'harness': testSuiteName,
+                'status': testSuiteData['status'] if ('status' in testSuiteData) else 'Unknown'
+            }
+        return data
+
+    def getFlags(self):
+        data = {}
+        for flag in self.flagData:
+            flagData = self.flagData[flag]
+            data[flag] = {
+                'title': flagData['description'] if ('description' in flagData) else 'Unknown',
+                'abbr': flagData['title'] if ('title' in flagData) else flag
+            }
+        return data
+
+
+    def build(self, testSuiteNames):
+        try:
+            os.makedirs(self.cacheDir)
+        except:
+            pass
+        self.testSuiteData = self._loadShepherdData('test_suites', 'test suite', repo = 'css')
+        if (not self.testSuiteData):
+            self.ui.warn("ERROR: Unable to load test suite information.\n")
+            return -1
+        if (testSuiteNames):
+            self.buildSuiteNames = []
+            for testSuiteName in testSuiteNames:
+                if (testSuiteName in self.testSuiteData):
+                    self.buildSuiteNames.append(testSuiteName)
+                else:
+                    self.ui.status("Unknown test suite: ", testSuiteName, "\n")
+        else:
+            self.buildSuiteNames = [testSuiteName for testSuiteName in self.testSuiteData if self.testSuiteData[testSuiteName].get('build')]
+
+        self.buildSpecNames = defaultdict(list)
+        if (self.buildSuiteNames):
+            self.specificationData = self._loadShepherdData('specifications', 'specification', anchors = True, draft = True)
+            if (not self.specificationData):
+                self.ui.warn("ERROR: Unable to load specification information.\n")
+                return -2
+            for testSuiteName in self.buildSuiteNames:
+                specNames = self.testSuiteData[testSuiteName].get('specs')
+                if (specNames):
+                    for specName in specNames:
+                        if (specName in self.specificationData):
+                            self.buildSpecNames[specName].append(testSuiteName)
+                        else:
+                            self.ui.warn("WARNING: Test suite '", testSuiteName, "' references unknown specification: '", specName, "'.\n")
+                else:
+                    self.ui.warn("ERROR: Test suite '", testSuiteName, "' does not have target specifications.\n")
+                    return -6
+        else:
+            self.ui.status("No test suites identified\n")
+            return 0
+
+        if (not self.buildSpecNames):
+            self.ui.status("No target specifications identified\n")
+            return -3
+
+        self.flagData = self._loadShepherdData('test_flags', 'test flag')
+        if (not self.flagData):
+            self.ui.warn("ERROR: Unable to load flag information\n")
+            return -4
+
+        self.formatData = self._loadShepherdData('test_formats', 'test format')
+        if (not self.formatData):
+            self.ui.warn("ERROR: Unable to load format information\n")
+            return -5
+
+
+        self.buildSuiteNames.sort()
+
+        for testSuiteName in self.buildSuiteNames:
+            data = self.testSuiteData[testSuiteName]
+            specData = self.specificationData[data['specs'][0]]
+            specURL = specData['base_uri'] if ('base_uri' in specData) else specData.get('draft_uri')
+            draftURL = specData['draft_uri'] if ('draft_uri' in specData) else specData.get('base_uri')
+            self.testSuites[testSuiteName] = Suite.TestSuite(testSuiteName, data['title'], specURL, draftURL, self.sourceCache, self.ui) # XXX need to support multiple specs
+            if ('formats' in data):
+                self.testSuites[testSuiteName].setFormats(data['formats'])
+
+        self.ui.status("Scanning test files\n")
+
+        for dir in Utils.listdirs('.'):
+            if (not (self.sourceTree.isIgnoredDir(dir) or (dir in self.ignorePaths))):
+                self.gatherTests(dir)
+
+
+        if (os.path.exists(self.workPath)):
+            self.ui.note("Clearing work path: ", self.workPath, "\n")
+            shutil.rmtree(self.workPath)
+
+        suiteData = self.getSuiteData()
+        flagData = self.getFlags()
+        templatePath = os.path.join('tools', 'templates')
+        for testSuiteName in self.buildSuiteNames:
+            testSuite = self.testSuites[testSuiteName]
+            self.ui.status("Building ", testSuiteName, "\n")
+            specSections = self.getSections(self.testSuiteData[testSuiteName]['specs'][0])
+            indexer = Indexer.Indexer(testSuite, specSections, suiteData, flagData, True,
+                                      templatePathList = [templatePath],
+                                      extraData = {'devel' : False, 'official' : True })
+            workPath = os.path.join(self.workPath, testSuiteName)
+            testSuite.buildInto(workPath, indexer)
+
+        # move from work path to output path
+        for testSuiteName in self.buildSuiteNames:
+            workPath = os.path.join(self.workPath, testSuiteName)
+            outputPath = os.path.join(self.outputPath, testSuiteName)
+            backupPath = os.path.join(self.backupPath, testSuiteName) if (self.backupPath) else None
+            if (os.path.exists(workPath)):
+                if (os.path.exists(outputPath)):
+                    if (backupPath):
+                        if (os.path.exists(backupPath)):
+                            self.ui.note("Removing ", backupPath, "\n")
+                            shutil.rmtree(backupPath)       # delete old backup
+                        self.ui.note("Backing up ", outputPath, " to ", backupPath, "\n")
+                        shutil.move(outputPath, backupPath) # backup old output
+                    else:
+                        self.ui.note("Removing ", outputPath, "\n")
+                        shutil.rmtree(outputPath)           # no backups, delete old output
+                self.ui.note("Moving ", workPath, " to ", outputPath, "\n")
+                shutil.move(workPath, outputPath)
+        if (os.path.exists(self.workPath)):
+            shutil.rmtree(self.workPath)
+        return 0
+
+
+
+if __name__ == "__main__":      # called from the command line
+    parser = optparse.OptionParser(usage = "usage: %prog [options] test_suite [...]")
+    parser.add_option("-q", "--quiet",
+                      action = "store_true", dest = "quiet", default = False,
+                      help = "don't print status messages to stdout")
+    parser.add_option("-d", "--debug",
+                      action = "store_true", dest = "debug", default = False,
+                      help = "print detailed debugging information to stdout")
+    parser.add_option("-v", "--verbose",
+                      action = "store_true", dest = "verbose", default = False,
+                      help = "print more detailed debugging information to stdout")
+    parser.add_option("-o", "--output", dest = "output", metavar = "OUTPUT_PATH",
+                      help = "Path to build into (default 'dist')")
+    parser.add_option("-b", "--backup", dest = "backup", metavar = "BACKUP_PATH",
+                      help = "Path to preserve old version to")
+    parser.add_option("-i", "--ignore",
+                      action = "append", dest = "ignore", metavar = "IGNORE_PATH",
+                      help = "Ignore files in this path")
+    parser.add_option("-c", "--cache",
+                      action = "store_true", dest = "cache", default = False,
+                      help = "use cached test suite and specification data only")
+    (options, args) = parser.parse_args()
+
+
+    ui = ui.ui()
+    ui.setconfig('ui', 'debug', str(options.debug))
+    ui.setconfig('ui', 'quiet', str(options.quiet))
+    ui.setconfig('ui', 'verbose', str(options.verbose))
+
+    builder = Builder(ui, options.output, options.backup, options.ignore, options.cache)
+    result = builder.build(args)
+    quit(result)

tests/wpt/web-platform-tests/css/tools/html2xhtml.py

@@ -0,0 +1,77 @@
+#!/usr/bin/python
+
+# This file is licensed under CC Zero
+
+import sys
+import html5lib
+import re
+
+if len(sys.argv) != 3:
+  print """! html2xhtml requires two arguments: the filename to read, and the filename to write"""
+  exit()
+
+#######################################################################
+# Parse HTML and output XHTML
+
+f = open(sys.argv[1])
+p = html5lib.HTMLParser()
+t = p.parse(f)
+o = html5lib.serializer.serialize(t, format='xhtml')
+f.close()
+
+#######################################################################
+# Clean up the mess left by html5lib
+
+def firstMatch(m): # Python makes s/x(y+)?/z$1/ very difficult
+  if m.group(1):
+    return m.group(1)
+  return ''
+
+# Missing XHTML artifacts
+
+o = re.sub('<!DOCTYPE [^>]+>',
+           '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
+           o);
+o = re.sub('<html( [^>]+)?>',
+           lambda m : '<html' + firstMatch(m) + ' xmlns="http://www.w3.org/1999/xhtml">',
+           o);
+
+# Fix weird reordering
+
+o = re.sub('<link href="(.*?)" (.*?) ?/>',
+           lambda m : '<link ' + m.group(2) + ' href="' + m.group(1) + '"/>',
+           o);
+
+# Indentation
+
+o = re.sub('<!DOCTYPE ([^>]+)><html',
+           lambda m : '<!DOCTYPE ' +  firstMatch(m) + '>\n<html',
+           o);
+o = re.sub('<html( [^>]+)?><',
+           lambda m : '<html' + firstMatch(m) + '>\n<',
+           o);
+o = re.sub('<head( [^>]+)?><',
+           lambda m : '<head' + firstMatch(m) + '>\n<',
+           o);
+o = re.sub('</head><',
+           '</head>\n<',
+           o);
+o = re.sub('<body( [^>]+)?><',
+           lambda m : '<body' + firstMatch(m) + '>\n<',
+           o);
+o = re.sub('</body><',
+           '</body>\n<',
+           o);
+o = re.sub('</html>$',
+           '</html>\n',
+           o);
+o = re.sub('\xa0',
+           '&nbsp;',
+           o); # make nbsp visible to people viewing source
+
+#######################################################################
+# Write to file
+
+f = open(sys.argv[2], 'w')
+f.write(o.encode('utf-8'))
+f.close()

tests/wpt/web-platform-tests/css/tools/list-all.pl

@@ -0,0 +1,86 @@
+#!/usr/bin/perl
+# Print all files by filename and highlight duplicates
+# Prints in format specified as an argument on the command line:
+#   '-txt'  -> tab-separated database
+#   '-pre'  -> linkified tab-separated database using HTML and <pre>
+#   '-html' -> HTML with tables
+
+use Template;
+
+$top = $ARGV[-1] || '.';
+
+@files = `find $top -type f ! -ipath '*.hg*' ! -ipath '*build-test*' ! -ipath '*selectors3*'`;
+foreach (@files) {
+  chomp;
+  m!^(?:\./)?((?:[^/]+/)*)([^/]+?)(\.[a-z]+)?$!;
+  next if (m!/support/!);
+  next if (m!\.css$!);
+  next if (m!boland!);
+  unless (exists $pairs{$2}) {
+    $pairs{$2} = ["$1$2$3"];
+  }
+  else {
+    push @{$pairs{$2}}, "$1$2$3";
+  }
+}
+
+my $tt = Template->new({ INCLUDE_PATH => $libroot . '/templates' }) || die $tt->error(), "\n";
+
+# default template
+$tmpl = <<'EOM'
+[%- FOREACH name = pairs.keys.sort %]
+[%- FOREACH path = pairs.$name %]
+[% name %]	[% path %]
+[%- END %][% END %]
+EOM
+;
+# linkified version
+if ($ARGV[0] eq '-pre') {
+  $tmpl = <<'EOM'
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
+<title>CSS Tests by Filename</title>
+<pre> <!-- tables are too slow -->
+[%- FOREACH name = pairs.keys.sort %]
+[%- FOREACH path = pairs.$name %]
+[% name %]	<a href="[% path %]">[% path %]</a>
+[%- END %][% END %]
+</pre>
+EOM
+}
+# tables version
+elsif ($ARGV[0] eq '-html') {
+  $tmpl = <<'EOM'
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
+<html>
+  <title>CSS Tests by Filename</title>
+  <style type="text/css">
+     table { table-layout: fixed; }
+     .dup { background: yellow; }
+     th, td { text-align: left; }
+  </style>
+<body>
+
+<h1>CSS Tests by Filename</h1>
+
+<table>
+  <thead>
+    <tr><th>Filename <th>Path</tr>
+  </thead>
+[%- FOREACH pair = pairs.pairs %]
+  <tbody>
+  [%- first = 1 %]
+  [%- FOREACH path = pair.value %]
+    <tr[%' class="support"' IF path.match('support') %]>
+    [%- IF first %]
+      <th rowspan="[% pair.value.size %]">[% pair.key %]
+    [%- END %]
+      <td><a href="[% path %]">[% path %]</a>
+    [%- first = 0 %]
+  [%- END %]
+  </tbody>
+[%- END %]
+</table>
+EOM
+}
+
+$tt->process(\$tmpl, { 'pairs' => \%pairs });

tests/wpt/web-platform-tests/css/tools/list-all.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+# First arg is directory path to list, second arg is path to output file (minus file extension)
+find $1 -type f ! -ipath '*.hg*' ! -ipath '*build-test*' ! -ipath '*selectors3*' ! -ipath '*/support/*' ! -ipath '*boland*' ! -ipath '*incoming*' > $2.txt
+perl -pi -e "s#^$1/?((?:[^/]+/)*)([^/]+?)(\.[a-z]+)?\$#\$2\t\$1\$2\$3#" $2.txt
+sort $2.txt -o $2.txt
+echo '<!DOCTYPE html><html><title>CSS Tests by Filename</title><pre>' > $2.html
+perl -pe 's#\t(.+)$#\t<a href="$1">$1</a>#' < $2.txt >> $2.html
+echo '</pre>' >> $2.html

tests/wpt/web-platform-tests/css/tools/make-html.py

@@ -0,0 +1,66 @@
+#!/usr/bin/python
+
+# HTMLMake
+# Converts all files of specified extension from XHTML to HTML
+# Written by fantasai
+# Joint copyright 2010 W3C and Microsoft
+# Licensed under BSD 3-Clause: <http://www.w3.org/Consortium/Legal/2008/03-bsd-license>
+
+srcExt = '.xht'
+dstExt = '.htm'
+skipDirs = ('contributors/microsoft/submitted/support', # XXXfixme files should be .xht
+            'incoming', '.svn', 'CVS', '.hg')
+
+import os.path
+from os.path import join, getmtime
+import sys
+import re
+import os
+from w3ctestlib.Sources import XHTMLSource, SourceTree
+
+def xhtml2html(source, dest):
+    """Convert XHTML file given by path `source` into HTML file at path `dest`."""
+
+    # Parse and serialize
+    xs = XHTMLSource(SourceTree(None), source, dest)
+    o = xs.serializeHTML()
+
+    # Report errors
+    if xs.error:
+      print >>sys.stderr, "Error parsing XHTML file %s: %s" % (source, xs.error)
+
+    # Write
+    f = open(dest, 'w')
+    f.write(o.encode(xs.encoding, 'xmlcharrefreplace'))
+    f.close()
+
+if len(sys.argv) == 3:
+    clobber = sys.argv[1] == '--clobber'
+    force   = sys.argv[1] == '-f'
+    root    = sys.argv[2]
+elif len(sys.argv) == 2 and (sys.argv[1] != '--clobber' and sys.argv[1] != '-f'):
+    clobber = False;
+    force   = False;
+    root    = sys.argv[1]
+else:
+    print "make-html converts all %s XHTML files to %s HTML files." % (srcExt, dstExt)
+    print "Only changed files are converted, unless you specify -f."
+    print "To use, specify the root directory of the files you want converted, e.g."
+    print "  make-html ."
+    print "To delete all files with extension %s, specify the --clobber option." % dstExt
+    exit()
+
+for root, dirs, files in os.walk(root):
+    for skip in skipDirs:
+        if skip in dirs:
+            dirs.remove(skip)
+    for file in files:
+        if clobber:
+            if file.endswith(dstExt):
+                os.remove(join(root, file))
+        elif file.endswith(srcExt):
+            source = join(root, file)
+            dest = join(root, file[0:-1*len(srcExt)] + dstExt)
+            if not os.path.exists(dest) or getmtime(source) > getmtime(dest) or force:
+                # print "Processing %s" % source
+                xhtml2html(source, dest)

tests/wpt/web-platform-tests/css/tools/supportprop.py

@@ -0,0 +1,156 @@
+#!/usr/bin/python
+
+# This file is licensed under CC Zero
+
+import os
+from os.path import join
+import shutil
+import filecmp
+
+# Files to not sync across support/ directories
+fileExcludes = ('README')
+dirExcludes = ('.svn', '.hg', 'CVS')
+# To prevent support files from being propagated into a particular support/
+# directory, add a file named LOCK
+
+def propagate(source, dest, errors):
+  """Compare each file and copy from source to destination.
+     Do nothing and flag an error if the destination already exists
+     but is different. Recurse.
+     source and dest are both directory paths.
+     errors is a list of 2-element tuples, the first being a
+       source filepath and the second a destination filepath,
+       of file pairs where the destination isdifferent from
+  """
+
+  # This directory is locked; don't propagate
+  if os.path.exists(join(dest, 'LOCK')): return
+
+  # If the source directory doesn't exist return
+  if not os.path.exists(source): return
+
+  # Get the file and directory lists for source
+  children = os.listdir(source)
+  for name in children:
+    origin = join(source, name)
+    copy = join(dest, name)
+    if os.path.isfile(origin):
+      if name in fileExcludes: continue
+      # Copy over the file if it needs copying
+      if not os.path.exists(copy): # file missing
+        shutil.copy2(origin, copy) # copy it over
+      elif not filecmp.cmp(origin, copy): # files differ
+        if not filecmp.cmp(origin, copy, True): # contents equal, stats differ
+          shutil.copystat(origin, copy) # update stats so they match for next time
+        else: # contents differ
+          errors.append((origin, copy))
+    elif os.path.isdir(origin):
+      if name in dirExcludes: continue
+      # Duplicate the directory structure and propagate the subtree
+      if not os.path.exists(copy):
+        os.makedirs(copy)
+      propagate(origin, copy, errors)
+  if len(children) == 0:
+    print "Warn: " + source + " is empty.\n"
+
+def waterfall(parentDir, childDir, errors):
+  """Copy down support files from parent support to child.
+     parentDir is the parent of the parent support directory.
+     childDir is the parent of the current support directory,
+     that we should copy into.
+     waterfall recurses into childDir's children."""
+  assert os.path.exists(join(parentDir, 'support')), join(parentDir, 'support') + " doesn't exist\n"
+  if os.path.exists(join(childDir, 'support')):
+    propagate(join(parentDir, 'support'), join(childDir, 'support'), errors)
+    dirs = os.walk(childDir).next()[1]
+    for name in dirs:
+      if name == 'support':
+        pass
+      elif name not in dirExcludes:
+        waterfall(childDir, join(childDir, name), errors)
+
+def outline(source, dest, errors):
+  """Copy over directory structure and all files under any support/ directories
+     source and dest are both directory paths.
+     errors is a list of 2-element tuples, the first being a
+       source filepath and the second a destination filepath,
+       of support file pairs where the destination copy is
+       different from the source
+  """
+  # Get the directory list for source
+  dirs = os.walk(source).next()[1]
+  # Copy directory structure
+  for name in dirs:
+    if name in dirExcludes: continue
+    origin = join(source, name)
+    copy = join(dest, name)
+    if not os.path.exists(copy):
+      os.mkdirs(copy)
+    if name == 'support':
+      # Copy support files
+      propagate(origin, copy, errors)
+    else:
+      outline(origin, copy, errors)
+
+def syncSupport(source, dest, errors):
+  """For each support directory in dest, propagate the corresponding support
+     files from source.
+     source and dest are both directory paths.
+     errors is a list of 2-element tuples, the first being a
+       source filepath and the second a destination filepath,
+       of support file pairs where the destination copy is
+       different from the source
+  """
+  # Get the directory list for est
+  dirs = os.walk(dest).next()[1]
+  # Scan directory structure, building support dirs as necessary
+  for name in dirs:
+    if name in dirExcludes: continue
+    master = join(source, name)
+    slave  = join(dest, name)
+    if name == 'support':
+      # Copy support files
+      propagate(master, slave, errors)
+    else:
+      syncSupport(master, slave, errors)
+
+def main():
+  # Part I: Propagate support files through approved/
+
+  errors = []
+  root, dirs, _ = os.walk('.').next()
+  if 'approved' in dirs:
+    root = join(root, 'approved')
+    suites = os.walk(root).next()[1]
+    suites = filter(lambda name: name not in dirExcludes, suites)
+    for suite in suites:
+      waterfall(root, join(root, suite, 'src'), errors)
+  else:
+    print "Failed to find approved/ directory.\n"
+    exit();
+
+  # Part II: Propagate test suite support files into contributors/
+
+  if 'contributors' in dirs:
+    _, contribs, _ = os.walk('contributors').next()
+    for contributor in contribs:
+      contribRoot = join('contributors', contributor, 'submitted')
+      if not os.path.exists(contribRoot): continue # missing submitted folder
+      dirs = os.walk(contribRoot).next()[1]
+      for dir in dirs:
+        # Check if contributor has a top-level directory name matching
+        # one of our suites; if so, sync any matching support directories
+        if dir in suites:
+          suiteRoot = join(root, dir, 'src')
+          if os.path.exists(suiteRoot):
+            syncSupport(suiteRoot, join(contribRoot, dir), errors)
+  else:
+    print "Failed to find contributors/ directory.\n"
+
+  # Print all errors
+
+  for error in errors:
+    print "Mismatch: " + error[0] + " vs " + error [1] + " Copy failed.\n"
+
+if __name__ == "__main__":
+  main()

tests/wpt/web-platform-tests/css/tools/templates/filename-list.tmpl

@@ -0,0 +1,18 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
+<html>
+  <title>CSS Tests by Filename</title>
+
+<body>
+
+<h1>CSS Tests by Filename</h1>
+
+<table>
+  <thead>
+    <tr><th>Filename <th>Path</tr>
+  </thead>
+  <tbody>
+[% FOREACH pair = pairs.sort %][% parts = pair.split('\t') %]
+    <tr><th>[% parts.0 %] <td><a href="[% parts.1 %]">[% parts.1 %]</a>
+[% END %]
+  </tbody>
+</table>

tests/wpt/web-platform-tests/css/tools/travis/LICENSE

@@ -0,0 +1,12 @@
+Copyright (c) 2015, Mozilla
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

tests/wpt/web-platform-tests/css/tools/travis/build.py

@@ -0,0 +1,223 @@
+import itertools
+import os
+import shutil
+import subprocess
+import sys
+
+import vcs
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+source_dir = os.path.join(here, "..", "..")
+
+remote_built = "https://github.com/jgraham/css-test-built.git"
+built_dir = os.path.join(here, "css-test-built")
+
+local_files = ["manifest", "serve", "serve.py", ".gitmodules", "tools", "resources",
+               "config.default.json"]
+
+def get_hgsubstate():
+    state = {}
+    with open(os.path.join(source_dir, ".hgsubstate"), "r") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            revision, path = line.split(" ", 1)
+            state[path] = revision
+    return state
+
+def fetch_submodules():
+    hg = vcs.hg
+    orig_dir = os.getcwd()
+    state = get_hgsubstate()
+    for tool in ["apiclient", "w3ctestlib"]:
+        dest_dir = os.path.join(source_dir, "tools", tool)
+        repo_path = "tools/" + tool
+        if os.path.exists(os.path.join(dest_dir, ".hg")):
+            try:
+                os.chdir(dest_dir)
+                if repo_path in state:
+                    rev = state[repo_path]
+                    try:
+                        hg("update", rev, log_error=False)
+                    except subprocess.CalledProcessError:
+                        hg("pull")
+                        hg("update", rev)
+                else:
+                    hg("pull")
+                    hg("update")
+            finally:
+                os.chdir(orig_dir)
+        else:
+            hg("clone", ("https://hg.csswg.org/dev/%s" % tool), dest_dir)
+            try:
+                os.chdir(dest_dir)
+                if repo_path in state:
+                    hg("update", state[repo_path])
+                else:
+                    hg("update")
+            finally:
+                os.chdir(orig_dir)
+
+def update_dist():
+    if not os.path.exists(built_dir) or not vcs.is_git_root(built_dir):
+        git = vcs.git
+        git("clone", "--depth", "1", remote_built, built_dir)
+    else:
+        git = vcs.bind_to_repo(vcs.git, built_dir)
+        git("fetch")
+        if "origin/master" in git("branch", "-a"):
+            git("checkout", "master")
+            git("merge", "--ff-only", "origin/master")
+
+    git = vcs.bind_to_repo(vcs.git, built_dir)
+    git("config", "user.email", "CssBuildBot@users.noreply.github.com")
+    git("config", "user.name", "CSS Build Bot")
+    git("submodule", "update", "--init", "--recursive")
+
+def setup_virtualenv():
+    virtualenv_path = os.path.join(here, "_virtualenv")
+
+    if not os.path.exists(virtualenv_path):
+        subprocess.check_call(["virtualenv", virtualenv_path])
+
+    activate_path = os.path.join(virtualenv_path, "bin", "activate_this.py")
+
+    execfile(activate_path, dict(__file__=activate_path))
+
+    subprocess.check_call(["pip", "-q", "install", "mercurial"])
+    subprocess.check_call(["pip", "-q", "install", "html5lib==0.9999999"])
+    subprocess.check_call(["pip", "-q", "install", "lxml"])
+    subprocess.check_call(["pip", "-q", "install", "Template-Python"])
+
+
+def update_to_changeset(changeset):
+    git = vcs.bind_to_repo(vcs.git, source_dir)
+    git("checkout", changeset)
+    apply_build_system_fixes()
+
+def apply_build_system_fixes():
+    fixes = [
+        "c017547f65e07bdd889736524d47824d032ba2e8",
+        "cb4a737a88aa7e2f4e54383c57ffa2dfae093dcf",
+        "ec540343a3e729644c8178dbcf6d063dca20d49f",
+    ]
+    git = vcs.bind_to_repo(vcs.git, source_dir)
+    for fix in fixes:
+        git("cherry-pick", "--keep-redundant-commits", fix)
+
+def build_tests():
+    subprocess.check_call(["python", os.path.join(source_dir, "tools", "build.py")],
+                           cwd=source_dir)
+
+def remove_current_files():
+    for node in os.listdir(built_dir):
+        if node.startswith(".git"):
+            continue
+
+        if node in ("resources", "tools"):
+            continue
+
+        path = os.path.join(built_dir, node)
+        if os.path.isdir(path):
+            shutil.rmtree(path)
+        else:
+            os.remove(path)
+
+def copy_files():
+    dist_path = os.path.join(source_dir, "dist")
+    for node in os.listdir(dist_path):
+        src_path = os.path.join(dist_path, node)
+        dest_path = os.path.join(built_dir, node)
+        if os.path.isdir(src_path):
+            shutil.copytree(src_path, dest_path)
+        else:
+            shutil.copy2(src_path, dest_path)
+
+def update_git():
+    git = vcs.bind_to_repo(vcs.git, built_dir)
+    git("add", ".")
+
+def add_changeset(changeset):
+    git = vcs.bind_to_repo(vcs.git, built_dir)
+
+    dest_path = os.path.join(built_dir, "source_rev")
+    with open(dest_path, "w") as f:
+        f.write(changeset)
+    git("add", os.path.relpath(dest_path, built_dir))
+
+def commit(changeset):
+    git = vcs.git
+
+    msg = git("log", "-r", changeset, "-n", "1", "--pretty=%B", repo=source_dir)
+    msg = "%s\n\nBuild from revision %s" % (msg, changeset)
+
+    git("commit", "-m", msg, repo=built_dir)
+
+def get_new_commits():
+    git = vcs.bind_to_repo(vcs.git, source_dir)
+    commit_path = os.path.join(built_dir, "source_rev")
+    with open(commit_path) as f:
+        prev_commit = f.read().strip()
+
+    if git("rev-parse", "--revs-only", prev_commit).strip() != prev_commit:
+        # we don't have prev_commit in current tree, so let's just do what's new
+        commit_range = os.environ['TRAVIS_COMMIT_RANGE']
+        assert (os.environ["TRAVIS_PULL_REQUEST"] != "false" or
+                os.environ["TRAVIS_BRANCH"] != "master")
+    else:
+        merge_base = git("merge-base", prev_commit, os.environ['TRAVIS_COMMIT']).strip()
+        commit_range = "%s..%s" % (merge_base, os.environ['TRAVIS_COMMIT'])
+
+    commits = git("log", "--pretty=%H", "-r", commit_range).strip()
+    if not commits:
+        return []
+    return reversed(commits.split("\n"))
+
+def maybe_push():
+    if os.environ["TRAVIS_PULL_REQUEST"] != "false":
+        return
+
+    if os.environ["TRAVIS_BRANCH"] != "master":
+        return
+
+    git = vcs.bind_to_repo(vcs.git, built_dir)
+
+    out = "https://%s@github.com/jgraham/css-test-built.git" % os.environ["TOKEN"]
+    git("remote", "add", "out", out, quiet=True)
+
+    for i in range(2):
+        try:
+            git("push", "out", "HEAD:master")
+        except subprocess.CalledProcessError:
+            if i == 0:
+                git("fetch", "origin")
+                git("rebase", "origin/master")
+        else:
+            return
+
+    raise Exception("Push failed")
+
+def main():
+    setup_virtualenv()
+    fetch_submodules()
+    update_dist()
+    changesets = list(get_new_commits())
+    print >> sys.stderr, "Building %d changesets:" % len(changesets)
+    print >> sys.stderr, "\n".join(changesets)
+    if len(changesets) > 50:
+        raise Exception("Building more than 50 changesets, giving up")
+
+    for changeset in changesets:
+        update_to_changeset(changeset)
+        remove_current_files()
+        build_tests()
+        copy_files()
+        update_git()
+        add_changeset(changeset)
+        commit(changeset)
+    maybe_push()
+
+if __name__ == "__main__":
+    main()

tests/wpt/web-platform-tests/css/tools/travis/vcs.py

@@ -0,0 +1,43 @@
+import subprocess
+import sys
+from functools import partial
+
+def vcs(bin_name):
+    def inner(command, *args, **kwargs):
+        repo = kwargs.pop("repo", None)
+        log_error = kwargs.pop("log_error", True)
+        quiet = kwargs.pop("quiet", False)
+        if kwargs:
+            raise TypeError, kwargs
+
+        args = list(args)
+
+        proc_kwargs = {}
+        if repo is not None:
+            proc_kwargs["cwd"] = repo
+
+        command_line = [bin_name, command] + args
+        if not quiet:
+            print >> sys.stderr, " ".join(command_line[:10])
+        try:
+            return subprocess.check_output(command_line, stderr=subprocess.STDOUT, **proc_kwargs)
+        except subprocess.CalledProcessError as e:
+            if log_error:
+                print >> sys.stderr, e.output
+            raise
+    return inner
+
+git = vcs("git")
+hg = vcs("hg")
+
+
+def bind_to_repo(vcs_func, repo):
+    return partial(vcs_func, repo=repo)
+
+
+def is_git_root(path):
+    try:
+        rv = git("rev-parse", "--show-cdup", repo=path)
+    except subprocess.CalledProcessError:
+        return False
+    return rv == "\n"

tests/wpt/web-platform-tests/css/tools/w3ctestlib/.hgignore

@@ -0,0 +1,7 @@
+syntax: glob
+
+*.xcodeproj
+*.DS_Store
+*.pyc
+*.svn
+*.directory

tests/wpt/web-platform-tests/css/tools/w3ctestlib/Groups.py

@@ -0,0 +1,201 @@
+#!/usr/bin/python
+# CSS Test Suite Manipulation Library
+# Initial code by fantasai, joint copyright 2010 W3C and Microsoft
+# Licensed under BSD 3-Clause: <http://www.w3.org/Consortium/Legal/2008/03-bsd-license>
+
+import shutil
+import filecmp
+import os.path
+import Utils
+from os.path import exists, join
+from Sources import SourceCache, SourceSet, ConfigSource, ReftestManifest
+from Utils import listfiles
+
+excludeDirs = ['CVS', '.svn', '.hg']
+
+class TestGroup:
+  """Base class for test groups. Should never be used directly.
+  """
+
+  @staticmethod
+  def combine(groupA, groupB):
+    """Merge TestGroup `groupB` into `groupA`. Return the result of the merge.
+       Can accept none as arguments.
+    """
+    if groupA and groupB:
+      groupA.merge(groupB)
+    return groupA or groupB
+
+  def __init__(self, sourceCache, importDir, name=None, title=None, ui = None, **kwargs):
+    """Initialize with:
+         SourceCache `sourceCache`
+         Group name `name`, which must be a possible directory name or None
+         Directory path `importDir`, whose context is imported into the group
+         Option: Tuple of support directory names `supportDirNames` defaults
+                 to ('support',).
+         Kwarg: File path manifestPath relative to `importDir` that
+           identifies the reftest manifest file (usually called 'reftest.list').
+         Kwarg: File path manifestDest as destination (relative) path for
+                the reftest manifest file. Defaults to value of manifestPath.
+         If manifest provided, assumes that only the files listed in the manifest,
+         the .htaccess files in its parent directory, and the `importDir`'s
+         .htaccess file and support directory are relevant to the test suite.
+    """
+    assert exists(importDir), "Directory to import %s does not exist" % importDir
+
+    # Save name
+    self.name = name
+    self.title = title
+    
+    self.ui = ui
+    
+    sourceTree = sourceCache.sourceTree
+
+    # Load htaccess
+    htapath = join(importDir, '.htaccess')
+    self.htaccess = ConfigSource(sourceTree, htapath, '.htaccess') \
+                    if exists(htapath) else None
+
+    # Load support files
+    self.support = SourceSet(sourceCache)
+    supportDirNames = kwargs.get('supportDirNames', ('support',))
+    for supportName in supportDirNames:
+      supportDir = join(importDir, supportName)
+      if exists(supportDir):
+        for (root, dirs, files) in os.walk(supportDir):
+          for dir in excludeDirs:
+            if dir in dirs:
+              dirs.remove(dir)
+          for name in files:
+            sourcepath = join(root, name)
+            relpath = Utils.relpath(sourcepath, importDir)
+            self.support.add(sourcepath, relpath, self.ui)
+
+    # Load tests
+    self.tests = SourceSet(sourceCache)
+    self.refs  = SourceSet(sourceCache)
+
+    # Read manifest
+    manifestPath = kwargs.get('manifestPath', None)
+    manifestDest = kwargs.get('manifestDest', manifestPath)
+    if (manifestPath):
+      self.manifest = ReftestManifest(join(importDir, manifestPath), manifestDest)
+
+      # Import tests
+      for (testSrc, refSrc), (testRel, refRel), refType in self.manifest:
+        test = sourceCache.generateSource(testSrc, testRel)
+        ref = sourceCache.generateSource(refSrc, refRel)
+        test.addReference(ref, refType)
+        self.tests.addSource(test, self.ui)
+    else:
+      self.manifest = None
+      # Import tests
+      fileNameList = []
+      if kwargs.get('selfTestExt'):
+        fileNameList += listfiles(importDir, kwargs['selfTestExt'])
+      if kwargs.get('selfTestList'):
+        fileNameList += kwargs['selfTestList']
+      for fileName in fileNameList:
+        filePath = join(importDir, fileName)
+        if sourceTree.isTestCase(filePath):
+          test = sourceCache.generateSource(filePath, fileName)
+          if (test.isTest()):
+            self.tests.addSource(test, self.ui)
+
+    for test in self.tests.iter():
+      if (test.isReftest()):
+        usedRefs = {}
+        usedRefs[test.sourcepath] = '=='
+        def loadReferences(source): # XXX need to verify refType for mutual exclusion (ie: a == b != a)
+          for refSrcPath, refRelPath, refType in source.getReferencePaths():
+            if (exists(refSrcPath)):
+              ref = sourceCache.generateSource(refSrcPath, refRelPath)
+              source.addReference(ref)
+              if (refSrcPath not in usedRefs):
+                usedRefs[refSrcPath] = refType
+                if (ref not in self.tests):
+                  self.refs.addSource(ref, self.ui)
+                loadReferences(ref)
+            else:
+              ui.warn("Missing Reference file: ", refSrcPath, "\n  referenced from: ", source.sourcepath, "\n")
+        loadReferences(test)
+
+
+  def sourceCache(self):
+    return self.support.sourceCache
+
+  def count(self):
+    """Returns number of tests.
+    """
+    return len(self.tests)
+
+  def iterTests(self):
+    return self.tests.iter()
+
+  def _initFrom(self, group=None):
+    """Initialize with data from TestGroup `group`."""
+    # copy
+    self.name     = group.name if group else None
+    self.title    = group.title if group else None
+    self.htaccess = group.htaccess if group else None
+    self.support  = group.support if group else None
+    self.tests    = group.tests if group else None
+
+  def merge(self, other):
+    """Merge Group `other`'s contents into this Group and clear its contents.
+    """
+    assert isinstance(other, TestGroup), \
+           "Expected Group instance, got %s" % type(other)
+    if self.htaccess and other.htaccess:
+      self.htaccess.append(other.htaccess)
+    else:
+      self.htaccess = self.htaccess or other.htaccess
+    other.htaccess = None
+
+    self.support = SourceSet.combine(self.support, other.support, self.ui)
+    other.support = None
+
+    self.tests = SourceSet.combine(self.tests, other.tests, self.ui)
+    other.tests = None
+    
+    self.refs  = SourceSet.combine(self.refs, other.refs, self.ui)
+    other.refs = None
+    if self.manifest and other.manifest:
+      self.manifest.append(other.manifest)
+    else:
+      self.manifest = self.manifest or other.manifest
+    other.manifest = None
+    
+
+  def build(self, format):
+    """Build Group's contents through OutputFormat `format`.
+    """
+    format.setSubDir(self.name)
+
+    # Write .htaccess
+    if self.htaccess:
+      format.write(self.htaccess)
+
+    # Write support files
+    format.convert = False  # XXX hack turn off format conversion
+    self.support.write(format)
+    format.convert = True   # XXX undo hack
+
+    # Write tests
+    self.tests.adjustContentPaths(format)
+    self.tests.write(format)
+
+    # Write refs
+    self.refs.write(format)
+    if self.manifest:
+      format.write(self.manifest)
+
+    # copy support files to reference directory (XXX temp until proper support path fixup)
+    formatDir = format.destDir()
+    supportDir = join(formatDir, 'support')
+    referenceDir = join(formatDir, 'reference')
+    if exists(supportDir) and exists(referenceDir):
+      shutil.copytree(supportDir, join(referenceDir, 'support'))
+
+    format.setSubDir()
+

tests/wpt/web-platform-tests/css/tools/w3ctestlib/HTMLSerializer.py

@@ -0,0 +1,277 @@
+#!/usr/bin/python
+# CSS Test Source Manipulation Library
+# Initial code by fantasai, joint copyright 2010 W3C and Microsoft
+# additions by peter.linss@hp.com copyright 2013 Hewlett-Packard
+# Licensed under BSD 3-Clause: <http://www.w3.org/Consortium/Legal/2008/03-bsd-license>
+
+import lxml
+from lxml import etree
+import htmlentitydefs
+import copy
+
+
+class HTMLSerializer(object):
+
+    gXMLns = 'http://www.w3.org/XML/1998/namespace'
+    gHTMLns = 'http://www.w3.org/1999/xhtml'
+  
+    gDefaultNamespaces = {'http://www.w3.org/XML/1998/namespace': 'xmlns',
+                          'http://www.w3.org/2000/xmlns/': 'xmlns',
+                          'http://www.w3.org/1999/xlink': 'xlink'}
+
+    gVoidElements = frozenset((
+        'base',
+        'command',
+        'event-source',
+        'link',
+        'meta',
+        'hr',
+        'br',
+        'img',
+        'embed',
+        'param',
+        'area',
+        'col',
+        'input',
+        'source'
+    ))
+
+    gCDataElements = frozenset((
+        'style',
+        'script'
+    ))
+  
+    gInvisibleChars = frozenset(
+        # ASCII control chars
+        range(0x0, 0x9) + range(0xB, 0xD) + range(0xE, 0x20) +
+        # Other control chars
+        # fixed-width spaces, zero-width marks, bidi marks
+        range(0x2000, 0x2010) +
+        # LS, PS, bidi control codes
+        range(0x2028, 0x2030) +
+        # nbsp, mathsp, ideosp, WJ, interlinear
+        [0x00A0, 0x205F, 0x3000, 0x2060, 0xFFF9, 0xFFFA, 0xFFFB]
+    )
+
+    gXMLEscapes = frozenset(gInvisibleChars |
+                            frozenset((ord('&'), ord('<'), ord('>'))))
+
+    gXMLEntityNames = {'"': 'quot', '&': 'amp', "'": 'apos', '<': 'lt', '>': 'gt'}
+
+    gDocTypes = {
+        'html': '<!DOCTYPE html>',
+        'html4':
+            '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">',
+        'html4-transitional':
+            '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">',
+        'html4-frameset':
+            '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">',
+        'svg11':
+            '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Basic//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd">',
+        'svg11-tiny':
+            '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Tiny//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-tiny.dtd">',
+        'xhtml10':
+            '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
+        'xhtml10-transitional':
+            '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
+        'xhtml10-frameset':
+            '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">',
+        'xhtml11':
+            '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
+        'xhtml-basic11':
+            '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">'
+    }
+  
+
+    def __init__(self):
+        self._reset()
+  
+    def _reset(self, xhtml = False):
+        self.mOutput = u''
+        self.mXHTML = xhtml
+
+    def _output(self, *args):
+        for arg in args:
+            self.mOutput += unicode(arg)
+
+    def _escape(self, text, escapeChars):
+        # This algorithm is O(MN) for M len(text) and N num escapable
+        # But it doesn't modify the text when N is zero (common case) and
+        # N is expected to be small (usually 1 or 2) in most other cases.
+        escapable = set()
+        for char in text:
+            if ord(char) in escapeChars:
+                escapable.add(char)
+        for char in escapable:
+            if (self.mXHTML):
+                name = self.gXMLEntityNames.get(char)
+            else:
+                name = htmlentitydefs.codepoint2name.get(ord(char))
+            escape = u'&%s;' % name if name else u'&#x%X;' % ord(char)
+            text = text.replace(char, escape)
+        return text
+
+    def _escapeXML(self, text):
+        return self._escape(text, self.gXMLEscapes)
+
+    def _escapeInvisible(self, text):
+        return self._escape(text, self.gInvisibleChars)
+
+    def _serializeElement(self, element, namespacePrefixes):
+        qName = etree.QName(element)
+        attrs = element.attrib.items()  # in tree order
+      
+        if (not namespacePrefixes):
+            namespacePrefixes = self.gDefaultNamespaces
+      
+        if (self.mXHTML):
+            namespacePrefixes = copy.copy(namespacePrefixes)
+            for attr, value in attrs:
+                attrQName = etree.QName(attr)
+                if (self.gXMLns == attrQName.namespace):
+                    namespacePrefixes[value] = attrQName.localname
+                elif ('xmlns' == attrQName.localname):
+                    namespacePrefixes[value] = ''
+
+        if (self.mXHTML and qName.namespace and namespacePrefixes[qName.namespace]):
+            self._output('<', namespacePrefixes[qName.namespace], ':', qName.localname)
+        else:
+            self._output('<', qName.localname)
+
+        for attr, value in attrs:
+            attrQName = etree.QName(attr)
+            if ((attrQName.namespace == self.gXMLns) and ('lang' == attrQName.localname)):
+                if (self.mXHTML):
+                    attr = 'xml:lang'
+                else:
+                    attr = 'lang'
+            elif (attrQName.namespace and namespacePrefixes[attrQName.namespace]):
+                attr = namespacePrefixes[attrQName.namespace] + ':' + attrQName.localname
+            else:
+                attr = attrQName.localname
+
+            self._output(' ', attr, '=')
+            value = value.replace('&', '&amp;')
+            if (self.mXHTML):
+                value = value.replace('<', '&lt;')
+
+            if (('"' in value) and ("'" not in value)):
+                self._output("'", self._escapeInvisible(value), "'")
+            else:
+                self._output('"', self._escapeInvisible(value.replace('"', '&quot;')), '"')
+
+        if ((qName.namespace == self.gHTMLns) and (qName.localname in self.gVoidElements)):
+            if (self.mXHTML):
+                self._output(' />')
+            else:
+                self._output('>')
+        else:
+            self._output('>')
+
+            if (None != element.text):
+                if ((qName.namespace == self.gHTMLns) and (qName.localname in self.gCDataElements)):
+                    if (self.mXHTML):
+                        self._output(self._escapeXML(element.text)) # or self._output('<![CDATA[', element.text, ']]>')
+                    else:
+                        self._output(element.text)
+                else:
+                    self._output(self._escapeXML(element.text))
+
+            for child in list(element):
+                self._serializeNode(child, namespacePrefixes)
+
+            self._output('</', qName.localname, '>')
+
+        if (None != element.tail):
+            self._output(self._escapeXML(element.tail))
+
+    def _serializeEntity(self, entity):
+        self._output(entity.text)
+        if (None != entity.tail):
+            self._output(self._escapeXML(entity.tail))
+        
+    def _serializePI(self, pi):
+        if (self.mXHTML):
+            self._output('<?', pi.target, ' ', pi.text, '?>')
+        else:
+            raise Exception("Processing Instructions can't be converted to HTML")
+        if (None != pi.tail):
+            self._output(self._escapeXML(pi.tail))
+        
+    def _serializeComment(self, comment):
+        self._output('<!--', comment.text, '-->') # XXX escape comment?
+        if (None != comment.tail):
+            self._output(self._escapeXML(comment.tail))
+        
+    def _serializeNode(self, node, namespacePrefixes = None):
+        if (isinstance(node, etree._Entity)):
+            self._serializeEntity(node)
+        elif (isinstance(node, etree._ProcessingInstruction)):
+            self._serializePI(node)
+        elif (isinstance(node, etree._Comment)):
+            self._serializeComment(node)
+        else:
+            self._serializeElement(node, namespacePrefixes)
+
+
+    def _serializeTree(self, tree):
+        root = tree.getroot()
+        preceding = [node for node in root.itersiblings(preceding = True)]
+        preceding.reverse()
+        for node in preceding:
+            self._serializeNode(node)
+        self._serializeNode(root)
+        for node in root.itersiblings():
+            self._serializeNode(node)
+  
+    def _serializeDoctype(self, tree, doctype, default):
+        if (doctype):
+            self._output(self.gDocTypes[doctype], '\n')
+        else:
+            if (hasattr(tree, 'docinfo') and tree.docinfo and tree.docinfo.doctype):
+                doctypeSearch = tree.docinfo.doctype.lower()
+                for doctype in self.gDocTypes:
+                    if (self.gDocTypes[doctype].lower() == doctypeSearch):
+                        break
+                else:
+                    doctype = None
+                if (self.mXHTML):
+                    if ('html' == doctype):
+                        doctype = 'xhtml10'
+                    elif ('html4' == doctype):
+                        doctype = 'xhtml10'
+                    elif ('html4-transitional' == doctype):
+                        doctype = 'xhtml10-transitional'
+                    elif ('html4-frameset' == doctype):
+                        doctype = 'xhtml10-frameset'
+                else:
+                    if ('xhtml10' == doctype):
+                        doctype = 'html4'
+                    elif ('xhtml10-transitional' == doctype):
+                        doctype = 'html4-transitional'
+                    elif ('xhtml10-frameset' == doctype):
+                        doctype = 'html4-frameset'
+                    elif ('xhtml11' == doctype):
+                        doctype = 'html4'
+                if (doctype):
+                    self._output(self.gDocTypes[doctype], '\n')
+                else:
+                    self._output(tree.docinfo.doctype, '\n')
+            else:
+                self._output(self.gDocTypes[default], '\n')
+
+
+    def serializeHTML(self, tree, doctype = None):
+        self._reset()
+        self._serializeDoctype(tree, doctype, 'html')
+        self._serializeTree(tree)
+        return self.mOutput
+
+    def serializeXHTML(self, tree, doctype = None):
+        self._reset(True)
+        # XXX '<!xml ...' ??
+        self._serializeDoctype(tree, doctype, 'xhtml11')
+        self._serializeTree(tree)
+        return self.mOutput
+
+

tests/wpt/web-platform-tests/css/tools/w3ctestlib/Indexer.py

@@ -0,0 +1,251 @@
+#!/usr/bin/python
+# CSS Test Suite Manipulation Library
+# Initial code by fantasai, joint copyright 2010 W3C and Microsoft
+# Licensed under BSD 3-Clause: <http://www.w3.org/Consortium/Legal/2008/03-bsd-license>
+
+# Define contains vmethod for Template Toolkit
+from template.stash import list_op
+@list_op("contains")
+def list_contains(l, x):
+  return x in l
+
+import sys
+import re
+import os
+import codecs
+from os.path import join, exists, abspath
+from template import Template
+import w3ctestlib
+from Utils import listfiles, escapeToNamedASCII
+from OutputFormats import ExtensionMap
+import shutil
+
+class Section:
+  def __init__(self, uri, title, numstr):
+    self.uri = uri
+    self.title = title
+    self.numstr = numstr
+    self.tests = []
+  def __cmp__(self, other):
+    return cmp(self.natsortkey(), other.natsortkey())
+  def chapterNum(self):
+    return self.numstr.partition('.')[0]
+  def natsortkey(self):
+    chunks = self.numstr.partition('.#')[0].split('.')
+    for index in range(len(chunks)):
+      if chunks[index].isdigit():
+        # wrap in tuple with '0' to explicitly specify numbers come first
+        chunks[index] = (0, int(chunks[index]))
+      else:
+        chunks[index] = (1, chunks[index])
+    return (chunks, self.numstr)
+
+class Indexer:
+
+  def __init__(self, suite, sections, suites, flags, splitChapter=False, templatePathList=None,
+               extraData=None, overviewTmplNames=None, overviewCopyExts=('.css', 'htaccess')):
+    """Initialize indexer with TestSuite `suite` toc data file
+       `tocDataPath` and additional template paths in list `templatePathList`.
+
+       The toc data file should be list of tab-separated records, one
+       per line, of each spec section's uri, number/letter, and title.
+       `splitChapter` selects a single page index if False, chapter 
+       indicies if True.
+       `extraData` can be a dictionary whose data gets passed to the templates.
+       `overviewCopyExts` lists file extensions that should be found
+       and copied from the template path into the main build directory.
+       The default value is ['.css', 'htaccess'].
+       `overviewTemplateNames` lists template names that should be
+       processed from the template path into the main build directory.
+       The '.tmpl' extension, if any, is stripped from the output filename.
+       The default value is ['index.htm.tmpl', 'index.xht.tmpl', 'testinfo.data.tmpl']
+    """
+    self.suite        = suite
+    self.splitChapter = splitChapter
+    self.extraData    = extraData
+    self.overviewCopyExtPat = re.compile('.*(%s)$' % '|'.join(overviewCopyExts))
+    self.overviewTmplNames = overviewTmplNames if overviewTmplNames is not None \
+      else ['index.htm.tmpl', 'index.xht.tmpl', 'testinfo.data.tmpl',
+            'implementation-report-TEMPLATE.data.tmpl']
+
+    # Initialize template engine
+    self.templatePath = [join(w3ctestlib.__path__[0], 'templates')]
+    if templatePathList:
+      self.templatePath.extend(templatePathList)
+    self.templatePath = [abspath(path) for path in self.templatePath]
+    self.tt = Template({
+       'INCLUDE_PATH': self.templatePath,
+       'ENCODING'    : 'utf-8',
+       'PRE_CHOMP'   : 1,
+       'POST_CHOMP'  : 0,
+    })
+
+    # Load toc data
+    self.sections = {}
+    for uri, numstr, title in sections:
+      uri = intern(uri.encode('ascii'))
+      uriKey = intern(self._normalizeScheme(uri))
+      numstr = escapeToNamedASCII(numstr)
+      title = escapeToNamedASCII(title) if title else None
+      self.sections[uriKey] = Section(uri, title, numstr)
+    
+    self.suites = suites
+    self.flags = flags
+
+    # Initialize storage
+    self.errors = {}
+    self.contributors = {}
+    self.alltests = []
+
+  def _normalizeScheme(self, uri):
+    if (uri and uri.startswith('http:')):
+      return 'https:' + uri[5:]
+    return uri
+
+  def indexGroup(self, group):
+    for test in group.iterTests():
+      data = test.getMetadata()
+      if data: # Shallow copy for template output
+        data = dict(data)
+        data['file'] = '/'.join((group.name, test.relpath)) \
+                       if group.name else test.relpath
+        if (data['scripttest']):
+            data['flags'].append(intern('script'))
+        self.alltests.append(data)
+        for uri in data['links']:
+          uri = self._normalizeScheme(uri)
+          uri = uri.replace(self._normalizeScheme(self.suite.draftroot), self._normalizeScheme(self.suite.specroot))
+          if self.sections.has_key(uri):
+            testlist = self.sections[uri].tests.append(data)
+        for credit in data['credits']:
+          self.contributors[credit[0]] = credit[1]
+      else:
+        self.errors[test.sourcepath] = test.errors
+
+  def __writeTemplate(self, template, data, outfile):
+    o = self.tt.process(template, data)
+    f = open(outfile, 'w')
+    f.write(o.encode('utf-8'))
+    f.close()
+
+  def writeOverview(self, destDir, errorOut=sys.stderr, addTests=[]):
+    """Write format-agnostic pages such as test suite overview pages,
+       test data files, and error reports.
+
+       Indexed errors are reported to errorOut, which must be either
+       an output handle such as sys.stderr, a tuple of
+       (template filename string, output filename string)
+       or None to suppress error output.
+
+       `addTests` is a list of additional test paths, relative to the
+       overview root; it is intended for indexing raw tests
+    """
+
+    # Set common values
+    data = self.extraData.copy()
+    data['suitetitle']   = self.suite.title
+    data['suite']        = self.suite.name
+    data['specroot']     = self.suite.specroot
+    data['draftroot']    = self.suite.draftroot
+    data['contributors'] = self.contributors
+    data['tests']        = self.alltests
+    data['extmap']       = ExtensionMap({'.xht':'', '.html':'', '.htm':'', '.svg':''})
+    data['formats']      = self.suite.formats
+    data['addtests']     = addTests
+    data['suites']       = self.suites
+    data['flagInfo']     = self.flags
+    data['formatInfo']   = { 'html4': { 'report': True, 'path': 'html4', 'ext': 'htm', 'filter': 'nonHTML'},
+                             'html5': { 'report': True, 'path': 'html', 'ext': 'htm', 'filter': 'nonHTML' },
+                             'xhtml1': { 'report': True, 'path': 'xhtml1', 'ext': 'xht', 'filter': 'HTMLonly' },
+                             'xhtml1print': { 'report': False, 'path': 'xhtml1print', 'ext': 'xht', 'filter': 'HTMLonly' },
+                             'svg': { 'report': True, 'path': 'svg', 'ext': 'svg', 'filter': 'HTMLonly' }
+                           }
+
+    # Copy simple copy files
+    for tmplDir in reversed(self.templatePath):
+      files = listfiles(tmplDir)
+      for file in files:
+        if self.overviewCopyExtPat.match(file):
+          shutil.copy(join(tmplDir, file), join(destDir, file))
+
+    # Generate indexes
+    for tmpl in self.overviewTmplNames:
+      out = tmpl[0:-5] if tmpl.endswith('.tmpl') else tmpl
+      self.__writeTemplate(tmpl, data, join(destDir, out))
+
+    # Report errors
+    if (self.errors):
+        if type(errorOut) is type(('tmpl','out')):
+            data['errors'] = errors
+            self.__writeTemplate(errorOut[0], data, join(destDir, errorOut[1]))
+        else:
+            sys.stdout.flush()
+            for errorLocation in self.errors:
+                print >> errorOut, "Error in %s: %s" % \
+                               (errorLocation, ' '.join([str(error) for error in self.errors[errorLocation]]))
+
+  def writeIndex(self, format):
+    """Write indices into test suite build output through format `format`.
+    """
+
+    # Set common values
+    data = self.extraData.copy()
+    data['suitetitle'] = self.suite.title
+    data['suite']      = self.suite.name
+    data['specroot']   = self.suite.specroot
+    data['draftroot']  = self.suite.draftroot
+    
+    data['indexext']   = format.indexExt
+    data['isXML']      = format.indexExt.startswith('.x')
+    data['formatdir']  = format.formatDirName
+    data['extmap']     = format.extMap
+    data['tests']      = self.alltests
+    data['suites']     = self.suites
+    data['flagInfo']   = self.flags
+
+    # Generate indices:
+
+    # Reftest indices
+    self.__writeTemplate('reftest-toc.tmpl', data,
+                         format.dest('reftest-toc%s' % format.indexExt))
+    self.__writeTemplate('reftest.tmpl', data,
+                         format.dest('reftest.list'))
+
+    # Table of Contents
+    sectionlist = sorted(self.sections.values())
+    if self.splitChapter:
+      # Split sectionlist into chapters
+      chapters = []
+      lastChapNum = '$' # some nonmatching initial char
+      chap = None
+      for section in sectionlist:
+        if (section.title and (section.chapterNum() != lastChapNum)):
+          lastChapNum = section.chapterNum()
+          chap = section
+          chap.sections = []
+          chap.testcount = 0
+          chap.testnames = set()
+          chapters.append(chap)
+        chap.testnames.update([test['name'] for test in section.tests])
+        chap.testcount = len(chap.testnames)
+        chap.sections.append(section)
+
+      # Generate main toc
+      data['chapters'] = chapters
+      self.__writeTemplate('chapter-toc.tmpl', data,
+                           format.dest('toc%s' % format.indexExt))
+      del data['chapters']
+
+      # Generate chapter tocs
+      for chap in chapters:
+        data['chaptertitle'] = chap.title
+        data['testcount']    = chap.testcount
+        data['sections']     = chap.sections
+        self.__writeTemplate('test-toc.tmpl', data, format.dest('chapter-%s%s' \
+                             % (chap.numstr, format.indexExt)))
+
+    else: # not splitChapter
+      data['chapters'] = sectionlist
+      self.__writeTemplate('test-toc.tmpl', data,
+                           format.dest('toc%s' % format.indexExt))
+      del data['chapters']

tests/wpt/web-platform-tests/css/tools/w3ctestlib/OutputFormats.py

@@ -0,0 +1,207 @@
+#!/usr/bin/python
+# CSS Test Source Manipulation Library
+# Initial code by fantasai, joint copyright 2010 W3C and Microsoft
+# Licensed under BSD 3-Clause: <http://www.w3.org/Consortium/Legal/2008/03-bsd-license>
+
+import re
+import os
+from os.path import join, exists, splitext, dirname, basename
+from Sources import XHTMLSource, HTMLSource, SVGSource, SourceTree
+
+class ExtensionMap:
+  """ Given a file extension mapping (e.g. {'.xht' : '.htm'}), provides
+      a translate function for paths.
+  """
+  def __init__(self, extMap):
+    self.extMap = extMap
+
+  def translate(self, path):
+    for ext in self.extMap:
+      if path.endswith(ext):
+        return splitext(path)[0] + self.extMap[ext]
+    return path
+
+class BasicFormat:
+  """Base class. A Format manages all the conversions and location
+     transformations (e.g. subdirectory for all tests in that format)
+     associated with a test suite format.
+
+     The base class implementation performs no conversions or
+     format-specific location transformations."""
+  formatDirName = None
+  indexExt      = '.htm'
+  convert       = True   # XXX hack to supress format conversion in support dirs, need to clean up output code to make this cleaner
+
+  def __init__(self, destroot, sourceTree, extMap=None, outputDirName=None):
+    """Creates format root of the output tree. `destroot` is the root path
+       of the output tree.
+
+       extMap provides a file extension mapping, e.g. {'.xht' : '.htm'}
+    """
+    self.root = join(destroot, outputDirName) if outputDirName else destroot
+    self.sourceTree = sourceTree
+    self.formatDirName = outputDirName
+    if not exists(self.root):
+      os.makedirs(self.root)
+    self.extMap = ExtensionMap(extMap or {})
+    self.subdir = None
+
+  def setSubDir(self, name=None):
+    """Sets format to write into group subdirectory `name`.
+    """
+    self.subdir = name
+
+  def destDir(self):
+    return join(self.root, self.subdir) if self.subdir else self.root
+    
+  def dest(self, relpath):
+    """Returns final destination of relpath in this format and ensures that the
+       parent directory exists."""
+    # Translate path
+    if (self.convert):
+      relpath = self.extMap.translate(relpath)
+    if (self.sourceTree.isReferenceAnywhere(relpath)):
+      relpath = join('reference', basename(relpath))
+    # XXX when forcing support files into support path, need to account for support/support
+    dest = join(self.root, self.subdir, relpath) if self.subdir \
+           else join(self.root, relpath)
+    # Ensure parent
+    parent = dirname(dest)
+    if not exists(parent):
+      os.makedirs(parent)
+
+    return dest
+
+  def write(self, source):
+    """Write FileSource to destination, following all necessary
+       conversion methods."""
+    source.write(self, source)
+
+  testTransform = False
+  # def testTransform(self, outputString, source) if needed
+
+class XHTMLFormat(BasicFormat):
+  """Base class for XHTML test suite format. Builds into 'xhtml1' subfolder
+     of root.
+  """
+  indexExt      = '.xht'
+
+  def __init__(self, destroot, sourceTree, extMap=None, outputDirName='xhtml1'):
+    if not extMap:
+      extMap = {'.htm' : '.xht', '.html' : '.xht', '.xhtml' : '.xht' }
+    BasicFormat.__init__(self, destroot, sourceTree, extMap, outputDirName)
+
+  def write(self, source):
+    # skip HTMLonly tests
+    if hasattr(source, 'hasFlag') and source.hasFlag('HTMLonly'):
+      return
+    if isinstance(source, HTMLSource) and self.convert:
+      source.write(self, source.serializeXHTML())
+    else:
+      source.write(self)
+
+class HTMLFormat(BasicFormat):
+  """Base class for HTML test suite format. Builds into 'html4' subfolder
+     of root.
+  """
+
+  def __init__(self, destroot, sourceTree, extMap=None, outputDirName='html4'):
+    if not extMap:
+      extMap = {'.xht' : '.htm', '.xhtml' : '.htm', '.html' : '.htm' }
+    BasicFormat.__init__(self, destroot, sourceTree, extMap, outputDirName)
+
+  def write(self, source):
+    # skip nonHTML tests
+    if hasattr(source, 'hasFlag') and source.hasFlag('nonHTML'):
+      return
+    if isinstance(source, XHTMLSource) and self.convert:
+      source.write(self, source.serializeHTML())
+    else:
+      source.write(self)
+      
+
+class HTML5Format(HTMLFormat):
+  def __init__(self, destroot, sourceTree, extMap=None, outputDirName='html'):
+    HTMLFormat.__init__(self, destroot, sourceTree, extMap, outputDirName)
+
+  def write(self, source):
+    # skip nonHTML tests
+    if hasattr(source, 'hasFlag') and source.hasFlag('nonHTML'):
+      return
+    if isinstance(source, XHTMLSource) and self.convert:
+      source.write(self, source.serializeHTML())
+    else:
+      source.write(self)
+
+
+class SVGFormat(BasicFormat):
+  def __init__(self, destroot, sourceTree, extMap=None, outputDirName='svg'):
+    if not extMap:
+      extMap = {'.svg' : '.svg' }
+    BasicFormat.__init__(self, destroot, sourceTree, extMap, outputDirName)
+
+  def write(self, source):
+    # skip non SVG tests
+    if isinstance(source, SVGSource):
+      source.write(self)
+
+
+class XHTMLPrintFormat(XHTMLFormat):
+  """Base class for XHTML Print test suite format. Builds into 'xhtml1print'
+     subfolder of root.
+  """
+
+  def __init__(self, destroot, sourceTree, testSuiteName, extMap=None, outputDirName='xhtml1print'):
+    if not extMap:
+      extMap = {'.htm' : '.xht', '.html' : '.xht', '.xhtml' : '.xht' }
+    BasicFormat.__init__(self, destroot, sourceTree, extMap, outputDirName)
+    self.testSuiteName = testSuiteName
+
+  def write(self, source):
+    if (isinstance(source, XHTMLSource)):
+      if not source.hasFlag('HTMLonly'):
+        source.write(self, self.testTransform(source))
+    else:
+      XHTMLFormat.write(self, source)
+
+  def testTransform(self, source):
+    assert isinstance(source, XHTMLSource)
+    output = source.serializeXHTML('xhtml10')
+
+    headermeta = {'suitename' : self.testSuiteName,
+                  'testid'    : source.name(),
+                  'margin'    : '',
+                 }
+    if re.search('@page\s*{[^}]*@', output):
+      # Don't use headers and footers when page tests margin boxes
+      output = re.sub('(<body[^>]*>)',
+                      '\1\n' + self.__htmlstart % headermeta,
+                      output);
+      output = re.sub('(</body[^>]*>)',
+                      '\1\n' + self.__htmlend % headermeta,
+                      output);
+    else:
+      # add margin rule only when @page statement does not exist
+      if not re.search('@page', output):
+        headermeta['margin'] = self.__margin
+      output = re.sub('</title>',
+                      '</title>\n  <style type="text/css">%s</style>' % \
+                        (self.__css % headermeta),
+                      output);
+    return output;
+
+  # template bits
+  __margin = 'margin: 7%;';
+  __font = 'font: italic 8pt sans-serif; color: gray;'
+  __css = """
+    @page { %s
+            %%(margin)s
+            counter-increment: page;
+            @top-left { content: "%%(suitename)s"; }
+            @top-right { content: "Test %%(testid)s"; }
+            @bottom-right { content: counter(page); }
+          }
+""" % __font
+  __htmlstart = '<p style="%s">Start of %%(suitename)s %%(testid)s.</p>' % __font
+  __htmlend = '<p style="%s">End of %%(suitename)s %%(testid)s.</p>' % __font
+

tests/wpt/web-platform-tests/css/tools/w3ctestlib/Suite.py

@@ -0,0 +1,121 @@
+#!/usr/bin/python
+# CSS Test Suite Manipulation Library
+# Initial code by fantasai, joint copyright 2010 W3C and Microsoft
+# Licensed under BSD 3-Clause: <http://www.w3.org/Consortium/Legal/2008/03-bsd-license>
+
+import OutputFormats
+import Utils
+from Groups import TestGroup, excludeDirs
+from Sources import SourceTree, SourceCache
+from shutil import copytree, rmtree
+from os.path import join
+import os
+from mercurial import ui as UserInterface, hg
+
+class TestSuite:
+  """Representation of a standard CSS test suite."""
+
+  def __init__(self, name, title, specUri, draftUri, sourceCache = None, ui = None):
+    self.name = name
+    self.title = title
+    self.specroot = specUri
+    self.draftroot = draftUri
+
+    self.ui = ui if ui else UserInterface.ui()
+    self.defaultReftestRelpath='reftest.list'
+    self.groups = {}
+    self.sourcecache = sourceCache if sourceCache else SourceCache(SourceTree(hg.repository(self.ui, '.')))
+    self.formats = ('html4', 'xhtml1', 'xhtml1print') # XXX FIXME, hardcoded list is lame
+    self.rawgroups = {}
+
+  def addTestsByExt(self, dir, ext, groupName='', groupTitle=''):
+    """Add tests from directory `dir` by file extension (via `ext`, e.g. ext='.xht').
+    """
+    group = TestGroup(self.sourcecache, dir, selfTestExt=ext,
+                      name=groupName, title=groupTitle, ui = self.ui)
+    self.addGroup(group)
+
+
+  def addTestsByList(self, dir, filenames, groupName='', groupTitle=''):
+    """Add tests from directory `dir`, via file name list `filenames`.
+    """
+    group = TestGroup(self.sourcecache, dir, selfTestList=filenames,
+                      name=groupName, title=groupTitle, ui = self.ui)
+    self.addGroup(group)
+
+  def addReftests(self, dir, manifestPath, groupName='', groupTitle=''):
+    """Add tests by importing context of directory `dir` and importing all
+       tests listed in the `reftestManifestName` manifest inside `dir`.
+    """
+    group = TestGroup(self.sourcecache,
+                      dir, manifestPath=manifestPath,
+                      manifestDest=self.defaultReftestRelpath,
+                      name=groupName, title=groupTitle, ui = self.ui)
+    self.addGroup(group)
+
+  def addGroup(self, group):
+    """ Add CSSTestGroup `group` to store. """
+    master = self.groups.get(group.name)
+    if master:
+      master.merge(group)
+    else:
+      self.groups[group.name] = group
+
+  def addRaw(self, dir, relpath):
+    """Add the contents of directory `dir` to the test suite by copying
+       (not processing). Note this means such tests will not be indexed.
+       `relpath` gives the directory's path within the build destination.
+    """
+    self.rawgroups[dir] = relpath
+
+  def setFormats(self, formats):
+    self.formats = formats
+    
+  def buildInto(self, dest, indexer):
+    """Builds test suite through all OutputFormats into directory at path `dest`
+       or through OutputFormat destination `dest`, using Indexer `indexer`.
+    """
+    if isinstance(dest, OutputFormats.BasicFormat):
+      formats = (dest,)
+      dest = dest.root
+    else:
+      formats = []
+      for format in self.formats:
+        if (format == 'html4'):
+          formats.append(OutputFormats.HTMLFormat(dest, self.sourcecache.sourceTree))
+        elif (format == 'html5'):
+          formats.append(OutputFormats.HTML5Format(dest, self.sourcecache.sourceTree))
+        elif (format == 'xhtml1'):
+          formats.append(OutputFormats.XHTMLFormat(dest, self.sourcecache.sourceTree))
+        elif (format == 'xhtml1print'):
+          formats.append(OutputFormats.XHTMLPrintFormat(dest, self.sourcecache.sourceTree, self.title))
+        elif (format == 'svg'):
+          formats.append(OutputFormats.SVGFormat(dest, self.sourcecache.sourceTree))
+
+    for format in formats:
+      for group in self.groups.itervalues():
+        group.build(format)
+
+    for group in self.groups.itervalues():
+      indexer.indexGroup(group)
+
+    for format in formats:
+      indexer.writeIndex(format)
+
+
+    rawtests = []
+    for src, relpath in self.rawgroups.items():
+      copytree(src, join(dest,relpath))
+      for (root, dirs, files) in os.walk(join(dest,relpath)):
+        for xdir in excludeDirs:
+          if xdir in dirs:
+            dirs.remove(xdir)
+            rmtree(join(root,xdir))
+        rawtests.extend(
+          [join(Utils.relpath(root,dest),file)
+           for file in files]
+        )
+
+    rawtests.sort()
+    indexer.writeOverview(dest, addTests=rawtests)
+    

tests/wpt/web-platform-tests/css/tools/w3ctestlib/Utils.py

@@ -0,0 +1,161 @@
+#!/usr/bin/python
+# CSS Test Suite Manipulation Library Utilities
+# Initial code by fantasai, joint copyright 2010 W3C and Microsoft
+# Licensed under BSD 3-Clause: <http://www.w3.org/Consortium/Legal/2008/03-bsd-license>
+
+###### XML Parsing ######
+
+import os
+import w3ctestlib
+os.environ['XML_CATALOG_FILES'] = os.path.join(w3ctestlib.__path__[0], 'catalog/catalog.xml')
+
+###### File path manipulation ######
+
+import os.path
+from os.path import sep, pardir
+
+def assetName(path):
+  return intern(os.path.splitext(os.path.basename(path))[0].lower().encode('ascii'))
+  
+def basepath(path):
+  """ Returns the path part of os.path.split.
+  """
+  return os.path.split(path)[0]
+
+def isPathInsideBase(path, base=''):
+  path = os.path.normpath(path)
+  if base:
+    base = os.path.normpath(base)
+    pathlist = path.split(os.path.sep)
+    baselist = base.split(os.path.sep)
+    while baselist:
+      p = pathlist.pop(0)
+      b = baselist.pop(0)
+      if p != b:
+        return False
+    return not pathlist[0].startswith(os.path.pardir)
+  return not path.startswith(os.path.pardir)
+
+def relpath(path, start):
+  """Return relative path from start to end. WARNING: this is not the
+     same as a relative URL; see relativeURL()."""
+  try:
+    return os.path.relpath(path, start)
+  except AttributeError:
+    # This function is copied directly from the Python 2.6 source
+    # code, and is therefore under a different license.
+
+    if not path:
+        raise ValueError("no path specified")
+    start_list = os.path.abspath(start).split(sep)
+    path_list = os.path.abspath(path).split(sep)
+    if start_list[0].lower() != path_list[0].lower():
+        unc_path, rest = os.path.splitunc(path)
+        unc_start, rest = os.path.splitunc(start)
+        if bool(unc_path) ^ bool(unc_start):
+            raise ValueError("Cannot mix UNC and non-UNC paths (%s and %s)"
+                                                                % (path, start))
+        else:
+            raise ValueError("path is on drive %s, start on drive %s"
+                                                % (path_list[0], start_list[0]))
+    # Work out how much of the filepath is shared by start and path.
+    for i in range(min(len(start_list), len(path_list))):
+        if start_list[i].lower() != path_list[i].lower():
+            break
+    else:
+        i += 1
+
+    rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
+    if not rel_list:
+        return os.path.curdir
+    return os.path.join(*rel_list)
+
+def relativeURL(start, end):
+  """ Returns relative URL from `start` to `end`.
+  """
+#  if isPathInsideBase(end, start):
+#    return relpath(end, start)
+#  else:
+  return relpath(end, basepath(start))
+
+def listfiles(path, ext = None):
+  """ Returns a list of all files in a directory.
+      Optionally lists only files with a given extension.
+  """
+  try:
+    _,_,files = os.walk(path).next()
+    if (ext):
+      files = [fileName for fileName in files if fileName.endswith(ext)]
+  except StopIteration, e:
+    files = []
+  return files
+
+def listdirs(path):
+  """ Returns a list of all subdirectories in a directory.
+  """
+  try:
+    _,dirs,_ = os.walk(path).next()
+  except StopIteration, e:
+    dirs = []
+  return dirs
+
+###### MIME types and file extensions ######
+
+extensionMap = { None     : 'application/octet-stream', # default
+                 '.xht'   : 'application/xhtml+xml',
+                 '.xhtml' : 'application/xhtml+xml',
+                 '.xml'   : 'application/xml',
+                 '.htm'   : 'text/html',
+                 '.html'  : 'text/html',
+                 '.txt'   : 'text/plain',
+                 '.jpg'   : 'image/jpeg',
+                 '.png'   : 'image/png',
+                 '.svg'   : 'image/svg+xml',
+               }
+
+def getMimeFromExt(filepath):
+  """Convenience function: equal to extenionMap.get(ext, extensionMap[None]).
+  """
+  if filepath.endswith('.htaccess'):
+    return 'config/htaccess'
+  ext = os.path.splitext(filepath)[1]
+  return extensionMap.get(ext, extensionMap[None])
+
+###### Escaping ######
+
+import types
+from htmlentitydefs import entitydefs
+
+entityify = dict([c,e] for e,c in entitydefs.iteritems())
+
+def escapeMarkup(data):
+  """Escape markup characters (&, >, <). Copied from xml.sax.saxutils.
+  """
+  # must do ampersand first
+  data = data.replace("&", "&amp;")
+  data = data.replace(">", "&gt;")
+  data = data.replace("<", "&lt;")
+  return data
+
+def escapeToNamedASCII(text):
+  """Escapes to named entities where possible and numeric-escapes non-ASCII
+  """
+  return escapeToNamed(text).encode('ascii', 'xmlcharrefreplace')
+
+def escapeToNamed(text):
+  """Escape characters with named entities.
+  """
+  escapable = set()
+
+  for c in text:
+    if ord(c) > 127:
+      escapable.add(c)
+  if type(text) == types.UnicodeType:
+    for c in escapable:
+      cLatin = c.encode('Latin-1', 'ignore')
+      if (cLatin in entityify):
+        text = text.replace(c, "&%s;" % entityify[cLatin])
+  else:
+    for c in escapable:
+      text = text.replace(c, "&%s;" % entityify[c])
+  return text

tests/wpt/web-platform-tests/css/tools/w3ctestlib/__init__.py

@@ -0,0 +1,3 @@
+
+
+__all__ = ['Sources', 'Groups', 'Indexer', 'Suite', 'OutputFormats', 'HTMLSerializer']

tests/wpt/web-platform-tests/css/tools/w3ctestlib/catalog/catalog.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0"?>
+<!-- <!DOCTYPE catalog PUBLIC "-//OASIS//DTD XML Catalogs V1.0//EN" "file:///usr/share/xml/schema/xml-core/catalog.dtd"> -->
+<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog">
+  <group  prefer="public">
+    <public
+       publicId="-//W3C//DTD XHTML 1.1//EN"
+       uri="xhtml11.dtd"/>
+    <public
+       publicId="-//W3C//DTD XHTML 1.0 Strict//EN"
+       uri="xhtml1-strict.dtd"/>
+    <public
+       publicId="-//W3C//DTD XHTML 1.0 Transitional//EN"
+       uri="xhtml1-transitional.dtd"/>
+    <public
+       publicId="-//W3C//DTD XHTML 1.0 Frameset//EN"
+       uri="xhtml1-frameset.dtd"/>
+    <public
+       publicId="-//W3C//ENTITIES Latin 1 for XHTML//EN"
+       uri="xhtml-lat1.ent"/>
+    <public
+       publicId="-//W3C//ENTITIES Special for XHTML//EN"
+       uri="xhtml-special.ent"/>
+    <public
+       publicId="-//W3C//ENTITIES Symbols for XHTML//EN"
+       uri="xhtml-special.ent"/>
+  </group>
+</catalog>

tests/wpt/web-platform-tests/css/tools/w3ctestlib/catalog/xhtml-lat1.ent

@@ -0,0 +1,196 @@
+<!-- Portions (C) International Organization for Standardization 1986
+     Permission to copy in any form is granted for use with
+     conforming SGML systems and applications as defined in
+     ISO 8879, provided this notice is included in all copies.
+-->
+<!-- Character entity set. Typical invocation:
+    <!ENTITY % HTMLlat1 PUBLIC
+       "-//W3C//ENTITIES Latin 1 for XHTML//EN"
+       "http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent">
+    %HTMLlat1;
+-->
+
+<!ENTITY nbsp   "&#160;"> <!-- no-break space = non-breaking space,
+                                  U+00A0 ISOnum -->
+<!ENTITY iexcl  "&#161;"> <!-- inverted exclamation mark, U+00A1 ISOnum -->
+<!ENTITY cent   "&#162;"> <!-- cent sign, U+00A2 ISOnum -->
+<!ENTITY pound  "&#163;"> <!-- pound sign, U+00A3 ISOnum -->
+<!ENTITY curren "&#164;"> <!-- currency sign, U+00A4 ISOnum -->
+<!ENTITY yen    "&#165;"> <!-- yen sign = yuan sign, U+00A5 ISOnum -->
+<!ENTITY brvbar "&#166;"> <!-- broken bar = broken vertical bar,
+                                  U+00A6 ISOnum -->
+<!ENTITY sect   "&#167;"> <!-- section sign, U+00A7 ISOnum -->
+<!ENTITY uml    "&#168;"> <!-- diaeresis = spacing diaeresis,
+                                  U+00A8 ISOdia -->
+<!ENTITY copy   "&#169;"> <!-- copyright sign, U+00A9 ISOnum -->
+<!ENTITY ordf   "&#170;"> <!-- feminine ordinal indicator, U+00AA ISOnum -->
+<!ENTITY laquo  "&#171;"> <!-- left-pointing double angle quotation mark
+                                  = left pointing guillemet, U+00AB ISOnum -->
+<!ENTITY not    "&#172;"> <!-- not sign = angled dash,
+                                  U+00AC ISOnum -->
+<!ENTITY shy    "&#173;"> <!-- soft hyphen = discretionary hyphen,
+                                  U+00AD ISOnum -->
+<!ENTITY reg    "&#174;"> <!-- registered sign = registered trade mark sign,
+                                  U+00AE ISOnum -->
+<!ENTITY macr   "&#175;"> <!-- macron = spacing macron = overline
+                                  = APL overbar, U+00AF ISOdia -->
+<!ENTITY deg    "&#176;"> <!-- degree sign, U+00B0 ISOnum -->
+<!ENTITY plusmn "&#177;"> <!-- plus-minus sign = plus-or-minus sign,
+                                  U+00B1 ISOnum -->
+<!ENTITY sup2   "&#178;"> <!-- superscript two = superscript digit two
+                                  = squared, U+00B2 ISOnum -->
+<!ENTITY sup3   "&#179;"> <!-- superscript three = superscript digit three
+                                  = cubed, U+00B3 ISOnum -->
+<!ENTITY acute  "&#180;"> <!-- acute accent = spacing acute,
+                                  U+00B4 ISOdia -->
+<!ENTITY micro  "&#181;"> <!-- micro sign, U+00B5 ISOnum -->
+<!ENTITY para   "&#182;"> <!-- pilcrow sign = paragraph sign,
+                                  U+00B6 ISOnum -->
+<!ENTITY middot "&#183;"> <!-- middle dot = Georgian comma
+                                  = Greek middle dot, U+00B7 ISOnum -->
+<!ENTITY cedil  "&#184;"> <!-- cedilla = spacing cedilla, U+00B8 ISOdia -->
+<!ENTITY sup1   "&#185;"> <!-- superscript one = superscript digit one,
+                                  U+00B9 ISOnum -->
+<!ENTITY ordm   "&#186;"> <!-- masculine ordinal indicator,
+                                  U+00BA ISOnum -->
+<!ENTITY raquo  "&#187;"> <!-- right-pointing double angle quotation mark
+                                  = right pointing guillemet, U+00BB ISOnum -->
+<!ENTITY frac14 "&#188;"> <!-- vulgar fraction one quarter
+                                  = fraction one quarter, U+00BC ISOnum -->
+<!ENTITY frac12 "&#189;"> <!-- vulgar fraction one half
+                                  = fraction one half, U+00BD ISOnum -->
+<!ENTITY frac34 "&#190;"> <!-- vulgar fraction three quarters
+                                  = fraction three quarters, U+00BE ISOnum -->
+<!ENTITY iquest "&#191;"> <!-- inverted question mark
+                                  = turned question mark, U+00BF ISOnum -->
+<!ENTITY Agrave "&#192;"> <!-- latin capital letter A with grave
+                                  = latin capital letter A grave,
+                                  U+00C0 ISOlat1 -->
+<!ENTITY Aacute "&#193;"> <!-- latin capital letter A with acute,
+                                  U+00C1 ISOlat1 -->
+<!ENTITY Acirc  "&#194;"> <!-- latin capital letter A with circumflex,
+                                  U+00C2 ISOlat1 -->
+<!ENTITY Atilde "&#195;"> <!-- latin capital letter A with tilde,
+                                  U+00C3 ISOlat1 -->
+<!ENTITY Auml   "&#196;"> <!-- latin capital letter A with diaeresis,
+                                  U+00C4 ISOlat1 -->
+<!ENTITY Aring  "&#197;"> <!-- latin capital letter A with ring above
+                                  = latin capital letter A ring,
+                                  U+00C5 ISOlat1 -->
+<!ENTITY AElig  "&#198;"> <!-- latin capital letter AE
+                                  = latin capital ligature AE,
+                                  U+00C6 ISOlat1 -->
+<!ENTITY Ccedil "&#199;"> <!-- latin capital letter C with cedilla,
+                                  U+00C7 ISOlat1 -->
+<!ENTITY Egrave "&#200;"> <!-- latin capital letter E with grave,
+                                  U+00C8 ISOlat1 -->
+<!ENTITY Eacute "&#201;"> <!-- latin capital letter E with acute,
+                                  U+00C9 ISOlat1 -->
+<!ENTITY Ecirc  "&#202;"> <!-- latin capital letter E with circumflex,
+                                  U+00CA ISOlat1 -->
+<!ENTITY Euml   "&#203;"> <!-- latin capital letter E with diaeresis,
+                                  U+00CB ISOlat1 -->
+<!ENTITY Igrave "&#204;"> <!-- latin capital letter I with grave,
+                                  U+00CC ISOlat1 -->
+<!ENTITY Iacute "&#205;"> <!-- latin capital letter I with acute,
+                                  U+00CD ISOlat1 -->
+<!ENTITY Icirc  "&#206;"> <!-- latin capital letter I with circumflex,
+                                  U+00CE ISOlat1 -->
+<!ENTITY Iuml   "&#207;"> <!-- latin capital letter I with diaeresis,
+                                  U+00CF ISOlat1 -->
+<!ENTITY ETH    "&#208;"> <!-- latin capital letter ETH, U+00D0 ISOlat1 -->
+<!ENTITY Ntilde "&#209;"> <!-- latin capital letter N with tilde,
+                                  U+00D1 ISOlat1 -->
+<!ENTITY Ograve "&#210;"> <!-- latin capital letter O with grave,
+                                  U+00D2 ISOlat1 -->
+<!ENTITY Oacute "&#211;"> <!-- latin capital letter O with acute,
+                                  U+00D3 ISOlat1 -->
+<!ENTITY Ocirc  "&#212;"> <!-- latin capital letter O with circumflex,
+                                  U+00D4 ISOlat1 -->
+<!ENTITY Otilde "&#213;"> <!-- latin capital letter O with tilde,
+                                  U+00D5 ISOlat1 -->
+<!ENTITY Ouml   "&#214;"> <!-- latin capital letter O with diaeresis,
+                                  U+00D6 ISOlat1 -->
+<!ENTITY times  "&#215;"> <!-- multiplication sign, U+00D7 ISOnum -->
+<!ENTITY Oslash "&#216;"> <!-- latin capital letter O with stroke
+                                  = latin capital letter O slash,
+                                  U+00D8 ISOlat1 -->
+<!ENTITY Ugrave "&#217;"> <!-- latin capital letter U with grave,
+                                  U+00D9 ISOlat1 -->
+<!ENTITY Uacute "&#218;"> <!-- latin capital letter U with acute,
+                                  U+00DA ISOlat1 -->
+<!ENTITY Ucirc  "&#219;"> <!-- latin capital letter U with circumflex,
+                                  U+00DB ISOlat1 -->
+<!ENTITY Uuml   "&#220;"> <!-- latin capital letter U with diaeresis,
+                                  U+00DC ISOlat1 -->
+<!ENTITY Yacute "&#221;"> <!-- latin capital letter Y with acute,
+                                  U+00DD ISOlat1 -->
+<!ENTITY THORN  "&#222;"> <!-- latin capital letter THORN,
+                                  U+00DE ISOlat1 -->
+<!ENTITY szlig  "&#223;"> <!-- latin small letter sharp s = ess-zed,
+                                  U+00DF ISOlat1 -->
+<!ENTITY agrave "&#224;"> <!-- latin small letter a with grave
+                                  = latin small letter a grave,
+                                  U+00E0 ISOlat1 -->
+<!ENTITY aacute "&#225;"> <!-- latin small letter a with acute,
+                                  U+00E1 ISOlat1 -->
+<!ENTITY acirc  "&#226;"> <!-- latin small letter a with circumflex,
+                                  U+00E2 ISOlat1 -->
+<!ENTITY atilde "&#227;"> <!-- latin small letter a with tilde,
+                                  U+00E3 ISOlat1 -->
+<!ENTITY auml   "&#228;"> <!-- latin small letter a with diaeresis,
+                                  U+00E4 ISOlat1 -->
+<!ENTITY aring  "&#229;"> <!-- latin small letter a with ring above
+                                  = latin small letter a ring,
+                                  U+00E5 ISOlat1 -->
+<!ENTITY aelig  "&#230;"> <!-- latin small letter ae
+                                  = latin small ligature ae, U+00E6 ISOlat1 -->
+<!ENTITY ccedil "&#231;"> <!-- latin small letter c with cedilla,
+                                  U+00E7 ISOlat1 -->
+<!ENTITY egrave "&#232;"> <!-- latin small letter e with grave,
+                                  U+00E8 ISOlat1 -->
+<!ENTITY eacute "&#233;"> <!-- latin small letter e with acute,
+                                  U+00E9 ISOlat1 -->
+<!ENTITY ecirc  "&#234;"> <!-- latin small letter e with circumflex,
+                                  U+00EA ISOlat1 -->
+<!ENTITY euml   "&#235;"> <!-- latin small letter e with diaeresis,
+                                  U+00EB ISOlat1 -->
+<!ENTITY igrave "&#236;"> <!-- latin small letter i with grave,
+                                  U+00EC ISOlat1 -->
+<!ENTITY iacute "&#237;"> <!-- latin small letter i with acute,
+                                  U+00ED ISOlat1 -->
+<!ENTITY icirc  "&#238;"> <!-- latin small letter i with circumflex,
+                                  U+00EE ISOlat1 -->
+<!ENTITY iuml   "&#239;"> <!-- latin small letter i with diaeresis,
+                                  U+00EF ISOlat1 -->
+<!ENTITY eth    "&#240;"> <!-- latin small letter eth, U+00F0 ISOlat1 -->
+<!ENTITY ntilde "&#241;"> <!-- latin small letter n with tilde,
+                                  U+00F1 ISOlat1 -->
+<!ENTITY ograve "&#242;"> <!-- latin small letter o with grave,
+                                  U+00F2 ISOlat1 -->
+<!ENTITY oacute "&#243;"> <!-- latin small letter o with acute,
+                                  U+00F3 ISOlat1 -->
+<!ENTITY ocirc  "&#244;"> <!-- latin small letter o with circumflex,
+                                  U+00F4 ISOlat1 -->
+<!ENTITY otilde "&#245;"> <!-- latin small letter o with tilde,
+                                  U+00F5 ISOlat1 -->
+<!ENTITY ouml   "&#246;"> <!-- latin small letter o with diaeresis,
+                                  U+00F6 ISOlat1 -->
+<!ENTITY divide "&#247;"> <!-- division sign, U+00F7 ISOnum -->
+<!ENTITY oslash "&#248;"> <!-- latin small letter o with stroke,
+                                  = latin small letter o slash,
+                                  U+00F8 ISOlat1 -->
+<!ENTITY ugrave "&#249;"> <!-- latin small letter u with grave,
+                                  U+00F9 ISOlat1 -->
+<!ENTITY uacute "&#250;"> <!-- latin small letter u with acute,
+                                  U+00FA ISOlat1 -->
+<!ENTITY ucirc  "&#251;"> <!-- latin small letter u with circumflex,
+                                  U+00FB ISOlat1 -->
+<!ENTITY uuml   "&#252;"> <!-- latin small letter u with diaeresis,
+                                  U+00FC ISOlat1 -->
+<!ENTITY yacute "&#253;"> <!-- latin small letter y with acute,
+                                  U+00FD ISOlat1 -->
+<!ENTITY thorn  "&#254;"> <!-- latin small letter thorn,
+                                  U+00FE ISOlat1 -->
+<!ENTITY yuml   "&#255;"> <!-- latin small letter y with diaeresis,
+                                  U+00FF ISOlat1 -->

tests/wpt/web-platform-tests/css/tools/w3ctestlib/catalog/xhtml-special.ent

@@ -0,0 +1,80 @@
+<!-- Special characters for XHTML -->
+
+<!-- Character entity set. Typical invocation:
+     <!ENTITY % HTMLspecial PUBLIC
+        "-//W3C//ENTITIES Special for XHTML//EN"
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent">
+     %HTMLspecial;
+-->
+
+<!-- Portions (C) International Organization for Standardization 1986:
+     Permission to copy in any form is granted for use with
+     conforming SGML systems and applications as defined in
+     ISO 8879, provided this notice is included in all copies.
+-->
+
+<!-- Relevant ISO entity set is given unless names are newly introduced.
+     New names (i.e., not in ISO 8879 list) do not clash with any
+     existing ISO 8879 entity names. ISO 10646 character numbers
+     are given for each character, in hex. values are decimal
+     conversions of the ISO 10646 values and refer to the document
+     character set. Names are Unicode names. 
+-->
+
+<!-- C0 Controls and Basic Latin -->
+<!ENTITY quot    "&#34;"> <!--  quotation mark, U+0022 ISOnum -->
+<!ENTITY amp     "&#38;#38;"> <!--  ampersand, U+0026 ISOnum -->
+<!ENTITY lt      "&#38;#60;"> <!--  less-than sign, U+003C ISOnum -->
+<!ENTITY gt      "&#62;"> <!--  greater-than sign, U+003E ISOnum -->
+<!ENTITY apos	 "&#39;"> <!--  apostrophe = APL quote, U+0027 ISOnum -->
+
+<!-- Latin Extended-A -->
+<!ENTITY OElig   "&#338;"> <!--  latin capital ligature OE,
+                                    U+0152 ISOlat2 -->
+<!ENTITY oelig   "&#339;"> <!--  latin small ligature oe, U+0153 ISOlat2 -->
+<!-- ligature is a misnomer, this is a separate character in some languages -->
+<!ENTITY Scaron  "&#352;"> <!--  latin capital letter S with caron,
+                                    U+0160 ISOlat2 -->
+<!ENTITY scaron  "&#353;"> <!--  latin small letter s with caron,
+                                    U+0161 ISOlat2 -->
+<!ENTITY Yuml    "&#376;"> <!--  latin capital letter Y with diaeresis,
+                                    U+0178 ISOlat2 -->
+
+<!-- Spacing Modifier Letters -->
+<!ENTITY circ    "&#710;"> <!--  modifier letter circumflex accent,
+                                    U+02C6 ISOpub -->
+<!ENTITY tilde   "&#732;"> <!--  small tilde, U+02DC ISOdia -->
+
+<!-- General Punctuation -->
+<!ENTITY ensp    "&#8194;"> <!-- en space, U+2002 ISOpub -->
+<!ENTITY emsp    "&#8195;"> <!-- em space, U+2003 ISOpub -->
+<!ENTITY thinsp  "&#8201;"> <!-- thin space, U+2009 ISOpub -->
+<!ENTITY zwnj    "&#8204;"> <!-- zero width non-joiner,
+                                    U+200C NEW RFC 2070 -->
+<!ENTITY zwj     "&#8205;"> <!-- zero width joiner, U+200D NEW RFC 2070 -->
+<!ENTITY lrm     "&#8206;"> <!-- left-to-right mark, U+200E NEW RFC 2070 -->
+<!ENTITY rlm     "&#8207;"> <!-- right-to-left mark, U+200F NEW RFC 2070 -->
+<!ENTITY ndash   "&#8211;"> <!-- en dash, U+2013 ISOpub -->
+<!ENTITY mdash   "&#8212;"> <!-- em dash, U+2014 ISOpub -->
+<!ENTITY lsquo   "&#8216;"> <!-- left single quotation mark,
+                                    U+2018 ISOnum -->
+<!ENTITY rsquo   "&#8217;"> <!-- right single quotation mark,
+                                    U+2019 ISOnum -->
+<!ENTITY sbquo   "&#8218;"> <!-- single low-9 quotation mark, U+201A NEW -->
+<!ENTITY ldquo   "&#8220;"> <!-- left double quotation mark,
+                                    U+201C ISOnum -->
+<!ENTITY rdquo   "&#8221;"> <!-- right double quotation mark,
+                                    U+201D ISOnum -->
+<!ENTITY bdquo   "&#8222;"> <!-- double low-9 quotation mark, U+201E NEW -->
+<!ENTITY dagger  "&#8224;"> <!-- dagger, U+2020 ISOpub -->
+<!ENTITY Dagger  "&#8225;"> <!-- double dagger, U+2021 ISOpub -->
+<!ENTITY permil  "&#8240;"> <!-- per mille sign, U+2030 ISOtech -->
+<!ENTITY lsaquo  "&#8249;"> <!-- single left-pointing angle quotation mark,
+                                    U+2039 ISO proposed -->
+<!-- lsaquo is proposed but not yet ISO standardized -->
+<!ENTITY rsaquo  "&#8250;"> <!-- single right-pointing angle quotation mark,
+                                    U+203A ISO proposed -->
+<!-- rsaquo is proposed but not yet ISO standardized -->
+
+<!-- Currency Symbols -->
+<!ENTITY euro   "&#8364;"> <!--  euro sign, U+20AC NEW -->

tests/wpt/web-platform-tests/css/tools/w3ctestlib/catalog/xhtml-symbol.ent

@@ -0,0 +1,237 @@
+<!-- Mathematical, Greek and Symbolic characters for XHTML -->
+
+<!-- Character entity set. Typical invocation:
+     <!ENTITY % HTMLsymbol PUBLIC
+        "-//W3C//ENTITIES Symbols for XHTML//EN"
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent">
+     %HTMLsymbol;
+-->
+
+<!-- Portions (C) International Organization for Standardization 1986:
+     Permission to copy in any form is granted for use with
+     conforming SGML systems and applications as defined in
+     ISO 8879, provided this notice is included in all copies.
+-->
+
+<!-- Relevant ISO entity set is given unless names are newly introduced.
+     New names (i.e., not in ISO 8879 list) do not clash with any
+     existing ISO 8879 entity names. ISO 10646 character numbers
+     are given for each character, in hex. values are decimal
+     conversions of the ISO 10646 values and refer to the document
+     character set. Names are Unicode names. 
+-->
+
+<!-- Latin Extended-B -->
+<!ENTITY fnof     "&#402;"> <!-- latin small letter f with hook = function
+                                    = florin, U+0192 ISOtech -->
+
+<!-- Greek -->
+<!ENTITY Alpha    "&#913;"> <!-- greek capital letter alpha, U+0391 -->
+<!ENTITY Beta     "&#914;"> <!-- greek capital letter beta, U+0392 -->
+<!ENTITY Gamma    "&#915;"> <!-- greek capital letter gamma,
+                                    U+0393 ISOgrk3 -->
+<!ENTITY Delta    "&#916;"> <!-- greek capital letter delta,
+                                    U+0394 ISOgrk3 -->
+<!ENTITY Epsilon  "&#917;"> <!-- greek capital letter epsilon, U+0395 -->
+<!ENTITY Zeta     "&#918;"> <!-- greek capital letter zeta, U+0396 -->
+<!ENTITY Eta      "&#919;"> <!-- greek capital letter eta, U+0397 -->
+<!ENTITY Theta    "&#920;"> <!-- greek capital letter theta,
+                                    U+0398 ISOgrk3 -->
+<!ENTITY Iota     "&#921;"> <!-- greek capital letter iota, U+0399 -->
+<!ENTITY Kappa    "&#922;"> <!-- greek capital letter kappa, U+039A -->
+<!ENTITY Lambda   "&#923;"> <!-- greek capital letter lamda,
+                                    U+039B ISOgrk3 -->
+<!ENTITY Mu       "&#924;"> <!-- greek capital letter mu, U+039C -->
+<!ENTITY Nu       "&#925;"> <!-- greek capital letter nu, U+039D -->
+<!ENTITY Xi       "&#926;"> <!-- greek capital letter xi, U+039E ISOgrk3 -->
+<!ENTITY Omicron  "&#927;"> <!-- greek capital letter omicron, U+039F -->
+<!ENTITY Pi       "&#928;"> <!-- greek capital letter pi, U+03A0 ISOgrk3 -->
+<!ENTITY Rho      "&#929;"> <!-- greek capital letter rho, U+03A1 -->
+<!-- there is no Sigmaf, and no U+03A2 character either -->
+<!ENTITY Sigma    "&#931;"> <!-- greek capital letter sigma,
+                                    U+03A3 ISOgrk3 -->
+<!ENTITY Tau      "&#932;"> <!-- greek capital letter tau, U+03A4 -->
+<!ENTITY Upsilon  "&#933;"> <!-- greek capital letter upsilon,
+                                    U+03A5 ISOgrk3 -->
+<!ENTITY Phi      "&#934;"> <!-- greek capital letter phi,
+                                    U+03A6 ISOgrk3 -->
+<!ENTITY Chi      "&#935;"> <!-- greek capital letter chi, U+03A7 -->
+<!ENTITY Psi      "&#936;"> <!-- greek capital letter psi,
+                                    U+03A8 ISOgrk3 -->
+<!ENTITY Omega    "&#937;"> <!-- greek capital letter omega,
+                                    U+03A9 ISOgrk3 -->
+
+<!ENTITY alpha    "&#945;"> <!-- greek small letter alpha,
+                                    U+03B1 ISOgrk3 -->
+<!ENTITY beta     "&#946;"> <!-- greek small letter beta, U+03B2 ISOgrk3 -->
+<!ENTITY gamma    "&#947;"> <!-- greek small letter gamma,
+                                    U+03B3 ISOgrk3 -->
+<!ENTITY delta    "&#948;"> <!-- greek small letter delta,
+                                    U+03B4 ISOgrk3 -->
+<!ENTITY epsilon  "&#949;"> <!-- greek small letter epsilon,
+                                    U+03B5 ISOgrk3 -->
+<!ENTITY zeta     "&#950;"> <!-- greek small letter zeta, U+03B6 ISOgrk3 -->
+<!ENTITY eta      "&#951;"> <!-- greek small letter eta, U+03B7 ISOgrk3 -->
+<!ENTITY theta    "&#952;"> <!-- greek small letter theta,
+                                    U+03B8 ISOgrk3 -->
+<!ENTITY iota     "&#953;"> <!-- greek small letter iota, U+03B9 ISOgrk3 -->
+<!ENTITY kappa    "&#954;"> <!-- greek small letter kappa,
+                                    U+03BA ISOgrk3 -->
+<!ENTITY lambda   "&#955;"> <!-- greek small letter lamda,
+                                    U+03BB ISOgrk3 -->
+<!ENTITY mu       "&#956;"> <!-- greek small letter mu, U+03BC ISOgrk3 -->
+<!ENTITY nu       "&#957;"> <!-- greek small letter nu, U+03BD ISOgrk3 -->
+<!ENTITY xi       "&#958;"> <!-- greek small letter xi, U+03BE ISOgrk3 -->
+<!ENTITY omicron  "&#959;"> <!-- greek small letter omicron, U+03BF NEW -->
+<!ENTITY pi       "&#960;"> <!-- greek small letter pi, U+03C0 ISOgrk3 -->
+<!ENTITY rho      "&#961;"> <!-- greek small letter rho, U+03C1 ISOgrk3 -->
+<!ENTITY sigmaf   "&#962;"> <!-- greek small letter final sigma,
+                                    U+03C2 ISOgrk3 -->
+<!ENTITY sigma    "&#963;"> <!-- greek small letter sigma,
+                                    U+03C3 ISOgrk3 -->
+<!ENTITY tau      "&#964;"> <!-- greek small letter tau, U+03C4 ISOgrk3 -->
+<!ENTITY upsilon  "&#965;"> <!-- greek small letter upsilon,
+                                    U+03C5 ISOgrk3 -->
+<!ENTITY phi      "&#966;"> <!-- greek small letter phi, U+03C6 ISOgrk3 -->
+<!ENTITY chi      "&#967;"> <!-- greek small letter chi, U+03C7 ISOgrk3 -->
+<!ENTITY psi      "&#968;"> <!-- greek small letter psi, U+03C8 ISOgrk3 -->
+<!ENTITY omega    "&#969;"> <!-- greek small letter omega,
+                                    U+03C9 ISOgrk3 -->
+<!ENTITY thetasym "&#977;"> <!-- greek theta symbol,
+                                    U+03D1 NEW -->
+<!ENTITY upsih    "&#978;"> <!-- greek upsilon with hook symbol,
+                                    U+03D2 NEW -->
+<!ENTITY piv      "&#982;"> <!-- greek pi symbol, U+03D6 ISOgrk3 -->
+
+<!-- General Punctuation -->
+<!ENTITY bull     "&#8226;"> <!-- bullet = black small circle,
+                                     U+2022 ISOpub  -->
+<!-- bullet is NOT the same as bullet operator, U+2219 -->
+<!ENTITY hellip   "&#8230;"> <!-- horizontal ellipsis = three dot leader,
+                                     U+2026 ISOpub  -->
+<!ENTITY prime    "&#8242;"> <!-- prime = minutes = feet, U+2032 ISOtech -->
+<!ENTITY Prime    "&#8243;"> <!-- double prime = seconds = inches,
+                                     U+2033 ISOtech -->
+<!ENTITY oline    "&#8254;"> <!-- overline = spacing overscore,
+                                     U+203E NEW -->
+<!ENTITY frasl    "&#8260;"> <!-- fraction slash, U+2044 NEW -->
+
+<!-- Letterlike Symbols -->
+<!ENTITY weierp   "&#8472;"> <!-- script capital P = power set
+                                     = Weierstrass p, U+2118 ISOamso -->
+<!ENTITY image    "&#8465;"> <!-- black-letter capital I = imaginary part,
+                                     U+2111 ISOamso -->
+<!ENTITY real     "&#8476;"> <!-- black-letter capital R = real part symbol,
+                                     U+211C ISOamso -->
+<!ENTITY trade    "&#8482;"> <!-- trade mark sign, U+2122 ISOnum -->
+<!ENTITY alefsym  "&#8501;"> <!-- alef symbol = first transfinite cardinal,
+                                     U+2135 NEW -->
+<!-- alef symbol is NOT the same as hebrew letter alef,
+     U+05D0 although the same glyph could be used to depict both characters -->
+
+<!-- Arrows -->
+<!ENTITY larr     "&#8592;"> <!-- leftwards arrow, U+2190 ISOnum -->
+<!ENTITY uarr     "&#8593;"> <!-- upwards arrow, U+2191 ISOnum-->
+<!ENTITY rarr     "&#8594;"> <!-- rightwards arrow, U+2192 ISOnum -->
+<!ENTITY darr     "&#8595;"> <!-- downwards arrow, U+2193 ISOnum -->
+<!ENTITY harr     "&#8596;"> <!-- left right arrow, U+2194 ISOamsa -->
+<!ENTITY crarr    "&#8629;"> <!-- downwards arrow with corner leftwards
+                                     = carriage return, U+21B5 NEW -->
+<!ENTITY lArr     "&#8656;"> <!-- leftwards double arrow, U+21D0 ISOtech -->
+<!-- Unicode does not say that lArr is the same as the 'is implied by' arrow
+    but also does not have any other character for that function. So lArr can
+    be used for 'is implied by' as ISOtech suggests -->
+<!ENTITY uArr     "&#8657;"> <!-- upwards double arrow, U+21D1 ISOamsa -->
+<!ENTITY rArr     "&#8658;"> <!-- rightwards double arrow,
+                                     U+21D2 ISOtech -->
+<!-- Unicode does not say this is the 'implies' character but does not have 
+     another character with this function so rArr can be used for 'implies'
+     as ISOtech suggests -->
+<!ENTITY dArr     "&#8659;"> <!-- downwards double arrow, U+21D3 ISOamsa -->
+<!ENTITY hArr     "&#8660;"> <!-- left right double arrow,
+                                     U+21D4 ISOamsa -->
+
+<!-- Mathematical Operators -->
+<!ENTITY forall   "&#8704;"> <!-- for all, U+2200 ISOtech -->
+<!ENTITY part     "&#8706;"> <!-- partial differential, U+2202 ISOtech  -->
+<!ENTITY exist    "&#8707;"> <!-- there exists, U+2203 ISOtech -->
+<!ENTITY empty    "&#8709;"> <!-- empty set = null set, U+2205 ISOamso -->
+<!ENTITY nabla    "&#8711;"> <!-- nabla = backward difference,
+                                     U+2207 ISOtech -->
+<!ENTITY isin     "&#8712;"> <!-- element of, U+2208 ISOtech -->
+<!ENTITY notin    "&#8713;"> <!-- not an element of, U+2209 ISOtech -->
+<!ENTITY ni       "&#8715;"> <!-- contains as member, U+220B ISOtech -->
+<!ENTITY prod     "&#8719;"> <!-- n-ary product = product sign,
+                                     U+220F ISOamsb -->
+<!-- prod is NOT the same character as U+03A0 'greek capital letter pi' though
+     the same glyph might be used for both -->
+<!ENTITY sum      "&#8721;"> <!-- n-ary summation, U+2211 ISOamsb -->
+<!-- sum is NOT the same character as U+03A3 'greek capital letter sigma'
+     though the same glyph might be used for both -->
+<!ENTITY minus    "&#8722;"> <!-- minus sign, U+2212 ISOtech -->
+<!ENTITY lowast   "&#8727;"> <!-- asterisk operator, U+2217 ISOtech -->
+<!ENTITY radic    "&#8730;"> <!-- square root = radical sign,
+                                     U+221A ISOtech -->
+<!ENTITY prop     "&#8733;"> <!-- proportional to, U+221D ISOtech -->
+<!ENTITY infin    "&#8734;"> <!-- infinity, U+221E ISOtech -->
+<!ENTITY ang      "&#8736;"> <!-- angle, U+2220 ISOamso -->
+<!ENTITY and      "&#8743;"> <!-- logical and = wedge, U+2227 ISOtech -->
+<!ENTITY or       "&#8744;"> <!-- logical or = vee, U+2228 ISOtech -->
+<!ENTITY cap      "&#8745;"> <!-- intersection = cap, U+2229 ISOtech -->
+<!ENTITY cup      "&#8746;"> <!-- union = cup, U+222A ISOtech -->
+<!ENTITY int      "&#8747;"> <!-- integral, U+222B ISOtech -->
+<!ENTITY there4   "&#8756;"> <!-- therefore, U+2234 ISOtech -->
+<!ENTITY sim      "&#8764;"> <!-- tilde operator = varies with = similar to,
+                                     U+223C ISOtech -->
+<!-- tilde operator is NOT the same character as the tilde, U+007E,
+     although the same glyph might be used to represent both  -->
+<!ENTITY cong     "&#8773;"> <!-- approximately equal to, U+2245 ISOtech -->
+<!ENTITY asymp    "&#8776;"> <!-- almost equal to = asymptotic to,
+                                     U+2248 ISOamsr -->
+<!ENTITY ne       "&#8800;"> <!-- not equal to, U+2260 ISOtech -->
+<!ENTITY equiv    "&#8801;"> <!-- identical to, U+2261 ISOtech -->
+<!ENTITY le       "&#8804;"> <!-- less-than or equal to, U+2264 ISOtech -->
+<!ENTITY ge       "&#8805;"> <!-- greater-than or equal to,
+                                     U+2265 ISOtech -->
+<!ENTITY sub      "&#8834;"> <!-- subset of, U+2282 ISOtech -->
+<!ENTITY sup      "&#8835;"> <!-- superset of, U+2283 ISOtech -->
+<!ENTITY nsub     "&#8836;"> <!-- not a subset of, U+2284 ISOamsn -->
+<!ENTITY sube     "&#8838;"> <!-- subset of or equal to, U+2286 ISOtech -->
+<!ENTITY supe     "&#8839;"> <!-- superset of or equal to,
+                                     U+2287 ISOtech -->
+<!ENTITY oplus    "&#8853;"> <!-- circled plus = direct sum,
+                                     U+2295 ISOamsb -->
+<!ENTITY otimes   "&#8855;"> <!-- circled times = vector product,
+                                     U+2297 ISOamsb -->
+<!ENTITY perp     "&#8869;"> <!-- up tack = orthogonal to = perpendicular,
+                                     U+22A5 ISOtech -->
+<!ENTITY sdot     "&#8901;"> <!-- dot operator, U+22C5 ISOamsb -->
+<!-- dot operator is NOT the same character as U+00B7 middle dot -->
+
+<!-- Miscellaneous Technical -->
+<!ENTITY lceil    "&#8968;"> <!-- left ceiling = APL upstile,
+                                     U+2308 ISOamsc  -->
+<!ENTITY rceil    "&#8969;"> <!-- right ceiling, U+2309 ISOamsc  -->
+<!ENTITY lfloor   "&#8970;"> <!-- left floor = APL downstile,
+                                     U+230A ISOamsc  -->
+<!ENTITY rfloor   "&#8971;"> <!-- right floor, U+230B ISOamsc  -->
+<!ENTITY lang     "&#9001;"> <!-- left-pointing angle bracket = bra,
+                                     U+2329 ISOtech -->
+<!-- lang is NOT the same character as U+003C 'less than sign' 
+     or U+2039 'single left-pointing angle quotation mark' -->
+<!ENTITY rang     "&#9002;"> <!-- right-pointing angle bracket = ket,
+                                     U+232A ISOtech -->
+<!-- rang is NOT the same character as U+003E 'greater than sign' 
+     or U+203A 'single right-pointing angle quotation mark' -->
+
+<!-- Geometric Shapes -->
+<!ENTITY loz      "&#9674;"> <!-- lozenge, U+25CA ISOpub -->
+
+<!-- Miscellaneous Symbols -->
+<!ENTITY spades   "&#9824;"> <!-- black spade suit, U+2660 ISOpub -->
+<!-- black here seems to mean filled as opposed to hollow -->
+<!ENTITY clubs    "&#9827;"> <!-- black club suit = shamrock,
+                                     U+2663 ISOpub -->
+<!ENTITY hearts   "&#9829;"> <!-- black heart suit = valentine,
+                                     U+2665 ISOpub -->
+<!ENTITY diams    "&#9830;"> <!-- black diamond suit, U+2666 ISOpub -->

tests/wpt/web-platform-tests/css/tools/w3ctestlib/catalog/xhtml1-strict.dtd

@@ -0,0 +1,978 @@
+<!--
+   Extensible HTML version 1.0 Strict DTD
+
+   This is the same as HTML 4 Strict except for
+   changes due to the differences between XML and SGML.
+
+   Namespace = http://www.w3.org/1999/xhtml
+
+   For further information, see: http://www.w3.org/TR/xhtml1
+
+   Copyright (c) 1998-2002 W3C (MIT, INRIA, Keio),
+   All Rights Reserved. 
+
+   This DTD module is identified by the PUBLIC and SYSTEM identifiers:
+
+   PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+   SYSTEM "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
+
+   $Revision: 1.1 $
+   $Date: 2002/08/01 13:56:03 $
+
+-->
+
+<!--================ Character mnemonic entities =========================-->
+
+<!ENTITY % HTMLlat1 PUBLIC
+   "-//W3C//ENTITIES Latin 1 for XHTML//EN"
+   "xhtml-lat1.ent">
+%HTMLlat1;
+
+<!ENTITY % HTMLsymbol PUBLIC
+   "-//W3C//ENTITIES Symbols for XHTML//EN"
+   "xhtml-symbol.ent">
+%HTMLsymbol;
+
+<!ENTITY % HTMLspecial PUBLIC
+   "-//W3C//ENTITIES Special for XHTML//EN"
+   "xhtml-special.ent">
+%HTMLspecial;
+
+<!--================== Imported Names ====================================-->
+
+<!ENTITY % ContentType "CDATA">
+    <!-- media type, as per [RFC2045] -->
+
+<!ENTITY % ContentTypes "CDATA">
+    <!-- comma-separated list of media types, as per [RFC2045] -->
+
+<!ENTITY % Charset "CDATA">
+    <!-- a character encoding, as per [RFC2045] -->
+
+<!ENTITY % Charsets "CDATA">
+    <!-- a space separated list of character encodings, as per [RFC2045] -->
+
+<!ENTITY % LanguageCode "NMTOKEN">
+    <!-- a language code, as per [RFC3066] -->
+
+<!ENTITY % Character "CDATA">
+    <!-- a single character, as per section 2.2 of [XML] -->
+
+<!ENTITY % Number "CDATA">
+    <!-- one or more digits -->
+
+<!ENTITY % LinkTypes "CDATA">
+    <!-- space-separated list of link types -->
+
+<!ENTITY % MediaDesc "CDATA">
+    <!-- single or comma-separated list of media descriptors -->
+
+<!ENTITY % URI "CDATA">
+    <!-- a Uniform Resource Identifier, see [RFC2396] -->
+
+<!ENTITY % UriList "CDATA">
+    <!-- a space separated list of Uniform Resource Identifiers -->
+
+<!ENTITY % Datetime "CDATA">
+    <!-- date and time information. ISO date format -->
+
+<!ENTITY % Script "CDATA">
+    <!-- script expression -->
+
+<!ENTITY % StyleSheet "CDATA">
+    <!-- style sheet data -->
+
+<!ENTITY % Text "CDATA">
+    <!-- used for titles etc. -->
+
+<!ENTITY % Length "CDATA">
+    <!-- nn for pixels or nn% for percentage length -->
+
+<!ENTITY % MultiLength "CDATA">
+    <!-- pixel, percentage, or relative -->
+
+<!ENTITY % Pixels "CDATA">
+    <!-- integer representing length in pixels -->
+
+<!-- these are used for image maps -->
+
+<!ENTITY % Shape "(rect|circle|poly|default)">
+
+<!ENTITY % Coords "CDATA">
+    <!-- comma separated list of lengths -->
+
+<!--=================== Generic Attributes ===============================-->
+
+<!-- core attributes common to most elements
+  id       document-wide unique id
+  class    space separated list of classes
+  style    associated style info
+  title    advisory title/amplification
+-->
+<!ENTITY % coreattrs
+ "id          ID             #IMPLIED
+  class       CDATA          #IMPLIED
+  style       %StyleSheet;   #IMPLIED
+  title       %Text;         #IMPLIED"
+  >
+
+<!-- internationalization attributes
+  lang        language code (backwards compatible)
+  xml:lang    language code (as per XML 1.0 spec)
+  dir         direction for weak/neutral text
+-->
+<!ENTITY % i18n
+ "lang        %LanguageCode; #IMPLIED
+  xml:lang    %LanguageCode; #IMPLIED
+  dir         (ltr|rtl)      #IMPLIED"
+  >
+
+<!-- attributes for common UI events
+  onclick     a pointer button was clicked
+  ondblclick  a pointer button was double clicked
+  onmousedown a pointer button was pressed down
+  onmouseup   a pointer button was released
+  onmousemove a pointer was moved onto the element
+  onmouseout  a pointer was moved away from the element
+  onkeypress  a key was pressed and released
+  onkeydown   a key was pressed down
+  onkeyup     a key was released
+-->
+<!ENTITY % events
+ "onclick     %Script;       #IMPLIED
+  ondblclick  %Script;       #IMPLIED
+  onmousedown %Script;       #IMPLIED
+  onmouseup   %Script;       #IMPLIED
+  onmouseover %Script;       #IMPLIED
+  onmousemove %Script;       #IMPLIED
+  onmouseout  %Script;       #IMPLIED
+  onkeypress  %Script;       #IMPLIED
+  onkeydown   %Script;       #IMPLIED
+  onkeyup     %Script;       #IMPLIED"
+  >
+
+<!-- attributes for elements that can get the focus
+  accesskey   accessibility key character
+  tabindex    position in tabbing order
+  onfocus     the element got the focus
+  onblur      the element lost the focus
+-->
+<!ENTITY % focus
+ "accesskey   %Character;    #IMPLIED
+  tabindex    %Number;       #IMPLIED
+  onfocus     %Script;       #IMPLIED
+  onblur      %Script;       #IMPLIED"
+  >
+
+<!ENTITY % attrs "%coreattrs; %i18n; %events;">
+
+<!--=================== Text Elements ====================================-->
+
+<!ENTITY % special.pre
+   "br | span | bdo | map">
+
+
+<!ENTITY % special
+   "%special.pre; | object | img ">
+
+<!ENTITY % fontstyle "tt | i | b | big | small ">
+
+<!ENTITY % phrase "em | strong | dfn | code | q |
+                   samp | kbd | var | cite | abbr | acronym | sub | sup ">
+
+<!ENTITY % inline.forms "input | select | textarea | label | button">
+
+<!-- these can occur at block or inline level -->
+<!ENTITY % misc.inline "ins | del | script">
+
+<!-- these can only occur at block level -->
+<!ENTITY % misc "noscript | %misc.inline;">
+
+<!ENTITY % inline "a | %special; | %fontstyle; | %phrase; | %inline.forms;">
+
+<!-- %Inline; covers inline or "text-level" elements -->
+<!ENTITY % Inline "(#PCDATA | %inline; | %misc.inline;)*">
+
+<!--================== Block level elements ==============================-->
+
+<!ENTITY % heading "h1|h2|h3|h4|h5|h6">
+<!ENTITY % lists "ul | ol | dl">
+<!ENTITY % blocktext "pre | hr | blockquote | address">
+
+<!ENTITY % block
+     "p | %heading; | div | %lists; | %blocktext; | fieldset | table">
+
+<!ENTITY % Block "(%block; | form | %misc;)*">
+
+<!-- %Flow; mixes block and inline and is used for list items etc. -->
+<!ENTITY % Flow "(#PCDATA | %block; | form | %inline; | %misc;)*">
+
+<!--================== Content models for exclusions =====================-->
+
+<!-- a elements use %Inline; excluding a -->
+
+<!ENTITY % a.content
+   "(#PCDATA | %special; | %fontstyle; | %phrase; | %inline.forms; | %misc.inline;)*">
+
+<!-- pre uses %Inline excluding big, small, sup or sup -->
+
+<!ENTITY % pre.content
+   "(#PCDATA | a | %fontstyle; | %phrase; | %special.pre; | %misc.inline;
+      | %inline.forms;)*">
+
+<!-- form uses %Block; excluding form -->
+
+<!ENTITY % form.content "(%block; | %misc;)*">
+
+<!-- button uses %Flow; but excludes a, form and form controls -->
+
+<!ENTITY % button.content
+   "(#PCDATA | p | %heading; | div | %lists; | %blocktext; |
+    table | %special; | %fontstyle; | %phrase; | %misc;)*">
+
+<!--================ Document Structure ==================================-->
+
+<!-- the namespace URI designates the document profile -->
+
+<!ELEMENT html (head, body)>
+<!ATTLIST html
+  %i18n;
+  id          ID             #IMPLIED
+  xmlns       %URI;          #FIXED 'http://www.w3.org/1999/xhtml'
+  >
+
+<!--================ Document Head =======================================-->
+
+<!ENTITY % head.misc "(script|style|meta|link|object)*">
+
+<!-- content model is %head.misc; combined with a single
+     title and an optional base element in any order -->
+
+<!ELEMENT head (%head.misc;,
+     ((title, %head.misc;, (base, %head.misc;)?) |
+      (base, %head.misc;, (title, %head.misc;))))>
+
+<!ATTLIST head
+  %i18n;
+  id          ID             #IMPLIED
+  profile     %URI;          #IMPLIED
+  >
+
+<!-- The title element is not considered part of the flow of text.
+       It should be displayed, for example as the page header or
+       window title. Exactly one title is required per document.
+    -->
+<!ELEMENT title (#PCDATA)>
+<!ATTLIST title 
+  %i18n;
+  id          ID             #IMPLIED
+  >
+
+<!-- document base URI -->
+
+<!ELEMENT base EMPTY>
+<!ATTLIST base
+  href        %URI;          #REQUIRED
+  id          ID             #IMPLIED
+  >
+
+<!-- generic metainformation -->
+<!ELEMENT meta EMPTY>
+<!ATTLIST meta
+  %i18n;
+  id          ID             #IMPLIED
+  http-equiv  CDATA          #IMPLIED
+  name        CDATA          #IMPLIED
+  content     CDATA          #REQUIRED
+  scheme      CDATA          #IMPLIED
+  >
+
+<!--
+  Relationship values can be used in principle:
+
+   a) for document specific toolbars/menus when used
+      with the link element in document head e.g.
+        start, contents, previous, next, index, end, help
+   b) to link to a separate style sheet (rel="stylesheet")
+   c) to make a link to a script (rel="script")
+   d) by stylesheets to control how collections of
+      html nodes are rendered into printed documents
+   e) to make a link to a printable version of this document
+      e.g. a PostScript or PDF version (rel="alternate" media="print")
+-->
+
+<!ELEMENT link EMPTY>
+<!ATTLIST link
+  %attrs;
+  charset     %Charset;      #IMPLIED
+  href        %URI;          #IMPLIED
+  hreflang    %LanguageCode; #IMPLIED
+  type        %ContentType;  #IMPLIED
+  rel         %LinkTypes;    #IMPLIED
+  rev         %LinkTypes;    #IMPLIED
+  media       %MediaDesc;    #IMPLIED
+  >
+
+<!-- style info, which may include CDATA sections -->
+<!ELEMENT style (#PCDATA)>
+<!ATTLIST style
+  %i18n;
+  id          ID             #IMPLIED
+  type        %ContentType;  #REQUIRED
+  media       %MediaDesc;    #IMPLIED
+  title       %Text;         #IMPLIED
+  xml:space   (preserve)     #FIXED 'preserve'
+  >
+
+<!-- script statements, which may include CDATA sections -->
+<!ELEMENT script (#PCDATA)>
+<!ATTLIST script
+  id          ID             #IMPLIED
+  charset     %Charset;      #IMPLIED
+  type        %ContentType;  #REQUIRED
+  src         %URI;          #IMPLIED
+  defer       (defer)        #IMPLIED
+  xml:space   (preserve)     #FIXED 'preserve'
+  >
+
+<!-- alternate content container for non script-based rendering -->
+
+<!ELEMENT noscript %Block;>
+<!ATTLIST noscript
+  %attrs;
+  >
+
+<!--=================== Document Body ====================================-->
+
+<!ELEMENT body %Block;>
+<!ATTLIST body
+  %attrs;
+  onload          %Script;   #IMPLIED
+  onunload        %Script;   #IMPLIED
+  >
+
+<!ELEMENT div %Flow;>  <!-- generic language/style container -->
+<!ATTLIST div
+  %attrs;
+  >
+
+<!--=================== Paragraphs =======================================-->
+
+<!ELEMENT p %Inline;>
+<!ATTLIST p
+  %attrs;
+  >
+
+<!--=================== Headings =========================================-->
+
+<!--
+  There are six levels of headings from h1 (the most important)
+  to h6 (the least important).
+-->
+
+<!ELEMENT h1  %Inline;>
+<!ATTLIST h1
+   %attrs;
+   >
+
+<!ELEMENT h2 %Inline;>
+<!ATTLIST h2
+   %attrs;
+   >
+
+<!ELEMENT h3 %Inline;>
+<!ATTLIST h3
+   %attrs;
+   >
+
+<!ELEMENT h4 %Inline;>
+<!ATTLIST h4
+   %attrs;
+   >
+
+<!ELEMENT h5 %Inline;>
+<!ATTLIST h5
+   %attrs;
+   >
+
+<!ELEMENT h6 %Inline;>
+<!ATTLIST h6
+   %attrs;
+   >
+
+<!--=================== Lists ============================================-->
+
+<!-- Unordered list -->
+
+<!ELEMENT ul (li)+>
+<!ATTLIST ul
+  %attrs;
+  >
+
+<!-- Ordered (numbered) list -->
+
+<!ELEMENT ol (li)+>
+<!ATTLIST ol
+  %attrs;
+  >
+
+<!-- list item -->
+
+<!ELEMENT li %Flow;>
+<!ATTLIST li
+  %attrs;
+  >
+
+<!-- definition lists - dt for term, dd for its definition -->
+
+<!ELEMENT dl (dt|dd)+>
+<!ATTLIST dl
+  %attrs;
+  >
+
+<!ELEMENT dt %Inline;>
+<!ATTLIST dt
+  %attrs;
+  >
+
+<!ELEMENT dd %Flow;>
+<!ATTLIST dd
+  %attrs;
+  >
+
+<!--=================== Address ==========================================-->
+
+<!-- information on author -->
+
+<!ELEMENT address %Inline;>
+<!ATTLIST address
+  %attrs;
+  >
+
+<!--=================== Horizontal Rule ==================================-->
+
+<!ELEMENT hr EMPTY>
+<!ATTLIST hr
+  %attrs;
+  >
+
+<!--=================== Preformatted Text ================================-->
+
+<!-- content is %Inline; excluding "img|object|big|small|sub|sup" -->
+
+<!ELEMENT pre %pre.content;>
+<!ATTLIST pre
+  %attrs;
+  xml:space (preserve) #FIXED 'preserve'
+  >
+
+<!--=================== Block-like Quotes ================================-->
+
+<!ELEMENT blockquote %Block;>
+<!ATTLIST blockquote
+  %attrs;
+  cite        %URI;          #IMPLIED
+  >
+
+<!--=================== Inserted/Deleted Text ============================-->
+
+<!--
+  ins/del are allowed in block and inline content, but its
+  inappropriate to include block content within an ins element
+  occurring in inline content.
+-->
+<!ELEMENT ins %Flow;>
+<!ATTLIST ins
+  %attrs;
+  cite        %URI;          #IMPLIED
+  datetime    %Datetime;     #IMPLIED
+  >
+
+<!ELEMENT del %Flow;>
+<!ATTLIST del
+  %attrs;
+  cite        %URI;          #IMPLIED
+  datetime    %Datetime;     #IMPLIED
+  >
+
+<!--================== The Anchor Element ================================-->
+
+<!-- content is %Inline; except that anchors shouldn't be nested -->
+
+<!ELEMENT a %a.content;>
+<!ATTLIST a
+  %attrs;
+  %focus;
+  charset     %Charset;      #IMPLIED
+  type        %ContentType;  #IMPLIED
+  name        NMTOKEN        #IMPLIED
+  href        %URI;          #IMPLIED
+  hreflang    %LanguageCode; #IMPLIED
+  rel         %LinkTypes;    #IMPLIED
+  rev         %LinkTypes;    #IMPLIED
+  shape       %Shape;        "rect"
+  coords      %Coords;       #IMPLIED
+  >
+
+<!--===================== Inline Elements ================================-->
+
+<!ELEMENT span %Inline;> <!-- generic language/style container -->
+<!ATTLIST span
+  %attrs;
+  >
+
+<!ELEMENT bdo %Inline;>  <!-- I18N BiDi over-ride -->
+<!ATTLIST bdo
+  %coreattrs;
+  %events;
+  lang        %LanguageCode; #IMPLIED
+  xml:lang    %LanguageCode; #IMPLIED
+  dir         (ltr|rtl)      #REQUIRED
+  >
+
+<!ELEMENT br EMPTY>   <!-- forced line break -->
+<!ATTLIST br
+  %coreattrs;
+  >
+
+<!ELEMENT em %Inline;>   <!-- emphasis -->
+<!ATTLIST em %attrs;>
+
+<!ELEMENT strong %Inline;>   <!-- strong emphasis -->
+<!ATTLIST strong %attrs;>
+
+<!ELEMENT dfn %Inline;>   <!-- definitional -->
+<!ATTLIST dfn %attrs;>
+
+<!ELEMENT code %Inline;>   <!-- program code -->
+<!ATTLIST code %attrs;>
+
+<!ELEMENT samp %Inline;>   <!-- sample -->
+<!ATTLIST samp %attrs;>
+
+<!ELEMENT kbd %Inline;>  <!-- something user would type -->
+<!ATTLIST kbd %attrs;>
+
+<!ELEMENT var %Inline;>   <!-- variable -->
+<!ATTLIST var %attrs;>
+
+<!ELEMENT cite %Inline;>   <!-- citation -->
+<!ATTLIST cite %attrs;>
+
+<!ELEMENT abbr %Inline;>   <!-- abbreviation -->
+<!ATTLIST abbr %attrs;>
+
+<!ELEMENT acronym %Inline;>   <!-- acronym -->
+<!ATTLIST acronym %attrs;>
+
+<!ELEMENT q %Inline;>   <!-- inlined quote -->
+<!ATTLIST q
+  %attrs;
+  cite        %URI;          #IMPLIED
+  >
+
+<!ELEMENT sub %Inline;> <!-- subscript -->
+<!ATTLIST sub %attrs;>
+
+<!ELEMENT sup %Inline;> <!-- superscript -->
+<!ATTLIST sup %attrs;>
+
+<!ELEMENT tt %Inline;>   <!-- fixed pitch font -->
+<!ATTLIST tt %attrs;>
+
+<!ELEMENT i %Inline;>   <!-- italic font -->
+<!ATTLIST i %attrs;>
+
+<!ELEMENT b %Inline;>   <!-- bold font -->
+<!ATTLIST b %attrs;>
+
+<!ELEMENT big %Inline;>   <!-- bigger font -->
+<!ATTLIST big %attrs;>
+
+<!ELEMENT small %Inline;>   <!-- smaller font -->
+<!ATTLIST small %attrs;>
+
+<!--==================== Object ======================================-->
+<!--
+  object is used to embed objects as part of HTML pages.
+  param elements should precede other content. Parameters
+  can also be expressed as attribute/value pairs on the
+  object element itself when brevity is desired.
+-->
+
+<!ELEMENT object (#PCDATA | param | %block; | form | %inline; | %misc;)*>
+<!ATTLIST object
+  %attrs;
+  declare     (declare)      #IMPLIED
+  classid     %URI;          #IMPLIED
+  codebase    %URI;          #IMPLIED
+  data        %URI;          #IMPLIED
+  type        %ContentType;  #IMPLIED
+  codetype    %ContentType;  #IMPLIED
+  archive     %UriList;      #IMPLIED
+  standby     %Text;         #IMPLIED
+  height      %Length;       #IMPLIED
+  width       %Length;       #IMPLIED
+  usemap      %URI;          #IMPLIED
+  name        NMTOKEN        #IMPLIED
+  tabindex    %Number;       #IMPLIED
+  >
+
+<!--
+  param is used to supply a named property value.
+  In XML it would seem natural to follow RDF and support an
+  abbreviated syntax where the param elements are replaced
+  by attribute value pairs on the object start tag.
+-->
+<!ELEMENT param EMPTY>
+<!ATTLIST param
+  id          ID             #IMPLIED
+  name        CDATA          #IMPLIED
+  value       CDATA          #IMPLIED
+  valuetype   (data|ref|object) "data"
+  type        %ContentType;  #IMPLIED
+  >
+
+<!--=================== Images ===========================================-->
+
+<!--
+   To avoid accessibility problems for people who aren't
+   able to see the image, you should provide a text
+   description using the alt and longdesc attributes.
+   In addition, avoid the use of server-side image maps.
+   Note that in this DTD there is no name attribute. That
+   is only available in the transitional and frameset DTD.
+-->
+
+<!ELEMENT img EMPTY>
+<!ATTLIST img
+  %attrs;
+  src         %URI;          #REQUIRED
+  alt         %Text;         #REQUIRED
+  longdesc    %URI;          #IMPLIED
+  height      %Length;       #IMPLIED
+  width       %Length;       #IMPLIED
+  usemap      %URI;          #IMPLIED
+  ismap       (ismap)        #IMPLIED
+  >
+
+<!-- usemap points to a map element which may be in this document
+  or an external document, although the latter is not widely supported -->
+
+<!--================== Client-side image maps ============================-->
+
+<!-- These can be placed in the same document or grouped in a
+     separate document although this isn't yet widely supported -->
+
+<!ELEMENT map ((%block; | form | %misc;)+ | area+)>
+<!ATTLIST map
+  %i18n;
+  %events;
+  id          ID             #REQUIRED
+  class       CDATA          #IMPLIED
+  style       %StyleSheet;   #IMPLIED
+  title       %Text;         #IMPLIED
+  name        NMTOKEN        #IMPLIED
+  >
+
+<!ELEMENT area EMPTY>
+<!ATTLIST area
+  %attrs;
+  %focus;
+  shape       %Shape;        "rect"
+  coords      %Coords;       #IMPLIED
+  href        %URI;          #IMPLIED
+  nohref      (nohref)       #IMPLIED
+  alt         %Text;         #REQUIRED
+  >
+
+<!--================ Forms ===============================================-->
+<!ELEMENT form %form.content;>   <!-- forms shouldn't be nested -->
+
+<!ATTLIST form
+  %attrs;
+  action      %URI;          #REQUIRED
+  method      (get|post)     "get"
+  enctype     %ContentType;  "application/x-www-form-urlencoded"
+  onsubmit    %Script;       #IMPLIED
+  onreset     %Script;       #IMPLIED
+  accept      %ContentTypes; #IMPLIED
+  accept-charset %Charsets;  #IMPLIED
+  >
+
+<!--
+  Each label must not contain more than ONE field
+  Label elements shouldn't be nested.
+-->
+<!ELEMENT label %Inline;>
+<!ATTLIST label
+  %attrs;
+  for         IDREF          #IMPLIED
+  accesskey   %Character;    #IMPLIED
+  onfocus     %Script;       #IMPLIED
+  onblur      %Script;       #IMPLIED
+  >
+
+<!ENTITY % InputType
+  "(text | password | checkbox |
+    radio | submit | reset |
+    file | hidden | image | button)"
+   >
+
+<!-- the name attribute is required for all but submit & reset -->
+
+<!ELEMENT input EMPTY>     <!-- form control -->
+<!ATTLIST input
+  %attrs;
+  %focus;
+  type        %InputType;    "text"
+  name        CDATA          #IMPLIED
+  value       CDATA          #IMPLIED
+  checked     (checked)      #IMPLIED
+  disabled    (disabled)     #IMPLIED
+  readonly    (readonly)     #IMPLIED
+  size        CDATA          #IMPLIED
+  maxlength   %Number;       #IMPLIED
+  src         %URI;          #IMPLIED
+  alt         CDATA          #IMPLIED
+  usemap      %URI;          #IMPLIED
+  onselect    %Script;       #IMPLIED
+  onchange    %Script;       #IMPLIED
+  accept      %ContentTypes; #IMPLIED
+  >
+
+<!ELEMENT select (optgroup|option)+>  <!-- option selector -->
+<!ATTLIST select
+  %attrs;
+  name        CDATA          #IMPLIED
+  size        %Number;       #IMPLIED
+  multiple    (multiple)     #IMPLIED
+  disabled    (disabled)     #IMPLIED
+  tabindex    %Number;       #IMPLIED
+  onfocus     %Script;       #IMPLIED
+  onblur      %Script;       #IMPLIED
+  onchange    %Script;       #IMPLIED
+  >
+
+<!ELEMENT optgroup (option)+>   <!-- option group -->
+<!ATTLIST optgroup
+  %attrs;
+  disabled    (disabled)     #IMPLIED
+  label       %Text;         #REQUIRED
+  >
+
+<!ELEMENT option (#PCDATA)>     <!-- selectable choice -->
+<!ATTLIST option
+  %attrs;
+  selected    (selected)     #IMPLIED
+  disabled    (disabled)     #IMPLIED
+  label       %Text;         #IMPLIED
+  value       CDATA          #IMPLIED
+  >
+
+<!ELEMENT textarea (#PCDATA)>     <!-- multi-line text field -->
+<!ATTLIST textarea
+  %attrs;
+  %focus;
+  name        CDATA          #IMPLIED
+  rows        %Number;       #REQUIRED
+  cols        %Number;       #REQUIRED
+  disabled    (disabled)     #IMPLIED
+  readonly    (readonly)     #IMPLIED
+  onselect    %Script;       #IMPLIED
+  onchange    %Script;       #IMPLIED
+  >
+
+<!--
+  The fieldset element is used to group form fields.
+  Only one legend element should occur in the content
+  and if present should only be preceded by whitespace.
+-->
+<!ELEMENT fieldset (#PCDATA | legend | %block; | form | %inline; | %misc;)*>
+<!ATTLIST fieldset
+  %attrs;
+  >
+
+<!ELEMENT legend %Inline;>     <!-- fieldset label -->
+<!ATTLIST legend
+  %attrs;
+  accesskey   %Character;    #IMPLIED
+  >
+
+<!--
+ Content is %Flow; excluding a, form and form controls
+--> 
+<!ELEMENT button %button.content;>  <!-- push button -->
+<!ATTLIST button
+  %attrs;
+  %focus;
+  name        CDATA          #IMPLIED
+  value       CDATA          #IMPLIED
+  type        (button|submit|reset) "submit"
+  disabled    (disabled)     #IMPLIED
+  >
+
+<!--======================= Tables =======================================-->
+
+<!-- Derived from IETF HTML table standard, see [RFC1942] -->
+
+<!--
+ The border attribute sets the thickness of the frame around the
+ table. The default units are screen pixels.
+
+ The frame attribute specifies which parts of the frame around
+ the table should be rendered. The values are not the same as
+ CALS to avoid a name clash with the valign attribute.
+-->
+<!ENTITY % TFrame "(void|above|below|hsides|lhs|rhs|vsides|box|border)">
+
+<!--
+ The rules attribute defines which rules to draw between cells:
+
+ If rules is absent then assume:
+     "none" if border is absent or border="0" otherwise "all"
+-->
+
+<!ENTITY % TRules "(none | groups | rows | cols | all)">
+  
+<!-- horizontal alignment attributes for cell contents
+
+  char        alignment char, e.g. char=':'
+  charoff     offset for alignment char
+-->
+<!ENTITY % cellhalign
+  "align      (left|center|right|justify|char) #IMPLIED
+   char       %Character;    #IMPLIED
+   charoff    %Length;       #IMPLIED"
+  >
+
+<!-- vertical alignment attributes for cell contents -->
+<!ENTITY % cellvalign
+  "valign     (top|middle|bottom|baseline) #IMPLIED"
+  >
+
+<!ELEMENT table
+     (caption?, (col*|colgroup*), thead?, tfoot?, (tbody+|tr+))>
+<!ELEMENT caption  %Inline;>
+<!ELEMENT thead    (tr)+>
+<!ELEMENT tfoot    (tr)+>
+<!ELEMENT tbody    (tr)+>
+<!ELEMENT colgroup (col)*>
+<!ELEMENT col      EMPTY>
+<!ELEMENT tr       (th|td)+>
+<!ELEMENT th       %Flow;>
+<!ELEMENT td       %Flow;>
+
+<!ATTLIST table
+  %attrs;
+  summary     %Text;         #IMPLIED
+  width       %Length;       #IMPLIED
+  border      %Pixels;       #IMPLIED
+  frame       %TFrame;       #IMPLIED
+  rules       %TRules;       #IMPLIED
+  cellspacing %Length;       #IMPLIED
+  cellpadding %Length;       #IMPLIED
+  >
+
+<!ATTLIST caption
+  %attrs;
+  >
+
+<!--
+colgroup groups a set of col elements. It allows you to group
+several semantically related columns together.
+-->
+<!ATTLIST colgroup
+  %attrs;
+  span        %Number;       "1"
+  width       %MultiLength;  #IMPLIED
+  %cellhalign;
+  %cellvalign;
+  >
+
+<!--
+ col elements define the alignment properties for cells in
+ one or more columns.
+
+ The width attribute specifies the width of the columns, e.g.
+
+     width=64        width in screen pixels
+     width=0.5*      relative width of 0.5
+
+ The span attribute causes the attributes of one
+ col element to apply to more than one column.
+-->
+<!ATTLIST col
+  %attrs;
+  span        %Number;       "1"
+  width       %MultiLength;  #IMPLIED
+  %cellhalign;
+  %cellvalign;
+  >
+
+<!--
+    Use thead to duplicate headers when breaking table
+    across page boundaries, or for static headers when
+    tbody sections are rendered in scrolling panel.
+
+    Use tfoot to duplicate footers when breaking table
+    across page boundaries, or for static footers when
+    tbody sections are rendered in scrolling panel.
+
+    Use multiple tbody sections when rules are needed
+    between groups of table rows.
+-->
+<!ATTLIST thead
+  %attrs;
+  %cellhalign;
+  %cellvalign;
+  >
+
+<!ATTLIST tfoot
+  %attrs;
+  %cellhalign;
+  %cellvalign;
+  >
+
+<!ATTLIST tbody
+  %attrs;
+  %cellhalign;
+  %cellvalign;
+  >
+
+<!ATTLIST tr
+  %attrs;
+  %cellhalign;
+  %cellvalign;
+  >
+
+
+<!-- Scope is simpler than headers attribute for common tables -->
+<!ENTITY % Scope "(row|col|rowgroup|colgroup)">
+
+<!-- th is for headers, td for data and for cells acting as both -->
+
+<!ATTLIST th
+  %attrs;
+  abbr        %Text;         #IMPLIED
+  axis        CDATA          #IMPLIED
+  headers     IDREFS         #IMPLIED
+  scope       %Scope;        #IMPLIED
+  rowspan     %Number;       "1"
+  colspan     %Number;       "1"
+  %cellhalign;
+  %cellvalign;
+  >
+
+<!ATTLIST td
+  %attrs;
+  abbr        %Text;         #IMPLIED
+  axis        CDATA          #IMPLIED
+  headers     IDREFS         #IMPLIED
+  scope       %Scope;        #IMPLIED
+  rowspan     %Number;       "1"
+  colspan     %Number;       "1"
+  %cellhalign;
+  %cellvalign;
+  >
+

tests/wpt/web-platform-tests/css/tools/w3ctestlib/catalog/xhtml11.dtd

@@ -0,0 +1,294 @@
+<!-- ....................................................................... -->
+<!-- XHTML 1.1 DTD  ........................................................ -->
+<!-- file: xhtml11.dtd
+-->
+
+<!-- XHTML 1.1 DTD
+
+     This is XHTML, a reformulation of HTML as a modular XML application.
+
+     The Extensible HyperText Markup Language (XHTML)
+     Copyright 1998-2001 World Wide Web Consortium
+        (Massachusetts Institute of Technology, Institut National de
+         Recherche en Informatique et en Automatique, Keio University).
+         All Rights Reserved.
+
+     Permission to use, copy, modify and distribute the XHTML DTD and its 
+     accompanying documentation for any purpose and without fee is hereby 
+     granted in perpetuity, provided that the above copyright notice and 
+     this paragraph appear in all copies.  The copyright holders make no 
+     representation about the suitability of the DTD for any purpose.
+
+     It is provided "as is" without expressed or implied warranty.
+
+        Author:     Murray M. Altheim <altheim@eng.sun.com>
+        Revision:   $Id: xhtml11.dtd,v 1.21 2001/05/29 16:37:01 ahby Exp $
+
+-->
+<!-- This is the driver file for version 1.1 of the XHTML DTD.
+
+     Please use this formal public identifier to identify it:
+
+         "-//W3C//DTD XHTML 1.1//EN"
+-->
+<!ENTITY % XHTML.version  "-//W3C//DTD XHTML 1.1//EN" >
+
+<!-- Use this URI to identify the default namespace:
+
+         "http://www.w3.org/1999/xhtml"
+
+     See the Qualified Names module for information
+     on the use of namespace prefixes in the DTD.
+-->
+<!ENTITY % NS.prefixed "IGNORE" >
+<!ENTITY % XHTML.prefix "" >
+
+<!-- Reserved for use with the XLink namespace:
+-->
+<!ENTITY % XLINK.xmlns "" >
+<!ENTITY % XLINK.xmlns.attrib "" >
+
+<!-- For example, if you are using XHTML 1.1 directly, use the FPI
+     in the DOCTYPE declaration, with the xmlns attribute on the
+     document element to identify the default namespace:
+
+       <?xml version="1.0"?>
+       <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "xhtml11.dtd">
+       <html xmlns="http://www.w3.org/1999/xhtml"
+             xml:lang="en">
+       ...
+       </html>
+
+     Revisions:
+     (none)
+-->
+
+<!-- reserved for future use with document profiles -->
+<!ENTITY % XHTML.profile  "" >
+
+<!-- Bidirectional Text features
+     This feature-test entity is used to declare elements
+     and attributes used for bidirectional text support.
+-->
+<!ENTITY % XHTML.bidi  "INCLUDE" >
+
+<?doc type="doctype" role="title" { XHTML 1.1 } ?>
+
+<!-- ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: -->
+
+<!-- Pre-Framework Redeclaration placeholder  .................... -->
+<!-- this serves as a location to insert markup declarations
+     into the DTD prior to the framework declarations.
+-->
+<!ENTITY % xhtml-prefw-redecl.module "IGNORE" >
+<![%xhtml-prefw-redecl.module;[
+%xhtml-prefw-redecl.mod;
+<!-- end of xhtml-prefw-redecl.module -->]]>
+
+<!ENTITY % xhtml-events.module "INCLUDE" >
+
+<!-- Inline Style Module  ........................................ -->
+<!ENTITY % xhtml-inlstyle.module "INCLUDE" >
+<![%xhtml-inlstyle.module;[
+<!ENTITY % xhtml-inlstyle.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Inline Style 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-inlstyle-1.mod" >
+%xhtml-inlstyle.mod;]]>
+
+<!-- declare Document Model module instantiated in framework
+-->
+<!ENTITY % xhtml-model.mod
+     PUBLIC "-//W3C//ENTITIES XHTML 1.1 Document Model 1.0//EN"
+            "xhtml11-model-1.mod" >
+
+<!-- Modular Framework Module (required) ......................... -->
+<!ENTITY % xhtml-framework.module "INCLUDE" >
+<![%xhtml-framework.module;[
+<!ENTITY % xhtml-framework.mod
+     PUBLIC "-//W3C//ENTITIES XHTML Modular Framework 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-framework-1.mod" >
+%xhtml-framework.mod;]]>
+
+<!-- Post-Framework Redeclaration placeholder  ................... -->
+<!-- this serves as a location to insert markup declarations
+     into the DTD following the framework declarations.
+-->
+<!ENTITY % xhtml-postfw-redecl.module "IGNORE" >
+<![%xhtml-postfw-redecl.module;[
+%xhtml-postfw-redecl.mod;
+<!-- end of xhtml-postfw-redecl.module -->]]>
+
+<!-- Text Module (Required)  ..................................... -->
+<!ENTITY % xhtml-text.module "INCLUDE" >
+<![%xhtml-text.module;[
+<!ENTITY % xhtml-text.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Text 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-text-1.mod" >
+%xhtml-text.mod;]]>
+
+<!-- Hypertext Module (required) ................................. -->
+<!ENTITY % xhtml-hypertext.module "INCLUDE" >
+<![%xhtml-hypertext.module;[
+<!ENTITY % xhtml-hypertext.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Hypertext 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-hypertext-1.mod" >
+%xhtml-hypertext.mod;]]>
+
+<!-- Lists Module (required)  .................................... -->
+<!ENTITY % xhtml-list.module "INCLUDE" >
+<![%xhtml-list.module;[
+<!ENTITY % xhtml-list.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Lists 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-list-1.mod" >
+%xhtml-list.mod;]]>
+
+<!-- ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: -->
+
+<!-- Edit Module  ................................................ -->
+<!ENTITY % xhtml-edit.module "INCLUDE" >
+<![%xhtml-edit.module;[
+<!ENTITY % xhtml-edit.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Editing Elements 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-edit-1.mod" >
+%xhtml-edit.mod;]]>
+
+<!-- BIDI Override Module  ....................................... -->
+<!ENTITY % xhtml-bdo.module "%XHTML.bidi;" >
+<![%xhtml-bdo.module;[
+<!ENTITY % xhtml-bdo.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML BIDI Override Element 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-bdo-1.mod" >
+%xhtml-bdo.mod;]]>
+
+<!-- Ruby Module  ................................................ -->
+<!ENTITY % Ruby.common.attlists "INCLUDE" >
+<!ENTITY % Ruby.common.attrib "%Common.attrib;" >
+<!ENTITY % xhtml-ruby.module "INCLUDE" >
+<![%xhtml-ruby.module;[
+<!ENTITY % xhtml-ruby.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Ruby 1.0//EN"
+            "http://www.w3.org/TR/ruby/xhtml-ruby-1.mod" >
+%xhtml-ruby.mod;]]>
+
+<!-- Presentation Module  ........................................ -->
+<!ENTITY % xhtml-pres.module "INCLUDE" >
+<![%xhtml-pres.module;[
+<!ENTITY % xhtml-pres.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Presentation 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-pres-1.mod" >
+%xhtml-pres.mod;]]>
+
+<!-- Link Element Module  ........................................ -->
+<!ENTITY % xhtml-link.module "INCLUDE" >
+<![%xhtml-link.module;[
+<!ENTITY % xhtml-link.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Link Element 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-link-1.mod" >
+%xhtml-link.mod;]]>
+
+<!-- Document Metainformation Module  ............................ -->
+<!ENTITY % xhtml-meta.module "INCLUDE" >
+<![%xhtml-meta.module;[
+<!ENTITY % xhtml-meta.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Metainformation 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-meta-1.mod" >
+%xhtml-meta.mod;]]>
+
+<!-- Base Element Module  ........................................ -->
+<!ENTITY % xhtml-base.module "INCLUDE" >
+<![%xhtml-base.module;[
+<!ENTITY % xhtml-base.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Base Element 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-base-1.mod" >
+%xhtml-base.mod;]]>
+
+<!-- Scripting Module  ........................................... -->
+<!ENTITY % xhtml-script.module "INCLUDE" >
+<![%xhtml-script.module;[
+<!ENTITY % xhtml-script.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Scripting 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-script-1.mod" >
+%xhtml-script.mod;]]>
+
+<!-- Style Sheets Module  ......................................... -->
+<!ENTITY % xhtml-style.module "INCLUDE" >
+<![%xhtml-style.module;[
+<!ENTITY % xhtml-style.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Style Sheets 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-style-1.mod" >
+%xhtml-style.mod;]]>
+
+<!-- Image Module  ............................................... -->
+<!ENTITY % xhtml-image.module "INCLUDE" >
+<![%xhtml-image.module;[
+<!ENTITY % xhtml-image.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Images 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-image-1.mod" >
+%xhtml-image.mod;]]>
+
+<!-- Client-side Image Map Module  ............................... -->
+<!ENTITY % xhtml-csismap.module "INCLUDE" >
+<![%xhtml-csismap.module;[
+<!ENTITY % xhtml-csismap.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Client-side Image Maps 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-csismap-1.mod" >
+%xhtml-csismap.mod;]]>
+
+<!-- Server-side Image Map Module  ............................... -->
+<!ENTITY % xhtml-ssismap.module "INCLUDE" >
+<![%xhtml-ssismap.module;[
+<!ENTITY % xhtml-ssismap.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Server-side Image Maps 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-ssismap-1.mod" >
+%xhtml-ssismap.mod;]]>
+
+<!-- Param Element Module  ....................................... -->
+<!ENTITY % xhtml-param.module "INCLUDE" >
+<![%xhtml-param.module;[
+<!ENTITY % xhtml-param.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Param Element 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-param-1.mod" >
+%xhtml-param.mod;]]>
+
+<!-- Embedded Object Module  ..................................... -->
+<!ENTITY % xhtml-object.module "INCLUDE" >
+<![%xhtml-object.module;[
+<!ENTITY % xhtml-object.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Embedded Object 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-object-1.mod" >
+%xhtml-object.mod;]]>
+
+<!-- Tables Module ............................................... -->
+<!ENTITY % xhtml-table.module "INCLUDE" >
+<![%xhtml-table.module;[
+<!ENTITY % xhtml-table.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Tables 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-table-1.mod" >
+%xhtml-table.mod;]]>
+
+<!-- Forms Module  ............................................... -->
+<!ENTITY % xhtml-form.module "INCLUDE" >
+<![%xhtml-form.module;[
+<!ENTITY % xhtml-form.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Forms 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-form-1.mod" >
+%xhtml-form.mod;]]>
+
+<!-- Legacy Markup ............................................... -->
+<!ENTITY % xhtml-legacy.module "IGNORE" >
+<![%xhtml-legacy.module;[
+<!ENTITY % xhtml-legacy.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Legacy Markup 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-legacy-1.mod" >
+%xhtml-legacy.mod;]]>
+
+<!-- Document Structure Module (required)  ....................... -->
+<!ENTITY % xhtml-struct.module "INCLUDE" >
+<![%xhtml-struct.module;[
+<!ENTITY % xhtml-struct.mod
+     PUBLIC "-//W3C//ELEMENTS XHTML Document Structure 1.0//EN"
+            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-struct-1.mod" >
+%xhtml-struct.mod;]]>
+
+<!-- end of XHTML 1.1 DTD  ................................................. -->
+<!-- ....................................................................... -->

tests/wpt/web-platform-tests/css/tools/w3ctestlib/templates/chapter-toc.tmpl

@@ -0,0 +1,46 @@
+[%# variables in this template
+  indexext    [string, e.g. '.html']
+  suitetitle  [string]
+  specroot    [uri string]
+  formatdir   [dir name string]
+  chapters    [list of struct]
+    .numstr     [string, e.g. '6.1.13']
+    .title      [string]
+    .testcount  [number]
+%]
+[% IF isXML %]
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+[% ELSE %]
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
+<html>
+[% END %]
+ <head>
+  <title>[% suitetitle %]</title>
+  <style type="text/css">
+    @import "http://www.w3.org/StyleSheets/TR/base.css";
+    @import "[% IF formatdir %]../[% END %]indices.css";
+  </style>
+ </head>
+<body>
+  <h1>[% suitetitle %] By Chapter</h1>
+
+  <p>This index contains both
+    <a href="http://wiki.csswg.org/test/selftest">self-describing tests</a>
+    and reftests.
+    A separate <a href="reftest-toc[% indexext%]">alphabetical reftest index</a>
+    is provided for tests in <a href="http://wiki.csswg.org/test/reftest">reftest
+    format</a> along with the <a href="reftest.list">reftest manifest</a>.</p>
+
+  <table>
+[% FOREACH chapter IN chapters %]
+    <tbody id="s[% chapter.numstr %]">
+      <tr><th><a href="chapter-[% chapter.numstr %][% indexext %]">
+        [% (chapter.numstr.match('^\d')) ? 'Chapter' : 'Appendix' +%] [%+ chapter.numstr +%] - 
+        [%+ chapter.title +%]</a></th>
+      <td>([% chapter.testcount +%] Tests)</td></tr>
+    </tbody>
+[% END %]
+  </table>
+</body>
+</html>

tests/wpt/web-platform-tests/css/tools/w3ctestlib/templates/implementation-report-TEMPLATE.data.tmpl

@@ -0,0 +1,21 @@
+# UA version OS version
+# UA string (if applicable)
+# http://test.csswg.org/suites/[% suite %]/DATESTAMP/
+# See http://wiki.csswg.org/test/implementation-report for instructions
+testname	revision	result	comment
+[% FOREACH test IN tests.sort(name) %]
+[% FOREACH format IN formats %]
+[% IF formatInfo.$format.report %]
+[% SET skipFormat = 0 %]
+[% FOREACH flag IN test.flags %]
+  [% SET skipFormat = 1 IF flag == formatInfo.$format.filter %]
+[% END %]
+[% UNLESS skipFormat +%]
+[%+ formatInfo.$format.path +%]/[% test.name +%].[% formatInfo.$format.ext +%]	[%+ test.revision +%]	?
+[% END %]
+[% END %]
+[% END %]
+[% END %]
+[% FOREACH test IN addtests.sort() +%]
+[%+ test +%]	[%+ test.revision +%]	?	
+[% END %]

tests/wpt/web-platform-tests/css/tools/w3ctestlib/templates/index.content.tmpl

@@ -0,0 +1,190 @@
+[% PROCESS "suitedata.tmpl" %]
+[% IF official %]
+  <h1>[% suites.$suite.title %]</h1>
+[% ELSE %]
+  <h1>Unofficial [% suites.$suite.title %]</h1>
+[% END %]
+  <dt>Test Coordinator:</dt>
+   	<dd>[% suites.$suite.owner %]</dd>
+  
+  <p>This is a <strong>[% statusNames.${suites.$suite.status}.title or "ERROR: $suite" %]</strong>
+     version of the [% suites.$suite.title %].</p>
+
+[% IF suites.$suite.harness != '' %]
+   <p>You can provide test data or review the testing results for this test suite:</p>
+   <dt><a href="http://test.csswg.org/harness/suite/[% suites.$suite.harness %]">Enter Data</a></dt>
+   <dt><a href="http://test.csswg.org/harness/review/[% suites.$suite.harness %]">Review Results</a></dt>
+[% END %]
+       
+
+[% IF devel %]
+ <p>This build exists to aid in test suite development and contains unreviewed
+   tests. <strong>The pass/fail results of these tests are not reliable
+   indications of conformance.</strong>
+[% ELSE %]
+ <p>Some tests in the test suite may contain errors.
+[% END %]
+   Please check the latest version of the
+   <a href="[% suites.$suite.specroot %]">[% suites.$suite.spec %] specification</a>
+   <strong>and its errata</strong>
+   before assuming a failure is due to an implementation bug and
+   not a test suite bug.</p>
+
+[% UNLESS official %]
+ <p>You can find the <a href="[% suites.$suite.officialUrl %]">official
+  build</a> of the [% suites.$suite.title %] on W3C's web site.</p>
+[% END %]
+
+  <p>[% IF suites.$suite.status != 'fin' && suites.$suite.status != 'rc' %]
+  In time we hope to correct all errors and extend this test suite to
+  cover all of [% suites.$suite.spec %]. Your help is welcome in this effort.
+  [% END %]
+  The appropriate mailing list for submitting tests and bug reports is
+  <a href="http://lists.w3.org/Archives/Public/public-css-testsuite/">public-css-testsuite@w3.org</a>.
+  More information on the contribution process and test guidelines is
+  available on the <a href="http://wiki.csswg.org/test">wiki
+  page</a>.</p>
+
+ <p>Tests are currently available in these formats:</p>
+
+ <dl>
+[% FOREACH format IN formats %]
+  [% IF format == 'html4' %]
+   <dt><a href="html4/toc.htm">HTML 4.01</a></dt>
+     <dd>HTML 4.01 tests sent as <code>text/html</code></dd>
+  [% END %]
+  [% IF format == 'html5' %]
+   <dt><a href="html/toc.htm">HTML 5</a></dt>
+     <dd>HTML 5 tests sent as <code>text/html</code></dd>
+  [% END %]
+  [% IF format == 'xhtml1' %]
+   <dt><a href="xhtml1/toc.xht">XHTML 1.1</a></dt>
+     <dd>XHTML 1.1 tests sent as <code>application/xhtml+xml</code></dd>
+  [% END %]
+  [% IF format == 'xhtml1print' %]
+   <dt><a href="xhtml1print/toc.xht">XHTML 1.1 for Printers</a></dt>
+     <dd>XHTML 1.1 tests with all images converted from PNG to JPEG
+       and formatted with headers and footers to ease testing of
+       embedded printer software. This is not a canonical format,
+       and some tests may fail due to the format conversion that
+       would otherwise pass in the above XHTML 1.1 format.</dd>
+  </dl>
+  [% END %]
+[% END %]
+
+[% IF suite == 'css2.1' %]
+  <p>Additional tests, that do not fit in any of those formats,
+    are located separately:</p>
+
+  <dl>
+    <dt><a href="other/">Other Formats</a></dt>
+      <dd>Tests that do not fit in the above formats because they
+        test a combination of CSS and a particular document language's
+        features and/or error recovery.</dd>
+  </dl>
+[% END %]
+  
+  <p>Unless the test instructions explicitly indicate otherwise,
+    any occurrence of red in a test indicates test failure.</p>
+
+[% IF suite == 'css2.1' %]
+  <p>Note that <em>many</em> of the tests require the
+   <a href="http://www.w3.org/Style/CSS/Test/Fonts/Ahem/">Ahem font to be installed</a>.
+   These tests are marked with the 'ahem' flag in their metadata.
+   Without the Ahem font installed, these tests are of no value.</p>
+  <p>Some of the font-related tests also require
+   <a href="http://www.w3.org/Style/CSS/Test/Fonts/">special fonts</a>.
+   These tests are marked with the 'font' flag in their metadata.</p>
+
+[% END %]
+<h2 id="implement">Implementation Reports</h2>
+  <p>An <a href="implementation-report-TEMPLATE.data">implementation report template</a>
+    is available to help with creating implementation reports. See also the
+    <a href="http://lists.w3.org/Archives/Public/public-css-testsuite/2010Aug/0020.html">explanation</a>
+    of its format.</p>
+
+<h2 id="common">Common Assumptions</h2>
+
+  <p>Most of the test suite makes the following assumptions:</p>
+  <ul>
+    <li>The X/HTML <code>div</code> element is assigned <code>display: block;</code>
+      and no other property declaration.</li>
+    <li>The X/HTML <code>span</code> element is assigned <code>display: inline;</code>
+      and no other property declaration.</li>
+    <li>The X/HTML <code>p</code> element is assigned <code>display: block;</code></li>
+    <li>The X/HTML <code>li</code> element is assigned <code>display: list-item;</code></li>
+    <li>The X/HTML table elements <code>table</code>, <code>tbody</code>,
+      <code>tr</code>, and <code>td</code> are assigned the <code>display</code>
+      values <code>table</code>, <code>table-row-group</code>,
+      <code>table-row</code>, and <code>table-cell</code>, respectively.</li>
+    <li>The device can display the sixteen color values associated with the color
+      keywords <code>black</code>, <code>white</code>, <code>gray</code>,
+      <code>silver</code>, <code>red</code>, <code>green</code>, <code>blue</code>,
+      <code>purple</code>, <code>yellow</code>, <code>orange</code>, <code>teal</code>,
+      <code>fuchsia</code>, <code>maroon</code>, <code>navy</code>, <code>aqua</code>,
+      and <code>lime</code> as distinct colors.</li>
+    <li>The UA is set to print background colors and, if it supports graphics,
+      background images.</li>
+    <li>The UA implements reasonable page-breaking behavior; e.g., it is assumed
+      that UAs will not break at every opportunity, but only near the end of
+      a page unless a page break is forced.</li>
+    <li>The UA implements reasonable line-breaking behavior; e.g., it is assumed
+      that spaces between alphanumeric characters provide line breaking
+      opportunities and that UAs will not break at every opportunity, but only
+      near the end of a line unless a line break is forced.</li>
+  </ul>
+
+<h2 id="uncommon">Uncommon Assumptions</h2>
+
+  <p>In addition, some of the tests make one or more of the following
+   assumptions:</p>
+
+  <ul>
+    <li>The device is a full-color device.</li>
+    <li>The device has a viewport width of at least 640px (approx).</li>
+    <li>The resolution of the device is 96 CSS pixels per inch.</li>
+    <li>The UA imposes no minimum font size.</li>
+    <li>The 'medium' font-size computes to 16px.</li>
+    <li>The initial value of 'color' is black.</li>
+    <li>The canvas background is white.</li>
+    <li>The user stylesheet is empty (except where indicated by the tests).</li>
+    <li>The device is interactive and uses scroll bars.</li>
+  </ul>
+
+  <p>The tests that need these assumptions to be true have not yet been
+  marked, but it is likely that we will add a way to identify these
+  tests in due course. Tests should avoid relying on these assumptions
+  unless necessary.</p>
+
+<h2>License</h2>
+
+[% IF official %]
+  <p>This test suite is licensed under both the
+  <a href="http://www.w3.org/Consortium/Legal/2008/04-testsuite-license">W3C
+  Test Suite License</a> and the <a href="http://www.w3.org/Consortium/Legal/2008/03-bsd-license">W3C
+  3-clause BSD License</a>. See W3C Legal's <a href="http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright">explanation
+  of the licenses</a>.</p>
+[% ELSE %]
+  <p>These tests are licensed under the <a href="LICENSE-BSD">BSD 3-clause
+  License</a>. You may modify and distribute them under those terms. Aside
+  from their titles, documentation, and location they are identical to the
+  official tests of the same date. However, only the
+  <a href="http://www.w3.org/Style/Test/[% suite %]/current/">official % suites.$suite.title %]
+  </a> may be used as the basis for CSS conformance
+  claims.</p>
+[% END %]
+
+<h2>Acknowledgements</h2>
+
+  <p>Many thanks to the following for their contributions:</p>
+  <ul>
+[%- FOREACH person = contributors.keys.sort %]
+  [% IF not person.match('^CSS1') %]
+    <li>[% person %]</li>
+  [% END %]
+[%- END %]
+  </ul>
+[% IF suite == 'css2.1' %]
+  <p>...and all the <a href="http://www.w3.org/Style/CSS/Test/CSS1/current/tsack.html">contributors
+  to the CSS1 test suite</a>.</p>
+[% END %]

tests/wpt/web-platform-tests/css/tools/w3ctestlib/templates/index.htm.tmpl

@@ -0,0 +1,20 @@
+[% PROCESS "suitedata.tmpl" %]
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
+<html lang="en">
+ <head>
+[% IF official %]
+  <title>[% suites.$suite.title %]</title>
+[% ELSE %]
+  <title>Unofficial [% suites.$suite.title %]</title>
+[% END %]
+  <style type="text/css">
+    @import "http://www.w3.org/StyleSheets/TR/base.css";
+    @import "indices.css";
+  </style>
+ </head>
+ <body>
+
+[% INCLUDE "index.content.tmpl" %]
+
+</body>
+</html>

tests/wpt/web-platform-tests/css/tools/w3ctestlib/templates/index.xht.tmpl

@@ -0,0 +1,20 @@
+[% PROCESS "suitedata.tmpl" %]
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+ <head>
+[% IF official %]
+  <title>[% suites.$suite.title %]</title>
+[% ELSE %]
+  <title>Unofficial [% suites.$suite.title %]</title>
+[% END %]
+  <style type="text/css">
+    @import "http://www.w3.org/StyleSheets/TR/base.css";
+    @import "indices.css";
+  </style>
+ </head>
+ <body>
+
+[% INCLUDE index.content.tmpl %]
+
+</body>
+</html>

tests/wpt/web-platform-tests/css/tools/w3ctestlib/templates/indices.css

@@ -0,0 +1,96 @@
+/* CSS for CSS Conformance Test Indices */
+/* Written by fantasai */
+
+/* Test Tables */
+
+  table {
+    border-collapse: collapse;
+  }
+
+  thead {
+    border-bottom: 0.2em solid;
+  }
+
+  tbody {
+    border: thin solid;
+    border-style: solid none;
+  }
+
+  tbody.ch {
+    border-top: 0.2em solid;
+  }
+  tbody.ch th {
+    font-weight: bold;
+  }
+
+  tbody th {
+    border-bottom: silver dotted thin;
+    background: #EEE;
+    color: black;
+    font-weight: normal;
+    font-style: italic;
+  }
+  tbody th :link {
+    color: gray;
+    background: transparent;
+  }
+  tbody th :visited {
+    color: #333;
+    background: transparent;
+  }
+
+  th, td {
+    padding: 0.2em;
+    text-align: left;
+    vertical-align: baseline;
+  }
+  
+  td {
+    font-size: 0.9em;
+  }
+
+  /* flags */
+  td abbr {
+    border: solid thin gray;
+    padding: 0 0.1em;
+    cursor: help;
+  }
+  td abbr:hover {
+    background: #ffa;
+    color: black;
+  }
+
+
+  tr:hover {
+    background: #F9F9F9;
+    color: navy;
+  }
+
+  th a,
+  td a {
+    text-decoration: none;
+  }
+  th a:hover,
+  td a:hover,
+  th a:focus,
+  td a:focus {
+    text-decoration: underline;
+  }
+
+  td a {
+    display: block;
+    padding-left: 2em;
+    text-indent: -1em;
+  }
+  .refs {
+    font-weight: bold;
+    font-size: larger;
+  }
+  .assert, .assert > li {
+    list-style-type: none;
+    font-style: italic;
+    color: gray;
+    margin: 0;
+    padding: 0;
+    text-indent: 0;
+  }

tests/wpt/web-platform-tests/css/tools/w3ctestlib/templates/reftest-toc.tmpl

@@ -0,0 +1,74 @@
+[%# variables in this template
+  isXML       [bool]
+  extmap      [ExtensionMap object]
+  suitetitle  [string]
+  specroot    [URI of spec]
+  formatdir   [string]
+  chaptitle   [string]
+  chapdir     [string]
+  testcount   [number]
+  sections    [list of struct]
+    .id          [string - section number or id]
+    .uri         [URI of section]
+    .tests       [list of struct]
+       .asserts    [list of strings]
+       .flags      [list of token strings]
+       .links      [list of uri strings]
+       .name       [string]
+%]
+[% PROCESS suitedata.tmpl %]
+[% IF isXML %]
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+[% formatMismatchFlag = 'HTMLonly' %]
+[% ELSE %]
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
+<html>
+[% formatMismatchFlag = 'nonHTML' %]
+[% END %]
+ <head>
+  <title>[% suitetitle %] Reftest Index</title>
+  <style type="text/css">
+    @import "http://www.w3.org/StyleSheets/TR/base.css";
+    @import "[% IF formatdir %]../[% END %]indices.css";
+  </style>
+ </head>
+
+ <body>
+
+  <h1>[% suitetitle %] Reftest Index</h1>
+  <table width="100%">
+    <col id="test-column">[% IF isXML %]</col>[% END %]
+    <col id="ref-column">[% IF isXML %]</col>[% END %]
+    <col id="flags-column">[% IF isXML %]</col>[% END %]
+    <thead>
+      <tr>
+        <th>Test</th>
+        <th>Reference</th>
+        <th>Flags</th>
+      </tr>
+    </thead>
+[% FOREACH entry IN tests.sort('name') %]
+  [% IF entry.references and not entry.flags.contains(formatMismatchFlag) %]
+    <tbody id="[% entry.name %]" class="[% entry.flags.join(' ') %]">
+    [% FOREACH refList IN entry.references %]
+      [% IF loop.first %]
+      <tr>
+        <td rowspan="[% loop.size %]" title="[% entry.title | collapse | html %]">
+          <a href="[% extmap.translate(entry.file) %]">[% entry.name %]</a></td>
+        <td>[% FOREACH ref IN refList %]<a href="[% extmap.translate(ref.relpath) %]">[% refCompMap.${ref.type} %]</a> [% END %]</td>
+        <td rowspan="[% entry.references.size %]">[% FOREACH flag IN entry.flags %][% IF flag != 'nonHTML' and flag != 'HTMLonly' %]<abbr class="[% flag %]" title="[% flagInfo.$flag.title %]">[% flagInfo.$flag.abbr %]</abbr>[% END %][% END %]</td>
+      </tr>
+      [% ELSE %]
+      <tr>
+        <td><a href="[% extmap.translate(ref.relpath) %]">[% refCompMap.${ref.type} %]</a></td>
+      </tr>
+      [% END %]
+    [% END %]
+    </tbody>
+  [% END %]
+[% END %]
+  </table>
+
+ </body>
+</html>

tests/wpt/web-platform-tests/css/tools/w3ctestlib/templates/reftest.tmpl

@@ -0,0 +1,7 @@
+[% FOR entry IN tests.sort('name') %]
+[% IF not entry.flags.contains(formatMismatchFlag) %]
+[% FOREACH refList IN entry.references %]
+[%+ extmap.translate(entry.file) %] [% FOREACH ref IN refList %] [%+ ref.type %] [%+ extmap.translate(ref.relpath) %][% END %]
+[% END %]
+[% END %]
+[% END %]

tests/wpt/web-platform-tests/css/tools/w3ctestlib/templates/suitedata.tmpl

@@ -0,0 +1,23 @@
+[% refCompMap =
+    { '==' => '=',
+      '!=' => '≠'
+    }
+%]
+[%  statusNames = {
+      'dev' => {
+        'title' => 'Development',
+        'link'  => 'http://www.w3.org/Style/CSS/Test/#phase-pa' },
+      'alpha' => {
+        'title' => 'Alpha',
+        'link'  => 'http://www.w3.org/Style/CSS/Test/#phase-alpha' },
+      'beta' => {
+        'title' => 'Beta',
+        'link'  => 'http://www.w3.org/Style/CSS/Test/#phase-beta' },
+      'rc' => {
+        'title' => 'Release Candidate',
+        'link'  => 'http://www.w3.org/Style/CSS/Test/#phase-rc' },
+      'final' => {
+        'title' => 'Final',
+        'link'  => 'http://www.w3.org/Style/CSS/Test/#phase-fin' },
+    }
+%]

tests/wpt/web-platform-tests/css/tools/w3ctestlib/templates/test-toc.tmpl

@@ -0,0 +1,97 @@
+[%# variables in this template
+  isXML       [bool]
+  extmap      [ExtensionMap object]
+  suitetitle  [string]
+  specroot    [URI of spec]
+  formatdir   [string]
+  chaptitle   [string]
+  chapdir     [string]
+  testcount   [number]
+  sections    [list of struct]
+    .id          [string - section number or id]
+    .uri         [URI of section]
+    .tests       [list of struct]
+       .asserts    [list of strings]
+       .flags      [list of token strings]
+       .links      [list of uri strings]
+       .name       [string]
+%]
+[% PROCESS suitedata.tmpl %]
+[% IF isXML %]
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+[% formatMismatchFlag = 'HTMLonly' %]
+[% ELSE %]
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
+<html>
+[% formatMismatchFlag = 'nonHTML' %]
+[% END %]
+ <head>
+  <title>[% chaptertitle %] - [% suitetitle %]</title>
+  <style type="text/css">
+    @import "http://www.w3.org/StyleSheets/TR/base.css";
+    @import "[% IF formatdir %]../[% END %]indices.css";
+  </style>
+ </head>
+
+ <body>
+
+  <h1>[% suitetitle %]</h1>
+[% IF chaptertitle %]
+  <h2>[% chaptertitle %] ([% testcount %] tests)</h2>
+[% END %]
+  <table width="100%">
+    <col id="test-column">[% IF isXML %]</col>[% END %]
+    <col id="refs-column">[% IF isXML %]</col>[% END %]
+    <col id="flags-column">[% IF isXML %]</col>[% END %]
+    <col id="info-column">[% IF isXML %]</col>[% END %]
+    <thead>
+      <tr>
+        <th>Test</th>
+        <th><abbr title="Rendering References">Refs</abbr></th>
+        <th>Flags</th>
+        <th>Info</th>
+      </tr>
+    </thead>
+[% FOREACH section IN sections %]
+    <tbody id="s[% section.numstr %]">
+      [% IF section.title %]
+      <tr><th colspan="4" scope="rowgroup">
+        <a href="#s[% section.numstr %]">+</a>
+        <a href="[% section.uri %]">[% section.numstr +%] [%+ section.title %]</a></th></tr>
+      [% END %]
+      <!-- [% section.tests.size %] tests -->
+  [% FOREACH entry IN section.tests.sort('name') %]
+    [% FOREACH flag IN entry.flags %]
+      [% SET skip = 1 IF flag == formatMismatchFlag %]
+    [% END %]
+    [% UNLESS skip %]
+      [% primary = (entry.links.0 == section.uri) or (entry.links.0 == section.uri.replace(specroot, draftroot)) %]
+      <tr id="[% entry.name %]-[% section.numstr %]" class="
+              [% 'primary' IF primary %]
+              [% ' ' IF primary and entry.flags.size > 0 %]
+              [% entry.flags.join(' ') %]">
+        <td>[% '<strong>' IF primary %]
+            <a href="[% extmap.translate(entry.file) %]">[% entry.name%]</a>
+            [% '</strong>' IF primary %]</td>
+        <td>[% FOREACH refList IN entry.references %][% FOREACH ref IN refList %]<a href="[% extmap.translate(ref.relpath) %]">[% refCompMap.${ref.type} %]</a> [%+ END %][%+ END %]</td>
+        <td>[% FOREACH flag IN entry.flags %][% IF flag != 'nonHTML' and flag != 'HTMLonly' %]<abbr class="[% flag %]" title="[% flagInfo.$flag.title %]">[% flagInfo.$flag.abbr %]</abbr>[% END %][% END %]</td>
+        <td>[% entry.title | collapse | html %]
+      [% IF entry.asserts.size > 0 %]
+          <ul class="assert">
+        [% FOREACH assertion IN entry.asserts %]
+            <li>[% assertion | collapse | html %]</li>
+        [% END %]
+          </ul>
+      [% END %]
+        </td>
+      </tr>
+    [% END %]
+    [% skip = 0 %]
+  [% END %]
+    </tbody>
+[% END %]
+  </table>
+
+ </body>
+</html>

tests/wpt/web-platform-tests/css/tools/w3ctestlib/templates/testinfo.data.tmpl

@@ -0,0 +1,16 @@
+id	references	title	flags	links	revision	credits	assertion
+[% FOREACH test IN tests.sort('name') %]
+[%+ test.file.replace('\.[a-z]+$', '') +%]	
+[%- FOREACH refList IN test.references -%][%- FOREACH ref IN refList -%]
+[%- '!' IF ref.type == '!=' %][% extmap.translate(ref.relpath) %][% ',' IF not loop.last() -%]
+[%- END +%][% ';' IF not loop.last() -%]
+[%- END +%]	
+[%- test.title FILTER collapse +%]	
+[%- test.flags.join(',') +%]	
+[%- test.links.join(',') +%]	
+[%- test.revision +%]	
+[%- FOREACH credit IN test.credits -%]
+`[% credit.0 %]`<[% credit.1 %]>[% ',' IF not loop.last() -%]
+[%- END +%]	
+[%- test.asserts.join(' ') FILTER collapse +%]
+[% END %]