diff --git a/odml/doc.py b/odml/doc.py
index 8d75f2b..ea15912 100644
--- a/odml/doc.py
+++ b/odml/doc.py
@@ -34,10 +34,13 @@ class BaseDocument(base.sectionable, Document):
             print(e)
             self._id = str(uuid.uuid4())
         self._author = author
-        self._date = date  # date must be a datetime
         self._version = version
         self._repository = repository
 
+        # Make sure date is properly parsed into a datetime object
+        self._date = None
+        self.date = date
+
     @property
     def id(self):
         """
diff --git a/odml/dtypes.py b/odml/dtypes.py
index 39d1e8d..e86bf8d 100644
--- a/odml/dtypes.py
+++ b/odml/dtypes.py
@@ -1,5 +1,5 @@
 import sys
-import datetime
+import datetime as dt
 from enum import Enum
 self = sys.modules[__name__].__dict__
 
@@ -12,6 +12,10 @@ try:
 except NameError:
     unicode = str
 
+FORMAT_DATE = "%Y-%m-%d"
+FORMAT_DATETIME = "%Y-%m-%d %H:%M:%S"
+FORMAT_TIME = "%H:%M:%S"
+
 
 class DType(str, Enum):
     string = 'string'
@@ -44,11 +48,11 @@ def default_values(dtype):
         return default_dtype_value[dtype]
 
     if dtype == 'datetime':
-        return datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        return dt.datetime.now().replace(microsecond=0)
     if dtype == 'date':
-        return datetime.datetime.now().strftime('%Y-%m-%d')
+        return dt.datetime.now().date()
     if dtype == 'time':
-        return datetime.datetime.now().strftime('%H:%M:%S')
+        return dt.datetime.now().replace(microsecond=0).time()
 
     return ''  # Maybe return None ?
 
@@ -65,9 +69,9 @@ def infer_dtype(value):
         if dtype == 'string' and '\n' in value:
             dtype = 'text'
         return dtype
-    else:
-        # If unable to infer a dtype of given value, return defalt as *string*
-        return 'string'
+
+    # If unable to infer a dtype of given value, return default as *string*
+    return 'string'
 
 
 def valid_type(dtype):
@@ -109,14 +113,15 @@ def set(value, dtype=None):
         if isinstance(value, str):
             return str_set(value)
     else:
-        if type(value) in (str, unicode):
+        if isinstance(value, (str, unicode)):
             return str_set(value)
     return self.get(dtype + "_set", str_set)(value)
 
 
 def int_get(string):
-    if not string:
-        return 0
+    if string is None or string == "":
+        return default_values("int")
+
     try:
         return int(string)
     except ValueError:
@@ -125,14 +130,20 @@ def int_get(string):
 
 
 def float_get(string):
-    if not string:
-        return 0.0
+    if string is None or string == "":
+        return default_values("float")
+
     return float(string)
 
 
 def str_get(string):
+    # Do not stringify empty list or dict but make sure boolean False gets through.
+    if string in [None, "", [], {}]:
+        return default_values("string")
+
     if sys.version_info < (3, 0):
         return unicode(string)
+
     return str(string)
 
 
@@ -144,71 +155,65 @@ string_set = str_get
 
 
 def time_get(string):
-    if not string:
-        return None
-    if type(string) is datetime.time:
-        return datetime.datetime.strptime(string.strftime('%H:%M:%S'),
-                                          '%H:%M:%S').time()
-    else:
-        return datetime.datetime.strptime(string, '%H:%M:%S').time()
+    if string is None or string == "":
+        return default_values("time")
 
+    if isinstance(string, dt.time):
+        return dt.datetime.strptime(string.strftime(FORMAT_TIME), FORMAT_TIME).time()
 
-def time_set(value):
-    if not value:
-        return None
-    if type(value) is datetime.time:
-        return value.strftime("%H:%M:%S")
-    return value.isoformat()
+    return dt.datetime.strptime(string, FORMAT_TIME).time()
+
+
+time_set = time_get
 
 
 def date_get(string):
-    if not string:
-        return None
-    if type(string) is datetime.date:
-        return datetime.datetime.strptime(string.isoformat(),
-                                          '%Y-%m-%d').date()
-    else:
-        return datetime.datetime.strptime(string, '%Y-%m-%d').date()
+    if string is None or string == "":
+        return default_values("date")
+
+    if isinstance(string, dt.date):
+        return dt.datetime.strptime(string.isoformat(), FORMAT_DATE).date()
+
+    return dt.datetime.strptime(string, FORMAT_DATE).date()
 
 
-date_set = time_set
+date_set = date_get
 
 
 def datetime_get(string):
-    if not string:
-        return None
-    if type(string) is datetime.datetime:
-        return datetime.datetime.strptime(string.strftime('%Y-%m-%d %H:%M:%S'),
-                                          '%Y-%m-%d %H:%M:%S')
-    else:
-        return datetime.datetime.strptime(string, '%Y-%m-%d %H:%M:%S')
+    if string is None or string == "":
+        return default_values("datetime")
 
+    if isinstance(string, dt.datetime):
+        return dt.datetime.strptime(string.strftime(FORMAT_DATETIME), FORMAT_DATETIME)
 
-def datetime_set(value):
-    if not value:
-        return None
-    if type(value) is datetime.datetime:
-        return value.strftime('%Y-%m-%d %H:%M:%S')
-    else:
-        return datetime.datetime.strptime(value, '%Y-%m-%d %H:%M:%S')
+    return dt.datetime.strptime(string, FORMAT_DATETIME)
+
+
+datetime_set = datetime_get
 
 
 def boolean_get(string):
-    if string is None:
-        return None
-    if type(string) in (unicode, str):
+    if string in [None, "", [], {}]:
+        return default_values("boolean")
+
+    if isinstance(string, (unicode, str)):
         string = string.lower()
+
     truth = ["true", "1", True, "t"]  # be kind, spec only accepts True / False
     if string in truth:
         return True
+
     false = ["false", "0", False, "f"]
     if string in false:
         return False
+
     # disallow any values that cannot be interpreted as boolean.
     raise ValueError
 
 # Alias boolean_set to boolean_get. Both perform same function.
 
+
 boolean_set = boolean_get
 bool_get = boolean_get
 bool_set = boolean_set
diff --git a/odml/tools/dict_parser.py b/odml/tools/dict_parser.py
index 0d2cdf0..3dd95a9 100644
--- a/odml/tools/dict_parser.py
+++ b/odml/tools/dict_parser.py
@@ -83,7 +83,13 @@ class DictWriter:
                     if isinstance(tag, tuple):
                         prop_dict[attr] = list(tag)
                     elif (tag == []) or tag:  # Even if 'value' is empty, allow '[]'
-                        prop_dict[attr] = tag
+                        # Custom odML tuples require special handling
+                        # for save loading from file.
+                        if attr == "value" and prop.dtype and \
+                                prop.dtype.endswith("-tuple") and len(prop.value) > 0:
+                            prop_dict["value"] = "(%s)" % ";".join(prop.value[0])
+                        else:
+                            prop_dict[attr] = tag
 
             props_seq.append(prop_dict)
 
@@ -178,17 +184,13 @@ class DictReader:
 
         for _property in props_list:
             prop_attrs = {}
-            values = []
 
             for i in _property:
                 attr = self.is_valid_attribute(i, odmlfmt.Property)
-                if attr == 'value':
-                    values = _property['value']
                 if attr:
                     prop_attrs[attr] = _property[attr]
 
             prop = odmlfmt.Property.create(**prop_attrs)
-            prop.value = values
             odml_props.append(prop)
 
         return odml_props
diff --git a/odml/tools/odmlparser.py b/odml/tools/odmlparser.py
index 1caa7fa..641a52a 100644
--- a/odml/tools/odmlparser.py
+++ b/odml/tools/odmlparser.py
@@ -5,6 +5,7 @@ A generic odML parsing module.
 Parses odML files and documents.
 """
 
