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
|
"""
Unit test for ClassSelector parameters.
"""
import unittest
from numbers import Number
import param
from .utils import check_defaults
class TestClassSelectorParameters(unittest.TestCase):
def setUp(self):
super().setUp()
class P(param.Parameterized):
e = param.ClassSelector(default=1,class_=int)
f = param.ClassSelector(default=int,class_=Number, is_instance=False)
g = param.ClassSelector(default=1,class_=(int,str))
h = param.ClassSelector(default=int,class_=(int,str), is_instance=False)
self.P = P
def _check_defaults(self, p):
assert p.default is None
assert p.allow_None is True
assert p.instantiate is True
assert p.is_instance is True
def test_defaults_class(self):
class P(param.Parameterized):
s = param.ClassSelector(class_=int)
check_defaults(P.param.s, label='S', skip=['instantiate'])
self._check_defaults(P.param.s)
assert P.param.s.class_ is int
def test_defaults_inst(self):
class P(param.Parameterized):
s = param.ClassSelector(class_=int)
p = P()
check_defaults(p.param.s, label='S', skip=['instantiate'])
self._check_defaults(p.param.s)
assert p.param.s.class_ is int
def test_defaults_unbound(self):
s = param.ClassSelector(class_=int)
check_defaults(s, label=None, skip=['instantiate'])
self._check_defaults(s)
assert s.class_ is int
def test_single_class_instance_constructor(self):
p = self.P(e=6)
self.assertEqual(p.e, 6)
def test_single_class_instance_error(self):
exception = "ClassSelector parameter 'P.e' value must be an instance of int, not 'a'."
with self.assertRaisesRegex(ValueError, exception):
self.P(e='a')
def test_single_class_type_constructor(self):
p = self.P(f=float)
self.assertEqual(p.f, float)
def test_single_class_type_error(self):
exception = "ClassSelector parameter 'P.f' value must be a subclass of Number, not <class 'str'>."
with self.assertRaisesRegex(ValueError, exception):
self.P(f=str)
def test_multiple_class_instance_constructor1(self):
p = self.P(g=1)
self.assertEqual(p.g, 1)
def test_multiple_class_instance_constructor2(self):
p = self.P(g='A')
self.assertEqual(p.g, 'A')
def test_multiple_class_instance_error(self):
exception = r"ClassSelector parameter 'P.g' value must be an instance of \(int, str\), not 3.0."
with self.assertRaisesRegex(ValueError, exception):
self.P(g=3.0)
def test_multiple_class_type_constructor1(self):
p = self.P(h=int)
self.assertEqual(p.h, int)
def test_multiple_class_type_constructor2(self):
p = self.P(h=str)
self.assertEqual(p.h, str)
def test_class_selector_get_range(self):
p = self.P()
classes = p.param.g.get_range()
self.assertIn('int', classes)
self.assertIn('str', classes)
def test_multiple_class_type_error(self):
exception = r"ClassSelector parameter 'P.h' value must be a subclass of \(int, str\), not <class 'float'>."
with self.assertRaisesRegex(ValueError, exception):
self.P(h=float)
class TestDictParameters(unittest.TestCase):
def _check_defaults(self, p):
assert p.default is None
assert p.allow_None is True
assert p.instantiate is True
assert p.is_instance is True
assert p.class_ == dict
def test_defaults_class(self):
class P(param.Parameterized):
s = param.Dict()
check_defaults(P.param.s, label='S', skip=['instantiate'])
self._check_defaults(P.param.s)
def test_defaults_inst(self):
class P(param.Parameterized):
s = param.Dict()
p = P()
check_defaults(p.param.s, label='S', skip=['instantiate'])
self._check_defaults(p.param.s)
def test_defaults_unbound(self):
s = param.Dict()
check_defaults(s, label=None, skip=['instantiate'])
self._check_defaults(s)
def test_valid_dict_parameter(self):
valid_dict = {1:2, 3:3}
class Test(param.Parameterized):
items = param.Dict(default=valid_dict)
def test_valid_dict_parameter_positional(self):
valid_dict = {1:2, 3:3}
class Test(param.Parameterized):
items = param.Dict(valid_dict)
def test_dict_invalid_set(self):
valid_dict = {1:2, 3:3}
class Test(param.Parameterized):
items = param.Dict(valid_dict)
test = Test()
exception = "Dict parameter 'Test.items' value must be an instance of dict, not 3."
with self.assertRaisesRegex(ValueError, exception):
test.items = 3
|
