def main(reactor):
    print 'List of tuples'
    resp = yield treq.get('http://httpbin.org/get',
                          params=[('foo', 'bar'), ('baz', 'bax')])
    content = yield treq.content(resp)
    print content

    print 'Single value dictionary'
    resp = yield treq.get('http://httpbin.org/get',
                          params={'foo': 'bar', 'baz': 'bax'})
    content = yield treq.content(resp)
    print content

    print 'Multi value dictionary'
    resp = yield treq.get('http://httpbin.org/get',
                          params={'foo': ['bar', 'baz', 'bax']})
    content = yield treq.content(resp)
    print content

    print 'Mixed value dictionary'
    resp = yield treq.get('http://httpbin.org/get',
                          params={'foo': ['bar', 'baz'], 'bax': 'quux'})
    content = yield treq.content(resp)
    print content

    print 'Preserved query parameters'
    resp = yield treq.get('http://httpbin.org/get?foo=bar',
                          params={'baz': 'bax'})
    content = yield treq.content(resp)
    print content

 def login(self, email, password, accountType = ACCOUNT_TYPE_HOSTED_OR_GOOGLE):
     params = {"Email": email, "Passwd": password, "service": self.SERVICE,
               "accountType": accountType, "has_permission": "1",
               "source": "android", "androidId": self.androidId,
               "app": "com.android.vending", "sdk_version": "16" }
     resp = yield treq.post(self.URL_LOGIN, params)
     if resp.code == http.OK:
         data = yield treq.content(resp)
         data = data.split()
         params = {}
         for d in data:
             k, v = d.split("=")
             params[k.strip()] = v.strip()
         if "Auth" in params:
             self.setAuthSubToken(params["Auth"])
             self.loggedIn = True
         else:
             raise LoginError("Auth token not found.")
     else:
         if resp.code == http.FORBIDDEN:
             data = yield treq.content(resp)
             params = {}
             for d in data.split('\n'):
                 d = d.strip()
                 if d:
                     k, v = d.split("=", 1)
                     params[k.strip()] = v.strip()
             if "error" in params:
                 raise LoginError(params["error"])
             else:
                 raise LoginError("Login failed.")
         else:
             data = yield treq.content(resp)
             raise LoginError("Login failed: error %d <%s>" % (resp.code, data.rstrip(),))

    def test_content_multiple_waiters(self):
        d1 = content(self.response)
        d2 = content(self.response)

        self.protocol.dataReceived('foo')
        self.protocol.connectionLost(Failure(ResponseDone()))

        self.assertEqual(self.successResultOf(d1), 'foo')
        self.assertEqual(self.successResultOf(d2), 'foo')

        self.assertNotIdentical(d1, d2)

def handleArchivePage(response):
        global CURRENTIP
	log.msg( "Archive page code is %s" % response.code)
	if response.code ==403:
		log.msg("Oh oh - looks like we're in the doghouse")
		CURRENTIP=next(IPADDRS)
		log.msg("Switching IP to %s" % str(CURRENTIP))
#		raise DoghouseException("Couldn't get archive - code was %i" % response.code)
                # treq seems to "block" if you don't fetch the content
                return treq.content(response)
