1 : // Copyright 2014 Google Inc. All Rights Reserved.
2 : //
3 : // Licensed under the Apache License, Version 2.0 (the "License");
4 : // you may not use this file except in compliance with the License.
5 : // You may obtain a copy of the License at
6 : //
7 : // http://www.apache.org/licenses/LICENSE-2.0
8 : //
9 : // Unless required by applicable law or agreed to in writing, software
10 : // distributed under the License is distributed on an "AS IS" BASIS,
11 : // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 : // See the License for the specific language governing permissions and
13 : // limitations under the License.
14 :
15 : #include "syzygy/common/buffer_parser.h"
16 : #include "gtest/gtest.h"
17 :
18 : namespace common {
19 :
20 : namespace {
21 :
22 : const char kDataBuffer[] = {
23 : 0, 1, 2, 3, 4, 5, 6, 7,
24 : 8, 9, 10, 11, 12, 13, 14, 15,
25 : 16, 17
26 : };
27 : size_t kDataBufferSize = sizeof(kDataBuffer);
28 :
29 : } // namespace
30 :
31 E : TEST(BinaryBufferParser, ContainsSucceedsInBuffer) {
32 E : BinaryBufferParser parser(kDataBuffer, kDataBufferSize);
33 :
34 : // Verify that Contains succeeds and returns the right pointer
35 : // for ranges in the buffer.
36 E : for (size_t offset = 0; offset < kDataBufferSize; ++offset) {
37 E : for (size_t len = 0; len < kDataBufferSize - offset; ++len) {
38 E : ASSERT_TRUE(parser.Contains(offset, len));
39 E : }
40 E : }
41 E : }
42 :
43 E : TEST(BinaryBufferParser, ContainsFailsOnOutOfBuffer) {
44 E : BinaryBufferParser parser(kDataBuffer, kDataBufferSize);
45 :
46 : // Verify that Contains fails for ranges not in the buffer.
47 E : for (size_t offset = 0; offset < kDataBufferSize + 1; ++offset) {
48 E : ASSERT_FALSE(parser.Contains(offset, kDataBufferSize - offset + 1));
49 E : }
50 E : }
51 :
52 E : TEST(BinaryBufferParser, ContainsFailsOnOverflow) {
53 E : BinaryBufferParser parser(kDataBuffer, kDataBufferSize);
54 :
55 : // Verify that Contains fails for offsets that overflow the buffer.
56 E : for (size_t offset = 1; offset < kDataBufferSize; ++offset) {
57 E : ASSERT_FALSE(parser.Contains(-static_cast<int>(offset), offset));
58 E : ASSERT_FALSE(parser.Contains(offset, -static_cast<int>(offset)));
59 E : }
60 E : }
61 :
62 E : TEST(BinaryBufferParser, GetAtSucceedsInBuffer) {
63 E : BinaryBufferParser parser(kDataBuffer, kDataBufferSize);
64 :
65 : // Verify that GetAt succeeds and returns the right pointer
66 : // for ranges in the buffer.
67 E : for (size_t offset = 0; offset < kDataBufferSize; ++offset) {
68 E : for (size_t len = 0; len < kDataBufferSize - offset; ++len) {
69 E : const void* ptr = NULL;
70 :
71 E : ASSERT_TRUE(parser.GetAt(offset, len, &ptr));
72 E : ASSERT_TRUE(ptr != NULL);
73 E : if (len > 0) {
74 E : ASSERT_EQ(offset, *reinterpret_cast<const char*>(ptr));
75 : }
76 E : }
77 E : }
78 E : }
79 :
80 E : TEST(BinaryBufferParser, GetAtTyped) {
81 : struct Foo { int a; int b; };
82 : static const char kBuffer[sizeof(Foo) + 1];
83 E : BinaryBufferParser parser(kBuffer, sizeof(kBuffer));
84 :
85 E : const Foo* foo = NULL;
86 E : ASSERT_TRUE(parser.GetAt(0, &foo));
87 E : ASSERT_EQ(parser.data(), foo);
88 :
89 E : ASSERT_TRUE(parser.GetAt(1, &foo));
90 E : ASSERT_FALSE(parser.GetAt(2, &foo));
91 E : }
92 :
93 : template <class CharType>
94 E : void TestGetStringAt() {
95 : static const CharType kBuf[] = {
96 : L'a', L'b', L'c', L'd', L'\0',
97 : L'e', L'f', L'g',
98 : };
99 :
100 E : BinaryBufferParser parser(kBuf, sizeof(kBuf));
101 E : const CharType* str = NULL;
102 E : size_t len = 0;
103 E : ASSERT_TRUE(parser.GetStringAt(0, &str, &len));
104 E : ASSERT_EQ(4, len);
105 :
106 E : ASSERT_TRUE(parser.GetStringAt(4 * sizeof(kBuf[0]), &str, &len));
107 E : ASSERT_EQ(0, len);
108 :
109 E : ASSERT_FALSE(parser.GetStringAt(5 * sizeof(kBuf[0]), &str, &len));
110 E : ASSERT_FALSE(parser.GetStringAt(sizeof(kBuf), &str, &len));
111 E : }
112 :
113 E : TEST(BinaryBufferParser, GetStringAtSucceeds) {
114 E : TestGetStringAt<char>();
115 E : }
116 :
117 E : TEST(BinaryBufferParser, GetStringAtWideSucceeds) {
118 E : TestGetStringAt<wchar_t>();
119 E : }
120 :
121 E : TEST(BinaryBufferReader, IsAligned) {
122 E : BinaryBufferReader reader(kDataBuffer, kDataBufferSize);
123 :
124 E : EXPECT_TRUE(reader.IsAligned(1));
125 E : EXPECT_TRUE(reader.IsAligned(2));
126 E : EXPECT_TRUE(reader.IsAligned(4));
127 E : EXPECT_TRUE(reader.IsAligned(8));
128 :
129 E : EXPECT_TRUE(reader.Consume(1));
130 :
131 E : EXPECT_TRUE(reader.IsAligned(1));
132 E : EXPECT_FALSE(reader.IsAligned(2));
133 E : EXPECT_FALSE(reader.IsAligned(4));
134 E : EXPECT_FALSE(reader.IsAligned(8));
135 :
136 E : EXPECT_TRUE(reader.Consume(3));
137 E : EXPECT_TRUE(reader.IsAligned(1));
138 E : EXPECT_TRUE(reader.IsAligned(2));
139 E : EXPECT_TRUE(reader.IsAligned(4));
140 E : EXPECT_FALSE(reader.IsAligned(8));
141 E : }
142 :
143 E : TEST(BinaryBufferReader, Align) {
144 E : BinaryBufferReader reader(kDataBuffer, kDataBufferSize);
145 :
146 E : EXPECT_TRUE(reader.Align(1));
147 E : EXPECT_TRUE(reader.Align(2));
148 E : EXPECT_TRUE(reader.Align(4));
149 E : EXPECT_TRUE(reader.Align(8));
150 :
151 E : EXPECT_EQ(0, reader.pos());
152 :
153 E : EXPECT_TRUE(reader.Consume(1));
154 E : EXPECT_TRUE(reader.Align(2));
155 E : EXPECT_EQ(2, reader.pos());
156 E : EXPECT_TRUE(reader.Align(4));
157 E : EXPECT_EQ(4, reader.pos());
158 E : }
159 :
160 E : TEST(BinaryBufferReader, PeekSucceedsInBuffer) {
161 E : BinaryBufferReader reader(kDataBuffer, kDataBufferSize);
162 :
163 : // Verify that Peek succeeds and returns the right pointer
164 : // for ranges in the buffer.
165 E : for (size_t offset = 0; offset < kDataBufferSize; ++offset) {
166 E : for (size_t len = 0; len < kDataBufferSize - offset; ++len) {
167 E : const void* ptr = NULL;
168 :
169 E : reader.set_pos(offset);
170 E : ASSERT_TRUE(reader.Peek(len, &ptr));
171 E : ASSERT_TRUE(ptr != NULL);
172 E : if (len > 0) {
173 E : ASSERT_EQ(offset, *reinterpret_cast<const char*>(ptr));
174 : }
175 E : }
176 E : }
177 E : }
178 :
179 E : TEST(BinaryBufferReader, Read) {
180 E : BinaryBufferReader reader(kDataBuffer, kDataBufferSize);
181 :
182 E : EXPECT_EQ(0, reader.pos());
183 E : const char* ptr = NULL;
184 E : EXPECT_TRUE(reader.Read(&ptr));
185 E : EXPECT_EQ(0, *ptr);
186 :
187 E : EXPECT_TRUE(reader.Read(2, &ptr));
188 E : EXPECT_EQ(1, *ptr);
189 :
190 E : EXPECT_TRUE(reader.Read(4, &ptr));
191 E : EXPECT_EQ(3, *ptr);
192 :
193 E : EXPECT_FALSE(reader.Read(kDataBufferSize, &ptr));
194 E : }
195 :
196 E : TEST(BinaryBufferReader, ReadCharString) {
197 : static const char kBuf[] = {
198 : L'a', L'b', L'c', L'd', L'\0', L'e', L'f', L'g', L'\0', L'h', L'i'
199 : };
200 E : BinaryBufferReader reader(kBuf, sizeof(kBuf));
201 :
202 E : const char* str = NULL;
203 E : size_t str_len = 0;
204 E : ASSERT_TRUE(reader.ReadString(&str, &str_len));
205 E : EXPECT_STREQ("abcd", str);
206 E : ASSERT_TRUE(reader.ReadString(&str, &str_len));
207 E : EXPECT_STREQ("efg", str);
208 E : ASSERT_FALSE(reader.ReadString(&str, &str_len));
209 E : }
210 :
211 E : TEST(BinaryBufferReader, ReadWideString) {
212 : static const wchar_t kBuf[] = {
213 : L'a', L'b', L'c', L'd', L'\0', L'e', L'f', L'g', L'\0', L'h', L'i'
214 : };
215 E : BinaryBufferReader reader(kBuf, sizeof(kBuf));
216 :
217 E : const wchar_t* str = NULL;
218 E : size_t str_len = 0;
219 E : ASSERT_TRUE(reader.ReadString(&str, &str_len));
220 E : EXPECT_STREQ(L"abcd", str);
221 E : ASSERT_TRUE(reader.ReadString(&str, &str_len));
222 E : EXPECT_STREQ(L"efg", str);
223 E : ASSERT_FALSE(reader.ReadString(&str, &str_len));
224 E : }
225 :
226 : } // namespace common
|