1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
|
# Copyright (C) 2008 John Paulett (john -at- paulett.org)
# Copyright (C) 2009-2018 David Aguilar (davvid -at- gmail.com)
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.
from __future__ import absolute_import, division, unicode_literals
import doctest
import io
import time
import unittest
from jsonpickle import compat, util
class Thing(object):
def __init__(self, name):
self.name = name
self.child = None
class DictSubclass(dict):
pass
class ListSubclass(list):
pass
class MethodTestClass(object):
variable = None
@staticmethod
def static_method():
pass
@classmethod
def class_method(cls):
pass
def bound_method(self):
pass
class MethodTestSubclass(MethodTestClass):
pass
class MethodTestOldStyle:
def bound_method(self):
pass
class UtilTestCase(unittest.TestCase):
def test_is_primitive_int(self):
self.assertTrue(util.is_primitive(0))
self.assertTrue(util.is_primitive(3))
self.assertTrue(util.is_primitive(-3))
def test_is_primitive_float(self):
self.assertTrue(util.is_primitive(0))
self.assertTrue(util.is_primitive(3.5))
self.assertTrue(util.is_primitive(-3.5))
self.assertTrue(util.is_primitive(float(3)))
def test_is_primitive_long(self):
self.assertTrue(util.is_primitive(2**64))
def test_is_primitive_bool(self):
self.assertTrue(util.is_primitive(True))
self.assertTrue(util.is_primitive(False))
def test_is_primitive_None(self):
self.assertTrue(util.is_primitive(None))
def test_is_primitive_bytes(self):
self.assertFalse(util.is_primitive(b'hello'))
self.assertFalse(util.is_primitive('foo'.encode('utf-8')))
self.assertTrue(util.is_primitive('foo'))
def test_is_primitive_unicode(self):
self.assertTrue(util.is_primitive(compat.ustr('')))
self.assertTrue(util.is_primitive('hello'))
def test_is_primitive_list(self):
self.assertFalse(util.is_primitive([]))
self.assertFalse(util.is_primitive([4, 4]))
def test_is_primitive_dict(self):
self.assertFalse(util.is_primitive({'key': 'value'}))
self.assertFalse(util.is_primitive({}))
def test_is_primitive_tuple(self):
self.assertFalse(util.is_primitive((1, 3)))
self.assertFalse(util.is_primitive((1,)))
def test_is_primitive_set(self):
self.assertFalse(util.is_primitive({1, 3}))
def test_is_primitive_object(self):
self.assertFalse(util.is_primitive(Thing('test')))
def test_is_list_list(self):
self.assertTrue(util.is_list([1, 2]))
def test_is_list_set(self):
self.assertTrue(util.is_set({1, 2}))
def test_is_list_tuple(self):
self.assertTrue(util.is_tuple((1, 2)))
def test_is_list_dict(self):
self.assertFalse(util.is_list({'key': 'value'}))
self.assertFalse(util.is_set({'key': 'value'}))
self.assertFalse(util.is_tuple({'key': 'value'}))
def test_is_list_other(self):
self.assertFalse(util.is_list(1))
self.assertFalse(util.is_set(1))
self.assertFalse(util.is_tuple(1))
def test_is_sequence_various(self):
self.assertTrue(util.is_sequence([]))
self.assertTrue(util.is_sequence(tuple()))
self.assertTrue(util.is_sequence(set()))
def test_is_dictionary_dict(self):
self.assertTrue(util.is_dictionary({}))
def test_is_dicitonary_sequences(self):
self.assertFalse(util.is_dictionary([]))
self.assertFalse(util.is_dictionary(set()))
def test_is_dictionary_tuple(self):
self.assertFalse(util.is_dictionary(tuple()))
def test_is_dictionary_primitive(self):
self.assertFalse(util.is_dictionary(int()))
self.assertFalse(util.is_dictionary(None))
self.assertFalse(util.is_dictionary(str()))
def test_is_dictionary_subclass_dict(self):
self.assertFalse(util.is_dictionary_subclass({}))
def test_is_dictionary_subclass_subclass(self):
self.assertTrue(util.is_dictionary_subclass(DictSubclass()))
def test_is_sequence_subclass_subclass(self):
self.assertTrue(util.is_sequence_subclass(ListSubclass()))
def test_is_sequence_subclass_list(self):
self.assertFalse(util.is_sequence_subclass([]))
def test_is_noncomplex_time_struct(self):
t = time.struct_time('123456789')
self.assertTrue(util.is_noncomplex(t))
def test_is_noncomplex_other(self):
self.assertFalse(util.is_noncomplex('a'))
def test_is_function_builtins(self):
self.assertTrue(util.is_function(globals))
def test_is_function_lambda(self):
self.assertTrue(util.is_function(lambda: False))
def test_is_function_instance_method(self):
class Foo(object):
def method(self):
pass
@staticmethod
def staticmethod():
pass
@classmethod
def classmethod(cls):
pass
f = Foo()
self.assertTrue(util.is_function(f.method))
self.assertTrue(util.is_function(f.staticmethod))
self.assertTrue(util.is_function(f.classmethod))
def test_itemgetter(self):
expect = '0'
actual = util.itemgetter((0, 'zero'))
self.assertEqual(expect, actual)
def test_has_method(self):
instance = MethodTestClass()
x = 1
has_method = util.has_method
# no attribute
self.assertFalse(has_method(instance, 'foo'))
# builtin method type
self.assertFalse(has_method(int, '__getnewargs__'))
self.assertTrue(has_method(x, '__getnewargs__'))
# staticmethod
self.assertTrue(has_method(instance, 'static_method'))
self.assertTrue(has_method(MethodTestClass, 'static_method'))
# not a method
self.assertFalse(has_method(instance, 'variable'))
self.assertFalse(has_method(MethodTestClass, 'variable'))
# classmethod
self.assertTrue(has_method(instance, 'class_method'))
self.assertTrue(has_method(MethodTestClass, 'class_method'))
# bound method
self.assertTrue(has_method(instance, 'bound_method'))
self.assertFalse(has_method(MethodTestClass, 'bound_method'))
# subclass bound method
sub_instance = MethodTestSubclass()
self.assertTrue(has_method(sub_instance, 'bound_method'))
self.assertFalse(has_method(MethodTestSubclass, 'bound_method'))
# old style object
old_instance = MethodTestOldStyle()
self.assertTrue(has_method(old_instance, 'bound_method'))
self.assertFalse(has_method(MethodTestOldStyle, 'bound_method'))
def test_importable_name(self):
func_being_tested_obj = util.importable_name
io_method_obj = io.BytesIO(b'bytes').readline
self.assertEqual(
util.importable_name(func_being_tested_obj),
'jsonpickle.util.importable_name',
)
self.assertEqual(util.importable_name(io_method_obj), '_io.BytesIO.readline')
self.assertEqual(util.importable_name(dict), 'builtins.dict')
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(UtilTestCase))
suite.addTest(doctest.DocTestSuite(util))
return suite
if __name__ == '__main__':
unittest.main(defaultTest='suite')
|
