[Cronet] Add Hello World response to QuicTestServer and use it in bidirectional stream test.

components/cronet/ios/test/cronet_bidirectional_stream_test.mm

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #import <Foundation/Foundation.h>
 #include <stdint.h>
 #include <list>
 #include <map>
 #include <string>
 
 #include "base/logging.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "components/cronet/ios/cronet_c_for_grpc.h"
 #include "components/cronet/ios/cronet_environment.h"
 #include "components/cronet/ios/test/quic_test_server.h"
 #include "net/base/mac/url_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gtest_mac.h"
 #include "url/gurl.h"
 
 namespace {
-const char kTestServerHost[] = "test.example.com";
-const int kTestServerPort = 6121;
-const char kTestServerUrl[] = "https://test.example.com:6121";
 
 cronet_bidirectional_stream_header kTestHeaders[] = {
     {"header1", "foo"},
     {"header2", "bar"},
 };
 const cronet_bidirectional_stream_header_array kTestHeadersArray = {
     2, 2, kTestHeaders};
 }  // namespace
 
+namespace cronet {
+
 class CronetBidirectionalStreamTest : public ::testing::Test {
  protected:
   CronetBidirectionalStreamTest() {}
   ~CronetBidirectionalStreamTest() override {}
 
   void SetUp() override {
     static bool initialized = false;
     if (!initialized) {
       initialized = true;
       // Hack to work around issues with SetUp being called multiple times
       // during the test, and QuicTestServer not shutting down / restarting
       // gracefully.
-      cronet::CronetEnvironment::Initialize();
-      cronet::StartQuicTestServer();
+      CronetEnvironment::Initialize();
+      StartQuicTestServer();
     }
 
-    cronet_environment_ = new cronet::CronetEnvironment("CronetTest/1.0.0.0");
+    cronet_environment_ = new CronetEnvironment("CronetTest/1.0.0.0");
     cronet_environment_->set_http2_enabled(true);
     cronet_environment_->set_quic_enabled(true);
     cronet_environment_->set_ssl_key_log_file_name("SSLKEYLOGFILE");
 
     scoped_ptr<net::MockCertVerifier> mock_cert_verifier(
         new net::MockCertVerifier());
     mock_cert_verifier->set_default_result(net::OK);
 
     cronet_environment_->set_cert_verifier(std::move(mock_cert_verifier));
     cronet_environment_->set_host_resolver_rules(
         "MAP test.example.com 127.0.0.1,"
         "MAP notfound.example.com ~NOTFOUND");
-    cronet_environment_->AddQuicHint(kTestServerHost, kTestServerPort,
+    cronet_environment_->AddQuicHint(kTestServerDomain, kTestServerPort,
                                      kTestServerPort);
 
     cronet_environment_->Start();
 
     cronet_engine_.obj = cronet_environment_;
 
     cronet_environment_->StartNetLog("cronet_netlog.json", true);
   }
 
   void TearDown() override {
-    // cronet::ShutdownQuicTestServer();
+    // ShutdownQuicTestServer();
     cronet_environment_->StopNetLog();
     //[CronetEngine stopNetLog];
     //[CronetEngine uninstall];
   }
 
   cronet_engine* engine() { return &cronet_engine_; }
 
  private:
-  static cronet::CronetEnvironment* cronet_environment_;
+  static CronetEnvironment* cronet_environment_;
   static cronet_engine cronet_engine_;
 };
 
-cronet::CronetEnvironment* CronetBidirectionalStreamTest::cronet_environment_;
+CronetEnvironment* CronetBidirectionalStreamTest::cronet_environment_;
 cronet_engine CronetBidirectionalStreamTest::cronet_engine_;
 
 class TestBidirectionalStreamCallback {
  public:
   enum ResponseStep {
     NOTHING,
     ON_REQUEST_HEADERS_SENT,
     ON_RESPONSE_STARTED,
     ON_READ_COMPLETED,
     ON_WRITE_COMPLETED,
@@ skipping 119 matching lines @@
     if (test->MaybeCancel(stream, ON_WRITE_COMPLETED))
       return;
     test->write_data.pop_front();
     test->MaybeWriteNextData(stream);
   }
 
   static void on_response_trailers_received_callback(
       cronet_bidirectional_stream* stream,
       const cronet_bidirectional_stream_header_array* trailers) {
     TestBidirectionalStreamCallback* test = FromStream(stream);
+    for (size_t i = 0; i < trailers->count; ++i) {
+      test->response_trailers[trailers->headers[i].key] =

[kapishnikov, 2016/04/26 20:11:50]

Is it possible for the response to contain two or more trailers with the same
key? If it is possible, maybe we should consider using a map of lists, i.e. {key
: [value1, value2, etc]}.

[mef, 2016/04/26 20:39:21]

I just confirmed that I've recalled correctly and additional values replace
previous in spdy header block (on the quic test server side).

+          trailers->headers[i].value;
+    }
+
     if (test->MaybeCancel(stream, ON_TRAILERS))
       return;
   }
 
   static void on_succeded_callback(cronet_bidirectional_stream* stream) {
     TestBidirectionalStreamCallback* test = FromStream(stream);
     test->MaybeCancel(stream, ON_SUCCEEDED);
     test->SignalDone();
   }
 
@@ skipping 29 matching lines @@
   TestBidirectionalStreamCallback test;
   test.AddWriteData("Hello, ");
   test.AddWriteData("world!");
   test.read_buffer_size = 2;
   test.stream =
       cronet_bidirectional_stream_create(engine(), &test, test.callback());
   DCHECK(test.stream);
   cronet_bidirectional_stream_start(test.stream, kTestServerUrl, 0, "POST",
                                     &kTestHeadersArray, false);
   test.BlockForDone();
-  ASSERT_EQ(std::string("404"), test.response_headers[":status"]);
+  ASSERT_EQ(std::string(kHelloStatus), test.response_headers[kStatusHeader]);
+  ASSERT_EQ(std::string(kHelloHeaderValue),
+            test.response_headers[kHelloHeaderName]);
   ASSERT_EQ(TestBidirectionalStreamCallback::ON_SUCCEEDED, test.response_step);
-  ASSERT_EQ(std::string("fi"), test.read_data.front());
-  ASSERT_EQ(std::string("file not found"),
-            base::JoinString(test.read_data, ""));
+  ASSERT_EQ(std::string(kHelloBodyValue, 2), test.read_data.front());
+  ASSERT_EQ(std::string(kHelloBodyValue), base::JoinString(test.read_data, ""));
+  ASSERT_EQ(std::string(kHelloTrailerValue),
+            test.response_trailers[kHelloTrailerName]);
   cronet_bidirectional_stream_destroy(test.stream);
 }
 
 TEST_F(CronetBidirectionalStreamTest, CancelOnRead) {
   TestBidirectionalStreamCallback test;
   test.stream =
       cronet_bidirectional_stream_create(engine(), &test, test.callback());
   DCHECK(test.stream);
   test.cancel_from_step = TestBidirectionalStreamCallback::ON_READ_COMPLETED;
   cronet_bidirectional_stream_start(test.stream, kTestServerUrl, 0, "POST",
                                     &kTestHeadersArray, true);
   test.BlockForDone();
-  ASSERT_EQ(std::string("404"), test.response_headers[":status"]);
-  ASSERT_EQ(std::string("file not found"), test.read_data.front());
+  ASSERT_EQ(std::string(kHelloStatus), test.response_headers[kStatusHeader]);
+  ASSERT_EQ(std::string(kHelloBodyValue), test.read_data.front());
   ASSERT_EQ(TestBidirectionalStreamCallback::ON_CANCELED, test.response_step);
   cronet_bidirectional_stream_destroy(test.stream);
 }
 
 TEST_F(CronetBidirectionalStreamTest, CancelOnResponse) {
   TestBidirectionalStreamCallback test;
   test.stream =
       cronet_bidirectional_stream_create(engine(), &test, test.callback());
   DCHECK(test.stream);
   test.cancel_from_step = TestBidirectionalStreamCallback::ON_RESPONSE_STARTED;
   cronet_bidirectional_stream_start(test.stream, kTestServerUrl, 0, "POST",
                                     &kTestHeadersArray, true);
   test.BlockForDone();
-  ASSERT_EQ(std::string("404"), test.response_headers[":status"]);
+  ASSERT_EQ(std::string(kHelloStatus), test.response_headers[kStatusHeader]);
   ASSERT_TRUE(test.read_data.empty());
   ASSERT_EQ(TestBidirectionalStreamCallback::ON_CANCELED, test.response_step);
   cronet_bidirectional_stream_destroy(test.stream);
 }
 
 TEST_F(CronetBidirectionalStreamTest, CancelOnSucceeded) {
   TestBidirectionalStreamCallback test;
   test.stream =
       cronet_bidirectional_stream_create(engine(), &test, test.callback());
   DCHECK(test.stream);
   test.cancel_from_step = TestBidirectionalStreamCallback::ON_SUCCEEDED;
   cronet_bidirectional_stream_start(test.stream, kTestServerUrl, 0, "POST",
                                     &kTestHeadersArray, true);
   test.BlockForDone();
-  ASSERT_EQ(std::string("404"), test.response_headers[":status"]);
-  ASSERT_EQ(std::string("file not found"), test.read_data.front());
+  ASSERT_EQ(std::string(kHelloStatus), test.response_headers[kStatusHeader]);
+  ASSERT_EQ(std::string(kHelloBodyValue), test.read_data.front());
   ASSERT_EQ(TestBidirectionalStreamCallback::ON_SUCCEEDED, test.response_step);
   cronet_bidirectional_stream_destroy(test.stream);
 }
 
 TEST_F(CronetBidirectionalStreamTest, ReadFailsBeforeRequestStarted) {
   TestBidirectionalStreamCallback test;
   test.stream =
       cronet_bidirectional_stream_create(engine(), &test, test.callback());
   DCHECK(test.stream);
   char read_buffer[1];
@@ skipping 26 matching lines @@
   DCHECK(test.stream);
   test.cancel_from_step = TestBidirectionalStreamCallback::ON_FAILED;
   cronet_bidirectional_stream_start(test.stream, "https://notfound.example.com",
                                     0, "GET", &kTestHeadersArray, true);
   test.BlockForDone();
   ASSERT_TRUE(test.read_data.empty());
   ASSERT_EQ(TestBidirectionalStreamCallback::ON_FAILED, test.response_step);
   ASSERT_EQ(net::ERR_NAME_NOT_RESOLVED, test.net_error);
   cronet_bidirectional_stream_destroy(test.stream);
 }
+
+}  // namespace cronet