Inside Bitcoin

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
12namespace leveldb {
13
14class FileNameTest {};
15
16TEST(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
75TEST(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
131int main(int argc, char** argv) { return leveldb::test::RunAllTests(); }
132