← Back to branch summary

~ubuntu-branches/debian/squeeze/protobuf/squeeze

« back to all changes in this revision

Viewing changes to src/google/protobuf/io/zero_copy_stream_unittest.cc

  • Committer: Bazaar Package Importer
  • Author(s): Julien Cristau
  • Date: 2009-06-02 16:19:00 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20090602161900-vm176i3ryt35yk91
Tags: 2.0.3-2.2
* Non-maintainer upload.
* Fix FTBFS from -2.1: don't fail when we can't clean up the java build,
  such as when openjdk isn't installed.
* Disable parallel builds, because libtool is made of fail (if binary-arch
  and build-indep run concurrently, we relink a library while it's being
  used; that doesn't work so well).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/google/protobuf/io/zero_copy_stream_unittest.cc
1
1
// Protocol Buffers - Google's data interchange format
2
 
// Copyright 2008 Google Inc.
 
2
// Copyright 2008 Google Inc.  All rights reserved.
3
3
// http://code.google.com/p/protobuf/
4
4
//
5
 
// Licensed under the Apache License, Version 2.0 (the "License");
6
 
// you may not use this file except in compliance with the License.
7
 
// You may obtain a copy of the License at
8
 
//
9
 
//      http://www.apache.org/licenses/LICENSE-2.0
10
 
//
11
 
// Unless required by applicable law or agreed to in writing, software
12
 
// distributed under the License is distributed on an "AS IS" BASIS,
13
 
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
 
// See the License for the specific language governing permissions and
15
 
// limitations under the License.
 
5
// Redistribution and use in source and binary forms, with or without
 
6
// modification, are permitted provided that the following conditions are
 
7
// met:
 
8
//
 
9
//     * Redistributions of source code must retain the above copyright
 
10
// notice, this list of conditions and the following disclaimer.
 
11
//     * Redistributions in binary form must reproduce the above
 
12
// copyright notice, this list of conditions and the following disclaimer
 
13
// in the documentation and/or other materials provided with the
 
14
// distribution.
 
15
//     * Neither the name of Google Inc. nor the names of its
 
16
// contributors may be used to endorse or promote products derived from
 
17
// this software without specific prior written permission.
 
18
//
 
19
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
20
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
21
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
22
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
23
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
24
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
25
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
26
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
27
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
28
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
29
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
16
30
 
17
31
// Author: kenton@google.com (Kenton Varda)
18
32
//  Based on original Protocol Buffers design by
76
90
  // Helper to read a fixed-length array of data from an input stream.
77
91
  int ReadFromInput(ZeroCopyInputStream* input, void* data, int size);
78
92
  // Write a string to the output stream.
79
 
  void WriteString(ZeroCopyOutputStream* output, const char* str);
 
93
  void WriteString(ZeroCopyOutputStream* output, const string& str);
80
94
  // Read a number of bytes equal to the size of the given string and checks
81
95
  // that it matches the string.
82
 
  void ReadString(ZeroCopyInputStream* input, const char* str);
 
96
  void ReadString(ZeroCopyInputStream* input, const string& str);
83
97
  // Writes some text to the output stream in a particular order.  Returns
84
98
  // the number of bytes written, incase the caller needs that to set up an
85
99
  // input stream.
88
102
  // WriteStuff() writes.
89
103
  void ReadStuff(ZeroCopyInputStream* input);
90
104
 
 
105
  // Similar to WriteStuff, but performs more sophisticated testing.
 
106
  int WriteStuffLarge(ZeroCopyOutputStream* output);
 
107
  // Reads and tests a stream that should have been written to
 
108
  // via WriteStuffLarge().
 
109
  void ReadStuffLarge(ZeroCopyInputStream* input);
 
110
 
91
111
  static const int kBlockSizes[];
92
112
  static const int kBlockSizeCount;
93
113
};
107
127
    if (!output->Next(&out, &out_size)) {
108
128
      return false;
109
129
    }
 
130
    EXPECT_GT(out_size, 0);
110
131
 
111
132
    if (in_size <= out_size) {
112
133
      memcpy(out, in, in_size);
131
152
    if (!input->Next(&in, &in_size)) {
132
153
      return size - out_size;
133
154
    }
 
155
    EXPECT_GT(in_size, 0);
134
156
 
135
157
    if (out_size <= in_size) {
136
158
      memcpy(out, in, out_size);
137
 
      input->BackUp(in_size - out_size);
 
159
      if (in_size > out_size) {
 
160
        input->BackUp(in_size - out_size);
 
161
      }
138
162
      return size;  // Copied all of it.
139
163
    }
140
164
 
144
168
  }
145
169
}
146
170
 
147
 
