leveldb::Harness Class Reference

Collaboration diagram for leveldb::Harness:

Public Member Functions
	Harness ()
void	Init (const TestArgs &args)
	~Harness ()
void	Add (const std::string &key, const std::string &value)
void	Test (Random *rnd)
void	TestForwardScan (const std::vector< std::string > &keys, const KVMap &data)
void	TestBackwardScan (const std::vector< std::string > &keys, const KVMap &data)
void	TestRandomAccess (Random *rnd, const std::vector< std::string > &keys, const KVMap &data)
std::string	ToString (const KVMap &data, const KVMap::const_iterator &it)
std::string	ToString (const KVMap &data, const KVMap::const_reverse_iterator &it)
std::string	ToString (const Iterator *it)
std::string	PickRandomKey (Random *rnd, const std::vector< std::string > &keys)
DB *	db () const

Private Attributes
Options	options_
Constructor *	constructor_

Detailed Description

Definition at line 437 of file table_test.cc.

Constructor & Destructor Documentation

Harness()

leveldb::Harness::Harness ( )

inline

Definition at line 439 of file table_test.cc.

: constructor_(NULL) { }

~Harness()

leveldb::Harness::~Harness ( )

inline

Definition at line 469 of file table_test.cc.

             {
    delete constructor_;
  }

Member Function Documentation

Add()

void leveldb::Harness::Add ( const std::string &  key, const std::string &  value  )

inline

Definition at line 473 of file table_test.cc.

                                                         {
    constructor_->Add(key, value);
  }

db()

DB* leveldb::Harness::db ( ) const

inline

Definition at line 640 of file table_test.cc.

{ return constructor_->db(); }

Init()

void leveldb::Harness::Init ( const TestArgs &  args )

inline

Definition at line 441 of file table_test.cc.

                                  {
    delete constructor_;
    constructor_ = NULL;
    options_ = Options();

    options_.block_restart_interval = args.restart_interval;
    // Use shorter block size for tests to exercise block boundary
    // conditions more.
    options_.block_size = 256;
    if (args.reverse_compare) {
      options_.comparator = &reverse_key_comparator;
    }
    switch (args.type) {
      case TABLE_TEST:
        constructor_ = new TableConstructor(options_.comparator);
        break;
      case BLOCK_TEST:
        constructor_ = new BlockConstructor(options_.comparator);
        break;
      case MEMTABLE_TEST:
        constructor_ = new MemTableConstructor(options_.comparator);
        break;
      case DB_TEST:
        constructor_ = new DBConstructor(options_.comparator);
        break;
    }
  }

PickRandomKey()

std::string leveldb::Harness::PickRandomKey ( Random *  rnd, const std::vector< std::string > &  keys  )

inline

Definition at line 612 of file table_test.cc.

                                                                         {
    if (keys.empty()) {
      return "foo";
    } else {
      const int index = rnd->Uniform(keys.size());
      std::string result = keys[index];
      switch (rnd->Uniform(3)) {
        case 0:
          // Return an existing key
          break;
        case 1: {
          // Attempt to return something smaller than an existing key
          if (result.size() > 0 && result[result.size()-1] > '\0') {
            result[result.size()-1]--;
          }
          break;
        }
        case 2: {
          // Return something larger than an existing key
          Increment(options_.comparator, &result);
          break;
        }
      }
      return result;
    }
  }

Here is the call graph for this function:

Test()

void leveldb::Harness::Test ( Random *  rnd )

inline

Definition at line 477 of file table_test.cc.

                         {
    std::vector<std::string> keys;
    KVMap data;
    constructor_->Finish(options_, &keys, &data);

    TestForwardScan(keys, data);
    TestBackwardScan(keys, data);
    TestRandomAccess(rnd, keys, data);
  }

TestBackwardScan()

void leveldb::Harness::TestBackwardScan ( const std::vector< std::string > &  keys, const KVMap &  data  )

inline

Definition at line 502 of file table_test.cc.

                                           {
    Iterator* iter = constructor_->NewIterator();
    ASSERT_TRUE(!iter->Valid());
    iter->SeekToLast();
    for (KVMap::const_reverse_iterator model_iter = data.rbegin();
         model_iter != data.rend();
         ++model_iter) {
      ASSERT_EQ(ToString(data, model_iter), ToString(iter));
      iter->Prev();
    }
    ASSERT_TRUE(!iter->Valid());
    delete iter;
  }

