[i18n streaming] improve unit tests

content/browser/webui/i18n_source_stream_unittest.cc

 // 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.
 
 #include <utility>
 
 #include "content/browser/webui/i18n_source_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/test_completion_callback.h"
 #include "net/filter/mock_source_stream.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
-// These constants are rather arbitrary, though the offsets and other sizes must
+// This constant is rather arbitrary, though the offsets and other sizes must
 // be less than kBufferSize.
 const int kBufferSize = 256;
-const int kSmallBufferSize = 1;
 
-const int kShortReplacementOffset = 5;
-const char kShortReplacementKey[] = "a";
-const char kShortReplacementToken[] = "$i18n{a}";
-const char kShortReplacementValue[] = "short";
+const int kMinimumSize = 1;
+const int kSmallSize = 5;  // Arbitrary small value > 1.
+const int kInOneReadSize = INT_MAX;
 
-const int kLongReplacementOffset = 33;
-const char kLongReplacementKey[] = "aLongerReplacementName";
-const char kLongReplacementToken[] = "$i18n{aLongerReplacementName}";
-const char kLongReplacementValue[] = "second replacement";
+struct I18nTest {
+  constexpr I18nTest(const char* input, const char* expected_output)
+      : input(input), expected_output(expected_output) {}
 
-const int kSourceSize =
-    50 + arraysize(kShortReplacementToken) + arraysize(kLongReplacementToken);
-const int kResultSize =
-    50 + arraysize(kShortReplacementValue) + arraysize(kLongReplacementValue);
+  const char* input;
+  const char* expected_output;
+};
+
+constexpr I18nTest kTestEmpty = I18nTest("", "");
+
+constexpr I18nTest kTestNoReplacements =
+    I18nTest("This text has no i18n replacements.",
+             "This text has no i18n replacements.");
+
+constexpr I18nTest kTestTagAtEndOfLine =
+    I18nTest("test with tag at end of line $",
+             "test with tag at end of line $");
+
+constexpr I18nTest kTestOneReplacement = I18nTest("$i18n{alpha}", "apple");
+
+constexpr I18nTest kTestOneReplacementPlus =
+    I18nTest("Extra text $i18n{alpha}.", "Extra text apple.");
+
+constexpr I18nTest kTestThreeReplacements =
+    I18nTest("$i18n{alpha}^$i18n{beta}_$i18n{gamma}", "apple^banana_carrot");
+
+constexpr I18nTest kTestExtraBraces =
+    I18nTest("($i18n{alpha})^_^_^_^_$i18n{beta}_beta_$i18n{gamma}}}}}}",
+             "(apple)^_^_^_^_banana_beta_carrot}}}}}");
+
+// These tests with generic names are sequences that might catch an error in the
+// future, depending on how the code changes.
+constexpr I18nTest kTest1 =
+    I18nTest("  }    $($i18n{gamma})^_^_^_^_$i18n{alpha}_$i18n{gamma}$",
+             "  }    $(carrot)^_^_^_^_apple_carrot$");
+
+constexpr I18nTest kTest2 =
+    I18nTest("$i18n{alpha} gamma}{ ^_^_^_^_$abc{beta}:$i18n{gamma}z",
+             "apple gamma}{ ^_^_^_^_$abc{beta}:carrotz");
 
 struct I18nTestParam {
-  I18nTestParam(int buf_size, net::MockSourceStream::Mode read_mode)
-      : buffer_size(buf_size), mode(read_mode) {}
+  constexpr I18nTestParam(
+      const I18nTest* test,
+      int buf_size,
+      int read_size,
+      net::MockSourceStream::Mode read_mode = net::MockSourceStream::SYNC)
+      : buffer_size(buf_size),
+        read_size(read_size),
+        mode(read_mode),
+        test(test) {}
 
   const int buffer_size;
+  const int read_size;
   const net::MockSourceStream::Mode mode;
+  const I18nTest* test;
 };
 
 }  // namespace
 
 class I18nSourceStreamTest : public ::testing::TestWithParam<I18nTestParam> {
  protected:
   I18nSourceStreamTest() : output_buffer_size_(GetParam().buffer_size) {}
 
   // Helpful function to initialize the test fixture.
   void Init() {
-    source_data_len_ = kBufferSize;
-    for (size_t i = 0; i < source_data_len_; i++)
-      source_data_[i] = i % 256;
-
-    // Inserts must be done last to first as they appear in the buffer.
-    InsertText(source_data_, source_data_len_, kLongReplacementOffset,
-               kLongReplacementToken);
-    InsertText(source_data_, source_data_len_, kShortReplacementOffset,
-               kShortReplacementToken);
-
-    result_data_len_ = kBufferSize;
-    for (size_t i = 0; i < result_data_len_; i++)
-      result_data_[i] = i % 256;
-
-    // Inserts must be done last to first as they appear in the buffer.
-    InsertText(result_data_, result_data_len_, kLongReplacementOffset,
-               kLongReplacementValue);
-    InsertText(result_data_, result_data_len_, kShortReplacementOffset,
-               kShortReplacementValue);
-
     output_buffer_ = new net::IOBuffer(output_buffer_size_);
     std::unique_ptr<net::MockSourceStream> source(new net::MockSourceStream());
     source_ = source.get();
 
-    replacements_[kShortReplacementKey] = kShortReplacementValue;
-    replacements_[kLongReplacementKey] = kLongReplacementValue;
+    replacements_["alpha"] = "apple";
+    replacements_["beta"] = "banana";
+    replacements_["gamma"] = "carrot";
     stream_ = I18nSourceStream::Create(
         std::move(source), net::SourceStream::TYPE_NONE, &replacements_);
   }
 
   // If MockSourceStream::Mode is ASYNC, completes 1 read from |mock_stream| and
   // wait for |callback| to complete. If Mode is not ASYNC, does nothing and
   // returns |previous_result|.
   int CompleteReadIfAsync(int previous_result,
                           net::TestCompletionCallback* callback,
                           net::MockSourceStream* mock_stream) {
     if (GetParam().mode == net::MockSourceStream::ASYNC) {
       EXPECT_EQ(net::ERR_IO_PENDING, previous_result);
       mock_stream->CompleteNextRead();
       return callback->WaitForResult();
     }
     return previous_result;
   }
 
-  void InsertText(char* buffer,
-                  size_t buffer_length,
-                  size_t offset,
-                  const char* text) {
-    // Intended to be dead simple so that it can be confirmed
-    // as correct by hand.
-    size_t text_length = strlen(text);
-    memmove(buffer + offset + text_length, buffer + offset,
-            buffer_length - offset - text_length);
-    memcpy(buffer + offset, text, text_length);
-  }
-
-  char* source_data() { return source_data_; }
-  size_t source_data_len() { return source_data_len_; }
-
-  char* result_data() { return result_data_; }
-  size_t result_data_len() { return result_data_len_; }
-
   net::IOBuffer* output_buffer() { return output_buffer_.get(); }
   char* output_data() { return output_buffer_->data(); }
   size_t output_buffer_size() { return output_buffer_size_; }
 
   net::MockSourceStream* source() { return source_; }
   I18nSourceStream* stream() { return stream_.get(); }
 
+  void PushReadResults(const char* input, size_t chunk_size) {
+    size_t written = 0;
+    size_t source_size = strlen(GetParam().test->input);
+    while (written != source_size) {
+      size_t write_size = std::min(chunk_size, source_size - written);
+      source()->AddReadResult(input + written, write_size, net::OK,
+                              GetParam().mode);
+      written += write_size;
+    }
+    source()->AddReadResult(nullptr, 0, net::OK, GetParam().mode);
+  }
+
   // Reads from |stream_| until an error occurs or the EOF is reached.
   // When an error occurs, returns the net error code. When an EOF is reached,
   // returns the number of bytes read and appends data read to |output|.
   int ReadStream(std::string* output) {
     int bytes_read = 0;
     while (true) {
       net::TestCompletionCallback callback;
       int rv = stream_->Read(output_buffer(), output_buffer_size(),
                              callback.callback());
       if (rv == net::ERR_IO_PENDING)
         rv = CompleteReadIfAsync(rv, &callback, source());
       if (rv == net::OK)
         break;
       if (rv < net::OK)
         return rv;
       EXPECT_GT(rv, net::OK);
       bytes_read += rv;
       output->append(output_data(), rv);
     }
     return bytes_read;
   }
 
  private:
-  char source_data_[kBufferSize];
-  size_t source_data_len_;
-
-  char result_data_[kBufferSize];
-  size_t result_data_len_;
-
   scoped_refptr<net::IOBuffer> output_buffer_;
   const int output_buffer_size_;
 
   net::MockSourceStream* source_;
   std::unique_ptr<I18nSourceStream> stream_;
 
   ui::TemplateReplacements replacements_;
 };
 
 INSTANTIATE_TEST_CASE_P(
     I18nSourceStreamTests,
     I18nSourceStreamTest,
-    ::testing::Values(I18nTestParam(kBufferSize, net::MockSourceStream::SYNC),
-                      I18nTestParam(kSmallBufferSize,
-                                    net::MockSourceStream::SYNC)));
+    ::testing::Values(
+        I18nTestParam(&kTest1, kBufferSize, kInOneReadSize),
+        I18nTestParam(&kTest1, kBufferSize, kSmallSize),
+        I18nTestParam(&kTest1, kMinimumSize, kMinimumSize),
+        I18nTestParam(&kTest1, kMinimumSize, kSmallSize),
 
-TEST_P(I18nSourceStreamTest, EmptyStream) {
+        I18nTestParam(&kTest2, kBufferSize, kInOneReadSize),
+        I18nTestParam(&kTest2, kBufferSize, kSmallSize),
+        I18nTestParam(&kTest2, kMinimumSize, kMinimumSize),
+        I18nTestParam(&kTest2, kMinimumSize, kSmallSize),
+
+        I18nTestParam(&kTestEmpty, kBufferSize, kInOneReadSize),
+        I18nTestParam(&kTestEmpty, kBufferSize, kSmallSize),
+        I18nTestParam(&kTestEmpty, kMinimumSize, kMinimumSize),
+        I18nTestParam(&kTestEmpty, kMinimumSize, kSmallSize),
+
+        I18nTestParam(&kTestExtraBraces, kBufferSize, kInOneReadSize),
+        I18nTestParam(&kTestExtraBraces, kBufferSize, kSmallSize),
+        I18nTestParam(&kTestExtraBraces, kMinimumSize, kMinimumSize),
+        I18nTestParam(&kTestExtraBraces, kMinimumSize, kSmallSize),
+
+        I18nTestParam(&kTestNoReplacements, kBufferSize, kInOneReadSize),
+        I18nTestParam(&kTestNoReplacements, kBufferSize, kSmallSize),
+        I18nTestParam(&kTestNoReplacements, kMinimumSize, kMinimumSize),
+        I18nTestParam(&kTestNoReplacements, kMinimumSize, kSmallSize),
+
+        I18nTestParam(&kTestOneReplacement, kBufferSize, kInOneReadSize),
+        I18nTestParam(&kTestOneReplacement, kBufferSize, kSmallSize),
+        I18nTestParam(&kTestOneReplacement, kMinimumSize, kMinimumSize),
+        I18nTestParam(&kTestOneReplacement, kMinimumSize, kSmallSize),
+
+        I18nTestParam(&kTestOneReplacementPlus, kBufferSize, kInOneReadSize),
+        I18nTestParam(&kTestOneReplacementPlus, kBufferSize, kSmallSize),
+        I18nTestParam(&kTestOneReplacementPlus, kMinimumSize, kMinimumSize),
+        I18nTestParam(&kTestOneReplacementPlus, kMinimumSize, kSmallSize),
+
+        I18nTestParam(&kTestTagAtEndOfLine, kBufferSize, kInOneReadSize),
+        I18nTestParam(&kTestTagAtEndOfLine, kBufferSize, kSmallSize),
+        I18nTestParam(&kTestTagAtEndOfLine, kMinimumSize, kMinimumSize),
+        I18nTestParam(&kTestTagAtEndOfLine, kMinimumSize, kSmallSize),
+
+        I18nTestParam(&kTestThreeReplacements, kBufferSize, kInOneReadSize),
+        I18nTestParam(&kTestThreeReplacements, kBufferSize, kSmallSize),
+        I18nTestParam(&kTestThreeReplacements, kMinimumSize, kMinimumSize),
+        I18nTestParam(&kTestThreeReplacements, kMinimumSize, kSmallSize)));
+
+TEST_P(I18nSourceStreamTest, FilterTests) {
   Init();
-  source()->AddReadResult("", 0, net::OK, GetParam().mode);
+  // Create the chain of read buffers.
+  PushReadResults(GetParam().test->input, GetParam().read_size);
+
+  // Process the buffers.
   std::string actual_output;
-  int result = ReadStream(&actual_output);
-  EXPECT_EQ(net::OK, result);
+  int rv = ReadStream(&actual_output);
+
+  // Check the results.
+  std::string expected_output(GetParam().test->expected_output);
+  ASSERT_EQ(expected_output.size(), static_cast<size_t>(rv));

[mmenke, 2017/01/06 22:39:40]

optional:  This is redundant with the EXPECT_EQ on the next line, and so isn't
needed (Alternatively, ASSERT seems worse than EXPECT on this test - we won't
crash on mismatch, unlike in the next one)

[dschuyler, 2017/01/09 20:14:07]

Converted to expect rather than assert. I agree that it is somewhat redundant,
but it kinda seems like a reasonable test since the value comes out of the api
in two places (return and .size() of param).

Done.

+  EXPECT_EQ(expected_output, actual_output);
   EXPECT_EQ("i18n", stream()->Description());
 }
 
