1
2import testing
3from testing import value_eq,object_eq,text_eq,check_object_eq
4from testing import FailedTest,failed
5
6
7def test_import():
8    import observables
9    from observables import AttributeProperties,DefinedAttributeBase
10    from observables import Observable
11    from observables import MomentumDistribution
12#end def test_import
13
14
15
16def test_defined_attribute_base():
17    from generic import obj,NexusError
18    from observables import AttributeProperties,DefinedAttributeBase
19
20    # empty init
21    p = AttributeProperties()
22    o = DefinedAttributeBase()
23
24    pref = obj(
25        assigned        = set(),
26        deepcopy        = False,
27        default         = None,
28        dest            = None,
29        name            = None,
30        no_default      = False,
31        required        = False,
32        type            = None,
33        )
34    assert(check_object_eq(p,pref))
35    assert(len(o)==0)
36
37    # init
38    p = AttributeProperties(
39        default  = 2,
40        dest     = 'nest',
41        deepcopy = True,
42        )
43
44    pref = obj(
45        assigned        = {'dest', 'default', 'deepcopy'},
46        deepcopy        = True,
47        default         = 2,
48        dest            = 'nest',
49        name            = None,
50        no_default      = False,
51        required        = False,
52        type            = None,
53        )
54    assert(check_object_eq(p,pref))
55
56
57    # define attributes
58    class DA(DefinedAttributeBase):
59        None
60    #end class DA
61
62    da_attributes = obj(
63        a = obj(
64            default    = 1,
65            ),
66        b = obj(
67            default    = 2,
68            type       = int,
69            required   = True,
70            ),
71        c = obj(
72            dest       = 'nest',
73            type       = str,
74            ),
75        d = obj(
76            type       = dict,
77            deepcopy   = True,
78            no_default = True,
79            ),
80        nest = obj(
81            type       = obj,
82            default    = obj,
83            ),
84        )
85
86    DA.define_attributes(**da_attributes)
87
88    def get_class_dict(cls):
89        o = obj()
90        o.transfer_from(cls.__dict__)
91        for k in list(o.keys()):
92            if k.startswith('_'):
93                del o[k]
94            #end if
95        #end for
96        return o
97    #end def get_class_dict
98
99    o = get_class_dict(DA)
100
101    oref = obj(
102        deepcopy_attributes = {'d'},
103        required_attributes = {'b'},
104        sublevel_attributes = {'c'},
105        toplevel_attributes = {'d', 'a', 'b', 'nest'},
106        typed_attributes    = {'d', 'c', 'b', 'nest'},
107        attribute_definitions = obj(
108            a = obj(
109                assigned        = {'default'},
110                deepcopy        = False,
111                default         = 1,
112                dest            = None,
113                name            = 'a',
114                no_default      = False,
115                required        = False,
116                type            = None,
117                ),
118            b = obj(
119                assigned        = {'required', 'default', 'type'},
120                deepcopy        = False,
121                default         = 2,
122                dest            = None,
123                name            = 'b',
124                no_default      = False,
125                required        = True,
126                type            = int,
127                ),
128            c = obj(
129                assigned        = {'dest', 'type'},
130                deepcopy        = False,
131                default         = None,
132                dest            = 'nest',
133                name            = 'c',
134                no_default      = False,
135                required        = False,
136                type            = str,
137                ),
138            d = obj(
139                assigned        = {'deepcopy', 'no_default', 'type'},
140                deepcopy        = True,
141                default         = None,
142                dest            = None,
143                name            = 'd',
144                no_default      = True,
145                required        = False,
146                type            = dict,
147                ),
148            nest = obj(
149                assigned        = {'default', 'type'},
150                deepcopy        = False,
151                default         = obj,
152                no_default      = False,
153                dest            = None,
154                name            = 'nest',
155                required        = False,
156                type            = obj,
157                ),
158            ),
159        )
160
161    assert(check_object_eq(o,oref))
162
163
164    class DA2(DA):
165        None
166    #end class DA2
167
168    DA2.define_attributes(
169        DA,
170        e = obj(
171            required = True,
172            )
173        )
174
175    o = get_class_dict(DA)
176    assert(check_object_eq(o,oref))
177
178    o2 = get_class_dict(DA2)
179    oref.required_attributes.add('e')
180    oref.toplevel_attributes.add('e')
181    oref.attribute_definitions.e = obj(
182        assigned        = {'required'},
183        deepcopy        = False,
184        default         = None,
185        dest            = None,
186        name            = 'e',
187        no_default      = False,
188        required        = True,
189        type            = None,
190        )
191    assert(check_object_eq(o2,oref))
192
193
194    # empty init
195    da = DA()
196    assert(len(da)==0)
197    assert(not da.check_attributes())
198
199
200    # set_default_attributes
201    da.set_default_attributes()
202
203    da_ref = obj(
204        a    = 1,
205        b    = 2,
206        nest = obj(
207            c = None,
208            ),
209        )
210
211    assert(check_object_eq(da,da_ref))
212    assert(not da.check_attributes())
213
214
215    # set_attributes/init
216    da = DA(
217        a = 2,
218        b = 3,
219        c = 'hi',
220        d = dict(a=2),
221        )
222
223    da_ref = obj(
224        a = 2,
225        b = 3,
226        d = {'a': 2},
227        nest = obj(
228            c = 'hi',
229            ),
230        )
231
232    assert(check_object_eq(da,da_ref))
233    assert(da.check_attributes())
234
235
236    # set_attribute
237    da = DA()
238
239    assert('b' not in da)
240    da.set_attribute('b',5)
241    assert('b' in da)
242    assert(da.b==5)
243
244    try:
245        da.set_attribute('unknown',None)
246        raise FailedTest
247    except NexusError:
248        None
249    except FailedTest:
250        failed()
251    except Exception as e:
252        failed(str(e))
253    #end try
254
255    da.set_attribute('b',3)
256    assert(da.b==3)
257
258    try:
259        da.set_attribute('b',3.5)
260        raise FailedTest
261    except NexusError:
262        None
263    except FailedTest:
264        failed()
265    except Exception as e:
266        failed(str(e))
267    #end try
268
269
270    # get_attribute
271    da = DA()
272
273    da.set_attribute('b',5)
274    assert('b' in da)
275    assert(da.b==5)
276
277    assert(da.get_attribute('b')==5)
278    assert(da.get_attribute('a',None) is None)
279    assert(da.get_attribute('c',None) is None)
280
281    try:
282        da.get_attribute('unknown')
283        raise FailedTest
284    except NexusError:
285        None
286    except FailedTest:
287        failed()
288    except Exception as e:
289        failed(str(e))
290    #end try
291
292    try:
293        da.get_attribute('a')
294        raise FailedTest
295    except NexusError:
296        None
297    except FailedTest:
298        failed()
299    except Exception as e:
300        failed(str(e))
301    #end try
302
303    try:
304        da.get_attribute('c')
305        raise FailedTest
306    except NexusError:
307        None
308    except FailedTest:
309        failed()
310    except Exception as e:
311        failed(str(e))
312    #end try
313
314
315    # default values
316    class DA_def(DefinedAttributeBase):
317        None
318    #end class DA_def
319    DA_def.set_unassigned_default(None)
320
321    class DA_def2(DA_def):
322        None
323    #end class DA_def2
324
325    DA_def2.define_attributes(**da_attributes)
326
327    assert(not DefinedAttributeBase.class_has('unassigned_default'))
328    assert(DA_def.class_has('unassigned_default'))
329    assert(DA_def2.class_has('unassigned_default'))
330    assert(DA_def.unassigned_default is None)
331    assert(DA_def2.unassigned_default is None)
332
333    da = DA_def2()
334    assert('a' not in da)
335    assert('c' not in da)
336    assert('nest' not in da)
337    assert(da.get_attribute('a',None) is None)
338    assert(da.get_attribute('c',None) is None)
339
340    try:
341        da.get_attribute('a')
342        raise FailedTest
343    except NexusError:
344        None
345    except FailedTest:
346        failed()
347    except Exception as e:
348        failed(str(e))
349    #end try
350
351    try:
352        da.get_attribute('c')
353        raise FailedTest
354    except NexusError:
355        None
356    except FailedTest:
357        failed()
358    except Exception as e:
359        failed(str(e))
360    #end try
361
362    da.set_default_attributes()
363
364    da_ref = obj(
365        a = 1,
366        b = 2,
367        nest = obj(
368            c = None,
369            )
370        )
371
372    assert(check_object_eq(da,da_ref))
373
374    da.b = None
375
376    assert(da.get_attribute('a')==1)
377    assert(da.get_attribute('b',assigned=False) is None)
378    assert(da.get_attribute('c',assigned=False) is None)
379    assert(da.get_attribute('a',2)==1)
380    assert(da.get_attribute('a',assigned=False)==1)
381
382    try:
383        da.get_attribute('b')
384        raise FailedTest
385    except NexusError:
386        None
387    except FailedTest:
388        failed()
389    except Exception as e:
390        failed(str(e))
391    #end try
392
393    try:
394        da.get_attribute('c')
395        raise FailedTest
396    except NexusError:
397        None
398    except FailedTest:
399        failed()
400    except Exception as e:
401        failed(str(e))
402    #end try
403
404#end def test_defined_attribute_base
405