Refactor tar code to support long names....

import/cross/tar_generator_test.cc

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 45 matching lines @@
 const int kUserIDOffset           = 108;
 const int kGroupIDOffset          = 116;
 const int kFileSizeOffset         = 124;
 const int kModifyTimeOffset       = 136;
 const int kHeaderCheckSumOffset   = 148;
 const int kLinkFlagOffset         = 156;
 const int kMagicOffset            = 257;
 const int kUserNameOffset         = 265;
 const int kGroupNameOffset        = 297;
 
+const char *kLongLink = "././@LongLink";
 const char *kDirName1 = "test/apples/";
 const char *kDirName2 = "test/oranges/";
 const char *kFileName1 = "test/apples/file1";
 const char *kFileName2 = "test/apples/file2";
 const char *kFileName3 = "test/oranges/file3";
+const char *kFileName4 =
+    "ThisIsAFilenameLongerThen100CharsThisIsAFilenameLongerThen100Chars"
+    "ThisIsAFilenameLongerThen100CharsThisIsAFilenameLongerThen100Chars";
 
 // The first file is less than one block in size
 const char *kFileContents1 =
-    "The cellphone is the world’s most ubiquitous computer.\n"
+    "The cellphone is the world most ubiquitous computer.\n"
     "The four billion cellphones in use around the globe carry personal\n"
     "information, provide access to the Web and are being used more and more\n"
     "to navigate the real world. And as cellphones change how we live,\n"
     "computer scientists say, they are also changing\n"
     "how we think about information\n";
 
 // The 2nd file takes two blocks
 const char *kFileContents2 =
     "From Hong Kong to eastern Europe to Wall Street, financial gloom was\n"
     "everywhere on Tuesday.\n"
     "Stock markets around the world staggered lower. In New York,\n"
     "the Dow fell more than 3 percent, coming within sight of its worst\n"
     "levels since the credit crisis erupted. Financial shares were battered.\n"
     "And rattled investors clamored to buy rainy-day investments like gold\n"
     "and Treasury debt. It was a global wave of selling spurred by rising\n"
-    "worries about how banks, automakers — entire countries — would fare\n"
+    "worries about how banks, automakers entire countries would fare\n"
     "in a deepening global downturn.\n"
-    "'Nobody believes it’s going get better yet,' said Howard Silverblatt,\n"
-    "senior index analyst at Standard & Poor’s. 'Do you see that light at\n"
-    "the end of the tunnel? Any kind of light? Right now, it’s not there'\n"
+    "'Nobody believes it&'s going get better yet,' said Howard Silverblatt,\n"
+    "senior index analyst at Standard & Poors. 'Do you see that light at\n"
+    "the end of the tunnel? Any kind of light? Right now, it's not there'\n"
     "yet.\n";
 
 // The 3rd file takes one block
 const char *kFileContents3 = "nothing much here...\n";
 
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // Receives the tar bytestream from the TarGenerator.
 // We validate the bytestream as it comes in...
 //
 class CallbackClient : public StreamProcessor {
  public:
   // states for state machine, with each state representing one
   // received block of the tar stream.
   // The blocks can be either headers (for directories and files)
   // or data blocks (zero padded at the end to make a full block)
   enum ValidationState {
     VALIDATE_DIRECTORY_HEADER1,  // header 1 is directory so no file data
     VALIDATE_FILE_HEADER1,
     VALIDATE_FILE_DATA1,         // 1st file takes one block
     VALIDATE_FILE_HEADER2,
     VALIDATE_FILE_DATA2_BLOCK1,  // 2nd file takes two blocks
     VALIDATE_FILE_DATA2_BLOCK2,
     VALIDATE_DIRECTORY_HEADER2,  // 3rd file is in another directory
     VALIDATE_FILE_HEADER3,
     VALIDATE_FILE_DATA3,
+    VALIDATE_FILE_LONGNAME_HEADER4,  // 4th file has a long name.
+    VALIDATE_FILE_LONGNAME_DATA4,
+    VALIDATE_FILE_HEADER4,
+    VALIDATE_FILE_DATA4,
     FINISHED
   };
 
   CallbackClient()
       : state_(VALIDATE_DIRECTORY_HEADER1),
         total_bytes_received_(0),
         memory_block_(kBlockSize),
         write_stream_(memory_block_, kBlockSize) {
   }
 
@@ skipping 76 matching lines @@
           break;
 
         case VALIDATE_FILE_HEADER3:
           ValidateHeader(memory_block_, kFileName3, strlen(kFileContents3));
           break;
 
         case VALIDATE_FILE_DATA3:
           ValidateData(memory_block_, kFileContents3);
           break;
 
+        case VALIDATE_FILE_LONGNAME_HEADER4:
+          ValidateHeader(memory_block_, kLongLink, strlen(kFileName4));
+          break;
+
+        case VALIDATE_FILE_LONGNAME_DATA4:
+          ValidateData(memory_block_, kFileName4);
+          break;
+
+        case VALIDATE_FILE_HEADER4: {
+          String first_99_chars(kFileName4, 99);
+          ValidateHeader(memory_block_, first_99_chars.c_str(),
+                         strlen(kFileContents3));
+          break;
+        }
+
+        case VALIDATE_FILE_DATA4:
+          ValidateData(memory_block_, kFileContents3);
+          break;
+
         case FINISHED:
           break;
       }
 
       // Advance to the next state
       ++state_;
 
       // So next time we write, we start at beginning of buffer
       write_stream_.Seek(0);
     }
