def testIterReverseMiddle(self):
     self.e.put('a', '')
     self.e.put('b', '')
     self.e.put('d', '')
     self.e.put('e', '')
     eq(strize(self.e.iter('c', True)),
        [('d', ''), ('b', ''), ('a', '')])

 def do_test(self, k):
     packed = keylib.packs(k)
     try:
         unpacked = keylib.unpack(packed)
         eq(k, keylib.unpack(keylib.packs(k)))
     except:
         print 'failing enc was: %r' % (packed,)
         raise

 def test_delete_pop(self):
     self.insert_items()
     self.coll.strategy.batch(max_recs=len(self.ITEMS))
     # Pop should trigger split of batch and return of old value.
     data = self.coll.strategy.pop(self.txn.get(), keylib.Key(3))
     eq(data, '"jim"')
     # Should now contain metadata + 2 remaining records.
     assert len(self.e.items) == (self.old_len + 2)

 def test1(self):
     for i in self.INTS:
         s = keylib.packs(i)
         try:
             j, = keylib.unpack(s)
             eq(j, i)
         except:
             print [i, s]
             raise

    def test_pos(self):
        tz = dateutil.tz.gettz('Etc/GMT+1')
        dt = datetime.now(tz)
        sn = _keylib.packs(dt)
        sp = keylib.packs(dt)
        eq(sn, sp)

        dn = _keylib.unpacks(sn)
        dp = keylib.unpacks(sp)
        eq(dn, dp)

 def testGetExist(self):
     key = self.coll.put(u'')
     eq(key, (1,))
     eq('', self.coll.get(1))
     key = self.coll.put(u'x')
     eq(key, (2,))
     eq(u'x', self.coll.get(2))

 def testReverseAutoInclude(self):
     eq(self.REVERSE, self.riter('de'))

 def testForwardSkipMostExist(self):
     eq([([('de',),], '')], self.iter('de'))

 def testForwardSeekBeyondNoExist(self):
     eq([], self.iter('df'))

 def testForwardSeekNoExist(self):
     eq(self.ITEMS[1:], self.iter('b'))

 def testForwardSeekExist(self):
     eq(self.ITEMS[1:], self.iter('cc'))

 def testIterKeys(self):
     eq([self.key, self.key2], list(self.i.keys()))
     eq([self.key2, self.key], list(self.i.keys(reverse=True)))

 def testForwardSeekFirst(self):
     eq(self.ITEMS, self.iter('aa'))

 def testReverseSeekNoExistInclude(self):
     eq(self.REVERSE[1:], self.riter('ddd'))

    def testIterPairs(self):
        eq(self.both, list(self.i.pairs()))
        eq(self.both, list(self.i.pairs(lo=68)))
        eq(self.both, list(self.i.pairs(lo=(69, u'dave'))))
        eq(self.second, list(self.i.pairs(lo=(69, u'dave2'))))
        eq([], list(self.i.pairs(lo=80)))

        eq(self.both[::-1], list(self.i.pairs(reverse=True)))

        self.coll.delete(self.key)
        eq(self.second, list(self.i.pairs()))
        self.coll.delete(self.key2)
        eq([], list(self.i.pairs()))

 def testGet(self):
     eq(None, self.i.get('missing'))
     eq(u'dave', self.i.get((69, u'dave')))
     eq(u'dave2', self.i.get((69, u'dave2')))

 def testReverseSeekExistInclude(self):
     eq(self.REVERSE[1:], self.riter(hi='dd', include=True))

 def testFind(self):
     eq(u'dave', self.i.find())
     eq(u'dave2', self.i.find(reverse=True))
     eq(u'dave2', self.i.find((69, u'dave2')))
     # open
     eq(u'dave', self.i.find(hi=(69, u'dave2'), reverse=True))

 def testIterValues(self):
     eq([u'dave', u'dave2'], list(self.i.values()))
     eq([u'dave2', u'dave'], list(self.i.values(reverse=True)))

 def testIterItems(self):
     item1 = (self.key, u'dave')
     item2 = (self.key2, u'dave2')
     eq([item1, item2], list(self.i.items()))
     eq([item2, item1], list(self.i.items(reverse=True)))