|
|
from __future__ import absolute_import, print_function
|
|
|
|
|
|
import unittest
|
|
|
|
|
|
import silenttestrunner
|
|
|
|
|
|
from mercurial import (
|
|
|
util,
|
|
|
)
|
|
|
|
|
|
class testlrucachedict(unittest.TestCase):
|
|
|
def testsimple(self):
|
|
|
d = util.lrucachedict(4)
|
|
|
self.assertEqual(d.capacity, 4)
|
|
|
d.insert('a', 'va', cost=2)
|
|
|
d['b'] = 'vb'
|
|
|
d['c'] = 'vc'
|
|
|
d.insert('d', 'vd', cost=42)
|
|
|
|
|
|
self.assertEqual(d['a'], 'va')
|
|
|
self.assertEqual(d['b'], 'vb')
|
|
|
self.assertEqual(d['c'], 'vc')
|
|
|
self.assertEqual(d['d'], 'vd')
|
|
|
|
|
|
self.assertEqual(d.totalcost, 44)
|
|
|
|
|
|
# 'a' should be dropped because it was least recently used.
|
|
|
d['e'] = 've'
|
|
|
self.assertNotIn('a', d)
|
|
|
self.assertIsNone(d.get('a'))
|
|
|
self.assertEqual(d.totalcost, 42)
|
|
|
|
|
|
self.assertEqual(d['b'], 'vb')
|
|
|
self.assertEqual(d['c'], 'vc')
|
|
|
self.assertEqual(d['d'], 'vd')
|
|
|
self.assertEqual(d['e'], 've')
|
|
|
|
|
|
# Replacing item with different cost adjusts totalcost.
|
|
|
d.insert('e', 've', cost=4)
|
|
|
self.assertEqual(d.totalcost, 46)
|
|
|
|
|
|
# Touch entries in some order (both get and set).
|
|
|
d['e']
|
|
|
d['c'] = 'vc2'
|
|
|
d['d']
|
|
|
d['b'] = 'vb2'
|
|
|
|
|
|
# 'e' should be dropped now
|
|
|
d['f'] = 'vf'
|
|
|
self.assertNotIn('e', d)
|
|
|
self.assertEqual(d['b'], 'vb2')
|
|
|
self.assertEqual(d['c'], 'vc2')
|
|
|
self.assertEqual(d['d'], 'vd')
|
|
|
self.assertEqual(d['f'], 'vf')
|
|
|
|
|
|
d.clear()
|
|
|
for key in ('a', 'b', 'c', 'd', 'e', 'f'):
|
|
|
self.assertNotIn(key, d)
|
|
|
|
|
|
def testunfull(self):
|
|
|
d = util.lrucachedict(4)
|
|
|
d['a'] = 1
|
|
|
d['b'] = 2
|
|
|
d['a']
|
|
|
d['b']
|
|
|
|
|
|
for key in ('a', 'b'):
|
|
|
self.assertIn(key, d)
|
|
|
|
|
|
def testget(self):
|
|
|
d = util.lrucachedict(4)
|
|
|
d['a'] = 'va'
|
|
|
d['b'] = 'vb'
|
|
|
d['c'] = 'vc'
|
|
|
|
|
|
self.assertIsNone(d.get('missing'))
|
|
|
self.assertEqual(list(d), ['c', 'b', 'a'])
|
|
|
|
|
|
self.assertEqual(d.get('a'), 'va')
|
|
|
self.assertEqual(list(d), ['a', 'c', 'b'])
|
|
|
|
|
|
def testcopypartial(self):
|
|
|
d = util.lrucachedict(4)
|
|
|
d.insert('a', 'va', cost=4)
|
|
|
d.insert('b', 'vb', cost=2)
|
|
|
|
|
|
dc = d.copy()
|
|
|
|
|
|
self.assertEqual(len(dc), 2)
|
|
|
self.assertEqual(dc.totalcost, 6)
|
|
|
for key in ('a', 'b'):
|
|
|
self.assertIn(key, dc)
|
|
|
self.assertEqual(dc[key], 'v%s' % key)
|
|
|
|
|
|
self.assertEqual(len(d), 2)
|
|
|
for key in ('a', 'b'):
|
|
|
self.assertIn(key, d)
|
|
|
self.assertEqual(d[key], 'v%s' % key)
|
|
|
|
|
|
d['c'] = 'vc'
|
|
|
del d['b']
|
|
|
self.assertEqual(d.totalcost, 4)
|
|
|
dc = d.copy()
|
|
|
self.assertEqual(len(dc), 2)
|
|
|
self.assertEqual(dc.totalcost, 4)
|
|
|
for key in ('a', 'c'):
|
|
|
self.assertIn(key, dc)
|
|
|
self.assertEqual(dc[key], 'v%s' % key)
|
|
|
|
|
|
def testcopyempty(self):
|
|
|
d = util.lrucachedict(4)
|
|
|
dc = d.copy()
|
|
|
self.assertEqual(len(dc), 0)
|
|
|
|
|
|
def testcopyfull(self):
|
|
|
d = util.lrucachedict(4)
|
|
|
d.insert('a', 'va', cost=42)
|
|
|
d['b'] = 'vb'
|
|
|
d['c'] = 'vc'
|
|
|
d['d'] = 'vd'
|
|
|
|
|
|
dc = d.copy()
|
|
|
|
|
|
for key in ('a', 'b', 'c', 'd'):
|
|
|
self.assertIn(key, dc)
|
|
|
self.assertEqual(dc[key], 'v%s' % key)
|
|
|
|
|
|
self.assertEqual(d.totalcost, 42)
|
|
|
self.assertEqual(dc.totalcost, 42)
|
|
|
|
|
|
# 'a' should be dropped because it was least recently used.
|
|
|
dc['e'] = 've'
|
|
|
self.assertNotIn('a', dc)
|
|
|
for key in ('b', 'c', 'd', 'e'):
|
|
|
self.assertIn(key, dc)
|
|
|
self.assertEqual(dc[key], 'v%s' % key)
|
|
|
|
|
|
self.assertEqual(d.totalcost, 42)
|
|
|
self.assertEqual(dc.totalcost, 0)
|
|
|
|
|
|
# Contents and order of original dict should remain unchanged.
|
|
|
dc['b'] = 'vb_new'
|
|
|
|
|
|
self.assertEqual(list(iter(d)), ['d', 'c', 'b', 'a'])
|
|
|
for key in ('a', 'b', 'c', 'd'):
|
|
|
self.assertEqual(d[key], 'v%s' % key)
|
|
|
|
|
|
d = util.lrucachedict(4, maxcost=42)
|
|
|
d.insert('a', 'va', cost=5)
|
|
|
d.insert('b', 'vb', cost=4)
|
|
|
d.insert('c', 'vc', cost=3)
|
|
|
dc = d.copy()
|
|
|
self.assertEqual(dc.maxcost, 42)
|
|
|
self.assertEqual(len(dc), 3)
|
|
|
|
|
|
# Max cost can be lowered as part of copy.
|
|
|
dc = d.copy(maxcost=10)
|
|
|
self.assertEqual(dc.maxcost, 10)
|
|
|
self.assertEqual(len(dc), 2)
|
|
|
self.assertEqual(dc.totalcost, 7)
|
|
|
self.assertIn('b', dc)
|
|
|
self.assertIn('c', dc)
|
|
|
|
|
|
def testcopydecreasecapacity(self):
|
|
|
d = util.lrucachedict(5)
|
|
|
d.insert('a', 'va', cost=4)
|
|
|
d.insert('b', 'vb', cost=2)
|
|
|
d['c'] = 'vc'
|
|
|
d['d'] = 'vd'
|
|
|
|
|
|
dc = d.copy(2)
|
|
|
self.assertEqual(dc.totalcost, 0)
|
|
|
for key in ('a', 'b'):
|
|
|
self.assertNotIn(key, dc)
|
|
|
for key in ('c', 'd'):
|
|
|
self.assertIn(key, dc)
|
|
|
self.assertEqual(dc[key], 'v%s' % key)
|
|
|
|
|
|
dc.insert('e', 've', cost=7)
|
|
|
self.assertEqual(dc.totalcost, 7)
|
|
|
self.assertNotIn('c', dc)
|
|
|
for key in ('d', 'e'):
|
|
|
self.assertIn(key, dc)
|
|
|
self.assertEqual(dc[key], 'v%s' % key)
|
|
|
|
|
|
# Original should remain unchanged.
|
|
|
self.assertEqual(d.totalcost, 6)
|
|
|
for key in ('a', 'b', 'c', 'd'):
|
|
|
self.assertIn(key, d)
|
|
|
self.assertEqual(d[key], 'v%s' % key)
|
|
|
|
|
|
def testcopyincreasecapacity(self):
|
|
|
d = util.lrucachedict(5)
|
|
|
d['a'] = 'va'
|
|
|
d['b'] = 'vb'
|
|
|
d['c'] = 'vc'
|
|
|
d['d'] = 'vd'
|
|
|
|
|
|
dc = d.copy(6)
|
|
|
for key in ('a', 'b', 'c', 'd'):
|
|
|
self.assertIn(key, dc)
|
|
|
self.assertEqual(dc[key], 'v%s' % key)
|
|
|
|
|
|
dc['e'] = 've'
|
|
|
dc['f'] = 'vf'
|
|
|
for key in ('a', 'b', 'c', 'd', 'e', 'f'):
|
|
|
self.assertIn(key, dc)
|
|
|
self.assertEqual(dc[key], 'v%s' % key)
|
|
|
|
|
|
dc['g'] = 'vg'
|
|
|
self.assertNotIn('a', dc)
|
|
|
for key in ('b', 'c', 'd', 'e', 'f', 'g'):
|
|
|
self.assertIn(key, dc)
|
|
|
self.assertEqual(dc[key], 'v%s' % key)
|
|
|
|
|
|
# Original should remain unchanged.
|
|
|
for key in ('a', 'b', 'c', 'd'):
|
|
|
self.assertIn(key, d)
|
|
|
self.assertEqual(d[key], 'v%s' % key)
|
|
|
|
|
|
def testpopoldest(self):
|
|
|
d = util.lrucachedict(4)
|
|
|
d.insert('a', 'va', cost=10)
|
|
|
d.insert('b', 'vb', cost=5)
|
|
|
|
|
|
self.assertEqual(len(d), 2)
|
|
|
self.assertEqual(d.popoldest(), ('a', 'va'))
|
|
|
self.assertEqual(len(d), 1)
|
|
|
self.assertEqual(d.totalcost, 5)
|
|
|
self.assertEqual(d.popoldest(), ('b', 'vb'))
|
|
|
self.assertEqual(len(d), 0)
|
|
|
self.assertEqual(d.totalcost, 0)
|
|
|
self.assertIsNone(d.popoldest())
|
|
|
|
|
|
d['a'] = 'va'
|
|
|
d['b'] = 'vb'
|
|
|
d['c'] = 'vc'
|
|
|
d['d'] = 'vd'
|
|
|
|
|
|
self.assertEqual(d.popoldest(), ('a', 'va'))
|
|
|
self.assertEqual(len(d), 3)
|
|
|
for key in ('b', 'c', 'd'):
|
|
|
self.assertEqual(d[key], 'v%s' % key)
|
|
|
|
|
|
d['a'] = 'va'
|
|
|
self.assertEqual(d.popoldest(), ('b', 'vb'))
|
|
|
|
|
|
def testmaxcost(self):
|
|
|
# Item cost is zero by default.
|
|
|
d = util.lrucachedict(6, maxcost=10)
|
|
|
d['a'] = 'va'
|
|
|
d['b'] = 'vb'
|
|
|
d['c'] = 'vc'
|
|
|
d['d'] = 'vd'
|
|
|
self.assertEqual(len(d), 4)
|
|
|
self.assertEqual(d.totalcost, 0)
|
|
|
|
|
|
d.clear()
|
|
|
|
|
|
# Insertion to exact cost threshold works without eviction.
|
|
|
d.insert('a', 'va', cost=6)
|
|
|
d.insert('b', 'vb', cost=4)
|
|
|
|
|
|
self.assertEqual(len(d), 2)
|
|
|
self.assertEqual(d['a'], 'va')
|
|
|
self.assertEqual(d['b'], 'vb')
|
|
|
|
|
|
# Inserting a new element with 0 cost works.
|
|
|
d['c'] = 'vc'
|
|
|
self.assertEqual(len(d), 3)
|
|
|
|
|
|
# Inserting a new element with cost putting us above high
|
|
|
# water mark evicts oldest single item.
|
|
|
d.insert('d', 'vd', cost=1)
|
|
|
self.assertEqual(len(d), 3)
|
|
|
self.assertEqual(d.totalcost, 5)
|
|
|
self.assertNotIn('a', d)
|
|
|
for key in ('b', 'c', 'd'):
|
|
|
self.assertEqual(d[key], 'v%s' % key)
|
|
|
|
|
|
# Inserting a new element with enough room for just itself
|
|
|
# evicts all items before.
|
|
|
d.insert('e', 've', cost=10)
|
|
|
self.assertEqual(len(d), 1)
|
|
|
self.assertEqual(d.totalcost, 10)
|
|
|
self.assertIn('e', d)
|
|
|
|
|
|
# Inserting a new element with cost greater than threshold
|
|
|
# still retains that item.
|
|
|
d.insert('f', 'vf', cost=11)
|
|
|
self.assertEqual(len(d), 1)
|
|
|
self.assertEqual(d.totalcost, 11)
|
|
|
self.assertIn('f', d)
|
|
|
|
|
|
# Inserting a new element will evict the last item since it is
|
|
|
# too large.
|
|
|
d['g'] = 'vg'
|
|
|
self.assertEqual(len(d), 1)
|
|
|
self.assertEqual(d.totalcost, 0)
|
|
|
self.assertIn('g', d)
|
|
|
|
|
|
d.clear()
|
|
|
|
|
|
d.insert('a', 'va', cost=7)
|
|
|
d.insert('b', 'vb', cost=3)
|
|
|
self.assertEqual(len(d), 2)
|
|
|
|
|
|
# Replacing a value with smaller cost won't result in eviction.
|
|
|
d.insert('b', 'vb2', cost=2)
|
|
|
self.assertEqual(len(d), 2)
|
|
|
|
|
|
# Replacing a value with a higher cost will evict when threshold
|
|
|
# exceeded.
|
|
|
d.insert('b', 'vb3', cost=4)
|
|
|
self.assertEqual(len(d), 1)
|
|
|
self.assertNotIn('a', d)
|
|
|
|
|
|
def testmaxcostcomplex(self):
|
|
|
d = util.lrucachedict(100, maxcost=100)
|
|
|
d.insert('a', 'va', cost=9)
|
|
|
d.insert('b', 'vb', cost=21)
|
|
|
d.insert('c', 'vc', cost=7)
|
|
|
d.insert('d', 'vc', cost=50)
|
|
|
self.assertEqual(d.totalcost, 87)
|
|
|
|
|
|
# Inserting new element should free multiple elements so we hit
|
|
|
# low water mark.
|
|
|
d.insert('e', 'vd', cost=25)
|
|
|
self.assertEqual(len(d), 2)
|
|
|
self.assertNotIn('a', d)
|
|
|
self.assertNotIn('b', d)
|
|
|
self.assertNotIn('c', d)
|
|
|
self.assertIn('d', d)
|
|
|
self.assertIn('e', d)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
silenttestrunner.main(__name__)
|
|
|
|
