Mojofy unittests related to service workers

content/browser/service_worker/service_worker_cache_writer_unittest.cc

 // Copyright 2015 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.
 
 #include "content/browser/service_worker/service_worker_cache_writer.h"
 
 #include <stddef.h>
 
 #include <list>
 #include <queue>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "content/browser/service_worker/service_worker_disk_cache.h"
+#include "content/browser/service_worker/service_worker_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 namespace {
 
 // A test implementation of ServiceWorkerResponseReader.
 //
 // This class exposes the ability to expect reads (see ExpectRead*() below).
 // Each call to ReadInfo() or ReadData() consumes another expected read, in the
 // order those reads were expected, so:
@@ skipping 366 matching lines @@
   net::Error WriteData(const std::string& data) {
     scoped_refptr<net::IOBuffer> buf = new net::StringIOBuffer(data);
     return cache_writer_->MaybeWriteData(buf.get(), data.size(),
                                          CreateWriteCallback());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerCacheWriterTest);
 };
 
+class ServiceWorkerCacheWriterTestP
+    : public MojoServiceWorkerTestP<ServiceWorkerCacheWriterTest> {};
+
 // Passthrough tests:
 // In these tests, the ServiceWorkerCacheWriter under test has no existing
 // reader, since no calls to ExpectReader() have been made; this means that
 // there is no existing cached response and the incoming data is written back to
 // the cache directly.
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughHeadersSync) {
   const size_t kHeaderSize = 16;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfoOk(kHeaderSize, false);
   Initialize();
 
   net::Error error = WriteHeaders(kHeaderSize);
   EXPECT_EQ(net::OK, error);
   EXPECT_FALSE(write_complete_);
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersAsync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughHeadersAsync) {
   size_t kHeaderSize = 16;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfoOk(kHeaderSize, true);
   Initialize();
 
   net::Error error = WriteHeaders(kHeaderSize);
   EXPECT_EQ(net::ERR_IO_PENDING, error);
   EXPECT_FALSE(write_complete_);
   writer->CompletePendingWrite();
   EXPECT_TRUE(write_complete_);
   EXPECT_EQ(net::OK, last_error_);
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughDataSync) {
   const std::string data1 = "abcdef";
   const std::string data2 = "ghijklmno";
   size_t response_size = data1.size() + data2.size();
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfoOk(response_size, false);
   writer->ExpectWriteDataOk(data1.size(), false);
   writer->ExpectWriteDataOk(data2.size(), false);
   Initialize();
 
   net::Error error = WriteHeaders(response_size);
   EXPECT_EQ(net::OK, error);
 
   error = WriteData(data1);
   EXPECT_EQ(net::OK, error);
 
   error = WriteData(data2);
   EXPECT_EQ(net::OK, error);
   EXPECT_TRUE(writer->AllExpectedWritesDone());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataAsync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughDataAsync) {
   const std::string data1 = "abcdef";
   const std::string data2 = "ghijklmno";
   size_t response_size = data1.size() + data2.size();
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfoOk(response_size, false);
   writer->ExpectWriteDataOk(data1.size(), true);
   writer->ExpectWriteDataOk(data2.size(), true);
   Initialize();
 
   net::Error error = WriteHeaders(response_size);
   EXPECT_EQ(net::OK, error);
 
   error = WriteData(data1);
   EXPECT_EQ(net::ERR_IO_PENDING, error);
   writer->CompletePendingWrite();
   EXPECT_TRUE(write_complete_);
 
   write_complete_ = false;
   error = WriteData(data2);
   EXPECT_EQ(net::ERR_IO_PENDING, error);
   writer->CompletePendingWrite();
   EXPECT_TRUE(write_complete_);
   EXPECT_EQ(net::OK, last_error_);
   EXPECT_TRUE(writer->AllExpectedWritesDone());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersFailSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughHeadersFailSync) {
   const size_t kHeaderSize = 16;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfo(kHeaderSize, false, net::ERR_FAILED);
   Initialize();
 
   net::Error error = WriteHeaders(kHeaderSize);
   EXPECT_EQ(net::ERR_FAILED, error);
   EXPECT_FALSE(write_complete_);
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughHeadersFailAsync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughHeadersFailAsync) {
   size_t kHeaderSize = 16;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfo(kHeaderSize, true, net::ERR_FAILED);
   Initialize();
 
   net::Error error = WriteHeaders(kHeaderSize);
   EXPECT_EQ(net::ERR_IO_PENDING, error);
   EXPECT_FALSE(write_complete_);
   writer->CompletePendingWrite();
   EXPECT_TRUE(write_complete_);
   EXPECT_EQ(net::ERR_FAILED, last_error_);
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataFailSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughDataFailSync) {
   const std::string data = "abcdef";
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfoOk(data.size(), false);
   writer->ExpectWriteData(data.size(), false, net::ERR_FAILED);
   Initialize();
 
   EXPECT_EQ(net::OK, WriteHeaders(data.size()));
   EXPECT_EQ(net::ERR_FAILED, WriteData(data));
   EXPECT_TRUE(writer->AllExpectedWritesDone());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, PassthroughDataFailAsync) {
+TEST_P(ServiceWorkerCacheWriterTestP, PassthroughDataFailAsync) {
   const std::string data = "abcdef";
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   writer->ExpectWriteInfoOk(data.size(), false);
   writer->ExpectWriteData(data.size(), true, net::ERR_FAILED);
   Initialize();
 
   EXPECT_EQ(net::OK, WriteHeaders(data.size()));
 
   EXPECT_EQ(net::ERR_IO_PENDING, WriteData(data));
   writer->CompletePendingWrite();
   EXPECT_EQ(net::ERR_FAILED, last_error_);
   EXPECT_TRUE(write_complete_);
   EXPECT_TRUE(writer->AllExpectedWritesDone());
 }
 
 // Comparison tests:
 // For the Compare* tests below, the ServiceWorkerCacheWriter under test has a
 // reader for an existing cached response, so it will compare the response being
 // written to it against the existing cached response.
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareHeadersSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareHeadersSync) {
   size_t response_size = 3;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   MockServiceWorkerResponseReader* reader = ExpectReader();
 
   reader->ExpectReadInfoOk(response_size, false);
   Initialize();
 
   net::Error error = WriteHeaders(response_size);
   EXPECT_EQ(net::OK, error);
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_TRUE(reader->AllExpectedReadsDone());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareDataOkSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareDataOkSync) {
   const std::string data1 = "abcdef";
   size_t response_size = data1.size();
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   MockServiceWorkerResponseReader* reader = ExpectReader();
 
   reader->ExpectReadInfoOk(response_size, false);
   reader->ExpectReadDataOk(data1, false);
   Initialize();
 
   net::Error error = WriteHeaders(response_size);
   EXPECT_EQ(net::OK, error);
 
   error = WriteData(data1);
   EXPECT_EQ(net::OK, error);
 
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_TRUE(reader->AllExpectedReadsDone());
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareHeadersFailSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareHeadersFailSync) {
   size_t response_size = 3;
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   MockServiceWorkerResponseReader* reader = ExpectReader();
 
   reader->ExpectReadInfo(response_size, false, net::ERR_FAILED);
   Initialize();
 
   EXPECT_EQ(net::ERR_FAILED, WriteHeaders(response_size));
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_TRUE(reader->AllExpectedReadsDone());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareDataFailSync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareDataFailSync) {
   const std::string data1 = "abcdef";
   size_t response_size = data1.size();
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   MockServiceWorkerResponseReader* reader = ExpectReader();
 
   reader->ExpectReadInfoOk(response_size, false);
   reader->ExpectReadData(data1.c_str(), data1.length(), false, net::ERR_FAILED);
   Initialize();
 
   net::Error error = WriteHeaders(response_size);
   EXPECT_EQ(net::OK, error);
 
   EXPECT_EQ(net::ERR_FAILED, WriteData(data1));
 
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_TRUE(reader->AllExpectedReadsDone());
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareShortCacheReads) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareShortCacheReads) {
   const size_t kHeaderSize = 16;
   const std::string& data1 = "abcdef";
   const std::string& cache_data2 = "ghi";
   const std::string& cache_data3 = "j";
   const std::string& cache_data4 = "kl";
   const std::string& net_data2 = "ghijkl";
   const std::string& data5 = "mnopqrst";
 
   MockServiceWorkerResponseReader* reader = ExpectReader();
   reader->ExpectReadInfo(kHeaderSize, false, kHeaderSize);
   reader->ExpectReadDataOk(data1, false);
   reader->ExpectReadDataOk(cache_data2, false);
   reader->ExpectReadDataOk(cache_data3, false);
   reader->ExpectReadDataOk(cache_data4, false);
   reader->ExpectReadDataOk(data5, false);
   Initialize();
 
   net::Error error = WriteHeaders(kHeaderSize);
   EXPECT_EQ(net::OK, error);
   error = WriteData(data1);
   EXPECT_EQ(net::OK, error);
   error = WriteData(net_data2);
   EXPECT_EQ(net::OK, error);
   error = WriteData(data5);
   EXPECT_EQ(net::OK, error);
   EXPECT_TRUE(reader->AllExpectedReadsDone());
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareDataOkAsync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareDataOkAsync) {
   const std::string data1 = "abcdef";
   size_t response_size = data1.size();
 
   MockServiceWorkerResponseReader* reader = ExpectReader();
 
   reader->ExpectReadInfoOk(response_size, true);
   reader->ExpectReadDataOk(data1, true);
   Initialize();
 
   net::Error error = WriteHeaders(response_size);
   EXPECT_EQ(net::ERR_IO_PENDING, error);
   reader->CompletePendingRead();
 
   error = WriteData(data1);
   EXPECT_EQ(net::ERR_IO_PENDING, error);
   reader->CompletePendingRead();
 
   EXPECT_TRUE(reader->AllExpectedReadsDone());
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
-TEST_F(ServiceWorkerCacheWriterTest, CompareDataManyOkAsync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareDataManyOkAsync) {
   const std::string expected_data[] = {
       "abcdef", "ghijkl", "mnopqr", "stuvwxyz",
   };
   size_t response_size = 0;
   for (size_t i = 0; i < arraysize(expected_data); ++i)
     response_size += expected_data[i].size();
 
   MockServiceWorkerResponseReader* reader = ExpectReader();
 
   reader->ExpectReadInfoOk(response_size, true);
@@ skipping 14 matching lines @@
   }
 
   EXPECT_TRUE(reader->AllExpectedReadsDone());
   EXPECT_EQ(0U, cache_writer_->bytes_written());
 }
 
 // This test writes headers and three data blocks data1, data2, data3; data2
 // differs in the cached version. The writer should be asked to rewrite the
 // headers and body with the new value, and the copy reader should be asked to
 // read the header and data1.