@@ skipping 83 matching lines @@
   EXPECT_EQ(0, header[kFileSizeOffset + 11]);
 
   EXPECT_TRUE(IsOctalString(header + kModifyTimeOffset));
   EXPECT_EQ(0, header[kModifyTimeOffset + 11]);
 
   EXPECT_TRUE(IsOctalString(header + kHeaderCheckSumOffset));
   EXPECT_EQ(0, header[kHeaderCheckSumOffset + 6]);
 
   // For now we only have directories '5' or normal files '0'
   int link_flag = header[kLinkFlagOffset];
-  EXPECT_TRUE(link_flag == '0' || link_flag == '5');
+  EXPECT_TRUE(link_flag == '0' || link_flag == '5' || link_flag == 'L');
 
   EXPECT_EQ(0, strcmp((const char*)header + kMagicOffset, "ustar  "));
 
   EXPECT_EQ(0, header[kUserNameOffset + 31]);
   EXPECT_EQ(0, header[kGroupNameOffset + 31]);
 
   // Validate checksum
   int checksum = ComputeCheckSum(header);
   int header_checksum;
   sscanf((const char*)header + kHeaderCheckSumOffset, "%o", &header_checksum);
@@ skipping 20 matching lines @@
 // Creates a tar file with three files in two directories
 //
 TEST_F(TarGeneratorTest, CreateSimpleArchive) {
   CallbackClient client;
   TarGenerator generator(&client);
 
   const int kFileLength1 = strlen(kFileContents1);
   const int kFileLength2 = strlen(kFileContents2);
   const int kFileLength3 = strlen(kFileContents3);
 
-  generator.AddFile(kFileName1, kFileLength1);
+  EXPECT_TRUE(generator.AddFile(kFileName1, kFileLength1));
   MemoryReadStream file1_stream(reinterpret_cast<const uint8*>(kFileContents1),
                                 kFileLength1);
   generator.AddFileBytes(&file1_stream, kFileLength1);
 
-  generator.AddFile(kFileName2, kFileLength2);
+  EXPECT_TRUE(generator.AddFile(kFileName2, kFileLength2));
   MemoryReadStream file2_stream(reinterpret_cast<const uint8*>(kFileContents2),
                                 kFileLength2);
   generator.AddFileBytes(&file2_stream, kFileLength2);
 
-  generator.AddFile(kFileName3, kFileLength3);
+  EXPECT_TRUE(generator.AddFile(kFileName3, kFileLength3));
   MemoryReadStream file3_stream(reinterpret_cast<const uint8*>(kFileContents3),
                                 kFileLength3);
   generator.AddFileBytes(&file3_stream, kFileLength3);
+  EXPECT_TRUE(generator.AddFile(kFileName4, kFileLength3));
+  MemoryReadStream file4_stream(reinterpret_cast<const uint8*>(kFileContents3),
+                                kFileLength3);
+  generator.AddFileBytes(&file4_stream, kFileLength3);
 
   generator.Finalize();
 
   // Verify that the tar byte stream produced is exactly divisible by
   // the block size
   size_t bytes_received = client.GetTotalBytesReceived();
   EXPECT_EQ(0, bytes_received % kBlockSize);
 
   // Make sure the state machine is in the expected state
   EXPECT_EQ(CallbackClient::FINISHED, client.GetState());
 }
 
 }  // namespace