filename_test.cc raw

   1  // Copyright (c) 2011 The LevelDB 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. See the AUTHORS file for names of contributors.
   4  
   5  #include "db/filename.h"
   6  
   7  #include "db/dbformat.h"
   8  #include "port/port.h"
   9  #include "util/logging.h"
  10  #include "util/testharness.h"
  11  
  12  namespace leveldb {
  13  
  14  class FileNameTest {};
  15  
  16  TEST(FileNameTest, Parse) {
  17    Slice db;
  18    FileType type;
  19    uint64_t number;
  20  
  21    // Successful parses
  22    static struct {
  23      const char* fname;
  24      uint64_t number;
  25      FileType type;
  26    } cases[] = {
  27        {"100.log", 100, kLogFile},
  28        {"0.log", 0, kLogFile},
  29        {"0.sst", 0, kTableFile},
  30        {"0.ldb", 0, kTableFile},
  31        {"CURRENT", 0, kCurrentFile},
  32        {"LOCK", 0, kDBLockFile},
  33        {"MANIFEST-2", 2, kDescriptorFile},
  34        {"MANIFEST-7", 7, kDescriptorFile},
  35        {"LOG", 0, kInfoLogFile},
  36        {"LOG.old", 0, kInfoLogFile},
  37        {"18446744073709551615.log", 18446744073709551615ull, kLogFile},
  38    };
  39    for (int i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
  40      std::string f = cases[i].fname;
  41      ASSERT_TRUE(ParseFileName(f, &number, &type)) << f;
  42      ASSERT_EQ(cases[i].type, type) << f;
  43      ASSERT_EQ(cases[i].number, number) << f;
  44    }
  45  
  46    // Errors
  47    static const char* errors[] = {"",
  48                                   "foo",
  49                                   "foo-dx-100.log",
  50                                   ".log",
  51                                   "",
  52                                   "manifest",
  53                                   "CURREN",
  54                                   "CURRENTX",
  55                                   "MANIFES",
  56                                   "MANIFEST",
  57                                   "MANIFEST-",
  58                                   "XMANIFEST-3",
  59                                   "MANIFEST-3x",
  60                                   "LOC",
  61                                   "LOCKx",
  62                                   "LO",
  63                                   "LOGx",
  64                                   "18446744073709551616.log",
  65                                   "184467440737095516150.log",
  66                                   "100",
  67                                   "100.",
  68                                   "100.lop"};
  69    for (int i = 0; i < sizeof(errors) / sizeof(errors[0]); i++) {
  70      std::string f = errors[i];
  71      ASSERT_TRUE(!ParseFileName(f, &number, &type)) << f;
  72    }
  73  }
  74  
  75  TEST(FileNameTest, Construction) {
  76    uint64_t number;
  77    FileType type;
  78    std::string fname;
  79  
  80    fname = CurrentFileName("foo");
  81    ASSERT_EQ("foo/", std::string(fname.data(), 4));
  82    ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  83    ASSERT_EQ(0, number);
  84    ASSERT_EQ(kCurrentFile, type);
  85  
  86    fname = LockFileName("foo");
  87    ASSERT_EQ("foo/", std::string(fname.data(), 4));
  88    ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  89    ASSERT_EQ(0, number);
  90    ASSERT_EQ(kDBLockFile, type);
  91  
  92    fname = LogFileName("foo", 192);
  93    ASSERT_EQ("foo/", std::string(fname.data(), 4));
  94    ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  95    ASSERT_EQ(192, number);
  96    ASSERT_EQ(kLogFile, type);
  97  
  98    fname = TableFileName("bar", 200);
  99    ASSERT_EQ("bar/", std::string(fname.data(), 4));
 100    ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 101    ASSERT_EQ(200, number);
 102    ASSERT_EQ(kTableFile, type);
 103  
 104    fname = DescriptorFileName("bar", 100);
 105    ASSERT_EQ("bar/", std::string(fname.data(), 4));
 106    ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 107    ASSERT_EQ(100, number);
 108    ASSERT_EQ(kDescriptorFile, type);
 109  
 110    fname = TempFileName("tmp", 999);
 111    ASSERT_EQ("tmp/", std::string(fname.data(), 4));
 112    ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 113    ASSERT_EQ(999, number);
 114    ASSERT_EQ(kTempFile, type);
 115  
 116    fname = InfoLogFileName("foo");
 117    ASSERT_EQ("foo/", std::string(fname.data(), 4));
 118    ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 119    ASSERT_EQ(0, number);
 120    ASSERT_EQ(kInfoLogFile, type);
 121  
 122    fname = OldInfoLogFileName("foo");
 123    ASSERT_EQ("foo/", std::string(fname.data(), 4));
 124    ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 125    ASSERT_EQ(0, number);
 126    ASSERT_EQ(kInfoLogFile, type);
 127  }
 128  
 129  }  // namespace leveldb
 130  
 131  int main(int argc, char** argv) { return leveldb::test::RunAllTests(); }
 132