code.kerkeslager.com Git - ton/blob - test_string.py

   1 import collections
   2 import unittest
   3
   4 from don import string, tags
   5
   6 class TestStringSerialize(unittest.TestCase):
   7     def test_serializes_null(self):
   8         self.assertEqual(string.serialize(None), 'null')
   9
  10     def test_serializes_true(self):
  11         self.assertEqual(string.serialize(True), 'true')
  12
  13     def test_serializes_false(self):
  14         self.assertEqual(string.serialize(False), 'false')
  15
  16     def test_serializes_int8(self):
  17         self.assertEqual(string.serialize(tags.TaggedObject(tags.INT8, 1)), '1i8')
  18         self.assertEqual(string.serialize(tags.TaggedObject(tags.INT8, -1)), '-1i8')
  19         self.assertEqual(string.serialize(tags.TaggedObject(tags.INT8, 42)), '42i8')
  20
  21     def test_serializes_int16(self):
  22         self.assertEqual(string.serialize(tags.TaggedObject(tags.INT16, 1)), '1i16')
  23         self.assertEqual(string.serialize(tags.TaggedObject(tags.INT16, -1)), '-1i16')
  24         self.assertEqual(string.serialize(tags.TaggedObject(tags.INT16, 42)), '42i16')
  25
  26     def test_serializes_int32(self):
  27         self.assertEqual(string.serialize(tags.TaggedObject(tags.INT32, 1)), '1i32')
  28         self.assertEqual(string.serialize(tags.TaggedObject(tags.INT32, -1)), '-1i32')
  29         self.assertEqual(string.serialize(tags.TaggedObject(tags.INT32, 42)), '42i32')
  30
  31     def test_serializes_int64(self):
  32         self.assertEqual(string.serialize(tags.TaggedObject(tags.INT64, 1)), '1i64')
  33         self.assertEqual(string.serialize(tags.TaggedObject(tags.INT64, -1)), '-1i64')
  34         self.assertEqual(string.serialize(tags.TaggedObject(tags.INT64, 42)), '42i64')
  35
  36     def test_serializes_float(self):
  37         self.assertEqual(string.serialize(tags.TaggedObject(tags.FLOAT, 1.0)), '1.0f')
  38
  39     def test_serializes_double(self):
  40         self.assertEqual(string.serialize(tags.TaggedObject(tags.DOUBLE, 1.0)), '1.0d')
  41
  42     def test_serializes_binary(self):
  43         self.assertEqual(string.serialize(tags.TaggedObject(tags.BINARY, b'\xde\xad\xbe\xef')), '"deadbeef"b')
  44
  45     def test_serializes_utf8(self):
  46         self.assertEqual(string.serialize(tags.TaggedObject(tags.UTF8, 'Hello, world')), '"Hello, world"utf8')
  47
  48     def test_serializes_utf16(self):
  49         self.assertEqual(string.serialize(tags.TaggedObject(tags.UTF16, 'Hello, world')), '"Hello, world"utf16')
  50
  51     def test_serializes_utf32(self):
  52         self.assertEqual(string.serialize(tags.TaggedObject(tags.UTF32, 'Hello, world')), '"Hello, world"utf32')
  53
  54     def test_serializes_list(self):
  55         self.assertEqual(string.serialize(tags.TaggedObject(tags.LIST, [1,2,3])), '[1i32, 2i32, 3i32]')
  56
  57     def test_serializes_dictionary(self):
  58         self.assertEqual(
  59             string.serialize(tags.TaggedObject(tags.DICTIONARY, collections.OrderedDict([
  60                 ('foo', 1),
  61                 ('bar', 'baz'),
  62             ]))),
  63             '{ "foo"utf8: 1i32, "bar"utf8: "baz"utf8 }'
  64         )
  65
  66 class TestStringDeserialize(unittest.TestCase):
  67     def test_deserializes_null(self):
  68         self.assertEqual(
  69             None,
  70             string.deserialize('null'),
  71         )
  72
  73     def test_deserializes_null_with_leading_whitespace(self):
  74         self.assertEqual(
  75             None,
  76             string.deserialize(' \t\nnull'),
  77         )
  78
  79     def test_deserializes_true(self):
  80         self.assertEqual(
  81             True,
  82             string.deserialize('true'),
  83         )
  84
  85     def test_deserializes_true_with_leading_whitespace(self):
  86         self.assertEqual(
  87             True,
  88             string.deserialize(' \t\ntrue'),
  89         )
  90
  91     def test_deserializes_false(self):
  92         self.assertEqual(
  93             False,
  94             string.deserialize('false'),
  95         )
  96
  97     def test_deserializes_false_with_leading_whitespace(self):
  98         self.assertEqual(
  99             False,
 100             string.deserialize(' \t\nfalse'),
 101         )
 102
 103     def test_deserializes_int8(self):
 104         self.assertEqual(10, string.deserialize('10i8'))
 105         self.assertEqual(-1, string.deserialize('-1i8'))
 106
 107     def test_deserializes_int8_with_leading_whitespace(self):
 108         self.assertEqual(10, string.deserialize(' \t\n10i8'))
 109         self.assertEqual(-1, string.deserialize(' \t\n-1i8'))
 110
 111     def test_deserializes_int16(self):
 112         self.assertEqual(10, string.deserialize('10i16'))
 113         self.assertEqual(-1, string.deserialize('-1i16'))
 114
 115     def test_deserializes_int16_with_leading_whitespace(self):
 116         self.assertEqual(10, string.deserialize(' \t\n10i16'))
 117         self.assertEqual(-1, string.deserialize(' \t\n-1i16'))
 118
 119     def test_deserializes_int32(self):
 120         self.assertEqual(10, string.deserialize('10i32'))
 121         self.assertEqual(-1, string.deserialize('-1i32'))
 122
 123     def test_deserializes_int32_with_leading_whitespace(self):
 124         self.assertEqual(10, string.deserialize(' \t\n10i32'))
 125         self.assertEqual(-1, string.deserialize(' \t\n-1i32'))
 126
 127     def test_deserializes_int64(self):
 128         self.assertEqual(10, string.deserialize('10i64'))
 129         self.assertEqual(-1, string.deserialize('-1i64'))
 130
 131     def test_deserializes_int64_with_leading_whitespace(self):
 132         self.assertEqual(10, string.deserialize(' \t\n10i64'))
 133         self.assertEqual(-1, string.deserialize(' \t\n-1i64'))
 134
 135     def test_deserializes_float(self):
 136         self.assertEqual(1.0, string.deserialize('1.0f'))
 137
 138     def test_deserializes_float_with_leading_whitspace(self):
 139         self.assertEqual(1.0, string.deserialize(' \t\n1.0f'))
 140
 141     def test_deserializes_double(self):
 142         self.assertEqual(1.0, string.deserialize('1.0d'))
 143
 144     def test_deserializes_double_with_leading_whitespace(self):
 145         self.assertEqual(1.0, string.deserialize(' \t\n1.0d'))
 146
 147     def test_deserializes_binary(self):
 148         self.assertEqual(
 149             b'\xde\xad\xbe\xef',
 150             string.deserialize('"deadbeef"b'),
 151         )
 152
 153     def test_deserializes_binary_with_leading_whitespace(self):
 154         self.assertEqual(
 155             b'\xde\xad\xbe\xef',
 156             string.deserialize(' \t\n"deadbeef"b'),
 157         )
 158
 159     def test_deserializes_utf8(self):
 160         self.assertEqual(
 161             "Hello, world",
 162             string.deserialize('"Hello, world"utf8'),
 163         )
 164
 165     def test_deserializes_utf16(self):
 166         self.assertEqual(
 167             "Hello, world",
 168             string.deserialize('"Hello, world"utf16'),
 169         )
 170
 171     def test_deserializes_utf32(self):
 172         self.assertEqual(
 173             "Hello, world",
 174             string.deserialize('"Hello, world"utf32'),
 175         )
 176
 177     def test_deserializes_utf8_with_leading_whitespace(self):
 178         self.assertEqual(
 179             "Hello, world",
 180             string.deserialize(' \t\n"Hello, world"utf8'),
 181         )
 182
 183     def test_deserializes_utf16_with_leading_whitespace(self):
 184         self.assertEqual(
 185             "Hello, world",
 186             string.deserialize(' \t\n"Hello, world"utf16'),
 187         )
 188
 189     def test_deserializes_utf32_with_leading_whitespace(self):
 190         self.assertEqual(
 191             "Hello, world",
 192             string.deserialize(' \t\n"Hello, world"utf32'),
 193         )
 194
 195     def test_deserializes_list(self):
 196         self.assertEqual(
 197             [1,2,3,4,5],
 198             string.deserialize("[1i8,2i8,3i8,4i8,5i8]"),
 199         )
 200
 201     def test_deserializes_list_with_leading_whitespace(self):
 202         self.assertEqual(
 203             [1,2,3,4,5],
 204             string.deserialize(" \t\n[ \t\n1i8 \t\n, \t\n2i8 \t\n, \t\n3i8 \t\n, \t\n4i8 \t\n, \t\n5i8 \t\n]"),
 205         )
 206
 207     def test_deserializes_dictionary(self):
 208         self.assertEqual(
 209             collections.OrderedDict([
 210                 ('foo', 1),
 211                 ('bar', 'baz'),
 212             ]),
 213             string.deserialize('{"foo"utf8:1i32,"bar"utf8:"baz"utf8}'),
 214         )
 215
 216     def test_deserializes_dictionary_with_leading_whitespace(self):
 217         self.assertEqual(
 218             collections.OrderedDict([
 219                 ('foo', 1),
 220                 ('bar', 'baz'),
 221             ]),
 222             string.deserialize(' \t\n{ \t\n"foo"utf8 \t\n: \t\n1i32 \t\n, \t\n"bar"utf8 \t\n: \t\n"baz"utf8 \t\n}'),
 223         )
 224
 225 unittest.main()