content/browser/loader/resource_buffer_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 "content/browser/loader/resource_buffer.h"
   6 #include "testing/gtest/include/gtest/gtest.h"
   7
   8 namespace content {
   9
  10 TEST(ResourceBufferTest, BasicAllocations) {
  11   scoped_refptr<ResourceBuffer> buf = new ResourceBuffer();
  12   EXPECT_TRUE(buf->Initialize(100, 5, 10));
  13   EXPECT_TRUE(buf->CanAllocate());
  14
  15   // First allocation
  16   {
  17     int size;
  18     char* ptr = buf->Allocate(&size);
  19     EXPECT_TRUE(ptr);
  20     EXPECT_EQ(10, size);
  21     EXPECT_TRUE(buf->CanAllocate());
  22
  23     EXPECT_EQ(0, buf->GetLastAllocationOffset());
  24
  25     buf->ShrinkLastAllocation(2);  // Less than our min allocation size.
  26     EXPECT_EQ(0, buf->GetLastAllocationOffset());
  27     EXPECT_TRUE(buf->CanAllocate());
  28   }
  29
  30   // Second allocation
  31   {
  32     int size;
  33     char* ptr = buf->Allocate(&size);
  34     EXPECT_TRUE(ptr);
  35     EXPECT_EQ(10, size);
  36     EXPECT_TRUE(buf->CanAllocate());
  37
  38     EXPECT_EQ(5, buf->GetLastAllocationOffset());
  39
  40     buf->ShrinkLastAllocation(4);
  41     EXPECT_EQ(5, buf->GetLastAllocationOffset());
  42
  43     EXPECT_TRUE(buf->CanAllocate());
  44   }
  45 }
  46
  47 TEST(ResourceBufferTest, AllocateAndRecycle) {
  48   scoped_refptr<ResourceBuffer> buf = new ResourceBuffer();
  49   EXPECT_TRUE(buf->Initialize(100, 5, 10));
  50
  51   int size;
  52
  53   buf->Allocate(&size);
  54   EXPECT_EQ(0, buf->GetLastAllocationOffset());
  55
  56   buf->RecycleLeastRecentlyAllocated();
  57
  58   // Offset should again be 0.
  59   buf->Allocate(&size);
  60   EXPECT_EQ(0, buf->GetLastAllocationOffset());
  61 }
  62
  63 TEST(ResourceBufferTest, WrapAround) {
  64   scoped_refptr<ResourceBuffer> buf = new ResourceBuffer();
  65   EXPECT_TRUE(buf->Initialize(20, 10, 10));
  66
  67   int size;
  68
  69   buf->Allocate(&size);
  70   EXPECT_EQ(10, size);
  71
  72   buf->Allocate(&size);
  73   EXPECT_EQ(10, size);
  74
  75   // Create hole at the beginnning.  Next allocation should go there.
  76   buf->RecycleLeastRecentlyAllocated();
  77
  78   buf->Allocate(&size);
  79   EXPECT_EQ(10, size);
  80
  81   EXPECT_EQ(0, buf->GetLastAllocationOffset());
  82 }
  83
  84 TEST(ResourceBufferTest, WrapAround2) {
  85   scoped_refptr<ResourceBuffer> buf = new ResourceBuffer();
  86   EXPECT_TRUE(buf->Initialize(30, 10, 10));
  87
  88   int size;
  89
  90   buf->Allocate(&size);
  91   EXPECT_EQ(10, size);
  92
  93   buf->Allocate(&size);
  94   EXPECT_EQ(10, size);
  95
  96   buf->Allocate(&size);
  97   EXPECT_EQ(10, size);
  98
  99   EXPECT_FALSE(buf->CanAllocate());
 100
 101   // Create holes at first and second slots.
 102   buf->RecycleLeastRecentlyAllocated();
 103   buf->RecycleLeastRecentlyAllocated();
 104
 105   EXPECT_TRUE(buf->CanAllocate());
 106
 107   buf->Allocate(&size);
 108   EXPECT_EQ(10, size);
 109   EXPECT_EQ(0, buf->GetLastAllocationOffset());
 110
 111   buf->Allocate(&size);
 112   EXPECT_EQ(10, size);
 113   EXPECT_EQ(10, buf->GetLastAllocationOffset());
 114
 115   EXPECT_FALSE(buf->CanAllocate());
 116 }
 117
 118 TEST(ResourceBufferTest, Full) {
 119   scoped_refptr<ResourceBuffer> buf = new ResourceBuffer();
 120   EXPECT_TRUE(buf->Initialize(20, 10, 10));
 121
 122   int size;
 123   buf->Allocate(&size);
 124   EXPECT_EQ(10, size);
 125
 126   buf->Allocate(&size);
 127   EXPECT_EQ(10, size);
 128
 129   // Full.
 130   EXPECT_FALSE(buf->CanAllocate());
 131
 132   // Still full, even if there is a small hole at the end.
 133   buf->ShrinkLastAllocation(5);
 134   EXPECT_FALSE(buf->CanAllocate());
 135 }
 136
 137 }  // namespace content