-TEST_F(ServiceWorkerCacheWriterTest, CompareFailedCopySync) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareFailedCopySync) {
   std::string data1 = "abcdef";
   std::string cache_data2 = "ghijkl";
   std::string net_data2 = "mnopqr";
   std::string data3 = "stuvwxyz";
   size_t cache_response_size = data1.size() + cache_data2.size() + data3.size();
   size_t net_response_size = data1.size() + net_data2.size() + data3.size();
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   MockServiceWorkerResponseReader* compare_reader = ExpectReader();
   MockServiceWorkerResponseReader* copy_reader = ExpectReader();
@@ skipping 20 matching lines @@
   EXPECT_EQ(net::OK, error);
   error = WriteData(data3);
   EXPECT_EQ(net::OK, error);
 
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_TRUE(compare_reader->AllExpectedReadsDone());
   EXPECT_TRUE(copy_reader->AllExpectedReadsDone());
 }
 
 // Tests behavior when the cached data is shorter than the network data.
-TEST_F(ServiceWorkerCacheWriterTest, CompareFailedCopyShort) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareFailedCopyShort) {
   std::string data1 = "abcdef";
   std::string cache_data2 = "mnop";
   std::string net_data2 = "mnopqr";
   std::string data3 = "stuvwxyz";
   size_t cache_response_size = data1.size() + cache_data2.size() + data3.size();
   size_t net_response_size = data1.size() + net_data2.size() + data3.size();
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   MockServiceWorkerResponseReader* compare_reader = ExpectReader();
   MockServiceWorkerResponseReader* copy_reader = ExpectReader();
@@ skipping 21 matching lines @@
   EXPECT_EQ(net::OK, error);
   error = WriteData(data3);
   EXPECT_EQ(net::OK, error);
 
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_TRUE(compare_reader->AllExpectedReadsDone());
   EXPECT_TRUE(copy_reader->AllExpectedReadsDone());
 }
 
 // Tests behavior when the cached data is longer than the network data.
