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
|
# -*- 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 datetime
import jsonpickle.util
from jsonpickle.util import *
from samples import Thing, ListSubclass, DictSubclass
class IsPrimitiveTestCase(unittest.TestCase):
def test_int(self):
self.assertTrue(is_primitive(0))
self.assertTrue(is_primitive(3))
self.assertTrue(is_primitive(-3))
def test_float(self):
self.assertTrue(is_primitive(0))
self.assertTrue(is_primitive(3.5))
self.assertTrue(is_primitive(-3.5))
self.assertTrue(is_primitive(float(3)))
def test_long(self):
self.assertTrue(is_primitive(long(3)))
def test_bool(self):
self.assertTrue(is_primitive(True))
self.assertTrue(is_primitive(False))
def test_None(self):
self.assertTrue(is_primitive(None))
def test_str(self):
self.assertTrue(is_primitive('hello'))
self.assertTrue(is_primitive(''))
def test_unicode(self):
self.assertTrue(is_primitive(u'hello'))
self.assertTrue(is_primitive(u''))
self.assertTrue(is_primitive(unicode('hello')))
def test_list(self):
self.assertFalse(is_primitive([]))
self.assertFalse(is_primitive([4, 4]))
def test_dict(self):
self.assertFalse(is_primitive({'key':'value'}))
self.assertFalse(is_primitive({}))
def test_tuple(self):
self.assertFalse(is_primitive((1, 3)))
self.assertFalse(is_primitive((1,)))
def test_set(self):
self.assertFalse(is_primitive(set([1, 3])))
def test_object(self):
self.assertFalse(is_primitive(Thing('test')))
class IsCollection(unittest.TestCase):
def test_list(self):
self.assertTrue(is_list([1, 2]))
def test_set(self):
self.assertTrue(is_set(set([1, 2])))
def test_tuple(self):
self.assertTrue(is_tuple((1, 2)))
def test_dict(self):
self.assertFalse(is_list({'key':'value'}))
self.assertFalse(is_set({'key':'value'}))
self.assertFalse(is_tuple({'key':'value'}))
def test_other(self):
self.assertFalse(is_list(1))
self.assertFalse(is_set(1))
self.assertFalse(is_tuple(1))
class IsDictionary(unittest.TestCase):
def test_dict(self):
self.assertTrue(is_dictionary({'key':'value'}))
def test_list(self):
self.assertFalse(is_dictionary([1, 2]))
class IsDictionarySubclass(unittest.TestCase):
def test_subclass(self):
self.assertTrue(is_dictionary_subclass(DictSubclass()))
def test_dict(self):
self.assertFalse(is_dictionary_subclass({'key':'value'}))
class IsCollectionSubclass(unittest.TestCase):
def test_subclass(self):
self.assertTrue(is_collection_subclass(ListSubclass()))
def test_list(self):
self.assertFalse(is_collection_subclass([]))
class IsNonComplex(unittest.TestCase):
def setUp(self):
self.time = time.struct_time('123456789')
def test_time_struct(self):
self.assertTrue(is_noncomplex(self.time))
def test_other(self):
self.assertFalse(is_noncomplex('a'))
class IsRepr(unittest.TestCase):
def setUp(self):
self.time = datetime.datetime.now()
def test_datetime(self):
self.assertTrue(is_repr(self.time))
def test_date(self):
self.assertTrue(is_repr(self.time.date()))
def test_time(self):
self.assertTrue(is_repr(self.time.time()))
def test_timedelta(self):
self.assertTrue(is_repr(datetime.timedelta(4)))
def test_object(self):
self.assertFalse(is_repr(object()))
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(IsPrimitiveTestCase))
suite.addTest(unittest.makeSuite(IsCollection))
suite.addTest(unittest.makeSuite(IsDictionary))
suite.addTest(unittest.makeSuite(IsDictionarySubclass))
suite.addTest(unittest.makeSuite(IsCollectionSubclass))
suite.addTest(unittest.makeSuite(IsNonComplex))
suite.addTest(unittest.makeSuite(IsRepr))
suite.addTest(doctest.DocTestSuite(jsonpickle.util))
return suite
if __name__ == '__main__':
unittest.main(defaultTest='suite')
|
