Inside Bitcoin

1501  static const int kNum = 100000;
1502  Random rnd(test::RandomSeed());
1503  for (int i = 0; i < kNum; i++) {
1504    fflush(nullptr);
1505    ASSERT_OK(Put(RandomKey(&rnd), RandomString(&rnd, 100)));
1506  }
1507}
1508
1509TEST(DBTest, ComparatorCheck) {
1510  class NewComparator : public Comparator {
1511   public:
1512    const char* Name() const override { return "leveldb.NewComparator"; }
1513    int Compare(const Slice& a, const Slice& b) const override {
1514      return BytewiseComparator()->Compare(a, b);
1515    }
1516    void FindShortestSeparator(std::string* s, const Slice& l) const override {
1517      BytewiseComparator()->FindShortestSeparator(s, l);
1518    }
1519    void FindShortSuccessor(std::string* key) const override {
1520      BytewiseComparator()->FindShortSuccessor(key);
1521    }
1522  };
1523  NewComparator cmp;
1524  Options new_options = CurrentOptions();
1525  new_options.comparator = &cmp;
1526  Status s = TryReopen(&new_options);
1527  ASSERT_TRUE(!s.ok());
1528  ASSERT_TRUE(s.ToString().find("comparator") != std::string::npos)
1529      << s.ToString();
1530}
1531
1532TEST(DBTest, CustomComparator) {
1533  class NumberComparator : public Comparator {
1534   public:
1535    const char* Name() const override { return "test.NumberComparator"; }
1536    int Compare(const Slice& a, const Slice& b) const override {
1537      return ToNumber(a) - ToNumber(b);
1538    }
1539    void FindShortestSeparator(std::string* s, const Slice& l) const override {
1540      ToNumber(*s);  // Check format
1541      ToNumber(l);   // Check format
1542    }
1543    void FindShortSuccessor(std::string* key) const override {
1544      ToNumber(*key);  // Check format
1545    }
1546
1547   private:
1548    static int ToNumber(const Slice& x) {
1549      // Check that there are no extra characters.
1550      ASSERT_TRUE(x.size() >= 2 && x[0] == '[' && x[x.size() - 1] == ']')
1551          << EscapeString(x);
1552      int val;
1553      char ignored;
1554      ASSERT_TRUE(sscanf(x.ToString().c_str(), "[%i]%c", &val, &ignored) == 1)
1555          << EscapeString(x);
1556      return val;
1557    }
1558  };
1559  NumberComparator cmp;
1560  Options new_options = CurrentOptions();
1561  new_options.create_if_missing = true;
1562  new_options.comparator = &cmp;
1563  new_options.filter_policy = nullptr;   // Cannot use bloom filters
1564  new_options.write_buffer_size = 1000;  // Compact more often
1565  DestroyAndReopen(&new_options);
1566  ASSERT_OK(Put("[10]", "ten"));
1567  ASSERT_OK(Put("[0x14]", "twenty"));
1568  for (int i = 0; i < 2; i++) {
1569    ASSERT_EQ("ten", Get("[10]"));
1570    ASSERT_EQ("ten", Get("[0xa]"));
1571    ASSERT_EQ("twenty", Get("[20]"));
1572    ASSERT_EQ("twenty", Get("[0x14]"));
1573    ASSERT_EQ("NOT_FOUND", Get("[15]"));
1574    ASSERT_EQ("NOT_FOUND", Get("[0xf]"));
1575    Compact("[0]", "[9999]");
1576  }
1577
1578  for (int run = 0; run < 2; run++) {
1579    for (int i = 0; i < 1000; i++) {
1580      char buf[100];
1581      snprintf(buf, sizeof(buf), "[%d]", i * 10);
1582      ASSERT_OK(Put(buf, buf));
1583    }
1584    Compact("[0]", "[1000000]");
1585  }
1586}
1587
1588TEST(DBTest, ManualCompaction) {
1589  ASSERT_EQ(config::kMaxMemCompactLevel, 2)
1590      << "Need to update this test to match kMaxMemCompactLevel";
1591
1592  MakeTables(3, "p", "q");
1593  ASSERT_EQ("1,1,1", FilesPerLevel());
1594
1595  // Compaction range falls before files
1596  Compact("", "c");
1597  ASSERT_EQ("1,1,1", FilesPerLevel());
1598
1599  // Compaction range falls after files
1600  Compact("r", "z");
1601  ASSERT_EQ("1,1,1", FilesPerLevel());
1602
1603  // Compaction range overlaps files
1604  Compact("p1", "p9");
1605  ASSERT_EQ("0,0,1", FilesPerLevel());
1606
1607  // Populate a different range
1608  MakeTables(3, "c", "e");
1609  ASSERT_EQ("1,1,2", FilesPerLevel());
1610
1611  // Compact just the new range
1612  Compact("b", "f");
1613  ASSERT_EQ("0,0,2", FilesPerLevel());
1614
1615  // Compact all
1616  MakeTables(1, "a", "z");
1617  ASSERT_EQ("0,1,2", FilesPerLevel());
1618  db_->CompactRange(nullptr, nullptr);
1619  ASSERT_EQ("0,0,1", FilesPerLevel());
1620}
1621
1622TEST(DBTest, DBOpen_Options) {
1623  std::string dbname = test::TmpDir() + "/db_options_test";
1624  DestroyDB(dbname, Options());
1625
1626  // Does not exist, and create_if_missing == false: error
1627  DB* db = nullptr;
1628  Options opts;
1629  opts.create_if_missing = false;
1630  Status s = DB::Open(opts, dbname, &db);
1631  ASSERT_TRUE(strstr(s.ToString().c_str(), "does not exist") != nullptr);
1632  ASSERT_TRUE(db == nullptr);
1633
1634  // Does not exist, and create_if_missing == true: OK
1635  opts.create_if_missing = true;
1636  s = DB::Open(opts, dbname, &db);
1637  ASSERT_OK(s);
1638  ASSERT_TRUE(db != nullptr);
1639
1640  delete db;
1641  db = nullptr;
1642
1643  // Does exist, and error_if_exists == true: error
1644  opts.create_if_missing = false;
1645  opts.error_if_exists = true;
1646  s = DB::Open(opts, dbname, &db);
1647  ASSERT_TRUE(strstr(s.ToString().c_str(), "exists") != nullptr);
1648  ASSERT_TRUE(db == nullptr);
1649
1650  // Does exist, and error_if_exists == false: OK
1651  opts.create_if_missing = true;
1652  opts.error_if_exists = false;
1653  s = DB::Open(opts, dbname, &db);
1654  ASSERT_OK(s);
1655  ASSERT_TRUE(db != nullptr);
1656
1657  delete db;
1658  db = nullptr;
1659}
1660
1661TEST(DBTest, DestroyEmptyDir) {
1662  std::string dbname = test::TmpDir() + "/db_empty_dir";
1663  TestEnv env(Env::Default());
1664  env.DeleteDir(dbname);
1665  ASSERT_TRUE(!env.FileExists(dbname));
1666
1667  Options opts;
1668  opts.env = &env;
1669
1670  ASSERT_OK(env.CreateDir(dbname));
1671  ASSERT_TRUE(env.FileExists(dbname));
1672  std::vector<std::string> children;
1673  ASSERT_OK(env.GetChildren(dbname, &children));
1674  // The stock Env's do not filter out '.' and '..' special files.
1675  ASSERT_EQ(2, children.size());
1676  ASSERT_OK(DestroyDB(dbname, opts));
1677  ASSERT_TRUE(!env.FileExists(dbname));
1678
1679  // Should also be destroyed if Env is filtering out dot files.
1680  env.SetIgnoreDotFiles(true);
1681  ASSERT_OK(env.CreateDir(dbname));
1682  ASSERT_TRUE(env.FileExists(dbname));
1683  ASSERT_OK(env.GetChildren(dbname, &children));
1684  ASSERT_EQ(0, children.size());
1685  ASSERT_OK(DestroyDB(dbname, opts));
1686  ASSERT_TRUE(!env.FileExists(dbname));
1687}
1688
1689TEST(DBTest, DestroyOpenDB) {
1690  std::string dbname = test::TmpDir() + "/open_db_dir";
1691  env_->DeleteDir(dbname);
1692  ASSERT_TRUE(!env_->FileExists(dbname));
1693
1694  Options opts;
1695  opts.create_if_missing = true;
1696  DB* db = nullptr;
1697  ASSERT_OK(DB::Open(opts, dbname, &db));
1698  ASSERT_TRUE(db != nullptr);
1699
1700  // Must fail to destroy an open db.
1701  ASSERT_TRUE(env_->FileExists(dbname));
1702  ASSERT_TRUE(!DestroyDB(dbname, Options()).ok());
1703  ASSERT_TRUE(env_->FileExists(dbname));
1704
1705  delete db;
1706  db = nullptr;
1707
1708  // Should succeed destroying a closed db.
1709  ASSERT_OK(DestroyDB(dbname, Options()));
1710  ASSERT_TRUE(!env_->FileExists(dbname));
1711}
1712
1713TEST(DBTest, Locking) {
1714  DB* db2 = nullptr;
1715  Status s = DB::Open(CurrentOptions(), dbname_, &db2);
1716  ASSERT_TRUE(!s.ok()) << "Locking did not prevent re-opening db";
1717}
1718
1719// Check that number of files does not grow when we are out of space
1720TEST(DBTest, NoSpace) {
1721  Options options = CurrentOptions();
1722  options.env = env_;
1723  Reopen(&options);
1724
1725  ASSERT_OK(Put("foo", "v1"));
1726  ASSERT_EQ("v1", Get("foo"));
1727  Compact("a", "z");
1728  const int num_files = CountFiles();
1729  // Force out-of-space errors.
1730  env_->no_space_.store(true, std::memory_order_release);
1731  for (int i = 0; i < 10; i++) {
1732    for (int level = 0; level < config::kNumLevels - 1; level++) {
1733      dbfull()->TEST_CompactRange(level, nullptr, nullptr);
1734    }
1735  }
1736  env_->no_space_.store(false, std::memory_order_release);
1737  ASSERT_LT(CountFiles(), num_files + 3);
1738}
1739
1740TEST(DBTest, NonWritableFileSystem) {
1741  Options options = CurrentOptions();
1742  options.write_buffer_size = 1000;
1743  options.env = env_;
1744  Reopen(&options);
1745  ASSERT_OK(Put("foo", "v1"));
1746  // Force errors for new files.
1747  env_->non_writable_.store(true, std::memory_order_release);
1748  std::string big(100000, 'x');
1749  int errors = 0;
1750  for (int i = 0; i < 20; i++) {