Inside Bitcoin

251    kHeaderSize + 10000,
252    2 * (kHeaderSize + 10000),
253    2 * (kHeaderSize + 10000) + (2 * log::kBlockSize - 1000) + 3 * kHeaderSize,
254    2 * (kHeaderSize + 10000) + (2 * log::kBlockSize - 1000) + 3 * kHeaderSize +
255        kHeaderSize + 1,
256    3 * log::kBlockSize,
257};
258
259// LogTest::initial_offset_last_record_offsets_ must be defined before this.
260int LogTest::num_initial_offset_records_ =
261    sizeof(LogTest::initial_offset_last_record_offsets_) / sizeof(uint64_t);
262
263TEST(LogTest, Empty) { ASSERT_EQ("EOF", Read()); }
264
265TEST(LogTest, ReadWrite) {
266  Write("foo");
267  Write("bar");
268  Write("");
269  Write("xxxx");
270  ASSERT_EQ("foo", Read());
271  ASSERT_EQ("bar", Read());
272  ASSERT_EQ("", Read());
273  ASSERT_EQ("xxxx", Read());
274  ASSERT_EQ("EOF", Read());
275  ASSERT_EQ("EOF", Read());  // Make sure reads at eof work
276}
277
278TEST(LogTest, ManyBlocks) {
279  for (int i = 0; i < 100000; i++) {
280    Write(NumberString(i));
281  }
282  for (int i = 0; i < 100000; i++) {
283    ASSERT_EQ(NumberString(i), Read());
284  }
285  ASSERT_EQ("EOF", Read());
286}
287
288TEST(LogTest, Fragmentation) {
289  Write("small");
290  Write(BigString("medium", 50000));
291  Write(BigString("large", 100000));
292  ASSERT_EQ("small", Read());
293  ASSERT_EQ(BigString("medium", 50000), Read());
294  ASSERT_EQ(BigString("large", 100000), Read());
295  ASSERT_EQ("EOF", Read());
296}
297
298TEST(LogTest, MarginalTrailer) {
299  // Make a trailer that is exactly the same length as an empty record.
300  const int n = kBlockSize - 2 * kHeaderSize;
301  Write(BigString("foo", n));
302  ASSERT_EQ(kBlockSize - kHeaderSize, WrittenBytes());
303  Write("");
304  Write("bar");
305  ASSERT_EQ(BigString("foo", n), Read());
306  ASSERT_EQ("", Read());
307  ASSERT_EQ("bar", Read());
308  ASSERT_EQ("EOF", Read());
309}
310
311TEST(LogTest, MarginalTrailer2) {
312  // Make a trailer that is exactly the same length as an empty record.
313  const int n = kBlockSize - 2 * kHeaderSize;
314  Write(BigString("foo", n));
315  ASSERT_EQ(kBlockSize - kHeaderSize, WrittenBytes());
316  Write("bar");
317  ASSERT_EQ(BigString("foo", n), Read());
318  ASSERT_EQ("bar", Read());
319  ASSERT_EQ("EOF", Read());
320  ASSERT_EQ(0, DroppedBytes());
321  ASSERT_EQ("", ReportMessage());
322}
323
324TEST(LogTest, ShortTrailer) {
325  const int n = kBlockSize - 2 * kHeaderSize + 4;
326  Write(BigString("foo", n));
327  ASSERT_EQ(kBlockSize - kHeaderSize + 4, WrittenBytes());
328  Write("");
329  Write("bar");
330  ASSERT_EQ(BigString("foo", n), Read());
331  ASSERT_EQ("", Read());
332  ASSERT_EQ("bar", Read());
333  ASSERT_EQ("EOF", Read());
334}
335
336TEST(LogTest, AlignedEof) {
337  const int n = kBlockSize - 2 * kHeaderSize + 4;
338  Write(BigString("foo", n));
339  ASSERT_EQ(kBlockSize - kHeaderSize + 4, WrittenBytes());
340  ASSERT_EQ(BigString("foo", n), Read());
341  ASSERT_EQ("EOF", Read());
342}
343
344TEST(LogTest, OpenForAppend) {
345  Write("hello");
346  ReopenForAppend();
347  Write("world");
348  ASSERT_EQ("hello", Read());
349  ASSERT_EQ("world", Read());
350  ASSERT_EQ("EOF", Read());
351}
352
353TEST(LogTest, RandomRead) {
354  const int N = 500;
355  Random write_rnd(301);
356  for (int i = 0; i < N; i++) {
357    Write(RandomSkewedString(i, &write_rnd));
358  }
359  Random read_rnd(301);
360  for (int i = 0; i < N; i++) {
361    ASSERT_EQ(RandomSkewedString(i, &read_rnd), Read());
362  }
363  ASSERT_EQ("EOF", Read());
364}
365
366// Tests of all the error paths in log_reader.cc follow:
367
368TEST(LogTest, ReadError) {
369  Write("foo");
370  ForceError();
371  ASSERT_EQ("EOF", Read());
372  ASSERT_EQ(kBlockSize, DroppedBytes());
373  ASSERT_EQ("OK", MatchError("read error"));
374}
375
376TEST(LogTest, BadRecordType) {
377  Write("foo");
378  // Type is stored in header[6]
379  IncrementByte(6, 100);
380  FixChecksum(0, 3);
381  ASSERT_EQ("EOF", Read());
382  ASSERT_EQ(3, DroppedBytes());
383  ASSERT_EQ("OK", MatchError("unknown record type"));
384}
385
386TEST(LogTest, TruncatedTrailingRecordIsIgnored) {
387  Write("foo");
388  ShrinkSize(4);  // Drop all payload as well as a header byte
389  ASSERT_EQ("EOF", Read());
390  // Truncated last record is ignored, not treated as an error.
391  ASSERT_EQ(0, DroppedBytes());
392  ASSERT_EQ("", ReportMessage());
393}
394
395TEST(LogTest, BadLength) {
396  const int kPayloadSize = kBlockSize - kHeaderSize;
397  Write(BigString("bar", kPayloadSize));
398  Write("foo");
399  // Least significant size byte is stored in header[4].
400  IncrementByte(4, 1);
401  ASSERT_EQ("foo", Read());
402  ASSERT_EQ(kBlockSize, DroppedBytes());
403  ASSERT_EQ("OK", MatchError("bad record length"));
404}
405
406TEST(LogTest, BadLengthAtEndIsIgnored) {
407  Write("foo");
408  ShrinkSize(1);
409  ASSERT_EQ("EOF", Read());
410  ASSERT_EQ(0, DroppedBytes());
411  ASSERT_EQ("", ReportMessage());
412}
413
414TEST(LogTest, ChecksumMismatch) {
415  Write("foo");
416  IncrementByte(0, 10);
417  ASSERT_EQ("EOF", Read());
418  ASSERT_EQ(10, DroppedBytes());
419  ASSERT_EQ("OK", MatchError("checksum mismatch"));
420}
421
422TEST(LogTest, UnexpectedMiddleType) {
423  Write("foo");
424  SetByte(6, kMiddleType);
425  FixChecksum(0, 3);
426  ASSERT_EQ("EOF", Read());
427  ASSERT_EQ(3, DroppedBytes());
428  ASSERT_EQ("OK", MatchError("missing start"));
429}
430
431TEST(LogTest, UnexpectedLastType) {
432  Write("foo");
433  SetByte(6, kLastType);
434  FixChecksum(0, 3);
435  ASSERT_EQ("EOF", Read());
436  ASSERT_EQ(3, DroppedBytes());
437  ASSERT_EQ("OK", MatchError("missing start"));
438}
439
440TEST(LogTest, UnexpectedFullType) {
441  Write("foo");
442  Write("bar");
443  SetByte(6, kFirstType);
444  FixChecksum(0, 3);
445  ASSERT_EQ("bar", Read());
446  ASSERT_EQ("EOF", Read());
447  ASSERT_EQ(3, DroppedBytes());
448  ASSERT_EQ("OK", MatchError("partial record without end"));
449}
450
451TEST(LogTest, UnexpectedFirstType) {
452  Write("foo");
453  Write(BigString("bar", 100000));
454  SetByte(6, kFirstType);
455  FixChecksum(0, 3);
456  ASSERT_EQ(BigString("bar", 100000), Read());
457  ASSERT_EQ("EOF", Read());
458  ASSERT_EQ(3, DroppedBytes());
459  ASSERT_EQ("OK", MatchError("partial record without end"));
460}
461
462TEST(LogTest, MissingLastIsIgnored) {
463  Write(BigString("bar", kBlockSize));
464  // Remove the LAST block, including header.
465  ShrinkSize(14);
466  ASSERT_EQ("EOF", Read());
467  ASSERT_EQ("", ReportMessage());
468  ASSERT_EQ(0, DroppedBytes());
469}
470
471TEST(LogTest, PartialLastIsIgnored) {
472  Write(BigString("bar", kBlockSize));
473  // Cause a bad record length in the LAST block.
474  ShrinkSize(1);
475  ASSERT_EQ("EOF", Read());
476  ASSERT_EQ("", ReportMessage());
477  ASSERT_EQ(0, DroppedBytes());
478}
479
480TEST(LogTest, SkipIntoMultiRecord) {
481  // Consider a fragmented record:
482  //    first(R1), middle(R1), last(R1), first(R2)
483  // If initial_offset points to a record after first(R1) but before first(R2)
484  // incomplete fragment errors are not actual errors, and must be suppressed
485  // until a new first or full record is encountered.
486  Write(BigString("foo", 3 * kBlockSize));
487  Write("correct");
488  StartReadingAt(kBlockSize);
489
490  ASSERT_EQ("correct", Read());
491  ASSERT_EQ("", ReportMessage());
492  ASSERT_EQ(0, DroppedBytes());
493  ASSERT_EQ("EOF", Read());
494}
495
496TEST(LogTest, ErrorJoinsRecords) {
497  // Consider two fragmented records:
498  //    first(R1) last(R1) first(R2) last(R2)
499  // where the middle two fragments disappear.  We do not want
500  // first(R1),last(R2) to get joined and returned as a valid record.