#                return defer.succeed(False)
	else:
                d=treq.content(response).addCallback(parseArchiveResults)
	return d

        def make_request():
            if ssl:
                response = yield treq.post(url, agent=self.agent, **kwargs)
            else:
                response = yield treq.post(url, **kwargs)

            try:
                content = yield treq.content(response)
            except:
                log.msg("Error while reading body in HTTP response",
                        level=logger.WARN)
                self.stats_client.incr('http.requests.errors.read_body_error')
                err = RuntimeError("Error while reading body in HTTP response (Response code: %d)." % response.code)
                err.status_code = response.code
                raise err
            else:
                if response.code == 200:
                    defer.returnValue(content)
                else:
                    log.msg("Error: Bad status code in HTTP response",
                            http_response_code=response.code,
                            http_content=content,
                            level=logger.WARN)
                    self.stats_client.incr('http.requests.errors.bad_status_code.%d' % response.code)
                    err = RuntimeError('Error: Bad status code in HTTP response: %d' % response.code)
                    err.status_code = response.code
                    raise err

 def test_client_init(self):
     # FIXME: this test passes because stuff in the server is hard coded.
     #        revisit this when we're actually parsing stuff.
     syncml = self.syncml.build_request()
     response = yield self.request(syncml.build().toXml())
     body = yield content(response)
     self.assertTrue(str(constants.AUTHENTICATION_ACCEPTED) in body)

 def test_delete_server_fails_specified_number_of_times(self):
     """
     Test to verify :func: `delete_server` does not delete the server,
     and returns the given response code, the number of times specified
     in the metadata
     """
     deletefail = {"times": 1, "code": 500}
     metadata = {"delete_server_failure": json.dumps(deletefail)}
     # create server and verify it was successful
     create_server_response = self.create_server(metadata=metadata)
     self.assertEquals(create_server_response.code, 202)
     create_server_response_body = self.successResultOf(
         treq.json_content(create_server_response))
     # delete server and verify the response
     delete_server = request(self, self.root, "DELETE", self.uri + '/servers/'
                             + create_server_response_body["server"]["id"])
     delete_server_response = self.successResultOf(delete_server)
     self.assertEqual(delete_server_response.code, 500)
     # get server and verify the server was not deleted
     get_server = request(self, self.root, "GET", self.uri + '/servers/' +
                          create_server_response_body["server"]["id"])
     get_server_response = self.successResultOf(get_server)
     self.assertEquals(get_server_response.code, 200)
     # delete server again and verify the response
     delete_server = request(self, self.root, "DELETE", self.uri + '/servers/'
                             + create_server_response_body["server"]["id"])
     delete_server_response = self.successResultOf(delete_server)
     self.assertEqual(delete_server_response.code, 204)
     self.assertEqual(self.successResultOf(treq.content(delete_server_response)),
                      b"")
     # get server and verify the server was deleted this time
     get_server = request(self, self.root, "GET", self.uri + '/servers/' +
                          create_server_response_body["server"]["id"])
     get_server_response = self.successResultOf(get_server)
     self.assertEquals(get_server_response.code, 404)

 def got_result(result):
     if result.code == success_code:
         return json_content(result)
     else:
         d = content(result)
         d.addCallback(error, result.code)
         return d

    def callRemote(self, method, *args):
        scheme = "https://" if self.secure else "http://"
        netloc = self.host
        if self.port:
            netloc += ":%s" % self.port
        if self.user:
            auth = self.user
            if self.password:
                auth += ":%s" % self.password
            netloc = "%[email protected]%s" % (auth, netloc)

        url = scheme + netloc + self.path
        data = self.payloadTemplate % (
            method,
            xmlrpclib.dumps(args, allow_none=self.allowNone),
        )
        headers = {"User-Agent": "Twisted/XMLRPC", "Content-Type": "text/xml"}

        response = yield treq.post(
            url,
            data,
            headers=headers,
            timeout=self.connectTimeout,
            reactor=self._reactor,
        )
        body = yield treq.content(response)
        parsed = xmlrpclib.loads(body, use_datetime=self.useDateTime)[0][0]
        returnValue(parsed)

def print_response(r):
    print(r.code, r.phrase)
    print(r.headers)

    d = treq.content(r)
    d.addCallback(print)
    return d

    def message_scan_url(self, url_info):
        # I'm still not sure whether I like inlineCallbacks. It made
        # this easier to test, though, because of implicit maybeDeferred.

        # TODO: limit size of retrieved content. it could be huge!
        try:

            queue_entry = util.queue_entry_parse(url_info)

            print "making request..."
            response = yield treq.get(queue_entry.url)
            content = yield treq.content(response)
            print "got content"

            base_url, urls = self.scan_page(queue_entry.url, content)
            urls = self.normalize_urls(base_url, urls)

            # TODO: would be cool to put some jitter in here. probably not needed
            # though, there will be natural jitter from the requests maybe possibly
            # hopefully... there will probably still be situations that it'd be
            # wanted though
        except:
            import traceback
            traceback.print_exc()
            print "offending url:", queue_entry.url
            self.command("url_completed", queue_entry.job_id)
            return

        self.command("url_completed", queue_entry.job_id)

        for url in urls:
            # blah, QueueEntry feels like java
            qe = util.QueueEntry(queue_entry.job_id, queue_entry.level + 1, url)
            self.command("found", util.queue_entry_format(qe))