Here is the call graph for this function:

TestForwardScan()

void leveldb::Harness::TestForwardScan ( const std::vector< std::string > &  keys, const KVMap &  data  )

inline

Definition at line 487 of file table_test.cc.

                                          {
    Iterator* iter = constructor_->NewIterator();
    ASSERT_TRUE(!iter->Valid());
    iter->SeekToFirst();
    for (KVMap::const_iterator model_iter = data.begin();
         model_iter != data.end();
         ++model_iter) {
      ASSERT_EQ(ToString(data, model_iter), ToString(iter));
      iter->Next();
    }
    ASSERT_TRUE(!iter->Valid());
    delete iter;
  }

Here is the call graph for this function:

TestRandomAccess()

void leveldb::Harness::TestRandomAccess ( Random *  rnd, const std::vector< std::string > &  keys, const KVMap &  data  )

inline

Definition at line 517 of file table_test.cc.

                                           {
    static const bool kVerbose = false;
    Iterator* iter = constructor_->NewIterator();
    ASSERT_TRUE(!iter->Valid());
    KVMap::const_iterator model_iter = data.begin();
    if (kVerbose) fprintf(stderr, "---\n");
    for (int i = 0; i < 200; i++) {
      const int toss = rnd->Uniform(5);
      switch (toss) {
        case 0: {
          if (iter->Valid()) {
            if (kVerbose) fprintf(stderr, "Next\n");
            iter->Next();
            ++model_iter;
            ASSERT_EQ(ToString(data, model_iter), ToString(iter));
          }
          break;
        }

        case 1: {
          if (kVerbose) fprintf(stderr, "SeekToFirst\n");
          iter->SeekToFirst();
          model_iter = data.begin();
          ASSERT_EQ(ToString(data, model_iter), ToString(iter));
          break;
        }

        case 2: {
          std::string key = PickRandomKey(rnd, keys);
          model_iter = data.lower_bound(key);
          if (kVerbose) fprintf(stderr, "Seek '%s'\n",
                                EscapeString(key).c_str());
          iter->Seek(Slice(key));
          ASSERT_EQ(ToString(data, model_iter), ToString(iter));
          break;
        }

        case 3: {
          if (iter->Valid()) {
            if (kVerbose) fprintf(stderr, "Prev\n");
            iter->Prev();
            if (model_iter == data.begin()) {
              model_iter = data.end();   // Wrap around to invalid value
            } else {
              --model_iter;
            }
            ASSERT_EQ(ToString(data, model_iter), ToString(iter));
          }
          break;
        }

        case 4: {
          if (kVerbose) fprintf(stderr, "SeekToLast\n");
          iter->SeekToLast();
          if (keys.empty()) {
            model_iter = data.end();
          } else {
            std::string last = data.rbegin()->first;
            model_iter = data.lower_bound(last);
          }
          ASSERT_EQ(ToString(data, model_iter), ToString(iter));
          break;
        }
      }
    }
    delete iter;
  }

Here is the call graph for this function:

ToString() [1/3]

std::string leveldb::Harness::ToString ( const KVMap &  data, const KVMap::const_iterator &  it  )

inline

Definition at line 587 of file table_test.cc.

                                                                       {
    if (it == data.end()) {
      return "END";
    } else {
      return "'" + it->first + "->" + it->second + "'";
    }
  }

ToString() [2/3]

std::string leveldb::Harness::ToString ( const KVMap &  data, const KVMap::const_reverse_iterator &  it  )

inline

Definition at line 595 of file table_test.cc.

                                                              {
    if (it == data.rend()) {
      return "END";
    } else {
      return "'" + it->first + "->" + it->second + "'";
    }
  }

ToString() [3/3]

std::string leveldb::Harness::ToString ( const Iterator *  it )

inline

Definition at line 604 of file table_test.cc.

                                         {
    if (!it->Valid()) {
      return "END";
    } else {
      return "'" + it->key().ToString() + "->" + it->value().ToString() + "'";
    }
  }

Here is the call graph for this function:

Member Data Documentation

constructor_

Constructor* leveldb::Harness::constructor_

private

Definition at line 644 of file table_test.cc.

options_

Options leveldb::Harness::options_

private

Definition at line 643 of file table_test.cc.

---

The documentation for this class was generated from the following file:

• table/table_test.cc