kwargs     = {}

tools/webdriver/webdriver/transport.py:91: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

fp = <http.client.HTTPResponse object at 0x7f44a7d70f70>
cls = <class 'json.decoder.JSONDecoder'>, object_hook = None, parse_float = None
parse_int = None, parse_constant = None, object_pairs_hook = None, kw = {}

    def load(fp, *, cls=None, object_hook=None, parse_float=None,
            parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
        """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
        a JSON document) to a Python object.
    
        ``object_hook`` is an optional function that will be called with the
        result of any object literal decode (a ``dict``). The return value of
        ``object_hook`` will be used instead of the ``dict``. This feature
        can be used to implement custom decoders (e.g. JSON-RPC class hinting).
    
        ``object_pairs_hook`` is an optional function that will be called with the
        result of any object literal decoded with an ordered list of pairs.  The
        return value of ``object_pairs_hook`` will be used instead of the ``dict``.
        This feature can be used to implement custom decoders.  If ``object_hook``
        is also defined, the ``object_pairs_hook`` takes priority.
    
        To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
        kwarg; otherwise ``JSONDecoder`` is used.
        """
>       return loads(fp.read(),
            cls=cls, object_hook=object_hook,
            parse_float=parse_float, parse_int=parse_int,
            parse_constant=parse_constant, object_pairs_hook=object_pairs_hook, **kw)

cls        = <class 'json.decoder.JSONDecoder'>
fp         = <http.client.HTTPResponse object at 0x7f44a7d70f70>
kw         = {}
object_hook = None
object_pairs_hook = None
parse_constant = None
parse_float = None
parse_int  = None

/usr/lib/python3.8/json/__init__.py:293: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

s = 'HTTP method not allowed', cls = <class 'json.decoder.JSONDecoder'>
object_hook = None, parse_float = None, parse_int = None, parse_constant = None
object_pairs_hook = None, kw = {}

    def loads(s, *, cls=None, object_hook=None, parse_float=None,
            parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
        """Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance
        containing a JSON document) to a Python object.
    
        ``object_hook`` is an optional function that will be called with the
        result of any object literal decode (a ``dict``). The return value of
        ``object_hook`` will be used instead of the ``dict``. This feature
        can be used to implement custom decoders (e.g. JSON-RPC class hinting).
    
        ``object_pairs_hook`` is an optional function that will be called with the
        result of any object literal decoded with an ordered list of pairs.  The
        return value of ``object_pairs_hook`` will be used instead of the ``dict``.
        This feature can be used to implement custom decoders.  If ``object_hook``
        is also defined, the ``object_pairs_hook`` takes priority.
    
        ``parse_float``, if specified, will be called with the string
        of every JSON float to be decoded. By default this is equivalent to
        float(num_str). This can be used to use another datatype or parser
        for JSON floats (e.g. decimal.Decimal).
    
        ``parse_int``, if specified, will be called with the string
        of every JSON int to be decoded. By default this is equivalent to
        int(num_str). This can be used to use another datatype or parser
        for JSON integers (e.g. float).
    
        ``parse_constant``, if specified, will be called with one of the
        following strings: -Infinity, Infinity, NaN.
        This can be used to raise an exception if invalid JSON numbers
        are encountered.
    
        To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
        kwarg; otherwise ``JSONDecoder`` is used.
    
        The ``encoding`` argument is ignored and deprecated since Python 3.1.
        """
        if isinstance(s, str):
            if s.startswith('\ufeff'):
                raise JSONDecodeError("Unexpected UTF-8 BOM (decode using utf-8-sig)",
                                      s, 0)
        else:
            if not isinstance(s, (bytes, bytearray)):
                raise TypeError(f'the JSON object must be str, bytes or bytearray, '
                                f'not {s.__class__.__name__}')
            s = s.decode(detect_encoding(s), 'surrogatepass')
    
        if "encoding" in kw:
            import warnings
            warnings.warn(
                "'encoding' is ignored and deprecated. It will be removed in Python 3.9",
                DeprecationWarning,
                stacklevel=2
            )
            del kw['encoding']
    
        if (cls is None and object_hook is None and
                parse_int is None and parse_float is None and
                parse_constant is None and object_pairs_hook is None and not kw):
            return _default_decoder.decode(s)
        if cls is None:
            cls = JSONDecoder
        if object_hook is not None:
            kw['object_hook'] = object_hook
        if object_pairs_hook is not None:
            kw['object_pairs_hook'] = object_pairs_hook
        if parse_float is not None:
            kw['parse_float'] = parse_float
        if parse_int is not None:
            kw['parse_int'] = parse_int
        if parse_constant is not None:
            kw['parse_constant'] = parse_constant
>       return cls(**kw).decode(s)

cls        = <class 'json.decoder.JSONDecoder'>
kw         = {}
object_hook = None
object_pairs_hook = None
parse_constant = None
parse_float = None
parse_int  = None
s          = 'HTTP method not allowed'

/usr/lib/python3.8/json/__init__.py:370: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <json.decoder.JSONDecoder object at 0x7f44a7c5c6d0>
s = 'HTTP method not allowed'
_w = <built-in method match of re.Pattern object at 0x7f44c03adcf0>

    def decode(self, s, _w=WHITESPACE.match):
        """Return the Python representation of ``s`` (a ``str`` instance
        containing a JSON document).
    
        """
>       obj, end = self.raw_decode(s, idx=_w(s, 0).end())

_w         = <built-in method match of re.Pattern object at 0x7f44c03adcf0>
s          = 'HTTP method not allowed'
self       = <json.decoder.JSONDecoder object at 0x7f44a7c5c6d0>

/usr/lib/python3.8/json/decoder.py:337: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <json.decoder.JSONDecoder object at 0x7f44a7c5c6d0>
s = 'HTTP method not allowed', idx = 0

    def raw_decode(self, s, idx=0):
        """Decode a JSON document from ``s`` (a ``str`` beginning with
        a JSON document) and return a 2-tuple of the Python
        representation and the index in ``s`` where the document ended.
    
        This can be used to decode a JSON document from a string that may
        have extraneous data at the end.
    
        """
        try:
            obj, end = self.scan_once(s, idx)
        except StopIteration as err:
>           raise JSONDecodeError("Expecting value", s, err.value) from None
E           json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)

idx        = 0
s          = 'HTTP method not allowed'
self       = <json.decoder.JSONDecoder object at 0x7f44a7c5c6d0>

/usr/lib/python3.8/json/decoder.py:355: JSONDecodeError

During handling of the above exception, another exception occurred:

session = <Session 4518a10a-9cd7-49e5-812c-77043eaefbfe>
url = <function url.<locals>.url at 0x7f44a7c67a60>, state = 'prompt'

    @pytest.mark.parametrize("state", ["granted", "denied", "prompt"])
    def test_set_to_state(session, url, state):
        session.url = url("/common/blank.html", protocol="https")
        parameters = {"descriptor": {"name": "geolocation"}, "state": state}
>       response = session.transport.send(
            "POST", "/session/{session_id}/permissions".format(**vars(session)),
            parameters)

parameters = {'descriptor': {'name': 'geolocation'}, 'state': 'prompt'}
session    = <Session 4518a10a-9cd7-49e5-812c-77043eaefbfe>
state      = 'prompt'
url        = <function url.<locals>.url at 0x7f44a7c67a60>

webdriver/tests/classic/permissions/set.py:97: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tools/webdriver/webdriver/transport.py:236: in send
    return Response.from_http(response, decoder=decoder, **codec_kwargs)
        body       = {'descriptor': {'name': 'geolocation'}, 'state': 'prompt'}
        codec_kwargs = {}
        decoder    = <class 'json.decoder.JSONDecoder'>
        encoder    = <class 'json.encoder.JSONEncoder'>
        headers    = None
        method     = 'POST'
        payload    = '{"descriptor": {"name": "geolocation"}, "state": "prompt"}'
        response   = <http.client.HTTPResponse object at 0x7f44a7d70f70>
        self       = <webdriver.transport.HTTPWireProtocol object at 0x7f44a7d5aa60>
        timeout    = None
        uri        = '/session/4518a10a-9cd7-49e5-812c-77043eaefbfe/permissions'
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

cls = <class 'webdriver.transport.Response'>
http_response = <http.client.HTTPResponse object at 0x7f44a7d70f70>
decoder = <class 'json.decoder.JSONDecoder'>, kwargs = {}

    @classmethod
    def from_http(cls, http_response, decoder=json.JSONDecoder, **kwargs):
        try:
            body = json.load(http_response, cls=decoder, **kwargs)
            headers = ResponseHeaders(http_response.getheaders())
        except ValueError:
>           raise ValueError("Failed to decode response body as JSON:\n" +
                             http_response.read())
E           TypeError: can only concatenate str (not "bytes") to str

cls        = <class 'webdriver.transport.Response'>
decoder    = <class 'json.decoder.JSONDecoder'>
http_response = <http.client.HTTPResponse object at 0x7f44a7d70f70>
kwargs     = {}

tools/webdriver/webdriver/transport.py:94: TypeError
50:58.48 INFO Got 49 unexpected results, with 0 unexpected passes
50:58.57 wptserve INFO Stopped http server on 127.0.0.1:9000
50:58.58 wptserve INFO Stopped http server on 127.0.0.1:8002
50:58.58 wptserve INFO Stopped http server on 127.0.0.1:8444
50:58.59 wptserve INFO Close on: (<AddressFamily.AF_INET: 2>, <SocketKind.SOCK_STREAM: 1>, 6, '', ('127.0.0.1', 8889))
50:58.59 wptserve INFO Stopped http server on 127.0.0.1:8445
50:58.59 wptserve INFO Stopped http server on 127.0.0.1:8003
50:58.59 wptserve INFO Stopped http server on 127.0.0.1:8446
50:58.59 wptserve INFO Close on: (<AddressFamily.AF_INET: 2>, <SocketKind.SOCK_STREAM: 1>, 6, '', ('127.0.0.1', 8888))
50:58.61 wptserve INFO Stopped http server on 127.0.0.1:8001
50:58.80 wptserve INFO Stopped http server on 127.0.0.1:8443
50:58.95 wptserve INFO Stopped http server on 127.0.0.1:8000
50:58.98 INFO Removed font: Ahem.ttf
50:59.00 INFO Closing logging queue
50:59.00 INFO queue closed
50:59.00 INFO Tolerating 49 unexpected results
[taskcluster 2024-01-15 03:14:22.249Z] === Task Finished ===
[taskcluster 2024-01-15 03:14:24.061Z] Successful task run with exit code: 0 completed in 3183.985 seconds