1/*
2 *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#include "webrtc/base/gunit.h"
12#include "webrtc/base/stream.h"
13#include "webrtc/test/testsupport/gtest_disable.h"
14
15namespace rtc {
16
17///////////////////////////////////////////////////////////////////////////////
18// TestStream
19///////////////////////////////////////////////////////////////////////////////
20
21class TestStream : public StreamInterface {
22 public:
23  TestStream() : pos_(0) { }
24
25  virtual StreamState GetState() const { return SS_OPEN; }
26  virtual StreamResult Read(void* buffer, size_t buffer_len,
27                            size_t* read, int* error) {
28    unsigned char* uc_buffer = static_cast<unsigned char*>(buffer);
29    for (size_t i = 0; i < buffer_len; ++i) {
30      uc_buffer[i] = static_cast<unsigned char>(pos_++);
31    }
32    if (read)
33      *read = buffer_len;
34    return SR_SUCCESS;
35  }
36  virtual StreamResult Write(const void* data, size_t data_len,
37                             size_t* written, int* error) {
38    if (error)
39      *error = -1;
40    return SR_ERROR;
41  }
42  virtual void Close() { }
43  virtual bool SetPosition(size_t position) {
44    pos_ = position;
45    return true;
46  }
47  virtual bool GetPosition(size_t* position) const {
48    if (position) *position = pos_;
49    return true;
50  }
51  virtual bool GetSize(size_t* size) const {
52    return false;
53  }
54  virtual bool GetAvailable(size_t* size) const {
55    return false;
56  }
57
58 private:
59  size_t pos_;
60};
61
62bool VerifyTestBuffer(unsigned char* buffer, size_t len,
63                      unsigned char value) {
64  bool passed = true;
65  for (size_t i = 0; i < len; ++i) {
66    if (buffer[i] != value++) {
67      passed = false;
68      break;
69    }
70  }
71  // Ensure that we don't pass again without re-writing
72  memset(buffer, 0, len);
73  return passed;
74}
75
76void SeekTest(StreamInterface* stream, const unsigned char value) {
77  size_t bytes;
78  unsigned char buffer[13] = { 0 };
79  const size_t kBufSize = sizeof(buffer);
80
81  EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
82  EXPECT_EQ(bytes, kBufSize);
83  EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, value));
84  EXPECT_TRUE(stream->GetPosition(&bytes));
85  EXPECT_EQ(13U, bytes);
86
87  EXPECT_TRUE(stream->SetPosition(7));
88
89  EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
90  EXPECT_EQ(bytes, kBufSize);
91  EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, value + 7));
92  EXPECT_TRUE(stream->GetPosition(&bytes));
93  EXPECT_EQ(20U, bytes);
94}
95
96TEST(StreamSegment, TranslatesPosition) {
97  TestStream* test = new TestStream;
98  // Verify behavior of original stream
99  SeekTest(test, 0);
100  StreamSegment* segment = new StreamSegment(test);
101  // Verify behavior of adapted stream (all values offset by 20)
102  SeekTest(segment, 20);
103  delete segment;
104}
105
106TEST(StreamSegment, SupportsArtificialTermination) {
107  TestStream* test = new TestStream;
108
109  size_t bytes;
110  unsigned char buffer[5000] = { 0 };
111  const size_t kBufSize = sizeof(buffer);
112
113  {
114    StreamInterface* stream = test;
115
116    // Read a lot of bytes
117    EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
118    EXPECT_EQ(bytes, kBufSize);
119    EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, 0));
120
121    // Test seeking far ahead
122    EXPECT_TRUE(stream->SetPosition(12345));
123
124    // Read a bunch more bytes
125    EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
126    EXPECT_EQ(bytes, kBufSize);
127    EXPECT_TRUE(VerifyTestBuffer(buffer, kBufSize, 12345 % 256));
128  }
129
130  // Create a segment of test stream in range [100,600)
131  EXPECT_TRUE(test->SetPosition(100));
132  StreamSegment* segment = new StreamSegment(test, 500);
133
134  {
135    StreamInterface* stream = segment;
136
137    EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
138    EXPECT_EQ(500U, bytes);
139    EXPECT_TRUE(VerifyTestBuffer(buffer, 500, 100));
140    EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_EOS);
141
142    // Test seeking past "end" of stream
143    EXPECT_FALSE(stream->SetPosition(12345));
144    EXPECT_FALSE(stream->SetPosition(501));
145
146    // Test seeking to end (edge case)
147    EXPECT_TRUE(stream->SetPosition(500));
148    EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_EOS);
149
150    // Test seeking to start
151    EXPECT_TRUE(stream->SetPosition(0));
152    EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_SUCCESS);
153    EXPECT_EQ(500U, bytes);
154    EXPECT_TRUE(VerifyTestBuffer(buffer, 500, 100));
155    EXPECT_EQ(stream->Read(buffer, kBufSize, &bytes, NULL), SR_EOS);
156  }
157
158  delete segment;
159}
160
161TEST(FifoBufferTest, TestAll) {
162  const size_t kSize = 16;
163  const char in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
164  char out[kSize * 2];
165  void* p;
166  const void* q;
167  size_t bytes;
168  FifoBuffer buf(kSize);
169  StreamInterface* stream = &buf;
170
171  // Test assumptions about base state
172  EXPECT_EQ(SS_OPEN, stream->GetState());
173  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
174  EXPECT_TRUE(NULL != stream->GetReadData(&bytes));
175  EXPECT_EQ((size_t)0, bytes);
176  stream->ConsumeReadData(0);
177  EXPECT_TRUE(NULL != stream->GetWriteBuffer(&bytes));
178  EXPECT_EQ(kSize, bytes);
179  stream->ConsumeWriteBuffer(0);
180
181  // Try a full write
182  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
183  EXPECT_EQ(kSize, bytes);
184
185  // Try a write that should block
186  EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, NULL));
187
188  // Try a full read
189  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
190  EXPECT_EQ(kSize, bytes);
191  EXPECT_EQ(0, memcmp(in, out, kSize));
192
193  // Try a read that should block
194  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
195
196  // Try a too-big write
197  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 2, &bytes, NULL));
198  EXPECT_EQ(bytes, kSize);
199
200  // Try a too-big read
201  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, NULL));
202  EXPECT_EQ(kSize, bytes);
203  EXPECT_EQ(0, memcmp(in, out, kSize));
204
205  // Try some small writes and reads
206  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
207  EXPECT_EQ(kSize / 2, bytes);
208  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
209  EXPECT_EQ(kSize / 2, bytes);
210  EXPECT_EQ(0, memcmp(in, out, kSize / 2));
211  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
212  EXPECT_EQ(kSize / 2, bytes);
213  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
214  EXPECT_EQ(kSize / 2, bytes);
215  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
216  EXPECT_EQ(kSize / 2, bytes);
217  EXPECT_EQ(0, memcmp(in, out, kSize / 2));
218  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
219  EXPECT_EQ(kSize / 2, bytes);
220  EXPECT_EQ(0, memcmp(in, out, kSize / 2));
221
222  // Try wraparound reads and writes in the following pattern
223  // WWWWWWWWWWWW.... 0123456789AB....
224  // RRRRRRRRXXXX.... ........89AB....
225  // WWWW....XXXXWWWW 4567....89AB0123
226  // XXXX....RRRRXXXX 4567........0123
227  // XXXXWWWWWWWWXXXX 4567012345670123
228  // RRRRXXXXXXXXRRRR ....01234567....
229  // ....RRRRRRRR.... ................
230  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, NULL));
231  EXPECT_EQ(kSize * 3 / 4, bytes);
232  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
233  EXPECT_EQ(kSize / 2, bytes);
234  EXPECT_EQ(0, memcmp(in, out, kSize / 2));
235  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
236  EXPECT_EQ(kSize / 2, bytes);
237  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 4, &bytes, NULL));
238  EXPECT_EQ(kSize / 4 , bytes);
239  EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
240  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
241  EXPECT_EQ(kSize / 2, bytes);
242  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
243  EXPECT_EQ(kSize / 2 , bytes);
244  EXPECT_EQ(0, memcmp(in, out, kSize / 2));
245  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
246  EXPECT_EQ(kSize / 2 , bytes);
247  EXPECT_EQ(0, memcmp(in, out, kSize / 2));
248
249  // Use GetWriteBuffer to reset the read_position for the next tests
250  stream->GetWriteBuffer(&bytes);
251  stream->ConsumeWriteBuffer(0);
252
253  // Try using GetReadData to do a full read
254  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
255  q = stream->GetReadData(&bytes);
256  EXPECT_TRUE(NULL != q);
257  EXPECT_EQ(kSize, bytes);
258  EXPECT_EQ(0, memcmp(q, in, kSize));
259  stream->ConsumeReadData(kSize);
260  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
261
262  // Try using GetReadData to do some small reads
263  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
264  q = stream->GetReadData(&bytes);
265  EXPECT_TRUE(NULL != q);
266  EXPECT_EQ(kSize, bytes);
267  EXPECT_EQ(0, memcmp(q, in, kSize / 2));
268  stream->ConsumeReadData(kSize / 2);
269  q = stream->GetReadData(&bytes);
270  EXPECT_TRUE(NULL != q);
271  EXPECT_EQ(kSize / 2, bytes);
272  EXPECT_EQ(0, memcmp(q, in + kSize / 2, kSize / 2));
273  stream->ConsumeReadData(kSize / 2);
274  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
275
276  // Try using GetReadData in a wraparound case
277  // WWWWWWWWWWWWWWWW 0123456789ABCDEF
278  // RRRRRRRRRRRRXXXX ............CDEF
279  // WWWWWWWW....XXXX 01234567....CDEF
280  // ............RRRR 01234567........
281  // RRRRRRRR........ ................
282  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
283  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, NULL));
284  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
285  q = stream->GetReadData(&bytes);
286  EXPECT_TRUE(NULL != q);
287  EXPECT_EQ(kSize / 4, bytes);
288  EXPECT_EQ(0, memcmp(q, in + kSize * 3 / 4, kSize / 4));
289  stream->ConsumeReadData(kSize / 4);
290  q = stream->GetReadData(&bytes);
291  EXPECT_TRUE(NULL != q);
292  EXPECT_EQ(kSize / 2, bytes);
293  EXPECT_EQ(0, memcmp(q, in, kSize / 2));
294  stream->ConsumeReadData(kSize / 2);
295
296  // Use GetWriteBuffer to reset the read_position for the next tests
297  stream->GetWriteBuffer(&bytes);
298  stream->ConsumeWriteBuffer(0);
299
300  // Try using GetWriteBuffer to do a full write
301  p = stream->GetWriteBuffer(&bytes);
302  EXPECT_TRUE(NULL != p);
303  EXPECT_EQ(kSize, bytes);
304  memcpy(p, in, kSize);
305  stream->ConsumeWriteBuffer(kSize);
306  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
307  EXPECT_EQ(kSize, bytes);
308  EXPECT_EQ(0, memcmp(in, out, kSize));
309
310  // Try using GetWriteBuffer to do some small writes
311  p = stream->GetWriteBuffer(&bytes);
312  EXPECT_TRUE(NULL != p);
313  EXPECT_EQ(kSize, bytes);
314  memcpy(p, in, kSize / 2);
315  stream->ConsumeWriteBuffer(kSize / 2);
316  p = stream->GetWriteBuffer(&bytes);
317  EXPECT_TRUE(NULL != p);
318  EXPECT_EQ(kSize / 2, bytes);
319  memcpy(p, in + kSize / 2, kSize / 2);
320  stream->ConsumeWriteBuffer(kSize / 2);
321  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
322  EXPECT_EQ(kSize, bytes);
323  EXPECT_EQ(0, memcmp(in, out, kSize));
324
325  // Try using GetWriteBuffer in a wraparound case
326  // WWWWWWWWWWWW.... 0123456789AB....
327  // RRRRRRRRXXXX.... ........89AB....
328  // ........XXXXWWWW ........89AB0123
329  // WWWW....XXXXXXXX 4567....89AB0123
330  // RRRR....RRRRRRRR ................
331  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, NULL));
332  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
333  p = stream->GetWriteBuffer(&bytes);
334  EXPECT_TRUE(NULL != p);
335  EXPECT_EQ(kSize / 4, bytes);
336  memcpy(p, in, kSize / 4);
337  stream->ConsumeWriteBuffer(kSize / 4);
338  p = stream->GetWriteBuffer(&bytes);
339  EXPECT_TRUE(NULL != p);
340  EXPECT_EQ(kSize / 2, bytes);
341  memcpy(p, in + kSize / 4, kSize / 4);
342  stream->ConsumeWriteBuffer(kSize / 4);
343  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, NULL));
344  EXPECT_EQ(kSize * 3 / 4, bytes);
345  EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
346  EXPECT_EQ(0, memcmp(in, out + kSize / 4, kSize / 4));
347
348  // Check that the stream is now empty
349  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, NULL));
350
351  // Try growing the buffer
352  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
353  EXPECT_EQ(kSize, bytes);
354  EXPECT_TRUE(buf.SetCapacity(kSize * 2));
355  EXPECT_EQ(SR_SUCCESS, stream->Write(in + kSize, kSize, &bytes, NULL));
356  EXPECT_EQ(kSize, bytes);
357  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, NULL));
358  EXPECT_EQ(kSize * 2, bytes);
359  EXPECT_EQ(0, memcmp(in, out, kSize * 2));
360
361  // Try shrinking the buffer
362  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, NULL));
363  EXPECT_EQ(kSize, bytes);
364  EXPECT_TRUE(buf.SetCapacity(kSize));
365  EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, NULL));
366  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, NULL));
367  EXPECT_EQ(kSize, bytes);
368  EXPECT_EQ(0, memcmp(in, out, kSize));
369
370  // Write to the stream, close it, read the remaining bytes
371  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, NULL));
372  stream->Close();
373  EXPECT_EQ(SS_CLOSED, stream->GetState());
374  EXPECT_EQ(SR_EOS, stream->Write(in, kSize / 2, &bytes, NULL));
375  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, NULL));
376  EXPECT_EQ(0, memcmp(in, out, kSize / 2));
377  EXPECT_EQ(SR_EOS, stream->Read(out, kSize / 2, &bytes, NULL));
378}
379
380TEST(FifoBufferTest, FullBufferCheck) {
381  FifoBuffer buff(10);
382  buff.ConsumeWriteBuffer(10);
383
384  size_t free;
385  EXPECT_TRUE(buff.GetWriteBuffer(&free) != NULL);
386  EXPECT_EQ(0U, free);
387}
388
389TEST(FifoBufferTest, WriteOffsetAndReadOffset) {
390  const size_t kSize = 16;
391  const char in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
392  char out[kSize * 2];
393  FifoBuffer buf(kSize);
394
395  // Write 14 bytes.
396  EXPECT_EQ(SR_SUCCESS, buf.Write(in, 14, NULL, NULL));
397
398  // Make sure data is in |buf|.
399  size_t buffered;
400  EXPECT_TRUE(buf.GetBuffered(&buffered));
401  EXPECT_EQ(14u, buffered);
402
403  // Read 10 bytes.
404  buf.ConsumeReadData(10);
405
406  // There should be now 12 bytes of available space.
407  size_t remaining;
408  EXPECT_TRUE(buf.GetWriteRemaining(&remaining));
409  EXPECT_EQ(12u, remaining);
410
411  // Write at offset 12, this should fail.
412  EXPECT_EQ(SR_BLOCK, buf.WriteOffset(in, 10, 12, NULL));
413
414  // Write 8 bytes at offset 4, this wraps around the buffer.
415  EXPECT_EQ(SR_SUCCESS, buf.WriteOffset(in, 8, 4, NULL));
416
417  // Number of available space remains the same until we call
418  // ConsumeWriteBuffer().
419  EXPECT_TRUE(buf.GetWriteRemaining(&remaining));
420  EXPECT_EQ(12u, remaining);
421  buf.ConsumeWriteBuffer(12);
422
423  // There's 4 bytes bypassed and 4 bytes no read so skip them and verify the
424  // 8 bytes written.
425  size_t read;
426  EXPECT_EQ(SR_SUCCESS, buf.ReadOffset(out, 8, 8, &read));
427  EXPECT_EQ(8u, read);
428  EXPECT_EQ(0, memcmp(out, in, 8));
429
430  // There should still be 16 bytes available for reading.
431  EXPECT_TRUE(buf.GetBuffered(&buffered));
432  EXPECT_EQ(16u, buffered);
433
434  // Read at offset 16, this should fail since we don't have that much data.
435  EXPECT_EQ(SR_BLOCK, buf.ReadOffset(out, 10, 16, NULL));
436}
437
438TEST(AsyncWriteTest, DISABLED_ON_MAC(TestWrite)) {
439  FifoBuffer* buf = new FifoBuffer(100);
440  AsyncWriteStream stream(buf, Thread::Current());
441  EXPECT_EQ(SS_OPEN, stream.GetState());
442
443  // Write "abc".  Will go to the logging thread, which is the current
444  // thread.
445  stream.Write("abc", 3, NULL, NULL);
446  char bytes[100];
447  size_t count;
448  // Messages on the thread's queue haven't been processed, so "abc"
449  // hasn't been written yet.
450  EXPECT_NE(SR_SUCCESS, buf->ReadOffset(&bytes, 3, 0, &count));
451  // Now we process the messages on the thread's queue, so "abc" has
452  // been written.
453  EXPECT_TRUE_WAIT(SR_SUCCESS == buf->ReadOffset(&bytes, 3, 0, &count), 10);
454  EXPECT_EQ(3u, count);
455  EXPECT_EQ(0, memcmp(bytes, "abc", 3));
456
457  // Write "def".  Will go to the logging thread, which is the current
458  // thread.
459  stream.Write("d", 1, &count, NULL);
460  stream.Write("e", 1, &count, NULL);
461  stream.Write("f", 1, &count, NULL);
462  EXPECT_EQ(1u, count);
463  // Messages on the thread's queue haven't been processed, so "def"
464  // hasn't been written yet.
465  EXPECT_NE(SR_SUCCESS, buf->ReadOffset(&bytes, 3, 3, &count));
466  // Flush() causes the message to be processed, so "def" has now been
467  // written.
468  stream.Flush();
469  EXPECT_EQ(SR_SUCCESS, buf->ReadOffset(&bytes, 3, 3, &count));
470  EXPECT_EQ(3u, count);
471  EXPECT_EQ(0, memcmp(bytes, "def", 3));
472
473  // Write "xyz".  Will go to the logging thread, which is the current
474  // thread.
475  stream.Write("xyz", 3, &count, NULL);
476  EXPECT_EQ(3u, count);
477  // Messages on the thread's queue haven't been processed, so "xyz"
478  // hasn't been written yet.
479  EXPECT_NE(SR_SUCCESS, buf->ReadOffset(&bytes, 3, 6, &count));
480  // Close() causes the message to be processed, so "xyz" has now been
481  // written.
482  stream.Close();
483  EXPECT_EQ(SR_SUCCESS, buf->ReadOffset(&bytes, 3, 6, &count));
484  EXPECT_EQ(3u, count);
485  EXPECT_EQ(0, memcmp(bytes, "xyz", 3));
486  EXPECT_EQ(SS_CLOSED, stream.GetState());
487
488  // Is't closed, so the writes should fail.
489  EXPECT_EQ(SR_ERROR, stream.Write("000", 3, NULL, NULL));
490
491}
492
493}  // namespace rtc
494