def http_status_filter(response, allowed, ex, msg=None, include_resp_text=True):
    """
    Checks the response status and determines if it is in one of the
    allowed ranges.  If not, it raises `ex()`.

    `ex` is a callable that results in an Exception to be raised,
        (typically an exception class).
    `allowed` is a sequence of (start, end) valid status ranges.
    """
    code = response.code
    in_range = False
    for start_range, end_range in allowed:
        if code >= start_range and code <= end_range:
            in_range = True
            break
    if not in_range:

        def raise_error(body, ex):
            ex_msg = []
            if msg is not None:
                ex_msg.append(msg)
            if include_resp_text:
                ex_msg.append(body)
            text = '\n'.join(ex_msg)
            if text != "":
                raise ex(text)
            else:
                raise ex()

        # Need to still deliver the response body or Twisted make
        # hang.
        d = treq.content(response)
        d.addCallback(raise_error, ex)
        return d
    return response

def do_http(method, url, **kwargs):
    response = yield treq.request(method, url, persistent=False, **kwargs)
    body = yield treq.content(response)
    # TODO: replace this with response.fail_for_status when
    # https://github.com/twisted/treq/pull/159 has landed
    if 400 <= response.code < 600:
        raise Error(response.code, response=body)
    defer.returnValue(body)

 def test_delete_queue(self):
     """
     Test to verify :func:`del_queue` on ``DELETE /v2.0/<tenant_id>/servers/<queue_name>``
     """
     delete_queue = request(self, self.root, b"DELETE", self.uri + '/queues/' + self.queue_name)
     delete_queue_response = self.successResultOf(delete_queue)
     self.assertEqual(delete_queue_response.code, 204)
     self.assertEqual(self.successResultOf(treq.content(delete_queue_response)), b"")

 def test_invalid_content_type(self):
     response = yield self.request_with_fixture('client_sync_init.xml', {
         'Content-Type': ['foo'],
     })
     body = yield content(response)
     self.assertEqual(response.code, http.NOT_ACCEPTABLE)
     self.assertContentType(response, 'text/plain')
     self.assertEqual(body, 'Unsupported content-type.')

    def test_content(self):
        d = content(self.response)

        self.protocol.dataReceived('foo')
        self.protocol.dataReceived('bar')
        self.protocol.connectionLost(Failure(ResponseDone()))

        self.assertEqual(self.successResultOf(d), 'foobar')

 def got_result(result):
     if result.code in success_codes:
         action.addSuccessFields(response_code=result.code)
         return json_content(result)
     else:
         d = content(result)
         d.addCallback(error, result.code)
         return d

 def test_delete_server(self):
     """
     Test to verify :func:`delete_server` on ``DELETE /v2.0/<tenant_id>/servers/<server_id>``
     """
     delete_server = request(self, self.root, "DELETE", self.uri + '/servers/' + self.server_id)
     delete_server_response = self.successResultOf(delete_server)
     self.assertEqual(delete_server_response.code, 204)
     self.assertEqual(self.successResultOf(treq.content(delete_server_response)),
                      b"")

    def test_content_cached(self):
        d1 = content(self.response)

        self.protocol.dataReceived('foo')
        self.protocol.dataReceived('bar')
        self.protocol.connectionLost(Failure(ResponseDone()))

        self.assertEqual(self.successResultOf(d1), 'foobar')

        def _fail_deliverBody(protocol):
            self.fail("deliverBody unexpectedly called.")

        self.response.original.deliverBody.side_effect = _fail_deliverBody

        d3 = content(self.response)

        self.assertEqual(self.successResultOf(d3), 'foobar')

        self.assertNotIdentical(d1, d3)

 def got_response(response):
     if response.code in success_codes:
         action.addSuccessFields(response_code=response.code)
         d = json_content(response)
         d.addCallback(lambda decoded_body: (decoded_body, response.headers))
         return d
     else:
         d = content(response)
         d.addCallback(error, response.code)
         return d