OLD | NEW |
| (Empty) |
1 // Copyright (c) 2013 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 // The test buffer data is 52 bytes, wrap position is set to 20 (this is | |
6 // arbitrarily chosen). The total buffer size is allocated dynamically based on | |
7 // the actual header size. This gives: | |
8 // Header of some size, non-wrapping part 20 bytes, wrapping part 32 bytes. | |
9 // As input data, a 14 byte array is used and repeatedly written. It's chosen | |
10 // not to be an integer factor smaller than the wrapping part. This ensures that | |
11 // the wrapped data isn't repeated at the same position. | |
12 // Note that desipte the number of wraps (if one or more), the reference output | |
13 // data is the same since the offset at each wrap is always the same. | |
14 | |
15 #include "base/memory/scoped_ptr.h" | |
16 #include "content/common/partial_circular_buffer.h" | |
17 #include "testing/gtest/include/gtest/gtest.h" | |
18 | |
19 namespace content { | |
20 | |
21 const uint32 kWrapPosition = 20; | |
22 const uint8 kInputData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}; | |
23 const uint8 kOutputRefDataWrap[] = | |
24 // The 20 bytes in the non-wrapping part. | |
25 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1, 2, 3, 4, 5, 6, | |
26 // The 32 bytes in wrapping part. | |
27 11, 12, 13, 14, | |
28 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, | |
29 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}; | |
30 | |
31 class PartialCircularBufferTest : public testing::Test { | |
32 public: | |
33 PartialCircularBufferTest() { | |
34 PartialCircularBuffer::BufferData test_struct; | |
35 buffer_header_size_ = | |
36 &test_struct.data[0] - reinterpret_cast<uint8*>(&test_struct); | |
37 | |
38 buffer_.reset(new uint8[buffer_header_size_ + sizeof(kOutputRefDataWrap)]); | |
39 pcb_write_.reset(new PartialCircularBuffer( | |
40 buffer_.get(), | |
41 buffer_header_size_ + sizeof(kOutputRefDataWrap), | |
42 kWrapPosition)); | |
43 } | |
44 | |
45 void WriteToBuffer(int num) { | |
46 for (int i = 0; i < num; ++i) | |
47 pcb_write_->Write(kInputData, sizeof(kInputData)); | |
48 } | |
49 | |
50 void InitReadBuffer() { | |
51 pcb_read_.reset(new PartialCircularBuffer( | |
52 buffer_.get(), buffer_header_size_ + sizeof(kOutputRefDataWrap))); | |
53 } | |
54 | |
55 protected: | |
56 scoped_ptr<PartialCircularBuffer> pcb_write_; | |
57 scoped_ptr<PartialCircularBuffer> pcb_read_; | |
58 scoped_ptr<uint8[]> buffer_; | |
59 uint32 buffer_header_size_; | |
60 | |
61 DISALLOW_COPY_AND_ASSIGN(PartialCircularBufferTest); | |
62 }; | |
63 | |
64 TEST_F(PartialCircularBufferTest, NoWrapBeginningPartOnly) { | |
65 WriteToBuffer(1); | |
66 InitReadBuffer(); | |
67 | |
68 uint8 output_data[sizeof(kInputData)] = {0}; | |
69 EXPECT_EQ(sizeof(output_data), | |
70 pcb_read_->Read(output_data, sizeof(output_data))); | |
71 | |
72 EXPECT_EQ(0, memcmp(kInputData, output_data, sizeof(kInputData))); | |
73 | |
74 EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data))); | |
75 } | |
76 | |
77 TEST_F(PartialCircularBufferTest, NoWrapBeginningAndEndParts) { | |
78 WriteToBuffer(2); | |
79 InitReadBuffer(); | |
80 | |
81 uint8 output_data[2 * sizeof(kInputData)] = {0}; | |
82 EXPECT_EQ(sizeof(output_data), | |
83 pcb_read_->Read(output_data, sizeof(output_data))); | |
84 | |
85 const uint8 output_ref_data[2 * sizeof(kInputData)] = | |
86 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, | |
87 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}; | |
88 EXPECT_EQ(0, memcmp(output_ref_data, output_data, sizeof(output_data))); | |
89 | |
90 EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data))); | |
91 } | |
92 | |
93 TEST_F(PartialCircularBufferTest, WrapOnce) { | |
94 WriteToBuffer(4); | |
95 InitReadBuffer(); | |
96 | |
97 uint8 output_data[sizeof(kOutputRefDataWrap)] = {0}; | |
98 EXPECT_EQ(sizeof(output_data), | |
99 pcb_read_->Read(output_data, sizeof(output_data))); | |
100 | |
101 EXPECT_EQ(0, memcmp(kOutputRefDataWrap, output_data, sizeof(output_data))); | |
102 | |
103 EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data))); | |
104 } | |
105 | |
106 TEST_F(PartialCircularBufferTest, WrapTwice) { | |
107 WriteToBuffer(7); | |
108 InitReadBuffer(); | |
109 | |
110 uint8 output_data[sizeof(kOutputRefDataWrap)] = {0}; | |
111 EXPECT_EQ(sizeof(output_data), | |
112 pcb_read_->Read(output_data, sizeof(output_data))); | |
113 | |
114 EXPECT_EQ(0, memcmp(kOutputRefDataWrap, output_data, sizeof(output_data))); | |
115 | |
116 EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data))); | |
117 } | |
118 | |
119 TEST_F(PartialCircularBufferTest, WrapOnceSmallerOutputBuffer) { | |
120 WriteToBuffer(4); | |
121 InitReadBuffer(); | |
122 | |
123 uint8 output_data[sizeof(kOutputRefDataWrap)] = {0}; | |
124 const uint32 size_per_read = 16; | |
125 uint32 read = 0; | |
126 for (; read + size_per_read <= sizeof(output_data); read += size_per_read) { | |
127 EXPECT_EQ(size_per_read, | |
128 pcb_read_->Read(output_data + read, size_per_read)); | |
129 } | |
130 EXPECT_EQ(sizeof(output_data) - read, | |
131 pcb_read_->Read(output_data + read, size_per_read)); | |
132 | |
133 EXPECT_EQ(0, memcmp(kOutputRefDataWrap, output_data, sizeof(output_data))); | |
134 | |
135 EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data))); | |
136 } | |
137 | |
138 } // namespace content | |
OLD | NEW |