public function sendFeedRequest($methodPath, array $params = array())
 {
     $url = Google_Http_REST::createRequestUri($this->service->servicePath, $methodPath, $params);
     $httpRequest = new Google_Http_Request($url, 'GET', null, null);
     $httpRequest = $this->client->getAuth()->sign($httpRequest);
     try {
         //$response = $this->client->execute($httpRequest);
         // leave execue() because the json deserialization is in it
         // we need pure xml, su custom requesting
         $response = $this->client->getIo()->makeRequest($httpRequest);
     } catch (\Exception $e) {
     }
     return $response;
 }

 public function parseResponse(Google_Http_Request $response)
 {
     $contentType = $response->getResponseHeader('content-type');
     $contentType = explode(';', $contentType);
     $boundary = false;
     foreach ($contentType as $part) {
         $part = explode('=', $part, 2);
         if (isset($part[0]) && 'boundary' == trim($part[0])) {
             $boundary = $part[1];
         }
     }
     $body = $response->getResponseBody();
     if ($body) {
         $body = str_replace("--{$boundary}--", "--{$boundary}", $body);
         $parts = explode("--{$boundary}", $body);
         $responses = array();
         foreach ($parts as $part) {
             $part = trim($part);
             if (!empty($part)) {
                 list($metaHeaders, $part) = explode("\r\n\r\n", $part, 2);
                 $metaHeaders = $this->client->getIo()->getHttpResponseHeaders($metaHeaders);
                 $status = substr($part, 0, strpos($part, "\n"));
                 $status = explode(" ", $status);
                 $status = $status[1];
                 list($partHeaders, $partBody) = $this->client->getIo()->ParseHttpResponse($part, false);
                 $response = new Google_Http_Request("");
                 $response->setResponseHttpCode($status);
                 $response->setResponseHeaders($partHeaders);
                 $response->setResponseBody($partBody);
                 // Need content id.
                 $key = $metaHeaders['content-id'];
                 if (isset($this->expected_classes[$key]) && strlen($this->expected_classes[$key]) > 0) {
                     $class = $this->expected_classes[$key];
                     $response->setExpectedClass($class);
                 }
                 try {
                     $response = Google_Http_REST::decodeHttpResponse($response);
                     $responses[$key] = $response;
                 } catch (Google_Service_Exception $e) {
                     // Store the exception as the response, so succesful responses
                     // can be processed.
                     $responses[$key] = $e;
                 }
             }
         }
         return $responses;
     }
     return null;
 }

 /**
  * TODO(ianbarber): This function needs simplifying.
  *
  * @param $name
  * @param $arguments
  * @param $expected_class - optional, the expected class name
  *
  * @throws Google_Exception
  *
  * @return Google_Http_Request|expected_class
  */
 public function call($name, $arguments, $expected_class = null)
 {
     if (!isset($this->methods[$name])) {
         throw new Google_Exception('Unknown function: ' . "{$this->serviceName}->{$this->resourceName}->{$name}()");
     }
     $method = $this->methods[$name];
     $parameters = $arguments[0];
     // postBody is a special case since it's not defined in the discovery
     // document as parameter, but we abuse the param entry for storing it.
     $postBody = null;
     if (isset($parameters['postBody'])) {
         if (is_object($parameters['postBody'])) {
             $parameters['postBody'] = $this->convertToArrayAndStripNulls($parameters['postBody']);
         }
         $postBody = json_encode($parameters['postBody']);
         unset($parameters['postBody']);
     }
     // TODO(ianbarber): optParams here probably should have been
     // handled already - this may well be redundant code.
     if (isset($parameters['optParams'])) {
         $optParams = $parameters['optParams'];
         unset($parameters['optParams']);
         $parameters = array_merge($parameters, $optParams);
     }
     if (!isset($method['parameters'])) {
         $method['parameters'] = [];
     }
     $method['parameters'] = array_merge($method['parameters'], $this->stackParameters);
     foreach ($parameters as $key => $val) {
         if ($key != 'postBody' && !isset($method['parameters'][$key])) {
             throw new Google_Exception("({$name}) unknown parameter: '{$key}'");
         }
     }
     foreach ($method['parameters'] as $paramName => $paramSpec) {
         if (isset($paramSpec['required']) && $paramSpec['required'] && !isset($parameters[$paramName])) {
             throw new Google_Exception("({$name}) missing required param: '{$paramName}'");
         }
         if (isset($parameters[$paramName])) {
             $value = $parameters[$paramName];
             $parameters[$paramName] = $paramSpec;
             $parameters[$paramName]['value'] = $value;
             unset($parameters[$paramName]['required']);
         } else {
             // Ensure we don't pass nulls.
             unset($parameters[$paramName]);
         }
     }
     $servicePath = $this->service->servicePath;
     $url = Google_Http_REST::createRequestUri($servicePath, $method['path'], $parameters);
     $httpRequest = new Google_Http_Request($this->client, $url, $method['httpMethod'], null, $postBody);
     if ($postBody) {
         $contentTypeHeader = [];
         $contentTypeHeader['content-type'] = 'application/json; charset=UTF-8';
         $httpRequest->setRequestHeaders($contentTypeHeader);
         $httpRequest->setPostBody($postBody);
     }
     $httpRequest = $this->client->getAuth()->sign($httpRequest);
     $httpRequest->setExpectedClass($expected_class);
     if (isset($parameters['data']) && ($parameters['uploadType']['value'] == 'media' || $parameters['uploadType']['value'] == 'multipart')) {
         // If we are doing a simple media upload, trigger that as a convenience.
         $mfu = new Google_Http_MediaFileUpload($this->client, $httpRequest, isset($parameters['mimeType']) ? $parameters['mimeType']['value'] : 'application/octet-stream', $parameters['data']['value']);
     }
     if ($this->client->shouldDefer()) {
         // If we are in batch or upload mode, return the raw request.
         return $httpRequest;
     }
     return $httpRequest->execute();
 }

 /**
  * Helper method to execute deferred HTTP requests.
  *
  * @returns object of the type of the expected class or array.
  */
 public function execute()
 {
     $this->maybeMoveParametersToBody();
     return Google_Http_REST::execute($this->client, $this);
 }

 /**
  * Sends a PUT-Request to google drive and parses the response,
  * setting the appropiate variables from the response()
  *
  * @param Google_Http_Request $httpRequest the Reuqest which will be send
  *
  * @return false|mixed false when the upload is unfinished or the decoded http response
  *
  */
 private function makePutRequest(Google_Http_Request $httpRequest)
 {
     if ($this->client->getClassConfig("Google_Http_Request", "enable_gzip_for_uploads")) {
         $httpRequest->enableGzip();
     } else {
         $httpRequest->disableGzip();
     }
     $response = $this->client->getIo()->makeRequest($httpRequest);
     $response->setExpectedClass($this->request->getExpectedClass());
     $code = $response->getResponseHttpCode();
     $this->httpResultCode = $code;
     if (308 == $code) {
         // Track the amount uploaded.
         $range = explode('-', $response->getResponseHeader('range'));
         $this->progress = $range[1] + 1;
         // Allow for changing upload URLs.
         $location = $response->getResponseHeader('location');
         if ($location) {
             $this->resumeUri = $location;
         }
         // No problems, but upload not complete.
         return false;
     } else {
         return Google_Http_REST::decodeHttpResponse($response, $this->client);
     }
 }

 /**
  * Runs the defined request.
  *
  * @return array
  */
 private function makeRequest()
 {
     $request = new Google_Http_Request('/test');
     $io = $this->getMockBuilder('Google_IO_Abstract')->disableOriginalConstructor()->setMethods(array('makeRequest'))->getMockForAbstractClass();
     $io->expects($this->exactly($this->mockedCallsCount))->method('makeRequest')->will($this->returnCallback(array($this, 'getNextMockedCall')));
     $this->client->setIo($io);
     return Google_Http_REST::execute($this->client, $request);
 }

 /**
  * Helper method to execute deferred HTTP requests.
  *
  * @param $request Google_Http_Request|Google_Http_Batch
  * @throws Google_Exception
  * @return object of the type of the expected class or array.
  */
 public function execute($request)
 {
     if ($request instanceof Google_Http_Request) {
         $request->setUserAgent($this->getApplicationName() . " " . self::USER_AGENT_SUFFIX . $this->getLibraryVersion());
         if (!$this->getClassConfig("Google_Http_Request", "disable_gzip")) {
             $request->enableGzip();
         }
         $request->maybeMoveParametersToBody();
         return Google_Http_REST::execute($this, $request);
     } else {
         if ($request instanceof Google_Http_Batch) {
             return $request->execute();
         } else {
             //throw new Google_Exception("Do not know how to execute this type of object.");
             echo json_encode(array('status' => FALSE, 'response-code' => 400, 'response' => "Do not know how to execute this type of object.", 'message' => ''));
             die;
         }
     }
 }

 public function parseResponse(ResponseInterface $response, $classes = array())
 {
     $contentType = $response->getHeaderLine('content-type');
     $contentType = explode(';', $contentType);
     $boundary = false;
     foreach ($contentType as $part) {
         $part = explode('=', $part, 2);
         if (isset($part[0]) && 'boundary' == trim($part[0])) {
             $boundary = $part[1];
         }
     }
     $body = (string) $response->getBody();
     if (!empty($body)) {
         $body = str_replace("--{$boundary}--", "--{$boundary}", $body);
         $parts = explode("--{$boundary}", $body);
         $responses = array();
         $requests = array_values($this->requests);
         foreach ($parts as $i => $part) {
             $part = trim($part);
             if (!empty($part)) {
                 list($rawHeaders, $part) = explode("\r\n\r\n", $part, 2);
                 $headers = $this->parseRawHeaders($rawHeaders);
                 $status = substr($part, 0, strpos($part, "\n"));
                 $status = explode(" ", $status);
                 $status = $status[1];
                 list($partHeaders, $partBody) = $this->parseHttpResponse($part, false);
                 $response = new Response($status, $partHeaders, Psr7\stream_for($partBody));
                 // Need content id.
                 $key = $headers['content-id'];
                 $class = '';
                 if (!empty($this->expected_classes[$key])) {
                     $class = $this->expected_classes[$key];
                 }
                 try {
                     $response = Google_Http_REST::decodeHttpResponse($response, $requests[$i - 1]);
                 } catch (Google_Service_Exception $e) {
                     // Store the exception as the response, so successful responses
                     // can be processed.
                     $response = $e;
                 }
                 $responses[$key] = $response;
             }
         }
         return $responses;
     }
     return null;
 }

 /**
  * Helper method to execute deferred HTTP requests.
  *
  * @param $request GuzzleHttp\Message\RequestInterface|Google_Http_Batch
  * @throws Google_Exception
  * @return object of the type of the expected class or array.
  */
 public function execute($request, $expectedClass = null)
 {
     $request->setHeader('User-Agent', $this->config->get('application_name') . " " . self::USER_AGENT_SUFFIX . $this->getLibraryVersion());
     $http = $this->getHttpClient();
     $result = Google_Http_REST::execute($http, $request, $this->config['retry']);
     $expectedClass = $expectedClass ?: $request->getHeader('X-Php-Expected-Class');
     if ($expectedClass) {
         $result = new $expectedClass($result);
     }
     return $result;
 }

 /**
  * Sends a PUT-Request to google drive and parses the response,
  * setting the appropiate variables from the response()
  *
  * @param Google_Http_Request $httpRequest the Reuqest which will be send
  *
  * @return false|mixed false when the upload is unfinished or the decoded http response
  *
  */
 private function makePutRequest(RequestInterface $request)
 {
     $response = $this->client->execute($request);
     $this->httpResultCode = $response->getStatusCode();
     if (308 == $this->httpResultCode) {
         // Track the amount uploaded.
         $range = explode('-', $response->getHeaderLine('range'));
         $this->progress = $range[1] + 1;
         // Allow for changing upload URLs.
         $location = $response->getHeaderLine('location');
         if ($location) {
             $this->resumeUri = $location;
         }
         // No problems, but upload not complete.
         return false;
     }
     return Google_Http_REST::decodeHttpResponse($response, $this->request);
 }

 /**
  * TODO(ianbarber): This function needs simplifying.
  * @param $name
  * @param $arguments
  * @param $expected_class - optional, the expected class name
  * @return Google_Http_Request|expected_class
  * @throws Google_Exception
  */
 public function call($name, $arguments, $expected_class = null)
 {
     if (!isset($this->methods[$name])) {
         $this->client->getLogger()->error('Service method unknown', array('service' => $this->serviceName, 'resource' => $this->resourceName, 'method' => $name));
         throw new Google_Exception("Unknown function: " . "{$this->serviceName}->{$this->resourceName}->{$name}()");
     }
     $method = $this->methods[$name];
     $parameters = $arguments[0];
     // postBody is a special case since it's not defined in the discovery
     // document as parameter, but we abuse the param entry for storing it.
     $postBody = null;
     if (isset($parameters['postBody'])) {
         if ($parameters['postBody'] instanceof Google_Model) {
             // In the cases the post body is an existing object, we want
             // to use the smart method to create a simple object for
             // for JSONification.
             $parameters['postBody'] = $parameters['postBody']->toSimpleObject();
         } else {
             if (is_object($parameters['postBody'])) {
                 // If the post body is another kind of object, we will try and
                 // wrangle it into a sensible format.
                 $parameters['postBody'] = $this->convertToArrayAndStripNulls($parameters['postBody']);
             }
         }
         $postBody = json_encode($parameters['postBody']);
         unset($parameters['postBody']);
     }
     // TODO(ianbarber): optParams here probably should have been
     // handled already - this may well be redundant code.
     if (isset($parameters['optParams'])) {
         $optParams = $parameters['optParams'];
         unset($parameters['optParams']);
         $parameters = array_merge($parameters, $optParams);
     }
     if (!isset($method['parameters'])) {
         $method['parameters'] = array();
     }
     $method['parameters'] = array_merge($method['parameters'], $this->stackParameters);
     foreach ($parameters as $key => $val) {
         if ($key != 'postBody' && !isset($method['parameters'][$key])) {
             $this->client->getLogger()->error('Service parameter unknown', array('service' => $this->serviceName, 'resource' => $this->resourceName, 'method' => $name, 'parameter' => $key));
             throw new Google_Exception("({$name}) unknown parameter: '{$key}'");
         }
     }
     foreach ($method['parameters'] as $paramName => $paramSpec) {
         if (isset($paramSpec['required']) && $paramSpec['required'] && !isset($parameters[$paramName])) {
             $this->client->getLogger()->error('Service parameter missing', array('service' => $this->serviceName, 'resource' => $this->resourceName, 'method' => $name, 'parameter' => $paramName));
             throw new Google_Exception("({$name}) missing required param: '{$paramName}'");
         }
         if (isset($parameters[$paramName])) {
             $value = $parameters[$paramName];
             $parameters[$paramName] = $paramSpec;
             $parameters[$paramName]['value'] = $value;
             unset($parameters[$paramName]['required']);
         } else {
             // Ensure we don't pass nulls.
             unset($parameters[$paramName]);
         }
     }
     $this->client->getLogger()->info('Service Call', array('service' => $this->serviceName, 'resource' => $this->resourceName, 'method' => $name, 'arguments' => $parameters));
     $url = Google_Http_REST::createRequestUri($this->servicePath, $method['path'], $parameters);
     $httpRequest = new Google_Http_Request($url, $method['httpMethod'], null, $postBody);
     if ($this->rootUrl) {
         $httpRequest->setBaseComponent($this->rootUrl);
     } else {
         $httpRequest->setBaseComponent($this->client->getBasePath());
     }
     if ($postBody) {
         $contentTypeHeader = array();
         $contentTypeHeader['content-type'] = 'application/json; charset=UTF-8';
         $httpRequest->setRequestHeaders($contentTypeHeader);
         $httpRequest->setPostBody($postBody);
     }
     $httpRequest = $this->client->getAuth()->sign($httpRequest);
     $httpRequest->setExpectedClass($expected_class);
     if (isset($parameters['data']) && ($parameters['uploadType']['value'] == 'media' || $parameters['uploadType']['value'] == 'multipart')) {
         // If we are doing a simple media upload, trigger that as a convenience.
         $mfu = new Google_Http_MediaFileUpload($this->client, $httpRequest, isset($parameters['mimeType']) ? $parameters['mimeType']['value'] : 'application/octet-stream', $parameters['data']['value']);
     }
     if (isset($parameters['alt']) && $parameters['alt']['value'] == 'media') {
         $httpRequest->enableExpectedRaw();
     }
     if ($this->client->shouldDefer()) {
         // If we are in batch or upload mode, return the raw request.
         return $httpRequest;
     }
     return $this->client->execute($httpRequest);
 }

 /**
  * Send the next part of the file to upload.
  * @param [$chunk] the next set of bytes to send. If false will used $data passed
  * at construct time.
  */
 public function nextChunk($chunk = false)
 {
     if (false == $this->resumeUri) {
         $this->resumeUri = $this->getResumeUri();
     }
     if (false == $chunk) {
         $chunk = substr($this->data, $this->progress, $this->chunkSize);
     }
     $lastBytePos = $this->progress + strlen($chunk) - 1;
     $headers = array('content-range' => "bytes {$this->progress}-{$lastBytePos}/{$this->size}", 'content-type' => $this->request->getRequestHeader('content-type'), 'content-length' => $this->chunkSize, 'expect' => '');
     $httpRequest = new Google_Http_Request($this->resumeUri, 'PUT', $headers, $chunk);
     if ($this->client->getClassConfig("Google_Http_Request", "enable_gzip_for_uploads")) {
         $httpRequest->enableGzip();
     } else {
         $httpRequest->disableGzip();
     }
     $response = $this->client->getIo()->makeRequest($httpRequest);
     $response->setExpectedClass($this->request->getExpectedClass());
     $code = $response->getResponseHttpCode();
     $this->httpResultCode = $code;
     if (308 == $code) {
         // Track the amount uploaded.
         $range = explode('-', $response->getResponseHeader('range'));
         $this->progress = $range[1] + 1;
         // Allow for changing upload URLs.
         $location = $response->getResponseHeader('location');
         if ($location) {
             $this->resumeUri = $location;
         }
         // No problems, but upload not complete.
         return false;
     } else {
         return Google_Http_REST::decodeHttpResponse($response);
     }
 }

 /**
  * Helper method to execute deferred HTTP requests.
  *
  * @param $request Psr\Http\Message\RequestInterface|Google_Http_Batch
  * @throws Google_Exception
  * @return object of the type of the expected class or Psr\Http\Message\ResponseInterface.
  */
 public function execute(RequestInterface $request, $expectedClass = null)
 {
     $request = $request->withHeader('User-Agent', $this->config['application_name'] . " " . self::USER_AGENT_SUFFIX . $this->getLibraryVersion());
     // call the authorize method
     // this is where most of the grunt work is done
     $http = $this->authorize();
     return Google_Http_REST::execute($http, $request, $expectedClass, $this->config['retry']);
 }

 /**
  * Helper method to execute deferred HTTP requests.
  *
  * @param $request Google_Http_Request|Google_Http_Batch
  * @throws Google_Exception
  * @return object of the type of the expected class or array.
  */
 public function execute($request)
 {
     if ($request instanceof Google_Http_Request) {
         $request->setUserAgent($this->getApplicationName() . " " . self::USER_AGENT_SUFFIX . $this->getLibraryVersion());
         if (!$this->getClassConfig("Google_Http_Request", "disable_gzip")) {
             $request->enableGzip();
         }
         $request->maybeMoveParametersToBody();
         return Google_Http_REST::execute($this, $request);
     } else {
         if ($request instanceof Google_Http_Batch) {
             return $request->execute();
         } else {
             throw new Google_Exception("Do not know how to execute this type of object.");
         }
     }
 }

 /**
  * Runs the defined request.
  *
  * @return array
  */
 private function makeRequest()
 {
     $request = new Request('GET', '/test');
     $http = $this->getMock('GuzzleHttp\\ClientInterface');
     $http->expects($this->exactly($this->mockedCallsCount))->method('send')->will($this->returnCallback(array($this, 'getNextMockedCall')));
     return Google_Http_REST::execute($http, $request, $this->retryConfig, $this->retryMap);
 }

 public function testCreateRequestUri()
 {
     $basePath = "http://localhost";
     $restPath = "/plus/{u}";
     // Test Path
     $params = array();
     $params['u']['type'] = 'string';
     $params['u']['location'] = 'path';
     $params['u']['value'] = 'me';
     $value = $this->rest->createRequestUri($basePath, $restPath, $params);
     $this->assertEquals("http://localhost/plus/me", $value);
     // Test Query
     $params = array();
     $params['u']['type'] = 'string';
     $params['u']['location'] = 'query';
     $params['u']['value'] = 'me';
     $value = $this->rest->createRequestUri($basePath, '/plus', $params);
     $this->assertEquals("http://localhost/plus?u=me", $value);
     // Test Booleans
     $params = array();
     $params['u']['type'] = 'boolean';
     $params['u']['location'] = 'path';
     $params['u']['value'] = '1';
     $value = $this->rest->createRequestUri($basePath, $restPath, $params);
     $this->assertEquals("http://localhost/plus/true", $value);
     $params['u']['location'] = 'query';
     $value = $this->rest->createRequestUri($basePath, '/plus', $params);
     $this->assertEquals("http://localhost/plus?u=true", $value);
     // Test encoding
     $params = array();
     $params['u']['type'] = 'string';
     $params['u']['location'] = 'query';
     $params['u']['value'] = '@me/';
     $value = $this->rest->createRequestUri($basePath, '/plus', $params);
     $this->assertEquals("http://localhost/plus?u=%40me%2F", $value);
 }

 /**
  * @expectedException Google_Service_Exception
  */
 public function tesProperErrorFormatting()
 {
     $stream = Stream::factory('{
       error: {
        errors: [
         {
          "domain": "global",
          "reason": "authError",
          "message": "Invalid Credentials",
          "locationType": "header",
          "location": "Authorization",
         }
        ],
       "code": 401,
       "message": "Invalid Credentials"
     }');
     $response = new Response(401, array(), $stream);
     $this->rest->decodeHttpResponse($response);
 }

 /**
  * @expectedException Google_Service_Exception
  */
 public function testNotJson404Error()
 {
     $stream = Psr7\stream_for('Not Found');
     $response = new Response(404, array(), $stream);
     $this->rest->decodeHttpResponse($response, $this->request);
 }

 /**
  * @expectedException Google_Service_Exception
  */
 public function testNotJson404Error()
 {
     $stream = Stream::factory('Not Found');
     $response = new Response(404, array(), $stream);
     $this->rest->decodeHttpResponse($response);
 }