+import datetime
 import json
 import yaml
 
@@ -67,11 +68,21 @@ class ODMLWriter:
             if self.parser == 'YAML':
                 string_doc = yaml.dump(odml_output, default_flow_style=False)
             elif self.parser == 'JSON':
-                string_doc = json.dumps(odml_output, indent=4)
+                string_doc = json.dumps(odml_output, indent=4,
+                                        cls=JSONDateTimeSerializer)
 
         return string_doc
 
 
+# Required to serialize datetime values with JSON.
+class JSONDateTimeSerializer(json.JSONEncoder):
+    def default(self, o):
+        if isinstance(o, (datetime.datetime, datetime.date, datetime.time)):
+            return str(o)
+
+        return json.JSONEncoder.default(self, o)
+
+
 class ODMLReader:
     """
     A reader to parse odML files or strings into odml documents,
diff --git a/odml/tools/xmlparser.py b/odml/tools/xmlparser.py
index a0d48c1..f2ea862 100644
--- a/odml/tools/xmlparser.py
+++ b/odml/tools/xmlparser.py
@@ -83,7 +83,11 @@ class XMLWriter:
             if val is None:
                 continue
             if isinstance(fmt, format.Property.__class__) and k == "value":
-                ele = E(k, to_csv(val))
+                # Custom odML tuples require special handling for save loading from file.
+                if e.dtype and e.dtype.endswith("-tuple") and len(val) > 0:
+                    ele = E(k, "(%s)" % ";".join(val[0]))
+                else:
+                    ele = E(k, to_csv(val))
                 cur.append(ele)
             else:
                 if isinstance(val, list):

[dtype] Return defined default values
Currently the "get" methods in `dtype.py` return magic numbers as default values. Make them return the already defined default values instead.
diff --git a/test/test_dtypes.py b/test/test_dtypes.py
index 6e90e5e..bbc3d35 100644
--- a/test/test_dtypes.py
+++ b/test/test_dtypes.py
@@ -1,8 +1,7 @@
+import datetime
 import unittest
 
 import odml.dtypes as typ
-import odml
-import datetime
 
 
 class TestTypes(unittest.TestCase):
@@ -11,42 +10,150 @@ class TestTypes(unittest.TestCase):
         pass
 
     def test_date(self):
+        self.assertIsInstance(typ.date_get(None), datetime.date)
+        self.assertIsInstance(typ.date_get(""), datetime.date)
+
+        re = "^[0-9]{4}-(0[1-9]|1[0-2])-([0-2][0-9]|3[0-1])$"
+        self.assertRegexpMatches(typ.date_get(None).strftime(typ.FORMAT_DATE), re)
+        self.assertRegexpMatches(typ.date_get("").strftime(typ.FORMAT_DATE), re)
+
         date = datetime.date(2011, 12, 1)
         date_string = '2011-12-01'
         self.assertEqual(date, typ.date_get(date_string))
-        self.assertEqual(typ.date_set(date), date_string)
+        self.assertEqual(date, typ.date_get(date))
+
+        with self.assertRaises(TypeError):
+            _ = typ.date_get([])
+        with self.assertRaises(TypeError):
+            _ = typ.date_get({})
+        with self.assertRaises(TypeError):
+            _ = typ.date_get(False)
+
+        # Test fail on datetime.datetime
+        with self.assertRaises(ValueError):
+            _ = typ.date_get(datetime.datetime.now())
+
+        # Test fail on datetime.time
+        with self.assertRaises(TypeError):
+            _ = typ.date_get(datetime.datetime.now().time())
+
+        # Test fail on invalid string format
+        with self.assertRaises(ValueError):
+            _ = typ.date_get("11.11.1111")
 
     def test_time(self):
+        self.assertIsInstance(typ.time_get(None), datetime.time)
+        self.assertIsInstance(typ.time_get(""), datetime.time)
+
+        re = "^[0-5][0-9]:[0-5][0-9]:[0-5][0-9]$"
+        self.assertRegexpMatches(typ.time_get(None).strftime(typ.FORMAT_TIME), re)
+        self.assertRegexpMatches(typ.time_get("").strftime(typ.FORMAT_TIME), re)
+
         time = datetime.time(12, 34, 56)
         time_string = '12:34:56'
         self.assertEqual(time, typ.time_get(time_string))
-        self.assertEqual(typ.time_set(time), time_string)
+        self.assertEqual(time, typ.time_get(time))
+
+        with self.assertRaises(TypeError):
+            _ = typ.time_get([])
+        with self.assertRaises(TypeError):
+            _ = typ.time_get({})
+        with self.assertRaises(TypeError):
+            _ = typ.time_get(False)
+
+        # Test fail on datetime.datetime
+        with self.assertRaises(TypeError):
+            _ = typ.time_get(datetime.datetime.now())
+
+        # Test fail on datetime.date
+        with self.assertRaises(TypeError):
+            _ = typ.time_get(datetime.datetime.now().date())
+
+        # Test fail on invalid string format
+        with self.assertRaises(ValueError):
+            _ = typ.time_get("11-11-11")
 
     def test_datetime(self):
+        self.assertIsInstance(typ.datetime_get(None), datetime.datetime)
+        self.assertIsInstance(typ.datetime_get(""), datetime.datetime)
+
+        re = "^[0-9]{4}-(0[1-9]|1[0-2])-([0-2][0-9]|3[0-1]) " \
+             "[0-5][0-9]:[0-5][0-9]:[0-5][0-9]$"
+        self.assertRegexpMatches(typ.datetime_get(None).strftime(typ.FORMAT_DATETIME), re)
+        self.assertRegexpMatches(typ.datetime_get("").strftime(typ.FORMAT_DATETIME), re)
+
         date = datetime.datetime(2011, 12, 1, 12, 34, 56)
         date_string = '2011-12-01 12:34:56'
         self.assertEqual(date, typ.datetime_get(date_string))
-        self.assertEqual(typ.datetime_set(date), date_string)
+        self.assertEqual(date, typ.datetime_get(date))
+
+        with self.assertRaises(TypeError):
+            _ = typ.datetime_get([])
+        with self.assertRaises(TypeError):
+            _ = typ.datetime_get({})
+        with self.assertRaises(TypeError):
+            _ = typ.datetime_get(False)
+
+        # Test fail on datetime.time
+        with self.assertRaises(TypeError):
+            _ = typ.datetime_get(datetime.datetime.now().time())
+
+        # Test fail on datetime.date
+        with self.assertRaises(TypeError):
+            _ = typ.datetime_get(datetime.datetime.now().date())
+
+        # Test fail on invalid string format
+        with self.assertRaises(ValueError):
+            _ = typ.datetime_get("11.11.1111 12:12:12")
 
     def test_int(self):
-        p = odml.Property("test", value="123456789012345678901", dtype="int")
-        self.assertEqual(p.value[0], 123456789012345678901)
-        p = odml.Property("test", value="-123456789012345678901", dtype="int")
-        self.assertEqual(p.value[0], -123456789012345678901)
-        p = odml.Property("test", value="123.45", dtype="int")
-        self.assertEqual(p.value[0], 123)
+        self.assertEqual(typ.default_values("int"), typ.int_get(None))
+        self.assertEqual(typ.default_values("int"), typ.int_get(""))
+
+        self.assertIsInstance(typ.int_get(11), int)
+        self.assertIsInstance(typ.int_get(1.1), int)
+        self.assertIsInstance(typ.int_get("11"), int)
+        self.assertEqual(typ.int_get("123456789012345678901"), 123456789012345678901)
+        self.assertEqual(typ.int_get("-123456789012345678901"), -123456789012345678901)
+        self.assertEqual(typ.int_get("123.45"), 123)
+
+        with self.assertRaises(TypeError):
+            _ = typ.int_get([])
+        with self.assertRaises(TypeError):
+            _ = typ.int_get({})
+        with self.assertRaises(ValueError):
+            _ = typ.int_get("fail")
+
+    def test_float(self):
+        self.assertEqual(typ.default_values("float"), typ.float_get(None))
+        self.assertEqual(typ.default_values("float"), typ.float_get(""))
+
+        self.assertIsInstance(typ.float_get(1), float)
+        self.assertIsInstance(typ.float_get("1.1"), float)
+        self.assertEqual(typ.float_get(123.45), 123.45)
+
+        with self.assertRaises(TypeError):
+            _ = typ.float_get([])
+        with self.assertRaises(TypeError):
+            _ = typ.float_get({})
+        with self.assertRaises(ValueError):
+            _ = typ.float_get("fail")
 
     def test_str(self):
-        s = odml.Property(name='Name', value='Sherin')
-        self.assertEqual(s.value[0], 'Sherin')
-        self.assertEqual(s.dtype, 'string')
+        self.assertEqual(typ.default_values("string"), typ.str_get(None))
+        self.assertEqual(typ.default_values("string"), typ.str_get(""))
+        self.assertEqual(typ.default_values("string"), typ.str_get([]))
+        self.assertEqual(typ.default_values("string"), typ.str_get({}))
 
-        s.value = 'Jerin'
-        self.assertEqual(s.value[0], 'Jerin')
-        self.assertEqual(s.dtype, 'string')
+        # Make sure boolean values are properly converted to string.
+        self.assertEqual(typ.str_get(False), 'False')
+        self.assertEqual(typ.str_get(True), 'True')
 
     def test_bool(self):
-        self.assertEqual(None, typ.boolean_get(None))
+        self.assertEqual(typ.default_values("boolean"), typ.boolean_get(None))
+        self.assertEqual(typ.default_values("boolean"), typ.boolean_get(""))
+        self.assertEqual(typ.default_values("boolean"), typ.boolean_get([]))
+        self.assertEqual(typ.default_values("boolean"), typ.boolean_get({}))
 
         true_values = [True, "TRUE", "true", "T", "t", "1", 1]
         for val in true_values:
@@ -64,18 +171,17 @@ class TestTypes(unittest.TestCase):
             typ.boolean_get(2.1)
 
     def test_tuple(self):
-        # Success test
-        t = odml.Property(name="Location", value='(39.12; 67.19)', dtype='2-tuple')
-        tuple_value = t.value[0]  # As the formed tuple is a list of list
-        self.assertEqual(tuple_value[0], '39.12')
-        self.assertEqual(tuple_value[1], '67.19')
+        self.assertIs(typ.tuple_get(""), None)
+        self.assertIs(typ.tuple_get(None), None)
 
-        # Failure test. More tuple values then specified.
-        with self.assertRaises(ValueError):
-            t = odml.Property(name="Public-Key", value='(5689; 1254; 687)',
-                              dtype='2-tuple')
+        self.assertEqual(typ.tuple_get("(39.12; 67.19)"), ["39.12", "67.19"])
+
+        # Test fail on missing parenthesis.
+        with self.assertRaises(AssertionError):
+            _ = typ.tuple_get("fail")
+        # Test fail on mismatching element count and count number.
+        with self.assertRaises(AssertionError):
+            _ = typ.tuple_get("(1; 2; 3)", 2)
 
     def test_dtype_none(self):
-        t = odml.Property(name="Record", value={'name': 'Marie'})
-        self.assertEqual(t.dtype, 'string')
-        self.assertEqual(t.value[0], "{'name': 'Marie'}")
+        self.assertEqual(typ.get({'name': 'Marie'}), "{'name': 'Marie'}")
diff --git a/test/test_infer_type.py b/test/test_infer_type.py
index 8909f85..7f27bc4 100644
--- a/test/test_infer_type.py
+++ b/test/test_infer_type.py
@@ -11,51 +11,51 @@ class TestInferType(unittest.TestCase):
         p = Property("test", value="somestring")
         assert(p.dtype == "string")
         if sys.version_info < (3, 0):
-            assert (type(p.value[0]) == unicode)
+            assert isinstance(p.value[0], unicode)
         else:
-            assert (type(p.value[0]) == str)
+            assert isinstance(p.value[0], str)
 
     def test_text(self):
         p = Property("test", value="some\nstring")
         assert(p.dtype == "text")
         if sys.version_info < (3, 0):
-            assert (type(p.value[0]) == unicode)
+            assert isinstance(p.value[0], unicode)
         else:
-            assert (type(p.value[0]) == str)
+            assert isinstance(p.value[0], str)
 
     def test_int(self):
         p = Property("test", value=111)
         assert(p.dtype == "int")
-        assert(type(p.value[0]) == int)
+        assert isinstance(p.value[0], int)
 
     def test_float(self):
         p = Property("test", value=3.14)
         assert(p.dtype == "float")
-        assert(type(p.value[0]) == float)
+        assert isinstance(p.value[0], float)
 
     def test_datetime(self):
         p = Property("test", value=dt.now())
         assert(p.dtype == "datetime")
-        assert(type(p.value[0]) == dt)
+        assert isinstance(p.value[0], dt)
 
     def test_date(self):
         p = Property("test", dt.now().date())
         assert(p.dtype == "date")
-        assert(type(p.value[0]) == date)
+        assert isinstance(p.value[0], date)
 
     def test_time(self):
         p = Property("test", value=dt.now().time())
         assert(p.dtype == "time")
-        assert(type(p.value[0]) == time)
+        assert isinstance(p.value[0], time)
 
     def test_boolean(self):
         p = Property("test", True)
         assert(p.dtype == "boolean")
-        assert(type(p.value[0]) == bool)
+        assert isinstance(p.value[0], bool)
 
         p = Property("test", False)
         assert(p.dtype == "boolean")
-        assert(type(p.value[0]) == bool)
+        assert isinstance(p.value[0], bool)
 
     def test_read_write(self):
         doc = Document("author")
@@ -79,37 +79,37 @@ class TestInferType(unittest.TestCase):
         p = new_sec.properties["strprop"]
         assert(p.dtype == "string")
         if sys.version_info < (3, 0):
-            assert(type(p.value[0]) == unicode)
+            assert isinstance(p.value[0], unicode)
         else:
-            assert(type(p.value[0]) == str)
+            assert isinstance(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)
+            assert isinstance(p.value[0], unicode)
         else:
-            assert(type(p.value[0]) == str)
+            assert isinstance(p.value[0], str)
 
         p = new_sec.properties["intprop"]
         assert(p.dtype == "int")
-        assert(type(p.value[0]) == int)
+        assert isinstance(p.value[0], int)
 
         p = new_sec.properties["floatprop"]
         assert(p.dtype == "float")
-        assert(type(p.value[0]) == float)
+        assert isinstance(p.value[0], float)
 
         p = new_sec.properties["datetimeprop"]
         assert(p.dtype == "datetime")
-        assert(type(p.value[0]) == dt)
+        assert isinstance(p.value[0], dt)
 
         p = new_sec.properties["dateprop"]
         assert(p.dtype == "date")
-        assert(type(p.value[0]) == date)
+        assert isinstance(p.value[0], date)
 
         p = new_sec.properties["timeprop"]
         assert(p.dtype == "time")
-        assert(type(p.value[0]) == time)
+        assert isinstance(p.value[0], time)
 
         p = new_sec.properties["boolprop"]
         assert(p.dtype == "boolean")
-        assert(type(p.value[0]) == bool)
+        assert isinstance(p.value[0], bool)
diff --git a/test/test_property.py b/test/test_property.py
index c122f97..cbcaade 100644
--- a/test/test_property.py
+++ b/test/test_property.py
@@ -73,6 +73,24 @@ class TestProperty(unittest.TestCase):
         p6 = Property("test", {"name": "Marie", "name":"Johanna"})
         self.assertEqual(len(p6), 1)
 
+        # Test tuple dtype value.
+        t = Property(name="Location", value='(39.12; 67.19)', dtype='2-tuple')
+        tuple_value = t.value[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')
+
+        # Test missing tuple length.
+        with self.assertRaises(ValueError):
+            _ = Property(name="Public-Key", value='(5689; 1254; 687)', dtype='-tuple')
+
+        # Test invalid tuple format.
+        with self.assertRaises(ValueError):
+            _ = Property(name="Public-Key", value='5689; 1254; 687', dtype='3-tuple')
+
     def test_get_set_value(self):
         values = [1, 2, 3, 4, 5]
         p = Property("property", value=values)
diff --git a/test/test_samplefile.py b/test/test_samplefile.py
index 92ae8ec..3bd5ec6 100644
--- a/test/test_samplefile.py
+++ b/test/test_samplefile.py
@@ -197,7 +197,7 @@ class AttributeTest(unittest.TestCase):
     def test_conversion_int_to_float(self):
         p = odml.Property("test", "1", dtype="int")
         self.assertEqual(p.dtype, "int")
-        self.assertEqual(type(p.value[0]), int)
+        self.assertIsInstance(p.value[0], int)
         p.dtype = "float"  # change dtype
         self.assertEqual(p.dtype, "float")
         self.assertEqual(p.value[0], 1.0)

pip install -e .
parse_log_pytest
pytest
pytest
apt-get update apt-get install -y libxml2-dev libxslt1-dev lib32z1-dev
3.5
pytest --no-header -rA --tb=line --color=no -p no:cacheprovider -W ignore::DeprecationWarning
attrs @ file:///opt/conda/conda-bld/attrs_1642510447205/work
certifi==2021.5.30
importlib-metadata @ file:///tmp/build/80754af9/importlib-metadata_1631916693255/work
iniconfig @ file:///home/linux1/recipes/ci/iniconfig_1610983019677/work
isodate==0.6.1
lxml==5.3.1
more-itertools @ file:///tmp/build/80754af9/more-itertools_1637733554872/work
-e git+https://github.com/G-Node/python-odml.git@8953343f0f4616c0a71087d406b5f6d4a2036748#egg=odML
packaging @ file:///tmp/build/80754af9/packaging_1637314298585/work
pluggy @ file:///tmp/build/80754af9/pluggy_1615976315926/work
py @ file:///opt/conda/conda-bld/py_1644396412707/work
pyparsing @ file:///tmp/build/80754af9/pyparsing_1635766073266/work
pytest==6.2.4
PyYAML==6.0.1
rdflib==5.0.0
six==1.17.0
toml @ file:///tmp/build/80754af9/toml_1616166611790/work
typing_extensions @ file:///opt/conda/conda-bld/typing_extensions_1647553014482/work
zipp @ file:///tmp/build/80754af9/zipp_1633618647012/work

name: python-odml
channels:
  - defaults
  - https://repo.anaconda.com/pkgs/main
  - https://repo.anaconda.com/pkgs/r
  - conda-forge
dependencies:
  - _libgcc_mutex=0.1=main
  - _openmp_mutex=5.1=1_gnu
  - attrs=21.4.0=pyhd3eb1b0_0
  - ca-certificates=2025.2.25=h06a4308_0
  - certifi=2021.5.30=py36h06a4308_0
  - importlib-metadata=4.8.1=py36h06a4308_0
  - importlib_metadata=4.8.1=hd3eb1b0_0
  - iniconfig=1.1.1=pyhd3eb1b0_0
  - ld_impl_linux-64=2.40=h12ee557_0
  - libffi=3.3=he6710b0_2
  - libgcc-ng=11.2.0=h1234567_1
  - libgomp=11.2.0=h1234567_1
  - libstdcxx-ng=11.2.0=h1234567_1
  - more-itertools=8.12.0=pyhd3eb1b0_0
  - ncurses=6.4=h6a678d5_0
  - openssl=1.1.1w=h7f8727e_0
  - packaging=21.3=pyhd3eb1b0_0
  - pip=21.2.2=py36h06a4308_0
  - pluggy=0.13.1=py36h06a4308_0
  - py=1.11.0=pyhd3eb1b0_0
  - pyparsing=3.0.4=pyhd3eb1b0_0
  - pytest=6.2.4=py36h06a4308_2
  - python=3.6.13=h12debd9_1
  - readline=8.2=h5eee18b_0
  - setuptools=58.0.4=py36h06a4308_0
  - sqlite=3.45.3=h5eee18b_0
  - tk=8.6.14=h39e8969_0
  - toml=0.10.2=pyhd3eb1b0_0
  - typing_extensions=4.1.1=pyh06a4308_0
  - wheel=0.37.1=pyhd3eb1b0_0
  - xz=5.6.4=h5eee18b_1
  - zipp=3.6.0=pyhd3eb1b0_0
  - zlib=1.2.13=h5eee18b_1
  - pip:
      - isodate==0.6.1
      - lxml==5.3.1
      - pyyaml==6.0.1
      - rdflib==5.0.0
      - six==1.17.0
prefix: /opt/conda/envs/python-odml

test/test_dtypes.py::TestTypes::test_bool test/test_dtypes.py::TestTypes::test_date test/test_dtypes.py::TestTypes::test_datetime test/test_dtypes.py::TestTypes::test_float test/test_dtypes.py::TestTypes::test_int test/test_dtypes.py::TestTypes::test_str test/test_dtypes.py::TestTypes::test_time
test/test_dtypes.py::TestTypes::test_dtype_none test/test_dtypes.py::TestTypes::test_tuple test/test_infer_type.py::TestInferType::test_boolean test/test_infer_type.py::TestInferType::test_date test/test_infer_type.py::TestInferType::test_datetime test/test_infer_type.py::TestInferType::test_float test/test_infer_type.py::TestInferType::test_int test/test_infer_type.py::TestInferType::test_read_write test/test_infer_type.py::TestInferType::test_string test/test_infer_type.py::TestInferType::test_text test/test_infer_type.py::TestInferType::test_time test/test_property.py::TestProperty::test_bool_conversion test/test_property.py::TestProperty::test_dtype test/test_property.py::TestProperty::test_get_set_value test/test_property.py::TestProperty::test_merge test/test_property.py::TestProperty::test_name test/test_property.py::TestProperty::test_parent test/test_property.py::TestProperty::test_path test/test_property.py::TestProperty::test_set_id test/test_property.py::TestProperty::test_str_to_int_convert test/test_property.py::TestProperty::test_value test/test_property.py::TestProperty::test_value_origin test/test_samplefile.py::SampleFileCreatorTest::test_samplefile test/test_samplefile.py::SampleFileOperationTest::test_find_key test/test_samplefile.py::SampleFileOperationTest::test_restore test/test_samplefile.py::SampleFileOperationTest::test_save test/test_samplefile.py::SampleFileOperationTest::test_xml_writer_version test/test_samplefile.py::AttributeTest::test_conversion_float_to_int test/test_samplefile.py::AttributeTest::test_conversion_int_to_float test/test_samplefile.py::AttributeTest::test_value_float test/test_samplefile.py::AttributeTest::test_value_int test/test_samplefile.py::CopyTest::test_dependence test/test_samplefile.py::CopyTest::test_independence test/test_samplefile.py::MiscTest::test_findall_related test/test_samplefile.py::MiscTest::test_get_property_by_path test/test_samplefile.py::MiscTest::test_get_section_by_path test/test_samplefile.py::MiscTest::test_paths test/test_samplefile.py::MiscTest::test_reorder_first test/test_samplefile.py::MiscTest::test_reorder_post test/test_samplefile.py::MiscTest::test_save_version test/test_samplefile.py::MiscTest::test_section_path
odml/tools/dict_parser.py odml/doc.py odml/tools/odmlparser.py odml/tools/xmlparser.py odml/dtypes.py
odml/tools/dict_parser.py odml/doc.py odml/tools/odmlparser.py odml/tools/xmlparser.py odml/dtypes.py