OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 The Crashpad Authors. 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 "util/file/delimited_file_reader.h" |
| 16 |
| 17 #include <vector> |
| 18 |
| 19 #include "base/format_macros.h" |
| 20 #include "base/strings/stringprintf.h" |
| 21 #include "gtest/gtest.h" |
| 22 #include "util/file/string_file.h" |
| 23 |
| 24 namespace crashpad { |
| 25 namespace test { |
| 26 namespace { |
| 27 |
| 28 TEST(DelimitedFileReader, EmptyFile) { |
| 29 StringFile string_file; |
| 30 DelimitedFileReader delimited_file_reader(&string_file); |
| 31 |
| 32 std::string line; |
| 33 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 34 delimited_file_reader.GetLine(&line)); |
| 35 |
| 36 // The file is still at EOF. |
| 37 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 38 delimited_file_reader.GetLine(&line)); |
| 39 } |
| 40 |
| 41 TEST(DelimitedFileReader, EmptyOneLineFile) { |
| 42 StringFile string_file; |
| 43 string_file.SetString("\n"); |
| 44 DelimitedFileReader delimited_file_reader(&string_file); |
| 45 |
| 46 std::string line; |
| 47 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 48 delimited_file_reader.GetLine(&line)); |
| 49 EXPECT_EQ(string_file.string(), line); |
| 50 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 51 delimited_file_reader.GetLine(&line)); |
| 52 |
| 53 // The file is still at EOF. |
| 54 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 55 delimited_file_reader.GetLine(&line)); |
| 56 } |
| 57 |
| 58 TEST(DelimitedFileReader, SmallOneLineFile) { |
| 59 StringFile string_file; |
| 60 string_file.SetString("one line\n"); |
| 61 DelimitedFileReader delimited_file_reader(&string_file); |
| 62 |
| 63 std::string line; |
| 64 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 65 delimited_file_reader.GetLine(&line)); |
| 66 EXPECT_EQ(string_file.string(), line); |
| 67 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 68 delimited_file_reader.GetLine(&line)); |
| 69 |
| 70 // The file is still at EOF. |
| 71 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 72 delimited_file_reader.GetLine(&line)); |
| 73 } |
| 74 |
| 75 TEST(DelimitedFileReader, SmallOneLineFileWithoutNewline) { |
| 76 StringFile string_file; |
| 77 string_file.SetString("no newline"); |
| 78 DelimitedFileReader delimited_file_reader(&string_file); |
| 79 |
| 80 std::string line; |
| 81 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 82 delimited_file_reader.GetLine(&line)); |
| 83 EXPECT_EQ(string_file.string(), line); |
| 84 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 85 delimited_file_reader.GetLine(&line)); |
| 86 |
| 87 // The file is still at EOF. |
| 88 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 89 delimited_file_reader.GetLine(&line)); |
| 90 } |
| 91 |
| 92 TEST(DelimitedFileReader, SmallMultiLineFile) { |
| 93 StringFile string_file; |
| 94 string_file.SetString("first\nsecond line\n3rd\n"); |
| 95 DelimitedFileReader delimited_file_reader(&string_file); |
| 96 |
| 97 std::string line; |
| 98 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 99 delimited_file_reader.GetLine(&line)); |
| 100 EXPECT_EQ("first\n", line); |
| 101 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 102 delimited_file_reader.GetLine(&line)); |
| 103 EXPECT_EQ("second line\n", line); |
| 104 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 105 delimited_file_reader.GetLine(&line)); |
| 106 EXPECT_EQ("3rd\n", line); |
| 107 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 108 delimited_file_reader.GetLine(&line)); |
| 109 |
| 110 // The file is still at EOF. |
| 111 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 112 delimited_file_reader.GetLine(&line)); |
| 113 } |
| 114 |
| 115 TEST(DelimitedFileReader, SmallMultiFieldFile) { |
| 116 StringFile string_file; |
| 117 string_file.SetString("first,second field\ntwo lines,3rd,"); |
| 118 DelimitedFileReader delimited_file_reader(&string_file); |
| 119 |
| 120 std::string field; |
| 121 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 122 delimited_file_reader.GetDelim(',', &field)); |
| 123 EXPECT_EQ("first,", field); |
| 124 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 125 delimited_file_reader.GetDelim(',', &field)); |
| 126 EXPECT_EQ("second field\ntwo lines,", field); |
| 127 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 128 delimited_file_reader.GetDelim(',', &field)); |
| 129 EXPECT_EQ("3rd,", field); |
| 130 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 131 delimited_file_reader.GetDelim(',', &field)); |
| 132 |
| 133 // The file is still at EOF. |
| 134 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 135 delimited_file_reader.GetDelim(',', &field)); |
| 136 } |
| 137 |
| 138 TEST(DelimitedFileReader, SmallMultiFieldFile_MixedDelimiters) { |
| 139 StringFile string_file; |
| 140 string_file.SetString("first,second, still 2nd\t3rd\nalso\tnewline\n55555$"); |
| 141 DelimitedFileReader delimited_file_reader(&string_file); |
| 142 |
| 143 std::string field; |
| 144 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 145 delimited_file_reader.GetDelim(',', &field)); |
| 146 EXPECT_EQ("first,", field); |
| 147 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 148 delimited_file_reader.GetDelim('\t', &field)); |
| 149 EXPECT_EQ("second, still 2nd\t", field); |
| 150 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 151 delimited_file_reader.GetLine(&field)); |
| 152 EXPECT_EQ("3rd\n", field); |
| 153 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 154 delimited_file_reader.GetDelim('\n', &field)); |
| 155 EXPECT_EQ("also\tnewline\n", field); |
| 156 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 157 delimited_file_reader.GetDelim('$', &field)); |
| 158 EXPECT_EQ("55555$", field); |
| 159 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 160 delimited_file_reader.GetDelim('?', &field)); |
| 161 |
| 162 // The file is still at EOF. |
| 163 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 164 delimited_file_reader.GetLine(&field)); |
| 165 } |
| 166 |
| 167 TEST(DelimitedFileReader, EmptyLineMultiLineFile) { |
| 168 StringFile string_file; |
| 169 string_file.SetString("first\n\n\n4444\n"); |
| 170 DelimitedFileReader delimited_file_reader(&string_file); |
| 171 |
| 172 std::string line; |
| 173 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 174 delimited_file_reader.GetLine(&line)); |
| 175 EXPECT_EQ("first\n", line); |
| 176 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 177 delimited_file_reader.GetLine(&line)); |
| 178 EXPECT_EQ("\n", line); |
| 179 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 180 delimited_file_reader.GetLine(&line)); |
| 181 EXPECT_EQ("\n", line); |
| 182 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 183 delimited_file_reader.GetLine(&line)); |
| 184 EXPECT_EQ("4444\n", line); |
| 185 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 186 delimited_file_reader.GetLine(&line)); |
| 187 |
| 188 // The file is still at EOF. |
| 189 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 190 delimited_file_reader.GetLine(&line)); |
| 191 } |
| 192 |
| 193 TEST(DelimitedFileReader, LongOneLineFile) { |
| 194 std::string contents(50000, '!'); |
| 195 contents[1] = '?'; |
| 196 contents.push_back('\n'); |
| 197 |
| 198 StringFile string_file; |
| 199 string_file.SetString(contents); |
| 200 DelimitedFileReader delimited_file_reader(&string_file); |
| 201 |
| 202 std::string line; |
| 203 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 204 delimited_file_reader.GetLine(&line)); |
| 205 EXPECT_EQ(contents, line); |
| 206 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 207 delimited_file_reader.GetLine(&line)); |
| 208 |
| 209 // The file is still at EOF. |
| 210 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 211 delimited_file_reader.GetLine(&line)); |
| 212 } |
| 213 |
| 214 void TestLongMultiLineFile(int base_length) { |
| 215 std::vector<std::string> lines; |
| 216 std::string contents; |
| 217 for (size_t line_index = 0; line_index <= 'z' - 'a'; ++line_index) { |
| 218 char c = 'a' + static_cast<char>(line_index); |
| 219 |
| 220 // Mix up the lengths a little. |
| 221 std::string line(base_length + line_index * ((line_index % 3) - 1), c); |
| 222 |
| 223 // Mix up the data a little too. |
| 224 ASSERT_LT(line_index, line.size()); |
| 225 line[line_index] -= ('a' - 'A'); |
| 226 |
| 227 line.push_back('\n'); |
| 228 contents.append(line); |
| 229 lines.push_back(line); |
| 230 } |
| 231 |
| 232 StringFile string_file; |
| 233 string_file.SetString(contents); |
| 234 DelimitedFileReader delimited_file_reader(&string_file); |
| 235 |
| 236 std::string line; |
| 237 for (size_t line_index = 0; line_index < lines.size(); ++line_index) { |
| 238 SCOPED_TRACE(base::StringPrintf("line_index %" PRIuS, line_index)); |
| 239 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 240 delimited_file_reader.GetLine(&line)); |
| 241 EXPECT_EQ(lines[line_index], line); |
| 242 } |
| 243 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 244 delimited_file_reader.GetLine(&line)); |
| 245 |
| 246 // The file is still at EOF. |
| 247 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 248 delimited_file_reader.GetLine(&line)); |
| 249 } |
| 250 |
| 251 TEST(DelimitedFileReader, LongMultiLineFile) { |
| 252 TestLongMultiLineFile(500); |
| 253 } |
| 254 |
| 255 TEST(DelimitedFileReader, ReallyLongMultiLineFile) { |
| 256 TestLongMultiLineFile(5000); |
| 257 } |
| 258 |
| 259 TEST(DelimitedFileReader, EmbeddedNUL) { |
| 260 const char kString[] = "embedded\0NUL\n"; |
| 261 StringFile string_file; |
| 262 string_file.SetString(std::string(kString, arraysize(kString) - 1)); |
| 263 DelimitedFileReader delimited_file_reader(&string_file); |
| 264 |
| 265 std::string line; |
| 266 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 267 delimited_file_reader.GetLine(&line)); |
| 268 EXPECT_EQ(string_file.string(), line); |
| 269 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 270 delimited_file_reader.GetLine(&line)); |
| 271 |
| 272 // The file is still at EOF. |
| 273 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 274 delimited_file_reader.GetLine(&line)); |
| 275 } |
| 276 |
| 277 TEST(DelimitedFileReader, NULDelimiter) { |
| 278 const char kString[] = "aa\0b\0ccc\0"; |
| 279 StringFile string_file; |
| 280 string_file.SetString(std::string(kString, arraysize(kString) - 1)); |
| 281 DelimitedFileReader delimited_file_reader(&string_file); |
| 282 |
| 283 std::string field; |
| 284 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 285 delimited_file_reader.GetDelim('\0', &field)); |
| 286 EXPECT_EQ(std::string("aa\0", 3), field); |
| 287 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 288 delimited_file_reader.GetDelim('\0', &field)); |
| 289 EXPECT_EQ(std::string("b\0", 2), field); |
| 290 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 291 delimited_file_reader.GetDelim('\0', &field)); |
| 292 EXPECT_EQ(std::string("ccc\0", 4), field); |
| 293 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 294 delimited_file_reader.GetDelim('\0', &field)); |
| 295 |
| 296 // The file is still at EOF. |
| 297 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 298 delimited_file_reader.GetDelim('\0', &field)); |
| 299 } |
| 300 |
| 301 TEST(DelimitedFileReader, EdgeCases) { |
| 302 const size_t kSizes[] = {4094, 4095, 4096, 4097, 8190, 8191, 8192, 8193}; |
| 303 for (size_t index = 0; index < arraysize(kSizes); ++index) { |
| 304 size_t size = kSizes[index]; |
| 305 SCOPED_TRACE( |
| 306 base::StringPrintf("index %" PRIuS ", size %" PRIuS, index, size)); |
| 307 |
| 308 std::string line_0(size, '$'); |
| 309 line_0.push_back('\n'); |
| 310 |
| 311 StringFile string_file; |
| 312 string_file.SetString(line_0); |
| 313 DelimitedFileReader delimited_file_reader(&string_file); |
| 314 |
| 315 std::string line; |
| 316 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 317 delimited_file_reader.GetLine(&line)); |
| 318 EXPECT_EQ(line_0, line); |
| 319 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 320 delimited_file_reader.GetLine(&line)); |
| 321 |
| 322 // The file is still at EOF. |
| 323 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 324 delimited_file_reader.GetLine(&line)); |
| 325 |
| 326 std::string line_1(size, '@'); |
| 327 line_1.push_back('\n'); |
| 328 |
| 329 string_file.SetString(line_0 + line_1); |
| 330 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 331 delimited_file_reader.GetLine(&line)); |
| 332 EXPECT_EQ(line_0, line); |
| 333 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 334 delimited_file_reader.GetLine(&line)); |
| 335 EXPECT_EQ(line_1, line); |
| 336 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 337 delimited_file_reader.GetLine(&line)); |
| 338 |
| 339 // The file is still at EOF. |
| 340 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 341 delimited_file_reader.GetLine(&line)); |
| 342 |
| 343 line_1[size] = '?'; |
| 344 |
| 345 string_file.SetString(line_0 + line_1); |
| 346 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 347 delimited_file_reader.GetLine(&line)); |
| 348 EXPECT_EQ(line_0, line); |
| 349 ASSERT_EQ(DelimitedFileReader::Result::kSuccess, |
| 350 delimited_file_reader.GetLine(&line)); |
| 351 EXPECT_EQ(line_1, line); |
| 352 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 353 delimited_file_reader.GetLine(&line)); |
| 354 |
| 355 // The file is still at EOF. |
| 356 EXPECT_EQ(DelimitedFileReader::Result::kEndOfFile, |
| 357 delimited_file_reader.GetLine(&line)); |
| 358 } |
| 359 } |
| 360 |
| 361 } // namespace |
| 362 } // namespace test |
| 363 } // namespace crashpad |
OLD | NEW |