Improve test coverage for kernel fast stream.

trunk/src/protocol/srs_protocol_stream.cpp

@@ -52,14 +52,14 @@ IMergeReadHandler::~IMergeReadHandler()
 }
 #endif
 
-SrsFastStream::SrsFastStream()
+SrsFastStream::SrsFastStream(int size)
 {
 #ifdef SRS_PERF_MERGED_READ
     merged_read = false;
     _handler = NULL;
 #endif
     
-    nb_buffer = SRS_DEFAULT_RECV_BUFFER_SIZE;
+    nb_buffer = size? size:SRS_DEFAULT_RECV_BUFFER_SIZE;
     buffer = (char*)malloc(nb_buffer);
     p = end = buffer;
 }
@@ -84,8 +84,7 @@ void SrsFastStream::set_buffer(int buffer_size)
 {
     // never exceed the max size.
     if (buffer_size > SRS_MAX_SOCKET_BUFFER) {
-        srs_warn("limit the user-space buffer from %d to %d",
+        srs_warn("limit buffer size %d to %d", buffer_size, SRS_MAX_SOCKET_BUFFER);
-                 buffer_size, SRS_MAX_SOCKET_BUFFER);
     }
     
     // the user-space buffer size limit to a max value.
@@ -152,7 +151,7 @@ srs_error_t SrsFastStream::grow(ISrsReader* reader, int required_size)
     srs_assert(nb_exists_bytes >= 0);
     
     // resize the space when no left space.
-    if (nb_free_space < required_size - nb_exists_bytes) {
+    if (nb_exists_bytes + nb_free_space < required_size) {
         // reset or move to get more space.
         if (!nb_exists_bytes) {
             // reset when buffer is empty.
@@ -168,7 +167,7 @@ srs_error_t SrsFastStream::grow(ISrsReader* reader, int required_size)
         
         // check whether enough free space in buffer.
         nb_free_space = (int)(buffer + nb_buffer - end);
-        if (nb_free_space < required_size - nb_exists_bytes) {
+        if (nb_exists_bytes + nb_free_space < required_size) {
             return srs_error_new(ERROR_READER_BUFFER_OVERFLOW, "overflow, required=%d, max=%d, left=%d", required_size, nb_buffer, nb_free_space);
         }
     }

trunk/src/protocol/srs_protocol_stream.hpp

@@ -84,7 +84,8 @@ private:
     // the size of buffer.
     int nb_buffer;
 public:
-    SrsFastStream();
+    // If buffer is 0, use default size.
+    SrsFastStream(int size=0);
     virtual ~SrsFastStream();
 public:
     /**
@@ -128,7 +129,7 @@ public:
     virtual void skip(int size);
 public:
     /**
-     * grow buffer to the required size, loop to read from skt to fill.
+     * grow buffer to atleast required size, loop to read from skt to fill.
      * @param reader, read more bytes from reader to fill the buffer to required size.
      * @param required_size, loop to fill to ensure buffer size to required.
      * @return an int error code, error if required_size negative.

trunk/src/utest/srs_utest_kernel.cpp

@@ -271,8 +271,12 @@ MockBufferReader::~MockBufferReader()
 srs_error_t MockBufferReader::read(void* buf, size_t size, ssize_t* nread)
 {
     int len = srs_min(str.length(), size);
+    if (len == 0) {
+        return srs_error_new(-1, "no data");
+    }
 
     memcpy(buf, str.data(), len);
+    str = str.substr(len);
     
     if (nread) {
         *nread = len;
@@ -388,19 +392,73 @@ VOID TEST(KernelBufferTest, EraseBytes)
 
 VOID TEST(KernelFastBufferTest, Grow)
 {
-    SrsFastStream b;
+    srs_error_t err;
-    MockBufferReader r("winlin");
-    
-    b.grow(&r, 1);
-    EXPECT_EQ('w', b.read_1byte());
 
-    b.grow(&r, 3);
+    if(true) {
-    b.skip(1);
+        SrsFastStream b(5);
-    EXPECT_EQ('n', b.read_1byte());
+        MockBufferReader r("Hello, world!");
-    
+
-    b.grow(&r, 100);
+        HELPER_ASSERT_SUCCESS(b.grow(&r, 5));
-    b.skip(99);
+        b.skip(2);
-    EXPECT_EQ('w', b.read_1byte());
+
+        HELPER_ASSERT_FAILED(b.grow(&r, 6));
+    }
+
+    if(true) {
+        SrsFastStream b(5);
+        MockBufferReader r("Hello, world!");
+
+        HELPER_ASSERT_SUCCESS(b.grow(&r, 5));
+        b.skip(5);
+
+        HELPER_ASSERT_FAILED(b.grow(&r, 6));
+    }
+
+    if(true) {
+        SrsFastStream b(6);
+        MockBufferReader r("Hello, world!");
+
+        HELPER_ASSERT_SUCCESS(b.grow(&r, 5));
+        EXPECT_EQ('H', b.read_1byte()); EXPECT_EQ('e', b.read_1byte()); EXPECT_EQ('l', b.read_1byte());
+        b.skip(2);
+
+        HELPER_ASSERT_SUCCESS(b.grow(&r, 2));
+        b.skip(2);
+
+        HELPER_ASSERT_SUCCESS(b.grow(&r, 5));
+        EXPECT_EQ('w', b.read_1byte()); EXPECT_EQ('o', b.read_1byte()); EXPECT_EQ('r', b.read_1byte());
+        b.skip(2);
+    }
+
+    if(true) {
+        SrsFastStream b(5);
+        MockBufferReader r("Hello, world!");
+
+        HELPER_ASSERT_SUCCESS(b.grow(&r, 5));
+        EXPECT_EQ('H', b.read_1byte()); EXPECT_EQ('e', b.read_1byte()); EXPECT_EQ('l', b.read_1byte());
+        b.skip(2);
+
+        HELPER_ASSERT_SUCCESS(b.grow(&r, 2));
+        b.skip(2);
+
+        HELPER_ASSERT_SUCCESS(b.grow(&r, 5));
+        EXPECT_EQ('w', b.read_1byte()); EXPECT_EQ('o', b.read_1byte()); EXPECT_EQ('r', b.read_1byte());
+        b.skip(2);
+    }
+
+    if (true) {
+        SrsFastStream b;
+        MockBufferReader r("winlin");
+
+        HELPER_ASSERT_SUCCESS(b.grow(&r, 1));
+        EXPECT_EQ('w', b.read_1byte());
+
+        HELPER_ASSERT_SUCCESS(b.grow(&r, 3));
+        b.skip(1);
+        EXPECT_EQ('n', b.read_1byte());
+
+        HELPER_ASSERT_FAILED(b.grow(&r, 100));
+    }
 }
 
 /**