Exemplo n.º 1
0
 def setUp(self):
     self.treeset = LLTreeSet()
     self.k0 = long(1)
     self.treeset.insert(self.k0)
     self.k1 = long((time.time() - 3600 * 25) * 1e6)
     self.treeset.insert(self.k1)
     self.k2 = long((time.time() - 3600 * 4) * 1e6)
     self.treeset.insert(self.k2)
     self.k3 = long((time.time() - 3600 * 3) * 1e6)
     self.treeset.insert(self.k3)
     self.k10 = long(time.time() * 1e6 - 10)
     self.treeset.insert(self.k10)
     self.k11 = self.k10 + 1
     self.treeset.insert(self.k11)
 def setUp(self):
     self.treeset = LLTreeSet()
     self.k0 = long(1)
     self.treeset.insert(self.k0)
     self.k1 = long((time.time() - 3700) * 1e6)
     self.treeset.insert(self.k1)
     self.k2 = self.k1 + 1
     self.treeset.insert(self.k2)
     self.k3 = self.k2 + 1
     self.treeset.insert(self.k3)
     self.k10 = long(time.time() * 1e6 - 10)
     self.treeset.insert(self.k10)
     self.k11 = self.k10 + 1
     self.treeset.insert(self.k11)
Exemplo n.º 3
0
 def setUp(self):
     self.treeset = LLTreeSet()
     for id in replay_ids:
         self.treeset.insert(id)
Exemplo n.º 4
0
class TestLongkeysortreverse2(unittest.TestCase):
    """Replay real-life problem"""
    def setUp(self):
        self.treeset = LLTreeSet()
        for id in replay_ids:
            self.treeset.insert(id)

    def test_replay_ids(self):
        self.assertEquals(replay_ids, sorted(replay_ids))

    def test_all2(self):
        got = sorted(longkeysortreverse(self.treeset, None, None, None))
        expect = replay_ids
        self.assertEquals(len(got), len(expect))
        self.assertEquals(got, expect)

    def test_minv(self):
        minv = 1465289825265391
        got = sorted(longkeysortreverse(self.treeset, minv, None, None))
        expect = [x for x in replay_ids if minv <= x]
        self.assertEquals(len(got), len(expect))
        self.assertEquals(got, expect)

    def test_maxv(self):
        maxv = 1465894624580543
        got = sorted(longkeysortreverse(self.treeset, None, maxv, None))
        expect = [x for x in replay_ids if x <= maxv]
        self.assertEquals(len(got), len(expect))
        self.assertEquals(got, expect)

    def test_limit_20(self):
        got = sorted(longkeysortreverse(self.treeset, None, None, 20))
        expect = replay_ids[-20:]
        self.assertEquals(len(got), len(expect))
        self.assertEquals(got, expect)

    def test_limit_50(self):
        got = sorted(longkeysortreverse(self.treeset, None, None, 50))
        expect = replay_ids[-50:]
        self.assertEquals(len(got), len(expect))
        self.assertEquals(got, expect)

    def test_minv_maxv(self):
        minv = 1465289825265391
        maxv = 1465894624580543
        got = sorted(longkeysortreverse(self.treeset, minv, maxv, None))
        expect = [x for x in replay_ids if minv <= x <= maxv]
        self.assertEquals(len(got), len(expect))
        self.assertEquals(got, expect)

    def test_minv_limit(self):
        minv = 1465289825265391
        got = sorted(longkeysortreverse(self.treeset, minv, None, 20))
        expect = [x for x in replay_ids if minv <= x][-20:]
        self.assertEquals(len(got), len(expect))
        self.assertEquals(got, expect)

    def test_maxv_limit(self):
        maxv = 1465894624580543
        got = sorted(longkeysortreverse(self.treeset, None, maxv, 20))
        expect = [x for x in replay_ids if x <= maxv][-20:]
        self.assertEquals(len(got), len(expect))
        self.assertEquals(got, expect)

    def test_minv_maxv_limit(self):
        minv = 1465289825265391
        maxv = 1465894624580543
        got = sorted(longkeysortreverse(self.treeset, minv, maxv, 10))
        expect = [x for x in replay_ids if minv <= x <= maxv][-10:]
        self.assertEquals(len(got), len(expect))
        self.assertEquals(got, expect)
