ebml/tests/test_core.py

   1 import unittest
   2 try:
   3         from cStringIO import StringIO
   4 except ImportError:
   5         from StringIO import StringIO
   6 from random import randint
   7 from ..core import *
   8
   9
  10 class ElementSizeTests(unittest.TestCase):
  11         def assert_roundtrip(self, value, length=None):
  12                 encoded = encode_element_size(value, length=length)
  13                 encoded_stream = StringIO(encoded)
  14                 self.assertEqual(value, read_element_size(encoded_stream)[0])
  15
  16         def test_unknown(self):
  17                 for length in xrange(1, 9):
  18                         self.assert_roundtrip(None, length=length)
  19
  20         def test_base_10(self):
  21                 for value in (10**exp for exp in xrange(1, 16)):
  22                         self.assert_roundtrip(value)
  23
  24         def test_base_2(self):
  25                 for value in (2**exp for exp in xrange(1, 56)):
  26                         self.assert_roundtrip(value)
  27
  28         def test_max_base_2(self):
  29                 for value in ((2**exp) - 2 for exp in xrange(1, 57)):
  30                         self.assert_roundtrip(value)
  31
  32         def test_random(self):
  33                 maximum = 2**56 - 2
  34                 for value in (randint(0, maximum) for i in xrange(0, 200)):
  35                         self.assert_roundtrip(value)
  36
  37
  38 class ElementIDTests(unittest.TestCase):
  39         ebml_ids = (
  40                 0x1a45dfa3,
  41                 0x4286,
  42                 0x42f7,
  43                 0x42f2,
  44                 0x42f3,
  45                 0x4282,
  46                 0x4287,
  47                 0x4285,
  48                 0xbf,
  49                 0xec
  50         )
  51
  52         def assert_roundtrip(self, value):
  53                 encoded = encode_element_id(value)
  54                 encoded_stream = StringIO(encoded)
  55                 self.assertEqual(value, read_element_id(encoded_stream)[0])
  56
  57         def test_ebml_ids(self):
  58                 for id_ in self.ebml_ids:
  59                         self.assert_roundtrip(id_)
  60
  61
  62 class ValueTestCase(unittest.TestCase):
  63         encoder = None
  64         reader = None
  65
  66         def assert_roundtrip(self, value):
  67                 if self.encoder is not None and self.reader is not None:
  68                         encoded = self.encoder(value)
  69                         encoded_stream = StringIO(encoded)
  70                         self.assertEqual(value, self.reader(encoded_stream, len(encoded)))
  71                 else:
  72                         raise NotImplementedError
  73
  74
  75 class UnsignedIntegerTests(ValueTestCase):
  76         encoder = staticmethod(encode_unsigned_integer)
  77         reader = staticmethod(read_unsigned_integer)
  78         maximum = 2**64 - 1
  79
  80         def test_random(self):
  81                 for value in (randint(0, self.maximum) for i in xrange(0, 10000)):
  82                         self.assert_roundtrip(value)
  83
  84         def test_maximum(self):
  85                 self.assert_roundtrip(self.maximum)
  86
  87
  88 class SignedIntegerTests(ValueTestCase):
  89         encoder = staticmethod(encode_signed_integer)
  90         reader = staticmethod(read_signed_integer)
  91         minimum = -(2**63)
  92         maximum = (2**63) - 1
  93
  94         def test_random(self):
  95                 for value in (randint(self.minimum, self.maximum) for i in xrange(0, 10000)):
  96                         self.assert_roundtrip(value)
  97
  98         def test_minimum(self):
  99                 self.assert_roundtrip(self.minimum)
 100
 101         def test_maximum(self):
 102                 self.assert_roundtrip(self.maximum)
 103
 104
 105 if __name__ == '__main__':
 106         unittest.main()