content/browser/renderer_host/resource_buffer_unittest.cc - Issue 11414299: Add content/browser/loader/ for resource loading related classes.

Side by Side Diff: content/browser/renderer_host/resource_buffer_unittest.cc

Issue 11414299: Add content/browser/loader/ for resource loading related classes. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/

Patch Set: Created 8 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

« no previous file with comments | « content/browser/renderer_host/resource_buffer.cc ('k') | content/browser/renderer_host/resource_dispatcher_host_browsertest.cc » ('j') | content/browser/renderer_host/socket_stream_dispatcher_host.h » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
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/renderer_host/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

OLD	NEW