def ziplist_with_integers() :
# Integers between 0 and 12, both inclusive, are encoded differently
for x in range(0,13):
r.rpush("ziplist_with_integers", x)
# Dealing with 1 byte integers
r.rpush("ziplist_with_integers", -2)
r.rpush("ziplist_with_integers", 13)
r.rpush("ziplist_with_integers", 25)
r.rpush("ziplist_with_integers", -61)
r.rpush("ziplist_with_integers", 63)
# Dealing with 2 byte integers
r.rpush("ziplist_with_integers", 16380)
r.rpush("ziplist_with_integers", -16000)
# Dealing with 4 byte signed integers
r.rpush("ziplist_with_integers", 65535)
r.rpush("ziplist_with_integers", -65523)
# Dealing with 8 byte signed integers
r.rpush("ziplist_with_integers", 4194304)
r.rpush("ziplist_with_integers", 0x7fffffffffffffff)
def test_ziplist_with_integers(self):
r = load_rdb('ziplist_with_integers.rdb')
expected_numbers = []
for x in range(0,13):
expected_numbers.append(x)
expected_numbers += [-2, 13, 25, -61, 63, 16380, -16000, 65535, -65523, 4194304, 0x7fffffffffffffff]
self.assertEquals(r.lengths[0][b"ziplist_with_integers"], len(expected_numbers))
for num in expected_numbers :
self.assert_(num in r.databases[0][b"ziplist_with_integers"], "Cannot find %d" % num)
def test_string_key_with_compression(self):
r = load_rdb('easily_compressible_string_key.rdb')
key = b"".join(b'a' for x in range(0, 200))
value = b"Key that redis should compress easily"
self.assertEquals(r.databases[0][key], value)
def easily_compressible_string_key():
r.set("".join('a' for x in range(0, 200)),
"Key that redis should compress easily")
def random_string(length, seed):
random.seed(seed)
return ''.join(
random.choice(string.ascii_uppercase + string.digits)
for x in range(length))
def regular_sorted_set():
num_entries = 500
for x in range(0, num_entries):
r.zadd("force_sorted_set", float(x) / 100, random_string(50, x))
def linkedlist():
num_entries = 1000
for x in range(0, num_entries):
r.rpush("force_linkedlist", random_string(50, x))
def linkedlist() :
num_entries = 1000
for x in range(0, num_entries) :
r.rpush("force_linkedlist", random_string(50, x))
def dictionary():
num_entries = 1000
for x in range(0, num_entries):
r.hset("force_dictionary", random_string(50, x),
random_string(50, x + num_entries))
def ziplist_that_compresses_easily() :
for length in (6, 12, 18, 24, 30, 36) :
r.rpush("ziplist_compresses_easily", ("".join("a" for x in range(length))))
def dictionary() :
num_entries = 1000
for x in range(0, num_entries) :
r.hset("force_dictionary", random_string(50, x), random_string(50, x + num_entries))
def easily_compressible_string_key() :
r.set("".join('a' for x in range(0, 200)), "Key that redis should compress easily")
def random_string(length, seed) :
random.seed(seed)
return ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(length))
def regular_sorted_set() :
num_entries = 500
for x in range(0, num_entries) :
r.zadd("force_sorted_set", float(x) / 100, random_string(50, x))
def test_string_key_with_compression(self):
r = load_rdb('easily_compressible_string_key.rdb')
key = b"".join(b'a' for x in range(0, 200))
value = b"Key that redis should compress easily"
self.assertEquals(r.databases[0][key], value)
def test_ziplist_that_compresses_easily(self):
r = load_rdb('ziplist_that_compresses_easily.rdb')
self.assertEquals(r.lengths[0][b"ziplist_compresses_easily"], 6)
for idx, length in enumerate([6, 12, 18, 24, 30, 36]) :
self.assertEquals((b"".join(b"a" for x in range(length))), r.databases[0][b"ziplist_compresses_easily"][idx])
def ziplist_that_compresses_easily():
for length in (6, 12, 18, 24, 30, 36):
r.rpush("ziplist_compresses_easily",
("".join("a" for x in range(length))))
