/**
  * @runInSeparateProcess
  */
 public function testRespondsPlainTextWithHttpCode404()
 {
     (new NotFound())->respond();
     $this->assertContains('Content-Type: text/plain; charset=utf-8', xdebug_get_headers());
     $this->assertEquals(Http::NOT_FOUND, http_response_code());
     $this->expectOutputString('Not Found.');
 }

 public function test_send_headers()
 {
     SecureHeaders::fromFile($this->configPath)->send();
     $headers = xdebug_get_headers();
     $this->assertContains('X-Content-Type-Options: nosniff', $headers);
     $this->assertContains('Referrer-Policy: strict-origin-when-cross-origin', $headers);
 }

 /**
  * @runInSeparateProcess
  */
 public function testRespondsPlainTextWithHttpCode401()
 {
     (new Unauthorized())->respond();
     $this->assertContains('Content-Type: text/plain; charset=utf-8', xdebug_get_headers());
     $this->assertEquals(Http::UNAUTHORIZED, http_response_code());
     $this->expectOutputString('Unauthorized.');
 }

 /**
  * @runInSeparateProcess
  */
 public function testRespondsPlainTextWithHttpCode403()
 {
     (new Forbidden())->respond();
     $this->assertContains('Content-Type: text/plain; charset=utf-8', xdebug_get_headers());
     $this->assertEquals(Http::FORBIDDEN, http_response_code());
     $this->expectOutputString("Forbidden!");
 }

 /**
  * @runInSeparateProcess
  * @dataProvider locationCodeProvider
  */
 public function testSendsLocationAndHttpCodeHeaderWhenResponding($location, $httpCode, $expectedHeader, $expectedCode)
 {
     $redirect = new Redirect($location, $httpCode);
     $redirect->respond();
     $this->assertContains($expectedHeader, xdebug_get_headers());
     $this->assertEquals($expectedCode, http_response_code());
 }

 /**
  * @runInSeparateProcess
  */
 public function testRespondsPlainTextWithHttpCode405()
 {
     (new MethodNotAllowed())->respond();
     $this->assertContains('Content-Type: text/plain; charset=utf-8', xdebug_get_headers());
     $this->assertEquals(Http::METHOD_NOT_ALLOWED, http_response_code());
     $this->expectOutputString('Method not allowed.');
 }

 /**
  * @runInSeparateProcess
  * @outputBuffering disabled
  */
 public function testProtectedController()
 {
     if (!function_exists('xdebug_get_headers')) {
         $this->markTestSkipped('Xdebug not installed');
     }
     $autoloader = new Autoloader();
     $autoloader->register();
     $autoloader->addNamespaces([['Linna\\FOO', dirname(__DIR__) . '/FOO']]);
     //config options
     $session = new Session();
     $session->start();
     $password = new Password();
     $storedPassword = $password->hash('password');
     //attemp first login
     $login = new Login($session, $password);
     $login->login('root', 'password', $storedUser = 'root', $storedPassword, 1);
     $loginLogged = $login->logged;
     $model = new FOOModel();
     $controller1 = new FOOProtectedController($model, $login);
     $controllerTest1 = $controller1->test;
     $login->logout();
     $loginNoLogged = $login->logged;
     ob_start();
     $controller2 = new FOOProtectedController($model, $login);
     $headers_list = xdebug_get_headers();
     ob_end_clean();
     $this->assertEquals(true, $loginLogged);
     $this->assertEquals(false, $loginNoLogged);
     $this->assertEquals(true, $controllerTest1);
     $this->assertEquals(true, in_array('Location: http://localhost', $headers_list));
     $session->destroy();
 }

 /**
  * @runInSeparateProcess
  */
 public function testRespondsPlainTextWithHttpCode500()
 {
     (new InternalServerError())->respond();
     $this->assertContains('Content-Type: text/plain; charset=utf-8', xdebug_get_headers());
     $this->assertEquals(Http::INTERNAL_SERVER_ERROR, http_response_code());
     $this->expectOutputString("Internal server error.");
 }

 /**
  * @test
  */
 public function shouldShowCaptcha()
 {
     $this->oneClickCaptchaService->showCaptcha();
     $headers = xdebug_get_headers();
     $this->assertEquals("Expires: Thu, 19 Nov 1981 08:52:00 GMT", $headers[1]);
     $this->assertEquals("Pragma: public", $headers[2]);
     $this->assertEquals("Cache-Control: public", $headers[3]);
 }

 /**
  * コンテンツタイプを出力
  * 
  * @return void
  */
 public function testHeader()
 {
     $this->markTestIncomplete('このテストは、まだ実装されていません。');
     $this->BcMobile->header();
     $result = xdebug_get_headers();
     $expected = 'Content-type: application/xhtml+xml';
     $this->assertEquals($expected, $result[0]);
 }

 /**
  * @runInSeparateProcess
  */
 public function testResponseObjectReturnsAllowedHeaderWhenWrongMethodUsed()
 {
     $request = $this->container['request'];
     $request->setSupportedRequestMethods(array($request::POST, $request::PUT, $request::DELETE));
     $response = $this->container['response'];
     $this->response->send($response::METHOD_NOT_ALLOWED_CODE);
     $this->assertContains('Allow: POST, PUT, DELETE', xdebug_get_headers());
 }

 /**
  * @runInSeparateProcess
  */
 public function testRespondsPlainTextWithHttpCode400()
 {
     $messages = ['This is a unit test.', 'I am testing the output.'];
     (new BadRequest($messages))->respond();
     $this->assertContains('Content-Type: text/plain; charset=utf-8', xdebug_get_headers());
     $this->assertEquals(Http::BAD_REQUEST, http_response_code());
     $this->expectOutputString("This is a unit test.\nI am testing the output.");
 }

 /**
  * @runInSeparateProcess
  */
 public function testJson()
 {
     $response = new Response($this->makeRequest());
     $response->setJson(['a' => 'b']);
     $this->expectOutputString(json_encode(['a' => 'b', 'c' => 'd']));
     $response->json(['c' => 'd']);
     $this->assertContains('Content-type: application/json', xdebug_get_headers());
 }

 /**
  * @runInSeparateProcess
  */
 public function testRespondsJsonWithHttpCode500()
 {
     $messages = ['This is a unit test.', 'I am testing the output.'];
     (new BadJsonRequest($messages))->respond();
     $this->assertContains('Content-Type: application/json; charset=utf-8', xdebug_get_headers());
     $this->assertEquals(Http::BAD_REQUEST, http_response_code());
     $this->expectOutputString('{"messages":["This is a unit test.","I am testing the output."]}');
 }

 /**
  * @test
  * @requires PHP > 5.3
  * @runInSeparateProcess
  */
 public function testHeaderResponseAttributes()
 {
     $this->qrCode->setFormat('png')->setHeaderResponse();
     $this->assertEquals(['Content-Type: image/png'], \xdebug_get_headers());
     $this->qrCode->setFormat('jpg')->setHeaderResponse();
     $this->assertEquals(['Content-Type: image/jpeg'], \xdebug_get_headers());
     $this->qrCode->setFormat('gif')->setHeaderResponse();
     $this->assertEquals(['Content-Type: image/gif'], \xdebug_get_headers());
 }

 public static function doTest($response)
 {
     $writer = new ezcMvcHttpResponseWriter($response);
     ob_start();
     $writer->handleResponse();
     $contents = ob_get_contents();
     ob_end_clean();
     return array(xdebug_get_headers(), $contents);
 }

 /**
  * @covers ::Header
  * @runInSeparateProcess
  */
 public function testHeader()
 {
     $header = 'a test header';
     ob_start();
     $this->assertEquals($this->testObj, $this->testObj->Header($header));
     $headers = xdebug_get_headers();
     ob_end_clean();
     $this->assertContains($header, $headers);
 }

 /**
  * @runInSeparateProcess
  */
 public function testSendsRedirectLocationHeader()
 {
     if (!function_exists('xdebug_get_headers')) {
         $this->markTestSkipped('Requires ext/xdebug to be installed.');
     }
     $this->redirector->redirect('http://www.example.com');
     $this->assertContains('Location: http://www.example.com/', xdebug_get_headers());
     header_remove();
 }

 /**
  * @runInSeparateProcess
  */
 public function testRedirect()
 {
     $data = array('name' => 'foo', 'email' => '[email protected]', 'message' => 'baz');
     $this->cb_args = array();
     $kontact = new Kontact($this->schema, $this->cb);
     $kontact->process($data, 'qux');
     $this->assertEquals(array('Location: qux?err=0&data%5Bname%5D=foo&data%5Bemail%5D=foo%40bar.com&data%5Bmessage%5D=baz'), xdebug_get_headers());
     $this->assertEquals(array(0, $data), $this->cb_args);
 }

 public function testSendMessageGzipCompression()
 {
     $communication = new PluginFusioninventoryCommunication();
     $communication->setMessage('<foo><bar/></foo>');
     $this->expectOutputString(gzencode($this->output));
     $communication->sendMessage('gzip');
     $headers = xdebug_get_headers();
     $this->assertContains('Content-Type: application/x-compress-gzip', $headers);
 }