third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 40 matching lines @@
 #include <gtest/gtest.h>
 #include <google/protobuf/io/zero_copy_stream_impl.h>
 
 
 // This declares an unsigned long long integer literal in a portable way.
 // (The original macro is way too big and ruins my formatting.)
 #undef ULL
 #define ULL(x) GOOGLE_ULONGLONG(x)
 
 namespace google {
+
 namespace protobuf {
 namespace io {
 namespace {
 
 // ===================================================================
 // Data-Driven Test Infrastructure
 
 // TEST_1D and TEST_2D are macros I'd eventually like to see added to
 // gTest.  These macros can be used to declare tests which should be
 // run multiple times, once for each item in some input array.  TEST_1D
@@ skipping 56 matching lines @@
                                            const CaseType2& CASES2##_case)
 
 // ===================================================================
 
 class CodedStreamTest : public testing::Test {
  protected:
   // Helper method used by tests for bytes warning. See implementation comment
   // for further information.
   static void SetupTotalBytesLimitWarningTest(
       int total_bytes_limit, int warning_threshold,
-      vector<string>* out_errors, vector<string>* out_warnings);
+      std::vector<string>* out_errors, std::vector<string>* out_warnings);
 
   // Buffer used during most of the tests. This assumes tests run sequentially.
   static const int kBufferSize = 1024 * 64;
   static uint8 buffer_[kBufferSize];
 };
 
 uint8 CodedStreamTest::buffer_[CodedStreamTest::kBufferSize];
 
 // We test each operation over a variety of block sizes to insure that
 // we test cases where reads or writes cross buffer boundaries, cases
@@ skipping 89 matching lines @@
       GOOGLE_LOG(FATAL) << "Tests never call this.";
     }
     virtual bool Skip(int count) {
       GOOGLE_LOG(FATAL) << "Tests never call this.";
       return false;
     }
     virtual int64 ByteCount() const { return 0; }
     int count_;
   } in;
   CodedInputStream input(&in);
-  input.ReadTag();
+  input.ReadTagNoLastTag();
   EXPECT_TRUE(input.ConsumedEntireMessage());
 }
 
 TEST_1D(CodedStreamTest, ExpectTag, kVarintCases) {
   // Leave one byte at the beginning of the buffer so we can read it
   // to force the first buffer to be loaded.
   buffer_[0] = '\0';
   memcpy(buffer_ + 1, kVarintCases_case.bytes, kVarintCases_case.size);
   ArrayInputStream input(buffer_, sizeof(buffer_));
 
@@ skipping 180 matching lines @@
 TEST_2D(CodedStreamTest, ReadVarint32Error, kVarintErrorCases, kBlockSizes) {
   memcpy(buffer_, kVarintErrorCases_case.bytes, kVarintErrorCases_case.size);
   ArrayInputStream input(buffer_, kVarintErrorCases_case.size,
                          kBlockSizes_case);
   CodedInputStream coded_input(&input);
 
   uint32 value;
   EXPECT_EQ(kVarintErrorCases_case.can_parse, coded_input.ReadVarint32(&value));
 }
 
+TEST_2D(CodedStreamTest, ReadVarint32Error_LeavesValueInInitializedState,
+        kVarintErrorCases, kBlockSizes) {
+  memcpy(buffer_, kVarintErrorCases_case.bytes, kVarintErrorCases_case.size);
+  ArrayInputStream input(buffer_, kVarintErrorCases_case.size,
+                         kBlockSizes_case);
+  CodedInputStream coded_input(&input);
+
+  uint32 value = 0;
+  EXPECT_EQ(kVarintErrorCases_case.can_parse, coded_input.ReadVarint32(&value));
+  // While the specific value following a failure is not critical, we do want to
+  // ensure that it doesn't get set to an uninitialized value. (This check fails
+  // in MSAN mode if value has been set to an uninitialized value.)
+  EXPECT_EQ(value, value);
+}
+
 TEST_2D(CodedStreamTest, ReadVarint64Error, kVarintErrorCases, kBlockSizes) {
   memcpy(buffer_, kVarintErrorCases_case.bytes, kVarintErrorCases_case.size);
   ArrayInputStream input(buffer_, kVarintErrorCases_case.size,
                          kBlockSizes_case);
   CodedInputStream coded_input(&input);
 
   uint64 value;
   EXPECT_EQ(kVarintErrorCases_case.can_parse, coded_input.ReadVarint64(&value));
 }
 
+TEST_2D(CodedStreamTest, ReadVarint64Error_LeavesValueInInitializedState,
+        kVarintErrorCases, kBlockSizes) {
+  memcpy(buffer_, kVarintErrorCases_case.bytes, kVarintErrorCases_case.size);
+  ArrayInputStream input(buffer_, kVarintErrorCases_case.size,
+                         kBlockSizes_case);
+  CodedInputStream coded_input(&input);
+
+  uint64 value = 0;
+  EXPECT_EQ(kVarintErrorCases_case.can_parse, coded_input.ReadVarint64(&value));
+  // While the specific value following a failure is not critical, we do want to
+  // ensure that it doesn't get set to an uninitialized value. (This check fails
+  // in MSAN mode if value has been set to an uninitialized value.)
+  EXPECT_EQ(value, value);
+}
+
 // -------------------------------------------------------------------
 // VarintSize
 
 struct VarintSizeCase {
   uint64 value;
   int size;
 };
 
 inline std::ostream& operator<<(std::ostream& os, const VarintSizeCase& c) {
   return os << c.value;
@@ skipping 19 matching lines @@
   EXPECT_EQ(kVarintSizeCases_case.size,
     CodedOutputStream::VarintSize32(
       static_cast<uint32>(kVarintSizeCases_case.value)));
 }
 
 TEST_1D(CodedStreamTest, VarintSize64, kVarintSizeCases) {
   EXPECT_EQ(kVarintSizeCases_case.size,
     CodedOutputStream::VarintSize64(kVarintSizeCases_case.value));
 }
 
+TEST_F(CodedStreamTest, VarintSize32PowersOfTwo) {
+  int expected = 1;
+  for (int i = 1; i < 32; i++) {
+    if (i % 7 == 0) {
+      expected += 1;
+    }
+    EXPECT_EQ(expected,
+              CodedOutputStream::VarintSize32(static_cast<uint32>(0x1u << i)));
+  }
+}
+
+TEST_F(CodedStreamTest, VarintSize64PowersOfTwo) {
+  int expected = 1;
+  for (int i = 1; i < 64; i++) {
+    if (i % 7 == 0) {
+      expected += 1;
+    }
+    EXPECT_EQ(expected, CodedOutputStream::VarintSize64(
+                            static_cast<uint64>(0x1ull << i)));
+  }
+}
+
 // -------------------------------------------------------------------
 // Fixed-size int tests
 
 struct Fixed32Case {
   uint8 bytes[sizeof(uint32)];          // Encoded bytes.
   uint32 value;                         // Parsed value.
 };
 
 struct Fixed64Case {
   uint8 bytes[sizeof(uint64)];          // Encoded bytes.
@@ skipping 662 matching lines @@
 TEST_F(CodedStreamTest, TotalBytesLimit) {
   ArrayInputStream input(buffer_, sizeof(buffer_));
   CodedInputStream coded_input(&input);
   coded_input.SetTotalBytesLimit(16, -1);
   EXPECT_EQ(16, coded_input.BytesUntilTotalBytesLimit());
 
   string str;
   EXPECT_TRUE(coded_input.ReadString(&str, 16));
   EXPECT_EQ(0, coded_input.BytesUntilTotalBytesLimit());
 
-  vector<string> errors;
+  std::vector<string> errors;
 
   {
     ScopedMemoryLog error_log;
     EXPECT_FALSE(coded_input.ReadString(&str, 1));
     errors = error_log.GetMessages(ERROR);
   }
 
   ASSERT_EQ(1, errors.size());
   EXPECT_PRED_FORMAT2(testing::IsSubstring,
     "A protocol message was rejected because it was too big", errors[0]);
@@ skipping 13 matching lines @@
   // Set both total_bytes_limit and a regular limit at 16 bytes.
   coded_input.SetTotalBytesLimit(16, -1);
   CodedInputStream::Limit limit = coded_input.PushLimit(16);
 
   // Read 16 bytes.
   string str;
   EXPECT_TRUE(coded_input.ReadString(&str, 16));
 
   // Read a tag.  Should fail, but report being a valid endpoint since it's
   // a regular limit.
-  EXPECT_EQ(0, coded_input.ReadTag());
+  EXPECT_EQ(0, coded_input.ReadTagNoLastTag());
   EXPECT_TRUE(coded_input.ConsumedEntireMessage());
 
   // Pop the limit.
   coded_input.PopLimit(limit);
 
   // Read a tag.  Should fail, and report *not* being a valid endpoint, since
   // this time we're hitting the total bytes limit.
-  EXPECT_EQ(0, coded_input.ReadTag());
+  EXPECT_EQ(0, coded_input.ReadTagNoLastTag());
   EXPECT_FALSE(coded_input.ConsumedEntireMessage());
 }
 
 // This method is used by the tests below.
 // It constructs a CodedInputStream with the given limits and tries to read 2KiB
 // of data from it. Then it returns the logged errors and warnings in the given
 // vectors.
 void CodedStreamTest::SetupTotalBytesLimitWarningTest(
     int total_bytes_limit, int warning_threshold,
-    vector<string>* out_errors, vector<string>* out_warnings) {
+    std::vector<string>* out_errors, std::vector<string>* out_warnings) {
   ArrayInputStream raw_input(buffer_, sizeof(buffer_), 128);
 
   ScopedMemoryLog scoped_log;
   {
     CodedInputStream input(&raw_input);
     input.SetTotalBytesLimit(total_bytes_limit, warning_threshold);
     string str;
     EXPECT_TRUE(input.ReadString(&str, 2048));
   }
 
   *out_errors = scoped_log.GetMessages(ERROR);
   *out_warnings = scoped_log.GetMessages(WARNING);
 }
 
 TEST_F(CodedStreamTest, TotalBytesLimitWarning) {
-  vector<string> errors;
-  vector<string> warnings;
+  std::vector<string> errors;
+  std::vector<string> warnings;
   SetupTotalBytesLimitWarningTest(10240, 1024, &errors, &warnings);
 
   EXPECT_EQ(0, errors.size());
 
-  ASSERT_EQ(2, warnings.size());
-  EXPECT_PRED_FORMAT2(testing::IsSubstring,
-    "Reading dangerously large protocol message.  If the message turns out to "
-    "be larger than 10240 bytes, parsing will be halted for security reasons.",
-    warnings[0]);
+  EXPECT_EQ(1, warnings.size());
   EXPECT_PRED_FORMAT2(testing::IsSubstring,
     "The total number of bytes read was 2048",
-    warnings[1]);
+    warnings[0]);
 }
 
 TEST_F(CodedStreamTest, TotalBytesLimitWarningDisabled) {
-  vector<string> errors;
-  vector<string> warnings;
+  std::vector<string> errors;
+  std::vector<string> warnings;
 
   // Test with -1
   SetupTotalBytesLimitWarningTest(10240, -1, &errors, &warnings);
   EXPECT_EQ(0, errors.size());
   EXPECT_EQ(0, warnings.size());
 
   // Test again with -2, expecting the same result
   SetupTotalBytesLimitWarningTest(10240, -2, &errors, &warnings);
   EXPECT_EQ(0, errors.size());
   EXPECT_EQ(0, warnings.size());
@@ skipping 78 matching lines @@
  private:
   char buffer_[1024];
   int64 buffer_count_;
 };
 
 TEST_F(CodedStreamTest, InputOver2G) {
   // CodedInputStream should gracefully handle input over 2G and call
   // input.BackUp() with the correct number of bytes on destruction.
   ReallyBigInputStream input;
 
-  vector<string> errors;
+  std::vector<string> errors;
 
   {
     ScopedMemoryLog error_log;
     CodedInputStream coded_input(&input);
     string str;
     EXPECT_TRUE(coded_input.ReadString(&str, 512));
     EXPECT_TRUE(coded_input.ReadString(&str, 1024));
     errors = error_log.GetMessages(ERROR);
   }
 
   EXPECT_EQ(INT_MAX - 512, input.backup_amount_);
   EXPECT_EQ(0, errors.size());
 }
 
 // ===================================================================
 
 
 }  // namespace
 }  // namespace io
 }  // namespace protobuf
 }  // namespace google