How to use the requests3.structures.HTTPHeaderDict function in requests3

def test_copy(self):
        hd = HTTPHeaderDict(self.u3dict)
        hd2 = hd.copy()
        assert hd is not hd2
        assert hd == hd2

def test_repr(self):
        hd = HTTPHeaderDict()
        assert repr(hd) == '{}'
        hd.add('type', 'xml')
        assert repr(hd) == "{'type': 'xml'}"
        hd.add('type', 'html')
        assert repr(hd) == "{'type': ('xml', 'html')}"
        # We can't guarantee order once we have more than one key.
        hd.add('Accept', 'text/html')
        assert repr(hd) in [
            "{'type': ('xml', 'html'), 'Accept': 'text/html'}",
            "{'Accept': 'text/html', 'type': ('xml', 'html')}",
        ]
        assert str(hd) == repr(hd)

def test_equality(self):
        hd = HTTPHeaderDict(self.u3dict)
        assert hd == self.u3dict
        assert hd == HTTPHeaderDict(hd)
        # Test that we still work even if we are comparing to a
        # CaseInsensitiveDict instance.
        cid = CaseInsensitiveDict(hd)
        assert hd == cid
        assert cid == hd

self.kvs = [
            ('animal', 'chicken'),
            ('AnimaL', 'Cow'),
            ('CAKE', 'Cheese!'),
            ('Sauce', 'Bread'),
            ('Sauce', 'Cherry, or Plum Tomato'),
        ]
        # HTTPHeaderDict from urllib3.
        self.u3dict = ud = U3HeaderDict()
        [ud.add(*tpl) for tpl in self.kvs]
        # Regular dictionary.
        self.ddict = dict(self.kvs)
        self.ddict['Sauce'] = ['Bread!', 'Cherry, or Plum Tomato']
        # Used by test_extend. All of these "extra" values are mostly
        # equivalent to each other.
        self.extra_hd = hd2 = HTTPHeaderDict(ANIMAL=['Dog', 'elephant'])
        hd2['cake'] = 'Babka'
        hd2.setlist('sound', ['quiet', 'LOUD'])
        hd2['CUTLERY'] = 'fork'
        self.extra_tuple_pairs = tuple_pairs = [
            ('ANIMAL', 'Dog'),
            ('Animal', 'elephant'),
            ('cake', ['Babka']),
            ('sound', 'quiet'),
            ('sound', 'LOUD'),
            ('CUTLERY', 'fork'),
        ]
        self.extra_simple_dict = dict(tuple_pairs)
        self.extra_simple_dict['sound'] = ('quiet', 'LOUD')
        self.extra_u3 = U3HeaderDict()
        for k, v in tuple_pairs:
            if isinstance(v, (tuple, list)):

def test_extend(self, attr, as_arg, animal_arg_is_ordered):
        item = getattr(self, attr)
        # Call extend with the associated values - we should see all of the
        # merged data in the HTTPHeaderDict instance.
        extras = {'cutlery': 'knife'}
        hd = HTTPHeaderDict(self.kvs)
        if as_arg:
            hd.extend(item, **extras)
        else:
            hd.extend(extras, **item)
        # Test all the stored values are what we expect.
        mget = hd.getlist
        # Depending on the item we merged in, we might be able to make
        # assumptions what the overall order of the structure is.
        animal_seq = mget('animal')
        if animal_arg_is_ordered:
            assert animal_seq == ['chicken', 'Cow', 'Dog', 'elephant']
        else:
            # The existing order in HTTPHeadersDict of the first two values
            # should be preserved - no guarantees in which order the other
            # two values are added.
            assert animal_seq in [

def test_lower_items(self):
        hd = HTTPHeaderDict(self.kvs, cutlery='fork')
        assert list(hd.lower_items()) == [
            ('animal', 'chicken, Cow'),
            ('cake', 'Cheese!'),
            ('sauce', 'Bread, Cherry, or Plum Tomato'),
            ('cutlery', 'fork'),
        ]

def test_equality(self):
        hd = HTTPHeaderDict(self.u3dict)
        assert hd == self.u3dict
        assert hd == HTTPHeaderDict(hd)
        # Test that we still work even if we are comparing to a
        # CaseInsensitiveDict instance.
        cid = CaseInsensitiveDict(hd)
        assert hd == cid
        assert cid == hd

async def build_response(self, req, resp):
        """Builds a :class:`Response ` object from a urllib3
        response. This should not be called from user code, and is only exposed
        for use when subclassing the
        :class:`HTTPAdapter `

        :param req: The :class:`PreparedRequest ` used to generate the response.
        :param resp: The urllib3 response object.
        :rtype: requests.Response
        """
        response = AsyncResponse()
        # Fallback to None if there's no status_code, for whatever reason.
        response.status_code = getattr(resp, 'status', None)
        # Make headers case-insensitive.
        response.headers = HTTPHeaderDict(getattr(resp, 'headers', {}))
        # Set encoding.
        response.encoding = get_encoding_from_headers(response.headers)
        response.raw = resp
        response.reason = response.raw.reason
        if isinstance(req.url, bytes):
            response.url = req.url.decode('utf-8')
        else:
            response.url = req.url
        # Add new cookies from the server.
        extract_cookies_to_jar(response.cookies, req, resp)
        # Give the Response some context.
        response.request = req
        response.connection = self
        return response

def build_response(self, req, resp):
        """Builds a :class:`Response ` object from a urllib3
        response. This should not be called from user code, and is only exposed
        for use when subclassing the
        :class:`HTTPAdapter `

        :param req: The :class:`PreparedRequest ` used to generate the response.
        :param resp: The urllib3 response object.
        :rtype: requests.Response
        """
        response = Response()
        # Fallback to None if there's no status_code, for whatever reason.
        response.status_code = getattr(resp, 'status', None)
        # Make headers case-insensitive.
        response.headers = HTTPHeaderDict(getattr(resp, 'headers', {}))
        # Set encoding.
        response.encoding = get_encoding_from_headers(response.headers)
        response.raw = resp
        response.reason = response.raw.reason
        if isinstance(req.url, bytes):
            response.url = req.url.decode('utf-8')
        else:
            response.url = req.url
        # Add new cookies from the server.
        extract_cookies_to_jar(response.cookies, req, resp)
        # Give the Response some context.
        response.request = req
        response.connection = self
        return response