def handle_creators_item(_, node, sec):
sub_type_base = "datacite/creator"
for sub in node:
if sub == "creatorName":
creator_name_map = {
"#text": "creatorName",
"@nameType": "nameType"
}
creator_name_helper = DataCiteItem(sec_name=sub,
attribute_map=creator_name_map,
func=None)
handle_props(creator_name_helper, node[sub], sec)
elif sub in ["givenName", "familyName"]:
if isinstance(node[sub], str):
Property(name=sub, values=node[sub], parent=sec)
elif "#text" in node[sub]:
Property(name=sub, values=node[sub]["#text"], parent=sec)
else:
print("[Warning] Could not parse '%s/%s'" % (sub_type_base, sub))
elif sub == "nameIdentifier":
handle_name_identifiers(sub, node, sub_type_base, sec)
elif sub == "affiliation":
handle_affiliations(sub, node, sub_type_base, sec)
else:
print("[Warning] Ignoring unsupported attribute '%s'" % sub)
def test_value(self):
p = Property("property", 100)
self.assertEqual(p.values[0], 100)
self.assertIsInstance(p.values, list)
p.values = None
self.assertEqual(len(p), 0)
p.values = [1, 2, 3]
p.values = ""
self.assertEqual(len(p), 0)
p.values = [1, 2, 3]
p.values = []
self.assertEqual(len(p), 0)
p.values = [1, 2, 3]
p.values = ()
self.assertEqual(len(p), 0)
p.values.append(5)
self.assertEqual(len(p.values), 0)
p2 = Property("test", {"name": "Marie", "name": "Johanna"})
self.assertEqual(len(p2), 1)
# Test tuple dtype value.
t = Property(name="Location", value='(39.12; 67.19)', dtype='2-tuple')
tuple_value = t.values[0] # As the formed tuple is a list of list
self.assertEqual(tuple_value[0], '39.12')
self.assertEqual(tuple_value[1], '67.19')
# Test invalid tuple length
with self.assertRaises(ValueError):
_ = Property(name="Public-Key", value='(5689; 1254; 687)', dtype='2-tuple')
def test_comparison(self):
p_name = "propertyName"
p_origin = "from over there"
p_unit = "pears"
p_uncertainty = "+-12"
p_ref = "4 8 15 16 23"
p_def = "an odml test property"
p_dep = "yes"
p_dep_val = "42"
p_val = ["a", "b"]
prop_a = Property(name=p_name,
value_origin=p_origin,
unit=p_unit,
uncertainty=p_uncertainty,
reference=p_ref,
definition=p_def,
dependency=p_dep,
dependency_value=p_dep_val,
value=p_val)
prop_b = Property(name=p_name,
value_origin=p_origin,
unit=p_unit,
uncertainty=p_uncertainty,
reference=p_ref,
definition=p_def,
dependency=p_dep,
dependency_value=p_dep_val,
value=p_val)
self.assertEqual(prop_a, prop_b)
prop_b.name = 'newPropertyName'
self.assertNotEqual(prop_a, prop_b)
def test_name(self):
# Test id is used when name is not provided
prop = Property()
self.assertIsNotNone(prop.name)
self.assertEqual(prop.name, prop.id)
# Test name is properly set on init
name = "rumpelstilzchen"
prop = Property(name)
self.assertEqual(prop.name, name)
# Test name can be properly set on single and connected Properties
prop = Property()
self.assertNotEqual(prop.name, "prop")
prop.name = "prop"
self.assertEqual(prop.name, "prop")
sec = Section()
prop_a = Property(parent=sec)
self.assertNotEqual(prop_a.name, "prop_a")
prop_a.name = "prop_a"
self.assertEqual(prop_a.name, "prop_a")
# Test property name can be changed with siblings
prop_b = Property(name="prop_b", parent=sec)
self.assertEqual(prop_b.name, "prop_b")
prop_b.name = "prop"
self.assertEqual(prop_b.name, "prop")
# Test property name set will fail on existing sibling with same name
with self.assertRaises(KeyError):
prop_b.name = "prop_a"
self.assertEqual(prop_b.name, "prop")
def test_remove(self):
sec = Section(name="remsec")
ssec_one = Section(name="subsec_one", parent=sec)
ssec_two = Section(name="subsec_two", parent=sec)
self.assertEqual(len(sec.sections), 2)
self.assertIsNotNone(ssec_one.parent)
sec.remove(ssec_one)
self.assertEqual(len(sec.sections), 1)
self.assertEqual(sec.sections[0].name, ssec_two.name)
self.assertIsNone(ssec_one.parent)
with self.assertRaises(ValueError):
sec.remove(ssec_one)
self.assertEqual(len(sec.sections), 1)
prop_one = Property(name="prop_one", parent=sec)
prop_two = Property(name="prop_two", parent=sec)
self.assertEqual(len(sec.properties), 2)
self.assertIsNotNone(prop_one.parent)
sec.remove(prop_one)
self.assertEqual(len(sec.properties), 1)
self.assertEqual(sec.properties[0].name, prop_two.name)
self.assertIsNone(prop_one.parent)
with self.assertRaises(ValueError):
sec.remove(prop_one)
self.assertEqual(len(sec.properties), 1)
with self.assertRaises(ValueError):
sec.remove("prop_two")
def test_contains(self):
sec = Section(name="root")
subsec = Section(name="subsec", type="test")
prop = Property(name="prop")
# Test not contains on empty child-lists.
self.assertIsNone(sec.contains(subsec))
self.assertIsNone(sec.contains(prop))
# Test contains of Section and Property
subsec.parent = sec
simisec = Section(name="subsec", type="test")
self.assertEqual(sec.contains(simisec).name, subsec.name)
prop.parent = sec
simiprop = Property(name="prop")
self.assertEqual(sec.contains(simiprop).name, prop.name)
# Test not contains on mismatching Section name/type and Property name
self.assertIsNone(sec.contains(Section(name="subsec", type="typetest")))
self.assertIsNone(sec.contains(Section(name="typesec", type="test")))
self.assertIsNone(sec.contains(Property(name="prop_two")))
# Test fail on non-Section/Property objects
with self.assertRaises(ValueError):
sec.contains(Document())
with self.assertRaises(ValueError):
sec.contains("some info")
def test_get_merged_equivalent(self):
sec = Section(name="parent")
mersec = Section(name="merged_section")
merprop_other = Property(name="other_prop", value="other")
merprop = Property(name="prop", value=[1, 2, 3])
# Check None on unset parent.
prop = Property(name="prop")
self.assertIsNone(prop.get_merged_equivalent())
# Check None on parent without merged Section.
prop.parent = sec
self.assertIsNone(prop.get_merged_equivalent())
# Check None on parent with merged Section but no attached Property.
sec.merge(mersec)
self.assertIsNone(prop.get_merged_equivalent())
# Check None on parent with merged Section and unequal Property.
merprop_other.parent = mersec
self.assertIsNone(prop.get_merged_equivalent())
# Check receiving merged equivalent Property.
merprop.parent = mersec
self.assertIsNotNone(prop.get_merged_equivalent())
self.assertEqual(prop.get_merged_equivalent(), merprop)
def test_reorder(self):
sec = Section()
prop_zero = Property(name="prop_zero", parent=sec)
prop_one = Property(name="prop_one", parent=sec)
prop_two = Property(name="prop_two", parent=sec)
prop_three = Property(name="prop_three", parent=sec)
self.assertEqual(sec.properties[0].name, prop_zero.name)
self.assertEqual(sec.properties[2].name, prop_two.name)
prop_two.reorder(0)
self.assertEqual(sec.properties[0].name, prop_two.name)
self.assertEqual(sec.properties[1].name, prop_zero.name)
self.assertEqual(sec.properties[2].name, prop_one.name)
self.assertEqual(sec.properties[3].name, prop_three.name)
prop_two.reorder(2)
self.assertEqual(sec.properties[0].name, prop_zero.name)
self.assertEqual(sec.properties[1].name, prop_one.name)
self.assertEqual(sec.properties[2].name, prop_two.name)
self.assertEqual(sec.properties[3].name, prop_three.name)
# Test Exception on unconnected property
prop = Property(name="main")
with self.assertRaises(ValueError):
prop.reorder(0)
def test_bool_conversion(self):
# Success tests
p = Property(name='received', value=[1, 0, 1, 0, 1])
assert(p.dtype == 'int')
p.dtype = DType.boolean
assert(p.dtype == 'boolean')
assert(p.values == [True, False, True, False, True])
q = Property(name='sent', value=['False', True, 'TRUE', '0', 't', 'F', '1'])
assert(q.dtype == 'string')
q.dtype = DType.boolean
assert(q.dtype == 'boolean')
assert(q.values == [False, True, True, False, True, False, True])
# Failure tests
curr_val = [3, 0, 1, 0, 8]
curr_type = 'int'
p = Property(name='received', value=curr_val)
assert(p.dtype == curr_type)
with self.assertRaises(ValueError):
p.dtype = DType.boolean
assert(p.dtype == curr_type)
assert(p.values == curr_val)
curr_type = 'string'
q = Property(name='sent', value=['False', True, 'TRUE', '0', 't', '12', 'Ft'])
assert(q.dtype == curr_type)
with self.assertRaises(ValueError):
q.dtype = DType.boolean
assert(q.dtype == curr_type)
def test_bool_conversion(self):
# Success tests
prop = Property(name='received', value=[1, 0, 1, 0, 1])
self.assertEqual(prop.dtype, 'int')
prop.dtype = DType.boolean
self.assertEqual(prop.dtype, 'boolean')
self.assertEqual(prop.values, [True, False, True, False, True])
prop = Property(name='sent', value=['False', True, 'TRUE', '0', 't', 'F', '1'])
self.assertEqual(prop.dtype, 'string')
prop.dtype = DType.boolean
self.assertEqual(prop.dtype, 'boolean')
self.assertEqual(prop.values, [False, True, True, False, True, False, True])
# Failure tests
curr_val = [3, 0, 1, 0, 8]
curr_type = 'int'
prop = Property(name='received', value=curr_val)
self.assertEqual(prop.dtype, curr_type)
with self.assertRaises(ValueError):
prop.dtype = DType.boolean
self.assertEqual(prop.dtype, curr_type)
self.assertEqual(prop.values, curr_val)
curr_type = 'string'
prop = Property(name='sent', value=['False', True, 'TRUE', '0', 't', '12', 'Ft'])
self.assertEqual(prop.dtype, curr_type)
with self.assertRaises(ValueError):
prop.dtype = DType.boolean
self.assertEqual(prop.dtype, curr_type)
def test_merge(self):
p_dst = Property("p1", value=[1, 2, 3], unit="Hz",
definition="Freude\t schoener\nGoetterfunken\n",
reference="portal.g-node.org", uncertainty=0.0, value_origin="file")
p_src = Property("p2", value=[2, 4, 6], unit="Hz",
definition="FREUDE schoener GOETTERfunken")
test_p = p_dst.clone()
test_p.merge(p_src)
self.assertEqual(len(test_p.values), 5)
p_inv_unit = p_src.clone()
p_inv_unit.unit = 's'
p_inv_def = p_src.clone()
p_inv_def.definition = "Freunde schoender Goetterfunken"
p_inv_uncert = p_src.clone()
p_inv_uncert.uncertainty = 10.0
p_inv_ref = p_src.clone()
p_inv_ref.reference = "test"
p_inv_origin = p_src.clone()
p_inv_origin.value_origin = "other file"
test_p = p_dst.clone()
self.assertRaises(ValueError, test_p.merge, p_inv_unit)
self.assertRaises(ValueError, test_p.merge, p_inv_def)
self.assertRaises(ValueError, test_p.merge, p_inv_uncert)
self.assertRaises(ValueError, test_p.merge, p_inv_ref)
self.assertRaises(ValueError, test_p.merge, p_inv_origin)
test_p.reference = None
test_p.merge(p_src)
self.assertEqual(test_p.reference, p_src.reference)
test_p.unit = ""
test_p.merge(p_src)
self.assertEqual(test_p.unit, p_src.unit)
test_p.uncertainty = None
test_p.merge(p_src)
self.assertEqual(test_p.uncertainty, p_src.uncertainty)
test_p.definition = ""
test_p.merge(p_src)
self.assertEqual(test_p.definition, p_src.definition)
test_p.value_origin = ""
test_p.merge(p_src)
self.assertEqual(test_p.value_origin, p_src.value_origin)
double_p = Property("adouble", value=3.14)
int_p = Property("aint", value=3)
self.assertRaises(ValueError, double_p.merge, int_p)
int_p.merge(double_p, strict=False)
self.assertEqual(len(int_p), 2)
def test_boolean(self):
prop = Property("test", True)
self.assertEqual(prop.dtype, "boolean")
self.assertIsInstance(prop.values[0], bool)
prop = Property("test", False)
self.assertEqual(prop.dtype, "boolean")
self.assertIsInstance(prop.values[0], bool)
def test_boolean(self):
p = Property("test", True)
assert (p.dtype == "boolean")
assert (type(p.value[0]) == bool)
p = Property("test", False)
assert (p.dtype == "boolean")
assert (type(p.value[0]) == bool)
def test_boolean(self):
p = Property("test", True)
assert (p.dtype == "boolean")
assert isinstance(p.values[0], bool)
p = Property("test", False)
assert (p.dtype == "boolean")
assert isinstance(p.values[0], bool)
def test_id(self):
prop = Property(name="P")
self.assertIsNotNone(prop.id)
prop = Property("P", oid="79b613eb-a256-46bf-84f6-207df465b8f7")
self.assertEqual(prop.id, "79b613eb-a256-46bf-84f6-207df465b8f7")
prop = Property("P", oid="id")
self.assertNotEqual(prop.id, "id")
# Make sure id cannot be reset programmatically.
with self.assertRaises(AttributeError):
prop.id = "someId"
def setUp(self):
"""
doc -- <section sec_main> -- <section sub_main>
\
-- <section sec_branch> -- <section sub_branch>
"""
doc = Document("author")
sec_main = Section("sec_main", "maintype")
doc.append(sec_main)
sec_main.append(Property("strprop", "somestring"))
sec_main.append(Property("txtprop", "some\ntext"))
sub_main = Section("sub_main", "maintype")
sec_main.append(sub_main)
sub_main.append(Property("strprop", "somestring"))
sub_main.append(Property("txtprop", "some\ntext"))
sec_branch = Section("sec_branch", "branchtype")
sec_main.append(sec_branch)
sec_branch.append(Property("strprop", "otherstring"))
sec_branch.append(Property("txtprop", "other\ntext"))
sub_branch = Section("sub_branch", "branchtype")
sec_branch.append(sub_branch)
sub_branch.append(Property("strprop", "otherstring"))
sub_branch.append(Property("txtprop", "other\ntext"))
self.doc = doc
def test_bool_conversion(self):
p = Property(name='received', value=[3, 0, 1, 0, 8])
assert (p.dtype == 'int')
p.dtype = DType.boolean
assert (p.dtype == 'boolean')
assert (p.value == [True, False, True, False, True])
q = Property(name='sent',
value=['False', True, 'TRUE', '0', 't', 'F', 'Ft'])
assert (q.dtype == 'string')
q.dtype = DType.boolean
assert (q.dtype == 'boolean')
assert (q.value == [False, True, True, False, True, False, True])
def setUp(self):
"""
doc -- <section foo> -- <section subfoo>
\
-- <section bar> -- <section subbar>
"""
doc = Document("author")
foo = Section("foo", "footype")
doc.append(foo)
foo.append(Property("strprop", "somestring"))
foo.append(Property("txtprop", "some\ntext"))
subfoo = Section("subfoo", "footype")
foo.append(subfoo)
subfoo.append(Property("strprop", "somestring"))
subfoo.append(Property("txtprop", "some\ntext"))
bar = Section("bar", "bartype")
foo.append(bar)
bar.append(Property("strprop", "otherstring"))
bar.append(Property("txtprop", "other\ntext"))
subbar = Section("subbar", "bartype")
bar.append(subbar)
subbar.append(Property("strprop", "otherstring"))
subbar.append(Property("txtprop", "other\ntext"))
self.doc = doc
def test_string(self):
p = Property("test", value="somestring")
assert (p.dtype == "string")
if sys.version_info < (3, 0):
assert isinstance(p.values[0], unicode)
else:
assert isinstance(p.values[0], str)
def setUp(self):
doc = Document()
sec = Section(name="sec1", type="test", parent=doc)
Section(name="sec2", type="test", parent=sec)
Property(name="prop1", values=[1.3], parent=sec)
self.doc = doc
def test_property(self):
"""
Test if a property and its attributes get converted correctly from rdf to odml.
"""
doc = Document()
sec1 = Section(name="sec1", type="test", parent=doc)
prop2 = Property(name="numbers",
definition="any number",
dtype="float",
parent=sec1,
values=[1, 3.4, 67.8, -12],
unit="meter",
uncertainty=0.8,
value_origin="force",
reference="Experiment 1")
rdf_writer = RDFWriter(doc).get_rdf_str()
rdf_reader = RDFReader().from_string(rdf_writer, "turtle")
prop = rdf_reader[0].sections[0].properties["numbers"]
self.assertEqual(prop.name, "numbers")
self.assertEqual(prop.dtype, "float")
self.assertEqual(prop.id, prop2.id)
self.assertEqual(prop.parent, rdf_reader[0].sections[0])
self.assertEqual(len(prop.values), 4)
self.assertEqual(prop.values, [1, 3.4, 67.8, -12])
self.assertEqual(prop.definition, "any number")
self.assertEqual(prop.unit, "meter")
self.assertEqual(prop.uncertainty, "0.8")
self.assertEqual(prop.value_origin, "force")
self.assertEqual(prop.reference, "Experiment 1")
def test_insert(self):
doc = Document()
sec_one = Section(name="sec_one", parent=doc)
sec_two = Section(name="sec_two", parent=doc)
subsec = Section(name="sec_three")
self.assertNotEqual(doc.sections[1].name, subsec.name)
doc.insert(1, subsec)
self.assertEqual(len(doc.sections), 3)
self.assertEqual(doc.sections[1].name, subsec.name)
self.assertEqual(doc.sections[0].name, sec_one.name)
self.assertEqual(doc.sections[2].name, sec_two.name)
self.assertEqual(subsec.parent, doc)
# Test invalid object
with self.assertRaises(ValueError):
doc.insert(1, Document())
with self.assertRaises(ValueError):
doc.insert(1, Property(name="prop_one"))
with self.assertRaises(ValueError):
doc.insert(1, "some info")
self.assertEqual(len(doc), 3)
# Test same name entries
with self.assertRaises(ValueError):
doc.insert(0, subsec)
self.assertEqual(len(doc), 3)
def test_dtype(self):
prop = Property(name="prop")
# Test assignment of all supported dtypes.
for curr_type in DType:
prop.dtype = curr_type
self.assertEqual(prop.dtype, curr_type)
# Test assignment of dtype alias.
prop.dtype = "bool"
self.assertEqual(prop.dtype, "bool")
prop.dtype = "str"
self.assertEqual(prop.dtype, "str")
# Test assignment of tuple.
prop.dtype = "2-tuple"
self.assertEqual(prop.dtype, "2-tuple")
# Test set None
prop.dtype = None
self.assertIsNone(prop.dtype)
# Test assignment fails.
with self.assertRaises(AttributeError):
prop.dtype = 1
with self.assertRaises(AttributeError):
prop.dtype = "crash and burn"
with self.assertRaises(AttributeError):
prop.dtype = "x-tuple"
# Test not setting None when a property contains values.
prop.values = [1, 2, 3]
self.assertIsNotNone(prop.dtype)
prop.dtype = None
self.assertIsNotNone(prop.dtype)
def test_append(self):
doc = Document()
self.assertListEqual(doc.sections, [])
# Test append Section
sec = Section(name="sec_one")
doc.append(sec)
self.assertEqual(len(doc.sections), 1)
self.assertEqual(sec.parent, doc)
# Test fail on Section list or tuple append
with self.assertRaises(ValueError):
doc.append([Section(name="sec_two"), Section(name="sec_three")])
with self.assertRaises(ValueError):
doc.append((Section(name="sec_two"), Section(name="sec_three")))
self.assertEqual(len(doc.sections), 1)
# Test fail on unsupported value
with self.assertRaises(ValueError):
doc.append(Document())
with self.assertRaises(ValueError):
doc.append("Section")
with self.assertRaises(ValueError):
doc.append(Property(name="prop"))
# Test fail on same name entities
with self.assertRaises(KeyError):
doc.append(Section(name="sec_one"))
self.assertEqual(len(doc.sections), 1)
def test_extend(self):
doc = Document()
self.assertListEqual(doc.sections, [])
# Test extend with Section list
doc.extend([Section(name="sec_one"), Section(name="sec_two")])
self.assertEqual(len(doc), 2)
self.assertEqual(len(doc.sections), 2)
self.assertEqual(doc.sections[0].name, "sec_one")
# Test fail on non iterable
with self.assertRaises(TypeError):
doc.extend(1)
self.assertEqual(len(doc.sections), 2)
# Test fail on non Section entry
with self.assertRaises(ValueError):
doc.extend([Document()])
with self.assertRaises(ValueError):
doc.extend([Property(name="prop")])
with self.assertRaises(ValueError):
doc.extend([5])
self.assertEqual(len(doc.sections), 2)
# Test fail on same name entities
with self.assertRaises(KeyError):
doc.extend([Section(name="sec_three"), Section(name="sec_one")])
self.assertEqual(len(doc.sections), 2)
def test_parent(self):
s = Section("Section")
self.assertIsNone(s.parent)
s.parent = None
self.assertIsNone(s.parent)
s.parent = Document()
self.assertIsInstance(s.parent, BaseDocument)
self.assertIsInstance(s.parent._sections[0], BaseSection)
""" Test if child is removed from _sections of a parent after assigning
a new parent to the child """
p = s.parent
s.parent = Section("S")
self.assertEqual(len(p._sections), 0)
s = Section("section_doc", parent=Document())
self.assertIsInstance(s.parent, BaseDocument)
self.assertEqual(len(s.parent._sections), 1)
p = s.parent
s.parent = None
self.assertEqual(len(p._sections), 0)
self.assertEqual(s.parent, None)
s = Section("section_sec", parent=Section("S"))
self.assertIsInstance(s.parent, BaseSection)
self.assertEqual(len(s.parent._sections), 1)
p = s.parent
s.parent = None
self.assertEqual(len(p._sections), 0)
self.assertEqual(s.parent, None)
with self.assertRaises(ValueError):
Section("section_property", parent=Property("P"))
def test_string(self):
p = Property("test", value="somestring")
assert (p.dtype == "string")
if sys.version_info < (3, 0):
assert (type(p.value[0]) == unicode)
else:
assert (type(p.value[0]) == str)
def test_str_to_int_convert(self):
# Success Test
prop = Property(name='cats_onboard', value=['3', '0', '1', '0', '8'])
self.assertEqual(prop.dtype, 'string')
prop.dtype = DType.int
self.assertEqual(prop.dtype, 'int')
self.assertEqual(prop.values, [3, 0, 1, 0, 8])
# Failure Test
prop = Property(name='dogs_onboard', value=['7', '20', '1 Dog', 'Seven'])
self.assertEqual(prop.dtype, 'string')
with self.assertRaises(ValueError):
prop.dtype = DType.int
self.assertEqual(prop.dtype, 'string')
self.assertEqual(prop.values, ['7', '20', '1 Dog', 'Seven'])
def test_read_write(self):
doc = Document("author")
sec = Section("name", "type")
doc.append(sec)
sec.append(Property("strprop", "somestring"))
sec.append(Property("txtprop", "some\ntext"))
sec.append(Property("intprop", 200))
sec.append(Property("floatprop", 2.00))
sec.append(Property("datetimeprop", dt.now()))
sec.append(Property("dateprop", dt.now().date()))
sec.append(Property("timeprop", dt.now().time()))
sec.append(Property("boolprop", True))
if sys.version_info < (3, 0):
str_doc = unicode(XMLWriter(doc))
else:
str_doc = str(XMLWriter(doc))
new_doc = XMLReader().fromString(str_doc)
new_sec = new_doc.sections[0]
p = new_sec.properties["strprop"]
assert (p.dtype == "string")
if sys.version_info < (3, 0):
assert (type(p.value[0]) == unicode)
else:
assert (type(p.value[0]) == str)
p = new_sec.properties["txtprop"]
assert (p.dtype == "text")
if sys.version_info < (3, 0):
assert (type(p.value[0]) == unicode)
else:
assert (type(p.value[0]) == str)
p = new_sec.properties["intprop"]
assert (p.dtype == "int")
assert (type(p.value[0]) == int)
p = new_sec.properties["floatprop"]
assert (p.dtype == "float")
assert (type(p.value[0]) == float)
p = new_sec.properties["datetimeprop"]
assert (p.dtype == "datetime")
assert (type(p.value[0]) == dt)
p = new_sec.properties["dateprop"]
assert (p.dtype == "date")
assert (type(p.value[0]) == date)
p = new_sec.properties["timeprop"]
assert (p.dtype == "time")
assert (type(p.value[0]) == time)
p = new_sec.properties["boolprop"]
assert (p.dtype == "boolean")
assert (type(p.value[0]) == bool)
def test_clone(self):
sec = Section(name="parent")
# Check different id.
prop = Property(name="original")
clone_prop = prop.clone()
self.assertNotEqual(prop.id, clone_prop.id)
# Check parent removal in clone.
prop.parent = sec
clone_prop = prop.clone()
self.assertIsNotNone(prop.parent)
self.assertIsNone(clone_prop.parent)
# Check keep_id
prop = Property(name="keepid")
clone_prop = prop.clone(True)
self.assertEqual(prop.id, clone_prop.id)