Exemplo n.º 5
0
class TestLongkeysortreverse1(unittest.TestCase):
    def setUp(self):
        self.treeset = LLTreeSet()
        self.k0 = long(1)
        self.treeset.insert(self.k0)
        self.k1 = long((time.time() - 3600 * 25) * 1e6)
        self.treeset.insert(self.k1)
        self.k2 = long((time.time() - 3600 * 4) * 1e6)
        self.treeset.insert(self.k2)
        self.k3 = long((time.time() - 3600 * 3) * 1e6)
        self.treeset.insert(self.k3)
        self.k10 = long(time.time() * 1e6 - 10)
        self.treeset.insert(self.k10)
        self.k11 = self.k10 + 1
        self.treeset.insert(self.k11)

    def test_all(self):
        values = list(longkeysortreverse(self.treeset))
        expect = [self.k11, self.k10, self.k3, self.k2, self.k1, self.k0]
        self.assertEquals(values, expect)

    def test_min_hour(self):
        minv = long((time.time() - 3600) * 1e6)
        values = list(longkeysortreverse(self.treeset, minv=minv))
        expect = [self.k11, self.k10]
        self.assertEquals(values, expect)

    def test_max_hour_direct(self):
        maxv = long((time.time() - 3600) * 1e6)
        values = list(longkeysortreverse(self.treeset, maxv=maxv))
        expect = [self.k3, self.k2, self.k1, self.k0]
        self.assertEquals(values, expect)

    def test_max_hour2_direct(self):
        maxv = long((time.time() - 3600 * 2) * 1e6)
        values = list(longkeysortreverse(self.treeset, maxv=maxv))
        expect = [self.k3, self.k2, self.k1, self.k0]
        self.assertEquals(values, expect)

    def test_max_hour_optimize(self):
        maxv = long((time.time() - 3600) * 1e6)
        values = list(longkeysortreverse(self.treeset, maxv=maxv, limit=100))
        expect = [self.k3, self.k2, self.k1, self.k0]
        self.assertEquals(values, expect)

    def test_max_hour2_optimize(self):
        maxv = long((time.time() - 3600 * 2) * 1e6)
        values = list(longkeysortreverse(self.treeset, maxv=maxv, limit=100))
        expect = [self.k3, self.k2, self.k1, self.k0]
        self.assertEquals(values, expect)

    def test_min_day(self):
        minv = long((time.time() - 3600 * 24) * 1e6)
        values = list(longkeysortreverse(self.treeset, minv=minv))
        expect = [self.k11, self.k10, self.k3, self.k2]
        self.assertEquals(values, expect)

    def test_max_day_direct(self):
        maxv = long((time.time() - 3600 * 24) * 1e6)
        values = list(longkeysortreverse(self.treeset, maxv=maxv))
        expect = [self.k1, self.k0]
        self.assertEquals(values, expect)

    def test_max_day_optimize(self):
        maxv = long((time.time() - 3600 * 24) * 1e6)
        values = list(longkeysortreverse(self.treeset, maxv=maxv, limit=100))
        expect = [self.k1, self.k0]
        self.assertEquals(values, expect)

    def test_min_day_max_hour(self):
        maxv = long((time.time() - 3600) * 1e6)
        minv = long((time.time() - 3600 * 24) * 1e6)
        values = list(longkeysortreverse(self.treeset, minv=minv, maxv=maxv))
        expect = [self.k3, self.k2]
        self.assertEquals(values, expect)

    def test_all_limit(self):
        values = list(longkeysortreverse(self.treeset, limit=3))
        expect = [self.k11, self.k10, self.k3]
        self.assertEquals(values, expect)

    def test_min_day_max_hour_limit(self):
        maxv = long((time.time() - 3600) * 1e6)
        minv = long((time.time() - 3600 * 24) * 1e6)
        values = list(
            longkeysortreverse(self.treeset, minv=minv, maxv=maxv, limit=1))
        expect = [self.k3]
        self.assertEquals(values, expect)
Exemplo n.º 6
0
class TestLongkeysortreverse(unittest.TestCase):

    def setUp(self):
        self.treeset = LLTreeSet()
        self.k0 = long(1)
        self.treeset.insert(self.k0)
        self.k1 = long((time.time() - 3700) * 1e6)
        self.treeset.insert(self.k1)
        self.k2 = self.k1 + 1
        self.treeset.insert(self.k2)
        self.k3 = self.k2 + 1
        self.treeset.insert(self.k3)
        self.k10 = long(time.time() * 1e6 - 10)
        self.treeset.insert(self.k10)
        self.k11 = self.k10 + 1
        self.treeset.insert(self.k11)

    def test_all(self):
        values = list(longkeysortreverse(self.treeset))
        expect = [self.k11, self.k10, self.k3, self.k2, self.k1, self.k0]
        self.assertEquals(values, expect)

    def test_min_hour(self):
        minv = long((time.time() - 3600) * 1e6)
        values = list(longkeysortreverse(self.treeset, minv=minv))
        expect = [self.k11, self.k10]
        self.assertEquals(values, expect)

    def test_max_hour(self):
        maxv = long((time.time() - 3600) * 1e6)
        values = list(longkeysortreverse(self.treeset, maxv=maxv))
        expect = [self.k3, self.k2, self.k1, self.k0]
        self.assertEquals(values, expect)

    def test_min_day(self):
        minv = long((time.time() - 3600 * 24) * 1e6)
        values = list(longkeysortreverse(self.treeset, minv=minv))
        expect = [self.k11, self.k10, self.k3, self.k2, self.k1]
        self.assertEquals(values, expect)

    def test_max_day(self):
        maxv = long((time.time() - 3600 * 24) * 1e6)
        values = list(longkeysortreverse(self.treeset, maxv=maxv))
        expect = [self.k0]
        self.assertEquals(values, expect)

    def test_min_day_max_hour(self):
        maxv = long((time.time() - 3600) * 1e6)
        minv = long((time.time() - 3600 * 24) * 1e6)
        values = list(longkeysortreverse(self.treeset,
                                         minv=minv,
                                         maxv=maxv))
        expect = [self.k3, self.k2, self.k1]
        self.assertEquals(values, expect)

    def test_all_limit(self):
        values = list(longkeysortreverse(self.treeset, limit=3))
        expect = [self.k11, self.k10, self.k3]
        self.assertEquals(values, expect)

    def test_min_day_max_hour_limit(self):
        maxv = long((time.time() - 3600) * 1e6)
        minv = long((time.time() - 3600 * 24) * 1e6)
        values = list(longkeysortreverse(self.treeset,
                                         minv=minv,
                                         maxv=maxv,
                                         limit=1))
        expect = [self.k3]
        self.assertEquals(values, expect)
Exemplo n.º 7
0
 def _makeOne(self):
     from BTrees.LLBTree import LLTreeSet
     return LLTreeSet()