Revert https://codereview.chromium.org/1291903002 (protobuf roll).

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

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
+// http://code.google.com/p/protobuf/
 //
 // 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.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
@@ skipping 25 matching lines @@
 // of varying sizes, with a BackUp() after each chunk.  It is read back
 // similarly, but with chunks separated at different points.  The whole
 // process is run with a variety of block sizes for both the input and
 // the output.
 //
 // TODO(kenton):  Rewrite this test to bring it up to the standards of all
 //   the other proto2 tests.  May want to wait for gTest to implement
 //   "parametized tests" so that one set of tests can be used on all the
 //   implementations.
 
+#include "config.h"
+
 #ifdef _MSC_VER
 #include <io.h>
 #else
 #include <unistd.h>
 #endif
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <errno.h>
@@ skipping 492 matching lines @@
       result.append(reinterpret_cast<const char*>(buffer), size);
     }
   }
   return result;
 }
 
 TEST_F(IoTest, CompressionOptions) {
   // Some ad-hoc testing of compression options.
 
   string golden;
-  GOOGLE_CHECK_OK(File::GetContents(
-      TestSourceDir() +
-          "/google/protobuf/testdata/golden_message",
-      &golden, true));
+  File::ReadFileToStringOrDie(
+    TestSourceDir() + "/google/protobuf/testdata/golden_message",
+    &golden);
 
   GzipOutputStream::Options options;
   string gzip_compressed = Compress(golden, options);
 
   options.compression_level = 0;
   string not_compressed = Compress(golden, options);
 
   // Try zlib compression for fun.
   options = GzipOutputStream::Options();
   options.format = GzipOutputStream::ZLIB;
@@ skipping 72 matching lines @@
 
       delete coded_input;
       delete gzin;
       delete input;
     }
   }
 
   delete [] temp_buffer;
   delete [] buffer;
 }
-
-TEST_F(IoTest, GzipInputByteCountAfterClosed) {
-  string golden = "abcdefghijklmnopqrstuvwxyz";
-  string compressed = Compress(golden, GzipOutputStream::Options());
-
-  for (int i = 0; i < kBlockSizeCount; i++) {
-    ArrayInputStream arr_input(compressed.data(), compressed.size(),
-                               kBlockSizes[i]);
-    GzipInputStream gz_input(&arr_input);
-    const void* buffer;
-    int size;
-    while (gz_input.Next(&buffer, &size)) {
-      EXPECT_LE(gz_input.ByteCount(), golden.size());
-    }
-    EXPECT_EQ(golden.size(), gz_input.ByteCount());
-  }
-}
-
-TEST_F(IoTest, GzipInputByteCountAfterClosedConcatenatedStreams) {
-  string golden1 = "abcdefghijklmnopqrstuvwxyz";
-  string golden2 = "the quick brown fox jumps over the lazy dog";
-  const size_t total_size = golden1.size() + golden2.size();
-  string compressed = Compress(golden1, GzipOutputStream::Options()) +
-                      Compress(golden2, GzipOutputStream::Options());
-
-  for (int i = 0; i < kBlockSizeCount; i++) {
-    ArrayInputStream arr_input(compressed.data(), compressed.size(),
-                               kBlockSizes[i]);
-    GzipInputStream gz_input(&arr_input);
-    const void* buffer;
-    int size;
-    while (gz_input.Next(&buffer, &size)) {
-      EXPECT_LE(gz_input.ByteCount(), total_size);
-    }
-    EXPECT_EQ(total_size, gz_input.ByteCount());
-  }
-}
 #endif
 
 // There is no string input, only string output.  Also, it doesn't support
 // explicit block sizes.  So, we'll only run one test and we'll use
 // ArrayInput to read back the results.
 TEST_F(IoTest, StringIo) {
   string str;
   {
     StringOutputStream output(&str);
     WriteStuff(&output);
@@ skipping 248 matching lines @@
   ArrayOutputStream output(buffer, kBufferSize);
   WriteStuff(&output);
 
   // Set up input.
   ArrayInputStream array_input(buffer, kBufferSize);
   LimitingInputStream input(&array_input, output.ByteCount());
 
   ReadStuff(&input);
 }
 
-// Checks that ByteCount works correctly for LimitingInputStreams where the
-// underlying stream has already been read.
-TEST_F(IoTest, LimitingInputStreamByteCount) {
-  const int kHalfBufferSize = 128;
-  const int kBufferSize = kHalfBufferSize * 2;
-  uint8 buffer[kBufferSize];
-
-  // Set up input. Only allow half to be read at once.
-  ArrayInputStream array_input(buffer, kBufferSize, kHalfBufferSize);
-  const void* data;
-  int size;
-  EXPECT_TRUE(array_input.Next(&data, &size));
-  EXPECT_EQ(kHalfBufferSize, array_input.ByteCount());
-  // kHalfBufferSize - 1 to test limiting logic as well.
-  LimitingInputStream input(&array_input, kHalfBufferSize - 1);
-  EXPECT_EQ(0, input.ByteCount());
-  EXPECT_TRUE(input.Next(&data, &size));
-  EXPECT_EQ(kHalfBufferSize - 1 , input.ByteCount());
-}
-
 // Check that a zero-size array doesn't confuse the code.
 TEST(ZeroSizeArray, Input) {
   ArrayInputStream input(NULL, 0);
   const void* data;
   int size;
   EXPECT_FALSE(input.Next(&data, &size));
 }
 
 TEST(ZeroSizeArray, Output) {
   ArrayOutputStream output(NULL, 0);
   void* data;
   int size;
   EXPECT_FALSE(output.Next(&data, &size));
 }
 
 }  // namespace
 }  // namespace io
 }  // namespace protobuf
 }  // namespace google