Classes
class	Arena

class	ArenaTest

class	AutoCompactTest

class	Benchmark

class	Block

class	BlockBuilder

class	BlockConstructor

struct	BlockContents

class	BlockHandle

class	BloomTest

class	Cache

class	CacheTest

class	Coding

class	Compaction

class	Comparator

class	ConcurrentTest

class	Constructor

class	CorruptionTest

class	DB

class	DBConstructor

class	DBImpl

class	DBTest

class	Env

class	EnvPosixTest

class	EnvWrapper

class	FaultInjectionTest

class	FaultInjectionTestEnv

class	FileLock

struct	FileMetaData

class	FileNameTest

class	FilterBlockBuilder

class	FilterBlockReader

class	FilterBlockTest

class	FilterPolicy

class	FindFileTest

class	Footer

class	FormatTest

class	Harness

class	HASH

class	Histogram

class	InternalFilterPolicy

class	InternalKey

class	InternalKeyComparator

class	Iterator

class	IteratorWrapper

class	KeyConvertingIterator

class	Logger

class	LookupKey

class	MemEnvTest

class	MemTable

class	MemTableConstructor

class	MemTableIterator

class	MemTableTest

class	ModelDB

class	MutexLock

struct	Options

struct	ParsedInternalKey

class	PosixLogger

class	Random

class	RandomAccessFile

struct	Range

struct	ReadOptions

class	RecoveryTest

class	SequentialFile

class	SkipList

class	SkipTest

class	Slice

class	Snapshot

class	SnapshotImpl

class	SnapshotList

class	SpecialEnv

struct	State

class	Status

class	StringSink

class	StringSource

class	Table

struct	TableAndFile

class	TableBuilder

class	TableCache

class	TableConstructor

class	TableTest

struct	TestArgs

class	TestHashFilter

class	TestState

class	TestWritableFile

class	Version

class	VersionEdit

class	VersionEditTest

class	VersionSet

class	WritableFile

class	WriteBatch

class	WriteBatchInternal

class	WriteBatchTest

struct	WriteOptions

Typedefs
typedef uint64_t	SequenceNumber

typedef uint64_t	Key

typedef std::map< std::string, std::string, STLLessThan >	KVMap

Enumerations
enum	ValueType { kTypeDeletion = 0x0, kTypeValue = 0x1 }

enum	FileType { kLogFile, kDBLockFile, kTableFile, kDescriptorFile, kCurrentFile, kTempFile, kInfoLogFile }

enum	Tag { kComparator = 1, kLogNumber = 2, kNextFileNumber = 3, kLastSequence = 4, kCompactPointer = 5, kDeletedFile = 6, kNewFile = 7, kPrevLogNumber = 9 }

enum	CompressionType { kNoCompression = 0x0, kSnappyCompression = 0x1 }

enum	TestType { TABLE_TEST, BLOCK_TEST, MEMTABLE_TEST, DB_TEST }

Functions
	TEST (AutoCompactTest, ReadAll)

	TEST (AutoCompactTest, ReadHalf)

Status	BuildTable (const std::string &dbname, Env env, const Options &options, TableCache table_cache, Iterator iter, FileMetaData meta)

	TEST (CorruptionTest, Recovery)

	TEST (CorruptionTest, RecoverWriteError)

	TEST (CorruptionTest, NewFileErrorDuringWrite)

	TEST (CorruptionTest, TableFile)

	TEST (CorruptionTest, TableFileRepair)

	TEST (CorruptionTest, TableFileIndexData)

	TEST (CorruptionTest, MissingDescriptor)

	TEST (CorruptionTest, SequenceNumberRecovery)

	TEST (CorruptionTest, CorruptedDescriptor)

	TEST (CorruptionTest, CompactionInputError)

	TEST (CorruptionTest, CompactionInputErrorParanoid)

	TEST (CorruptionTest, UnrelatedKeys)

template<class T , class V >
static void	ClipToRange (T *ptr, V minvalue, V maxvalue)

Options	SanitizeOptions (const std::string &dbname, const InternalKeyComparator icmp, const InternalFilterPolicy ipolicy, const Options &src)

Status	DestroyDB (const std::string &dbname, const Options &options)

Iterator *	NewDBIterator (DBImpl db, const Comparator user_key_comparator, Iterator *internal_iter, SequenceNumber sequence, uint32_t seed)

static std::string	RandomString (Random *rnd, int len)

	TEST (DBTest, Empty)

	TEST (DBTest, ReadWrite)

	TEST (DBTest, PutDeleteGet)

	TEST (DBTest, GetFromImmutableLayer)

	TEST (DBTest, GetFromVersions)

	TEST (DBTest, GetMemUsage)

	TEST (DBTest, GetSnapshot)

	TEST (DBTest, GetLevel0Ordering)

	TEST (DBTest, GetOrderedByLevels)

	TEST (DBTest, GetPicksCorrectFile)

	TEST (DBTest, GetEncountersEmptyLevel)

	TEST (DBTest, IterEmpty)

	TEST (DBTest, IterSingle)

	TEST (DBTest, IterMulti)

	TEST (DBTest, IterSmallAndLargeMix)

	TEST (DBTest, IterMultiWithDelete)

	TEST (DBTest, Recover)

	TEST (DBTest, RecoveryWithEmptyLog)

	TEST (DBTest, RecoverDuringMemtableCompaction)

static std::string	Key (int i)

	TEST (DBTest, MinorCompactionsHappen)

	TEST (DBTest, RecoverWithLargeLog)

	TEST (DBTest, CompactionsGenerateMultipleFiles)

	TEST (DBTest, RepeatedWritesToSameKey)

	TEST (DBTest, SparseMerge)

static bool	Between (uint64_t val, uint64_t low, uint64_t high)

	TEST (DBTest, ApproximateSizes)

	TEST (DBTest, ApproximateSizes_MixOfSmallAndLarge)

	TEST (DBTest, IteratorPinsRef)

	TEST (DBTest, Snapshot)

	TEST (DBTest, HiddenValuesAreRemoved)

	TEST (DBTest, DeletionMarkers1)

	TEST (DBTest, DeletionMarkers2)

	TEST (DBTest, OverlapInLevel0)

	TEST (DBTest, L0_CompactionBug_Issue44_a)

	TEST (DBTest, L0_CompactionBug_Issue44_b)

	TEST (DBTest, ComparatorCheck)

	TEST (DBTest, CustomComparator)

	TEST (DBTest, ManualCompaction)

	TEST (DBTest, DBOpen_Options)

	TEST (DBTest, Locking)

	TEST (DBTest, NoSpace)

	TEST (DBTest, NonWritableFileSystem)

	TEST (DBTest, WriteSyncError)

	TEST (DBTest, ManifestWriteError)

	TEST (DBTest, MissingSSTFile)

	TEST (DBTest, StillReadSST)

	TEST (DBTest, FilesDeletedAfterCompaction)

	TEST (DBTest, BloomFilter)

	TEST (DBTest, MultiThreaded)

static std::string	RandomKey (Random *rnd)

static bool	CompareIterators (int step, DB model, DB db, const Snapshot model_snap, const Snapshot db_snap)

	TEST (DBTest, Randomized)

std::string	MakeKey (unsigned int num)

void	BM_LogAndApply (int iters, int num_base_files)

static uint64_t	PackSequenceAndType (uint64_t seq, ValueType t)

void	AppendInternalKey (std::string *result, const ParsedInternalKey &key)

size_t	InternalKeyEncodingLength (const ParsedInternalKey &key)

bool	ParseInternalKey (const Slice &internal_key, ParsedInternalKey *result)

Slice	ExtractUserKey (const Slice &internal_key)

ValueType	ExtractValueType (const Slice &internal_key)

static std::string	IKey (const std::string &user_key, uint64_t seq, ValueType vt)

static std::string	Shorten (const std::string &s, const std::string &l)

static std::string	ShortSuccessor (const std::string &s)

static void	TestKey (const std::string &key, uint64_t seq, ValueType vt)

	TEST (FormatTest, InternalKey_EncodeDecode)

	TEST (FormatTest, InternalKeyShortSeparator)

	TEST (FormatTest, InternalKeyShortestSuccessor)

Status	DumpFile (Env env, const std::string &fname, WritableFile dst)

	TEST (FaultInjectionTest, FaultTestNoLogReuse)

	TEST (FaultInjectionTest, FaultTestWithLogReuse)

Status	WriteStringToFileSync (Env *env, const Slice &data, const std::string &fname)

static std::string	MakeFileName (const std::string &name, uint64_t number, const char *suffix)

std::string	LogFileName (const std::string &name, uint64_t number)

std::string	TableFileName (const std::string &name, uint64_t number)

std::string	SSTTableFileName (const std::string &name, uint64_t number)

std::string	DescriptorFileName (const std::string &dbname, uint64_t number)

std::string	CurrentFileName (const std::string &dbname)

std::string	LockFileName (const std::string &dbname)

std::string	TempFileName (const std::string &dbname, uint64_t number)

std::string	InfoLogFileName (const std::string &dbname)

std::string	OldInfoLogFileName (const std::string &dbname)

bool	ParseFileName (const std::string &fname, uint64_t number, FileType type)

Status	SetCurrentFile (Env *env, const std::string &dbname, uint64_t descriptor_number)

	TEST (FileNameTest, Parse)

	TEST (FileNameTest, Construction)

static Slice	GetLengthPrefixedSlice (const char *data)

static const char *	EncodeKey (std::string *scratch, const Slice &target)

	TEST (RecoveryTest, ManifestReused)

	TEST (RecoveryTest, LargeManifestCompacted)

	TEST (RecoveryTest, NoLogFiles)

	TEST (RecoveryTest, LogFileReuse)

	TEST (RecoveryTest, MultipleMemTables)

	TEST (RecoveryTest, MultipleLogFiles)

Status	RepairDB (const std::string &dbname, const Options &options)

	TEST (SkipTest, Empty)

	TEST (SkipTest, InsertAndLookup)

	TEST (SkipTest, ConcurrentWithoutThreads)

static void	ConcurrentReader (void *arg)

static void	RunConcurrent (int run)

	TEST (SkipTest, Concurrent1)

	TEST (SkipTest, Concurrent2)

	TEST (SkipTest, Concurrent3)

	TEST (SkipTest, Concurrent4)

	TEST (SkipTest, Concurrent5)

static void	DeleteEntry (const Slice &key, void *value)

static void	UnrefEntry (void arg1, void arg2)

static bool	GetInternalKey (Slice input, InternalKey dst)

static bool	GetLevel (Slice input, int level)

static void	TestEncodeDecode (const VersionEdit &edit)

	TEST (VersionEditTest, EncodeDecode)

static int	TargetFileSize (const Options *options)

static int64_t	MaxGrandParentOverlapBytes (const Options *options)

static int64_t	ExpandedCompactionByteSizeLimit (const Options *options)

static double	MaxBytesForLevel (const Options *options, int level)

static uint64_t	MaxFileSizeForLevel (const Options *options, int level)

static int64_t	TotalFileSize (const std::vector< FileMetaData *> &files)

int	FindFile (const InternalKeyComparator &icmp, const std::vector< FileMetaData *> &files, const Slice &key)

static bool	AfterFile (const Comparator ucmp, const Slice user_key, const FileMetaData *f)

static bool	BeforeFile (const Comparator ucmp, const Slice user_key, const FileMetaData *f)

bool	SomeFileOverlapsRange (const InternalKeyComparator &icmp, bool disjoint_sorted_files, const std::vector< FileMetaData > &files, const Slice smallest_user_key, const Slice *largest_user_key)

static Iterator *	GetFileIterator (void *arg, const ReadOptions &options, const Slice &file_value)

static void	SaveValue (void *arg, const Slice &ikey, const Slice &v)

static bool	NewestFirst (FileMetaData a, FileMetaData b)

	TEST (FindFileTest, Empty)

	TEST (FindFileTest, Single)

	TEST (FindFileTest, Multiple)

	TEST (FindFileTest, MultipleNullBoundaries)

	TEST (FindFileTest, OverlapSequenceChecks)

	TEST (FindFileTest, OverlappingFiles)

static std::string	PrintContents (WriteBatch *b)

	TEST (WriteBatchTest, Empty)

	TEST (WriteBatchTest, Multiple)

	TEST (WriteBatchTest, Corruption)

	TEST (WriteBatchTest, Append)

Env *	NewMemEnv (Env *base_env)

	TEST (MemEnvTest, Basics)

	TEST (MemEnvTest, ReadWrite)

	TEST (MemEnvTest, Locks)

	TEST (MemEnvTest, Misc)

	TEST (MemEnvTest, LargeWrite)

	TEST (MemEnvTest, DBTest)

Cache *	NewLRUCache (size_t capacity)

const Comparator *	BytewiseComparator ()

void	Log (Logger info_log, const char format,...)

Status	WriteStringToFile (Env *env, const Slice &data, const std::string &fname)

Status	ReadFileToString (Env env, const std::string &fname, std::string data)

const FilterPolicy *	NewBloomFilterPolicy (int bits_per_key)

Iterator *	NewEmptyIterator ()

Iterator *	NewErrorIterator (const Status &status)

bool	operator== (const Slice &x, const Slice &y)

bool	operator!= (const Slice &x, const Slice &y)

static const char *	DecodeEntry (const char p, const char limit, uint32_t shared, uint32_t non_shared, uint32_t *value_length)

	TEST (FilterBlockTest, EmptyBuilder)

	TEST (FilterBlockTest, SingleChunk)

	TEST (FilterBlockTest, MultiChunk)

Status	ReadBlock (RandomAccessFile file, const ReadOptions &options, const BlockHandle &handle, BlockContents result)

Iterator *	NewMergingIterator (const Comparator cmp, Iterator *list, int n)

static void	DeleteBlock (void arg, void ignored)

static void	DeleteCachedBlock (const Slice &key, void *value)

static void	ReleaseBlock (void arg, void h)

static std::string	Reverse (const Slice &key)

static void	Increment (const Comparator cmp, std::string key)

	TEST (Harness, Empty)

	TEST (Harness, ZeroRestartPointsInBlock)

	TEST (Harness, SimpleEmptyKey)

	TEST (Harness, SimpleSingle)

	TEST (Harness, SimpleMulti)

	TEST (Harness, SimpleSpecialKey)

	TEST (Harness, Randomized)

	TEST (Harness, RandomizedLongDB)

	TEST (MemTableTest, Simple)

static bool	Between (uint64_t val, uint64_t low, uint64_t high)

	TEST (TableTest, ApproximateOffsetOfPlain)

static bool	SnappyCompressionSupported ()

	TEST (TableTest, ApproximateOffsetOfCompressed)

Iterator *	NewTwoLevelIterator (Iterator index_iter, BlockFunction block_function, void arg, const ReadOptions &options)

Iterator *	NewTwoLevelIterator (Iterator index_iter, Iterator (block_function)(void arg, const ReadOptions &options, const Slice &index_value), void *arg, const ReadOptions &options)

	TEST (ArenaTest, Empty)

	TEST (ArenaTest, Simple)

static Slice	Key (int i, char *buffer)

	TEST (BloomTest, EmptyFilter)

	TEST (BloomTest, Small)

static int	NextLength (int length)

	TEST (BloomTest, VaryingLengths)

static std::string	EncodeKey (int k)

static int	DecodeKey (const Slice &k)

static void *	EncodeValue (uintptr_t v)

static int	DecodeValue (void *v)

	TEST (CacheTest, HitAndMiss)

	TEST (CacheTest, Erase)

	TEST (CacheTest, EntriesArePinned)

	TEST (CacheTest, EvictionPolicy)

	TEST (CacheTest, UseExceedsCacheSize)

	TEST (CacheTest, HeavyEntries)

	TEST (CacheTest, NewId)

	TEST (CacheTest, Prune)

void	EncodeFixed32 (char *buf, uint32_t value)

void	EncodeFixed64 (char *buf, uint64_t value)

void	PutFixed32 (std::string *dst, uint32_t value)

void	PutFixed64 (std::string *dst, uint64_t value)

char *	EncodeVarint32 (char *dst, uint32_t v)

void	PutVarint32 (std::string *dst, uint32_t v)

char *	EncodeVarint64 (char *dst, uint64_t v)

void	PutVarint64 (std::string *dst, uint64_t v)

void	PutLengthPrefixedSlice (std::string *dst, const Slice &value)

int	VarintLength (uint64_t v)

const char *	GetVarint32PtrFallback (const char p, const char limit, uint32_t *value)

bool	GetVarint32 (Slice input, uint32_t value)

const char *	GetVarint64Ptr (const char p, const char limit, uint64_t *value)

bool	GetVarint64 (Slice input, uint64_t value)

const char *	GetLengthPrefixedSlice (const char p, const char limit, Slice *result)

bool	GetLengthPrefixedSlice (Slice input, Slice result)

const char *	GetVarint32Ptr (const char p, const char limit, uint32_t *v)

uint32_t	DecodeFixed32 (const char *ptr)

uint64_t	DecodeFixed64 (const char *ptr)

	TEST (Coding, Fixed32)

	TEST (Coding, Fixed64)

	TEST (Coding, EncodingOutput)

	TEST (Coding, Varint32)

	TEST (Coding, Varint64)

	TEST (Coding, Varint32Overflow)

	TEST (Coding, Varint32Truncation)

	TEST (Coding, Varint64Overflow)

	TEST (Coding, Varint64Truncation)

	TEST (Coding, Strings)

static void	InitModule ()

static Status	DoWriteStringToFile (Env *env, const Slice &data, const std::string &fname, bool should_sync)

static void	InitDefaultEnv ()

static void	SetBool (void *ptr)

	TEST (EnvPosixTest, RunImmediately)

	TEST (EnvPosixTest, RunMany)

static void	ThreadBody (void *arg)

	TEST (EnvPosixTest, StartThread)

uint32_t	Hash (const char *data, size_t n, uint32_t seed)

	TEST (HASH, SignedUnsignedIssue)

void	AppendNumberTo (std::string *str, uint64_t num)

void	AppendEscapedStringTo (std::string *str, const Slice &value)

std::string	NumberToString (uint64_t num)

std::string	EscapeString (const Slice &value)

bool	ConsumeDecimalNumber (Slice in, uint64_t val)

Variables
static const int	kValueSize = 200 * 1024

static const int	kTotalSize = 100 * 1024 * 1024

static const int	kCount = kTotalSize / kValueSize

static const int	kValueSize = 1000

const int	kNumNonTableCacheFiles = 10

static const ValueType	kValueTypeForSeek = kTypeValue

static const SequenceNumber	kMaxSequenceNumber

static const int	kValueSize = 1000

static const int	kMaxNumValues = 2000

static const size_t	kNumIterations = 3

static const size_t	kHeader = 12

static const int	kMajorVersion = 1

static const int	kMinorVersion = 19

static const size_t	kFilterBaseLg = 11

static const size_t	kFilterBase = 1 << kFilterBaseLg

static const uint64_t	kTableMagicNumber = 0xdb4775248b80fb57ull

static const size_t	kBlockTrailerSize = 5

static ReverseKeyComparator	reverse_key_comparator

static const TestArgs	kTestArgList []

static const int	kNumTestArgs = sizeof(kTestArgList) / sizeof(kTestArgList[0])

static const int	kBlockSize = 4096

static const int	kVerbose = 1

static port::OnceType	once = LEVELDB_ONCE_INIT

static const Comparator *	bytewise

static pthread_once_t	once = PTHREAD_ONCE_INIT

static Env *	default_env

static const int	kDelayMicros = 100000

Class Documentation

§ leveldb::ArenaTest

class leveldb::ArenaTest

Definition at line 12 of file arena_test.cc.

§ leveldb::BlockContents

struct leveldb::BlockContents

Definition at line 86 of file format.h.

Collaboration diagram for leveldb::BlockContents:

[legend]

Class Members
bool	cachable
Slice	data
bool	heap_allocated

§ leveldb::Coding

class leveldb::Coding

Definition at line 11 of file coding_test.cc.

§ leveldb::FileNameTest

class leveldb::FileNameTest

Definition at line 14 of file filename_test.cc.

§ leveldb::FilterBlockTest

class leveldb::FilterBlockTest

Definition at line 41 of file filter_block_test.cc.

Collaboration diagram for leveldb::FilterBlockTest:

[legend]

Class Members
TestHashFilter	policy_

§ leveldb::FormatTest

class leveldb::FormatTest

Definition at line 47 of file dbformat_test.cc.

§ leveldb::HASH

class leveldb::HASH

Definition at line 10 of file hash_test.cc.

§ leveldb::MemTableTest

class leveldb::MemTableTest

Definition at line 760 of file table_test.cc.

§ leveldb::SkipTest

class leveldb::SkipTest

Definition at line 29 of file skiplist_test.cc.

§ leveldb::State

struct leveldb::State

Definition at line 67 of file env_test.cc.

Class Members
Mutex	mu
int	num_running
int	val

§ leveldb::TableAndFile

struct leveldb::TableAndFile

Definition at line 14 of file table_cache.cc.

Collaboration diagram for leveldb::TableAndFile:

[legend]

Class Members
RandomAccessFile *	file
Table *	table

§ leveldb::TableTest

class leveldb::TableTest

Definition at line 798 of file table_test.cc.

§ leveldb::TestArgs

struct leveldb::TestArgs

Definition at line 406 of file table_test.cc.

Class Members
int	restart_interval
bool	reverse_compare
TestType	type

§ leveldb::VersionEditTest

class leveldb::VersionEditTest

Definition at line 20 of file version_edit_test.cc.

§ leveldb::WriteBatchTest

class leveldb::WriteBatchTest

Definition at line 55 of file write_batch_test.cc.

Typedef Documentation

§ Key

typedef uint64_t leveldb::Key

Definition at line 15 of file skiplist_test.cc.

§ KVMap

typedef std::map<std::string, std::string, STLLessThan> leveldb::KVMap

Definition at line 137 of file table_test.cc.

§ SequenceNumber

typedef uint64_t leveldb::SequenceNumber

Definition at line 63 of file dbformat.h.

Enumeration Type Documentation

§ CompressionType

enum leveldb::CompressionType

Enumerator
kNoCompression
kSnappyCompression

Definition at line 23 of file options.h.

                      {
   // NOTE: do not change the values of existing entries, as these are
   // part of the persistent format on disk.
   kNoCompression     = 0x0,
   kSnappyCompression = 0x1
 };

§ FileType

enum leveldb::FileType

Enumerator
kLogFile
kDBLockFile
kTableFile
kDescriptorFile
kCurrentFile
kTempFile
kInfoLogFile

Definition at line 20 of file filename.h.

               {
   kLogFile,
   kDBLockFile,
   kTableFile,
   kDescriptorFile,
   kCurrentFile,
   kTempFile,
   kInfoLogFile  // Either the current one, or an old one
 };

§ Tag

enum leveldb::Tag

Enumerator
kComparator
kLogNumber
kNextFileNumber
kLastSequence
kCompactPointer
kDeletedFile
kNewFile
kPrevLogNumber

Definition at line 14 of file version_edit.cc.

          {
   kComparator           = 1,
   kLogNumber            = 2,
   kNextFileNumber       = 3,
   kLastSequence         = 4,
   kCompactPointer       = 5,
   kDeletedFile          = 6,
   kNewFile              = 7,
   // 8 was used for large value refs
   kPrevLogNumber        = 9
 };

§ TestType

enum leveldb::TestType

Enumerator
TABLE_TEST
BLOCK_TEST
MEMTABLE_TEST
DB_TEST

Definition at line 399 of file table_test.cc.

               {
   TABLE_TEST,
   BLOCK_TEST,
   MEMTABLE_TEST,
   DB_TEST
 };

§ ValueType

enum leveldb::ValueType

Enumerator
kTypeDeletion
kTypeValue

Definition at line 51 of file dbformat.h.

                {
   kTypeDeletion = 0x0,
   kTypeValue = 0x1
 };

Function Documentation

§ AfterFile()

static bool leveldb::AfterFile	(	const Comparator *	ucmp,
		const Slice *	user_key,
		const FileMetaData *	f
	)

static

