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
|
# -*- coding: utf-8 -*-
#
# Copyright (C) 2008 John Paulett (john -at- paulett.org)
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.
import unittest
import doctest
import time
import jsonpickle.util
from jsonpickle.compat import unicode
from jsonpickle.compat import long
from jsonpickle import util
class Thing(object):
def __init__(self, name):
self.name = name
self.child = None
class DictSubclass(dict):
pass
class ListSubclass(list):
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(long(3)))
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_str(self):
self.assertTrue(util.is_primitive('hello'))
self.assertTrue(util.is_primitive(''))
def test_is_primitive_unicode(self):
self.assertTrue(util.is_primitive(unicode('hello')))
self.assertTrue(util.is_primitive(unicode('')))
self.assertTrue(util.is_primitive(unicode('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(set([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(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 suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(UtilTestCase))
suite.addTest(doctest.DocTestSuite(jsonpickle.util))
return suite
if __name__ == '__main__':
unittest.main(defaultTest='suite')
|