void IoTest::WriteString(ZeroCopyOutputStream* output, const char* str) {
148
 
  EXPECT_TRUE(WriteToOutput(output, str, strlen(str)));
 
171
void IoTest::WriteString(ZeroCopyOutputStream* output, const string& str) {
 
172
  EXPECT_TRUE(WriteToOutput(output, str.c_str(), str.size()));
149
173
}
150
174
 
151
 
void IoTest::ReadString(ZeroCopyInputStream* input, const char* str) {
152
 
  int length = strlen(str);
153
 
  scoped_array<char> buffer(new char[length + 1]);
154
 
  buffer[length] = '\0';
155
 
  EXPECT_EQ(ReadFromInput(input, buffer.get(), length), length);
156
 
  EXPECT_STREQ(str, buffer.get());
 
175
void IoTest::ReadString(ZeroCopyInputStream* input, const string& str) {
 
176
  scoped_array<char> buffer(new char[str.size() + 1]);
 
177
  buffer[str.size()] = '\0';
 
178
  EXPECT_EQ(ReadFromInput(input, buffer.get(), str.size()), str.size());
 
179
  EXPECT_STREQ(str.c_str(), buffer.get());
157
180
}
158
181
 
159
182
int IoTest::WriteStuff(ZeroCopyOutputStream* output) {
188
211
  EXPECT_EQ(ReadFromInput(input, &byte, 1), 0);
189
212
}
190
213
 
 
214
int IoTest::WriteStuffLarge(ZeroCopyOutputStream* output) {
 
215
  WriteString(output, "Hello world!\n");
 
216
  WriteString(output, "Some te");
 
217
  WriteString(output, "xt.  Blah blah.");
 
218
  WriteString(output, string(100000, 'x'));  // A very long string
 
219
  WriteString(output, string(100000, 'y'));  // A very long string
 
220
  WriteString(output, "01234567890123456789");
 
221
 
 
222
  EXPECT_EQ(output->ByteCount(), 200055);
 
223
 
 
224
  int result = output->ByteCount();
 
225
  return result;
 
226
}
 
227
 
 
228
// Reads text from an input stream and expects it to match what WriteStuff()
 
229
// writes.
 
230
void IoTest::ReadStuffLarge(ZeroCopyInputStream* input) {
 
231
  ReadString(input, "Hello world!\nSome text.  ");
 
232
  EXPECT_TRUE(input->Skip(5));
 
233
  ReadString(input, "blah.");
 
234
  EXPECT_TRUE(input->Skip(100000 - 10));
 
235
  ReadString(input, string(10, 'x') + string(100000 - 20000, 'y'));
 
236
  EXPECT_TRUE(input->Skip(20000 - 10));
 
237
  ReadString(input, "yyyyyyyyyy01234567890123456789");
 
238
 
 
239
  EXPECT_EQ(input->ByteCount(), 200055);
 
240
 
 
241
  uint8 byte;
 
242
  EXPECT_EQ(ReadFromInput(input, &byte, 1), 0);
 
243
}
 
244
 
191
245
// ===================================================================
192
246
 
193
247
TEST_F(IoTest, ArrayIo) {
355
409
TEST_F(IoTest, IostreamIo) {
356
410
  for (int i = 0; i < kBlockSizeCount; i++) {
357
411
    for (int j = 0; j < kBlockSizeCount; j++) {
358
 
      stringstream stream;
359
 
 
360
412
      {
361
 
        OstreamOutputStream output(&stream, kBlockSizes[i]);
362
 
        WriteStuff(&output);
363
 
        EXPECT_FALSE(stream.fail());
 
413
        stringstream stream;
 
414
 
 
415
        {
 
416
          OstreamOutputStream output(&stream, kBlockSizes[i]);
 
417
          WriteStuff(&output);
 
418
          EXPECT_FALSE(stream.fail());
 
419
        }
 
420
 
 
421
        {
 
422
          IstreamInputStream input(&stream, kBlockSizes[j]);
 
423
          ReadStuff(&input);
 
424
          EXPECT_TRUE(stream.eof());
 
425
        }
364
426
      }
365
427
 
366
428
      {
367
 
        IstreamInputStream input(&stream, kBlockSizes[j]);
368
 
        ReadStuff(&input);
369
 
        EXPECT_TRUE(stream.eof());
 
429
        stringstream stream;
 
430
 
 
431
        {
 
432
          OstreamOutputStream output(&stream, kBlockSizes[i]);
 
433
          WriteStuffLarge(&output);
 
434
          EXPECT_FALSE(stream.fail());
 
435
        }
 
436
 
 
437
        {
 
438
          IstreamInputStream input(&stream, kBlockSizes[j]);
 
439
          ReadStuffLarge(&input);
 
440
          EXPECT_TRUE(stream.eof());
 
441
        }
370
442
      }
371
443
    }
372
444
  }