[PPAPI] Implement an IOStreamResource for data transmission between plugin and renderer.

ppapi/shared_impl/circular_buffer_unittest.cc

Index: ppapi/shared_impl/circular_buffer_unittest.cc
diff --git a/ppapi/shared_impl/circular_buffer_unittest.cc b/ppapi/shared_impl/circular_buffer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a5de5500d9570435c026da2a8e831e4f19664664
--- /dev/null
+++ b/ppapi/shared_impl/circular_buffer_unittest.cc
@@ -0,0 +1,223 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/compiler_specific.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/shared_impl/circular_buffer.h"
+#include "ppapi/shared_impl/test_globals.h"

[yzshen1, 2014/01/03 21:51:41]

This is not needed.

+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace ppapi {
+
+typedef testing::Test CircularBufferTest;
+
+TEST_F(CircularBufferTest, TestWrite) {
+  {
+    char buf[] = "0123456789EEEE";
+    scoped_ptr<CircularBuffer> cb(new CircularBuffer(buf, 10));
+
+    cb->MoveLimit(10);
+    EXPECT_EQ(10u, cb->remaining());
+
+    EXPECT_EQ(2, cb->Write("AB", 2));
+    EXPECT_EQ(8U, cb->remaining());
+    EXPECT_STREQ("AB23456789EEEE", buf);
+
+    EXPECT_EQ(4, cb->WriteAll("ABCD", 4));
+    EXPECT_EQ(4U, cb->remaining());
+    EXPECT_STREQ("ABABCD6789EEEE", buf);
+  }
+
+  {
+    char buf[] = "0123456789EEEE";
+    scoped_ptr<CircularBuffer> cb(new CircularBuffer(buf, 10));
+
+    cb->MoveLimit(10);
+    cb->MovePosition(8);
+    EXPECT_EQ(2U, cb->remaining());
+
+    // Do not have enough space for 4 bytes
+    EXPECT_EQ(PP_ERROR_NOSPACE, cb->WriteAll("ABCD", 4));
+    EXPECT_EQ(2U, cb->remaining());
+    EXPECT_STREQ("0123456789EEEE", buf);
+
+    EXPECT_EQ(2, cb->Write("ABCD", 4));
+    EXPECT_EQ(0U, cb->remaining());
+    EXPECT_STREQ("01234567ABEEEE", buf);
+  }
+
+  {
+    char buf[] = "0123456789EEEE";
+    scoped_ptr<CircularBuffer> cb(new CircularBuffer(buf, 10));
+
+    // Make the available range cross border of the buf.
+    cb->MoveLimit(10);
+    cb->MovePosition(8);
+    EXPECT_EQ(2U, cb->remaining());
+
+    cb->MoveLimit(2);
+    EXPECT_EQ(4U, cb->remaining());
+
+    EXPECT_EQ(PP_ERROR_NOSPACE, cb->WriteAll("ABCDEF", 6));
+    EXPECT_EQ(4U, cb->remaining());
+    EXPECT_STREQ("0123456789EEEE", buf);
+
+    EXPECT_EQ(4, cb->Write("ABCDEF", 6));
+    EXPECT_EQ(0U, cb->remaining());
+    EXPECT_STREQ("CD234567ABEEEE", buf);
+  }
+}
+
+TEST_F(CircularBufferTest, TestRead) {
+  {
+    char buf[] = "0123456789EEEE";
+    scoped_ptr<CircularBuffer> cb(new CircularBuffer(buf, 10));
+
+    cb->MoveLimit(10);
+    EXPECT_EQ(10u, cb->remaining());
+
+    {
+      char buf1[] = "AAAAAA";
+      EXPECT_EQ(2, cb->Read(buf1, 2));
+      EXPECT_EQ(8U, cb->remaining());
+      EXPECT_STREQ("01AAAA", buf1);
+    }
+
+    {
+      char buf1[] = "AAAAAA";
+      EXPECT_EQ(4, cb->ReadAll(buf1, 4));
+      EXPECT_EQ(4U, cb->remaining());
+      EXPECT_STREQ("2345AA", buf1);
+    }
+    EXPECT_STREQ("0123456789EEEE", buf);
+  }
+
+  {
+    char buf[] = "0123456789EEEE";
+    scoped_ptr<CircularBuffer> cb(new CircularBuffer(buf, 10));
+
+    cb->MoveLimit(10);
+    cb->MovePosition(8);
+    EXPECT_EQ(2U, cb->remaining());
+
+    // Do not have enough space for 4 bytes
+    char buf1[] = "AAAAAA";
+    EXPECT_EQ(PP_ERROR_NOSPACE, cb->ReadAll(buf1, 4));
+    EXPECT_EQ(2U, cb->remaining());
+    EXPECT_STREQ("AAAAAA", buf1);
+
+    EXPECT_EQ(2, cb->Read(buf1, 4));
+    EXPECT_EQ(0U, cb->remaining());
+    EXPECT_STREQ("89AAAA", buf1);
+
+    EXPECT_STREQ("0123456789EEEE", buf);
+  }
+
+  {
+    char buf[] = "0123456789EEEE";
+    scoped_ptr<CircularBuffer> cb(new CircularBuffer(buf, 10));
+
+    // Make the available range cross border of the buf.
+    cb->MoveLimit(10);
+    cb->MovePosition(8);
+    EXPECT_EQ(2U, cb->remaining());
+
+    cb->MoveLimit(2);
+    EXPECT_EQ(4U, cb->remaining());
+
+    char buf1[] = "AAAAAA";
+    EXPECT_EQ(PP_ERROR_NOSPACE, cb->ReadAll(buf1, 6));
+    EXPECT_EQ(4U, cb->remaining());
+    EXPECT_STREQ("AAAAAA", buf1);
+
+    EXPECT_EQ(4, cb->Read(buf1, 6));
+    EXPECT_EQ(0U, cb->remaining());
+    EXPECT_STREQ("8901AA", buf1);
+
+    EXPECT_STREQ("0123456789EEEE", buf);
+  }
+}
+
+TEST_F(CircularBufferTest, TestLock) {
+  {
+    char buf[] = "0123456789EEEE";
+    char *p = NULL;
+    char *p1 = NULL;
+    scoped_ptr<CircularBuffer> cb(new CircularBuffer(buf, 10));
+
+    cb->MoveLimit(8);
+    cb->MovePosition(2);
+    EXPECT_EQ(6U, cb->remaining());
+
+    EXPECT_EQ(PP_ERROR_NOSPACE, cb->Lock(reinterpret_cast<void**>(&p), 8));
+
+    EXPECT_EQ(PP_OK, cb->Lock(reinterpret_cast<void**>(&p), 2));
+    EXPECT_STREQ(buf + 2, p);
+
+    EXPECT_STREQ("23456789EEEE", p);
+
+    p[0] = 'A';
+    p[1] = 'B';
+    EXPECT_STREQ("01AB456789EEEE", buf);
+
+    // Write with the CricularBuffer locked.
+    EXPECT_EQ(PP_ERROR_INPROGRESS, cb->Write("CD", 2));
+    EXPECT_EQ(PP_ERROR_INPROGRESS, cb->WriteAll("CD", 2));
+
+    // Read with the CricularBuffer locked.
+    char buf1[2];
+    EXPECT_EQ(PP_ERROR_INPROGRESS, cb->Read(buf1, 2));
+    EXPECT_EQ(PP_ERROR_INPROGRESS, cb->ReadAll(buf1, 2));
+
+    // Lock the CricularBuffer again.
+    EXPECT_EQ(PP_ERROR_INPROGRESS, cb->Lock(reinterpret_cast<void**>(&p1), 2));
+
+    // Unlock with an invalid pointer.
+    EXPECT_EQ(PP_ERROR_BADARGUMENT, cb->Unlock(p + 1));
+    EXPECT_EQ(2, cb->Unlock(p));
+    EXPECT_EQ(4U, cb->remaining());
+
+    EXPECT_EQ(PP_OK, cb->Lock(reinterpret_cast<void**>(&p1), 2));
+    EXPECT_STREQ(buf + 4, p1);
+
+    EXPECT_EQ(2, cb->Unlock(p1));
+    EXPECT_EQ(2U, cb->remaining());
+  }
+
+  {
+    char buf[] = "0123456789EEEE";
+    char *p = NULL;
+    scoped_ptr<CircularBuffer> cb(new CircularBuffer(buf, 10));
+
+    // Make the available range cross border of the buf.
+    cb->MoveLimit(10);
+    cb->MovePosition(5);
+    EXPECT_EQ(5U, cb->remaining());
+
+    cb->MoveLimit(5);
+    EXPECT_EQ(10U, cb->remaining());
+
+    // Try Lock a range cross border of the buf.
+    EXPECT_EQ(PP_ERROR_FAILED, cb->Lock(reinterpret_cast<void**>(&p), 8));
+
+    EXPECT_EQ(PP_OK, cb->Lock(reinterpret_cast<void**>(&p), 5));
+    EXPECT_EQ(buf + 5, p);
+    EXPECT_EQ(5, cb->Unlock(p));
+  }
+}
+
+TEST_F(CircularBufferTest, TestCrash) {
+  char buf[] = "0123456789EEEE";
+  scoped_ptr<CircularBuffer> cb(new CircularBuffer(buf, 10));
+
+  cb->MoveLimit(10);
+  EXPECT_EQ(10u, cb->remaining());
+
+  EXPECT_DEATH(cb->MoveLimit(1), ".*Check failed:.*");
+
+  cb->MovePosition(8);
+  EXPECT_DEATH(cb->MovePosition(3), ".*Check failed:.*");
+}
+
+}  // namespace ppapi