src/third_party/webrtc/base/stream_unittest.cc

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