-TEST_P(I18nSourceStreamTest, NoTranslations) {
+TEST_P(I18nSourceStreamTest, LargeFilterTests) {
   Init();
-  const char kText[] = "This text has no i18n replacements.";
-  size_t kTextLength = strlen(kText);
-  source()->AddReadResult(kText, kTextLength, net::OK, GetParam().mode);
-  source()->AddReadResult(nullptr, 0, net::OK, GetParam().mode);
+  std::string padding;
+  // 251 and 599 are prime and avoid power-of-two repetition.
+  int padding_modulus = 251;
+  int pad_size = 599;
+  padding.resize(pad_size);
+  for (int i = 0; i < pad_size; ++i)
+    padding[i] = i % padding_modulus;
+
+  // Create the chain of read buffers.
+  int pad_count = 128;  // Arbitrary number of pads to add.

[mmenke, 2017/01/06 22:39:40]

nit:  const int kPadCount

[dschuyler, 2017/01/09 20:14:07]

Done.

+  for (int i = 0; i < pad_count; ++i) {
+    source()->AddReadResult(padding.c_str(), padding.size(), net::OK,
+                            GetParam().mode);
+  }
+  PushReadResults(GetParam().test->input, GetParam().read_size);
+
+  // Process the buffers.
   std::string actual_output;
   int rv = ReadStream(&actual_output);
-  EXPECT_EQ(static_cast<int>(kTextLength), rv);
-  EXPECT_EQ(kText, actual_output);
+
+  // Check the results.
+  size_t total_padding = pad_count * padding.size();
+  std::string expected_output(GetParam().test->expected_output);
+  ASSERT_EQ(expected_output.size() + total_padding, static_cast<size_t>(rv));
+  for (int i = 0; i < pad_count; ++i) {
+    EXPECT_EQ(actual_output.substr(i * padding.size(), padding.size()),
+              padding);
+  }
+  EXPECT_EQ(expected_output, &actual_output[total_padding]);
   EXPECT_EQ("i18n", stream()->Description());
 }
 
-TEST_P(I18nSourceStreamTest, I18nOneRead) {
-  Init();
-  source()->AddReadResult(source_data(), kSourceSize, net::OK, GetParam().mode);
-  source()->AddReadResult(nullptr, 0, net::OK, GetParam().mode);
-  std::string actual_output;
-  int rv = ReadStream(&actual_output);
-  EXPECT_EQ(static_cast<int>(kResultSize), rv);
-  EXPECT_EQ(std::string(result_data(), kResultSize), actual_output);
-  EXPECT_EQ("i18n", stream()->Description());
-}
-
-TEST_P(I18nSourceStreamTest, I18nInMultipleReads) {
-  Init();
-  size_t chunk_size = 5;
-  size_t written = 0;
-  while (written + chunk_size < kSourceSize) {
-    source()->AddReadResult(source_data() + written, chunk_size, net::OK,
-                            GetParam().mode);
-    written += chunk_size;
-  }
-  source()->AddReadResult(source_data() + written, kSourceSize - written,
-                          net::OK, GetParam().mode);
-  source()->AddReadResult(nullptr, 0, net::OK, GetParam().mode);
-  std::string actual_output;
-  int rv = ReadStream(&actual_output);
-  EXPECT_EQ(static_cast<int>(kResultSize), rv);
-  EXPECT_EQ(std::string(result_data(), kResultSize), actual_output);
-  EXPECT_EQ("i18n", stream()->Description());
-}
-
-TEST_P(I18nSourceStreamTest, I18nTagAtEndOfLine) {
-  Init();
-  const char kSourceData[] = "test with tag at end of line $";
-  const size_t source_size = strlen(kSourceData);
-  source()->AddReadResult(kSourceData, source_size, net::OK, GetParam().mode);
-  source()->AddReadResult(nullptr, 0, net::OK, GetParam().mode);
-  std::string actual_output;
-  int rv = ReadStream(&actual_output);
-  EXPECT_EQ(static_cast<int>(source_size), rv);
-  EXPECT_EQ(kSourceData, actual_output);
-  EXPECT_EQ("i18n", stream()->Description());
-}
-
 }  // namespace content