Index: content/child/blob_storage/blob_transport_controller_unittest.cc |
diff --git a/content/child/blob_storage/blob_transport_controller_unittest.cc b/content/child/blob_storage/blob_transport_controller_unittest.cc |
index 08120fcaca7c23a4809d5c3410fbaed9240baf77..33d2d996b82589199e7d5454081e366925d1ba1c 100644 |
--- a/content/child/blob_storage/blob_transport_controller_unittest.cc |
+++ b/content/child/blob_storage/blob_transport_controller_unittest.cc |
@@ -7,13 +7,22 @@ |
#include <stddef.h> |
#include <stdint.h> |
-#include "base/memory/ptr_util.h" |
+#include "base/bind.h" |
+#include "base/bind_helpers.h" |
+#include "base/files/file.h" |
+#include "base/files/file_path.h" |
+#include "base/files/file_util.h" |
#include "base/memory/shared_memory.h" |
+#include "base/message_loop/message_loop.h" |
+#include "base/process/process_handle.h" |
+#include "base/test/test_file_util.h" |
#include "base/test/test_simple_task_runner.h" |
#include "base/tuple.h" |
#include "content/child/blob_storage/blob_consolidation.h" |
#include "content/child/thread_safe_sender.h" |
#include "content/common/fileapi/webblob_messages.h" |
+#include "ipc/ipc_message.h" |
+#include "ipc/ipc_platform_file.h" |
#include "ipc/ipc_sender.h" |
#include "ipc/ipc_sync_message_filter.h" |
#include "ipc/ipc_test_sink.h" |
@@ -22,9 +31,13 @@ |
#include "testing/gmock/include/gmock/gmock.h" |
#include "testing/gtest/include/gtest/gtest.h" |
+using base::File; |
+using base::FilePath; |
+using base::TestSimpleTaskRunner; |
using storage::BlobItemBytesRequest; |
using storage::BlobItemBytesResponse; |
using storage::DataElement; |
+using storage::IPCBlobCreationCancelCode; |
namespace content { |
namespace { |
@@ -87,15 +100,59 @@ static blink::WebThreadSafeData CreateData(const std::string& str) { |
class BlobTransportControllerTest : public testing::Test { |
public: |
- BlobTransportControllerTest() |
- : io_thread_runner_(new base::TestSimpleTaskRunner()), |
- main_thread_runner_(new OtherThreadTestSimpleTaskRunner()) {} |
+ BlobTransportControllerTest() {} |
void SetUp() override { |
sender_ = new BlobTransportControllerTestSender(&sink_); |
BlobTransportController::GetInstance()->ClearForTesting(); |
} |
+ BlobTransportController::ResponsesStatus GetResponses( |
+ BlobTransportController* holder, |
+ const std::string& uuid, |
+ const std::vector<BlobItemBytesRequest>& requests, |
+ std::vector<base::SharedMemoryHandle>* memory_handles, |
+ const std::vector<IPC::PlatformFileForTransit>& file_handles, |
+ std::vector<BlobItemBytesResponse>* output) { |
+ error_called_ = false; |
+ all_async_responses_.clear(); |
+ return holder->GetResponses( |
+ uuid, requests, memory_handles, file_handles, output, io_thread_runner_, |
+ file_runner_.get(), |
+ base::Bind(&BlobTransportControllerTest::ResponsesCallback, |
+ base::Unretained(this)), |
+ base::Bind(&BlobTransportControllerTest::ErrorCallback, |
+ base::Unretained(this))); |
+ } |
+ |
+ void OnMemoryRequest( |
+ BlobTransportController* holder, |
+ const std::string uuid, |
+ const std::vector<storage::BlobItemBytesRequest>& requests) { |
+ std::vector<base::SharedMemoryHandle> memory_handles; |
+ std::vector<IPC::PlatformFileForTransit> file_handles; |
+ holder->OnMemoryRequest(uuid, requests, &memory_handles, file_handles, |
+ io_thread_runner_, file_runner_.get(), |
+ base::Bind(&BlobTransportControllerTest::SendIPC, |
+ base::Unretained(this))); |
+ } |
+ |
+ bool AsyncOperationsCalled() { |
+ return error_called_ || !all_async_responses_.empty(); |
+ } |
+ |
+ bool AsyncOperationsPending() { |
+ return io_thread_runner_->HasPendingTask() || |
+ file_runner_->HasPendingTask(); |
+ } |
+ |
+ FilePath CreateTemporaryFile() { |
+ FilePath path; |
+ EXPECT_TRUE(base::CreateTemporaryFile(&path)); |
+ files_opened_.push_back(path); |
+ return path; |
+ } |
+ |
void ExpectRegisterAndStartMessage(const std::string& expected_uuid, |
const std::string& expected_content_type, |
std::vector<DataElement>* descriptions) { |
@@ -119,14 +176,58 @@ class BlobTransportControllerTest : public testing::Test { |
EXPECT_TRUE(base::get<2>(register_contents).empty()); |
} |
+ void ExpectMemoryResponses( |
+ const std::string& expected_uuid, |
+ std::vector<storage::BlobItemBytesResponse> expected_responses) { |
+ const IPC::Message* responses_message = |
+ sink_.GetUniqueMessageMatching(BlobStorageMsg_MemoryItemResponse::ID); |
+ ASSERT_TRUE(responses_message); |
+ base::Tuple<std::string, std::vector<storage::BlobItemBytesResponse>> |
+ responses_content; |
+ BlobStorageMsg_MemoryItemResponse::Read(responses_message, |
+ &responses_content); |
+ EXPECT_EQ(expected_uuid, base::get<0>(responses_content)); |
+ EXPECT_EQ(expected_responses, base::get<1>(responses_content)); |
+ } |
+ |
void TearDown() override { |
BlobTransportController::GetInstance()->ClearForTesting(); |
+ for (const FilePath& path : files_opened_) { |
+ EXPECT_TRUE(base::DeleteFile(path, false)); |
+ } |
+ } |
+ |
+ protected: |
+ void ResponsesCallback(const std::vector<BlobItemBytesResponse>& responses) { |
+ all_async_responses_.insert(all_async_responses_.end(), responses.begin(), |
+ responses.end()); |
} |
+ void ErrorCallback(IPCBlobCreationCancelCode code) { |
+ error_code_ = code; |
+ error_called_ = true; |
+ } |
+ |
+ void SendIPC(std::unique_ptr<IPC::Message> message) { |
+ sink_.Send(message.release()); |
+ } |
+ |
+ bool error_called_ = false; |
+ IPCBlobCreationCancelCode error_code_ = IPCBlobCreationCancelCode::UNKNOWN; |
+ std::vector<storage::BlobItemBytesResponse> all_async_responses_; |
+ std::vector<FilePath> files_opened_; |
+ |
IPC::TestSink sink_; |
scoped_refptr<BlobTransportControllerTestSender> sender_; |
- scoped_refptr<base::TestSimpleTaskRunner> io_thread_runner_; |
- scoped_refptr<OtherThreadTestSimpleTaskRunner> main_thread_runner_; |
+ |
+ // Thread runners. |
+ scoped_refptr<base::TestSimpleTaskRunner> io_thread_runner_ = |
+ new TestSimpleTaskRunner(); |
+ scoped_refptr<base::TestSimpleTaskRunner> file_thread_runner_ = |
+ new TestSimpleTaskRunner(); |
+ scoped_refptr<OtherThreadTestSimpleTaskRunner> main_thread_runner_ = |
+ new OtherThreadTestSimpleTaskRunner(); |
+ scoped_refptr<TestSimpleTaskRunner> file_runner_ = new TestSimpleTaskRunner(); |
}; |
TEST_F(BlobTransportControllerTest, Descriptions) { |
@@ -136,7 +237,7 @@ TEST_F(BlobTransportControllerTest, Descriptions) { |
const size_t kShortcutSize = 11; |
// The first two data elements should be combined and the data shortcut. |
- std::unique_ptr<BlobConsolidation> consolidation(new BlobConsolidation()); |
+ scoped_refptr<BlobConsolidation> consolidation(new BlobConsolidation()); |
consolidation->AddBlobItem(KRefBlobUUID, 10, 10); |
consolidation->AddDataItem(CreateData("Hello")); |
consolidation->AddDataItem(CreateData("Hello2")); |
@@ -163,7 +264,7 @@ TEST_F(BlobTransportControllerTest, Responses) { |
BlobTransportController* holder = BlobTransportController::GetInstance(); |
// The first two data elements should be combined. |
- BlobConsolidation* consolidation = new BlobConsolidation(); |
+ scoped_refptr<BlobConsolidation> consolidation = new BlobConsolidation(); |
consolidation->AddBlobItem(KRefBlobUUID, 10, 10); |
consolidation->AddDataItem(CreateData("Hello")); |
consolidation->AddDataItem(CreateData("Hello2")); |
@@ -171,7 +272,7 @@ TEST_F(BlobTransportControllerTest, Responses) { |
consolidation->AddDataItem(CreateData("Hello3")); |
// See the above test for the expected descriptions layout. |
- holder->blob_storage_[kBlobUUID] = base::WrapUnique(consolidation); |
+ holder->blob_storage_[kBlobUUID] = consolidation; |
std::vector<BlobItemBytesRequest> requests; |
std::vector<base::SharedMemoryHandle> memory_handles; |
@@ -181,8 +282,9 @@ TEST_F(BlobTransportControllerTest, Responses) { |
// Request for all of first data |
requests.push_back(BlobItemBytesRequest::CreateIPCRequest(0, 1, 0, 11)); |
EXPECT_EQ(ResponsesStatus::SUCCESS, |
- holder->GetResponses(kBlobUUID, requests, &memory_handles, |
- file_handles, &output)); |
+ GetResponses(holder, kBlobUUID, requests, &memory_handles, |
+ file_handles, &output)); |
+ EXPECT_FALSE(AsyncOperationsPending()); |
EXPECT_EQ(1u, output.size()); |
std::vector<storage::BlobItemBytesResponse> expected; |
expected.push_back(ResponseWithData(0, "HelloHello2")); |
@@ -192,8 +294,9 @@ TEST_F(BlobTransportControllerTest, Responses) { |
output.clear(); |
requests[0] = BlobItemBytesRequest::CreateIPCRequest(1000, 3, 1, 5); |
EXPECT_EQ(ResponsesStatus::SUCCESS, |
- holder->GetResponses(kBlobUUID, requests, &memory_handles, |
- file_handles, &output)); |
+ GetResponses(holder, kBlobUUID, requests, &memory_handles, |
+ file_handles, &output)); |
+ EXPECT_FALSE(AsyncOperationsPending()); |
EXPECT_EQ(1u, output.size()); |
expected.clear(); |
expected.push_back(ResponseWithData(1000, "ello3")); |
@@ -204,8 +307,9 @@ TEST_F(BlobTransportControllerTest, Responses) { |
requests[0] = BlobItemBytesRequest::CreateIPCRequest(0, 1, 0, 11); |
requests.push_back(BlobItemBytesRequest::CreateIPCRequest(1, 3, 0, 6)); |
EXPECT_EQ(ResponsesStatus::SUCCESS, |
- holder->GetResponses(kBlobUUID, requests, &memory_handles, |
- file_handles, &output)); |
+ GetResponses(holder, kBlobUUID, requests, &memory_handles, |
+ file_handles, &output)); |
+ EXPECT_FALSE(AsyncOperationsPending()); |
EXPECT_EQ(2u, output.size()); |
expected.clear(); |
expected.push_back(ResponseWithData(0, "HelloHello2")); |
@@ -221,7 +325,7 @@ TEST_F(BlobTransportControllerTest, SharedMemory) { |
BlobTransportController* holder = BlobTransportController::GetInstance(); |
// The first two data elements should be combined. |
- BlobConsolidation* consolidation = new BlobConsolidation(); |
+ scoped_refptr<BlobConsolidation> consolidation = new BlobConsolidation(); |
consolidation->AddBlobItem(KRefBlobUUID, 10, 10); |
consolidation->AddDataItem(CreateData("Hello")); |
consolidation->AddDataItem(CreateData("Hello2")); |
@@ -229,7 +333,7 @@ TEST_F(BlobTransportControllerTest, SharedMemory) { |
consolidation->AddDataItem(CreateData("Hello3")); |
// See the above test for the expected descriptions layout. |
- holder->blob_storage_[kBlobUUID] = base::WrapUnique(consolidation); |
+ holder->blob_storage_[kBlobUUID] = consolidation; |
std::vector<BlobItemBytesRequest> requests; |
std::vector<base::SharedMemoryHandle> memory_handles; |
@@ -249,8 +353,9 @@ TEST_F(BlobTransportControllerTest, SharedMemory) { |
memory_handles.push_back(handle); |
EXPECT_EQ(ResponsesStatus::SUCCESS, |
- holder->GetResponses(kBlobUUID, requests, &memory_handles, |
- file_handles, &output)); |
+ GetResponses(holder, kBlobUUID, requests, &memory_handles, |
+ file_handles, &output)); |
+ EXPECT_FALSE(AsyncOperationsPending()); |
EXPECT_EQ(2u, output.size()); |
std::vector<storage::BlobItemBytesResponse> expected; |
expected.push_back(BlobItemBytesResponse(0)); |
@@ -263,6 +368,79 @@ TEST_F(BlobTransportControllerTest, SharedMemory) { |
expected_memory.size())); |
} |
+TEST_F(BlobTransportControllerTest, Disk) { |
+ using ResponsesStatus = BlobTransportController::ResponsesStatus; |
+ const std::string kBlobUUID = "uuid"; |
+ const std::string KRefBlobUUID = "refuuid"; |
+ const std::string kBadBlobUUID = "uuuidBad"; |
+ BlobTransportController* holder = BlobTransportController::GetInstance(); |
+ FilePath path1 = CreateTemporaryFile(); |
+ File file(path1, File::FLAG_OPEN | File::FLAG_WRITE | File::FLAG_READ); |
+ ASSERT_TRUE(file.IsValid()); |
+ ASSERT_TRUE(file.SetLength(11 + 6)); |
+ // The first two data elements should be combined. |
+ scoped_refptr<BlobConsolidation> consolidation(new BlobConsolidation()); |
+ consolidation->AddBlobItem(KRefBlobUUID, 10, 10); |
+ consolidation->AddDataItem(CreateData("Hello")); |
+ consolidation->AddDataItem(CreateData("Hello2")); |
+ consolidation->AddBlobItem(KRefBlobUUID, 0, 10); |
+ consolidation->AddDataItem(CreateData("Hello3")); |
+ // See the above test for the expected descriptions layout. |
+ holder->blob_storage_[kBlobUUID] = consolidation; |
+ std::vector<BlobItemBytesRequest> requests; |
+ std::vector<base::SharedMemoryHandle> memory_handles; |
+ std::vector<IPC::PlatformFileForTransit> file_handles; |
+ std::vector<storage::BlobItemBytesResponse> output; |
+ // Request for all data in shared memory |
+ requests.push_back( |
+ BlobItemBytesRequest::CreateFileRequest(0, 1, 0, 11, 0, 0)); |
+ requests.push_back( |
+ BlobItemBytesRequest::CreateFileRequest(1, 3, 0, 6, 0, 11)); |
+ file_handles.push_back(IPC::TakePlatformFileForTransit(std::move(file))); |
+ EXPECT_EQ(ResponsesStatus::PENDING_IO, |
+ GetResponses(holder, kBlobUUID, requests, &memory_handles, |
+ file_handles, &output)); |
+ EXPECT_TRUE(file_runner_->HasPendingTask()); |
+ EXPECT_FALSE(io_thread_runner_->HasPendingTask()); |
+ EXPECT_FALSE(AsyncOperationsCalled()); |
+ file_runner_->RunPendingTasks(); |
+ EXPECT_FALSE(file_runner_->HasPendingTask()); |
+ EXPECT_TRUE(io_thread_runner_->HasPendingTask()); |
+ EXPECT_FALSE(AsyncOperationsCalled()); |
+ io_thread_runner_->RunPendingTasks(); |
+ EXPECT_TRUE(AsyncOperationsCalled()); |
+ EXPECT_EQ(0u, output.size()); |
+ EXPECT_EQ(2u, all_async_responses_.size()); |
+ std::vector<storage::BlobItemBytesResponse> expected = { |
+ BlobItemBytesResponse(0), BlobItemBytesResponse(1)}; |
+ EXPECT_EQ(expected, all_async_responses_); |
+ std::string expected_memory = "HelloHello2Hello3"; |
+ file = IPC::PlatformFileForTransitToFile(file_handles[0]); |
+ file_handles.clear(); |
+ char data[11 + 6]; |
+ file.Read(0, data, 11 + 6); |
+ std::vector<char> value(data, data + 11 + 6); |
+ EXPECT_THAT(value, testing::ElementsAreArray(expected_memory.c_str(), |
+ expected_memory.size())); |
+ |
+ // Finally, test that we get errors correctly. |
+ FilePath path2 = CreateTemporaryFile(); |
+ EXPECT_TRUE(base::MakeFileUnwritable(path2)); |
+ File file2(path2, File::FLAG_OPEN | File::FLAG_WRITE); |
+ EXPECT_FALSE(file2.IsValid()); |
+ file_handles.push_back(IPC::TakePlatformFileForTransit(std::move(file2))); |
+ EXPECT_EQ(ResponsesStatus::PENDING_IO, |
+ GetResponses(holder, kBlobUUID, requests, &memory_handles, |
+ file_handles, &output)); |
+ EXPECT_FALSE(AsyncOperationsCalled()); |
+ file_runner_->RunPendingTasks(); |
+ io_thread_runner_->RunPendingTasks(); |
+ EXPECT_TRUE(AsyncOperationsCalled()); |
+ EXPECT_EQ(0u, all_async_responses_.size()); |
+ EXPECT_TRUE(error_called_); |
+ EXPECT_EQ(IPCBlobCreationCancelCode::FILE_WRITE_FAILED, error_code_); |
+} |
+ |
TEST_F(BlobTransportControllerTest, TestPublicMethods) { |
const std::string kBlobUUID = "uuid"; |
const std::string kBlobContentType = "content_type"; |
@@ -272,10 +450,10 @@ TEST_F(BlobTransportControllerTest, TestPublicMethods) { |
std::vector<DataElement> message_descriptions; |
BlobTransportController* holder = BlobTransportController::GetInstance(); |
- BlobConsolidation* consolidation = new BlobConsolidation(); |
+ scoped_refptr<BlobConsolidation> consolidation = new BlobConsolidation(); |
consolidation->AddBlobItem(KRefBlobUUID, 10, 10); |
BlobTransportController::InitiateBlobTransfer( |
- kBlobUUID, kBlobContentType, base::WrapUnique(consolidation), sender_, |
+ kBlobUUID, kBlobContentType, consolidation, sender_, |
io_thread_runner_.get(), main_thread_runner_); |
// Check that we have the 'increase ref' pending task. |
EXPECT_TRUE(main_thread_runner_->HasPendingTask()); |
@@ -290,11 +468,9 @@ TEST_F(BlobTransportControllerTest, TestPublicMethods) { |
EXPECT_FALSE(holder->IsTransporting(kBlobUUID)); |
io_thread_runner_->RunPendingTasks(); |
EXPECT_TRUE(holder->IsTransporting(kBlobUUID)); |
- base::Tuple<std::string, std::vector<DataElement>> message_contents; |
EXPECT_EQ(MakeBlobElement(KRefBlobUUID, 10, 10), message_descriptions[0]); |
- holder->OnCancel(kBlobUUID, |
- storage::IPCBlobCreationCancelCode::OUT_OF_MEMORY); |
+ holder->OnCancel(kBlobUUID, IPCBlobCreationCancelCode::OUT_OF_MEMORY); |
EXPECT_FALSE(holder->IsTransporting(kBlobUUID)); |
// Check we have the 'decrease ref' task. |
EXPECT_TRUE(main_thread_runner_->HasPendingTask()); |
@@ -302,10 +478,10 @@ TEST_F(BlobTransportControllerTest, TestPublicMethods) { |
sink_.ClearMessages(); |
// Add the second. |
- BlobConsolidation* consolidation2 = new BlobConsolidation(); |
+ scoped_refptr<BlobConsolidation> consolidation2 = new BlobConsolidation(); |
consolidation2->AddBlobItem(KRefBlobUUID, 10, 10); |
BlobTransportController::InitiateBlobTransfer( |
- kBlob2UUID, kBlob2ContentType, base::WrapUnique(consolidation2), sender_, |
+ kBlob2UUID, kBlob2ContentType, consolidation2, sender_, |
io_thread_runner_.get(), main_thread_runner_); |
EXPECT_TRUE(main_thread_runner_->HasPendingTask()); |
main_thread_runner_->ClearPendingTasks(); |
@@ -321,6 +497,52 @@ TEST_F(BlobTransportControllerTest, TestPublicMethods) { |
main_thread_runner_->ClearPendingTasks(); |
} |
+TEST_F(BlobTransportControllerTest, TestMemoryResponsesPublicMethod) { |
+ const std::string kBlobUUID = "uuid"; |
+ const std::string kBlobContentType = "content_type"; |
+ const std::string kData = "HelloHello2Hello3"; |
+ const int kDataSize = 17; |
+ // Here we test that we receive data responses when we request them. |
+ BlobTransportController* holder = BlobTransportController::GetInstance(); |
+ |
+ scoped_refptr<BlobConsolidation> consolidation(new BlobConsolidation()); |
+ // These items should be combined. |
+ consolidation->AddDataItem(CreateData("Hello")); |
+ consolidation->AddDataItem(CreateData("Hello2")); |
+ consolidation->AddDataItem(CreateData("Hello3")); |
+ std::vector<DataElement> message_descriptions; |
michaeln
2016/04/21 01:58:41
maybe move this down to just above where its first
dmurph
2016/04/22 22:37:10
Done.
|
+ BlobTransportController::InitiateBlobTransfer( |
+ kBlobUUID, kBlobContentType, consolidation, sender_, |
+ io_thread_runner_.get(), main_thread_runner_); |
+ // Check that we have the 'increase ref' pending task. |
+ EXPECT_TRUE(main_thread_runner_->HasPendingTask()); |
+ // Check that we have the 'store' pending task. |
+ EXPECT_TRUE(io_thread_runner_->HasPendingTask()); |
+ // Check that we've sent the data. |
+ ExpectRegisterAndStartMessage(kBlobUUID, kBlobContentType, |
+ &message_descriptions); |
+ main_thread_runner_->ClearPendingTasks(); |
+ |
+ // Check that we got the correct start message. |
+ EXPECT_FALSE(holder->IsTransporting(kBlobUUID)); |
+ io_thread_runner_->RunPendingTasks(); |
+ EXPECT_TRUE(holder->IsTransporting(kBlobUUID)); |
+ ASSERT_EQ(1u, message_descriptions.size()); |
+ EXPECT_EQ(MakeDataElement("HelloHello2Hello3"), message_descriptions[0]); |
+ |
+ // Now we request the memory. |
+ std::vector<BlobItemBytesRequest> requests; |
+ requests.push_back( |
+ BlobItemBytesRequest::CreateIPCRequest(0, 0, 0, kDataSize)); |
+ OnMemoryRequest(holder, kBlobUUID, requests); |
+ |
+ std::vector<BlobItemBytesResponse> expected_responses; |
+ BlobItemBytesResponse expected(0); |
+ expected.inline_data = std::vector<char>(kData.begin(), kData.end()); |
+ expected_responses.push_back(expected); |
+ ExpectMemoryResponses(kBlobUUID, expected_responses); |
+} |
+ |
TEST_F(BlobTransportControllerTest, ResponsesErrors) { |
using ResponsesStatus = BlobTransportController::ResponsesStatus; |
const std::string kBlobUUID = "uuid"; |
@@ -328,10 +550,10 @@ TEST_F(BlobTransportControllerTest, ResponsesErrors) { |
const std::string kBadBlobUUID = "uuuidBad"; |
BlobTransportController* holder = BlobTransportController::GetInstance(); |
- BlobConsolidation* consolidation = new BlobConsolidation(); |
+ scoped_refptr<BlobConsolidation> consolidation = new BlobConsolidation(); |
consolidation->AddBlobItem(KRefBlobUUID, 10, 10); |
- holder->blob_storage_[kBlobUUID] = base::WrapUnique(consolidation); |
+ holder->blob_storage_[kBlobUUID] = consolidation; |
std::vector<BlobItemBytesRequest> requests; |
std::vector<base::SharedMemoryHandle> memory_handles; |
@@ -340,8 +562,9 @@ TEST_F(BlobTransportControllerTest, ResponsesErrors) { |
// Error conditions |
EXPECT_EQ(ResponsesStatus::BLOB_NOT_FOUND, |
- holder->GetResponses(kBadBlobUUID, requests, &memory_handles, |
- file_handles, &output)); |
+ GetResponses(holder, kBadBlobUUID, requests, &memory_handles, |
+ file_handles, &output)); |
+ EXPECT_FALSE(AsyncOperationsPending()); |
EXPECT_EQ(0u, output.size()); |
} |