def test_extras():
st = RamStorage()
hw = HashWriter(st.create_file("test"))
hw.extras["test"] = 100
hw.extras["blah"] = "foo"
hw.close()
hr = HashReader(st.open_file("test"), st.file_length("test"))
assert hr.extras["test"] == 100
assert hr.extras["blah"] == "foo"
hr.close()
hw = OrderedHashWriter(st.create_file("test"))
hw.extras["test"] = 100
hw.extras["blah"] = "foo"
hw.close()
hr = HashReader(st.open_file("test"), st.file_length("test"))
assert hr.extras["test"] == 100
assert hr.extras["blah"] == "foo"
hr.close()
hr = OrderedHashReader(st.open_file("test"), st.file_length("test"))
assert hr.extras["test"] == 100
assert hr.extras["blah"] == "foo"
hr.close()
def test_hash_contents():
samp = [('alfa', 'bravo'), ('charlie', 'delta'), ('echo', 'foxtrot'),
('golf', 'hotel'), ('india', 'juliet'), ('kilo', 'lima'),
('mike', 'november'), ('oskar', 'papa'), ('quebec', 'romeo'),
('sierra', 'tango'), ('ultra', 'victor'), ('whiskey', 'xray'),
]
# Convert to bytes
samp = set((b(k), b(v)) for k, v in samp)
with TempStorage("hashcontents") as st:
hw = HashWriter(st.create_file("test.hsh"))
hw.add_all(samp)
hw.close()
hr = HashReader.open(st, "test.hsh")
probes = list(samp)
random.shuffle(probes)
for key, value in probes:
assert hr[key] == value
assert set(hr.keys()) == set([k for k, v in samp])
assert set(hr.values()) == set([v for k, v in samp])
assert set(hr.items()) == samp
hr.close()
def test_random_hash():
with TempStorage("randomhash") as st:
domain = "abcdefghijklmnopqrstuvwxyz"
domain += domain.upper()
times = 1000
minlen = 1
maxlen = len(domain)
samp = dict((randstring(domain, minlen, maxlen),
randstring(domain, minlen, maxlen)) for _ in xrange(times))
hwf = st.create_file("test.hsh")
hw = HashWriter(hwf)
for k, v in iteritems(samp):
hw.add(k, v)
hw.close()
keys = list(samp.keys())
random.shuffle(keys)
hrf = st.open_file("test.hsh")
hr = HashReader(hrf)
for k in keys:
v = hr[k]
assert_equal(v, b(samp[k]))
hr.close()
def test_random_hash():
from string import ascii_letters as domain
times = 1000
minlen = 1
maxlen = len(domain)
def randstring():
s = "".join(random.sample(domain, random.randint(minlen, maxlen)))
return b(s)
with TempStorage("randomhash") as st:
samp = dict((randstring(), randstring()) for _ in xrange(times))
hw = HashWriter(st.create_file("test.hsh"))
for k, v in iteritems(samp):
hw.add(k, v)
hw.close()
keys = list(samp.keys())
random.shuffle(keys)
hr = HashReader.open(st, "test.hsh")
for k in keys:
assert hr[k] == samp[k]
hr.close()
def test_bigtable():
with TempStorage("bigtable") as st:
def randstring(min, max):
return "".join(chr(randint(1, 255))
for _ in xrange(randint(min, max)))
count = 100000
samp = dict((randstring(1,50), randstring(1,50))
for _ in xrange(count))
fhw = HashWriter(st.create_file("big.hsh"))
fhw.add_all(iteritems(samp))
fhw.close()
fhr = HashReader(st.open_file("big.hsh"))
keys = list(samp.keys())
shuffle(keys)
for key in keys:
assert_equal(samp[key], fhr[key])
set1 = set(iteritems(samp))
set2 = set(fhr.items())
assert_equal(set1, set2)
fhr.close()
def test_hash_single():
st = RamStorage()
hw = HashWriter(st.create_file("test.hsh"))
hw.add(b("alfa"), b("bravo"))
hw.close()
hr = HashReader.open(st, "test.hsh")
assert hr.get(b("alfa")) == b("bravo")
assert hr.get(b("foo")) is None
def test_random_access():
times = 1000
with TempStorage("orderedhash") as st:
hw = HashWriter(st.create_file("test.hsh"))
hw.add_all((b("%08x" % x), b(str(x))) for x in xrange(times))
hw.close()
keys = list(range(times))
random.shuffle(keys)
hr = HashReader.open(st, "test.hsh")
for x in keys:
assert hr[b("%08x" % x)] == b(str(x))
hr.close()
def test_ordered_hash():
times = 10000
with TempStorage("orderedhash") as st:
hwf = st.create_file("test.hsh")
hw = HashWriter(hwf)
hw.add_all(("%08x" % x, str(x)) for x in xrange(times))
hw.close()
keys = list(range(times))
random.shuffle(keys)
hrf = st.open_file("test.hsh")
hr = HashReader(hrf)
for x in keys:
assert_equal(hr["%08x" % x], b(str(x)))
hr.close()
def test_hash_contents():
samp = set((('alfa', 'bravo'), ('charlie', 'delta'), ('echo', 'foxtrot'),
('golf', 'hotel'), ('india', 'juliet'), ('kilo', 'lima'),
('mike', 'november'), ('oskar', 'papa'), ('quebec', 'romeo'),
('sierra', 'tango'), ('ultra', 'victor'), ('whiskey', 'xray')))
with TempStorage("hashcontents") as st:
hwf = st.create_file("test.hsh")
hw = HashWriter(hwf)
hw.add_all(samp)
hw.close()
hrf = st.open_file("test.hsh")
hr = HashReader(hrf)
assert_equal(set(hr.items()), samp)
hr.close()
def test_hash_extras():
st = RamStorage()
hw = HashWriter(st.create_file("test.hsh"))
hw.extras["test"] = 100
hw.add(b("foo"), b("bar"))
hw.add(b("glonk"), b("baz"))
hw.close()
hr = HashReader.open(st, "test.hsh")
assert hr.extras["test"] == 100
assert hr.get(b("foo")) == b("bar")
assert hr.get(b("baz")) is None
hr.close()
def test_hash():
with TempStorage("hash") as st:
hwf = st.create_file("test.hsh")
hw = HashWriter(hwf)
hw.add(b("foo"), b("bar"))
hw.add(b("glonk"), b("baz"))
hw.close()
hr = HashReader.open(st, "test.hsh")
assert hr.get(b("foo")) == b("bar")
assert hr.get(b("baz")) is None
hr.close()
def test_hash():
with TempStorage("hash") as st:
hwf = st.create_file("test.hsh")
hw = HashWriter(hwf)
hw.add(b("foo"), b("bar"))
hw.add(b("glonk"), b("baz"))
hw.close()
hrf = st.open_file("test.hsh")
hr = HashReader(hrf)
assert_equal(hr.get(b("foo")), b("bar"))
assert_equal(hr.get(b("baz")), None)
hr.close()
def test_hash_extras():
st = RamStorage()
hw = HashWriter(st.create_file("test.hsh"))
hw.extras["test"] = 100
hw.add(b("foo"), b("bar"))
hw.add(b("glonk"), b("baz"))
hw.close()
hr = HashReader.open(st, "test.hsh")
assert hr.extras["test"] == 100
assert hr.get(b("foo")) == b("bar")
assert hr.get(b("baz")) is None
hr.close()
def test_hash_contents():
samp = [
('alfa', 'bravo'),
('charlie', 'delta'),
('echo', 'foxtrot'),
('golf', 'hotel'),
('india', 'juliet'),
('kilo', 'lima'),
('mike', 'november'),
('oskar', 'papa'),
('quebec', 'romeo'),
('sierra', 'tango'),
('ultra', 'victor'),
('whiskey', 'xray'),
]
# Convert to bytes
samp = set((b(k), b(v)) for k, v in samp)
with TempStorage("hashcontents") as st:
hw = HashWriter(st.create_file("test.hsh"))
hw.add_all(samp)
hw.close()
hr = HashReader.open(st, "test.hsh")
probes = list(samp)
random.shuffle(probes)
for key, value in probes:
assert hr[key] == value
assert set(hr.keys()) == set([k for k, v in samp])
assert set(hr.values()) == set([v for k, v in samp])
assert set(hr.items()) == samp
hr.close()
def test_hash_contents():
samp = [
('alfa', 'bravo'),
('charlie', 'delta'),
('echo', 'foxtrot'),
('golf', 'hotel'),
('india', 'juliet'),
('kilo', 'lima'),
('mike', 'november'),
('oskar', 'papa'),
('quebec', 'romeo'),
('sierra', 'tango'),
('ultra', 'victor'),
('whiskey', 'xray'),
]
# Convert to bytes
samp = set((b(k), b(v)) for k, v in samp)
with TempStorage("hashcontents") as st:
hwf = st.create_file("test.hsh")
hw = HashWriter(hwf)
hw.add_all(samp)
hw.close()
hrf = st.open_file("test.hsh")
hr = HashReader(hrf)
assert_equal(set(hr.items()), samp)
hr.close()
def test_random_hash():
from string import ascii_letters as domain
times = 1000
minlen = 1
maxlen = len(domain)
def randstring():
s = "".join(random.sample(domain, random.randint(minlen, maxlen)))
return b(s)
with TempStorage("randomhash") as st:
samp = dict((randstring(), randstring()) for _ in xrange(times))
hwf = st.create_file("test.hsh")
hw = HashWriter(hwf)
for k, v in iteritems(samp):
hw.add(k, v)
hw.close()
keys = list(samp.keys())
random.shuffle(keys)
hrf = st.open_file("test.hsh")
hr = HashReader(hrf)
for k in keys:
assert_equal(hr[k], samp[k])
hr.close()
def test_bigtable():
with TempStorage("bigtable") as st:
def randstring(min, max):
return "".join(
chr(randint(1, 255)) for _ in xrange(randint(min, max)))
count = 100000
samp = dict(
(randstring(1, 50), randstring(1, 50)) for _ in xrange(count))
fhw = HashWriter(st.create_file("big.hsh"))
fhw.add_all(iteritems(samp))
fhw.close()
fhr = HashReader(st.open_file("big.hsh"))
keys = list(samp.keys())
shuffle(keys)
for key in keys:
assert_equal(samp[key], fhr[key])
set1 = set(iteritems(samp))
set2 = set(fhr.items())
assert_equal(set1, set2)
fhr.close()
def test_random_hash():
with TempStorage("randomhash") as st:
domain = "abcdefghijklmnopqrstuvwxyz"
domain += domain.upper()
times = 1000
minlen = 1
maxlen = len(domain)
samp = dict((randstring(domain, minlen, maxlen),
randstring(domain, minlen, maxlen))
for _ in xrange(times))
hwf = st.create_file("test.hsh")
hw = HashWriter(hwf)
for k, v in iteritems(samp):
hw.add(k, v)
hw.close()
keys = list(samp.keys())
random.shuffle(keys)
hrf = st.open_file("test.hsh")
hr = HashReader(hrf)
for k in keys:
v = hr[k]
assert_equal(v, b(samp[k]))
hr.close()
def test_hash():
with TempStorage("hash") as st:
hwf = st.create_file("test.hsh")
hw = HashWriter(hwf)
hw.add(b("foo"), b("bar"))
hw.add(b("glonk"), b("baz"))
hw.close()
hr = HashReader.open(st, "test.hsh")
assert hr.get(b("foo")) == b("bar")
assert hr.get(b("baz")) is None
hr.close()
def test_hash_single():
st = RamStorage()
hw = HashWriter(st.create_file("test.hsh"))
hw.add(b("alfa"), b("bravo"))
hw.close()
hr = HashReader.open(st, "test.hsh")
assert hr.get(b("alfa")) == b("bravo")
assert hr.get(b("foo")) is None
def test_hash():
with TempStorage("hash") as st:
hwf = st.create_file("test.hsh")
hw = HashWriter(hwf)
hw.add("foo", "bar")
hw.add("glonk", "baz")
hw.close()
hrf = st.open_file("test.hsh")
hr = HashReader(hrf)
assert_equal(hr.get("foo"), b("bar"))
assert_equal(hr.get("baz"), None)
hr.close()
def test_random_access():
times = 1000
with TempStorage("orderedhash") as st:
hw = HashWriter(st.create_file("test.hsh"))
hw.add_all((b("%08x" % x), b(str(x))) for x in xrange(times))
hw.close()
keys = list(range(times))
random.shuffle(keys)
hr = HashReader.open(st, "test.hsh")
for x in keys:
assert hr[b("%08x" % x)] == b(str(x))
hr.close()
def test_ordered_hash():
times = 10000
with TempStorage("orderedhash") as st:
hwf = st.create_file("test.hsh")
hw = HashWriter(hwf)
hw.add_all((b("%08x" % x), b(str(x))) for x in xrange(times))
hw.close()
keys = list(range(times))
random.shuffle(keys)
hrf = st.open_file("test.hsh")
hr = HashReader(hrf)
for x in keys:
assert_equal(hr[b("%08x" % x)], b(str(x)))
hr.close()
def test_extras():
st = RamStorage()
hw = HashWriter(st.create_file("test"))
hw.extras["test"] = 100
hw.extras["blah"] = "foo"
hw.close()
hr = HashReader(st.open_file("test"), st.file_length("test"))
assert hr.extras["test"] == 100
assert hr.extras["blah"] == "foo"
hr.close()
hw = OrderedHashWriter(st.create_file("test"))
hw.extras["test"] = 100
hw.extras["blah"] = "foo"
hw.close()
hr = HashReader(st.open_file("test"), st.file_length("test"))
assert hr.extras["test"] == 100
assert hr.extras["blah"] == "foo"
hr.close()
hr = OrderedHashReader(st.open_file("test"), st.file_length("test"))
assert hr.extras["test"] == 100
assert hr.extras["blah"] == "foo"
hr.close()