components/cronet/ios/test/cronet_bidirectional_stream_test.mm - chromium/src - Git at Google

 // 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 {

 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.
       CronetEnvironment::Initialize();
     }

     StartQuicTestServer();

     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");

     std::unique_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(kTestServerDomain, kTestServerPort,
                                      kTestServerPort);

     cronet_environment_->Start();

     cronet_engine_.obj = cronet_environment_;

     cronet_environment_->StartNetLog("cronet_netlog.json", true);
   }

   void TearDown() override {
     ShutdownQuicTestServer();
     cronet_environment_->StopNetLog();
     //[CronetEngine stopNetLog];
     //[CronetEngine uninstall];
   }

   cronet_engine* engine() { return &cronet_engine_; }

  private:
   static CronetEnvironment* cronet_environment_;
   static cronet_engine cronet_engine_;
 };

 CronetEnvironment* CronetBidirectionalStreamTest::cronet_environment_;
 cronet_engine CronetBidirectionalStreamTest::cronet_engine_;

 class TestBidirectionalStreamCallback {
  public:
   enum ResponseStep {
     NOTHING,
     ON_STREAM_READY,
     ON_RESPONSE_STARTED,
     ON_READ_COMPLETED,
     ON_WRITE_COMPLETED,
     ON_TRAILERS,
     ON_CANCELED,
     ON_FAILED,
     ON_SUCCEEDED
   };

   cronet_bidirectional_stream* stream;
   base::WaitableEvent stream_done_event;

   // Test parameters.
   std::map<std::string, std::string> request_headers;
   std::list<std::string> write_data;
   std::string expected_negotiated_protocol;
   ResponseStep cancel_from_step;
   size_t read_buffer_size;

   // Test results.
   ResponseStep response_step;
   char* read_buffer;
   std::map<std::string, std::string> response_headers;
   std::map<std::string, std::string> response_trailers;
   std::vector<std::string> read_data;
   int net_error;

   TestBidirectionalStreamCallback()
       : stream(nullptr),
         stream_done_event(true, false),
         expected_negotiated_protocol("quic/1+spdy/3"),
         cancel_from_step(NOTHING),
         read_buffer_size(32768),
         response_step(NOTHING),
         read_buffer(nullptr),
         net_error(0) {}

   ~TestBidirectionalStreamCallback() {
     if (read_buffer)
       delete read_buffer;
   }

   static TestBidirectionalStreamCallback* FromStream(
       cronet_bidirectional_stream* stream) {
     DCHECK(stream);
     return (TestBidirectionalStreamCallback*)stream->annotation;
   }

   virtual bool MaybeCancel(cronet_bidirectional_stream* stream,
                            ResponseStep step) {
     DCHECK_EQ(stream, this->stream);
     response_step = step;
     DLOG(WARNING) << "Step: " << step;

     if (step != cancel_from_step)
       return false;

     cronet_bidirectional_stream_cancel(stream);
     return true;
   }

   void SignalDone() { stream_done_event.Signal(); }

   void BlockForDone() { stream_done_event.Wait(); }

   void AddWriteData(const std::string& data) { write_data.push_back(data); }

   virtual void MaybeWriteNextData(cronet_bidirectional_stream* stream) {
     DCHECK_EQ(stream, this->stream);
     if (write_data.empty())
       return;
     cronet_bidirectional_stream_write(stream, write_data.front().c_str(),
                                       write_data.front().size(),
                                       write_data.size() == 1);
   }

   cronet_bidirectional_stream_callback* callback() const { return &s_callback; }

  private:
   // C callbacks.
   static void on_stream_ready_callback(cronet_bidirectional_stream* stream) {
     TestBidirectionalStreamCallback* test = FromStream(stream);
     if (test->MaybeCancel(stream, ON_STREAM_READY))
       return;
     test->MaybeWriteNextData(stream);
   }

   static void on_response_headers_received_callback(
       cronet_bidirectional_stream* stream,
       const cronet_bidirectional_stream_header_array* headers,
       const char* negotiated_protocol) {
     TestBidirectionalStreamCallback* test = FromStream(stream);
     ASSERT_EQ(test->expected_negotiated_protocol,
               std::string(negotiated_protocol));
     for (size_t i = 0; i < headers->count; ++i) {
       test->response_headers[headers->headers[i].key] =
           headers->headers[i].value;
     }
     if (test->MaybeCancel(stream, ON_RESPONSE_STARTED))
       return;
     test->read_buffer = new char[test->read_buffer_size];
     cronet_bidirectional_stream_read(stream, test->read_buffer,
                                      test->read_buffer_size);
   }

   static void on_read_completed_callback(cronet_bidirectional_stream* stream,
                                          char* data,
                                          int count) {
     TestBidirectionalStreamCallback* test = FromStream(stream);
     test->read_data.push_back(std::string(data, count));
     if (test->MaybeCancel(stream, ON_READ_COMPLETED))
       return;
     if (count == 0)
       return;
     cronet_bidirectional_stream_read(stream, test->read_buffer,
                                      test->read_buffer_size);
   }

   static void on_write_completed_callback(cronet_bidirectional_stream* stream,
                                           const char* data) {
     TestBidirectionalStreamCallback* test = FromStream(stream);
     ASSERT_EQ(test->write_data.front().c_str(), data);
     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] =
           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();
   }

   static void on_failed_callback(cronet_bidirectional_stream* stream,
                                  int net_error) {
     TestBidirectionalStreamCallback* test = FromStream(stream);
     test->net_error = net_error;
     test->MaybeCancel(stream, ON_FAILED);
     test->SignalDone();
   }

   static void on_canceled_callback(cronet_bidirectional_stream* stream) {
     TestBidirectionalStreamCallback* test = FromStream(stream);
     test->MaybeCancel(stream, ON_CANCELED);
     test->SignalDone();
   }

   static cronet_bidirectional_stream_callback s_callback;
 };

 cronet_bidirectional_stream_callback
     TestBidirectionalStreamCallback::s_callback = {
         on_stream_ready_callback,
         on_response_headers_received_callback,
         on_read_completed_callback,
         on_write_completed_callback,
         on_response_trailers_received_callback,
         on_succeded_callback,
         on_failed_callback,
         on_canceled_callback};

 TEST_F(CronetBidirectionalStreamTest, StartExampleBidiStream) {
   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(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(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(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(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(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];
   cronet_bidirectional_stream_read(test.stream, read_buffer,
                                    sizeof(read_buffer));
   test.BlockForDone();
   ASSERT_TRUE(test.read_data.empty());
   ASSERT_EQ(TestBidirectionalStreamCallback::ON_FAILED, test.response_step);
   ASSERT_EQ(net::ERR_UNEXPECTED, test.net_error);
   cronet_bidirectional_stream_destroy(test.stream);
 }

 TEST_F(CronetBidirectionalStreamTest,
        StreamFailBeforeReadIsExecutedOnNetworkThread) {
   class CustomTestBidirectionalStreamCallback
       : public TestBidirectionalStreamCallback {
     bool MaybeCancel(cronet_bidirectional_stream* stream,
                      ResponseStep step) override {
       if (step == ResponseStep::ON_READ_COMPLETED) {
         // Shut down the server, and the stream should error out.
         // The second call to ShutdownQuicTestServer is no-op.
         ShutdownQuicTestServer();
       }
       return TestBidirectionalStreamCallback::MaybeCancel(stream, step);
     }
   };

   CustomTestBidirectionalStreamCallback 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(TestBidirectionalStreamCallback::ON_FAILED, test.response_step);
   ASSERT_EQ(net::ERR_QUIC_PROTOCOL_ERROR, test.net_error);
   cronet_bidirectional_stream_destroy(test.stream);
 }

 TEST_F(CronetBidirectionalStreamTest, WriteFailsBeforeRequestStarted) {
   TestBidirectionalStreamCallback test;
   test.stream =
       cronet_bidirectional_stream_create(engine(), &test, test.callback());
   DCHECK(test.stream);
   cronet_bidirectional_stream_write(test.stream, "1", 1, false);
   test.BlockForDone();
   ASSERT_TRUE(test.read_data.empty());
   ASSERT_EQ(TestBidirectionalStreamCallback::ON_FAILED, test.response_step);
   ASSERT_EQ(net::ERR_UNEXPECTED, test.net_error);
   cronet_bidirectional_stream_destroy(test.stream);
 }

 TEST_F(CronetBidirectionalStreamTest,
        StreamFailBeforeWriteIsExecutedOnNetworkThread) {
   class CustomTestBidirectionalStreamCallback
       : public TestBidirectionalStreamCallback {
     bool MaybeCancel(cronet_bidirectional_stream* stream,
                      ResponseStep step) override {
       if (step == ResponseStep::ON_WRITE_COMPLETED) {
         // Shut down the server, and the stream should error out.
         // The second call to ShutdownQuicTestServer is no-op.
         ShutdownQuicTestServer();
       }
       return TestBidirectionalStreamCallback::MaybeCancel(stream, step);
     }
   };

   CustomTestBidirectionalStreamCallback test;
   test.AddWriteData("Test String");
   test.AddWriteData("1234567890");
   test.AddWriteData("woot!");
   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(TestBidirectionalStreamCallback::ON_FAILED, test.response_step);
   ASSERT_EQ(net::ERR_QUIC_PROTOCOL_ERROR, test.net_error);
   cronet_bidirectional_stream_destroy(test.stream);
 }

 TEST_F(CronetBidirectionalStreamTest, FailedResolution) {
   TestBidirectionalStreamCallback test;
   test.stream =
       cronet_bidirectional_stream_create(engine(), &test, test.callback());
   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
	// 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 {

	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.
	CronetEnvironment::Initialize();
	}

	StartQuicTestServer();

	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");

	std::unique_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(kTestServerDomain, kTestServerPort,
	kTestServerPort);

	cronet_environment_->Start();

	cronet_engine_.obj = cronet_environment_;

	cronet_environment_->StartNetLog("cronet_netlog.json", true);
	}

	void TearDown() override {
	ShutdownQuicTestServer();
	cronet_environment_->StopNetLog();
	//[CronetEngine stopNetLog];
	//[CronetEngine uninstall];
	}

	cronet_engine* engine() { return &cronet_engine_; }

	private:
	static CronetEnvironment* cronet_environment_;
	static cronet_engine cronet_engine_;
	};

	CronetEnvironment* CronetBidirectionalStreamTest::cronet_environment_;
	cronet_engine CronetBidirectionalStreamTest::cronet_engine_;

	class TestBidirectionalStreamCallback {
	public:
	enum ResponseStep {
	NOTHING,
	ON_STREAM_READY,
	ON_RESPONSE_STARTED,
	ON_READ_COMPLETED,
	ON_WRITE_COMPLETED,
	ON_TRAILERS,
	ON_CANCELED,
	ON_FAILED,
	ON_SUCCEEDED
	};

	cronet_bidirectional_stream* stream;
	base::WaitableEvent stream_done_event;

	// Test parameters.
	std::map<std::string, std::string> request_headers;
	std::list<std::string> write_data;
	std::string expected_negotiated_protocol;
	ResponseStep cancel_from_step;
	size_t read_buffer_size;

	// Test results.
	ResponseStep response_step;
	char* read_buffer;
	std::map<std::string, std::string> response_headers;
	std::map<std::string, std::string> response_trailers;
	std::vector<std::string> read_data;
	int net_error;

	TestBidirectionalStreamCallback()
	: stream(nullptr),
	stream_done_event(true, false),
	expected_negotiated_protocol("quic/1+spdy/3"),
	cancel_from_step(NOTHING),
	read_buffer_size(32768),
	response_step(NOTHING),
	read_buffer(nullptr),
	net_error(0) {}

	~TestBidirectionalStreamCallback() {
	if (read_buffer)
	delete read_buffer;
	}

	static TestBidirectionalStreamCallback* FromStream(
	cronet_bidirectional_stream* stream) {
	DCHECK(stream);
	return (TestBidirectionalStreamCallback*)stream->annotation;
	}

	virtual bool MaybeCancel(cronet_bidirectional_stream* stream,
	ResponseStep step) {
	DCHECK_EQ(stream, this->stream);
	response_step = step;
	DLOG(WARNING) << "Step: " << step;

	if (step != cancel_from_step)
	return false;

	cronet_bidirectional_stream_cancel(stream);
	return true;
	}

	void SignalDone() { stream_done_event.Signal(); }

	void BlockForDone() { stream_done_event.Wait(); }

	void AddWriteData(const std::string& data) { write_data.push_back(data); }

	virtual void MaybeWriteNextData(cronet_bidirectional_stream* stream) {
	DCHECK_EQ(stream, this->stream);
	if (write_data.empty())
	return;
	cronet_bidirectional_stream_write(stream, write_data.front().c_str(),
	write_data.front().size(),
	write_data.size() == 1);
	}

	cronet_bidirectional_stream_callback* callback() const { return &s_callback; }

	private:
	// C callbacks.
	static void on_stream_ready_callback(cronet_bidirectional_stream* stream) {
	TestBidirectionalStreamCallback* test = FromStream(stream);
	if (test->MaybeCancel(stream, ON_STREAM_READY))
	return;
	test->MaybeWriteNextData(stream);
	}

	static void on_response_headers_received_callback(
	cronet_bidirectional_stream* stream,
	const cronet_bidirectional_stream_header_array* headers,
	const char* negotiated_protocol) {
	TestBidirectionalStreamCallback* test = FromStream(stream);
	ASSERT_EQ(test->expected_negotiated_protocol,
	std::string(negotiated_protocol));
	for (size_t i = 0; i < headers->count; ++i) {
	test->response_headers[headers->headers[i].key] =
	headers->headers[i].value;
	}
	if (test->MaybeCancel(stream, ON_RESPONSE_STARTED))
	return;
	test->read_buffer = new char[test->read_buffer_size];
	cronet_bidirectional_stream_read(stream, test->read_buffer,
	test->read_buffer_size);
	}

	static void on_read_completed_callback(cronet_bidirectional_stream* stream,
	char* data,
	int count) {
	TestBidirectionalStreamCallback* test = FromStream(stream);
	test->read_data.push_back(std::string(data, count));
	if (test->MaybeCancel(stream, ON_READ_COMPLETED))
	return;
	if (count == 0)
	return;
	cronet_bidirectional_stream_read(stream, test->read_buffer,
	test->read_buffer_size);
	}

	static void on_write_completed_callback(cronet_bidirectional_stream* stream,
	const char* data) {
	TestBidirectionalStreamCallback* test = FromStream(stream);
	ASSERT_EQ(test->write_data.front().c_str(), data);
	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] =
	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();
	}

	static void on_failed_callback(cronet_bidirectional_stream* stream,
	int net_error) {
	TestBidirectionalStreamCallback* test = FromStream(stream);
	test->net_error = net_error;
	test->MaybeCancel(stream, ON_FAILED);
	test->SignalDone();
	}

	static void on_canceled_callback(cronet_bidirectional_stream* stream) {
	TestBidirectionalStreamCallback* test = FromStream(stream);
	test->MaybeCancel(stream, ON_CANCELED);
	test->SignalDone();
	}

	static cronet_bidirectional_stream_callback s_callback;
	};

	cronet_bidirectional_stream_callback
	TestBidirectionalStreamCallback::s_callback = {
	on_stream_ready_callback,
	on_response_headers_received_callback,
	on_read_completed_callback,
	on_write_completed_callback,
	on_response_trailers_received_callback,
	on_succeded_callback,
	on_failed_callback,
	on_canceled_callback};

	TEST_F(CronetBidirectionalStreamTest, StartExampleBidiStream) {
	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(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(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(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(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(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];
	cronet_bidirectional_stream_read(test.stream, read_buffer,
	sizeof(read_buffer));
	test.BlockForDone();
	ASSERT_TRUE(test.read_data.empty());
	ASSERT_EQ(TestBidirectionalStreamCallback::ON_FAILED, test.response_step);
	ASSERT_EQ(net::ERR_UNEXPECTED, test.net_error);
	cronet_bidirectional_stream_destroy(test.stream);
	}

	TEST_F(CronetBidirectionalStreamTest,
	StreamFailBeforeReadIsExecutedOnNetworkThread) {
	class CustomTestBidirectionalStreamCallback
	: public TestBidirectionalStreamCallback {
	bool MaybeCancel(cronet_bidirectional_stream* stream,
	ResponseStep step) override {
	if (step == ResponseStep::ON_READ_COMPLETED) {
	// Shut down the server, and the stream should error out.
	// The second call to ShutdownQuicTestServer is no-op.
	ShutdownQuicTestServer();
	}
	return TestBidirectionalStreamCallback::MaybeCancel(stream, step);
	}
	};

	CustomTestBidirectionalStreamCallback 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(TestBidirectionalStreamCallback::ON_FAILED, test.response_step);
	ASSERT_EQ(net::ERR_QUIC_PROTOCOL_ERROR, test.net_error);
	cronet_bidirectional_stream_destroy(test.stream);
	}

	TEST_F(CronetBidirectionalStreamTest, WriteFailsBeforeRequestStarted) {
	TestBidirectionalStreamCallback test;
	test.stream =
	cronet_bidirectional_stream_create(engine(), &test, test.callback());
	DCHECK(test.stream);
	cronet_bidirectional_stream_write(test.stream, "1", 1, false);
	test.BlockForDone();
	ASSERT_TRUE(test.read_data.empty());
	ASSERT_EQ(TestBidirectionalStreamCallback::ON_FAILED, test.response_step);
	ASSERT_EQ(net::ERR_UNEXPECTED, test.net_error);
	cronet_bidirectional_stream_destroy(test.stream);
	}

	TEST_F(CronetBidirectionalStreamTest,
	StreamFailBeforeWriteIsExecutedOnNetworkThread) {
	class CustomTestBidirectionalStreamCallback
	: public TestBidirectionalStreamCallback {
	bool MaybeCancel(cronet_bidirectional_stream* stream,
	ResponseStep step) override {
	if (step == ResponseStep::ON_WRITE_COMPLETED) {
	// Shut down the server, and the stream should error out.
	// The second call to ShutdownQuicTestServer is no-op.
	ShutdownQuicTestServer();
	}
	return TestBidirectionalStreamCallback::MaybeCancel(stream, step);
	}
	};

	CustomTestBidirectionalStreamCallback test;
	test.AddWriteData("Test String");
	test.AddWriteData("1234567890");
	test.AddWriteData("woot!");
	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(TestBidirectionalStreamCallback::ON_FAILED, test.response_step);
	ASSERT_EQ(net::ERR_QUIC_PROTOCOL_ERROR, test.net_error);
	cronet_bidirectional_stream_destroy(test.stream);
	}

	TEST_F(CronetBidirectionalStreamTest, FailedResolution) {
	TestBidirectionalStreamCallback test;
	test.stream =
	cronet_bidirectional_stream_create(engine(), &test, test.callback());
	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