zero_copy_stream_unittest.rar_Zero

// Testing strategy: For each type of I/O (array, string, file, etc.) we // create an output stream and write some data to it, then create a // corresponding input stream to read the same data back and expect it to // match. When the data is written, it is written in several small chunks // 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> #include <sstream> #include <google/protobuf/io/zero_copy_stream_impl.h> #if HAVE_ZLIB #include <google/protobuf/io/gzip_stream.h> #endif #include <google/protobuf/stubs/common.h> #include <google/protobuf/testing/googletest.h> #include <google/protobuf/testing/file.h> #include <gtest/gtest.h> namespace google { namespace protobuf { namespace io { namespace { #ifdef _WIN32 #define pipe(fds) _pipe(fds, 4096, O_BINARY) #endif #ifndef O_BINARY #ifdef _O_BINARY #define O_BINARY _O_BINARY #else #define O_BINARY 0 // If this isn't defined, the platform doesn't need it. #endif #endif class IoTest : public testing::Test { protected: // Test helpers. // Helper to write an array of data to an output stream. bool WriteToOutput(ZeroCopyOutputStream* output, const void* data, int size); // Helper to read a fixed-length array of data from an input stream. int ReadFromInput(ZeroCopyInputStream* input, void* data, int size); // Write a string to the output stream. void WriteString(ZeroCopyOutputStream* output, const string& str); // Read a number of bytes equal to the size of the given string and checks // that it matches the string. void ReadString(ZeroCopyInputStream* input, const string& str); // Writes some text to the output stream in a particular order. Returns // the number of bytes written, incase the caller needs that to set up an // input stream. int WriteStuff(ZeroCopyOutputStream* output); // Reads text from an input stream and expects it to match what // WriteStuff() writes. void ReadStuff(ZeroCopyInputStream* input); // Similar to WriteStuff, but performs more sophisticated testing. int WriteStuffLarge(ZeroCopyOutputStream* output); // Reads and tests a stream that should have been written to // via WriteStuffLarge(). void ReadStuffLarge(ZeroCopyInputStream* input); #if HAVE_ZLIB string Compress(const string& data, const GzipOutputStream::Options& options); string Uncompress(const string& data); #endif static const int kBlockSizes[]; static const int kBlockSizeCount; }; const int IoTest::kBlockSizes[] = {-1, 1, 2, 5, 7, 10, 23, 64}; const int IoTest::kBlockSizeCount = GOOGLE_ARRAYSIZE(IoTest::kBlockSizes); bool IoTest::WriteToOutput(ZeroCopyOutputStream* output, const void* data, int size) { const uint8* in = reinterpret_cast<const uint8*>(data); int in_size = size; void* out; int out_size; while (true) { if (!output->Next(&out, &out_size)) { return false; } EXPECT_GT(out_size, 0); if (in_size <= out_size) { memcpy(out, in, in_size); output->BackUp(out_size - in_size); return true; } memcpy(out, in, out_size); in += out_size; in_size -= out_size; } } #define MAX_REPEATED_ZEROS 100 int IoTest::ReadFromInput(ZeroCopyInputStream* input, void* data, int size) { uint8* out = reinterpret_cast<uint8*>(data); int out_size = size; const void* in; int in_size = 0; int repeated_zeros = 0; while (true) { if (!input->Next(&in, &in_size)) { return size - out_size; } EXPECT_GT(in_size, -1); if (in_size == 0) { repeated_zeros++; } else { repeated_zeros = 0; } EXPECT_LT(repeated_zeros, MAX_REPEATED_ZEROS); if (out_size <= in_size) { memcpy(out, in, out_size); if (in_size > out_size) { input->BackUp(in_size - out_size); } return size; // Copied all of it. } memcpy(out, in, in_size); out += in_size; out_size -= in_size; } } void IoTest::WriteString(ZeroCopyOutputStream* output, const string& str) { EXPECT_TRUE(WriteToOutput(output, str.c_str(), str.size())); } void IoTest::ReadString(ZeroCopyInputStream* input, const string& str) { scoped_array<char> buffer(new char[str.size() + 1]); buffer[str.size()] = '\0'; EXPECT_EQ(ReadFromInput(input, buffer.get(), str.size()), str.size()); EXPECT_STREQ(str.c_str(), buffer.get()); } int IoTest::WriteStuff(ZeroCopyOutputStream* output) { WriteString(output, "Hello world!\n"); WriteString(output, "Some te"); WriteString(output, "xt. Blah blah."); WriteString(output, "abcdefg"); WriteString(output, "01234567890123456789"); WriteString(output, "foobar"); EXPECT_EQ(output->ByteCount(), 68); int result = output->ByteCount(); return result; } // Reads text from an input stream and expects it to match what WriteStuff() // writes. void IoTest::ReadStuff(ZeroCopyInputStream* input) { ReadString(input, "Hello world!\n"); ReadString(input, "Some text. "); ReadString(input, "Blah "); ReadString(input, "blah."); ReadString(input, "abcdefg"); EXPECT_TRUE(input->Skip(20)); ReadString(input, "foo"); ReadString(input, "bar"); EXPECT_EQ(input->ByteCount(), 68); uint8 byte; EXPECT_EQ(ReadFromInput(input, &byte, 1), 0); } int IoTest::WriteStuffLarge(ZeroCopyOutputStream* output) { WriteString(output, "Hello world!\n"); WriteString(output, "Some te"); WriteString(output, "xt. Blah blah."); WriteString(output, string(100000, 'x')); // A very long string WriteString(output, string(100000, 'y')); // A very long string WriteString(output, "01234567890123456789"); EXPECT_EQ(output->ByteCount(), 200055); int result = output->ByteCount(); return result; } // Reads text from an input stream and expects it to match what WriteStuff() // writes. void IoTest::ReadStuffLarge(ZeroCopyInputStream* input) { ReadString(input, "Hello world!\nSome text. "); EXPECT_TRUE(input->Skip(5)); ReadString(input, "blah."); EXPECT_TRUE(input->Skip(100000 - 10)); ReadString(input, string(10, 'x') + string(100000 - 20000, 'y')); EXPECT_TRUE(input->Skip(20000 - 10)); ReadString(input, "yyyyyyyyyy01234567890123456789"); EXPECT_EQ(input->ByteCount(), 200055); uint8 byte; EXPECT_EQ(ReadFromInput(input, &byte, 1), 0); } // =================================================================== TEST_F(IoTest, ArrayIo) { const int kBufferSize = 256; uint8 buffer[kBufferSize]; for (int i = 0; i < kBlockSizeCount; i++) { for (int j = 0; j < kBlockSizeCount; j++) { int size; { ArrayOutputStream output(buffer, kBufferSize, kBlockSizes[i]); size = WriteStuff(&output); } { ArrayInputStream input(buffer, size, kBlockSizes[j]); ReadStuff(&input); } } } } #if HAVE_ZLIB TEST_F(IoTest, GzipIo) { const int kBufferSize = 2*1024; uint8* buffer = new uint8[kBufferSize]; for (int i = 0; i < kBlockSizeCount; i++) { for (int j = 0; j < kBlockSizeCount; j++) { for (int z = 0; z < kBlockSizeCount; z++) { int gzip_buffer_size = kBlockSizes[z]; int size; { ArrayOutputStream output(buffer, kBufferSize, kBlockSizes[i]); GzipOutputStream gzout( &output, GzipOutputStream::GZIP, gzip_buffer_size); WriteStuff(&gzout); gzout.Close(); size = output.ByteCount(); } { ArrayInputStream input(