src/leveldb/db/filename_test.cc

   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     "",
  49     "foo",
  50     "foo-dx-100.log",
  51     ".log",
  52     "",
  53     "manifest",
  54     "CURREN",
  55     "CURRENTX",
  56     "MANIFES",
  57     "MANIFEST",
  58     "MANIFEST-",
  59     "XMANIFEST-3",
  60     "MANIFEST-3x",
  61     "LOC",
  62     "LOCKx",
  63     "LO",
  64     "LOGx",
  65     "18446744073709551616.log",
  66     "184467440737095516150.log",
  67     "100",
  68     "100.",
  69     "100.lop"
  70   };
  71   for (int i = 0; i < sizeof(errors) / sizeof(errors[0]); i++) {
  72     std::string f = errors[i];
  73     ASSERT_TRUE(!ParseFileName(f, &number, &type)) << f;
  74   }
  75 }
  76
  77 TEST(FileNameTest, Construction) {
  78   uint64_t number;
  79   FileType type;
  80   std::string fname;
  81
  82   fname = CurrentFileName("foo");
  83   ASSERT_EQ("foo/", std::string(fname.data(), 4));
  84   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  85   ASSERT_EQ(0, number);
  86   ASSERT_EQ(kCurrentFile, type);
  87
  88   fname = LockFileName("foo");
  89   ASSERT_EQ("foo/", std::string(fname.data(), 4));
  90   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  91   ASSERT_EQ(0, number);
  92   ASSERT_EQ(kDBLockFile, type);
  93
  94   fname = LogFileName("foo", 192);
  95   ASSERT_EQ("foo/", std::string(fname.data(), 4));
  96   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
  97   ASSERT_EQ(192, number);
  98   ASSERT_EQ(kLogFile, type);
  99
 100   fname = TableFileName("bar", 200);
 101   ASSERT_EQ("bar/", std::string(fname.data(), 4));
 102   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 103   ASSERT_EQ(200, number);
 104   ASSERT_EQ(kTableFile, type);
 105
 106   fname = DescriptorFileName("bar", 100);
 107   ASSERT_EQ("bar/", std::string(fname.data(), 4));
 108   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 109   ASSERT_EQ(100, number);
 110   ASSERT_EQ(kDescriptorFile, type);
 111
 112   fname = TempFileName("tmp", 999);
 113   ASSERT_EQ("tmp/", std::string(fname.data(), 4));
 114   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
 115   ASSERT_EQ(999, number);
 116   ASSERT_EQ(kTempFile, type);
 117 }
 118
 119 }  // namespace leveldb
 120
 121 int main(int argc, char** argv) {
 122   return leveldb::test::RunAllTests();
 123 }