test/unittest_utils.py
changeset 10609 e2d8e81bfe68
parent 10600 180aa08cad48
child 10933 830f1ea52789
equal deleted inserted replaced
10608:7fc548d9dd8e 10609:e2d8e81bfe68
    19 
    19 
    20 import re
    20 import re
    21 import decimal
    21 import decimal
    22 import datetime
    22 import datetime
    23 
    23 
       
    24 from six.moves import range
    24 
    25 
    25 from logilab.common.testlib import TestCase, DocTest, unittest_main
    26 from logilab.common.testlib import TestCase, DocTest, unittest_main
    26 
    27 
    27 from cubicweb.devtools.testlib import CubicWebTC
    28 from cubicweb.devtools.testlib import CubicWebTC
    28 from cubicweb.utils import (make_uid, UStringIO, SizeConstrainedList,
    29 from cubicweb.utils import (make_uid, UStringIO, SizeConstrainedList,
    65 
    66 
    66 class TestQueryCache(TestCase):
    67 class TestQueryCache(TestCase):
    67     def test_querycache(self):
    68     def test_querycache(self):
    68         c = QueryCache(ceiling=20)
    69         c = QueryCache(ceiling=20)
    69         # write only
    70         # write only
    70         for x in xrange(10):
    71         for x in range(10):
    71             c[x] = x
    72             c[x] = x
    72         self.assertEqual(c._usage_report(),
    73         self.assertEqual(c._usage_report(),
    73                          {'transientcount': 0,
    74                          {'transientcount': 0,
    74                           'itemcount': 10,
    75                           'itemcount': 10,
    75                           'permanentcount': 0})
    76                           'permanentcount': 0})
    76         c = QueryCache(ceiling=10)
    77         c = QueryCache(ceiling=10)
    77         # we should also get a warning
    78         # we should also get a warning
    78         for x in xrange(20):
    79         for x in range(20):
    79             c[x] = x
    80             c[x] = x
    80         self.assertEqual(c._usage_report(),
    81         self.assertEqual(c._usage_report(),
    81                          {'transientcount': 0,
    82                          {'transientcount': 0,
    82                           'itemcount': 10,
    83                           'itemcount': 10,
    83                           'permanentcount': 0})
    84                           'permanentcount': 0})
    84         # write + reads
    85         # write + reads
    85         c = QueryCache(ceiling=20)
    86         c = QueryCache(ceiling=20)
    86         for n in xrange(4):
    87         for n in range(4):
    87             for x in xrange(10):
    88             for x in range(10):
    88                 c[x] = x
    89                 c[x] = x
    89                 c[x]
    90                 c[x]
    90         self.assertEqual(c._usage_report(),
    91         self.assertEqual(c._usage_report(),
    91                          {'transientcount': 10,
    92                          {'transientcount': 10,
    92                           'itemcount': 10,
    93                           'itemcount': 10,
    93                           'permanentcount': 0})
    94                           'permanentcount': 0})
    94         c = QueryCache(ceiling=20)
    95         c = QueryCache(ceiling=20)
    95         for n in xrange(17):
    96         for n in range(17):
    96             for x in xrange(10):
    97             for x in range(10):
    97                 c[x] = x
    98                 c[x] = x
    98                 c[x]
    99                 c[x]
    99         self.assertEqual(c._usage_report(),
   100         self.assertEqual(c._usage_report(),
   100                          {'transientcount': 0,
   101                          {'transientcount': 0,
   101                           'itemcount': 10,
   102                           'itemcount': 10,
   102                           'permanentcount': 10})
   103                           'permanentcount': 10})
   103         c = QueryCache(ceiling=20)
   104         c = QueryCache(ceiling=20)
   104         for n in xrange(17):
   105         for n in range(17):
   105             for x in xrange(10):
   106             for x in range(10):
   106                 c[x] = x
   107                 c[x] = x
   107                 if n % 2:
   108                 if n % 2:
   108                     c[x]
   109                     c[x]
   109                 if x % 2:
   110                 if x % 2:
   110                     c[x]
   111                     c[x]
   167 
   168 
   168 class SizeConstrainedListTC(TestCase):
   169 class SizeConstrainedListTC(TestCase):
   169 
   170 
   170     def test_append(self):
   171     def test_append(self):
   171         l = SizeConstrainedList(10)
   172         l = SizeConstrainedList(10)
   172         for i in xrange(12):
   173         for i in range(12):
   173             l.append(i)
   174             l.append(i)
   174         self.assertEqual(l, range(2, 12))
   175         self.assertEqual(l, list(range(2, 12)))
   175 
   176 
   176     def test_extend(self):
   177     def test_extend(self):
   177         testdata = [(range(5), range(5)),
   178         testdata = [(list(range(5)), list(range(5))),
   178                     (range(10), range(10)),
   179                     (list(range(10)), list(range(10))),
   179                     (range(12), range(2, 12)),
   180                     (list(range(12)), list(range(2, 12))),
   180                     ]
   181                     ]
   181         for extension, expected in testdata:
   182         for extension, expected in testdata:
   182             l = SizeConstrainedList(10)
   183             l = SizeConstrainedList(10)
   183             l.extend(extension)
   184             l.extend(extension)
   184             yield self.assertEqual, l, expected
   185             yield self.assertEqual, l, expected