android_webview/browser/net/input_stream_reader_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "android_webview/browser/input_stream.h"
   6 #include "android_webview/browser/net/input_stream_reader.h"
   7 #include "base/android/scoped_java_ref.h"
   8 #include "base/callback.h"
   9 #include "base/memory/ref_counted.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "net/base/io_buffer.h"
  12 #include "net/http/http_byte_range.h"
  13
  14 #include "testing/gmock/include/gmock/gmock.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 using android_webview::InputStream;
  18 using android_webview::InputStreamReader;
  19 using testing::DoAll;
  20 using testing::Ge;
  21 using testing::InSequence;
  22 using testing::Lt;
  23 using testing::Ne;
  24 using testing::NotNull;
  25 using testing::Return;
  26 using testing::SetArgPointee;
  27 using testing::Test;
  28 using testing::_;
  29
  30 class MockInputStream : public InputStream {
  31  public:
  32   MockInputStream() {}
  33   virtual ~MockInputStream() {}
  34
  35   MOCK_CONST_METHOD1(BytesAvailable, bool(int* bytes_available));
  36   MOCK_METHOD2(Skip, bool(int64_t n, int64_t* bytes_skipped));
  37   MOCK_METHOD3(Read, bool(net::IOBuffer* dest, int length, int* bytes_read));
  38 };
  39
  40 class InputStreamReaderTest : public Test {
  41  public:
  42   InputStreamReaderTest()
  43       : input_stream_reader_(&input_stream_) {
  44   }
  45  protected:
  46   int SeekRange(int first_byte, int last_byte) {
  47     net::HttpByteRange byte_range;
  48     byte_range.set_first_byte_position(first_byte);
  49     byte_range.set_last_byte_position(last_byte);
  50     return input_stream_reader_.Seek(byte_range);
  51   }
  52
  53   int ReadRawData(scoped_refptr<net::IOBuffer> buffer, int bytesToRead) {
  54     return input_stream_reader_.ReadRawData(buffer.get(), bytesToRead);
  55   }
  56
  57   MockInputStream input_stream_;
  58   InputStreamReader input_stream_reader_;
  59 };
  60
  61 TEST_F(InputStreamReaderTest, BytesAvailableFailurePropagationOnSeek) {
  62   EXPECT_CALL(input_stream_, BytesAvailable(NotNull()))
  63       .WillOnce(Return(false));
  64
  65   ASSERT_GT(0, SeekRange(0, 0));
  66 }
  67
  68 TEST_F(InputStreamReaderTest, SkipFailurePropagationOnSeek) {
  69   const int streamSize = 10;
  70   const int bytesToSkip = 5;
  71
  72   EXPECT_CALL(input_stream_, BytesAvailable(NotNull()))
  73       .WillOnce(DoAll(SetArgPointee<0>(streamSize),
  74                       Return(true)));
  75
  76   EXPECT_CALL(input_stream_, Skip(bytesToSkip, NotNull()))
  77       .WillOnce(Return(false));
  78
  79   ASSERT_GT(0, SeekRange(bytesToSkip, streamSize - 1));
  80 }
  81
  82 TEST_F(InputStreamReaderTest, SeekToMiddle) {
  83   const int streamSize = 10;
  84   const int bytesToSkip = 5;
  85
  86   EXPECT_CALL(input_stream_, BytesAvailable(NotNull()))
  87       .WillOnce(DoAll(SetArgPointee<0>(streamSize),
  88                       Return(true)));
  89
  90   EXPECT_CALL(input_stream_, Skip(bytesToSkip, NotNull()))
  91       .WillOnce(DoAll(SetArgPointee<1>(bytesToSkip),
  92                       Return(true)));
  93
  94   ASSERT_EQ(bytesToSkip, SeekRange(bytesToSkip, streamSize - 1));
  95 }
  96
  97 TEST_F(InputStreamReaderTest, SeekToMiddleInSteps) {
  98   const int streamSize = 10;
  99   const int bytesToSkip = 5;
 100
 101   EXPECT_CALL(input_stream_, BytesAvailable(NotNull()))
 102       .Times(1)
 103       .WillOnce(DoAll(SetArgPointee<0>(streamSize),
 104                       Return(true)));
 105
 106   EXPECT_CALL(input_stream_, Skip(_, _))
 107       .Times(0);
 108   {
 109     InSequence s;
 110     EXPECT_CALL(input_stream_, Skip(bytesToSkip, NotNull()))
 111         .WillOnce(DoAll(SetArgPointee<1>(bytesToSkip - 3),
 112                         Return(true)))
 113         .RetiresOnSaturation();
 114     EXPECT_CALL(input_stream_, Skip(3, NotNull()))
 115         .WillOnce(DoAll(SetArgPointee<1>(1),
 116                         Return(true)))
 117         .RetiresOnSaturation();
 118     EXPECT_CALL(input_stream_, Skip(2, NotNull()))
 119         .WillOnce(DoAll(SetArgPointee<1>(2),
 120                         Return(true)))
 121         .RetiresOnSaturation();
 122   }
 123
 124   ASSERT_EQ(bytesToSkip, SeekRange(bytesToSkip, streamSize - 1));
 125 }
 126
 127 TEST_F(InputStreamReaderTest, SeekEmpty) {
 128   EXPECT_CALL(input_stream_, BytesAvailable(NotNull()))
 129       .WillOnce(DoAll(SetArgPointee<0>(0),
 130                       Return(true)));
 131
 132   ASSERT_EQ(0, SeekRange(0, 0));
 133 }
 134
 135 TEST_F(InputStreamReaderTest, SeekMoreThanAvailable) {
 136   const int bytesAvailable = 256;
 137   EXPECT_CALL(input_stream_, BytesAvailable(NotNull()))
 138       .WillOnce(DoAll(SetArgPointee<0>(bytesAvailable),
 139                       Return(true)));
 140
 141   ASSERT_GT(0, SeekRange(bytesAvailable, 2 * bytesAvailable));
 142 }
 143
 144 TEST_F(InputStreamReaderTest, ReadFailure) {
 145   const int bytesToRead = 128;
 146   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(bytesToRead);
 147   EXPECT_CALL(input_stream_, Read(buffer.get(), bytesToRead, NotNull()))
 148       .WillOnce(Return(false));
 149
 150   ASSERT_GT(0, ReadRawData(buffer, bytesToRead));
 151 }
 152
 153 TEST_F(InputStreamReaderTest, ReadNothing) {
 154   const int bytesToRead = 0;
 155   // Size of net::IOBuffer can't be 0.
 156   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(1);
 157   EXPECT_CALL(input_stream_, Read(buffer.get(), bytesToRead, NotNull()))
 158       .Times(0);
 159
 160   ASSERT_EQ(0, ReadRawData(buffer, bytesToRead));
 161 }
 162
 163 TEST_F(InputStreamReaderTest, ReadSuccess) {
 164   const int bytesToRead = 128;
 165   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(bytesToRead);
 166
 167   EXPECT_CALL(input_stream_, Read(buffer.get(), bytesToRead, NotNull()))
 168       .WillOnce(DoAll(SetArgPointee<2>(bytesToRead),
 169                       Return(true)));
 170
 171   ASSERT_EQ(bytesToRead, ReadRawData(buffer, bytesToRead));
 172 }