-TEST_F(ServiceWorkerCacheWriterTest, CompareFailedCopyLong) {
+TEST_P(ServiceWorkerCacheWriterTestP, CompareFailedCopyLong) {
   std::string data1 = "abcdef";
   std::string cache_data2 = "mnop";
   std::string net_data2 = "mnop";
   std::string cache_data3 = "qr";
   size_t cached_size = data1.size() + cache_data2.size() + cache_data3.size();
   size_t net_size = data1.size() + net_data2.size();
 
   MockServiceWorkerResponseWriter* writer = ExpectWriter();
   MockServiceWorkerResponseReader* compare_reader = ExpectReader();
   MockServiceWorkerResponseReader* copy_reader = ExpectReader();
@@ skipping 22 matching lines @@
   error = WriteData(net_data2);
   EXPECT_EQ(net::OK, error);
   error = WriteData("");
   EXPECT_EQ(net::OK, error);
 
   EXPECT_TRUE(writer->AllExpectedWritesDone());
   EXPECT_TRUE(compare_reader->AllExpectedReadsDone());
   EXPECT_TRUE(copy_reader->AllExpectedReadsDone());
 }
 
+INSTANTIATE_TEST_CASE_P(ServiceWorkerCacheWriterTest,
+                        ServiceWorkerCacheWriterTestP,
+                        testing::Bool());
+
 }  // namespace
 }  // namespace content