def test_bool(self):
td = make_TD(bool)
elt = td.xml_element(True, 'foo')
assert XU.str_from_xml_elt(elt) == '<foo>true</foo>'
assert td.extract_from(elt, 'foo') is True
elt = td.xml_element(False, 'foo')
assert XU.str_from_xml_elt(elt) == '<foo>false</foo>'
assert td.extract_from(elt, 'foo') is False
def test_type_descriptor(self, td):
rect = Rectangle(42, 100)
elt = td.xml_element(rect, 'rect')
assert XU.str_from_xml_elt(elt) == expected_rect_xml(42, 100)
rect_round_trip = td.extract_from(elt, 'rect')
assert rect_round_trip == rect
def test_type_descriptor(self, td):
val = [42, 100, 99, 123]
elt = td.xml_element(val, 'widths')
assert (XU.str_from_xml_elt(elt) ==
'<widths>%s</widths>' % ''.join('<wd>%d</wd>' % x for x in val))
val_round_trip = td.extract_from(elt, 'widths')
assert val_round_trip == val
def test_round_trip(self, colour, paint_pot_cls, tag, tag_for_expected):
pp = paint_pot_cls(100)
pp_xml = pp.as_xml(tag)
assert str_from_xml_elt(pp_xml) == self.expected_xml(tag_for_expected)
pp1 = paint_pot_cls.from_xml(pp_xml, tag_for_expected)
assert type(pp1) is type(pp)
assert pp1 == pp
def test_1(self):
layout = Layout('dark-blue',
[['rounded', 'red'],
['chamfered', 'matt'],
['pointy', 'anodized', 'black'],
['bevelled', 'twisted', 'plastic-coated']],
['red', 'burnt-ochre', 'orange'],
np.array([99, 42, 123], dtype=np.uint32),
Rectangle(210, 297),
np.array([(20, 30), (40, 50)], dtype=RectangleDType))
xml = X.serialize(layout, 'layout')
xml_str = XU.str_from_xml_elt(xml)
expected_str = remove_whitespace(
"""<layout>
<colour>dark-blue</colour>
<corner-properties>
<corner>
<prop>rounded</prop>
<prop>red</prop>
</corner>
<corner>
<prop>chamfered</prop>
<prop>matt</prop>
</corner>
<corner>
<prop>pointy</prop>
<prop>anodized</prop>
<prop>black</prop>
</corner>
<corner>
<prop>bevelled</prop>
<prop>twisted</prop>
<prop>plastic-coated</prop>
</corner>
</corner-properties>
<stripes>
<stripe-colour>red</stripe-colour>
<stripe-colour>burnt-ochre</stripe-colour>
<stripe-colour>orange</stripe-colour>
</stripes>
<product-id-codes>99,42,123</product-id-codes>
<shape>
<width>210</width>
<height>297</height>
</shape>
<components>
<rect>
<width>20</width>
<height>30</height>
</rect>
<rect>
<width>40</width>
<height>50</height>
</rect>
</components>
</layout>""")
assert xml_str == expected_str
X.deserialize(Layout, xml, 'layout')
def test_terse_string_descriptors(self, dtype_str):
td = make_TD(dtype_str)
tp = np.dtype(dtype_str).type
elt = td.xml_element(19, 'foo')
assert '<foo>19</foo>' == XU.str_from_xml_elt(elt)
val_round_trip = td.extract_from(elt, 'foo')
assert tp is type(val_round_trip)
assert val_round_trip == 19
def test_tuple_construction(self, descriptor_tup, exp_tag, exp_vslot):
elt_descriptor = X.ElementDescriptor.new_from_tuple(descriptor_tup)
val = 42
assert elt_descriptor.tag == exp_tag
assert elt_descriptor.value_from(self.rect) == val
assert elt_descriptor.value_slot == exp_vslot
xml_elt = elt_descriptor.xml_element(self.rect)
assert XU.str_from_xml_elt(xml_elt) == '<%s>%d</%s>' % (exp_tag, val, exp_tag)
round_trip_val = elt_descriptor.extract_from(xml_elt)
assert round_trip_val == val
def test_round_trip(self, type_descr, val, exp_xml, tag):
assert val.shape == ()
xml_elt = type_descr.xml_element(val, tag)
assert XU.str_from_xml_elt(xml_elt) == exp_xml
val_rt = type_descr.extract_from(xml_elt, tag)
assert type(val_rt) == np.ndarray
assert val_rt.dtype == val.dtype
assert val_rt.shape == val.shape
assert val_rt == val
def test_type_descriptor(self, td_func):
for tp, val, exp_txt in [(int, 42, '42'),
(float, 3.5, '3.5'),
(str, '3 < 5', '3 < 5'),
(np.uint8, np.uint8(42), '42')]:
td = td_func(tp)
elt = td.xml_element(val, 'foo')
assert XU.str_from_xml_elt(elt) == '<foo>%s</foo>' % exp_txt
val_round_trip = td.extract_from(elt, 'foo')
assert type(val_round_trip) is tp
assert val_round_trip == val
def test_type_descriptor(self, td):
xml_elt = td.xml_element(self.vals, 'rects')
expected_xml = remove_whitespace(
"""<rects>
<rect><width>42</width><height>100</height></rect>
<rect><width>99</width><height>12</height></rect>
</rects>""")
assert XU.str_from_xml_elt(xml_elt) == expected_xml
vals_rt = td.extract_from(xml_elt, 'rects')
assert vals_rt.dtype == self.vals.dtype
assert vals_rt.shape == self.vals.shape
assert np.all(vals_rt == self.vals)
def test_nested_elements(self):
elt = lxml.etree.Element('foo')
child_0 = lxml.etree.Element('bar')
child_0.text = '123'
elt.append(child_0)
child_1 = lxml.etree.Element('baz')
child_1.text = '456'
elt.append(child_1)
assert XmlUtils.str_from_xml_elt(elt) == '<foo><bar>123</bar><baz>456</baz></foo>'
def test_pretty(self):
elt = lxml.etree.Element('foo')
child_0 = lxml.etree.Element('bar')
child_0.text = '123'
elt.append(child_0)
child_1 = lxml.etree.Element('baz')
child_1.text = '456'
elt.append(child_1)
assert (XmlUtils.str_from_xml_elt(elt, pretty_print=True) ==
'<foo>\n <bar>123</bar>\n <baz>456</baz>\n</foo>\n')
def test_round_trip(self):
from enum import Enum
Animal = Enum('Animal', 'Cat Dog Rabbit')
class PetDetails(XMLSerializableNamedTuple):
xml_descriptor = [('type', Animal), ('weight', float)]
pd = PetDetails(Animal.Dog, 42.5)
pd_xml = pd.as_xml('pet-details')
assert str_from_xml_elt(pd_xml) == ('<pet-details><type>Dog</type>'
'<weight>42.5</weight></pet-details>')
pd1 = PetDetails.from_xml(pd_xml, 'pet-details')
assert pd1 == pd
def test_type_descriptor(self, td):
groups = [[1, 2], [3, 4, 5]]
elt = td.xml_element(groups, 'stripe-groups')
exp_txt = ('<stripe-groups>%s</stripe-groups>'
% ''.join(('<stripe-group>%s</stripe-group>'
% ''.join('<wd>%d</wd>' % x for x in grp))
for grp in groups))
assert exp_txt == XU.str_from_xml_elt(elt)
groups_round_trip = td.extract_from(elt, 'stripe-groups')
assert groups == groups_round_trip
def test_round_trip(self):
xml_elt = self.type_descr.xml_element(self.vals, 'rect-pairs')
expected_xml = remove_whitespace(
"""<rect-pairs>
<rect-pair>
<big><width>420</width><height>100</height></big>
<small><width>42</width><height>10</height></small>
</rect-pair>
<rect-pair>
<big><width>430</width><height>110</height></big>
<small><width>43</width><height>11</height></small>
</rect-pair>
</rect-pairs>""")
assert expected_xml == XU.str_from_xml_elt(xml_elt)
vals_rt = self.type_descr.extract_from(xml_elt, 'rect-pairs')
assert vals_rt.dtype == self.vals.dtype
assert vals_rt.shape == self.vals.shape
assert np.all(vals_rt == self.vals)
def test_round_trip(self, tag, tag_for_expected):
r = Rectangle(42, 100)
r_xml = r.as_xml(tag)
assert str_from_xml_elt(r_xml) == self.expected_xml(tag_for_expected)
r1 = Rectangle.from_xml(r_xml, tag_for_expected)
assert r1 == r
def test_nonempty_element(self):
elt = lxml.etree.Element('foo')
elt.text = 'hello'
assert XmlUtils.str_from_xml_elt(elt) == '<foo>hello</foo>'
def test_1(self):
serialized_xml = X.serialize(self.rect, 'rect')
assert XU.str_from_xml_elt(serialized_xml) == expected_rect_xml(42, 123)
rect_round_trip = X.deserialize(Rectangle, serialized_xml, 'rect')
assert rect_round_trip == self.rect
def test_round_trip(self, tag, tag_for_expected):
e = Ellipse(42, 99, 'red')
e_xml = e.as_xml(tag)
assert str_from_xml_elt(e_xml) == self.expected_xml(tag_for_expected)
e1 = Ellipse.from_xml(e_xml, tag_for_expected)
assert e1 == e
def test_as_xml_str(self, tag, kwargs):
if 'pretty_print' not in kwargs:
kwargs['pretty_print'] = True
p = Pattern(33, [Circle(10, 'blue'), Circle(12, 'red')])
assert str_from_xml_elt(p.as_xml(tag), **kwargs) == p.as_xml_str(tag, **kwargs)
def test_round_trip(self, tag, tag_for_expected):
p = Pattern(33, [Circle(10, 'blue'), Circle(12, 'red')])
p_xml = p.as_xml(tag)
assert str_from_xml_elt(p_xml) == self.expected_xml(tag_for_expected)
p1 = Pattern.from_xml(p_xml, tag_for_expected)
assert p1 == p
def test_round_trip(self, tag, tag_for_expected):
c = Circle(42, 'orange')
c_xml = c.as_xml(tag)
assert str_from_xml_elt(c_xml) == self.expected_xml(tag_for_expected)
c1 = Circle.from_xml(c_xml, tag_for_expected)
assert c1 == c
def test_empty_element(self):
elt = lxml.etree.Element('foo')
assert XmlUtils.str_from_xml_elt(elt) == '<foo/>'
def test_content(self):
xs = np.array([32, 42, 100, 99, -100], dtype=np.int32)
elt = self.td.xml_element(xs, 'values')
assert XU.str_from_xml_elt(elt) == '<values>32,42,100,99,-100</values>'