Definition at line 107 of file version_set.cc.

                                                                     {
   // NULL user_key occurs before all keys and is therefore never after *f
   return (user_key != NULL &&
           ucmp->Compare(*user_key, f->largest.user_key()) > 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ AppendEscapedStringTo()

void leveldb::AppendEscapedStringTo	(	std::string *	str,
		const Slice &	value
	)

Definition at line 22 of file logging.cc.

                                                                {
   for (size_t i = 0; i < value.size(); i++) {
     char c = value[i];
     if (c >= ' ' && c <= '~') {
       str->push_back(c);
     } else {
       char buf[10];
       snprintf(buf, sizeof(buf), "\\x%02x",
                static_cast<unsigned int>(c) & 0xff);
       str->append(buf);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ AppendInternalKey()

void leveldb::AppendInternalKey	(	std::string *	result,
		const ParsedInternalKey &	key
	)

Definition at line 18 of file dbformat.cc.

                                                                         {
   result->append(key.user_key.data(), key.user_key.size());
   PutFixed64(result, PackSequenceAndType(key.sequence, key.type));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ AppendNumberTo()

void leveldb::AppendNumberTo	(	std::string *	str,
		uint64_t	num
	)

Definition at line 16 of file logging.cc.

                                                   {
   char buf[30];
   snprintf(buf, sizeof(buf), "%llu", (unsigned long long) num);
   str->append(buf);
 }

Here is the caller graph for this function:

§ BeforeFile()

static bool leveldb::BeforeFile	(	const Comparator *	ucmp,
		const Slice *	user_key,
		const FileMetaData *	f
	)

static

Definition at line 114 of file version_set.cc.

                                                                      {
   // NULL user_key occurs after all keys and is therefore never before *f
   return (user_key != NULL &&
           ucmp->Compare(*user_key, f->smallest.user_key()) < 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ Between() [1/2]

static bool leveldb::Between	(	uint64_t	val,
		uint64_t	low,
		uint64_t	high
	)

static

Definition at line 787 of file table_test.cc.

                                                                {
   bool result = (val >= low) && (val <= high);
   if (!result) {
     fprintf(stderr, "Value %llu is not in range [%llu, %llu]\n",
             (unsigned long long)(val),
             (unsigned long long)(low),
             (unsigned long long)(high));
   }
   return result;
 }

§ Between() [2/2]

static bool leveldb::Between	(	uint64_t	val,
		uint64_t	low,
		uint64_t	high
	)

static

Definition at line 1064 of file db_test.cc.

                                                                {
   bool result = (val >= low) && (val <= high);
   if (!result) {
     fprintf(stderr, "Value %llu is not in range [%llu, %llu]\n",
             (unsigned long long)(val),
             (unsigned long long)(low),
             (unsigned long long)(high));
   }
   return result;
 }

Here is the caller graph for this function:

§ BM_LogAndApply()

void leveldb::BM_LogAndApply	(	int	iters,
		int	num_base_files
	)

Definition at line 2094 of file db_test.cc.

                                                    {
   std::string dbname = test::TmpDir() + "/leveldb_test_benchmark";
   DestroyDB(dbname, Options());
 
   DB* db = NULL;
   Options opts;
   opts.create_if_missing = true;
   Status s = DB::Open(opts, dbname, &db);
   ASSERT_OK(s);
   ASSERT_TRUE(db != NULL);
 
   delete db;
   db = NULL;
 
   Env* env = Env::Default();
 
   port::Mutex mu;
   MutexLock l(&mu);
 
   InternalKeyComparator cmp(BytewiseComparator());
   Options options;
   VersionSet vset(dbname, &options, NULL, &cmp);
   bool save_manifest;
   ASSERT_OK(vset.Recover(&save_manifest));
   VersionEdit vbase;
   uint64_t fnum = 1;
   for (int i = 0; i < num_base_files; i++) {
     InternalKey start(MakeKey(2*fnum), 1, kTypeValue);
     InternalKey limit(MakeKey(2*fnum+1), 1, kTypeDeletion);
     vbase.AddFile(2, fnum++, 1 /* file size */, start, limit);
   }
   ASSERT_OK(vset.LogAndApply(&vbase, &mu));
 
   uint64_t start_micros = env->NowMicros();
 
   for (int i = 0; i < iters; i++) {
     VersionEdit vedit;
     vedit.DeleteFile(2, fnum);
     InternalKey start(MakeKey(2*fnum), 1, kTypeValue);
     InternalKey limit(MakeKey(2*fnum+1), 1, kTypeDeletion);
     vedit.AddFile(2, fnum++, 1 /* file size */, start, limit);
     vset.LogAndApply(&vedit, &mu);
   }
   uint64_t stop_micros = env->NowMicros();
   unsigned int us = stop_micros - start_micros;
   char buf[16];
   snprintf(buf, sizeof(buf), "%d", num_base_files);
   fprintf(stderr,
           "BM_LogAndApply/%-6s   %8d iters : %9u us (%7.0f us / iter)\n",
           buf, iters, us, ((float)us) / iters);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ BuildTable()

Status leveldb::BuildTable	(	const std::string &	dbname,
		Env *	env,
		const Options &	options,
		TableCache *	table_cache,
		Iterator *	iter,
		FileMetaData *	meta
	)

Definition at line 17 of file builder.cc.

                                       {
   Status s;
   meta->file_size = 0;
   iter->SeekToFirst();
 
   std::string fname = TableFileName(dbname, meta->number);
   if (iter->Valid()) {
     WritableFile* file;
     s = env->NewWritableFile(fname, &file);
     if (!s.ok()) {
       return s;
     }
 
     TableBuilder* builder = new TableBuilder(options, file);
     meta->smallest.DecodeFrom(iter->key());
     for (; iter->Valid(); iter->Next()) {
       Slice key = iter->key();
       meta->largest.DecodeFrom(key);
       builder->Add(key, iter->value());
     }
 
     // Finish and check for builder errors
     if (s.ok()) {
       s = builder->Finish();
       if (s.ok()) {
         meta->file_size = builder->FileSize();
         assert(meta->file_size > 0);
       }
     } else {
       builder->Abandon();
     }
     delete builder;
 
     // Finish and check for file errors
     if (s.ok()) {
       s = file->Sync();
     }
     if (s.ok()) {
       s = file->Close();
     }
     delete file;
     file = NULL;
 
     if (s.ok()) {
       // Verify that the table is usable
       Iterator* it = table_cache->NewIterator(ReadOptions(),
                                               meta->number,
                                               meta->file_size);
       s = it->status();
       delete it;
     }
   }
 
   // Check for input iterator errors
   if (!iter->status().ok()) {
     s = iter->status();
   }
 
   if (s.ok() && meta->file_size > 0) {
     // Keep it
   } else {
     env->DeleteFile(fname);
   }
   return s;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ BytewiseComparator()

const Comparator * leveldb::BytewiseComparator ( )

Definition at line 76 of file comparator.cc.

                                        {
   port::InitOnce(&once, InitModule);
   return bytewise;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ ClipToRange()

template<class T , class V >

static void leveldb::ClipToRange	(	T *	ptr,
		V	minvalue,
		V	maxvalue
	)

static

Definition at line 86 of file db_impl.cc.

                                                         {
   if (static_cast<V>(*ptr) > maxvalue) *ptr = maxvalue;
   if (static_cast<V>(*ptr) < minvalue) *ptr = minvalue;
 }

Here is the caller graph for this function:

§ CompareIterators()

static bool leveldb::CompareIterators	(	int	step,
		DB *	model,
		DB *	db,
		const Snapshot *	model_snap,
		const Snapshot *	db_snap
	)

static

Definition at line 1969 of file db_test.cc.

                                                       {
   ReadOptions options;
   options.snapshot = model_snap;
   Iterator* miter = model->NewIterator(options);
   options.snapshot = db_snap;
   Iterator* dbiter = db->NewIterator(options);
   bool ok = true;
   int count = 0;
   for (miter->SeekToFirst(), dbiter->SeekToFirst();
        ok && miter->Valid() && dbiter->Valid();
        miter->Next(), dbiter->Next()) {
     count++;
     if (miter->key().compare(dbiter->key()) != 0) {
       fprintf(stderr, "step %d: Key mismatch: '%s' vs. '%s'\n",
               step,
               EscapeString(miter->key()).c_str(),
               EscapeString(dbiter->key()).c_str());
       ok = false;
       break;
     }
 
     if (miter->value().compare(dbiter->value()) != 0) {
       fprintf(stderr, "step %d: Value mismatch for key '%s': '%s' vs. '%s'\n",
               step,
               EscapeString(miter->key()).c_str(),
               EscapeString(miter->value()).c_str(),
               EscapeString(miter->value()).c_str());
       ok = false;
     }
   }
 
   if (ok) {
     if (miter->Valid() != dbiter->Valid()) {
       fprintf(stderr, "step %d: Mismatch at end of iterators: %d vs. %d\n",
               step, miter->Valid(), dbiter->Valid());
       ok = false;
     }
   }
   fprintf(stderr, "%d entries compared: ok=%d\n", count, ok);
   delete miter;
   delete dbiter;
   return ok;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ ConcurrentReader()

static void leveldb::ConcurrentReader ( void * arg )

static

Definition at line 336 of file skiplist_test.cc.

                                         {
   TestState* state = reinterpret_cast<TestState*>(arg);
   Random rnd(state->seed_);
   int64_t reads = 0;
   state->Change(TestState::RUNNING);
   while (!state->quit_flag_.Acquire_Load()) {
     state->t_.ReadStep(&rnd);
     ++reads;
   }
   state->Change(TestState::DONE);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ ConsumeDecimalNumber()

bool leveldb::ConsumeDecimalNumber	(	Slice *	in,
		uint64_t *	val
	)

Definition at line 48 of file logging.cc.

                                                     {
   uint64_t v = 0;
   int digits = 0;
   while (!in->empty()) {
     char c = (*in)[0];
     if (c >= '0' && c <= '9') {
       ++digits;
       const int delta = (c - '0');
       static const uint64_t kMaxUint64 = ~static_cast<uint64_t>(0);
       if (v > kMaxUint64/10 ||
           (v == kMaxUint64/10 && delta > kMaxUint64%10)) {
         // Overflow
         return false;
       }
       v = (v * 10) + delta;
       in->remove_prefix(1);
     } else {
       break;
     }
   }
   *val = v;
   return (digits > 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ CurrentFileName()

std::string leveldb::CurrentFileName ( const std::string & dbname )

Definition at line 50 of file filename.cc.

                                                    {
   return dbname + "/CURRENT";
 }

Here is the caller graph for this function:

§ DecodeEntry()

static const char* leveldb::DecodeEntry	(	const char *	p,
		const char *	limit,
		uint32_t *	shared,
		uint32_t *	non_shared,
		uint32_t *	value_length
	)

inlinestatic

Definition at line 53 of file block.cc.

                                                               {
   if (limit - p < 3) return NULL;
   *shared = reinterpret_cast<const unsigned char*>(p)[0];
   *non_shared = reinterpret_cast<const unsigned char*>(p)[1];
   *value_length = reinterpret_cast<const unsigned char*>(p)[2];
   if ((*shared | *non_shared | *value_length) < 128) {
     // Fast path: all three values are encoded in one byte each
     p += 3;
   } else {
     if ((p = GetVarint32Ptr(p, limit, shared)) == NULL) return NULL;
     if ((p = GetVarint32Ptr(p, limit, non_shared)) == NULL) return NULL;
     if ((p = GetVarint32Ptr(p, limit, value_length)) == NULL) return NULL;
   }
 
   if (static_cast<uint32_t>(limit - p) < (*non_shared + *value_length)) {
     return NULL;
   }
   return p;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ DecodeFixed32()

uint32_t leveldb::DecodeFixed32 ( const char * ptr )

inline

Definition at line 58 of file coding.h.

                                                {
   if (port::kLittleEndian) {
     // Load the raw bytes
     uint32_t result;
     memcpy(&result, ptr, sizeof(result));  // gcc optimizes this to a plain load
     return result;
   } else {
     return ((static_cast<uint32_t>(static_cast<unsigned char>(ptr[0])))
         | (static_cast<uint32_t>(static_cast<unsigned char>(ptr[1])) << 8)
         | (static_cast<uint32_t>(static_cast<unsigned char>(ptr[2])) << 16)
         | (static_cast<uint32_t>(static_cast<unsigned char>(ptr[3])) << 24));
   }
 }

Here is the caller graph for this function:

§ DecodeFixed64()

uint64_t leveldb::DecodeFixed64 ( const char * ptr )

inline

Definition at line 72 of file coding.h.

                                                {
   if (port::kLittleEndian) {
     // Load the raw bytes
     uint64_t result;
     memcpy(&result, ptr, sizeof(result));  // gcc optimizes this to a plain load
     return result;
   } else {
     uint64_t lo = DecodeFixed32(ptr);
     uint64_t hi = DecodeFixed32(ptr + 4);
     return (hi << 32) | lo;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ DecodeKey()

static int leveldb::DecodeKey ( const Slice & k )

static

Definition at line 19 of file cache_test.cc.

                                      {
   assert(k.size() == 4);
   return DecodeFixed32(k.data());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ DecodeValue()

static int leveldb::DecodeValue ( void * v )

static

Definition at line 24 of file cache_test.cc.

24 { return reinterpret_cast<uintptr_t>(v); }

Here is the caller graph for this function:

§ DeleteBlock()

static void leveldb::DeleteBlock	(	void *	arg,
		void *	ignored
	)

static

Definition at line 147 of file table.cc.

                                                   {
   delete reinterpret_cast<Block*>(arg);
 }

Here is the caller graph for this function:

§ DeleteCachedBlock()

static void leveldb::DeleteCachedBlock	(	const Slice &	key,
		void *	value
	)

static

Definition at line 151 of file table.cc.

                                                              {
   Block* block = reinterpret_cast<Block*>(value);
   delete block;
 }

Here is the caller graph for this function:

§ DeleteEntry()

static void leveldb::DeleteEntry	(	const Slice &	key,
		void *	value
	)

static

Definition at line 19 of file table_cache.cc.

                                                        {
   TableAndFile* tf = reinterpret_cast<TableAndFile*>(value);
   delete tf->table;
   delete tf->file;
   delete tf;
 }

Here is the caller graph for this function:

§ DescriptorFileName()

std::string leveldb::DescriptorFileName	(	const std::string &	dbname,
		uint64_t	number
	)

Definition at line 42 of file filename.cc.

                                                                        {
   assert(number > 0);
   char buf[100];
   snprintf(buf, sizeof(buf), "/MANIFEST-%06llu",
            static_cast<unsigned long long>(number));
   return dbname + buf;
 }

Here is the caller graph for this function:

§ DestroyDB()

Status leveldb::DestroyDB	(	const std::string &	dbname,
		const Options &	options
	)

Definition at line 1537 of file db_impl.cc.

                                                                   {
   Env* env = options.env;
   std::vector<std::string> filenames;
   // Ignore error in case directory does not exist
   env->GetChildren(dbname, &filenames);
   if (filenames.empty()) {
     return Status::OK();
   }
 
   FileLock* lock;
   const std::string lockname = LockFileName(dbname);
   Status result = env->LockFile(lockname, &lock);
   if (result.ok()) {
     uint64_t number;
     FileType type;
     for (size_t i = 0; i < filenames.size(); i++) {
       if (ParseFileName(filenames[i], &number, &type) &&
           type != kDBLockFile) {  // Lock file will be deleted at end
         Status del = env->DeleteFile(dbname + "/" + filenames[i]);
         if (result.ok() && !del.ok()) {
           result = del;
         }
       }
     }
     env->UnlockFile(lock);  // Ignore error since state is already gone
     env->DeleteFile(lockname);
     env->DeleteDir(dbname);  // Ignore error in case dir contains other files
   }
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ DoWriteStringToFile()

static Status leveldb::DoWriteStringToFile	(	Env *	env,
		const Slice &	data,
		const std::string &	fname,
		bool	should_sync
	)

static

Definition at line 40 of file env.cc.

                                                     {
   WritableFile* file;
   Status s = env->NewWritableFile(fname, &file);
   if (!s.ok()) {
     return s;
   }
   s = file->Append(data);
   if (s.ok() && should_sync) {
     s = file->Sync();
   }
   if (s.ok()) {
     s = file->Close();
   }
   delete file;  // Will auto-close if we did not close above
   if (!s.ok()) {
     env->DeleteFile(fname);
   }
   return s;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ DumpFile()

Status leveldb::DumpFile	(	Env *	env,
		const std::string &	fname,
		WritableFile *	dst
	)

Definition at line 210 of file dumpfile.cc.

                                                                      {
   FileType ftype;
   if (!GuessType(fname, &ftype)) {
     return Status::InvalidArgument(fname + ": unknown file type");
   }
   switch (ftype) {
     case kLogFile:         return DumpLog(env, fname, dst);
     case kDescriptorFile:  return DumpDescriptor(env, fname, dst);
     case kTableFile:       return DumpTable(env, fname, dst);
     default:
       break;
   }
   return Status::InvalidArgument(fname + ": not a dump-able file type");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ EncodeFixed32()

void leveldb::EncodeFixed32	(	char *	buf,
		uint32_t	value
	)

Definition at line 9 of file coding.cc.

                                               {
   if (port::kLittleEndian) {
     memcpy(buf, &value, sizeof(value));
   } else {
     buf[0] = value & 0xff;
     buf[1] = (value >> 8) & 0xff;
     buf[2] = (value >> 16) & 0xff;
     buf[3] = (value >> 24) & 0xff;
   }
 }

Here is the caller graph for this function:

§ EncodeFixed64()

void leveldb::EncodeFixed64	(	char *	buf,
		uint64_t	value
	)

Definition at line 20 of file coding.cc.

                                               {
   if (port::kLittleEndian) {
     memcpy(buf, &value, sizeof(value));
   } else {
     buf[0] = value & 0xff;
     buf[1] = (value >> 8) & 0xff;
     buf[2] = (value >> 16) & 0xff;
     buf[3] = (value >> 24) & 0xff;
     buf[4] = (value >> 32) & 0xff;
     buf[5] = (value >> 40) & 0xff;
     buf[6] = (value >> 48) & 0xff;
     buf[7] = (value >> 56) & 0xff;
   }
 }

Here is the caller graph for this function:

§ EncodeKey() [1/2]

static std::string leveldb::EncodeKey ( int k )

static

Definition at line 14 of file cache_test.cc.

                                   {
   std::string result;
   PutFixed32(&result, k);
   return result;
 }

Here is the call graph for this function:

§ EncodeKey() [2/2]

static const char* leveldb::EncodeKey	(	std::string *	scratch,
		const Slice &	target
	)

static

Definition at line 44 of file memtable.cc.

                                                                       {
   scratch->clear();
   PutVarint32(scratch, target.size());
   scratch->append(target.data(), target.size());
   return scratch->data();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ EncodeValue()

static void* leveldb::EncodeValue ( uintptr_t v )

static

Definition at line 23 of file cache_test.cc.

23 { return reinterpret_cast<void*>(v); }

Here is the caller graph for this function:

§ EncodeVarint32()

char * leveldb::EncodeVarint32	(	char *	dst,
		uint32_t	v
	)

Definition at line 47 of file coding.cc.

                                             {
   // Operate on characters as unsigneds
   unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);
   static const int B = 128;
   if (v < (1<<7)) {
     *(ptr++) = v;
   } else if (v < (1<<14)) {
     *(ptr++) = v | B;
     *(ptr++) = v>>7;
   } else if (v < (1<<21)) {
     *(ptr++) = v | B;
     *(ptr++) = (v>>7) | B;
     *(ptr++) = v>>14;
   } else if (v < (1<<28)) {
     *(ptr++) = v | B;
     *(ptr++) = (v>>7) | B;
     *(ptr++) = (v>>14) | B;
     *(ptr++) = v>>21;
   } else {
     *(ptr++) = v | B;
     *(ptr++) = (v>>7) | B;
     *(ptr++) = (v>>14) | B;
     *(ptr++) = (v>>21) | B;
     *(ptr++) = v>>28;
   }
   return reinterpret_cast<char*>(ptr);
 }

Here is the caller graph for this function:

§ EncodeVarint64()

char * leveldb::EncodeVarint64	(	char *	dst,
		uint64_t	v
	)

Definition at line 81 of file coding.cc.

                                             {
   static const int B = 128;
   unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);
   while (v >= B) {
     *(ptr++) = (v & (B-1)) | B;
     v >>= 7;
   }
   *(ptr++) = static_cast<unsigned char>(v);
   return reinterpret_cast<char*>(ptr);
 }

Here is the caller graph for this function:

§ EscapeString()

std::string leveldb::EscapeString ( const Slice & value )

Definition at line 42 of file logging.cc.

                                            {
   std::string r;
   AppendEscapedStringTo(&r, value);
   return r;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ ExpandedCompactionByteSizeLimit()

static int64_t leveldb::ExpandedCompactionByteSizeLimit ( const Options * options )

static

Definition at line 36 of file version_set.cc.

                                                                        {
   return 25 * TargetFileSize(options);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ ExtractUserKey()

Slice leveldb::ExtractUserKey ( const Slice & internal_key )

inline

Definition at line 98 of file dbformat.h.

                                                        {
   assert(internal_key.size() >= 8);
   return Slice(internal_key.data(), internal_key.size() - 8);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ ExtractValueType()

ValueType leveldb::ExtractValueType ( const Slice & internal_key )

inline

Definition at line 103 of file dbformat.h.

                                                              {
   assert(internal_key.size() >= 8);
   const size_t n = internal_key.size();
   uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
   unsigned char c = num & 0xff;
   return static_cast<ValueType>(c);
 }

Here is the call graph for this function:

§ FindFile()

int leveldb::FindFile	(	const InternalKeyComparator &	icmp,
		const std::vector< FileMetaData *> &	files,
		const Slice &	key
	)

Definition at line 86 of file version_set.cc.

                                {
   uint32_t left = 0;
   uint32_t right = files.size();
   while (left < right) {
     uint32_t mid = (left + right) / 2;
     const FileMetaData* f = files[mid];
     if (icmp.InternalKeyComparator::Compare(f->largest.Encode(), key) < 0) {
       // Key at "mid.largest" is < "target".  Therefore all
       // files at or before "mid" are uninteresting.
       left = mid + 1;
     } else {
       // Key at "mid.largest" is >= "target".  Therefore all files
       // after "mid" are uninteresting.
       right = mid;
     }
   }
   return right;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ GetFileIterator()

static Iterator* leveldb::GetFileIterator	(	void *	arg,
		const ReadOptions &	options,
		const Slice &	file_value
	)

static

Definition at line 213 of file version_set.cc.

                                                           {
   TableCache* cache = reinterpret_cast<TableCache*>(arg);
   if (file_value.size() != 16) {
     return NewErrorIterator(
         Status::Corruption("FileReader invoked with unexpected value"));
   } else {
     return cache->NewIterator(options,
                               DecodeFixed64(file_value.data()),
                               DecodeFixed64(file_value.data() + 8));
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ GetInternalKey()

static bool leveldb::GetInternalKey	(	Slice *	input,
		InternalKey *	dst
	)

static

Definition at line 88 of file version_edit.cc.

                                                            {
   Slice str;
   if (GetLengthPrefixedSlice(input, &str)) {
     dst->DecodeFrom(str);
     return true;
   } else {
     return false;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ GetLengthPrefixedSlice() [1/3]

static Slice leveldb::GetLengthPrefixedSlice ( const char * data )

static

Definition at line 14 of file memtable.cc.

                                                       {
   uint32_t len;
   const char* p = data;
   p = GetVarint32Ptr(p, p + 5, &len);  // +5: we assume "p" is not corrupted
   return Slice(p, len);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ GetLengthPrefixedSlice() [2/3]

const char* leveldb::GetLengthPrefixedSlice	(	const char *	p,
		const char *	limit,
		Slice *	result
	)

Definition at line 172 of file coding.cc.

                                                   {
   uint32_t len;
   p = GetVarint32Ptr(p, limit, &len);
   if (p == NULL) return NULL;
   if (p + len > limit) return NULL;
   *result = Slice(p, len);
   return p + len;
 }

Here is the call graph for this function:

§ GetLengthPrefixedSlice() [3/3]

bool leveldb::GetLengthPrefixedSlice	(	Slice *	input,
		Slice *	result
	)

Definition at line 182 of file coding.cc.

                                                          {
   uint32_t len;
   if (GetVarint32(input, &len) &&
       input->size() >= len) {
     *result = Slice(input->data(), len);
     input->remove_prefix(len);
     return true;
   } else {
     return false;
   }
 }

Here is the call graph for this function:

§ GetLevel()

static bool leveldb::GetLevel	(	Slice *	input,
		int *	level
	)

static

Definition at line 98 of file version_edit.cc.

                                                {
   uint32_t v;
   if (GetVarint32(input, &v) &&
       v < config::kNumLevels) {
     *level = v;
     return true;
   } else {
     return false;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ GetVarint32()

bool leveldb::GetVarint32	(	Slice *	input,
		uint32_t *	value
	)

Definition at line 131 of file coding.cc.

                                                 {
   const char* p = input->data();
   const char* limit = p + input->size();
   const char* q = GetVarint32Ptr(p, limit, value);
   if (q == NULL) {
     return false;
   } else {
     *input = Slice(q, limit - q);
     return true;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ GetVarint32Ptr()

const char * leveldb::GetVarint32Ptr	(	const char *	p,
		const char *	limit,
		uint32_t *	v
	)

inline

Definition at line 89 of file coding.h.

                                                    {
   if (p < limit) {
     uint32_t result = *(reinterpret_cast<const unsigned char*>(p));
     if ((result & 128) == 0) {
       *value = result;
       return p + 1;
     }
   }
   return GetVarint32PtrFallback(p, limit, value);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ GetVarint32PtrFallback()

const char * leveldb::GetVarint32PtrFallback	(	const char *	p,
		const char *	limit,
		uint32_t *	value
	)

Definition at line 112 of file coding.cc.

                                                     {
   uint32_t result = 0;
   for (uint32_t shift = 0; shift <= 28 && p < limit; shift += 7) {
     uint32_t byte = *(reinterpret_cast<const unsigned char*>(p));
     p++;
     if (byte & 128) {
       // More bytes are present
       result |= ((byte & 127) << shift);
     } else {
       result |= (byte << shift);
       *value = result;
       return reinterpret_cast<const char*>(p);
     }
   }
   return NULL;
 }

Here is the caller graph for this function:

§ GetVarint64()

bool leveldb::GetVarint64	(	Slice *	input,
		uint64_t *	value
	)

Definition at line 160 of file coding.cc.

                                                 {
   const char* p = input->data();
   const char* limit = p + input->size();
   const char* q = GetVarint64Ptr(p, limit, value);
   if (q == NULL) {
     return false;
   } else {
     *input = Slice(q, limit - q);
     return true;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ GetVarint64Ptr()

const char * leveldb::GetVarint64Ptr	(	const char *	p,
		const char *	limit,
		uint64_t *	value
	)

Definition at line 143 of file coding.cc.

                                                                               {
   uint64_t result = 0;
   for (uint32_t shift = 0; shift <= 63 && p < limit; shift += 7) {
     uint64_t byte = *(reinterpret_cast<const unsigned char*>(p));
     p++;
     if (byte & 128) {
       // More bytes are present
       result |= ((byte & 127) << shift);
     } else {
       result |= (byte << shift);
       *value = result;
       return reinterpret_cast<const char*>(p);
     }
   }
   return NULL;
 }

Here is the caller graph for this function:

§ Hash()

uint32_t leveldb::Hash	(	const char *	data,
		size_t	n,
		uint32_t	seed
	)

Definition at line 18 of file hash.cc.

                                                          {
   // Similar to murmur hash
   const uint32_t m = 0xc6a4a793;
   const uint32_t r = 24;
   const char* limit = data + n;
   uint32_t h = seed ^ (n * m);
 
   // Pick up four bytes at a time
   while (data + 4 <= limit) {
     uint32_t w = DecodeFixed32(data);
     data += 4;
     h += w;
     h *= m;
     h ^= (h >> 16);
   }
 
   // Pick up remaining bytes
   switch (limit - data) {
     case 3:
       h += static_cast<unsigned char>(data[2]) << 16;
       FALLTHROUGH_INTENDED;
     case 2:
       h += static_cast<unsigned char>(data[1]) << 8;
       FALLTHROUGH_INTENDED;
     case 1:
       h += static_cast<unsigned char>(data[0]);
       h *= m;
       h ^= (h >> r);
       break;
   }
   return h;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ IKey()

static std::string leveldb::IKey	(	const std::string &	user_key,
		uint64_t	seq,
		ValueType	vt
	)

static

Definition at line 11 of file dbformat_test.cc.

                                       {
   std::string encoded;
   AppendInternalKey(&encoded, ParsedInternalKey(user_key, seq, vt));
   return encoded;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ Increment()

static void leveldb::Increment	(	const Comparator *	cmp,
		std::string *	key
	)

static

Definition at line 66 of file table_test.cc.

                                                              {
   if (cmp == BytewiseComparator()) {
     key->push_back('\0');
   } else {
     assert(cmp == &reverse_key_comparator);
     std::string rev = Reverse(*key);
     rev.push_back('\0');
     *key = Reverse(rev);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ InfoLogFileName()

std::string leveldb::InfoLogFileName ( const std::string & dbname )

Definition at line 63 of file filename.cc.

                                                    {
   return dbname + "/LOG";
 }

Here is the caller graph for this function:

§ InitDefaultEnv()

static void leveldb::InitDefaultEnv ( )

static

Definition at line 611 of file env_posix.cc.

611 { default_env = new PosixEnv; }

leveldb::default_env

static Env * default_env

Definition: env_posix.cc:610

Here is the call graph for this function:

Here is the caller graph for this function:

§ InitModule()

static void leveldb::InitModule ( )

static

Definition at line 72 of file comparator.cc.

                          {
   bytewise = new BytewiseComparatorImpl;
 }

Here is the caller graph for this function:

§ InternalKeyEncodingLength()

size_t leveldb::InternalKeyEncodingLength ( const ParsedInternalKey & key )

inline

Definition at line 82 of file dbformat.h.

                                                                       {
   return key.user_key.size() + 8;
 }

Here is the call graph for this function:

§ Key() [1/2]

static Slice leveldb::Key	(	int	i,
		char *	buffer
	)

static

Definition at line 16 of file bloom_test.cc.

                                       {
   EncodeFixed32(buffer, i);
   return Slice(buffer, sizeof(uint32_t));
 }

Here is the call graph for this function:

§ Key() [2/2]

static std::string leveldb::Key ( int i )

static

Definition at line 924 of file db_test.cc.

                             {
   char buf[100];
   snprintf(buf, sizeof(buf), "key%06d", i);
   return std::string(buf);
 }

§ LockFileName()

std::string leveldb::LockFileName ( const std::string & dbname )

Definition at line 54 of file filename.cc.

                                                 {
   return dbname + "/LOCK";
 }

Here is the caller graph for this function:

§ Log()

void leveldb::Log	(	Logger *	info_log,
		const char *	format,
			...
	)

Definition at line 31 of file env.cc.

                                                     {
   if (info_log != NULL) {
     va_list ap;
     va_start(ap, format);
     info_log->Logv(format, ap);
     va_end(ap);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ LogFileName()

std::string leveldb::LogFileName	(	const std::string &	name,
		uint64_t	number
	)

Definition at line 27 of file filename.cc.

                                                               {
   assert(number > 0);
   return MakeFileName(name, number, "log");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ MakeFileName()

static std::string leveldb::MakeFileName	(	const std::string &	name,
		uint64_t	number,
		const char *	suffix
	)

static

Definition at line 18 of file filename.cc.

                                                     {
   char buf[100];
   snprintf(buf, sizeof(buf), "/%06llu.%s",
            static_cast<unsigned long long>(number),
            suffix);
   return name + buf;
 }

Here is the caller graph for this function:

§ MakeKey()

std::string leveldb::MakeKey ( unsigned int num )

Definition at line 2088 of file db_test.cc.

                                     {
   char buf[30];
   snprintf(buf, sizeof(buf), "%016u", num);
   return std::string(buf);
 }

Here is the caller graph for this function:

§ MaxBytesForLevel()

static double leveldb::MaxBytesForLevel	(	const Options *	options,
		int	level
	)

static

Definition at line 40 of file version_set.cc.

                                                                   {
   // Note: the result for level zero is not really used since we set
   // the level-0 compaction threshold based on number of files.
 
   // Result for both level-0 and level-1
   double result = 10. * 1048576.0;
   while (level > 1) {
     result *= 10;
     level--;
   }
   return result;
 }

Here is the caller graph for this function:

§ MaxFileSizeForLevel()

static uint64_t leveldb::MaxFileSizeForLevel	(	const Options *	options,
		int	level
	)

static

Definition at line 53 of file version_set.cc.

                                                                        {
   // We could vary per level to reduce number of files?
   return TargetFileSize(options);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ MaxGrandParentOverlapBytes()

static int64_t leveldb::MaxGrandParentOverlapBytes ( const Options * options )

static

Definition at line 29 of file version_set.cc.

                                                                   {
   return 10 * TargetFileSize(options);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ NewBloomFilterPolicy()

const FilterPolicy * leveldb::NewBloomFilterPolicy ( int bits_per_key )

Definition at line 91 of file bloom.cc.

                                                            {
   return new BloomFilterPolicy(bits_per_key);
 }

Here is the caller graph for this function:

§ NewDBIterator()

Iterator * leveldb::NewDBIterator	(	DBImpl *	db,
		const Comparator *	user_key_comparator,
		Iterator *	internal_iter,
		SequenceNumber	sequence,
		uint32_t	seed
	)

Definition at line 308 of file db_iter.cc.

                    {
   return new DBIter(db, user_key_comparator, internal_iter, sequence, seed);
 }

Here is the caller graph for this function:

§ NewEmptyIterator()

Iterator * leveldb::NewEmptyIterator ( )

Definition at line 59 of file iterator.cc.

                              {
   return new EmptyIterator(Status::OK());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ NewErrorIterator()

Iterator * leveldb::NewErrorIterator ( const Status & status )

Definition at line 63 of file iterator.cc.

                                                  {
   return new EmptyIterator(status);
 }

Here is the caller graph for this function:

§ NewestFirst()

static bool leveldb::NewestFirst	(	FileMetaData *	a,
		FileMetaData *	b
	)

static

Definition at line 283 of file version_set.cc.

                                                           {
   return a->number > b->number;
 }

Here is the caller graph for this function:

§ NewLRUCache()

Cache * leveldb::NewLRUCache ( size_t capacity )

Definition at line 401 of file cache.cc.

                                     {
   return new ShardedLRUCache(capacity);
 }

Here is the caller graph for this function:

§ NewMemEnv()

Env * leveldb::NewMemEnv ( Env * base_env )

Definition at line 394 of file memenv.cc.

                               {
   return new InMemoryEnv(base_env);
 }

§ NewMergingIterator()

Iterator * leveldb::NewMergingIterator	(	const Comparator *	cmp,
		Iterator **	list,
		int	n
	)

Definition at line 186 of file merger.cc.

                                                                             {
   assert(n >= 0);
   if (n == 0) {
     return NewEmptyIterator();
   } else if (n == 1) {
     return list[0];
   } else {
     return new MergingIterator(cmp, list, n);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ NewTwoLevelIterator() [1/2]

Iterator* leveldb::NewTwoLevelIterator	(	Iterator *	index_iter,
		Iterator ()(void *arg, const ReadOptions &options, const Slice &index_value)	block_function,
		void *	arg,
		const ReadOptions &	options
	)

§ NewTwoLevelIterator() [2/2]

Iterator* leveldb::NewTwoLevelIterator	(	Iterator *	index_iter,
		BlockFunction	block_function,
		void *	arg,
		const ReadOptions &	options
	)

Definition at line 174 of file two_level_iterator.cc.

                                 {
   return new TwoLevelIterator(index_iter, block_function, arg, options);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ NextLength()

static int leveldb::NextLength ( int length )

static

Definition at line 103 of file bloom_test.cc.

                                   {
   if (length < 10) {
     length += 1;
   } else if (length < 100) {
     length += 10;
   } else if (length < 1000) {
     length += 100;
   } else {
     length += 1000;
   }
   return length;
 }

Here is the caller graph for this function:

§ NumberToString()

std::string leveldb::NumberToString ( uint64_t num )

Definition at line 36 of file logging.cc.

                                        {
   std::string r;
   AppendNumberTo(&r, num);
   return r;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ OldInfoLogFileName()

std::string leveldb::OldInfoLogFileName ( const std::string & dbname )

Definition at line 68 of file filename.cc.

                                                       {
   return dbname + "/LOG.old";
 }

Here is the caller graph for this function:

§ operator!=()

bool leveldb::operator!=	(	const Slice &	x,
		const Slice &	y
	)

inline

Definition at line 92 of file slice.h.

                                                        {
   return !(x == y);
 }

§ operator==()

bool leveldb::operator==	(	const Slice &	x,
		const Slice &	y
	)

inline

Definition at line 87 of file slice.h.

                                                        {
   return ((x.size() == y.size()) &&
           (memcmp(x.data(), y.data(), x.size()) == 0));
 }

Here is the call graph for this function:

§ PackSequenceAndType()

static uint64_t leveldb::PackSequenceAndType	(	uint64_t	seq,
		ValueType	t
	)

static

Definition at line 12 of file dbformat.cc.

                                                                {
   assert(seq <= kMaxSequenceNumber);
   assert(t <= kValueTypeForSeek);
   return (seq << 8) | t;
 }

Here is the caller graph for this function:

§ ParseFileName()

bool leveldb::ParseFileName	(	const std::string &	fname,
		uint64_t *	number,
		FileType *	type
	)

Definition at line 80 of file filename.cc.

                                    {
   Slice rest(fname);
   if (rest == "CURRENT") {
     *number = 0;
     *type = kCurrentFile;
   } else if (rest == "LOCK") {
     *number = 0;
     *type = kDBLockFile;
   } else if (rest == "LOG" || rest == "LOG.old") {
     *number = 0;
     *type = kInfoLogFile;
   } else if (rest.starts_with("MANIFEST-")) {
     rest.remove_prefix(strlen("MANIFEST-"));
     uint64_t num;
     if (!ConsumeDecimalNumber(&rest, &num)) {
       return false;
     }
     if (!rest.empty()) {
       return false;
     }
     *type = kDescriptorFile;
     *number = num;
   } else {
     // Avoid strtoull() to keep filename format independent of the
     // current locale
     uint64_t num;
     if (!ConsumeDecimalNumber(&rest, &num)) {
       return false;
     }
     Slice suffix = rest;
     if (suffix == Slice(".log")) {
       *type = kLogFile;
     } else if (suffix == Slice(".sst") || suffix == Slice(".ldb")) {
       *type = kTableFile;
     } else if (suffix == Slice(".dbtmp")) {
       *type = kTempFile;
     } else {
       return false;
     }
     *number = num;
   }
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ ParseInternalKey()

bool leveldb::ParseInternalKey	(	const Slice &	internal_key,
		ParsedInternalKey *	result
	)

inline

Definition at line 176 of file dbformat.h.

                                                         {
   const size_t n = internal_key.size();
   if (n < 8) return false;
   uint64_t num = DecodeFixed64(internal_key.data() + n - 8);
   unsigned char c = num & 0xff;
   result->sequence = num >> 8;
   result->type = static_cast<ValueType>(c);
   result->user_key = Slice(internal_key.data(), n - 8);
   return (c <= static_cast<unsigned char>(kTypeValue));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ PrintContents()

static std::string leveldb::PrintContents ( WriteBatch * b )

static

Definition at line 15 of file write_batch_test.cc.

                                               {
   InternalKeyComparator cmp(BytewiseComparator());
   MemTable* mem = new MemTable(cmp);
   mem->Ref();
   std::string state;
   Status s = WriteBatchInternal::InsertInto(b, mem);
   int count = 0;
   Iterator* iter = mem->NewIterator();
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
     ParsedInternalKey ikey;
     ASSERT_TRUE(ParseInternalKey(iter->key(), &ikey));
     switch (ikey.type) {
       case kTypeValue:
         state.append("Put(");
         state.append(ikey.user_key.ToString());
         state.append(", ");
         state.append(iter->value().ToString());
         state.append(")");
         count++;
         break;
       case kTypeDeletion:
         state.append("Delete(");
         state.append(ikey.user_key.ToString());
         state.append(")");
         count++;
         break;
     }
     state.append("@");
     state.append(NumberToString(ikey.sequence));
   }
   delete iter;
   if (!s.ok()) {
     state.append("ParseError()");
   } else if (count != WriteBatchInternal::Count(b)) {
     state.append("CountMismatch()");
   }
   mem->Unref();
   return state;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ PutFixed32()

void leveldb::PutFixed32	(	std::string *	dst,
		uint32_t	value
	)

Definition at line 35 of file coding.cc.

                                                 {
   char buf[sizeof(value)];
   EncodeFixed32(buf, value);
   dst->append(buf, sizeof(buf));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ PutFixed64()

void leveldb::PutFixed64	(	std::string *	dst,
		uint64_t	value
	)

Definition at line 41 of file coding.cc.

                                                 {
   char buf[sizeof(value)];
   EncodeFixed64(buf, value);
   dst->append(buf, sizeof(buf));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ PutLengthPrefixedSlice()

void leveldb::PutLengthPrefixedSlice	(	std::string *	dst,
		const Slice &	value
	)

Definition at line 98 of file coding.cc.

                                                                 {
   PutVarint32(dst, value.size());
   dst->append(value.data(), value.size());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ PutVarint32()

void leveldb::PutVarint32	(	std::string *	dst,
		uint32_t	v
	)

Definition at line 75 of file coding.cc.

                                              {
   char buf[5];
   char* ptr = EncodeVarint32(buf, v);
   dst->append(buf, ptr - buf);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ PutVarint64()

void leveldb::PutVarint64	(	std::string *	dst,
		uint64_t	v
	)

Definition at line 92 of file coding.cc.

                                              {
   char buf[10];
   char* ptr = EncodeVarint64(buf, v);
   dst->append(buf, ptr - buf);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ RandomKey()

static std::string leveldb::RandomKey ( Random * rnd )

static

Definition at line 1962 of file db_test.cc.

                                         {
   int len = (rnd->OneIn(3)
              ? 1                // Short sometimes to encourage collisions
              : (rnd->OneIn(100) ? rnd->Skewed(10) : rnd->Uniform(10)));
   return test::RandomKey(rnd, len);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ RandomString()

static std::string leveldb::RandomString	(	Random *	rnd,
		int	len
	)

static

Definition at line 22 of file db_test.cc.

                                                     {
   std::string r;
   test::RandomString(rnd, len, &r);
   return r;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ ReadBlock()

Status leveldb::ReadBlock	(	RandomAccessFile *	file,
		const ReadOptions &	options,
		const BlockHandle &	handle,
		BlockContents *	result
	)

Definition at line 65 of file format.cc.

                                         {
   result->data = Slice();
   result->cachable = false;
   result->heap_allocated = false;
 
   // Read the block contents as well as the type/crc footer.
   // See table_builder.cc for the code that built this structure.
   size_t n = static_cast<size_t>(handle.size());
   char* buf = new char[n + kBlockTrailerSize];
   Slice contents;
   Status s = file->Read(handle.offset(), n + kBlockTrailerSize, &contents, buf);
   if (!s.ok()) {
     delete[] buf;
     return s;
   }
   if (contents.size() != n + kBlockTrailerSize) {
     delete[] buf;
     return Status::Corruption("truncated block read");
   }
 
   // Check the crc of the type and the block contents
   const char* data = contents.data();    // Pointer to where Read put the data
   if (options.verify_checksums) {
     const uint32_t crc = crc32c::Unmask(DecodeFixed32(data + n + 1));
     const uint32_t actual = crc32c::Value(data, n + 1);
     if (actual != crc) {
       delete[] buf;
       s = Status::Corruption("block checksum mismatch");
       return s;
     }
   }
 
   switch (data[n]) {
     case kNoCompression:
       if (data != buf) {
         // File implementation gave us pointer to some other data.
         // Use it directly under the assumption that it will be live
         // while the file is open.
         delete[] buf;
         result->data = Slice(data, n);
         result->heap_allocated = false;
         result->cachable = false;  // Do not double-cache
       } else {
         result->data = Slice(buf, n);
         result->heap_allocated = true;
         result->cachable = true;
       }
 
       // Ok
       break;
     case kSnappyCompression: {
       size_t ulength = 0;
       if (!port::Snappy_GetUncompressedLength(data, n, &ulength)) {
         delete[] buf;
         return Status::Corruption("corrupted compressed block contents");
       }
       char* ubuf = new char[ulength];
       if (!port::Snappy_Uncompress(data, n, ubuf)) {
         delete[] buf;
         delete[] ubuf;
         return Status::Corruption("corrupted compressed block contents");
       }
       delete[] buf;
       result->data = Slice(ubuf, ulength);
       result->heap_allocated = true;
       result->cachable = true;
       break;
     }
     default:
       delete[] buf;
       return Status::Corruption("bad block type");
   }
 
   return Status::OK();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ ReadFileToString()

Status leveldb::ReadFileToString	(	Env *	env,
		const std::string &	fname,
		std::string *	data
	)

Definition at line 72 of file env.cc.

                                                                            {
   data->clear();
   SequentialFile* file;
   Status s = env->NewSequentialFile(fname, &file);
   if (!s.ok()) {
     return s;
   }
   static const int kBufferSize = 8192;
   char* space = new char[kBufferSize];
   while (true) {
     Slice fragment;
     s = file->Read(kBufferSize, &fragment, space);
     if (!s.ok()) {
       break;
     }
     data->append(fragment.data(), fragment.size());
     if (fragment.empty()) {
       break;
     }
   }
   delete[] space;
   delete file;
   return s;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ ReleaseBlock()

static void leveldb::ReleaseBlock	(	void *	arg,
		void *	h
	)

static

Definition at line 156 of file table.cc.

                                              {
   Cache* cache = reinterpret_cast<Cache*>(arg);
   Cache::Handle* handle = reinterpret_cast<Cache::Handle*>(h);
   cache->Release(handle);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ RepairDB()

Status leveldb::RepairDB	(	const std::string &	dbname,
		const Options &	options
	)

Definition at line 456 of file repair.cc.

                                                                  {
   Repairer repairer(dbname, options);
   return repairer.Run();
 }

Here is the caller graph for this function:

§ Reverse()

static std::string leveldb::Reverse ( const Slice & key )

static

Definition at line 27 of file table_test.cc.

                                            {
   std::string str(key.ToString());
   std::string rev("");
   for (std::string::reverse_iterator rit = str.rbegin();
        rit != str.rend(); ++rit) {
     rev.push_back(*rit);
   }
   return rev;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ RunConcurrent()

static void leveldb::RunConcurrent ( int run )

static

Definition at line 348 of file skiplist_test.cc.

                                    {
   const int seed = test::RandomSeed() + (run * 100);
   Random rnd(seed);
   const int N = 1000;
   const int kSize = 1000;
   for (int i = 0; i < N; i++) {
     if ((i % 100) == 0) {
       fprintf(stderr, "Run %d of %d\n", i, N);
     }
     TestState state(seed + 1);
     Env::Default()->Schedule(ConcurrentReader, &state);
     state.Wait(TestState::RUNNING);
     for (int i = 0; i < kSize; i++) {
       state.t_.WriteStep(&rnd);
     }
     state.quit_flag_.Release_Store(&state);  // Any non-NULL arg will do
     state.Wait(TestState::DONE);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ SanitizeOptions()

Options leveldb::SanitizeOptions	(	const std::string &	dbname,
		const InternalKeyComparator *	icmp,
		const InternalFilterPolicy *	ipolicy,
		const Options &	src
	)

Definition at line 90 of file db_impl.cc.

                                             {
   Options result = src;
   result.comparator = icmp;
   result.filter_policy = (src.filter_policy != NULL) ? ipolicy : NULL;
   ClipToRange(&result.max_open_files,    64 + kNumNonTableCacheFiles, 50000);
   ClipToRange(&result.write_buffer_size, 64<<10,                      1<<30);
   ClipToRange(&result.max_file_size,     1<<20,                       1<<30);
   ClipToRange(&result.block_size,        1<<10,                       4<<20);
   if (result.info_log == NULL) {
     // Open a log file in the same directory as the db
     src.env->CreateDir(dbname);  // In case it does not exist
     src.env->RenameFile(InfoLogFileName(dbname), OldInfoLogFileName(dbname));
     Status s = src.env->NewLogger(InfoLogFileName(dbname), &result.info_log);
     if (!s.ok()) {
       // No place suitable for logging
       result.info_log = NULL;
     }
   }
   if (result.block_cache == NULL) {
     result.block_cache = NewLRUCache(8 << 20);
   }
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ SaveValue()

static void leveldb::SaveValue	(	void *	arg,
		const Slice &	ikey,
		const Slice &	v
	)

static

Definition at line 268 of file version_set.cc.

                                                                     {
   Saver* s = reinterpret_cast<Saver*>(arg);
   ParsedInternalKey parsed_key;
   if (!ParseInternalKey(ikey, &parsed_key)) {
     s->state = kCorrupt;
   } else {
     if (s->ucmp->Compare(parsed_key.user_key, s->user_key) == 0) {
       s->state = (parsed_key.type == kTypeValue) ? kFound : kDeleted;
       if (s->state == kFound) {
         s->value->assign(v.data(), v.size());
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ SetBool()

static void leveldb::SetBool ( void * ptr )

static

Definition at line 24 of file env_test.cc.

                                {
   reinterpret_cast<port::AtomicPointer*>(ptr)->NoBarrier_Store(ptr);
 }

Here is the caller graph for this function:

§ SetCurrentFile()

Status leveldb::SetCurrentFile	(	Env *	env,
		const std::string &	dbname,
		uint64_t	descriptor_number
	)

Definition at line 126 of file filename.cc.

                                                   {
   // Remove leading "dbname/" and add newline to manifest file name
   std::string manifest = DescriptorFileName(dbname, descriptor_number);
   Slice contents = manifest;
   assert(contents.starts_with(dbname + "/"));
   contents.remove_prefix(dbname.size() + 1);
   std::string tmp = TempFileName(dbname, descriptor_number);
   Status s = WriteStringToFileSync(env, contents.ToString() + "\n", tmp);
   if (s.ok()) {
     s = env->RenameFile(tmp, CurrentFileName(dbname));
   }
   if (!s.ok()) {
     env->DeleteFile(tmp);
   }
   return s;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ Shorten()

static std::string leveldb::Shorten	(	const std::string &	s,
		const std::string &	l
	)

static

Definition at line 19 of file dbformat_test.cc.

                                                                  {
   std::string result = s;
   InternalKeyComparator(BytewiseComparator()).FindShortestSeparator(&result, l);
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ ShortSuccessor()

static std::string leveldb::ShortSuccessor ( const std::string & s )

static

Definition at line 25 of file dbformat_test.cc.

                                                     {
   std::string result = s;
   InternalKeyComparator(BytewiseComparator()).FindShortSuccessor(&result);
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ SnappyCompressionSupported()

static bool leveldb::SnappyCompressionSupported ( )

static

Definition at line 830 of file table_test.cc.

                                          {
   std::string out;
   Slice in = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
   return port::Snappy_Compress(in.data(), in.size(), &out);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ SomeFileOverlapsRange()

bool leveldb::SomeFileOverlapsRange	(	const InternalKeyComparator &	icmp,
		bool	disjoint_sorted_files,
		const std::vector< FileMetaData *> &	files,
		const Slice *	smallest_user_key,
		const Slice *	largest_user_key
	)

Definition at line 121 of file version_set.cc.

                                    {
   const Comparator* ucmp = icmp.user_comparator();
   if (!disjoint_sorted_files) {
     // Need to check against all files
     for (size_t i = 0; i < files.size(); i++) {
       const FileMetaData* f = files[i];
       if (AfterFile(ucmp, smallest_user_key, f) ||
           BeforeFile(ucmp, largest_user_key, f)) {
         // No overlap
       } else {
         return true;  // Overlap
       }
     }
     return false;
   }
 
   // Binary search over file list
   uint32_t index = 0;
   if (smallest_user_key != NULL) {
     // Find the earliest possible internal key for smallest_user_key
     InternalKey small(*smallest_user_key, kMaxSequenceNumber,kValueTypeForSeek);
     index = FindFile(icmp, files, small.Encode());
   }
 
   if (index >= files.size()) {
     // beginning of range is after all files, so no overlap.
     return false;
   }
 
   return !BeforeFile(ucmp, largest_user_key, files[index]);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ SSTTableFileName()

std::string leveldb::SSTTableFileName	(	const std::string &	name,
		uint64_t	number
	)

Definition at line 37 of file filename.cc.

                                                                    {
   assert(number > 0);
   return MakeFileName(name, number, "sst");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ TableFileName()

std::string leveldb::TableFileName	(	const std::string &	name,
		uint64_t	number
	)

Definition at line 32 of file filename.cc.

                                                                 {
   assert(number > 0);
   return MakeFileName(name, number, "ldb");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ TargetFileSize()

static int leveldb::TargetFileSize ( const Options * options )

static

Definition at line 23 of file version_set.cc.

                                                   {
   return options->max_file_size;
 }

Here is the caller graph for this function:

§ TempFileName()

std::string leveldb::TempFileName	(	const std::string &	dbname,
		uint64_t	number
	)

Definition at line 58 of file filename.cc.

                                                                  {
   assert(number > 0);
   return MakeFileName(dbname, number, "dbtmp");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ TEST() [1/142]

leveldb::TEST	(	HASH	,
		SignedUnsignedIssue
	)

Definition at line 12 of file hash_test.cc.

                                 {
   const unsigned char data1[1] = {0x62};
   const unsigned char data2[2] = {0xc3, 0x97};
   const unsigned char data3[3] = {0xe2, 0x99, 0xa5};
   const unsigned char data4[4] = {0xe1, 0x80, 0xb9, 0x32};
   const unsigned char data5[48] = {
     0x01, 0xc0, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x14, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x04, 0x00,
     0x00, 0x00, 0x00, 0x14,
     0x00, 0x00, 0x00, 0x18,
     0x28, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x02, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
   };
 
   ASSERT_EQ(Hash(0, 0, 0xbc9f1d34), 0xbc9f1d34);
   ASSERT_EQ(
       Hash(reinterpret_cast<const char*>(data1), sizeof(data1), 0xbc9f1d34),
       0xef1345c4);
   ASSERT_EQ(
       Hash(reinterpret_cast<const char*>(data2), sizeof(data2), 0xbc9f1d34),
       0x5b663814);
   ASSERT_EQ(
       Hash(reinterpret_cast<const char*>(data3), sizeof(data3), 0xbc9f1d34),
       0x323c078f);
   ASSERT_EQ(
       Hash(reinterpret_cast<const char*>(data4), sizeof(data4), 0xbc9f1d34),
       0xed21633a);
   ASSERT_EQ(
       Hash(reinterpret_cast<const char*>(data5), sizeof(data5), 0x12345678),
       0xf333dabb);
 }

Here is the call graph for this function:

§ TEST() [2/142]

leveldb::TEST	(	Coding	,
		Fixed32
	)

Definition at line 13 of file coding_test.cc.

                       {
   std::string s;
   for (uint32_t v = 0; v < 100000; v++) {
     PutFixed32(&s, v);
   }
 
   const char* p = s.data();
   for (uint32_t v = 0; v < 100000; v++) {
     uint32_t actual = DecodeFixed32(p);
     ASSERT_EQ(v, actual);
     p += sizeof(uint32_t);
   }
 }

Here is the call graph for this function:

§ TEST() [3/142]

leveldb::TEST	(	ArenaTest	,
		Empty
	)

Definition at line 14 of file arena_test.cc.

                        {
   Arena arena;
 }

§ TEST() [4/142]

leveldb::TEST	(	FileNameTest	,
		Parse
	)

Definition at line 16 of file filename_test.cc.

                           {
   Slice db;
   FileType type;
   uint64_t number;
 
   // Successful parses
   static struct {
     const char* fname;
     uint64_t number;
     FileType type;
   } cases[] = {
     { "100.log",            100,   kLogFile },
     { "0.log",              0,     kLogFile },
     { "0.sst",              0,     kTableFile },
     { "0.ldb",              0,     kTableFile },
     { "CURRENT",            0,     kCurrentFile },
     { "LOCK",               0,     kDBLockFile },
     { "MANIFEST-2",         2,     kDescriptorFile },
     { "MANIFEST-7",         7,     kDescriptorFile },
     { "LOG",                0,     kInfoLogFile },
     { "LOG.old",            0,     kInfoLogFile },
     { "18446744073709551615.log", 18446744073709551615ull, kLogFile },
   };
   for (int i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
     std::string f = cases[i].fname;
     ASSERT_TRUE(ParseFileName(f, &number, &type)) << f;
     ASSERT_EQ(cases[i].type, type) << f;
     ASSERT_EQ(cases[i].number, number) << f;
   }
 
   // Errors
   static const char* errors[] = {
     "",
     "foo",
     "foo-dx-100.log",
     ".log",
     "",
     "manifest",
     "CURREN",
     "CURRENTX",
     "MANIFES",
     "MANIFEST",
     "MANIFEST-",
     "XMANIFEST-3",
     "MANIFEST-3x",
     "LOC",
     "LOCKx",
     "LO",
     "LOGx",
     "18446744073709551616.log",
     "184467440737095516150.log",
     "100",
     "100.",
     "100.lop"
   };
   for (int i = 0; i < sizeof(errors) / sizeof(errors[0]); i++) {
     std::string f = errors[i];
     ASSERT_TRUE(!ParseFileName(f, &number, &type)) << f;
   }
 }

Here is the call graph for this function:

§ TEST() [5/142]

leveldb::TEST	(	ArenaTest	,
		Simple
	)

Definition at line 18 of file arena_test.cc.

                         {
   std::vector<std::pair<size_t, char*> > allocated;
   Arena arena;
   const int N = 100000;
   size_t bytes = 0;
   Random rnd(301);
   for (int i = 0; i < N; i++) {
     size_t s;
     if (i % (N / 10) == 0) {
       s = i;
     } else {
       s = rnd.OneIn(4000) ? rnd.Uniform(6000) :
           (rnd.OneIn(10) ? rnd.Uniform(100) : rnd.Uniform(20));
     }
     if (s == 0) {
       // Our arena disallows size 0 allocations.
       s = 1;
     }
     char* r;
     if (rnd.OneIn(10)) {
       r = arena.AllocateAligned(s);
     } else {
       r = arena.Allocate(s);
     }
 
     for (size_t b = 0; b < s; b++) {
       // Fill the "i"th allocation with a known bit pattern
       r[b] = i % 256;
     }
     bytes += s;
     allocated.push_back(std::make_pair(s, r));
     ASSERT_GE(arena.MemoryUsage(), bytes);
     if (i > N/10) {
       ASSERT_LE(arena.MemoryUsage(), bytes * 1.10);
     }
   }
   for (size_t i = 0; i < allocated.size(); i++) {
     size_t num_bytes = allocated[i].first;
     const char* p = allocated[i].second;
     for (size_t b = 0; b < num_bytes; b++) {
       // Check the "i"th allocation for the known bit pattern
       ASSERT_EQ(int(p[b]) & 0xff, i % 256);
     }
   }
 }

Here is the call graph for this function:

§ TEST() [6/142]

leveldb::TEST	(	VersionEditTest	,
		EncodeDecode
	)

Definition at line 22 of file version_edit_test.cc.

                                     {
   static const uint64_t kBig = 1ull << 50;
 
   VersionEdit edit;
   for (int i = 0; i < 4; i++) {
     TestEncodeDecode(edit);
     edit.AddFile(3, kBig + 300 + i, kBig + 400 + i,
                  InternalKey("foo", kBig + 500 + i, kTypeValue),
                  InternalKey("zoo", kBig + 600 + i, kTypeDeletion));
     edit.DeleteFile(4, kBig + 700 + i);
     edit.SetCompactPointer(i, InternalKey("x", kBig + 900 + i, kTypeValue));
   }
 
   edit.SetComparatorName("foo");
   edit.SetLogNumber(kBig + 100);
   edit.SetNextFile(kBig + 200);
   edit.SetLastSequence(kBig + 1000);
   TestEncodeDecode(edit);
 }

Here is the call graph for this function:

§ TEST() [7/142]

leveldb::TEST	(	Coding	,
		Fixed64
	)

Definition at line 27 of file coding_test.cc.

                       {
   std::string s;
   for (int power = 0; power <= 63; power++) {
     uint64_t v = static_cast<uint64_t>(1) << power;
     PutFixed64(&s, v - 1);
     PutFixed64(&s, v + 0);
     PutFixed64(&s, v + 1);
   }
 
   const char* p = s.data();
   for (int power = 0; power <= 63; power++) {
     uint64_t v = static_cast<uint64_t>(1) << power;
     uint64_t actual;
     actual = DecodeFixed64(p);
     ASSERT_EQ(v-1, actual);
     p += sizeof(uint64_t);
 
     actual = DecodeFixed64(p);
     ASSERT_EQ(v+0, actual);
     p += sizeof(uint64_t);
 
     actual = DecodeFixed64(p);
     ASSERT_EQ(v+1, actual);
     p += sizeof(uint64_t);
   }
 }

Here is the call graph for this function:

§ TEST() [8/142]

leveldb::TEST	(	MemEnvTest	,
		Basics
	)

Definition at line 28 of file memenv_test.cc.

                          {
   uint64_t file_size;
   WritableFile* writable_file;
   std::vector<std::string> children;
 
   ASSERT_OK(env_->CreateDir("/dir"));
 
   // Check that the directory is empty.
   ASSERT_TRUE(!env_->FileExists("/dir/non_existent"));
   ASSERT_TRUE(!env_->GetFileSize("/dir/non_existent", &file_size).ok());
   ASSERT_OK(env_->GetChildren("/dir", &children));
   ASSERT_EQ(0, children.size());
 
   // Create a file.
   ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file));
   ASSERT_OK(env_->GetFileSize("/dir/f", &file_size));
   ASSERT_EQ(0, file_size);
   delete writable_file;
 
   // Check that the file exists.
   ASSERT_TRUE(env_->FileExists("/dir/f"));
   ASSERT_OK(env_->GetFileSize("/dir/f", &file_size));
   ASSERT_EQ(0, file_size);
   ASSERT_OK(env_->GetChildren("/dir", &children));
   ASSERT_EQ(1, children.size());
   ASSERT_EQ("f", children[0]);
 
   // Write to the file.
   ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file));
   ASSERT_OK(writable_file->Append("abc"));
   delete writable_file;
 
   // Check that append works.
   ASSERT_OK(env_->NewAppendableFile("/dir/f", &writable_file));
   ASSERT_OK(env_->GetFileSize("/dir/f", &file_size));
   ASSERT_EQ(3, file_size);
   ASSERT_OK(writable_file->Append("hello"));
   delete writable_file;
 
   // Check for expected size.
   ASSERT_OK(env_->GetFileSize("/dir/f", &file_size));
   ASSERT_EQ(8, file_size);
 
   // Check that renaming works.
   ASSERT_TRUE(!env_->RenameFile("/dir/non_existent", "/dir/g").ok());
   ASSERT_OK(env_->RenameFile("/dir/f", "/dir/g"));
   ASSERT_TRUE(!env_->FileExists("/dir/f"));
   ASSERT_TRUE(env_->FileExists("/dir/g"));
   ASSERT_OK(env_->GetFileSize("/dir/g", &file_size));
   ASSERT_EQ(8, file_size);
 
   // Check that opening non-existent file fails.
   SequentialFile* seq_file;
   RandomAccessFile* rand_file;
   ASSERT_TRUE(!env_->NewSequentialFile("/dir/non_existent", &seq_file).ok());
   ASSERT_TRUE(!seq_file);
   ASSERT_TRUE(!env_->NewRandomAccessFile("/dir/non_existent", &rand_file).ok());
   ASSERT_TRUE(!rand_file);
 
   // Check that deleting works.
   ASSERT_TRUE(!env_->DeleteFile("/dir/non_existent").ok());
   ASSERT_OK(env_->DeleteFile("/dir/g"));
   ASSERT_TRUE(!env_->FileExists("/dir/g"));
   ASSERT_OK(env_->GetChildren("/dir", &children));
   ASSERT_EQ(0, children.size());
   ASSERT_OK(env_->DeleteDir("/dir"));
 }

Here is the call graph for this function:

§ TEST() [9/142]

leveldb::TEST	(	EnvPosixTest	,
		RunImmediately
	)

Definition at line 28 of file env_test.cc.

                                    {
   port::AtomicPointer called (NULL);
   env_->Schedule(&SetBool, &called);
   Env::Default()->SleepForMicroseconds(kDelayMicros);
   ASSERT_TRUE(called.NoBarrier_Load() != NULL);
 }

Here is the call graph for this function:

§ TEST() [10/142]

leveldb::TEST	(	SkipTest	,
		Empty
	)

Definition at line 31 of file skiplist_test.cc.

                       {
   Arena arena;
   Comparator cmp;
   SkipList<Key, Comparator> list(cmp, &arena);
   ASSERT_TRUE(!list.Contains(10));
 
   SkipList<Key, Comparator>::Iterator iter(&list);
   ASSERT_TRUE(!iter.Valid());
   iter.SeekToFirst();
   ASSERT_TRUE(!iter.Valid());
   iter.Seek(100);
   ASSERT_TRUE(!iter.Valid());
   iter.SeekToLast();
   ASSERT_TRUE(!iter.Valid());
 }

Here is the call graph for this function:

§ TEST() [11/142]

leveldb::TEST	(	EnvPosixTest	,
		RunMany
	)

Definition at line 35 of file env_test.cc.

                             {
   port::AtomicPointer last_id (NULL);
 
   struct CB {
     port::AtomicPointer* last_id_ptr;   // Pointer to shared slot
     uintptr_t id;             // Order# for the execution of this callback
 
     CB(port::AtomicPointer* p, int i) : last_id_ptr(p), id(i) { }
 
     static void Run(void* v) {
       CB* cb = reinterpret_cast<CB*>(v);
       void* cur = cb->last_id_ptr->NoBarrier_Load();
       ASSERT_EQ(cb->id-1, reinterpret_cast<uintptr_t>(cur));
       cb->last_id_ptr->Release_Store(reinterpret_cast<void*>(cb->id));
     }
   };
 
   // Schedule in different order than start time
   CB cb1(&last_id, 1);
   CB cb2(&last_id, 2);
   CB cb3(&last_id, 3);
   CB cb4(&last_id, 4);
   env_->Schedule(&CB::Run, &cb1);
   env_->Schedule(&CB::Run, &cb2);
   env_->Schedule(&CB::Run, &cb3);
   env_->Schedule(&CB::Run, &cb4);
 
   Env::Default()->SleepForMicroseconds(kDelayMicros);
   void* cur = last_id.Acquire_Load();
   ASSERT_EQ(4, reinterpret_cast<uintptr_t>(cur));
 }

Here is the call graph for this function:

§ TEST() [12/142]

leveldb::TEST	(	FilterBlockTest	,
		EmptyBuilder
	)

Definition at line 46 of file filter_block_test.cc.

                                     {
   FilterBlockBuilder builder(&policy_);
   Slice block = builder.Finish();
   ASSERT_EQ("\\x00\\x00\\x00\\x00\\x0b", EscapeString(block));
   FilterBlockReader reader(&policy_, block);
   ASSERT_TRUE(reader.KeyMayMatch(0, "foo"));
   ASSERT_TRUE(reader.KeyMayMatch(100000, "foo"));
 }

Here is the call graph for this function:

§ TEST() [13/142]

leveldb::TEST	(	SkipTest	,
		InsertAndLookup
	)

Definition at line 47 of file skiplist_test.cc.

                                 {
   const int N = 2000;
   const int R = 5000;
   Random rnd(1000);
   std::set<Key> keys;
   Arena arena;
   Comparator cmp;
   SkipList<Key, Comparator> list(cmp, &arena);
   for (int i = 0; i < N; i++) {
     Key key = rnd.Next() % R;
     if (keys.insert(key).second) {
       list.Insert(key);
     }
   }
 
   for (int i = 0; i < R; i++) {
     if (list.Contains(i)) {
       ASSERT_EQ(keys.count(i), 1);
     } else {
       ASSERT_EQ(keys.count(i), 0);
     }
   }
 
   // Simple iterator tests
   {
     SkipList<Key, Comparator>::Iterator iter(&list);
     ASSERT_TRUE(!iter.Valid());
 
     iter.Seek(0);
     ASSERT_TRUE(iter.Valid());
     ASSERT_EQ(*(keys.begin()), iter.key());
 
     iter.SeekToFirst();
     ASSERT_TRUE(iter.Valid());
     ASSERT_EQ(*(keys.begin()), iter.key());
 
     iter.SeekToLast();
     ASSERT_TRUE(iter.Valid());
     ASSERT_EQ(*(keys.rbegin()), iter.key());
   }
 
   // Forward iteration test
   for (int i = 0; i < R; i++) {
     SkipList<Key, Comparator>::Iterator iter(&list);
     iter.Seek(i);
 
     // Compare against model iterator
     std::set<Key>::iterator model_iter = keys.lower_bound(i);
     for (int j = 0; j < 3; j++) {
       if (model_iter == keys.end()) {
         ASSERT_TRUE(!iter.Valid());
         break;
       } else {
         ASSERT_TRUE(iter.Valid());
         ASSERT_EQ(*model_iter, iter.key());
         ++model_iter;
         iter.Next();
       }
     }
   }
 
   // Backward iteration test
   {
     SkipList<Key, Comparator>::Iterator iter(&list);
     iter.SeekToLast();
 
     // Compare against model iterator
     for (std::set<Key>::reverse_iterator model_iter = keys.rbegin();
          model_iter != keys.rend();
          ++model_iter) {
       ASSERT_TRUE(iter.Valid());
       ASSERT_EQ(*model_iter, iter.key());
       iter.Prev();
     }
     ASSERT_TRUE(!iter.Valid());
   }
 }

Here is the call graph for this function:

§ TEST() [14/142]

leveldb::TEST	(	FormatTest	,
		InternalKey_EncodeDecode
	)

Definition at line 49 of file dbformat_test.cc.

                                            {
   const char* keys[] = { "", "k", "hello", "longggggggggggggggggggggg" };
   const uint64_t seq[] = {
     1, 2, 3,
     (1ull << 8) - 1, 1ull << 8, (1ull << 8) + 1,
     (1ull << 16) - 1, 1ull << 16, (1ull << 16) + 1,
     (1ull << 32) - 1, 1ull << 32, (1ull << 32) + 1
   };
   for (int k = 0; k < sizeof(keys) / sizeof(keys[0]); k++) {
     for (int s = 0; s < sizeof(seq) / sizeof(seq[0]); s++) {
       TestKey(keys[k], seq[s], kTypeValue);
       TestKey("hello", 1, kTypeDeletion);
     }
   }
 }

Here is the call graph for this function:

§ TEST() [15/142]

leveldb::TEST	(	FindFileTest	,
		Empty
	)

Definition at line 51 of file version_set_test.cc.

                           {
   ASSERT_EQ(0, Find("foo"));
   ASSERT_TRUE(! Overlaps("a", "z"));
   ASSERT_TRUE(! Overlaps(NULL, "z"));
   ASSERT_TRUE(! Overlaps("a", NULL));
   ASSERT_TRUE(! Overlaps(NULL, NULL));
 }

Here is the call graph for this function:

§ TEST() [16/142]

leveldb::TEST	(	FilterBlockTest	,
		SingleChunk
	)

Definition at line 55 of file filter_block_test.cc.

                                    {
   FilterBlockBuilder builder(&policy_);
   builder.StartBlock(100);
   builder.AddKey("foo");
   builder.AddKey("bar");
   builder.AddKey("box");
   builder.StartBlock(200);
   builder.AddKey("box");
   builder.StartBlock(300);
   builder.AddKey("hello");
   Slice block = builder.Finish();
   FilterBlockReader reader(&policy_, block);
   ASSERT_TRUE(reader.KeyMayMatch(100, "foo"));
   ASSERT_TRUE(reader.KeyMayMatch(100, "bar"));
   ASSERT_TRUE(reader.KeyMayMatch(100, "box"));
   ASSERT_TRUE(reader.KeyMayMatch(100, "hello"));
   ASSERT_TRUE(reader.KeyMayMatch(100, "foo"));
   ASSERT_TRUE(! reader.KeyMayMatch(100, "missing"));
   ASSERT_TRUE(! reader.KeyMayMatch(100, "other"));
 }

Here is the call graph for this function:

§ TEST() [17/142]

leveldb::TEST	(	Coding	,
		EncodingOutput
	)

Definition at line 55 of file coding_test.cc.

                              {
   std::string dst;
   PutFixed32(&dst, 0x04030201);
   ASSERT_EQ(4, dst.size());
   ASSERT_EQ(0x01, static_cast<int>(dst[0]));
   ASSERT_EQ(0x02, static_cast<int>(dst[1]));
   ASSERT_EQ(0x03, static_cast<int>(dst[2]));
   ASSERT_EQ(0x04, static_cast<int>(dst[3]));
 
   dst.clear();
   PutFixed64(&dst, 0x0807060504030201ull);
   ASSERT_EQ(8, dst.size());
   ASSERT_EQ(0x01, static_cast<int>(dst[0]));
   ASSERT_EQ(0x02, static_cast<int>(dst[1]));
   ASSERT_EQ(0x03, static_cast<int>(dst[2]));
   ASSERT_EQ(0x04, static_cast<int>(dst[3]));
   ASSERT_EQ(0x05, static_cast<int>(dst[4]));
   ASSERT_EQ(0x06, static_cast<int>(dst[5]));
   ASSERT_EQ(0x07, static_cast<int>(dst[6]));
   ASSERT_EQ(0x08, static_cast<int>(dst[7]));
 }

Here is the call graph for this function:

§ TEST() [18/142]

leveldb::TEST	(	WriteBatchTest	,
		Empty
	)

Definition at line 57 of file write_batch_test.cc.

                             {
   WriteBatch batch;
   ASSERT_EQ("", PrintContents(&batch));
   ASSERT_EQ(0, WriteBatchInternal::Count(&batch));
 }

Here is the call graph for this function:

§ TEST() [19/142]

leveldb::TEST	(	FindFileTest	,
		Single
	)

Definition at line 59 of file version_set_test.cc.

                            {
   Add("p", "q");
   ASSERT_EQ(0, Find("a"));
   ASSERT_EQ(0, Find("p"));
   ASSERT_EQ(0, Find("p1"));
   ASSERT_EQ(0, Find("q"));
   ASSERT_EQ(1, Find("q1"));
   ASSERT_EQ(1, Find("z"));
 
   ASSERT_TRUE(! Overlaps("a", "b"));
   ASSERT_TRUE(! Overlaps("z1", "z2"));
   ASSERT_TRUE(Overlaps("a", "p"));
   ASSERT_TRUE(Overlaps("a", "q"));
   ASSERT_TRUE(Overlaps("a", "z"));
   ASSERT_TRUE(Overlaps("p", "p1"));
   ASSERT_TRUE(Overlaps("p", "q"));
   ASSERT_TRUE(Overlaps("p", "z"));
   ASSERT_TRUE(Overlaps("p1", "p2"));
   ASSERT_TRUE(Overlaps("p1", "z"));
   ASSERT_TRUE(Overlaps("q", "q"));
   ASSERT_TRUE(Overlaps("q", "q1"));
 
   ASSERT_TRUE(! Overlaps(NULL, "j"));
   ASSERT_TRUE(! Overlaps("r", NULL));
   ASSERT_TRUE(Overlaps(NULL, "p"));
   ASSERT_TRUE(Overlaps(NULL, "p1"));
   ASSERT_TRUE(Overlaps("q", NULL));
   ASSERT_TRUE(Overlaps(NULL, NULL));
 }

Here is the call graph for this function:

§ TEST() [20/142]

leveldb::TEST	(	WriteBatchTest	,
		Multiple
	)

Definition at line 63 of file write_batch_test.cc.

                                {
   WriteBatch batch;
   batch.Put(Slice("foo"), Slice("bar"));
   batch.Delete(Slice("box"));
   batch.Put(Slice("baz"), Slice("boo"));
   WriteBatchInternal::SetSequence(&batch, 100);
   ASSERT_EQ(100, WriteBatchInternal::Sequence(&batch));
   ASSERT_EQ(3, WriteBatchInternal::Count(&batch));
   ASSERT_EQ("Put(baz, boo)@102"
             "Delete(box)@101"
             "Put(foo, bar)@100",
             PrintContents(&batch));
 }

Here is the call graph for this function:

§ TEST() [21/142]

leveldb::TEST	(	FormatTest	,
		InternalKeyShortSeparator
	)

Definition at line 65 of file dbformat_test.cc.

                                             {
   // When user keys are same
   ASSERT_EQ(IKey("foo", 100, kTypeValue),
             Shorten(IKey("foo", 100, kTypeValue),
                     IKey("foo", 99, kTypeValue)));
   ASSERT_EQ(IKey("foo", 100, kTypeValue),
             Shorten(IKey("foo", 100, kTypeValue),
                     IKey("foo", 101, kTypeValue)));
   ASSERT_EQ(IKey("foo", 100, kTypeValue),
             Shorten(IKey("foo", 100, kTypeValue),
                     IKey("foo", 100, kTypeValue)));
   ASSERT_EQ(IKey("foo", 100, kTypeValue),
             Shorten(IKey("foo", 100, kTypeValue),
                     IKey("foo", 100, kTypeDeletion)));
 
   // When user keys are misordered
   ASSERT_EQ(IKey("foo", 100, kTypeValue),
             Shorten(IKey("foo", 100, kTypeValue),
                     IKey("bar", 99, kTypeValue)));
 
   // When user keys are different, but correctly ordered
   ASSERT_EQ(IKey("g", kMaxSequenceNumber, kValueTypeForSeek),
             Shorten(IKey("foo", 100, kTypeValue),
                     IKey("hello", 200, kTypeValue)));
 
   // When start user key is prefix of limit user key
   ASSERT_EQ(IKey("foo", 100, kTypeValue),
             Shorten(IKey("foo", 100, kTypeValue),
                     IKey("foobar", 200, kTypeValue)));
 
   // When limit user key is prefix of start user key
   ASSERT_EQ(IKey("foobar", 100, kTypeValue),
             Shorten(IKey("foobar", 100, kTypeValue),
                     IKey("foo", 200, kTypeValue)));
 }

Here is the call graph for this function:

§ TEST() [22/142]

leveldb::TEST	(	CacheTest	,
		HitAndMiss
	)

Definition at line 73 of file cache_test.cc.

                             {
   ASSERT_EQ(-1, Lookup(100));
 
   Insert(100, 101);
   ASSERT_EQ(101, Lookup(100));
   ASSERT_EQ(-1,  Lookup(200));
   ASSERT_EQ(-1,  Lookup(300));
 
   Insert(200, 201);
   ASSERT_EQ(101, Lookup(100));
   ASSERT_EQ(201, Lookup(200));
   ASSERT_EQ(-1,  Lookup(300));
 
   Insert(100, 102);
   ASSERT_EQ(102, Lookup(100));
   ASSERT_EQ(201, Lookup(200));
   ASSERT_EQ(-1,  Lookup(300));
 
   ASSERT_EQ(1, deleted_keys_.size());
   ASSERT_EQ(100, deleted_keys_[0]);
   ASSERT_EQ(101, deleted_values_[0]);
 }

Here is the call graph for this function:

§ TEST() [23/142]

leveldb::TEST	(	FilterBlockTest	,
		MultiChunk
	)

Definition at line 76 of file filter_block_test.cc.

                                   {
   FilterBlockBuilder builder(&policy_);
 
   // First filter
   builder.StartBlock(0);
   builder.AddKey("foo");
   builder.StartBlock(2000);
   builder.AddKey("bar");
 
   // Second filter
   builder.StartBlock(3100);
   builder.AddKey("box");
 
   // Third filter is empty
 
   // Last filter
   builder.StartBlock(9000);
   builder.AddKey("box");
   builder.AddKey("hello");
 
   Slice block = builder.Finish();
   FilterBlockReader reader(&policy_, block);
 
   // Check first filter
   ASSERT_TRUE(reader.KeyMayMatch(0, "foo"));
   ASSERT_TRUE(reader.KeyMayMatch(2000, "bar"));
   ASSERT_TRUE(! reader.KeyMayMatch(0, "box"));
   ASSERT_TRUE(! reader.KeyMayMatch(0, "hello"));
 
   // Check second filter
   ASSERT_TRUE(reader.KeyMayMatch(3100, "box"));
   ASSERT_TRUE(! reader.KeyMayMatch(3100, "foo"));
   ASSERT_TRUE(! reader.KeyMayMatch(3100, "bar"));
   ASSERT_TRUE(! reader.KeyMayMatch(3100, "hello"));
 
   // Check third filter (empty)
   ASSERT_TRUE(! reader.KeyMayMatch(4100, "foo"));
   ASSERT_TRUE(! reader.KeyMayMatch(4100, "bar"));
   ASSERT_TRUE(! reader.KeyMayMatch(4100, "box"));
   ASSERT_TRUE(! reader.KeyMayMatch(4100, "hello"));
 
   // Check last filter
   ASSERT_TRUE(reader.KeyMayMatch(9000, "box"));
   ASSERT_TRUE(reader.KeyMayMatch(9000, "hello"));
   ASSERT_TRUE(! reader.KeyMayMatch(9000, "foo"));
   ASSERT_TRUE(! reader.KeyMayMatch(9000, "bar"));
 }

Here is the call graph for this function:

§ TEST() [24/142]

leveldb::TEST	(	WriteBatchTest	,
		Corruption
	)

Definition at line 77 of file write_batch_test.cc.

                                  {
   WriteBatch batch;
   batch.Put(Slice("foo"), Slice("bar"));
   batch.Delete(Slice("box"));
   WriteBatchInternal::SetSequence(&batch, 200);
   Slice contents = WriteBatchInternal::Contents(&batch);
   WriteBatchInternal::SetContents(&batch,
                                   Slice(contents.data(),contents.size()-1));
   ASSERT_EQ("Put(foo, bar)@200"
             "ParseError()",
             PrintContents(&batch));
 }

Here is the call graph for this function:

§ TEST() [25/142]

leveldb::TEST	(	FileNameTest	,
		Construction
	)

Definition at line 77 of file filename_test.cc.

                                  {
   uint64_t number;
   FileType type;
   std::string fname;
 
   fname = CurrentFileName("foo");
   ASSERT_EQ("foo/", std::string(fname.data(), 4));
   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
   ASSERT_EQ(0, number);
   ASSERT_EQ(kCurrentFile, type);
 
   fname = LockFileName("foo");
   ASSERT_EQ("foo/", std::string(fname.data(), 4));
   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
   ASSERT_EQ(0, number);
   ASSERT_EQ(kDBLockFile, type);
 
   fname = LogFileName("foo", 192);
   ASSERT_EQ("foo/", std::string(fname.data(), 4));
   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
   ASSERT_EQ(192, number);
   ASSERT_EQ(kLogFile, type);
 
   fname = TableFileName("bar", 200);
   ASSERT_EQ("bar/", std::string(fname.data(), 4));
   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
   ASSERT_EQ(200, number);
   ASSERT_EQ(kTableFile, type);
 
   fname = DescriptorFileName("bar", 100);
   ASSERT_EQ("bar/", std::string(fname.data(), 4));
   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
   ASSERT_EQ(100, number);
   ASSERT_EQ(kDescriptorFile, type);
 
   fname = TempFileName("tmp", 999);
   ASSERT_EQ("tmp/", std::string(fname.data(), 4));
   ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
   ASSERT_EQ(999, number);
   ASSERT_EQ(kTempFile, type);
 }

Here is the call graph for this function:

§ TEST() [26/142]

leveldb::TEST	(	Coding	,
		Varint32
	)

Definition at line 77 of file coding_test.cc.

                        {
   std::string s;
   for (uint32_t i = 0; i < (32 * 32); i++) {
     uint32_t v = (i / 32) << (i % 32);
     PutVarint32(&s, v);
   }
 
   const char* p = s.data();
   const char* limit = p + s.size();
   for (uint32_t i = 0; i < (32 * 32); i++) {
     uint32_t expected = (i / 32) << (i % 32);
     uint32_t actual;
     const char* start = p;
     p = GetVarint32Ptr(p, limit, &actual);
     ASSERT_TRUE(p != NULL);
     ASSERT_EQ(expected, actual);
     ASSERT_EQ(VarintLength(actual), p - start);
   }
   ASSERT_EQ(p, s.data() + s.size());
 }

Here is the call graph for this function:

§ TEST() [27/142]

leveldb::TEST	(	EnvPosixTest	,
		StartThread
	)

Definition at line 81 of file env_test.cc.

                                 {
   State state;
   state.val = 0;
   state.num_running = 3;
   for (int i = 0; i < 3; i++) {
     env_->StartThread(&ThreadBody, &state);
   }
   while (true) {
     state.mu.Lock();
     int num = state.num_running;
     state.mu.Unlock();
     if (num == 0) {
       break;
     }
     Env::Default()->SleepForMicroseconds(kDelayMicros);
   }
   ASSERT_EQ(state.val, 3);
 }

Here is the call graph for this function:

§ TEST() [28/142]

leveldb::TEST	(	BloomTest	,
		EmptyFilter
	)

Definition at line 89 of file bloom_test.cc.

                              {
   ASSERT_TRUE(! Matches("hello"));
   ASSERT_TRUE(! Matches("world"));
 }

Here is the call graph for this function:

§ TEST() [29/142]

leveldb::TEST	(	FindFileTest	,
		Multiple
	)

Definition at line 90 of file version_set_test.cc.

                              {
   Add("150", "200");
   Add("200", "250");
   Add("300", "350");
   Add("400", "450");
   ASSERT_EQ(0, Find("100"));
   ASSERT_EQ(0, Find("150"));
   ASSERT_EQ(0, Find("151"));
   ASSERT_EQ(0, Find("199"));
   ASSERT_EQ(0, Find("200"));
   ASSERT_EQ(1, Find("201"));
   ASSERT_EQ(1, Find("249"));
   ASSERT_EQ(1, Find("250"));
   ASSERT_EQ(2, Find("251"));
   ASSERT_EQ(2, Find("299"));
   ASSERT_EQ(2, Find("300"));
   ASSERT_EQ(2, Find("349"));
   ASSERT_EQ(2, Find("350"));
   ASSERT_EQ(3, Find("351"));
   ASSERT_EQ(3, Find("400"));
   ASSERT_EQ(3, Find("450"));
   ASSERT_EQ(4, Find("451"));
 
   ASSERT_TRUE(! Overlaps("100", "149"));
   ASSERT_TRUE(! Overlaps("251", "299"));
   ASSERT_TRUE(! Overlaps("451", "500"));
   ASSERT_TRUE(! Overlaps("351", "399"));
 
   ASSERT_TRUE(Overlaps("100", "150"));
   ASSERT_TRUE(Overlaps("100", "200"));
   ASSERT_TRUE(Overlaps("100", "300"));
   ASSERT_TRUE(Overlaps("100", "400"));
   ASSERT_TRUE(Overlaps("100", "500"));
   ASSERT_TRUE(Overlaps("375", "400"));
   ASSERT_TRUE(Overlaps("450", "450"));
   ASSERT_TRUE(Overlaps("450", "500"));
 }

Here is the call graph for this function:

§ TEST() [30/142]

leveldb::TEST	(	WriteBatchTest	,
		Append
	)

Definition at line 90 of file write_batch_test.cc.

                              {
   WriteBatch b1, b2;
   WriteBatchInternal::SetSequence(&b1, 200);
   WriteBatchInternal::SetSequence(&b2, 300);
   WriteBatchInternal::Append(&b1, &b2);
   ASSERT_EQ("",
             PrintContents(&b1));
   b2.Put("a", "va");
   WriteBatchInternal::Append(&b1, &b2);
   ASSERT_EQ("Put(a, va)@200",
             PrintContents(&b1));
   b2.Clear();
   b2.Put("b", "vb");
   WriteBatchInternal::Append(&b1, &b2);
   ASSERT_EQ("Put(a, va)@200"
             "Put(b, vb)@201",
             PrintContents(&b1));
   b2.Delete("foo");
   WriteBatchInternal::Append(&b1, &b2);
   ASSERT_EQ("Put(a, va)@200"
             "Put(b, vb)@202"
             "Put(b, vb)@201"
             "Delete(foo)@203",
             PrintContents(&b1));
 }

Here is the call graph for this function:

§ TEST() [31/142]

leveldb::TEST	(	BloomTest	,
		Small
	)

Definition at line 94 of file bloom_test.cc.

                        {
   Add("hello");
   Add("world");
   ASSERT_TRUE(Matches("hello"));
   ASSERT_TRUE(Matches("world"));
   ASSERT_TRUE(! Matches("x"));
   ASSERT_TRUE(! Matches("foo"));
 }

Here is the call graph for this function:

§ TEST() [32/142]

leveldb::TEST	(	MemEnvTest	,
		ReadWrite
	)

Definition at line 96 of file memenv_test.cc.

                             {
   WritableFile* writable_file;
   SequentialFile* seq_file;
   RandomAccessFile* rand_file;
   Slice result;
   char scratch[100];
 
   ASSERT_OK(env_->CreateDir("/dir"));
 
   ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file));
   ASSERT_OK(writable_file->Append("hello "));
   ASSERT_OK(writable_file->Append("world"));
   delete writable_file;
 
   // Read sequentially.
   ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file));
   ASSERT_OK(seq_file->Read(5, &result, scratch)); // Read "hello".
   ASSERT_EQ(0, result.compare("hello"));
   ASSERT_OK(seq_file->Skip(1));
   ASSERT_OK(seq_file->Read(1000, &result, scratch)); // Read "world".
   ASSERT_EQ(0, result.compare("world"));
   ASSERT_OK(seq_file->Read(1000, &result, scratch)); // Try reading past EOF.
   ASSERT_EQ(0, result.size());
   ASSERT_OK(seq_file->Skip(100)); // Try to skip past end of file.
   ASSERT_OK(seq_file->Read(1000, &result, scratch));
   ASSERT_EQ(0, result.size());
   delete seq_file;
 
   // Random reads.
   ASSERT_OK(env_->NewRandomAccessFile("/dir/f", &rand_file));
   ASSERT_OK(rand_file->Read(6, 5, &result, scratch)); // Read "world".
   ASSERT_EQ(0, result.compare("world"));
   ASSERT_OK(rand_file->Read(0, 5, &result, scratch)); // Read "hello".
   ASSERT_EQ(0, result.compare("hello"));
   ASSERT_OK(rand_file->Read(10, 100, &result, scratch)); // Read "d".
   ASSERT_EQ(0, result.compare("d"));
 
   // Too high offset.
   ASSERT_TRUE(!rand_file->Read(1000, 5, &result, scratch).ok());
   delete rand_file;
 }

Here is the call graph for this function:

§ TEST() [33/142]

leveldb::TEST	(	CacheTest	,
		Erase
	)

Definition at line 96 of file cache_test.cc.

                        {
   Erase(200);
   ASSERT_EQ(0, deleted_keys_.size());
 
   Insert(100, 101);
   Insert(200, 201);
   Erase(100);
   ASSERT_EQ(-1,  Lookup(100));
   ASSERT_EQ(201, Lookup(200));
   ASSERT_EQ(1, deleted_keys_.size());
   ASSERT_EQ(100, deleted_keys_[0]);
   ASSERT_EQ(101, deleted_values_[0]);
 
   Erase(100);
   ASSERT_EQ(-1,  Lookup(100));
   ASSERT_EQ(201, Lookup(200));
   ASSERT_EQ(1, deleted_keys_.size());
 }

Here is the call graph for this function:

§ TEST() [34/142]

leveldb::TEST	(	Coding	,
		Varint64
	)

Definition at line 98 of file coding_test.cc.

                        {
   // Construct the list of values to check
   std::vector<uint64_t> values;
   // Some special values
   values.push_back(0);
   values.push_back(100);
   values.push_back(~static_cast<uint64_t>(0));
   values.push_back(~static_cast<uint64_t>(0) - 1);
   for (uint32_t k = 0; k < 64; k++) {
     // Test values near powers of two
     const uint64_t power = 1ull << k;
     values.push_back(power);
     values.push_back(power-1);
     values.push_back(power+1);
   }
 
   std::string s;
   for (size_t i = 0; i < values.size(); i++) {
     PutVarint64(&s, values[i]);
   }
 
   const char* p = s.data();
   const char* limit = p + s.size();
   for (size_t i = 0; i < values.size(); i++) {
     ASSERT_TRUE(p < limit);
     uint64_t actual;
     const char* start = p;
     p = GetVarint64Ptr(p, limit, &actual);
     ASSERT_TRUE(p != NULL);
     ASSERT_EQ(values[i], actual);
     ASSERT_EQ(VarintLength(actual), p - start);
   }
   ASSERT_EQ(p, limit);
 
 }

Here is the call graph for this function:

§ TEST() [35/142]

leveldb::TEST	(	FormatTest	,
		InternalKeyShortestSuccessor
	)

Definition at line 101 of file dbformat_test.cc.

                                                {
   ASSERT_EQ(IKey("g", kMaxSequenceNumber, kValueTypeForSeek),
             ShortSuccessor(IKey("foo", 100, kTypeValue)));
   ASSERT_EQ(IKey("\xff\xff", 100, kTypeValue),
             ShortSuccessor(IKey("\xff\xff", 100, kTypeValue)));
 }

Here is the call graph for this function:

§ TEST() [36/142]

leveldb::TEST	(	AutoCompactTest	,
		ReadAll
	)

Definition at line 106 of file autocompact_test.cc.

                                {
   DoReads(kCount);
 }

Here is the call graph for this function:

§ TEST() [37/142]

leveldb::TEST	(	AutoCompactTest	,
		ReadHalf
	)

Definition at line 110 of file autocompact_test.cc.

                                 {
   DoReads(kCount/2);
 }

Here is the call graph for this function:

§ TEST() [38/142]

leveldb::TEST	(	CacheTest	,
		EntriesArePinned
	)

Definition at line 115 of file cache_test.cc.

                                   {
   Insert(100, 101);
   Cache::Handle* h1 = cache_->Lookup(EncodeKey(100));
   ASSERT_EQ(101, DecodeValue(cache_->Value(h1)));
 
   Insert(100, 102);
   Cache::Handle* h2 = cache_->Lookup(EncodeKey(100));
   ASSERT_EQ(102, DecodeValue(cache_->Value(h2)));
   ASSERT_EQ(0, deleted_keys_.size());
 
   cache_->Release(h1);
   ASSERT_EQ(1, deleted_keys_.size());
   ASSERT_EQ(100, deleted_keys_[0]);
   ASSERT_EQ(101, deleted_values_[0]);
 
   Erase(100);
   ASSERT_EQ(-1, Lookup(100));
   ASSERT_EQ(1, deleted_keys_.size());
 
   cache_->Release(h2);
   ASSERT_EQ(2, deleted_keys_.size());
   ASSERT_EQ(100, deleted_keys_[1]);
   ASSERT_EQ(102, deleted_values_[1]);
 }

Here is the call graph for this function:

§ TEST() [39/142]

leveldb::TEST	(	BloomTest	,
		VaryingLengths
	)

Definition at line 116 of file bloom_test.cc.

                                 {
   char buffer[sizeof(int)];
 
   // Count number of filters that significantly exceed the false positive rate
   int mediocre_filters = 0;
   int good_filters = 0;
 
   for (int length = 1; length <= 10000; length = NextLength(length)) {
     Reset();
     for (int i = 0; i < length; i++) {
       Add(Key(i, buffer));
     }
     Build();
 
     ASSERT_LE(FilterSize(), static_cast<size_t>((length * 10 / 8) + 40))
         << length;
 
     // All added keys must match
     for (int i = 0; i < length; i++) {
       ASSERT_TRUE(Matches(Key(i, buffer)))
           << "Length " << length << "; key " << i;
     }
 
     // Check false positive rate
     double rate = FalsePositiveRate();
     if (kVerbose >= 1) {
       fprintf(stderr, "False positives: %5.2f%% @ length = %6d ; bytes = %6d\n",
               rate*100.0, length, static_cast<int>(FilterSize()));
     }
     ASSERT_LE(rate, 0.02);   // Must not be over 2%
     if (rate > 0.0125) mediocre_filters++;  // Allowed, but not too often
     else good_filters++;
   }
   if (kVerbose >= 1) {
     fprintf(stderr, "Filters: %d good, %d mediocre\n",
             good_filters, mediocre_filters);
   }
   ASSERT_LE(mediocre_filters, good_filters/5);
 }

Here is the call graph for this function:

§ TEST() [40/142]

leveldb::TEST	(	FindFileTest	,
		MultipleNullBoundaries
	)

Definition at line 128 of file version_set_test.cc.

                                            {
   Add("150", "200");
   Add("200", "250");
   Add("300", "350");
   Add("400", "450");
   ASSERT_TRUE(! Overlaps(NULL, "149"));
   ASSERT_TRUE(! Overlaps("451", NULL));
   ASSERT_TRUE(Overlaps(NULL, NULL));
   ASSERT_TRUE(Overlaps(NULL, "150"));
   ASSERT_TRUE(Overlaps(NULL, "199"));
   ASSERT_TRUE(Overlaps(NULL, "200"));
   ASSERT_TRUE(Overlaps(NULL, "201"));
   ASSERT_TRUE(Overlaps(NULL, "400"));
   ASSERT_TRUE(Overlaps(NULL, "800"));
   ASSERT_TRUE(Overlaps("100", NULL));
   ASSERT_TRUE(Overlaps("200", NULL));
   ASSERT_TRUE(Overlaps("449", NULL));
   ASSERT_TRUE(Overlaps("450", NULL));
 }

Here is the call graph for this function:

§ TEST() [41/142]

leveldb::TEST	(	Coding	,
		Varint32Overflow
	)

Definition at line 134 of file coding_test.cc.

                                {
   uint32_t result;
   std::string input("\x81\x82\x83\x84\x85\x11");
   ASSERT_TRUE(GetVarint32Ptr(input.data(), input.data() + input.size(), &result)
               == NULL);
 }

Here is the call graph for this function:

§ TEST() [42/142]

leveldb::TEST	(	MemEnvTest	,
		Locks
	)

Definition at line 138 of file memenv_test.cc.

                         {
   FileLock* lock;
 
   // These are no-ops, but we test they return success.
   ASSERT_OK(env_->LockFile("some file", &lock));
   ASSERT_OK(env_->UnlockFile(lock));
 }

Here is the call graph for this function:

§ TEST() [43/142]

leveldb::TEST	(	CacheTest	,
		EvictionPolicy
	)

Definition at line 140 of file cache_test.cc.

                                 {
   Insert(100, 101);
   Insert(200, 201);
   Insert(300, 301);
   Cache::Handle* h = cache_->Lookup(EncodeKey(300));
 
   // Frequently used entry must be kept around,
   // as must things that are still in use.
   for (int i = 0; i < kCacheSize + 100; i++) {
     Insert(1000+i, 2000+i);
     ASSERT_EQ(2000+i, Lookup(1000+i));
     ASSERT_EQ(101, Lookup(100));
   }
   ASSERT_EQ(101, Lookup(100));
   ASSERT_EQ(-1, Lookup(200));
   ASSERT_EQ(301, Lookup(300));
   cache_->Release(h);
 }

Here is the call graph for this function:

§ TEST() [44/142]

leveldb::TEST	(	Coding	,
		Varint32Truncation
	)

Definition at line 141 of file coding_test.cc.

                                  {
   uint32_t large_value = (1u << 31) + 100;
   std::string s;
   PutVarint32(&s, large_value);
   uint32_t result;
   for (size_t len = 0; len < s.size() - 1; len++) {
     ASSERT_TRUE(GetVarint32Ptr(s.data(), s.data() + len, &result) == NULL);
   }
   ASSERT_TRUE(GetVarint32Ptr(s.data(), s.data() + s.size(), &result) != NULL);
   ASSERT_EQ(large_value, result);
 }

Here is the call graph for this function:

§ TEST() [45/142]

leveldb::TEST	(	MemEnvTest	,
		Misc
	)

Definition at line 146 of file memenv_test.cc.

                        {
   std::string test_dir;
   ASSERT_OK(env_->GetTestDirectory(&test_dir));
   ASSERT_TRUE(!test_dir.empty());
 
   WritableFile* writable_file;
   ASSERT_OK(env_->NewWritableFile("/a/b", &writable_file));
 
   // These are no-ops, but we test they return success.
   ASSERT_OK(writable_file->Sync());
   ASSERT_OK(writable_file->Flush());
   ASSERT_OK(writable_file->Close());
   delete writable_file;
 }

Here is the call graph for this function:

§ TEST() [46/142]

leveldb::TEST	(	FindFileTest	,
		OverlapSequenceChecks
	)

Definition at line 148 of file version_set_test.cc.

                                           {
   Add("200", "200", 5000, 3000);
   ASSERT_TRUE(! Overlaps("199", "199"));
   ASSERT_TRUE(! Overlaps("201", "300"));
   ASSERT_TRUE(Overlaps("200", "200"));
   ASSERT_TRUE(Overlaps("190", "200"));
   ASSERT_TRUE(Overlaps("200", "210"));
 }

Here is the call graph for this function:

§ TEST() [47/142]

leveldb::TEST	(	Coding	,
		Varint64Overflow
	)

Definition at line 153 of file coding_test.cc.

                                {
   uint64_t result;
   std::string input("\x81\x82\x83\x84\x85\x81\x82\x83\x84\x85\x11");
   ASSERT_TRUE(GetVarint64Ptr(input.data(), input.data() + input.size(), &result)
               == NULL);
 }

Here is the call graph for this function:

§ TEST() [48/142]

leveldb::TEST	(	FindFileTest	,
		OverlappingFiles
	)

Definition at line 157 of file version_set_test.cc.

                                      {
   Add("150", "600");
   Add("400", "500");
   disjoint_sorted_files_ = false;
   ASSERT_TRUE(! Overlaps("100", "149"));
   ASSERT_TRUE(! Overlaps("601", "700"));
   ASSERT_TRUE(Overlaps("100", "150"));
   ASSERT_TRUE(Overlaps("100", "200"));
   ASSERT_TRUE(Overlaps("100", "300"));
   ASSERT_TRUE(Overlaps("100", "400"));
   ASSERT_TRUE(Overlaps("100", "500"));
   ASSERT_TRUE(Overlaps("375", "400"));
   ASSERT_TRUE(Overlaps("450", "450"));
   ASSERT_TRUE(Overlaps("450", "500"));
   ASSERT_TRUE(Overlaps("450", "700"));
   ASSERT_TRUE(Overlaps("600", "700"));
 }

Here is the call graph for this function:

§ TEST() [49/142]

leveldb::TEST	(	CacheTest	,
		UseExceedsCacheSize
	)

Definition at line 159 of file cache_test.cc.

                                      {
   // Overfill the cache, keeping handles on all inserted entries.
   std::vector<Cache::Handle*> h;
   for (int i = 0; i < kCacheSize + 100; i++) {
     h.push_back(InsertAndReturnHandle(1000+i, 2000+i));
   }
 
   // Check that all the entries can be found in the cache.
   for (int i = 0; i < h.size(); i++) {
     ASSERT_EQ(2000+i, Lookup(1000+i));
   }
 
   for (int i = 0; i < h.size(); i++) {
     cache_->Release(h[i]);
   }
 }

Here is the call graph for this function:

§ TEST() [50/142]

leveldb::TEST	(	RecoveryTest	,
		ManifestReused
	)

Definition at line 159 of file recovery_test.cc.

                                    {
   if (!CanAppend()) {
     fprintf(stderr, "skipping test because env does not support appending\n");
     return;
   }
   ASSERT_OK(Put("foo", "bar"));
   Close();
   std::string old_manifest = ManifestFileName();
   Open();
   ASSERT_EQ(old_manifest, ManifestFileName());
   ASSERT_EQ("bar", Get("foo"));
   Open();
   ASSERT_EQ(old_manifest, ManifestFileName());
   ASSERT_EQ("bar", Get("foo"));
 }

Here is the call graph for this function:

§ TEST() [51/142]

leveldb::TEST	(	Coding	,
		Varint64Truncation
	)

Definition at line 160 of file coding_test.cc.

                                  {
   uint64_t large_value = (1ull << 63) + 100ull;
   std::string s;
   PutVarint64(&s, large_value);
   uint64_t result;
   for (size_t len = 0; len < s.size() - 1; len++) {
     ASSERT_TRUE(GetVarint64Ptr(s.data(), s.data() + len, &result) == NULL);
   }
   ASSERT_TRUE(GetVarint64Ptr(s.data(), s.data() + s.size(), &result) != NULL);
   ASSERT_EQ(large_value, result);
 }

Here is the call graph for this function:

§ TEST() [52/142]

leveldb::TEST	(	MemEnvTest	,
		LargeWrite
	)

Definition at line 161 of file memenv_test.cc.

                              {
   const size_t kWriteSize = 300 * 1024;
   char* scratch = new char[kWriteSize * 2];
 
   std::string write_data;
   for (size_t i = 0; i < kWriteSize; ++i) {
     write_data.append(1, static_cast<char>(i));
   }
 
   WritableFile* writable_file;
   ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file));
   ASSERT_OK(writable_file->Append("foo"));
   ASSERT_OK(writable_file->Append(write_data));
   delete writable_file;
 
   SequentialFile* seq_file;
   Slice result;
   ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file));
   ASSERT_OK(seq_file->Read(3, &result, scratch)); // Read "foo".
   ASSERT_EQ(0, result.compare("foo"));
 
   size_t read = 0;
   std::string read_data;
   while (read < kWriteSize) {
     ASSERT_OK(seq_file->Read(kWriteSize - read, &result, scratch));
     read_data.append(result.data(), result.size());
     read += result.size();
   }
   ASSERT_TRUE(write_data == read_data);
   delete seq_file;
   delete [] scratch;
 }

Here is the call graph for this function:

§ TEST() [53/142]

leveldb::TEST	(	Coding	,
		Strings
	)

Definition at line 172 of file coding_test.cc.

                       {
   std::string s;
   PutLengthPrefixedSlice(&s, Slice(""));
   PutLengthPrefixedSlice(&s, Slice("foo"));
   PutLengthPrefixedSlice(&s, Slice("bar"));
   PutLengthPrefixedSlice(&s, Slice(std::string(200, 'x')));
 
   Slice input(s);
   Slice v;
   ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));
   ASSERT_EQ("", v.ToString());
   ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));
   ASSERT_EQ("foo", v.ToString());
   ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));
   ASSERT_EQ("bar", v.ToString());
   ASSERT_TRUE(GetLengthPrefixedSlice(&input, &v));
   ASSERT_EQ(std::string(200, 'x'), v.ToString());
   ASSERT_EQ("", input.ToString());
 }

Here is the call graph for this function:

§ TEST() [54/142]

leveldb::TEST	(	RecoveryTest	,
		LargeManifestCompacted
	)

Definition at line 175 of file recovery_test.cc.

                                            {
   if (!CanAppend()) {
     fprintf(stderr, "skipping test because env does not support appending\n");
     return;
   }
   ASSERT_OK(Put("foo", "bar"));
   Close();
   std::string old_manifest = ManifestFileName();
 
   // Pad with zeroes to make manifest file very big.
   {
     uint64_t len = FileSize(old_manifest);
     WritableFile* file;
     ASSERT_OK(env()->NewAppendableFile(old_manifest, &file));
     std::string zeroes(3*1048576 - static_cast<size_t>(len), 0);
     ASSERT_OK(file->Append(zeroes));
     ASSERT_OK(file->Flush());
     delete file;
   }
 
   Open();
   std::string new_manifest = ManifestFileName();
   ASSERT_NE(old_manifest, new_manifest);
   ASSERT_GT(10000, FileSize(new_manifest));
   ASSERT_EQ("bar", Get("foo"));
 
   Open();
   ASSERT_EQ(new_manifest, ManifestFileName());
   ASSERT_EQ("bar", Get("foo"));
 }

Here is the call graph for this function:

§ TEST() [55/142]

leveldb::TEST	(	CacheTest	,
		HeavyEntries
	)

Definition at line 176 of file cache_test.cc.

                               {
   // Add a bunch of light and heavy entries and then count the combined
   // size of items still in the cache, which must be approximately the
   // same as the total capacity.
   const int kLight = 1;
   const int kHeavy = 10;
   int added = 0;
   int index = 0;
   while (added < 2*kCacheSize) {
     const int weight = (index & 1) ? kLight : kHeavy;
     Insert(index, 1000+index, weight);
     added += weight;
     index++;
   }
 
   int cached_weight = 0;
   for (int i = 0; i < index; i++) {
     const int weight = (i & 1 ? kLight : kHeavy);
     int r = Lookup(i);
     if (r >= 0) {
       cached_weight += weight;
       ASSERT_EQ(1000+i, r);
     }
   }
   ASSERT_LE(cached_weight, kCacheSize + kCacheSize/10);
 }

Here is the call graph for this function:

§ TEST() [56/142]

leveldb::TEST	(	MemEnvTest	,
		DBTest
	)

Definition at line 194 of file memenv_test.cc.

                          {
   Options options;
   options.create_if_missing = true;
   options.env = env_;
   DB* db;
 
   const Slice keys[] = {Slice("aaa"), Slice("bbb"), Slice("ccc")};
   const Slice vals[] = {Slice("foo"), Slice("bar"), Slice("baz")};
 
   ASSERT_OK(DB::Open(options, "/dir/db", &db));
   for (size_t i = 0; i < 3; ++i) {
     ASSERT_OK(db->Put(WriteOptions(), keys[i], vals[i]));
   }
 
   for (size_t i = 0; i < 3; ++i) {
     std::string res;
     ASSERT_OK(db->Get(ReadOptions(), keys[i], &res));
     ASSERT_TRUE(res == vals[i]);
   }
 
   Iterator* iterator = db->NewIterator(ReadOptions());
   iterator->SeekToFirst();
   for (size_t i = 0; i < 3; ++i) {
     ASSERT_TRUE(iterator->Valid());
     ASSERT_TRUE(keys[i] == iterator->key());
     ASSERT_TRUE(vals[i] == iterator->value());
     iterator->Next();
   }
   ASSERT_TRUE(!iterator->Valid());
   delete iterator;
 
   DBImpl* dbi = reinterpret_cast<DBImpl*>(db);
   ASSERT_OK(dbi->TEST_CompactMemTable());
 
   for (size_t i = 0; i < 3; ++i) {
     std::string res;
     ASSERT_OK(db->Get(ReadOptions(), keys[i], &res));
     ASSERT_TRUE(res == vals[i]);
   }
 
   delete db;
 }

Here is the call graph for this function:

§ TEST() [57/142]

leveldb::TEST	(	CorruptionTest	,
		Recovery
	)

Definition at line 202 of file corruption_test.cc.

                                {
   Build(100);
   Check(100, 100);
   Corrupt(kLogFile, 19, 1);      // WriteBatch tag for first record
   Corrupt(kLogFile, log::kBlockSize + 1000, 1);  // Somewhere in second block
   Reopen();
 
   // The 64 records in the first two log blocks are completely lost.
   Check(36, 36);
 }

Here is the call graph for this function:

§ TEST() [58/142]

leveldb::TEST	(	CacheTest	,
		NewId
	)

Definition at line 203 of file cache_test.cc.

                        {
   uint64_t a = cache_->NewId();
   uint64_t b = cache_->NewId();
   ASSERT_NE(a, b);
 }

Here is the call graph for this function:

§ TEST() [59/142]

leveldb::TEST	(	RecoveryTest	,
		NoLogFiles
	)

Definition at line 206 of file recovery_test.cc.

                                {
   ASSERT_OK(Put("foo", "bar"));
   ASSERT_EQ(1, DeleteLogFiles());
   Open();
   ASSERT_EQ("NOT_FOUND", Get("foo"));
   Open();
   ASSERT_EQ("NOT_FOUND", Get("foo"));
 }

Here is the call graph for this function:

§ TEST() [60/142]

leveldb::TEST	(	CacheTest	,
		Prune
	)

Definition at line 209 of file cache_test.cc.

                        {
   Insert(1, 100);
   Insert(2, 200);
 
   Cache::Handle* handle = cache_->Lookup(EncodeKey(1));
   ASSERT_TRUE(handle);
   cache_->Prune();
   cache_->Release(handle);
 
   ASSERT_EQ(100, Lookup(1));
   ASSERT_EQ(-1, Lookup(2));
 }

Here is the call graph for this function:

§ TEST() [61/142]

leveldb::TEST	(	CorruptionTest	,
		RecoverWriteError
	)

Definition at line 213 of file corruption_test.cc.

                                         {
   env_.writable_file_error_ = true;
   Status s = TryReopen();
   ASSERT_TRUE(!s.ok());
 }

Here is the call graph for this function:

§ TEST() [62/142]

leveldb::TEST	(	RecoveryTest	,
		LogFileReuse
	)

Definition at line 215 of file recovery_test.cc.

                                  {
   if (!CanAppend()) {
     fprintf(stderr, "skipping test because env does not support appending\n");
     return;
   }
   for (int i = 0; i < 2; i++) {
     ASSERT_OK(Put("foo", "bar"));
     if (i == 0) {
       // Compact to ensure current log is empty
       CompactMemTable();
     }
     Close();
     ASSERT_EQ(1, NumLogs());
     uint64_t number = FirstLogFile();
     if (i == 0) {
       ASSERT_EQ(0, FileSize(LogName(number)));
     } else {
       ASSERT_LT(0, FileSize(LogName(number)));
     }
     Open();
     ASSERT_EQ(1, NumLogs());
     ASSERT_EQ(number, FirstLogFile()) << "did not reuse log file";
     ASSERT_EQ("bar", Get("foo"));
     Open();
     ASSERT_EQ(1, NumLogs());
     ASSERT_EQ(number, FirstLogFile()) << "did not reuse log file";
     ASSERT_EQ("bar", Get("foo"));
   }
 }

Here is the call graph for this function:

§ TEST() [63/142]

leveldb::TEST	(	CorruptionTest	,
		NewFileErrorDuringWrite
	)

Definition at line 219 of file corruption_test.cc.

                                               {
   // Do enough writing to force minor compaction
   env_.writable_file_error_ = true;
   const int num = 3 + (Options().write_buffer_size / kValueSize);
   std::string value_storage;
   Status s;
   for (int i = 0; s.ok() && i < num; i++) {
     WriteBatch batch;
     batch.Put("a", Value(100, &value_storage));
     s = db_->Write(WriteOptions(), &batch);
   }
   ASSERT_TRUE(!s.ok());
   ASSERT_GE(env_.num_writable_file_errors_, 1);
   env_.writable_file_error_ = false;
   Reopen();
 }

Here is the call graph for this function:

§ TEST() [64/142]

leveldb::TEST	(	CorruptionTest	,
		TableFile
	)

Definition at line 236 of file corruption_test.cc.

                                 {
   Build(100);
   DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
   dbi->TEST_CompactMemTable();
   dbi->TEST_CompactRange(0, NULL, NULL);
   dbi->TEST_CompactRange(1, NULL, NULL);
 
   Corrupt(kTableFile, 100, 1);
   Check(90, 99);
 }

Here is the call graph for this function:

§ TEST() [65/142]

leveldb::TEST	(	RecoveryTest	,
		MultipleMemTables
	)

Definition at line 245 of file recovery_test.cc.

                                       {
   // Make a large log.
   const int kNum = 1000;
   for (int i = 0; i < kNum; i++) {
     char buf[100];
     snprintf(buf, sizeof(buf), "%050d", i);
     ASSERT_OK(Put(buf, buf));
   }
   ASSERT_EQ(0, NumTables());
   Close();
   ASSERT_EQ(0, NumTables());
   ASSERT_EQ(1, NumLogs());
   uint64_t old_log_file = FirstLogFile();
 
   // Force creation of multiple memtables by reducing the write buffer size.
   Options opt;
   opt.reuse_logs = true;
   opt.write_buffer_size = (kNum*100) / 2;
   Open(&opt);
   ASSERT_LE(2, NumTables());
   ASSERT_EQ(1, NumLogs());
   ASSERT_NE(old_log_file, FirstLogFile()) << "must not reuse log";
   for (int i = 0; i < kNum; i++) {
     char buf[100];
     snprintf(buf, sizeof(buf), "%050d", i);
     ASSERT_EQ(buf, Get(buf));
   }
 }

Here is the call graph for this function:

§ TEST() [66/142]

leveldb::TEST	(	CorruptionTest	,
		TableFileRepair
	)

Definition at line 247 of file corruption_test.cc.

                                       {
   options_.block_size = 2 * kValueSize;  // Limit scope of corruption
   options_.paranoid_checks = true;
   Reopen();
   Build(100);
   DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
   dbi->TEST_CompactMemTable();
   dbi->TEST_CompactRange(0, NULL, NULL);
   dbi->TEST_CompactRange(1, NULL, NULL);
 
   Corrupt(kTableFile, 100, 1);
   RepairDB();
   Reopen();
   Check(95, 99);
 }

Here is the call graph for this function:

§ TEST() [67/142]

leveldb::TEST	(	CorruptionTest	,
		TableFileIndexData
	)

Definition at line 263 of file corruption_test.cc.

                                          {
   Build(10000);  // Enough to build multiple Tables
   DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
   dbi->TEST_CompactMemTable();
 
   Corrupt(kTableFile, -2000, 500);
   Reopen();
   Check(5000, 9999);
 }

Here is the call graph for this function:

§ TEST() [68/142]

leveldb::TEST	(	CorruptionTest	,
		MissingDescriptor
	)

Definition at line 273 of file corruption_test.cc.

                                         {
   Build(1000);
   RepairDB();
   Reopen();
   Check(1000, 1000);
 }

Here is the call graph for this function:

§ TEST() [69/142]

leveldb::TEST	(	RecoveryTest	,
		MultipleLogFiles
	)

Definition at line 274 of file recovery_test.cc.

                                      {
   ASSERT_OK(Put("foo", "bar"));
   Close();
   ASSERT_EQ(1, NumLogs());
 
   // Make a bunch of uncompacted log files.
   uint64_t old_log = FirstLogFile();
   MakeLogFile(old_log+1, 1000, "hello", "world");
   MakeLogFile(old_log+2, 1001, "hi", "there");
   MakeLogFile(old_log+3, 1002, "foo", "bar2");
 
   // Recover and check that all log files were processed.
   Open();
   ASSERT_LE(1, NumTables());
   ASSERT_EQ(1, NumLogs());
   uint64_t new_log = FirstLogFile();
   ASSERT_LE(old_log+3, new_log);
   ASSERT_EQ("bar2", Get("foo"));
   ASSERT_EQ("world", Get("hello"));
   ASSERT_EQ("there", Get("hi"));
 
   // Test that previous recovery produced recoverable state.
   Open();
   ASSERT_LE(1, NumTables());
   ASSERT_EQ(1, NumLogs());
   if (CanAppend()) {
     ASSERT_EQ(new_log, FirstLogFile());
   }
   ASSERT_EQ("bar2", Get("foo"));
   ASSERT_EQ("world", Get("hello"));
   ASSERT_EQ("there", Get("hi"));
 
   // Check that introducing an older log file does not cause it to be re-read.
   Close();
   MakeLogFile(old_log+1, 2000, "hello", "stale write");
   Open();
   ASSERT_LE(1, NumTables());
   ASSERT_EQ(1, NumLogs());
   if (CanAppend()) {
     ASSERT_EQ(new_log, FirstLogFile());
   }
   ASSERT_EQ("bar2", Get("foo"));
   ASSERT_EQ("world", Get("hello"));
   ASSERT_EQ("there", Get("hi"));
 }

Here is the call graph for this function:

§ TEST() [70/142]

leveldb::TEST	(	CorruptionTest	,
		SequenceNumberRecovery
	)

Definition at line 280 of file corruption_test.cc.

                                              {
   ASSERT_OK(db_->Put(WriteOptions(), "foo", "v1"));
   ASSERT_OK(db_->Put(WriteOptions(), "foo", "v2"));
   ASSERT_OK(db_->Put(WriteOptions(), "foo", "v3"));
   ASSERT_OK(db_->Put(WriteOptions(), "foo", "v4"));
   ASSERT_OK(db_->Put(WriteOptions(), "foo", "v5"));
   RepairDB();
   Reopen();
   std::string v;
   ASSERT_OK(db_->Get(ReadOptions(), "foo", &v));
   ASSERT_EQ("v5", v);
   // Write something.  If sequence number was not recovered properly,
   // it will be hidden by an earlier write.
   ASSERT_OK(db_->Put(WriteOptions(), "foo", "v6"));
   ASSERT_OK(db_->Get(ReadOptions(), "foo", &v));
   ASSERT_EQ("v6", v);
   Reopen();
   ASSERT_OK(db_->Get(ReadOptions(), "foo", &v));
   ASSERT_EQ("v6", v);
 }

Here is the call graph for this function:

§ TEST() [71/142]

leveldb::TEST	(	SkipTest	,
		ConcurrentWithoutThreads
	)

Definition at line 288 of file skiplist_test.cc.

                                          {
   ConcurrentTest test;
   Random rnd(test::RandomSeed());
   for (int i = 0; i < 10000; i++) {
     test.ReadStep(&rnd);
     test.WriteStep(&rnd);
   }
 }

Here is the call graph for this function:

§ TEST() [72/142]

leveldb::TEST	(	CorruptionTest	,
		CorruptedDescriptor
	)

Definition at line 301 of file corruption_test.cc.

                                           {
   ASSERT_OK(db_->Put(WriteOptions(), "foo", "hello"));
   DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
   dbi->TEST_CompactMemTable();
   dbi->TEST_CompactRange(0, NULL, NULL);
 
   Corrupt(kDescriptorFile, 0, 1000);
   Status s = TryReopen();
   ASSERT_TRUE(!s.ok());
 
   RepairDB();
   Reopen();
   std::string v;
   ASSERT_OK(db_->Get(ReadOptions(), "foo", &v));
   ASSERT_EQ("hello", v);
 }

Here is the call graph for this function:

§ TEST() [73/142]

leveldb::TEST	(	CorruptionTest	,
		CompactionInputError
	)

Definition at line 318 of file corruption_test.cc.

                                            {
   Build(10);
   DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
   dbi->TEST_CompactMemTable();
   const int last = config::kMaxMemCompactLevel;
   ASSERT_EQ(1, Property("leveldb.num-files-at-level" + NumberToString(last)));
 
   Corrupt(kTableFile, 100, 1);
   Check(5, 9);
 
   // Force compactions by writing lots of values
   Build(10000);
   Check(10000, 10000);
 }

Here is the call graph for this function:

§ TEST() [74/142]

leveldb::TEST	(	CorruptionTest	,
		CompactionInputErrorParanoid
	)

Definition at line 333 of file corruption_test.cc.

                                                    {
   options_.paranoid_checks = true;
   options_.write_buffer_size = 512 << 10;
   Reopen();
   DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
 
   // Make multiple inputs so we need to compact.
   for (int i = 0; i < 2; i++) {
     Build(10);
     dbi->TEST_CompactMemTable();
     Corrupt(kTableFile, 100, 1);
     env_.SleepForMicroseconds(100000);
   }
   dbi->CompactRange(NULL, NULL);
 
   // Write must fail because of corrupted table
   std::string tmp1, tmp2;
   Status s = db_->Put(WriteOptions(), Key(5, &tmp1), Value(5, &tmp2));
   ASSERT_TRUE(!s.ok()) << "write did not fail in corrupted paranoid db";
 }

Here is the call graph for this function:

§ TEST() [75/142]

leveldb::TEST	(	CorruptionTest	,
		UnrelatedKeys
	)

Definition at line 354 of file corruption_test.cc.

                                     {
   Build(10);
   DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
   dbi->TEST_CompactMemTable();
   Corrupt(kTableFile, 100, 1);
 
   std::string tmp1, tmp2;
   ASSERT_OK(db_->Put(WriteOptions(), Key(1000, &tmp1), Value(1000, &tmp2)));
   std::string v;
   ASSERT_OK(db_->Get(ReadOptions(), Key(1000, &tmp1), &v));
   ASSERT_EQ(Value(1000, &tmp2).ToString(), v);
   dbi->TEST_CompactMemTable();
   ASSERT_OK(db_->Get(ReadOptions(), Key(1000, &tmp1), &v));
   ASSERT_EQ(Value(1000, &tmp2).ToString(), v);
 }

Here is the call graph for this function:

§ TEST() [76/142]

leveldb::TEST	(	SkipTest	,
		Concurrent1
	)

Definition at line 368 of file skiplist_test.cc.

368 { RunConcurrent(1); }

leveldb::RunConcurrent

static void RunConcurrent(int run)

Definition: skiplist_test.cc:348

Here is the call graph for this function:

§ TEST() [77/142]

leveldb::TEST	(	SkipTest	,
		Concurrent2
	)

Definition at line 369 of file skiplist_test.cc.

369 { RunConcurrent(2); }

leveldb::RunConcurrent

static void RunConcurrent(int run)

Definition: skiplist_test.cc:348

Here is the call graph for this function:

§ TEST() [78/142]

leveldb::TEST	(	SkipTest	,
		Concurrent3
	)

Definition at line 370 of file skiplist_test.cc.

370 { RunConcurrent(3); }

leveldb::RunConcurrent

static void RunConcurrent(int run)

Definition: skiplist_test.cc:348

Here is the call graph for this function:

§ TEST() [79/142]

leveldb::TEST	(	SkipTest	,
		Concurrent4
	)

Definition at line 371 of file skiplist_test.cc.

371 { RunConcurrent(4); }

leveldb::RunConcurrent

static void RunConcurrent(int run)

Definition: skiplist_test.cc:348

Here is the call graph for this function:

§ TEST() [80/142]

leveldb::TEST	(	SkipTest	,
		Concurrent5
	)

Definition at line 372 of file skiplist_test.cc.

372 { RunConcurrent(5); }

leveldb::RunConcurrent

static void RunConcurrent(int run)

Definition: skiplist_test.cc:348

Here is the call graph for this function:

§ TEST() [81/142]

leveldb::TEST	(	DBTest	,
		Empty
	)

Definition at line 511 of file db_test.cc.

                     {
   do {
     ASSERT_TRUE(db_ != NULL);
     ASSERT_EQ("NOT_FOUND", Get("foo"));
   } while (ChangeOptions());
 }

§ TEST() [82/142]

leveldb::TEST	(	DBTest	,
		ReadWrite
	)

Definition at line 518 of file db_test.cc.

                         {
   do {
     ASSERT_OK(Put("foo", "v1"));
     ASSERT_EQ("v1", Get("foo"));
     ASSERT_OK(Put("bar", "v2"));
     ASSERT_OK(Put("foo", "v3"));
     ASSERT_EQ("v3", Get("foo"));
     ASSERT_EQ("v2", Get("bar"));
   } while (ChangeOptions());
 }

§ TEST() [83/142]

leveldb::TEST	(	DBTest	,
		PutDeleteGet
	)

Definition at line 529 of file db_test.cc.

                            {
   do {
     ASSERT_OK(db_->Put(WriteOptions(), "foo", "v1"));
     ASSERT_EQ("v1", Get("foo"));
     ASSERT_OK(db_->Put(WriteOptions(), "foo", "v2"));
     ASSERT_EQ("v2", Get("foo"));
     ASSERT_OK(db_->Delete(WriteOptions(), "foo"));
     ASSERT_EQ("NOT_FOUND", Get("foo"));
   } while (ChangeOptions());
 }

§ TEST() [84/142]

leveldb::TEST	(	DBTest	,
		GetFromImmutableLayer
	)

Definition at line 540 of file db_test.cc.

                                     {
   do {
     Options options = CurrentOptions();
     options.env = env_;
     options.write_buffer_size = 100000;  // Small write buffer
     Reopen(&options);
 
     ASSERT_OK(Put("foo", "v1"));
     ASSERT_EQ("v1", Get("foo"));
 
     env_->delay_data_sync_.Release_Store(env_);      // Block sync calls
     Put("k1", std::string(100000, 'x'));             // Fill memtable
     Put("k2", std::string(100000, 'y'));             // Trigger compaction
     ASSERT_EQ("v1", Get("foo"));
     env_->delay_data_sync_.Release_Store(NULL);      // Release sync calls
   } while (ChangeOptions());
 }

§ TEST() [85/142]

leveldb::TEST	(	FaultInjectionTest	,
		FaultTestNoLogReuse
	)

Definition at line 540 of file fault_injection_test.cc.

                                               {
   ReuseLogs(false);
   DoTest();
 }

§ TEST() [86/142]

leveldb::TEST	(	FaultInjectionTest	,
		FaultTestWithLogReuse
	)

Definition at line 545 of file fault_injection_test.cc.

                                                 {
   ReuseLogs(true);
   DoTest();
 }

§ TEST() [87/142]

leveldb::TEST	(	DBTest	,
		GetFromVersions
	)

Definition at line 558 of file db_test.cc.

                               {
   do {
     ASSERT_OK(Put("foo", "v1"));
     dbfull()->TEST_CompactMemTable();
     ASSERT_EQ("v1", Get("foo"));
   } while (ChangeOptions());
 }

§ TEST() [88/142]

leveldb::TEST	(	DBTest	,
		GetMemUsage
	)

Definition at line 566 of file db_test.cc.

                           {
   do {
     ASSERT_OK(Put("foo", "v1"));
     std::string val;
     ASSERT_TRUE(db_->GetProperty("leveldb.approximate-memory-usage", &val));
     int mem_usage = atoi(val.c_str());
     ASSERT_GT(mem_usage, 0);
     ASSERT_LT(mem_usage, 5*1024*1024);
   } while (ChangeOptions());
 }

§ TEST() [89/142]

leveldb::TEST	(	DBTest	,
		GetSnapshot
	)

Definition at line 577 of file db_test.cc.

                           {
   do {
     // Try with both a short key and a long key
     for (int i = 0; i < 2; i++) {
       std::string key = (i == 0) ? std::string("foo") : std::string(200, 'x');
       ASSERT_OK(Put(key, "v1"));
       const Snapshot* s1 = db_->GetSnapshot();
       ASSERT_OK(Put(key, "v2"));
       ASSERT_EQ("v2", Get(key));
       ASSERT_EQ("v1", Get(key, s1));
       dbfull()->TEST_CompactMemTable();
       ASSERT_EQ("v2", Get(key));
       ASSERT_EQ("v1", Get(key, s1));
       db_->ReleaseSnapshot(s1);
     }
   } while (ChangeOptions());
 }

§ TEST() [90/142]

leveldb::TEST	(	DBTest	,
		GetLevel0Ordering
	)

Definition at line 595 of file db_test.cc.

                                 {
   do {
     // Check that we process level-0 files in correct order.  The code
     // below generates two level-0 files where the earlier one comes
     // before the later one in the level-0 file list since the earlier
     // one has a smaller "smallest" key.
     ASSERT_OK(Put("bar", "b"));
     ASSERT_OK(Put("foo", "v1"));
     dbfull()->TEST_CompactMemTable();
     ASSERT_OK(Put("foo", "v2"));
     dbfull()->TEST_CompactMemTable();
     ASSERT_EQ("v2", Get("foo"));
   } while (ChangeOptions());
 }

§ TEST() [91/142]

leveldb::TEST	(	DBTest	,
		GetOrderedByLevels
	)

Definition at line 610 of file db_test.cc.

                                  {
   do {
     ASSERT_OK(Put("foo", "v1"));
     Compact("a", "z");
     ASSERT_EQ("v1", Get("foo"));
     ASSERT_OK(Put("foo", "v2"));
     ASSERT_EQ("v2", Get("foo"));
     dbfull()->TEST_CompactMemTable();
     ASSERT_EQ("v2", Get("foo"));
   } while (ChangeOptions());
 }

§ TEST() [92/142]

leveldb::TEST	(	DBTest	,
		GetPicksCorrectFile
	)

Definition at line 622 of file db_test.cc.

                                   {
   do {
     // Arrange to have multiple files in a non-level-0 level.
     ASSERT_OK(Put("a", "va"));
     Compact("a", "b");
     ASSERT_OK(Put("x", "vx"));
     Compact("x", "y");
     ASSERT_OK(Put("f", "vf"));
     Compact("f", "g");
     ASSERT_EQ("va", Get("a"));
     ASSERT_EQ("vf", Get("f"));
     ASSERT_EQ("vx", Get("x"));
   } while (ChangeOptions());
 }

§ TEST() [93/142]

leveldb::TEST	(	DBTest	,
		GetEncountersEmptyLevel
	)

Definition at line 637 of file db_test.cc.

                                       {
   do {
     // Arrange for the following to happen:
     //   * sstable A in level 0
     //   * nothing in level 1
     //   * sstable B in level 2
     // Then do enough Get() calls to arrange for an automatic compaction
     // of sstable A.  A bug would cause the compaction to be marked as
     // occurring at level 1 (instead of the correct level 0).
 
     // Step 1: First place sstables in levels 0 and 2
     int compaction_count = 0;
     while (NumTableFilesAtLevel(0) == 0 ||
            NumTableFilesAtLevel(2) == 0) {
       ASSERT_LE(compaction_count, 100) << "could not fill levels 0 and 2";
       compaction_count++;
       Put("a", "begin");
       Put("z", "end");
       dbfull()->TEST_CompactMemTable();
     }
 
     // Step 2: clear level 1 if necessary.
     dbfull()->TEST_CompactRange(1, NULL, NULL);
     ASSERT_EQ(NumTableFilesAtLevel(0), 1);
     ASSERT_EQ(NumTableFilesAtLevel(1), 0);
     ASSERT_EQ(NumTableFilesAtLevel(2), 1);
 
     // Step 3: read a bunch of times
     for (int i = 0; i < 1000; i++) {
       ASSERT_EQ("NOT_FOUND", Get("missing"));
     }
 
     // Step 4: Wait for compaction to finish
     DelayMilliseconds(1000);
 
     ASSERT_EQ(NumTableFilesAtLevel(0), 0);
   } while (ChangeOptions());
 }

Here is the call graph for this function:

§ TEST() [94/142]

leveldb::TEST	(	Harness	,
		Empty
	)

Definition at line 648 of file table_test.cc.

                      {
   for (int i = 0; i < kNumTestArgs; i++) {
     Init(kTestArgList[i]);
     Random rnd(test::RandomSeed() + 1);
     Test(&rnd);
   }
 }

Here is the call graph for this function:

§ TEST() [95/142]

leveldb::TEST	(	Harness	,
		ZeroRestartPointsInBlock
	)

Definition at line 659 of file table_test.cc.

                                         {
   char data[sizeof(uint32_t)];
   memset(data, 0, sizeof(data));
   BlockContents contents;
   contents.data = Slice(data, sizeof(data));
   contents.cachable = false;
   contents.heap_allocated = false;
   Block block(contents);
   Iterator* iter = block.NewIterator(BytewiseComparator());
   iter->SeekToFirst();
   ASSERT_TRUE(!iter->Valid());
   iter->SeekToLast();
   ASSERT_TRUE(!iter->Valid());
   iter->Seek("foo");
   ASSERT_TRUE(!iter->Valid());
   delete iter;
 }

Here is the call graph for this function:

§ TEST() [96/142]

leveldb::TEST	(	DBTest	,
		IterEmpty
	)

Definition at line 676 of file db_test.cc.

                         {
   Iterator* iter = db_->NewIterator(ReadOptions());
 
   iter->SeekToFirst();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   iter->SeekToLast();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   iter->Seek("foo");
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   delete iter;
 }

Here is the call graph for this function:

§ TEST() [97/142]

leveldb::TEST	(	Harness	,
		SimpleEmptyKey
	)

Definition at line 678 of file table_test.cc.

                               {
   for (int i = 0; i < kNumTestArgs; i++) {
     Init(kTestArgList[i]);
     Random rnd(test::RandomSeed() + 1);
     Add("", "v");
     Test(&rnd);
   }
 }

Here is the call graph for this function:

§ TEST() [98/142]

leveldb::TEST	(	Harness	,
		SimpleSingle
	)

Definition at line 687 of file table_test.cc.

                             {
   for (int i = 0; i < kNumTestArgs; i++) {
     Init(kTestArgList[i]);
     Random rnd(test::RandomSeed() + 2);
     Add("abc", "v");
     Test(&rnd);
   }
 }

Here is the call graph for this function:

§ TEST() [99/142]

leveldb::TEST	(	DBTest	,
		IterSingle
	)

Definition at line 691 of file db_test.cc.

                          {
   ASSERT_OK(Put("a", "va"));
   Iterator* iter = db_->NewIterator(ReadOptions());
 
   iter->SeekToFirst();
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
   iter->SeekToFirst();
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   iter->SeekToLast();
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
   iter->SeekToLast();
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   iter->Seek("");
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   iter->Seek("a");
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   iter->Seek("b");
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   delete iter;
 }

Here is the call graph for this function:

§ TEST() [100/142]

leveldb::TEST	(	Harness	,
		SimpleMulti
	)

Definition at line 696 of file table_test.cc.

                            {
   for (int i = 0; i < kNumTestArgs; i++) {
     Init(kTestArgList[i]);
     Random rnd(test::RandomSeed() + 3);
     Add("abc", "v");
     Add("abcd", "v");
     Add("ac", "v2");
     Test(&rnd);
   }
 }

Here is the call graph for this function:

§ TEST() [101/142]

leveldb::TEST	(	Harness	,
		SimpleSpecialKey
	)

Definition at line 707 of file table_test.cc.

                                 {
   for (int i = 0; i < kNumTestArgs; i++) {
     Init(kTestArgList[i]);
     Random rnd(test::RandomSeed() + 4);
     Add("\xff\xff", "v3");
     Test(&rnd);
   }
 }

Here is the call graph for this function:

§ TEST() [102/142]

leveldb::TEST	(	Harness	,
		Randomized
	)

Definition at line 716 of file table_test.cc.

                           {
   for (int i = 0; i < kNumTestArgs; i++) {
     Init(kTestArgList[i]);
     Random rnd(test::RandomSeed() + 5);
     for (int num_entries = 0; num_entries < 2000;
          num_entries += (num_entries < 50 ? 1 : 200)) {
       if ((num_entries % 10) == 0) {
         fprintf(stderr, "case %d of %d: num_entries = %d\n",
                 (i + 1), int(kNumTestArgs), num_entries);
       }
       for (int e = 0; e < num_entries; e++) {
         std::string v;
         Add(test::RandomKey(&rnd, rnd.Skewed(4)),
             test::RandomString(&rnd, rnd.Skewed(5), &v).ToString());
       }
       Test(&rnd);
     }
   }
 }

Here is the call graph for this function:

§ TEST() [103/142]

leveldb::TEST	(	DBTest	,
		IterMulti
	)

Definition at line 729 of file db_test.cc.

                         {
   ASSERT_OK(Put("a", "va"));
   ASSERT_OK(Put("b", "vb"));
   ASSERT_OK(Put("c", "vc"));
   Iterator* iter = db_->NewIterator(ReadOptions());
 
   iter->SeekToFirst();
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "b->vb");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "c->vc");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
   iter->SeekToFirst();
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   iter->SeekToLast();
   ASSERT_EQ(IterStatus(iter), "c->vc");
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "b->vb");
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
   iter->SeekToLast();
   ASSERT_EQ(IterStatus(iter), "c->vc");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   iter->Seek("");
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Seek("a");
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Seek("ax");
   ASSERT_EQ(IterStatus(iter), "b->vb");
   iter->Seek("b");
   ASSERT_EQ(IterStatus(iter), "b->vb");
   iter->Seek("z");
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   // Switch from reverse to forward
   iter->SeekToLast();
   iter->Prev();
   iter->Prev();
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "b->vb");
 
   // Switch from forward to reverse
   iter->SeekToFirst();
   iter->Next();
   iter->Next();
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "b->vb");
 
   // Make sure iter stays at snapshot
   ASSERT_OK(Put("a",  "va2"));
   ASSERT_OK(Put("a2", "va3"));
   ASSERT_OK(Put("b",  "vb2"));
   ASSERT_OK(Put("c",  "vc2"));
   ASSERT_OK(Delete("b"));
   iter->SeekToFirst();
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "b->vb");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "c->vc");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
   iter->SeekToLast();
   ASSERT_EQ(IterStatus(iter), "c->vc");
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "b->vb");
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   delete iter;
 }

Here is the call graph for this function:

§ TEST() [104/142]

leveldb::TEST	(	Harness	,
		RandomizedLongDB
	)

Definition at line 736 of file table_test.cc.

                                 {
   Random rnd(test::RandomSeed());
   TestArgs args = { DB_TEST, false, 16 };
   Init(args);
   int num_entries = 100000;
   for (int e = 0; e < num_entries; e++) {
     std::string v;
     Add(test::RandomKey(&rnd, rnd.Skewed(4)),
         test::RandomString(&rnd, rnd.Skewed(5), &v).ToString());
   }
   Test(&rnd);
 
   // We must have created enough data to force merging
   int files = 0;
   for (int level = 0; level < config::kNumLevels; level++) {
     std::string value;
     char name[100];
     snprintf(name, sizeof(name), "leveldb.num-files-at-level%d", level);
     ASSERT_TRUE(db()->GetProperty(name, &value));
     files += atoi(value.c_str());
   }
   ASSERT_GT(files, 0);
 }

Here is the call graph for this function:

§ TEST() [105/142]

leveldb::TEST	(	MemTableTest	,
		Simple
	)

Definition at line 762 of file table_test.cc.

                            {
   InternalKeyComparator cmp(BytewiseComparator());
   MemTable* memtable = new MemTable(cmp);
   memtable->Ref();
   WriteBatch batch;
   WriteBatchInternal::SetSequence(&batch, 100);
   batch.Put(std::string("k1"), std::string("v1"));
   batch.Put(std::string("k2"), std::string("v2"));
   batch.Put(std::string("k3"), std::string("v3"));
   batch.Put(std::string("largekey"), std::string("vlarge"));
   ASSERT_TRUE(WriteBatchInternal::InsertInto(&batch, memtable).ok());
 
   Iterator* iter = memtable->NewIterator();
   iter->SeekToFirst();
   while (iter->Valid()) {
     fprintf(stderr, "key: '%s' -> '%s'\n",
             iter->key().ToString().c_str(),
             iter->value().ToString().c_str());
     iter->Next();
   }
 
   delete iter;
   memtable->Unref();
 }

Here is the call graph for this function:

§ TEST() [106/142]

leveldb::TEST	(	TableTest	,
		ApproximateOffsetOfPlain
	)

Definition at line 800 of file table_test.cc.

                                           {
   TableConstructor c(BytewiseComparator());
   c.Add("k01", "hello");
   c.Add("k02", "hello2");
   c.Add("k03", std::string(10000, 'x'));
   c.Add("k04", std::string(200000, 'x'));
   c.Add("k05", std::string(300000, 'x'));
   c.Add("k06", "hello3");
   c.Add("k07", std::string(100000, 'x'));
   std::vector<std::string> keys;
   KVMap kvmap;
   Options options;
   options.block_size = 1024;
   options.compression = kNoCompression;
   c.Finish(options, &keys, &kvmap);
 
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("abc"),       0,      0));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k01"),       0,      0));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k01a"),      0,      0));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k02"),       0,      0));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k03"),       0,      0));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k04"),   10000,  11000));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k04a"), 210000, 211000));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k05"),  210000, 211000));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k06"),  510000, 511000));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k07"),  510000, 511000));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("xyz"),  610000, 612000));
 
 }

Here is the call graph for this function:

§ TEST() [107/142]

leveldb::TEST	(	DBTest	,
		IterSmallAndLargeMix
	)

Definition at line 812 of file db_test.cc.

                                    {
   ASSERT_OK(Put("a", "va"));
   ASSERT_OK(Put("b", std::string(100000, 'b')));
   ASSERT_OK(Put("c", "vc"));
   ASSERT_OK(Put("d", std::string(100000, 'd')));
   ASSERT_OK(Put("e", std::string(100000, 'e')));
 
   Iterator* iter = db_->NewIterator(ReadOptions());
 
   iter->SeekToFirst();
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "b->" + std::string(100000, 'b'));
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "c->vc");
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "d->" + std::string(100000, 'd'));
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "e->" + std::string(100000, 'e'));
   iter->Next();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   iter->SeekToLast();
   ASSERT_EQ(IterStatus(iter), "e->" + std::string(100000, 'e'));
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "d->" + std::string(100000, 'd'));
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "c->vc");
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "b->" + std::string(100000, 'b'));
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "a->va");
   iter->Prev();
   ASSERT_EQ(IterStatus(iter), "(invalid)");
 
   delete iter;
 }

Here is the call graph for this function:

§ TEST() [108/142]

leveldb::TEST	(	TableTest	,
		ApproximateOffsetOfCompressed
	)

Definition at line 836 of file table_test.cc.

                                                {
   if (!SnappyCompressionSupported()) {
     fprintf(stderr, "skipping compression tests\n");
     return;
   }
 
   Random rnd(301);
   TableConstructor c(BytewiseComparator());
   std::string tmp;
   c.Add("k01", "hello");
   c.Add("k02", test::CompressibleString(&rnd, 0.25, 10000, &tmp));
   c.Add("k03", "hello3");
   c.Add("k04", test::CompressibleString(&rnd, 0.25, 10000, &tmp));
   std::vector<std::string> keys;
   KVMap kvmap;
   Options options;
   options.block_size = 1024;
   options.compression = kSnappyCompression;
   c.Finish(options, &keys, &kvmap);
 
   // Expected upper and lower bounds of space used by compressible strings.
   static const int kSlop = 1000;  // Compressor effectiveness varies.
   const int expected = 2500;  // 10000 * compression ratio (0.25)
   const int min_z = expected - kSlop;
   const int max_z = expected + kSlop;
 
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("abc"), 0, kSlop));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k01"), 0, kSlop));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k02"), 0, kSlop));
   // Have now emitted a large compressible string, so adjust expected offset.
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k03"), min_z, max_z));
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("k04"), min_z, max_z));
   // Have now emitted two large compressible strings, so adjust expected offset.
   ASSERT_TRUE(Between(c.ApproximateOffsetOf("xyz"), 2 * min_z, 2 * max_z));
 }

Here is the call graph for this function:

§ TEST() [109/142]

leveldb::TEST	(	DBTest	,
		IterMultiWithDelete
	)

Definition at line 850 of file db_test.cc.

                                   {
   do {
     ASSERT_OK(Put("a", "va"));
     ASSERT_OK(Put("b", "vb"));
     ASSERT_OK(Put("c", "vc"));
     ASSERT_OK(Delete("b"));
     ASSERT_EQ("NOT_FOUND", Get("b"));
 
     Iterator* iter = db_->NewIterator(ReadOptions());
     iter->Seek("c");
     ASSERT_EQ(IterStatus(iter), "c->vc");
     iter->Prev();
     ASSERT_EQ(IterStatus(iter), "a->va");
     delete iter;
   } while (ChangeOptions());
 }

Here is the call graph for this function:

§ TEST() [110/142]

leveldb::TEST	(	DBTest	,
		Recover
	)

Definition at line 867 of file db_test.cc.

                       {
   do {
     ASSERT_OK(Put("foo", "v1"));
     ASSERT_OK(Put("baz", "v5"));
 
     Reopen();
     ASSERT_EQ("v1", Get("foo"));
 
     ASSERT_EQ("v1", Get("foo"));
     ASSERT_EQ("v5", Get("baz"));
     ASSERT_OK(Put("bar", "v2"));
     ASSERT_OK(Put("foo", "v3"));
 
     Reopen();
     ASSERT_EQ("v3", Get("foo"));
     ASSERT_OK(Put("foo", "v4"));
     ASSERT_EQ("v4", Get("foo"));
     ASSERT_EQ("v2", Get("bar"));
     ASSERT_EQ("v5", Get("baz"));
   } while (ChangeOptions());
 }

§ TEST() [111/142]

leveldb::TEST	(	DBTest	,
		RecoveryWithEmptyLog
	)

Definition at line 889 of file db_test.cc.

                                    {
   do {
     ASSERT_OK(Put("foo", "v1"));
     ASSERT_OK(Put("foo", "v2"));
     Reopen();
     Reopen();
     ASSERT_OK(Put("foo", "v3"));
     Reopen();
     ASSERT_EQ("v3", Get("foo"));
   } while (ChangeOptions());
 }

§ TEST() [112/142]

leveldb::TEST	(	DBTest	,
		RecoverDuringMemtableCompaction
	)

Definition at line 903 of file db_test.cc.

                                               {
   do {
     Options options = CurrentOptions();
     options.env = env_;
     options.write_buffer_size = 1000000;
     Reopen(&options);
 
     // Trigger a long memtable compaction and reopen the database during it
     ASSERT_OK(Put("foo", "v1"));                         // Goes to 1st log file
     ASSERT_OK(Put("big1", std::string(10000000, 'x')));  // Fills memtable
     ASSERT_OK(Put("big2", std::string(1000, 'y')));      // Triggers compaction
     ASSERT_OK(Put("bar", "v2"));                         // Goes to new log file
 
     Reopen(&options);
     ASSERT_EQ("v1", Get("foo"));
     ASSERT_EQ("v2", Get("bar"));
     ASSERT_EQ(std::string(10000000, 'x'), Get("big1"));
     ASSERT_EQ(std::string(1000, 'y'), Get("big2"));
   } while (ChangeOptions());
 }

§ TEST() [113/142]

leveldb::TEST	(	DBTest	,
		MinorCompactionsHappen
	)

Definition at line 930 of file db_test.cc.

                                      {
   Options options = CurrentOptions();
   options.write_buffer_size = 10000;
   Reopen(&options);
 
   const int N = 500;
 
   int starting_num_tables = TotalTableFiles();
   for (int i = 0; i < N; i++) {
     ASSERT_OK(Put(Key(i), Key(i) + std::string(1000, 'v')));
   }
   int ending_num_tables = TotalTableFiles();
   ASSERT_GT(ending_num_tables, starting_num_tables);
 
   for (int i = 0; i < N; i++) {
     ASSERT_EQ(Key(i) + std::string(1000, 'v'), Get(Key(i)));
   }
 
   Reopen();
 
   for (int i = 0; i < N; i++) {
     ASSERT_EQ(Key(i) + std::string(1000, 'v'), Get(Key(i)));
   }
 }

§ TEST() [114/142]

leveldb::TEST	(	DBTest	,
		RecoverWithLargeLog
	)

Definition at line 955 of file db_test.cc.

                                   {
   {
     Options options = CurrentOptions();
     Reopen(&options);
     ASSERT_OK(Put("big1", std::string(200000, '1')));
     ASSERT_OK(Put("big2", std::string(200000, '2')));
     ASSERT_OK(Put("small3", std::string(10, '3')));
     ASSERT_OK(Put("small4", std::string(10, '4')));
     ASSERT_EQ(NumTableFilesAtLevel(0), 0);
   }
 
   // Make sure that if we re-open with a small write buffer size that
   // we flush table files in the middle of a large log file.
   Options options = CurrentOptions();
   options.write_buffer_size = 100000;
   Reopen(&options);
   ASSERT_EQ(NumTableFilesAtLevel(0), 3);
   ASSERT_EQ(std::string(200000, '1'), Get("big1"));
   ASSERT_EQ(std::string(200000, '2'), Get("big2"));
   ASSERT_EQ(std::string(10, '3'), Get("small3"));
   ASSERT_EQ(std::string(10, '4'), Get("small4"));
   ASSERT_GT(NumTableFilesAtLevel(0), 1);
 }

§ TEST() [115/142]

leveldb::TEST	(	DBTest	,
		CompactionsGenerateMultipleFiles
	)

Definition at line 979 of file db_test.cc.

                                                {
   Options options = CurrentOptions();
   options.write_buffer_size = 100000000;        // Large write buffer
   Reopen(&options);
 
   Random rnd(301);
 
   // Write 8MB (80 values, each 100K)
   ASSERT_EQ(NumTableFilesAtLevel(0), 0);
   std::vector<std::string> values;
   for (int i = 0; i < 80; i++) {
     values.push_back(RandomString(&rnd, 100000));
     ASSERT_OK(Put(Key(i), values[i]));
   }
 
   // Reopening moves updates to level-0
   Reopen(&options);
   dbfull()->TEST_CompactRange(0, NULL, NULL);
 
   ASSERT_EQ(NumTableFilesAtLevel(0), 0);
   ASSERT_GT(NumTableFilesAtLevel(1), 1);
   for (int i = 0; i < 80; i++) {
     ASSERT_EQ(Get(Key(i)), values[i]);
   }
 }

Here is the call graph for this function:

§ TEST() [116/142]

leveldb::TEST	(	DBTest	,
		RepeatedWritesToSameKey
	)

Definition at line 1005 of file db_test.cc.

                                       {
   Options options = CurrentOptions();
   options.env = env_;
   options.write_buffer_size = 100000;  // Small write buffer
   Reopen(&options);
 
   // We must have at most one file per level except for level-0,
   // which may have up to kL0_StopWritesTrigger files.
   const int kMaxFiles = config::kNumLevels + config::kL0_StopWritesTrigger;
 
   Random rnd(301);
   std::string value = RandomString(&rnd, 2 * options.write_buffer_size);
   for (int i = 0; i < 5 * kMaxFiles; i++) {
     Put("key", value);
     ASSERT_LE(TotalTableFiles(), kMaxFiles);
     fprintf(stderr, "after %d: %d files\n", int(i+1), TotalTableFiles());
   }
 }

Here is the call graph for this function:

§ TEST() [117/142]

leveldb::TEST	(	DBTest	,
		SparseMerge
	)

Definition at line 1024 of file db_test.cc.

                           {
   Options options = CurrentOptions();
   options.compression = kNoCompression;
   Reopen(&options);
 
   FillLevels("A", "Z");
 
   // Suppose there is:
   //    small amount of data with prefix A
   //    large amount of data with prefix B
   //    small amount of data with prefix C
   // and that recent updates have made small changes to all three prefixes.
   // Check that we do not do a compaction that merges all of B in one shot.
   const std::string value(1000, 'x');
   Put("A", "va");
   // Write approximately 100MB of "B" values
   for (int i = 0; i < 100000; i++) {
     char key[100];
     snprintf(key, sizeof(key), "B%010d", i);
     Put(key, value);
   }
   Put("C", "vc");
   dbfull()->TEST_CompactMemTable();
   dbfull()->TEST_CompactRange(0, NULL, NULL);
 
   // Make sparse update
   Put("A",    "va2");
   Put("B100", "bvalue2");
   Put("C",    "vc2");
   dbfull()->TEST_CompactMemTable();
 
   // Compactions should not cause us to create a situation where
   // a file overlaps too much data at the next level.
   ASSERT_LE(dbfull()->TEST_MaxNextLevelOverlappingBytes(), 20*1048576);
   dbfull()->TEST_CompactRange(0, NULL, NULL);
   ASSERT_LE(dbfull()->TEST_MaxNextLevelOverlappingBytes(), 20*1048576);
   dbfull()->TEST_CompactRange(1, NULL, NULL);
   ASSERT_LE(dbfull()->TEST_MaxNextLevelOverlappingBytes(), 20*1048576);
 }

§ TEST() [118/142]

leveldb::TEST	(	DBTest	,
		ApproximateSizes
	)

Definition at line 1075 of file db_test.cc.

                                {
   do {
     Options options = CurrentOptions();
     options.write_buffer_size = 100000000;        // Large write buffer
     options.compression = kNoCompression;
     DestroyAndReopen();
 
     ASSERT_TRUE(Between(Size("", "xyz"), 0, 0));
     Reopen(&options);
     ASSERT_TRUE(Between(Size("", "xyz"), 0, 0));
 
     // Write 8MB (80 values, each 100K)
     ASSERT_EQ(NumTableFilesAtLevel(0), 0);
     const int N = 80;
     static const int S1 = 100000;
     static const int S2 = 105000;  // Allow some expansion from metadata
     Random rnd(301);
     for (int i = 0; i < N; i++) {
       ASSERT_OK(Put(Key(i), RandomString(&rnd, S1)));
     }
 
     // 0 because GetApproximateSizes() does not account for memtable space
     ASSERT_TRUE(Between(Size("", Key(50)), 0, 0));
 
     if (options.reuse_logs) {
       // Recovery will reuse memtable, and GetApproximateSizes() does not
       // account for memtable usage;
       Reopen(&options);
       ASSERT_TRUE(Between(Size("", Key(50)), 0, 0));
       continue;
     }
 
     // Check sizes across recovery by reopening a few times
     for (int run = 0; run < 3; run++) {
       Reopen(&options);
 
       for (int compact_start = 0; compact_start < N; compact_start += 10) {
         for (int i = 0; i < N; i += 10) {
           ASSERT_TRUE(Between(Size("", Key(i)), S1*i, S2*i));
           ASSERT_TRUE(Between(Size("", Key(i)+".suffix"), S1*(i+1), S2*(i+1)));
           ASSERT_TRUE(Between(Size(Key(i), Key(i+10)), S1*10, S2*10));
         }
         ASSERT_TRUE(Between(Size("", Key(50)), S1*50, S2*50));
         ASSERT_TRUE(Between(Size("", Key(50)+".suffix"), S1*50, S2*50));
 
         std::string cstart_str = Key(compact_start);
         std::string cend_str = Key(compact_start + 9);
         Slice cstart = cstart_str;
         Slice cend = cend_str;
         dbfull()->TEST_CompactRange(0, &cstart, &cend);
       }
 
       ASSERT_EQ(NumTableFilesAtLevel(0), 0);
       ASSERT_GT(NumTableFilesAtLevel(1), 0);
     }
   } while (ChangeOptions());
 }

Here is the call graph for this function:

§ TEST() [119/142]

leveldb::TEST	(	DBTest	,
		ApproximateSizes_MixOfSmallAndLarge
	)

Definition at line 1133 of file db_test.cc.

                                                   {
   do {
     Options options = CurrentOptions();
     options.compression = kNoCompression;
     Reopen();
 
     Random rnd(301);
     std::string big1 = RandomString(&rnd, 100000);
     ASSERT_OK(Put(Key(0), RandomString(&rnd, 10000)));
     ASSERT_OK(Put(Key(1), RandomString(&rnd, 10000)));
     ASSERT_OK(Put(Key(2), big1));
     ASSERT_OK(Put(Key(3), RandomString(&rnd, 10000)));
     ASSERT_OK(Put(Key(4), big1));
     ASSERT_OK(Put(Key(5), RandomString(&rnd, 10000)));
     ASSERT_OK(Put(Key(6), RandomString(&rnd, 300000)));
     ASSERT_OK(Put(Key(7), RandomString(&rnd, 10000)));
 
     if (options.reuse_logs) {
       // Need to force a memtable compaction since recovery does not do so.
       ASSERT_OK(dbfull()->TEST_CompactMemTable());
     }
 
     // Check sizes across recovery by reopening a few times
     for (int run = 0; run < 3; run++) {
       Reopen(&options);
 
       ASSERT_TRUE(Between(Size("", Key(0)), 0, 0));
       ASSERT_TRUE(Between(Size("", Key(1)), 10000, 11000));
       ASSERT_TRUE(Between(Size("", Key(2)), 20000, 21000));
       ASSERT_TRUE(Between(Size("", Key(3)), 120000, 121000));
       ASSERT_TRUE(Between(Size("", Key(4)), 130000, 131000));
       ASSERT_TRUE(Between(Size("", Key(5)), 230000, 231000));
       ASSERT_TRUE(Between(Size("", Key(6)), 240000, 241000));
       ASSERT_TRUE(Between(Size("", Key(7)), 540000, 541000));
       ASSERT_TRUE(Between(Size("", Key(8)), 550000, 560000));
 
       ASSERT_TRUE(Between(Size(Key(3), Key(5)), 110000, 111000));
 
       dbfull()->TEST_CompactRange(0, NULL, NULL);
     }
   } while (ChangeOptions());
 }

Here is the call graph for this function:

§ TEST() [120/142]

leveldb::TEST	(	DBTest	,
		IteratorPinsRef
	)

Definition at line 1176 of file db_test.cc.

                               {
   Put("foo", "hello");
 
   // Get iterator that will yield the current contents of the DB.
   Iterator* iter = db_->NewIterator(ReadOptions());
 
   // Write to force compactions
   Put("foo", "newvalue1");
   for (int i = 0; i < 100; i++) {
     ASSERT_OK(Put(Key(i), Key(i) + std::string(100000, 'v'))); // 100K values
   }
   Put("foo", "newvalue2");
 
   iter->SeekToFirst();
   ASSERT_TRUE(iter->Valid());
   ASSERT_EQ("foo", iter->key().ToString());
   ASSERT_EQ("hello", iter->value().ToString());
   iter->Next();
   ASSERT_TRUE(!iter->Valid());
   delete iter;
 }

Here is the call graph for this function:

§ TEST() [121/142]

leveldb::TEST	(	DBTest	,
		Snapshot
	)

Definition at line 1198 of file db_test.cc.

                        {
   do {
     Put("foo", "v1");
     const Snapshot* s1 = db_->GetSnapshot();
     Put("foo", "v2");
     const Snapshot* s2 = db_->GetSnapshot();
     Put("foo", "v3");
     const Snapshot* s3 = db_->GetSnapshot();
 
     Put("foo", "v4");
     ASSERT_EQ("v1", Get("foo", s1));
     ASSERT_EQ("v2", Get("foo", s2));
     ASSERT_EQ("v3", Get("foo", s3));
     ASSERT_EQ("v4", Get("foo"));
 
     db_->ReleaseSnapshot(s3);
     ASSERT_EQ("v1", Get("foo", s1));
     ASSERT_EQ("v2", Get("foo", s2));
     ASSERT_EQ("v4", Get("foo"));
 
     db_->ReleaseSnapshot(s1);
     ASSERT_EQ("v2", Get("foo", s2));
     ASSERT_EQ("v4", Get("foo"));
 
     db_->ReleaseSnapshot(s2);
     ASSERT_EQ("v4", Get("foo"));
   } while (ChangeOptions());
 }

§ TEST() [122/142]

leveldb::TEST	(	DBTest	,
		HiddenValuesAreRemoved
	)

Definition at line 1227 of file db_test.cc.

                                      {
   do {
     Random rnd(301);
     FillLevels("a", "z");
 
     std::string big = RandomString(&rnd, 50000);
     Put("foo", big);
     Put("pastfoo", "v");
     const Snapshot* snapshot = db_->GetSnapshot();
     Put("foo", "tiny");
     Put("pastfoo2", "v2");        // Advance sequence number one more
 
     ASSERT_OK(dbfull()->TEST_CompactMemTable());
     ASSERT_GT(NumTableFilesAtLevel(0), 0);
 
     ASSERT_EQ(big, Get("foo", snapshot));
     ASSERT_TRUE(Between(Size("", "pastfoo"), 50000, 60000));
     db_->ReleaseSnapshot(snapshot);
     ASSERT_EQ(AllEntriesFor("foo"), "[ tiny, " + big + " ]");
     Slice x("x");
     dbfull()->TEST_CompactRange(0, NULL, &x);
     ASSERT_EQ(AllEntriesFor("foo"), "[ tiny ]");
     ASSERT_EQ(NumTableFilesAtLevel(0), 0);
     ASSERT_GE(NumTableFilesAtLevel(1), 1);
     dbfull()->TEST_CompactRange(1, NULL, &x);
     ASSERT_EQ(AllEntriesFor("foo"), "[ tiny ]");
 
     ASSERT_TRUE(Between(Size("", "pastfoo"), 0, 1000));
   } while (ChangeOptions());
 }

Here is the call graph for this function:

§ TEST() [123/142]

leveldb::TEST	(	DBTest	,
		DeletionMarkers1
	)

Definition at line 1258 of file db_test.cc.

                                {
   Put("foo", "v1");
   ASSERT_OK(dbfull()->TEST_CompactMemTable());
   const int last = config::kMaxMemCompactLevel;
   ASSERT_EQ(NumTableFilesAtLevel(last), 1);   // foo => v1 is now in last level
 
   // Place a table at level last-1 to prevent merging with preceding mutation
   Put("a", "begin");
   Put("z", "end");
   dbfull()->TEST_CompactMemTable();
   ASSERT_EQ(NumTableFilesAtLevel(last), 1);
   ASSERT_EQ(NumTableFilesAtLevel(last-1), 1);
 
   Delete("foo");
   Put("foo", "v2");
   ASSERT_EQ(AllEntriesFor("foo"), "[ v2, DEL, v1 ]");
   ASSERT_OK(dbfull()->TEST_CompactMemTable());  // Moves to level last-2
   ASSERT_EQ(AllEntriesFor("foo"), "[ v2, DEL, v1 ]");
   Slice z("z");
   dbfull()->TEST_CompactRange(last-2, NULL, &z);
   // DEL eliminated, but v1 remains because we aren't compacting that level
   // (DEL can be eliminated because v2 hides v1).
   ASSERT_EQ(AllEntriesFor("foo"), "[ v2, v1 ]");
   dbfull()->TEST_CompactRange(last-1, NULL, NULL);
   // Merging last-1 w/ last, so we are the base level for "foo", so
   // DEL is removed.  (as is v1).
   ASSERT_EQ(AllEntriesFor("foo"), "[ v2 ]");
 }

§ TEST() [124/142]

leveldb::TEST	(	DBTest	,
		DeletionMarkers2
	)

Definition at line 1287 of file db_test.cc.

                                {
   Put("foo", "v1");
   ASSERT_OK(dbfull()->TEST_CompactMemTable());
   const int last = config::kMaxMemCompactLevel;
   ASSERT_EQ(NumTableFilesAtLevel(last), 1);   // foo => v1 is now in last level
 
   // Place a table at level last-1 to prevent merging with preceding mutation
   Put("a", "begin");
   Put("z", "end");
   dbfull()->TEST_CompactMemTable();
   ASSERT_EQ(NumTableFilesAtLevel(last), 1);
   ASSERT_EQ(NumTableFilesAtLevel(last-1), 1);
 
   Delete("foo");
   ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v1 ]");
   ASSERT_OK(dbfull()->TEST_CompactMemTable());  // Moves to level last-2
   ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v1 ]");
   dbfull()->TEST_CompactRange(last-2, NULL, NULL);
   // DEL kept: "last" file overlaps
   ASSERT_EQ(AllEntriesFor("foo"), "[ DEL, v1 ]");
   dbfull()->TEST_CompactRange(last-1, NULL, NULL);
   // Merging last-1 w/ last, so we are the base level for "foo", so
   // DEL is removed.  (as is v1).
   ASSERT_EQ(AllEntriesFor("foo"), "[ ]");
 }

§ TEST() [125/142]

leveldb::TEST	(	DBTest	,
		OverlapInLevel0
	)

Definition at line 1313 of file db_test.cc.

                               {
   do {
     ASSERT_EQ(config::kMaxMemCompactLevel, 2) << "Fix test to match config";
 
     // Fill levels 1 and 2 to disable the pushing of new memtables to levels > 0.
     ASSERT_OK(Put("100", "v100"));
     ASSERT_OK(Put("999", "v999"));
     dbfull()->TEST_CompactMemTable();
     ASSERT_OK(Delete("100"));
     ASSERT_OK(Delete("999"));
     dbfull()->TEST_CompactMemTable();
     ASSERT_EQ("0,1,1", FilesPerLevel());
 
     // Make files spanning the following ranges in level-0:
     //  files[0]  200 .. 900
     //  files[1]  300 .. 500
     // Note that files are sorted by smallest key.
     ASSERT_OK(Put("300", "v300"));
     ASSERT_OK(Put("500", "v500"));
     dbfull()->TEST_CompactMemTable();
     ASSERT_OK(Put("200", "v200"));
     ASSERT_OK(Put("600", "v600"));
     ASSERT_OK(Put("900", "v900"));
     dbfull()->TEST_CompactMemTable();
     ASSERT_EQ("2,1,1", FilesPerLevel());
 
     // Compact away the placeholder files we created initially
     dbfull()->TEST_CompactRange(1, NULL, NULL);
     dbfull()->TEST_CompactRange(2, NULL, NULL);
     ASSERT_EQ("2", FilesPerLevel());
 
     // Do a memtable compaction.  Before bug-fix, the compaction would
     // not detect the overlap with level-0 files and would incorrectly place
     // the deletion in a deeper level.
     ASSERT_OK(Delete("600"));
     dbfull()->TEST_CompactMemTable();
     ASSERT_EQ("3", FilesPerLevel());
     ASSERT_EQ("NOT_FOUND", Get("600"));
   } while (ChangeOptions());
 }

§ TEST() [126/142]

leveldb::TEST	(	DBTest	,
		L0_CompactionBug_Issue44_a
	)

Definition at line 1354 of file db_test.cc.

                                          {
   Reopen();
   ASSERT_OK(Put("b", "v"));
   Reopen();
   ASSERT_OK(Delete("b"));
   ASSERT_OK(Delete("a"));
   Reopen();
   ASSERT_OK(Delete("a"));
   Reopen();
   ASSERT_OK(Put("a", "v"));
   Reopen();
   Reopen();
   ASSERT_EQ("(a->v)", Contents());
   DelayMilliseconds(1000);  // Wait for compaction to finish
   ASSERT_EQ("(a->v)", Contents());
 }

Here is the call graph for this function:

§ TEST() [127/142]

leveldb::TEST	(	DBTest	,
		L0_CompactionBug_Issue44_b
	)

Definition at line 1371 of file db_test.cc.

                                          {
   Reopen();
   Put("","");
   Reopen();
   Delete("e");
   Put("","");
   Reopen();
   Put("c", "cv");
   Reopen();
   Put("","");
   Reopen();
   Put("","");
   DelayMilliseconds(1000);  // Wait for compaction to finish
   Reopen();
   Put("d","dv");
   Reopen();
   Put("","");
   Reopen();
   Delete("d");
   Delete("b");
   Reopen();
   ASSERT_EQ("(->)(c->cv)", Contents());
   DelayMilliseconds(1000);  // Wait for compaction to finish
   ASSERT_EQ("(->)(c->cv)", Contents());
 }

Here is the call graph for this function:

§ TEST() [128/142]

leveldb::TEST	(	DBTest	,
		ComparatorCheck
	)

Definition at line 1397 of file db_test.cc.

                               {
   class NewComparator : public Comparator {
    public:
     virtual const char* Name() const { return "leveldb.NewComparator"; }
     virtual int Compare(const Slice& a, const Slice& b) const {
       return BytewiseComparator()->Compare(a, b);
     }
     virtual void FindShortestSeparator(std::string* s, const Slice& l) const {
       BytewiseComparator()->FindShortestSeparator(s, l);
     }
     virtual void FindShortSuccessor(std::string* key) const {
       BytewiseComparator()->FindShortSuccessor(key);
     }
   };
   NewComparator cmp;
   Options new_options = CurrentOptions();
   new_options.comparator = &cmp;
   Status s = TryReopen(&new_options);
   ASSERT_TRUE(!s.ok());
   ASSERT_TRUE(s.ToString().find("comparator") != std::string::npos)
       << s.ToString();
 }

Here is the call graph for this function:

§ TEST() [129/142]

leveldb::TEST	(	DBTest	,
		CustomComparator
	)

Definition at line 1420 of file db_test.cc.

                                {
   class NumberComparator : public Comparator {
    public:
     virtual const char* Name() const { return "test.NumberComparator"; }
     virtual int Compare(const Slice& a, const Slice& b) const {
       return ToNumber(a) - ToNumber(b);
     }
     virtual void FindShortestSeparator(std::string* s, const Slice& l) const {
       ToNumber(*s);     // Check format
       ToNumber(l);      // Check format
     }
     virtual void FindShortSuccessor(std::string* key) const {
       ToNumber(*key);   // Check format
     }
    private:
     static int ToNumber(const Slice& x) {
       // Check that there are no extra characters.
       ASSERT_TRUE(x.size() >= 2 && x[0] == '[' && x[x.size()-1] == ']')
           << EscapeString(x);
       int val;
       char ignored;
       ASSERT_TRUE(sscanf(x.ToString().c_str(), "[%i]%c", &val, &ignored) == 1)
           << EscapeString(x);
       return val;
     }
   };
   NumberComparator cmp;
   Options new_options = CurrentOptions();
   new_options.create_if_missing = true;
   new_options.comparator = &cmp;
   new_options.filter_policy = NULL;     // Cannot use bloom filters
   new_options.write_buffer_size = 1000;  // Compact more often
   DestroyAndReopen(&new_options);
   ASSERT_OK(Put("[10]", "ten"));
   ASSERT_OK(Put("[0x14]", "twenty"));
   for (int i = 0; i < 2; i++) {
     ASSERT_EQ("ten", Get("[10]"));
     ASSERT_EQ("ten", Get("[0xa]"));
     ASSERT_EQ("twenty", Get("[20]"));
     ASSERT_EQ("twenty", Get("[0x14]"));
     ASSERT_EQ("NOT_FOUND", Get("[15]"));
     ASSERT_EQ("NOT_FOUND", Get("[0xf]"));
     Compact("[0]", "[9999]");
   }
 
   for (int run = 0; run < 2; run++) {
     for (int i = 0; i < 1000; i++) {
       char buf[100];
       snprintf(buf, sizeof(buf), "[%d]", i*10);
       ASSERT_OK(Put(buf, buf));
     }
     Compact("[0]", "[1000000]");
   }
 }

Here is the call graph for this function:

§ TEST() [130/142]

leveldb::TEST	(	DBTest	,
		ManualCompaction
	)

Definition at line 1475 of file db_test.cc.

                                {
   ASSERT_EQ(config::kMaxMemCompactLevel, 2)
       << "Need to update this test to match kMaxMemCompactLevel";
 
   MakeTables(3, "p", "q");
   ASSERT_EQ("1,1,1", FilesPerLevel());
 
   // Compaction range falls before files
   Compact("", "c");
   ASSERT_EQ("1,1,1", FilesPerLevel());
 
   // Compaction range falls after files
   Compact("r", "z");
   ASSERT_EQ("1,1,1", FilesPerLevel());
 
   // Compaction range overlaps files
   Compact("p1", "p9");
   ASSERT_EQ("0,0,1", FilesPerLevel());
 
   // Populate a different range
   MakeTables(3, "c", "e");
   ASSERT_EQ("1,1,2", FilesPerLevel());
 
   // Compact just the new range
   Compact("b", "f");
   ASSERT_EQ("0,0,2", FilesPerLevel());
 
   // Compact all
   MakeTables(1, "a", "z");
   ASSERT_EQ("0,1,2", FilesPerLevel());
   db_->CompactRange(NULL, NULL);
   ASSERT_EQ("0,0,1", FilesPerLevel());
 }

§ TEST() [131/142]

leveldb::TEST	(	DBTest	,
		DBOpen_Options
	)

Definition at line 1509 of file db_test.cc.

                              {
   std::string dbname = test::TmpDir() + "/db_options_test";
   DestroyDB(dbname, Options());
 
   // Does not exist, and create_if_missing == false: error
   DB* db = NULL;
   Options opts;
   opts.create_if_missing = false;
   Status s = DB::Open(opts, dbname, &db);
   ASSERT_TRUE(strstr(s.ToString().c_str(), "does not exist") != NULL);
   ASSERT_TRUE(db == NULL);
 
   // Does not exist, and create_if_missing == true: OK
   opts.create_if_missing = true;
   s = DB::Open(opts, dbname, &db);
   ASSERT_OK(s);
   ASSERT_TRUE(db != NULL);
 
   delete db;
   db = NULL;
 
   // Does exist, and error_if_exists == true: error
   opts.create_if_missing = false;
   opts.error_if_exists = true;
   s = DB::Open(opts, dbname, &db);
   ASSERT_TRUE(strstr(s.ToString().c_str(), "exists") != NULL);
   ASSERT_TRUE(db == NULL);
 
   // Does exist, and error_if_exists == false: OK
   opts.create_if_missing = true;
   opts.error_if_exists = false;
   s = DB::Open(opts, dbname, &db);
   ASSERT_OK(s);
   ASSERT_TRUE(db != NULL);
 
   delete db;
   db = NULL;
 }

Here is the call graph for this function:

§ TEST() [132/142]

leveldb::TEST	(	DBTest	,
		Locking
	)

Definition at line 1548 of file db_test.cc.

                       {
   DB* db2 = NULL;
   Status s = DB::Open(CurrentOptions(), dbname_, &db2);
   ASSERT_TRUE(!s.ok()) << "Locking did not prevent re-opening db";
 }

Here is the call graph for this function:

§ TEST() [133/142]

leveldb::TEST	(	DBTest	,
		NoSpace
	)

Definition at line 1555 of file db_test.cc.

                       {
   Options options = CurrentOptions();
   options.env = env_;
   Reopen(&options);
 
   ASSERT_OK(Put("foo", "v1"));
   ASSERT_EQ("v1", Get("foo"));
   Compact("a", "z");
   const int num_files = CountFiles();
   env_->no_space_.Release_Store(env_);   // Force out-of-space errors
   for (int i = 0; i < 10; i++) {
     for (int level = 0; level < config::kNumLevels-1; level++) {
       dbfull()->TEST_CompactRange(level, NULL, NULL);
     }
   }
   env_->no_space_.Release_Store(NULL);
   ASSERT_LT(CountFiles(), num_files + 3);
 }

§ TEST() [134/142]

leveldb::TEST	(	DBTest	,
		NonWritableFileSystem
	)

Definition at line 1574 of file db_test.cc.

                                     {
   Options options = CurrentOptions();
   options.write_buffer_size = 1000;
   options.env = env_;
   Reopen(&options);
   ASSERT_OK(Put("foo", "v1"));
   env_->non_writable_.Release_Store(env_);  // Force errors for new files
   std::string big(100000, 'x');
   int errors = 0;
   for (int i = 0; i < 20; i++) {
     fprintf(stderr, "iter %d; errors %d\n", i, errors);
     if (!Put("foo", big).ok()) {
       errors++;
       DelayMilliseconds(100);
     }
   }
   ASSERT_GT(errors, 0);
   env_->non_writable_.Release_Store(NULL);
 }

Here is the call graph for this function:

§ TEST() [135/142]

leveldb::TEST	(	DBTest	,
		WriteSyncError
	)

Definition at line 1594 of file db_test.cc.

                              {
   // Check that log sync errors cause the DB to disallow future writes.
 
   // (a) Cause log sync calls to fail
   Options options = CurrentOptions();
   options.env = env_;
   Reopen(&options);
   env_->data_sync_error_.Release_Store(env_);
 
   // (b) Normal write should succeed
   WriteOptions w;
   ASSERT_OK(db_->Put(w, "k1", "v1"));
   ASSERT_EQ("v1", Get("k1"));
 
   // (c) Do a sync write; should fail
   w.sync = true;
   ASSERT_TRUE(!db_->Put(w, "k2", "v2").ok());
   ASSERT_EQ("v1", Get("k1"));
   ASSERT_EQ("NOT_FOUND", Get("k2"));
 
   // (d) make sync behave normally
   env_->data_sync_error_.Release_Store(NULL);
 
   // (e) Do a non-sync write; should fail
   w.sync = false;
   ASSERT_TRUE(!db_->Put(w, "k3", "v3").ok());
   ASSERT_EQ("v1", Get("k1"));
   ASSERT_EQ("NOT_FOUND", Get("k2"));
   ASSERT_EQ("NOT_FOUND", Get("k3"));
 }

§ TEST() [136/142]

leveldb::TEST	(	DBTest	,
		ManifestWriteError
	)

Definition at line 1625 of file db_test.cc.

                                  {
   // Test for the following problem:
   // (a) Compaction produces file F
   // (b) Log record containing F is written to MANIFEST file, but Sync() fails
   // (c) GC deletes F
   // (d) After reopening DB, reads fail since deleted F is named in log record
 
   // We iterate twice.  In the second iteration, everything is the
   // same except the log record never makes it to the MANIFEST file.
   for (int iter = 0; iter < 2; iter++) {
     port::AtomicPointer* error_type = (iter == 0)
         ? &env_->manifest_sync_error_
         : &env_->manifest_write_error_;
 
     // Insert foo=>bar mapping
     Options options = CurrentOptions();
     options.env = env_;
     options.create_if_missing = true;
     options.error_if_exists = false;
     DestroyAndReopen(&options);
     ASSERT_OK(Put("foo", "bar"));
     ASSERT_EQ("bar", Get("foo"));
 
     // Memtable compaction (will succeed)
     dbfull()->TEST_CompactMemTable();
     ASSERT_EQ("bar", Get("foo"));
     const int last = config::kMaxMemCompactLevel;
     ASSERT_EQ(NumTableFilesAtLevel(last), 1);   // foo=>bar is now in last level
 
     // Merging compaction (will fail)
     error_type->Release_Store(env_);
     dbfull()->TEST_CompactRange(last, NULL, NULL);  // Should fail
     ASSERT_EQ("bar", Get("foo"));
 
     // Recovery: should not lose data
     error_type->Release_Store(NULL);
     Reopen(&options);
     ASSERT_EQ("bar", Get("foo"));
   }
 }

§ TEST() [137/142]

leveldb::TEST	(	DBTest	,
		MissingSSTFile
	)

Definition at line 1666 of file db_test.cc.

                              {
   ASSERT_OK(Put("foo", "bar"));
   ASSERT_EQ("bar", Get("foo"));
 
   // Dump the memtable to disk.
   dbfull()->TEST_CompactMemTable();
   ASSERT_EQ("bar", Get("foo"));
 
   Close();
   ASSERT_TRUE(DeleteAnSSTFile());
   Options options = CurrentOptions();
   options.paranoid_checks = true;
   Status s = TryReopen(&options);
   ASSERT_TRUE(!s.ok());
   ASSERT_TRUE(s.ToString().find("issing") != std::string::npos)
       << s.ToString();
 }

Here is the call graph for this function:

§ TEST() [138/142]

leveldb::TEST	(	DBTest	,
		StillReadSST
	)

Definition at line 1684 of file db_test.cc.

                            {
   ASSERT_OK(Put("foo", "bar"));
   ASSERT_EQ("bar", Get("foo"));
 
   // Dump the memtable to disk.
   dbfull()->TEST_CompactMemTable();
   ASSERT_EQ("bar", Get("foo"));
   Close();
   ASSERT_GT(RenameLDBToSST(), 0);
   Options options = CurrentOptions();
   options.paranoid_checks = true;
   Status s = TryReopen(&options);
   ASSERT_TRUE(s.ok());
   ASSERT_EQ("bar", Get("foo"));
 }

Here is the call graph for this function:

§ TEST() [139/142]

leveldb::TEST	(	DBTest	,
		FilesDeletedAfterCompaction
	)

Definition at line 1700 of file db_test.cc.

                                           {
   ASSERT_OK(Put("foo", "v2"));
   Compact("a", "z");
   const int num_files = CountFiles();
   for (int i = 0; i < 10; i++) {
     ASSERT_OK(Put("foo", "v2"));
     Compact("a", "z");
   }
   ASSERT_EQ(CountFiles(), num_files);
 }

§ TEST() [140/142]

leveldb::TEST	(	DBTest	,
		BloomFilter
	)

Definition at line 1711 of file db_test.cc.

                           {
   env_->count_random_reads_ = true;
   Options options = CurrentOptions();
   options.env = env_;
   options.block_cache = NewLRUCache(0);  // Prevent cache hits
   options.filter_policy = NewBloomFilterPolicy(10);
   Reopen(&options);
 
   // Populate multiple layers
   const int N = 10000;
   for (int i = 0; i < N; i++) {
     ASSERT_OK(Put(Key(i), Key(i)));
   }
   Compact("a", "z");
   for (int i = 0; i < N; i += 100) {
     ASSERT_OK(Put(Key(i), Key(i)));
   }
   dbfull()->TEST_CompactMemTable();
 
   // Prevent auto compactions triggered by seeks
   env_->delay_data_sync_.Release_Store(env_);
 
   // Lookup present keys.  Should rarely read from small sstable.
   env_->random_read_counter_.Reset();
   for (int i = 0; i < N; i++) {
     ASSERT_EQ(Key(i), Get(Key(i)));
   }
   int reads = env_->random_read_counter_.Read();
   fprintf(stderr, "%d present => %d reads\n", N, reads);
   ASSERT_GE(reads, N);
   ASSERT_LE(reads, N + 2*N/100);
 
   // Lookup present keys.  Should rarely read from either sstable.
   env_->random_read_counter_.Reset();
   for (int i = 0; i < N; i++) {
     ASSERT_EQ("NOT_FOUND", Get(Key(i) + ".missing"));
   }
   reads = env_->random_read_counter_.Read();
   fprintf(stderr, "%d missing => %d reads\n", N, reads);
   ASSERT_LE(reads, 3*N/100);
 
   env_->delay_data_sync_.Release_Store(NULL);
   Close();
   delete options.block_cache;
   delete options.filter_policy;
 }

Here is the call graph for this function:

§ TEST() [141/142]

leveldb::TEST	(	DBTest	,
		MultiThreaded
	)

Definition at line 1824 of file db_test.cc.

                             {
   do {
     // Initialize state
     MTState mt;
     mt.test = this;
     mt.stop.Release_Store(0);
     for (int id = 0; id < kNumThreads; id++) {
       mt.counter[id].Release_Store(0);
       mt.thread_done[id].Release_Store(0);
     }
 
     // Start threads
     MTThread thread[kNumThreads];
     for (int id = 0; id < kNumThreads; id++) {
       thread[id].state = &mt;
       thread[id].id = id;
       env_->StartThread(MTThreadBody, &thread[id]);
     }
 
     // Let them run for a while
     DelayMilliseconds(kTestSeconds * 1000);
 
     // Stop the threads and wait for them to finish
     mt.stop.Release_Store(&mt);
     for (int id = 0; id < kNumThreads; id++) {
       while (mt.thread_done[id].Acquire_Load() == NULL) {
         DelayMilliseconds(100);
       }
     }
   } while (ChangeOptions());
 }

Here is the call graph for this function:

§ TEST() [142/142]

leveldb::TEST	(	DBTest	,
		Randomized
	)

Definition at line 2017 of file db_test.cc.

                          {
   Random rnd(test::RandomSeed());
   do {
     ModelDB model(CurrentOptions());
     const int N = 10000;
     const Snapshot* model_snap = NULL;
     const Snapshot* db_snap = NULL;
     std::string k, v;
     for (int step = 0; step < N; step++) {
       if (step % 100 == 0) {
         fprintf(stderr, "Step %d of %d\n", step, N);
       }
       // TODO(sanjay): Test Get() works
       int p = rnd.Uniform(100);
       if (p < 45) {                               // Put
         k = RandomKey(&rnd);
         v = RandomString(&rnd,
                          rnd.OneIn(20)
                          ? 100 + rnd.Uniform(100)
                          : rnd.Uniform(8));
         ASSERT_OK(model.Put(WriteOptions(), k, v));
         ASSERT_OK(db_->Put(WriteOptions(), k, v));
 
       } else if (p < 90) {                        // Delete
         k = RandomKey(&rnd);
         ASSERT_OK(model.Delete(WriteOptions(), k));
         ASSERT_OK(db_->Delete(WriteOptions(), k));
 
 
       } else {                                    // Multi-element batch
         WriteBatch b;
         const int num = rnd.Uniform(8);
         for (int i = 0; i < num; i++) {
           if (i == 0 || !rnd.OneIn(10)) {
             k = RandomKey(&rnd);
           } else {
             // Periodically re-use the same key from the previous iter, so
             // we have multiple entries in the write batch for the same key
           }
           if (rnd.OneIn(2)) {
             v = RandomString(&rnd, rnd.Uniform(10));
             b.Put(k, v);
           } else {
             b.Delete(k);
           }
         }
         ASSERT_OK(model.Write(WriteOptions(), &b));
         ASSERT_OK(db_->Write(WriteOptions(), &b));
       }
 
       if ((step % 100) == 0) {
         ASSERT_TRUE(CompareIterators(step, &model, db_, NULL, NULL));
         ASSERT_TRUE(CompareIterators(step, &model, db_, model_snap, db_snap));
         // Save a snapshot from each DB this time that we'll use next
         // time we compare things, to make sure the current state is
         // preserved with the snapshot
         if (model_snap != NULL) model.ReleaseSnapshot(model_snap);
         if (db_snap != NULL) db_->ReleaseSnapshot(db_snap);
 
         Reopen();
         ASSERT_TRUE(CompareIterators(step, &model, db_, NULL, NULL));
 
         model_snap = model.GetSnapshot();
         db_snap = db_->GetSnapshot();
       }
     }
     if (model_snap != NULL) model.ReleaseSnapshot(model_snap);
     if (db_snap != NULL) db_->ReleaseSnapshot(db_snap);
   } while (ChangeOptions());
 }

Here is the call graph for this function:

§ TestEncodeDecode()

static void leveldb::TestEncodeDecode ( const VersionEdit & edit )

static

Definition at line 10 of file version_edit_test.cc.

                                                       {
   std::string encoded, encoded2;
   edit.EncodeTo(&encoded);
   VersionEdit parsed;
   Status s = parsed.DecodeFrom(encoded);
   ASSERT_TRUE(s.ok()) << s.ToString();
   parsed.EncodeTo(&encoded2);
   ASSERT_EQ(encoded, encoded2);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ TestKey()

static void leveldb::TestKey	(	const std::string &	key,
		uint64_t	seq,
		ValueType	vt
	)

static

Definition at line 31 of file dbformat_test.cc.

                                   {
   std::string encoded = IKey(key, seq, vt);
 
   Slice in(encoded);
   ParsedInternalKey decoded("", 0, kTypeValue);
 
   ASSERT_TRUE(ParseInternalKey(in, &decoded));
   ASSERT_EQ(key, decoded.user_key.ToString());
   ASSERT_EQ(seq, decoded.sequence);
   ASSERT_EQ(vt, decoded.type);
 
   ASSERT_TRUE(!ParseInternalKey(Slice("bar"), &decoded));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ ThreadBody()

static void leveldb::ThreadBody ( void * arg )

static

Definition at line 73 of file env_test.cc.

                                   {
   State* s = reinterpret_cast<State*>(arg);
   s->mu.Lock();
   s->val += 1;
   s->num_running -= 1;
   s->mu.Unlock();
 }

Here is the caller graph for this function:

§ TotalFileSize()

static int64_t leveldb::TotalFileSize ( const std::vector< FileMetaData *> & files )

static

Definition at line 58 of file version_set.cc.

                                                                     {
   int64_t sum = 0;
   for (size_t i = 0; i < files.size(); i++) {
     sum += files[i]->file_size;
   }
   return sum;
 }

Here is the caller graph for this function:

§ UnrefEntry()

static void leveldb::UnrefEntry	(	void *	arg1,
		void *	arg2
	)

static

Definition at line 26 of file table_cache.cc.

                                                {
   Cache* cache = reinterpret_cast<Cache*>(arg1);
   Cache::Handle* h = reinterpret_cast<Cache::Handle*>(arg2);
   cache->Release(h);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ VarintLength()

int leveldb::VarintLength ( uint64_t v )

Definition at line 103 of file coding.cc.

                              {
   int len = 1;
   while (v >= 128) {
     v >>= 7;
     len++;
   }
   return len;
 }

Here is the caller graph for this function:

§ WriteStringToFile()

Status leveldb::WriteStringToFile	(	Env *	env,
		const Slice &	data,
		const std::string &	fname
	)

Definition at line 62 of file env.cc.

                                                  {
   return DoWriteStringToFile(env, data, fname, false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

§ WriteStringToFileSync()

Status leveldb::WriteStringToFileSync	(	Env *	env,
		const Slice &	data,
		const std::string &	fname
	)

Definition at line 67 of file env.cc.

                                                      {
   return DoWriteStringToFile(env, data, fname, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

§ bytewise

const Comparator* leveldb::bytewise

static

Definition at line 70 of file comparator.cc.

§ default_env

Env* leveldb::default_env

static

Definition at line 610 of file env_posix.cc.

§ kBlockSize

const int leveldb::kBlockSize = 4096

static

Definition at line 10 of file arena.cc.

§ kBlockTrailerSize

const size_t leveldb::kBlockTrailerSize = 5

static

Definition at line 84 of file format.h.

§ kCount

const int leveldb::kCount = kTotalSize / kValueSize

static

Definition at line 54 of file autocompact_test.cc.

§ kDelayMicros

const int leveldb::kDelayMicros = 100000

static

Definition at line 12 of file env_test.cc.

§ kFilterBase

const size_t leveldb::kFilterBase = 1 << kFilterBaseLg

static

Definition at line 16 of file filter_block.cc.

§ kFilterBaseLg

const size_t leveldb::kFilterBaseLg = 11

static

Definition at line 15 of file filter_block.cc.

§ kHeader

const size_t leveldb::kHeader = 12

static

Definition at line 27 of file write_batch.cc.

§ kMajorVersion

const int leveldb::kMajorVersion = 1

static

Definition at line 16 of file db.h.

§ kMaxNumValues

const int leveldb::kMaxNumValues = 2000

static

Definition at line 29 of file fault_injection_test.cc.

§ kMaxSequenceNumber

const SequenceNumber leveldb::kMaxSequenceNumber

static

Initial value:

=

((0x1ull << 56) - 1)

Definition at line 67 of file dbformat.h.

§ kMinorVersion

const int leveldb::kMinorVersion = 19

static

Definition at line 17 of file db.h.

§ kNumIterations

const size_t leveldb::kNumIterations = 3

static

Definition at line 30 of file fault_injection_test.cc.

§ kNumNonTableCacheFiles

const int leveldb::kNumNonTableCacheFiles = 10

Definition at line 38 of file db_impl.cc.

§ kNumTestArgs

const int leveldb::kNumTestArgs = sizeof(kTestArgList) / sizeof(kTestArgList[0])

static

Definition at line 435 of file table_test.cc.

§ kTableMagicNumber

const uint64_t leveldb::kTableMagicNumber = 0xdb4775248b80fb57ull

static

Definition at line 81 of file format.h.

§ kTestArgList

const TestArgs leveldb::kTestArgList[]

static

Initial value:

= {
  { TABLE_TEST, false, 16 },
  { TABLE_TEST, false, 1 },
  { TABLE_TEST, false, 1024 },
  { TABLE_TEST, true, 16 },
  { TABLE_TEST, true, 1 },
  { TABLE_TEST, true, 1024 },
  { BLOCK_TEST, false, 16 },
  { BLOCK_TEST, false, 1 },
  { BLOCK_TEST, false, 1024 },
  { BLOCK_TEST, true, 16 },
  { BLOCK_TEST, true, 1 },
  { BLOCK_TEST, true, 1024 },
  
  { MEMTABLE_TEST, false, 16 },
  { MEMTABLE_TEST, true, 16 },
  
  { DB_TEST, false, 16 },
  { DB_TEST, true, 16 },
}

Definition at line 412 of file table_test.cc.

§ kTotalSize

const int leveldb::kTotalSize = 100 * 1024 * 1024

static

Definition at line 53 of file autocompact_test.cc.

§ kValueSize [1/3]

const int leveldb::kValueSize = 1000

static

Definition at line 25 of file corruption_test.cc.

§ kValueSize [2/3]

const int leveldb::kValueSize = 1000

static

Definition at line 28 of file fault_injection_test.cc.

§ kValueSize [3/3]

const int leveldb::kValueSize = 200 * 1024

static

Definition at line 52 of file autocompact_test.cc.

§ kValueTypeForSeek

const ValueType leveldb::kValueTypeForSeek = kTypeValue

static

Definition at line 61 of file dbformat.h.

§ kVerbose

const int leveldb::kVerbose = 1

static

Definition at line 14 of file bloom_test.cc.

§ once [1/2]

port::OnceType leveldb::once = LEVELDB_ONCE_INIT

static

Definition at line 69 of file comparator.cc.

§ once [2/2]

pthread_once_t leveldb::once = PTHREAD_ONCE_INIT

static

Definition at line 609 of file env_posix.cc.

§ reverse_key_comparator

ReverseKeyComparator leveldb::reverse_key_comparator

static

Definition at line 64 of file table_test.cc.

Namespaces
	anonymous_namespace{bloom.cc}

	anonymous_namespace{cache.cc}

	anonymous_namespace{comparator.cc}

	anonymous_namespace{db_bench.cc}

	anonymous_namespace{db_impl.cc}

	anonymous_namespace{db_iter.cc}

	anonymous_namespace{db_test.cc}

	anonymous_namespace{dumpfile.cc}

	anonymous_namespace{env_posix.cc}

	anonymous_namespace{fault_injection_test.cc}

	anonymous_namespace{iterator.cc}

	anonymous_namespace{leveldbutil.cc}

	anonymous_namespace{memenv.cc}

	anonymous_namespace{merger.cc}

	anonymous_namespace{repair.cc}

	anonymous_namespace{table_test.cc}

	anonymous_namespace{two_level_iterator.cc}

	anonymous_namespace{version_set.cc}

	anonymous_namespace{write_batch.cc}

	config

	crc32c

	log

	test

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Class Documentation

§ leveldb::ArenaTest

§ leveldb::BlockContents

§ leveldb::Coding

§ leveldb::FileNameTest

§ leveldb::FilterBlockTest

§ leveldb::FormatTest

§ leveldb::HASH

§ leveldb::MemTableTest

§ leveldb::SkipTest

§ leveldb::State

§ leveldb::TableAndFile

§ leveldb::TableTest

§ leveldb::TestArgs

§ leveldb::VersionEditTest

§ leveldb::WriteBatchTest

Typedef Documentation

§ Key

§ KVMap

§ SequenceNumber

Enumeration Type Documentation

§ CompressionType

§ FileType

§ Tag

§ TestType

§ ValueType

Function Documentation

§ AfterFile()

§ AppendEscapedStringTo()

§ AppendInternalKey()

§ AppendNumberTo()

§ BeforeFile()

§ Between() [1/2]

§ Between() [2/2]

§ BM_LogAndApply()

§ BuildTable()

§ BytewiseComparator()

§ ClipToRange()

§ CompareIterators()

§ ConcurrentReader()

§ ConsumeDecimalNumber()

§ CurrentFileName()

§ DecodeEntry()

§ DecodeFixed32()

§ DecodeFixed64()

§ DecodeKey()

§ DecodeValue()

§ DeleteBlock()

§ DeleteCachedBlock()

§ DeleteEntry()

§ DescriptorFileName()

§ DestroyDB()

§ DoWriteStringToFile()

§ DumpFile()

§ EncodeFixed32()

§ EncodeFixed64()

§ EncodeKey() [1/2]

§ EncodeKey() [2/2]

§ EncodeValue()

§ EncodeVarint32()

§ EncodeVarint64()

§ EscapeString()

§ ExpandedCompactionByteSizeLimit()

§ ExtractUserKey()

§ ExtractValueType()

§ FindFile()

§ GetFileIterator()

§ GetInternalKey()

§ GetLengthPrefixedSlice() [1/3]

§ GetLengthPrefixedSlice() [2/3]

§ GetLengthPrefixedSlice() [3/3]

§ GetLevel()

§ GetVarint32()

§ GetVarint32Ptr()