continuing #38, merging in

tests/test_primitive_data/test_bit_string.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Test Primitive Bit String
+-------------------------
+"""
+
+import unittest
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
+from bacpypes.primitivedata import BitString, Tag
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+
+class SampleBitString(BitString):
+    bitLen = 13
+    bitNames = {
+        'b0': 0,
+        'b1': 1,
+        'b4': 4,
+        'b7': 7,
+        'b8': 8,
+        'b12': 12,
+    }
+
+
+@bacpypes_debugging
+def bit_string_tag(x):
+    """Convert a hex string to an bit_string application tag."""
+    if _debug: bit_string_tag._debug("bit_string_tag %r", x)
+
+    b = xtob(x)
+    tag = Tag(Tag.applicationTagClass, Tag.bitStringAppTag, len(b), b)
+    if _debug: bit_string_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+@bacpypes_debugging
+def bit_string_encode(obj):
+    """Encode an BitString object into a tag."""
+    if _debug: bit_string_encode._debug("bit_string_encode %r", obj)
+
+    tag = Tag()
+    obj.encode(tag)
+    if _debug: bit_string_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+
+@bacpypes_debugging
+def bit_string_decode(tag):
+    """Decode an bit_string application tag into an bit_string."""
+    if _debug: bit_string_decode._debug("bit_string_decode %r", tag)
+
+    obj = BitString(tag)
+    if _debug: bit_string_decode._debug("    - obj: %r", obj)
+
+    return obj
+
+
+@bacpypes_debugging
+def bit_string_endec(v, x):
+    """Pass the value to BitString, construct a tag from the hex string,
+    and compare results of encode and decoding each other."""
+    if _debug: bit_string_endec._debug("bit_string_endec %r %r", v, x)
+
+    tag = bit_string_tag(x)
+    if _debug: bit_string_endec._debug("    - tag: %r, %r", tag, tag.tagData)
+
+    obj = BitString(v)
+    if _debug: bit_string_endec._debug("    - obj: %r, %r", obj, obj.value)
+
+    assert bit_string_encode(obj) == tag
+    assert bit_string_decode(tag) == obj
+
+
+@bacpypes_debugging
+class TestBitString(unittest.TestCase):
+
+    def test_bit_string(self):
+        if _debug: TestBitString._debug("test_bit_string")
+
+        obj = BitString()
+        assert obj.value == []
+        assert str(obj) == "BitString()"
+
+        obj = BitString([0])
+        assert obj.value == [0]
+        assert str(obj) == "BitString(0)"
+
+        obj = BitString([0, 1])
+        assert obj.value == [0, 1]
+        assert str(obj) == "BitString(0,1)"
+
+        with self.assertRaises(TypeError):
+            BitString("some string")
+        with self.assertRaises(TypeError):
+            BitString(1.0)
+
+    def test_bit_string_sample(self):
+        if _debug: TestBitString._debug("test_bit_string_sample")
+
+        obj = SampleBitString()
+        assert obj.value == [0] * SampleBitString.bitLen
+
+        obj = SampleBitString([1])
+        assert str(obj) == "BitString(b0)"
+
+        obj = SampleBitString(['b4'])
+        assert str(obj) == "BitString(!b0,!b1,0,0,b4,0,0,!b7,!b8,0,0,0,!b12)"
+
+        with self.assertRaises(TypeError):
+            SampleBitString(["x1"])
+
+    def test_bit_string_tag(self):
+        if _debug: TestBitString._debug("test_bit_string_tag")
+
+        tag = Tag(Tag.applicationTagClass, Tag.bitStringAppTag, 1, xtob('08'))
+        obj = BitString(tag)
+        if _debug: TestBitString._debug("    - obj.value: %r", obj.value)
+        assert obj.value == []
+
+        tag = Tag(Tag.applicationTagClass, Tag.bitStringAppTag, 2, xtob('0102'))
+        obj = BitString(tag)
+        if _debug: TestBitString._debug("    - obj.value: %r", obj.value)
+        assert obj.value == [0, 0, 0, 0, 0, 0, 1]
+
+        tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 0, xtob(''))
+        with self.assertRaises(ValueError):
+            BitString(tag)
+
+        tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
+        with self.assertRaises(ValueError):
+            BitString(tag)
+
+        tag = Tag(Tag.openingTagClass, 0)
+        with self.assertRaises(ValueError):
+            BitString(tag)
+
+    def test_bit_string_copy(self):
+        if _debug: TestBitString._debug("test_bit_string_copy")
+
+        sample_value = [0, 1, 0, 1]
+        obj1 = BitString(sample_value)
+        obj2 = BitString(obj1)
+        assert obj2.value == sample_value
+
+    def test_bit_string_endec(self):
+        if _debug: TestBitString._debug("test_bit_string_endec")
+
+        bit_string_endec([], '00')
+        bit_string_endec([0], '0700')
+        bit_string_endec([1], '0780')
+        bit_string_endec([0] * 2, '0600')
+        bit_string_endec([1] * 2, '06c0')
+        bit_string_endec([0] * 10, '060000')
+        bit_string_endec([1] * 10, '06ffc0')
+

tests/test_primitive_data/test_character_string.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Test Primitive Data Character String
+------------------------------------
+"""
+
+import unittest
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
+from bacpypes.primitivedata import CharacterString, Tag, DecodingError
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+
+# globals
+fox_message = "the quick brown fox jumped over the lazy dog"
+
+@bacpypes_debugging
+def character_string_tag(x):
+    """Convert a hex string to an character_string application tag."""
+    if _debug: character_string_tag._debug("character_string_tag %r", x)
+
+    b = xtob(x)
+    tag = Tag(Tag.applicationTagClass, Tag.characterStringAppTag, len(b), b)
+    if _debug: character_string_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+@bacpypes_debugging
+def character_string_encode(obj):
+    """Encode an CharacterString object into a tag."""
+    if _debug: character_string_encode._debug("character_string_encode %r", obj)
+
+    tag = Tag()
+    obj.encode(tag)
+    if _debug: character_string_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+
+@bacpypes_debugging
+def character_string_decode(tag):
+    """Decode an character_string application tag into an character_string."""
+    if _debug: character_string_decode._debug("character_string_decode %r", tag)
+
+    obj = CharacterString(tag)
+    if _debug: character_string_decode._debug("    - obj: %r", obj)
+
+    return obj
+
+
+@bacpypes_debugging
+def character_string_endec(v, x):
+    """Pass the value to CharacterString, construct a tag from the hex string,
+    and compare results of encode and decoding each other."""
+    if _debug: character_string_endec._debug("character_string_endec %r %r", v, x)
+
+    tag = character_string_tag(x)
+    if _debug: character_string_endec._debug("    - tag: %r, %r", tag, tag.tagData)
+
+    obj = CharacterString(v)
+    if _debug: character_string_endec._debug("    - obj: %r, %r", obj, obj.value)
+
+    assert character_string_encode(obj) == tag
+    assert character_string_decode(tag) == obj
+
+
+@bacpypes_debugging
+class TestCharacterString(unittest.TestCase):
+
+    def test_character_string(self):
+        if _debug: TestCharacterString._debug("test_character_string")
+
+        obj = CharacterString()
+        assert obj.value == ''
+
+        with self.assertRaises(TypeError):
+            CharacterString(1)
+        with self.assertRaises(TypeError):
+            CharacterString(1.0)
+
+    def test_character_string_str(self):
+        if _debug: TestCharacterString._debug("test_character_string_str")
+
+        obj = CharacterString("hello")
+        assert obj.value == "hello"
+        assert str(obj) == "CharacterString(0,'hello')"
+
+    def test_character_string_tag(self):
+        if _debug: TestCharacterString._debug("test_character_string_tag")
+
+        tag = Tag(Tag.applicationTagClass, Tag.characterStringAppTag, 1, xtob('00'))
+        obj = CharacterString(tag)
+        assert obj.value == ''
+
+        tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 0, xtob(''))
+        with self.assertRaises(ValueError):
+            CharacterString(tag)
+
+        tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
+        with self.assertRaises(ValueError):
+            CharacterString(tag)
+
+        tag = Tag(Tag.openingTagClass, 0)
+        with self.assertRaises(ValueError):
+            CharacterString(tag)
+
+    def test_character_string_copy(self):
+        if _debug: TestCharacterString._debug("test_character_string_copy")
+
+        obj1 = CharacterString(fox_message)
+        obj2 = CharacterString(obj1)
+        assert obj2.value == fox_message
+
+    def test_character_string_endec(self):
+        if _debug: TestCharacterString._debug("test_character_string_endec")
+
+#       with self.assertRaises(DecodingError):
+#           obj = CharacterString(character_string_tag(''))
+
+        character_string_endec("", '00')
+        character_string_endec("abc", '00616263')

tests/test_primitive_data/test_date.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Test Primitive Data Date
+---------------------------
+"""
+
+import unittest
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
+from bacpypes.primitivedata import Date, Tag, DecodingError
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+
+@bacpypes_debugging
+def date_tag(x):
+    """Convert a hex string to an date application tag."""
+    if _debug: date_tag._debug("date_tag %r", x)
+
+    b = xtob(x)
+    tag = Tag(Tag.applicationTagClass, Tag.dateAppTag, len(b), b)
+    if _debug: date_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+@bacpypes_debugging
+def date_encode(obj):
+    """Encode an Date object into a tag."""
+    if _debug: date_encode._debug("date_encode %r", obj)
+
+    tag = Tag()
+    obj.encode(tag)
+    if _debug: date_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+
+@bacpypes_debugging
+def date_decode(tag):
+    """Decode an date application tag into an date."""
+    if _debug: date_decode._debug("date_decode %r", tag)
+
+    obj = Date(tag)
+    if _debug: date_decode._debug("    - obj: %r", obj)
+
+    return obj
+
+
+@bacpypes_debugging
+def date_endec(v, x):
+    """Pass the value to Date, construct a tag from the hex string,
+    and compare results of encode and decoding each other."""
+    if _debug: date_endec._debug("date_endec %r %r", v, x)
+
+    tag = date_tag(x)
+    if _debug: date_endec._debug("    - tag: %r, %r", tag, tag.tagData)
+
+    obj = Date(v)
+    if _debug: date_endec._debug("    - obj: %r, %r", obj, obj.value)
+
+    assert date_encode(obj) == tag
+    assert date_decode(tag) == obj
+
+
+@bacpypes_debugging
+class TestDate(unittest.TestCase):
+
+    def test_date(self):
+        if _debug: TestDate._debug("test_date")
+
+        # default values is all dont care
+        obj = Date()
+        assert obj.value == (255, 255, 255, 255)
+
+        with self.assertRaises(ValueError):
+            Date("some string")
+        with self.assertRaises(TypeError):
+            Date(1.0)
+
+    def test_date_tuple(self):
+        if _debug: TestDate._debug("test_date_tuple")
+
+        obj = Date((1,2,3,4))
+        assert obj.value == (1, 2, 3, 4)
+        assert str(obj) == "Date(2/3/1901 Thu)"
+
+        ### issue-48
+        # obj = Date("1/2/3")
+        # assert obj.value == (1, 2, x, y)
+
+        # obj = Date("*/2/3")
+        # assert obj.value == (255, 2, x, 255)
+
+        # obj = Date("1/*/3")
+        # assert obj.value == (1, 255, x, 255)
+
+        # obj = Date("1/2/*")
+        # assert obj.value == (1, 2, 255, 255)
+
+        # obj = Date("1/2/3 *")
+        # assert obj.value == (1, 2, 3, 255)
+
+    def test_date_tag(self):
+        if _debug: TestDate._debug("test_date_tag")
+
+        tag = Tag(Tag.applicationTagClass, Tag.dateAppTag, 1, xtob('01020304'))
+        obj = Date(tag)
+        assert obj.value == (1, 2, 3, 4)
+
+        tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 0, xtob(''))
+        with self.assertRaises(ValueError):
+            Date(tag)
+
+        tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
+        with self.assertRaises(ValueError):
+            Date(tag)
+
+        tag = Tag(Tag.openingTagClass, 0)
+        with self.assertRaises(ValueError):
+            Date(tag)
+
+    def test_date_copy(self):
+        if _debug: TestDate._debug("test_date_copy")
+
+        date_value = (2, 3, 4, 5)
+        obj1 = Date(date_value)
+        obj2 = Date(obj1)
+        assert obj2.value == date_value
+
+    def test_date_now(self):
+        if _debug: TestDate._debug("test_date_now")
+
+        # obj = Date().now()
+        ### how to test?
+
+    def test_date_endec(self):
+        if _debug: TestDate._debug("test_date_endec")
+
+#       with self.assertRaises(DecodingError):
+#           obj = Date(date_tag(''))
+
+        date_endec((0, 0, 0, 0), '00000000')
+        date_endec((1, 0, 0, 0), '01000000')
+        date_endec((0, 2, 0, 0), '00020000')
+        date_endec((0, 0, 3, 0), '00000300')
+        date_endec((0, 0, 0, 4), '00000004')

tests/test_primitive_data/test_double.py

@@ -11,7 +11,7 @@ import struct
 import math
 
 from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
-from bacpypes.primitivedata import Double, Tag
+from bacpypes.primitivedata import Double, Tag, DecodingError
 
 # some debugging
 _debug = 0
@@ -126,8 +126,8 @@ class TestDouble(unittest.TestCase):
     def test_double_endec(self):
         if _debug: TestDouble._debug("test_double_endec")
 
-        with self.assertRaises(struct.error):
+#       with self.assertRaises(DecodingError):
-            obj = Double(double_tag(''))
+#           obj = Double(double_tag(''))
 
         double_endec(0, '0000000000000000')
         double_endec(1, '3ff0000000000000')

tests/test_primitive_data/test_enumerated.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Test Primitive Data Enumerated
+------------------------------
+"""
+
+import unittest
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
+from bacpypes.primitivedata import Enumerated, Tag, DecodingError
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+
+@bacpypes_debugging
+def enumerated_tag(x):
+    """Convert a hex string to an enumerated application tag."""
+    if _debug: enumerated_tag._debug("enumerated_tag %r", x)
+
+    b = xtob(x)
+    tag = Tag(Tag.applicationTagClass, Tag.enumeratedAppTag, len(b), b)
+    if _debug: enumerated_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+@bacpypes_debugging
+def enumerated_encode(obj):
+    """Encode an Enumerated object into a tag."""
+    if _debug: enumerated_encode._debug("enumerated_encode %r", obj)
+
+    tag = Tag()
+    obj.encode(tag)
+    if _debug: enumerated_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+
+@bacpypes_debugging
+def enumerated_decode(tag):
+    """Decode an enumerated application tag into an enumerated."""
+    if _debug: enumerated_decode._debug("enumerated_decode %r", tag)
+
+    obj = Enumerated(tag)
+    if _debug: enumerated_decode._debug("    - obj: %r", obj)
+
+    return obj
+
+
+@bacpypes_debugging
+def enumerated_endec(v, x):
+    """Pass the value to Enumerated, construct a tag from the hex string,
+    and compare results of encode and decoding each other."""
+    if _debug: enumerated_endec._debug("enumerated_endec %r %r", v, x)
+
+    tag = enumerated_tag(x)
+    if _debug: enumerated_endec._debug("    - tag: %r, %r", tag, tag.tagData)
+
+    obj = Enumerated(v)
+    if _debug: enumerated_endec._debug("    - obj: %r, %r", obj, obj.value)
+
+    assert enumerated_encode(obj) == tag
+    assert enumerated_decode(tag) == obj
+
+
+@bacpypes_debugging
+class TestEnumerated(unittest.TestCase):
+
+    def test_enumerated(self):
+        if _debug: TestEnumerated._debug("test_enumerated")
+
+        obj = Enumerated()
+        assert obj.value == 0
+
+        with self.assertRaises(ValueError):
+            Enumerated("label")
+        with self.assertRaises(TypeError):
+            Enumerated(1.0)
+
+    def test_enumerated_int(self):
+        if _debug: TestEnumerated._debug("test_enumerated_int")
+
+        obj = Enumerated(1)
+        assert obj.value == 1
+        assert str(obj) == "Enumerated(1)"
+
+        with self.assertRaises(ValueError):
+            Enumerated(-1)
+
+    def test_enumerated_tag(self):
+        if _debug: TestEnumerated._debug("test_enumerated_tag")
+
+        tag = Tag(Tag.applicationTagClass, Tag.enumeratedAppTag, 1, xtob('01'))
+        obj = Enumerated(tag)
+        assert obj.value == 1
+
+        tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 0, xtob(''))
+        with self.assertRaises(ValueError):
+            Enumerated(tag)
+
+        tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
+        with self.assertRaises(ValueError):
+            Enumerated(tag)
+
+        tag = Tag(Tag.openingTagClass, 0)
+        with self.assertRaises(ValueError):
+            Enumerated(tag)
+
+    def test_enumerated_copy(self):
+        if _debug: TestEnumerated._debug("test_enumerated_copy")
+
+        obj1 = Enumerated(12)
+        obj2 = Enumerated(obj1)
+        assert obj2.value == 12
+
+    def test_enumerated_endec(self):
+        if _debug: TestEnumerated._debug("test_enumerated_endec")
+
+#       with self.assertRaises(DecodingError):
+#           obj = Enumerated(enumerated_tag(''))
+
+        enumerated_endec(0, '00')
+        enumerated_endec(1, '01')
+        enumerated_endec(127, '7f')
+        enumerated_endec(128, '80')
+        enumerated_endec(255, 'ff')
+
+        enumerated_endec(32767, '7fff')
+        enumerated_endec(32768, '8000')
+
+        enumerated_endec(8388607, '7fffff')
+        enumerated_endec(8388608, '800000')
+
+        enumerated_endec(2147483647, '7fffffff')
+        enumerated_endec(2147483648, '80000000')

tests/test_primitive_data/test_integer.py

@@ -9,7 +9,7 @@ Test Primitive Data Integer
 import unittest
 
 from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
-from bacpypes.primitivedata import Integer, Tag
+from bacpypes.primitivedata import Integer, Tag, DecodingError
 
 # some debugging
 _debug = 0
@@ -120,8 +120,8 @@ class TestInteger(unittest.TestCase):
     def test_integer_endec(self):
         if _debug: TestInteger._debug("test_integer_endec")
 
-        with self.assertRaises(IndexError):
+#       with self.assertRaises(DecodingError):
-            obj = Integer(integer_tag(''))
+#           obj = Integer(integer_tag(''))
 
         integer_endec(0, '00')
         integer_endec(1, '01')

tests/test_primitive_data/test_object_identifier.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Test Primitive Data Object Identifier
+-------------------------------------
+"""
+
+import unittest
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
+from bacpypes.primitivedata import ObjectIdentifier, Tag, DecodingError
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+
+@bacpypes_debugging
+def object_identifier_tag(x):
+    """Convert a hex string to an object_identifier application tag."""
+    if _debug: object_identifier_tag._debug("object_identifier_tag %r", x)
+
+    b = xtob(x)
+    tag = Tag(Tag.applicationTagClass, Tag.objectIdentifierAppTag, len(b), b)
+    if _debug: object_identifier_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+
+@bacpypes_debugging
+def object_identifier_encode(obj):
+    """Encode an ObjectIdentifier object into a tag."""
+    if _debug: object_identifier_encode._debug("object_identifier_encode %r", obj)
+
+    tag = Tag()
+    obj.encode(tag)
+    if _debug: object_identifier_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+
+@bacpypes_debugging
+def object_identifier_decode(tag):
+    """Decode an object_identifier application tag into an object_identifier."""
+    if _debug: object_identifier_decode._debug("object_identifier_decode %r", tag)
+
+    obj = ObjectIdentifier(tag)
+    if _debug: object_identifier_decode._debug("    - obj: %r", obj)
+
+    return obj
+
+
+@bacpypes_debugging
+def object_identifier_endec(v, x):
+    """Pass the value to ObjectIdentifier, construct a tag from the hex string,
+    and compare results of encode and decoding each other."""
+    if _debug: object_identifier_endec._debug("object_identifier_endec %r %r", v, x)
+
+    tag = object_identifier_tag(x)
+    if _debug: object_identifier_endec._debug("    - tag: %r, %r", tag, tag.tagData)
+
+    obj = ObjectIdentifier(v)
+    if _debug: object_identifier_endec._debug("    - obj: %r, %r", obj, obj.value)
+
+    assert object_identifier_encode(obj) == tag
+    assert object_identifier_decode(tag) == obj
+
+
+@bacpypes_debugging
+class TestObjectIdentifier(unittest.TestCase):
+
+    def test_object_identifier(self):
+        if _debug: TestObjectIdentifier._debug("test_object_identifier")
+
+        obj = ObjectIdentifier()
+        assert obj.value == ('analogInput', 0)
+
+        with self.assertRaises(TypeError):
+            ObjectIdentifier("some string")
+        with self.assertRaises(TypeError):
+            ObjectIdentifier(1.0)
+
+    def test_object_identifier_int(self):
+        if _debug: TestObjectIdentifier._debug("test_object_identifier_int")
+
+        obj = ObjectIdentifier(1)
+        assert obj.value == ('analogInput', 1)
+        assert str(obj) == "ObjectIdentifier(analogInput,1)"
+
+        obj = ObjectIdentifier(0x0400002)
+        assert obj.value == ('analogOutput', 2)
+        assert str(obj) == "ObjectIdentifier(analogOutput,2)"
+
+    def test_object_identifier_tag(self):
+        if _debug: TestObjectIdentifier._debug("test_object_identifier_tag")
+
+        tag = Tag(Tag.applicationTagClass, Tag.objectIdentifierAppTag, 1, xtob('06000003'))
+        obj = ObjectIdentifier(tag)
+        assert obj.value == ('pulseConverter', 3)
+
+        tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 0, xtob(''))
+        with self.assertRaises(ValueError):
+            ObjectIdentifier(tag)
+
+        tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
+        with self.assertRaises(ValueError):
+            ObjectIdentifier(tag)
+
+        tag = Tag(Tag.openingTagClass, 0)
+        with self.assertRaises(ValueError):
+            ObjectIdentifier(tag)
+
+    def test_object_identifier_copy(self):
+        if _debug: TestObjectIdentifier._debug("test_object_identifier_copy")
+
+        ### issue-49
+        # obj1 = ObjectIdentifier(('analogInput', 1))
+        # obj2 = ObjectIdentifier(obj1)
+        # assert obj2.value == ('analogInput', 1)
+
+    def test_object_identifier_endec(self):
+        if _debug: TestObjectIdentifier._debug("test_object_identifier_endec")
+
+        ### this should raise a DecodingError
+        # with self.assertRaises(DecodingError):
+        #     obj = ObjectIdentifier(object_identifier_tag(''))
+
+        # test standard types
+        object_identifier_endec(('analogInput', 0), '00000000')
+
+        # test vendor types

tests/test_primitive_data/test_object_type.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Test Primitive Data ObjectType
+------------------------------
+"""
+
+import unittest
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
+from bacpypes.primitivedata import ObjectType, Tag, DecodingError, \
+    expand_enumerations
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+
+class MyObjectType(ObjectType):
+    enumerations = {
+        'myAnalogInput': 128,
+        'myAnalogOutput': 129,
+        'myAnalogValue': 130,
+    }
+
+expand_enumerations(MyObjectType)
+
+
+@bacpypes_debugging
+def object_type_tag(x):
+    """Convert a hex string to an enumerated application tag."""
+    if _debug: object_type_tag._debug("object_type_tag %r", x)
+
+    b = xtob(x)
+    tag = Tag(Tag.applicationTagClass, Tag.enumeratedAppTag, len(b), b)
+    if _debug: object_type_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+@bacpypes_debugging
+def object_type_encode(obj):
+    """Encode an ObjectType object into a tag."""
+    if _debug: object_type_encode._debug("object_type_encode %r", obj)
+
+    tag = Tag()
+    obj.encode(tag)
+    if _debug: object_type_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+
+@bacpypes_debugging
+def object_type_decode(tag):
+    """Decode an enumerated application tag into an object_type."""
+    if _debug: object_type_decode._debug("object_type_decode %r", tag)
+
+    obj = ObjectType(tag)
+    if _debug: object_type_decode._debug("    - obj: %r", obj)
+
+    return obj
+
+
+@bacpypes_debugging
+def object_type_endec(v, x):
+    """Pass the value to ObjectType, construct a tag from the hex string,
+    and compare results of encode and decoding each other."""
+    if _debug: object_type_endec._debug("object_type_endec %r %r", v, x)
+
+    tag = object_type_tag(x)
+    if _debug: object_type_endec._debug("    - tag: %r, %r", tag, tag.tagData)
+
+    obj = ObjectType(v)
+    if _debug: object_type_endec._debug("    - obj: %r, %r", obj, obj.value)
+
+    assert object_type_encode(obj) == tag
+    assert object_type_decode(tag) == obj
+
+
+@bacpypes_debugging
+class TestObjectType(unittest.TestCase):
+
+    def test_object_type(self):
+        if _debug: TestObjectType._debug("test_object_type")
+
+        obj = ObjectType()
+        assert obj.value == 0
+
+        with self.assertRaises(ValueError):
+            ObjectType("unknownType")
+        with self.assertRaises(TypeError):
+            ObjectType(1.0)
+
+    def test_object_type_int(self):
+        if _debug: TestObjectType._debug("test_object_type_int")
+
+        # known values are translated into strings
+        obj = ObjectType(0)
+        assert obj.value == 'analogInput'
+        assert str(obj) == "Enumerated(analogInput)"
+
+        # unknown values are kept as integers
+        obj = ObjectType(127)
+        assert obj.value == 127
+        assert str(obj) == "Enumerated(127)"
+
+    def test_object_type_str(self):
+        if _debug: TestObjectType._debug("test_object_type_str")
+
+        # known strings are accepted
+        obj = ObjectType('analogInput')
+        assert obj.value == 'analogInput'
+
+    def test_object_type_tag(self):
+        if _debug: TestObjectType._debug("test_object_type_tag")
+
+        tag = Tag(Tag.applicationTagClass, Tag.enumeratedAppTag, 1, xtob('01'))
+        obj = ObjectType(tag)
+        assert obj.value == 'analogOutput'
+
+        tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 0, xtob(''))
+        with self.assertRaises(ValueError):
+            ObjectType(tag)
+
+        tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
+        with self.assertRaises(ValueError):
+            ObjectType(tag)
+
+        tag = Tag(Tag.openingTagClass, 0)
+        with self.assertRaises(ValueError):
+            ObjectType(tag)
+
+    def test_object_type_copy(self):
+        if _debug: TestObjectType._debug("test_object_type_copy")
+
+        # known values are translated into strings
+        obj1 = ObjectType(12)
+        obj2 = ObjectType(obj1)
+        assert obj2.value == 'loop'
+
+    def test_object_type_endec(self):
+        if _debug: TestObjectType._debug("test_object_type_endec")
+
+#       with self.assertRaises(DecodingError):
+#           obj = ObjectType(object_type_tag(''))
+
+        object_type_endec('analogInput', '00')
+        object_type_endec('analogOutput', '01')
+
+        object_type_endec(127, '7f')
+        object_type_endec(128, '80')

tests/test_primitive_data/test_real.py

@@ -11,7 +11,7 @@ import struct
 import math
 
 from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
-from bacpypes.primitivedata import Real, Tag
+from bacpypes.primitivedata import Real, Tag, DecodingError
 
 # some debugging
 _debug = 0
@@ -127,8 +127,8 @@ class TestReal(unittest.TestCase):
     def test_real_endec(self):
         if _debug: TestReal._debug("test_real_endec")
 
-        with self.assertRaises(struct.error):
+#       with self.assertRaises(DecodingError):
-            obj = Real(real_tag(''))
+#           obj = Real(real_tag(''))
 
         real_endec(0, '00000000')
         real_endec(1, '3f800000')

tests/test_primitive_data/test_tag.py

@@ -0,0 +1,585 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Test Primitive Data Tag
+-----------------------
+"""
+
+import unittest
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob, btox
+from bacpypes.primitivedata import Tag, ApplicationTag, ContextTag, \
+    OpeningTag, ClosingTag, TagList, \
+    Null, Boolean, Unsigned, Integer, Real, Double, OctetString, \
+    CharacterString, BitString, Enumerated, Date, Time, ObjectIdentifier, \
+    DecodingError
+from bacpypes.pdu import PDUData
+
+from test_integer import integer_tag
+from test_unsigned import unsigned_tag
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+
+def tag_tuple(tag):
+    """Simple function to decompose a tag for debugging."""
+    return (tag.tagClass, tag.tagNumber, tag.tagLVT, tag.tagData)
+
+
+@bacpypes_debugging
+def obj_decode(blob):
+    """Build PDU from the string, decode the tag, convert to an object."""
+    if _debug: obj_decode._debug("obj_decode %r", blob)
+
+    data = PDUData(blob)
+    tag = Tag(data)
+    obj = tag.app_to_object()
+    return obj
+
+
+@bacpypes_debugging
+def obj_encode(obj):
+    """Encode the object into a tag, encode it in a PDU, return the data."""
+    if _debug: obj_encode._debug("obj_encode %r", obj)
+
+    tag = Tag()
+    obj.encode(tag)
+    data = PDUData()
+    tag.encode(data)
+    return data.pduData
+
+
+@bacpypes_debugging
+def obj_endec(obj, x):
+    """Convert the value (a primitive object) to a hex encoded string, 
+    convert the hex encoded string to and object, and compare the results to
+    each other."""
+    if _debug: obj_endec._debug("obj_endec %r %r", obj, x)
+
+    # convert the hex string to a blob
+    blob = xtob(x)
+
+    # decode the blob into an object
+    obj2 = obj_decode(blob)
+    if _debug: obj_endec._debug("    - obj: %r, %r", obj, obj.value)
+
+    # encode the object into a blob
+    blob2 = obj_encode(obj)
+    if _debug: obj_endec._debug("    - blob2: %r", blob2)
+
+    # compare the results
+    assert obj == obj2
+    assert blob == blob2
+
+
+@bacpypes_debugging
+def context_decode(blob):
+    """Build PDU from the string, decode the tag, convert to an object."""
+    if _debug: context_decode._debug("context_decode %r", blob)
+
+    data = PDUData(blob)
+    tag = ContextTag(data)
+    return tag
+
+
+@bacpypes_debugging
+def context_encode(tag):
+    """Encode the object into a tag, encode it in a PDU, return the data."""
+    if _debug: context_encode._debug("context_encode %r", tag)
+
+    data = PDUData()
+    tag.encode(data)
+    return data.pduData
+
+
+@bacpypes_debugging
+def context_endec(tnum, x, y):
+    """Convert the value (a primitive object) to a hex encoded string, 
+    convert the hex encoded string to and object, and compare the results to
+    each other."""
+    if _debug: context_endec._debug("context_endec %r %r %r", tnum, x, y)
+
+    # convert the hex strings to a blobs
+    tdata = xtob(x)
+    blob1 = xtob(y)
+
+    # make a context tag
+    tag1 = ContextTag(tnum, tdata)
+
+    # decode the blob into a tag
+    tag2 = context_decode(blob1)
+    if _debug: context_endec._debug("    - tag: %r", tag)
+
+    # encode the tag into a blob
+    blob2 = context_encode(tag1)
+    if _debug: context_endec._debug("    - blob2: %r", blob2)
+
+    # compare the results
+    assert tag1 == tag2
+    assert blob1 == blob2
+
+
+@bacpypes_debugging
+def opening_decode(blob):
+    """Build PDU from the string, decode the tag, convert to an object."""
+    if _debug: opening_decode._debug("opening_decode %r", blob)
+
+    data = PDUData(blob)
+    tag = OpeningTag(data)
+    return tag
+
+
+@bacpypes_debugging
+def opening_encode(tag):
+    """Encode the object into a tag, encode it in a PDU, return the data."""
+    if _debug: opening_encode._debug("opening_encode %r", tag)
+
+    data = PDUData()
+    tag.encode(data)
+    return data.pduData
+
+
+@bacpypes_debugging
+def opening_endec(tnum, x):
+    """Convert the value (a primitive object) to a hex encoded string, 
+    convert the hex encoded string to and object, and compare the results to
+    each other."""
+    if _debug: opening_endec._debug("opening_endec %r %r", tnum, x)
+
+    # convert the hex string to a blob
+    blob1 = xtob(x)
+
+    # make a context tag
+    tag1 = OpeningTag(tnum)
+    if _debug: opening_endec._debug("    - tag1: %r", tag1)
+
+    # decode the blob into a tag
+    tag2 = opening_decode(blob1)
+    if _debug: opening_endec._debug("    - tag2: %r", tag2)
+
+    # encode the tag into a blob
+    blob2 = opening_encode(tag1)
+    if _debug: opening_endec._debug("    - blob2: %r", blob2)
+
+    # compare the results
+    assert tag1 == tag2
+    assert blob1 == blob2
+
+
+@bacpypes_debugging
+def closing_decode(blob):
+    """Build PDU from the string, decode the tag, convert to an object."""
+    if _debug: closing_decode._debug("closing_decode %r", blob)
+
+    data = PDUData(blob)
+    tag = ClosingTag(data)
+    return tag
+
+
+@bacpypes_debugging
+def closing_encode(tag):
+    """Encode the object into a tag, encode it in a PDU, return the data."""
+    if _debug: closing_encode._debug("closing_encode %r", tag)
+
+    data = PDUData()
+    tag.encode(data)
+    return data.pduData
+
+
+@bacpypes_debugging
+def closing_endec(tnum, x):
+    """Convert the value (a primitive object) to a hex encoded string, 
+    convert the hex encoded string to and object, and compare the results to
+    each other."""
+    if _debug: closing_endec._debug("closing_endec %r %r", tnum, x)
+
+    # convert the hex string to a blob
+    blob1 = xtob(x)
+
+    # make a context tag
+    tag1 = ClosingTag(tnum)
+    if _debug: closing_endec._debug("    - tag1: %r", tag1)
+
+    # decode the blob into a tag
+    tag2 = closing_decode(blob1)
+    if _debug: closing_endec._debug("    - tag2: %r", tag2)
+
+    # encode the tag into a blob
+    blob2 = closing_encode(tag1)
+    if _debug: closing_endec._debug("    - blob2: %r", blob2)
+
+    # compare the results
+    assert tag1 == tag2
+    assert blob1 == blob2
+
+
+@bacpypes_debugging
+def tag(tag_class, tag_number, x):
+    """Create a tag object with the given class, number, and data."""
+    if _debug: tag._debug("tag %r %r %r", tag_class, tag_number, x)
+
+    b = xtob(x)
+    tag = Tag(tag_class, tag_number, len(b), b)
+    if _debug: tag_tuple._debug("    - tag: %r", tag)
+
+    return tag
+
+
+@bacpypes_debugging
+class TestTag(unittest.TestCase):
+
+    def test_tag(self):
+        if _debug: TestTag._debug("test_tag")
+
+        # test tag construction
+        tag = Tag()
+        assert (tag.tagClass, tag.tagNumber) == (None, None)
+
+        # must have a valid encoded tag to extract from the data
+        data = PDUData(xtob(''))
+        with self.assertRaises(DecodingError):
+            tag = Tag(data)
+
+        # must have two values, class and number
+        with self.assertRaises(ValueError):
+            tag = Tag(0)
+
+        tag = Tag(0, 1)
+        assert (tag.tagClass, tag.tagNumber) == (0, 1)
+
+        tag = Tag(0, 1, 2)
+        assert (tag.tagClass, tag.tagNumber, tag.tagLVT) == (0, 1, 2)
+
+        # tag data must be bytes or bytearray
+        with self.assertRaises(TypeError):
+            tag = Tag(0, 1, 2, 3)
+
+@bacpypes_debugging
+class TestApplicationTag(unittest.TestCase):
+
+    def test_application_tag(self):
+        if _debug: TestApplicationTag._debug("test_application_tag")
+
+        # application tag construction, encoding, and decoding
+        tag = ApplicationTag(0, xtob(''))
+        if _debug: TestApplicationTag._debug("    - tag: %r", tag_tuple(tag))
+
+        with self.assertRaises(ValueError):
+            tag = ApplicationTag(0)
+
+    def test_generic_application_to_context(self):
+        if _debug: TestApplicationTag._debug("test_generic_application_to_context")
+
+        # create an application
+        tag = ApplicationTag(0, xtob('01'))
+        if _debug: TestApplicationTag._debug("    - tag: %r", tag_tuple(tag))
+
+        # convert it to context tagged, context 0
+        ctag = tag.app_to_context(0)
+        if _debug: TestApplicationTag._debug("    - ctag: %r", tag_tuple(ctag))
+
+        # create a context tag with the same shape
+        ttag = ContextTag(0, xtob('01'))
+        if _debug: TestApplicationTag._debug("    - ttag: %r", tag_tuple(ttag))
+
+        # check to see they are the same
+        assert ctag == ttag
+
+        # convert the context tag back to an application tag
+        dtag = ctag.context_to_app(0)
+        if _debug: TestApplicationTag._debug("    - dtag: %r", tag_tuple(dtag))
+
+        # check to see it round-tripped
+        assert dtag == tag
+
+    def test_boolean_application_to_context(self):
+        if _debug: TestApplicationTag._debug("test_boolean_application_to_context")
+
+        # create an application
+        tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 0)
+        if _debug: TestApplicationTag._debug("    - tag: %r", tag_tuple(tag))
+
+        # convert it to context tagged, context 0
+        ctag = tag.app_to_context(0)
+        if _debug: TestApplicationTag._debug("    - ctag: %r", tag_tuple(ctag))
+
+        # create a context tag with the same shape
+        ttag = ContextTag(0, xtob('00'))
+        if _debug: TestApplicationTag._debug("    - ttag: %r", tag_tuple(ttag))
+
+        # check to see they are the same
+        assert ctag == ttag
+
+        # convert the context tag back to an application tag
+        dtag = ctag.context_to_app(Tag.booleanAppTag)
+        if _debug: TestApplicationTag._debug("    - dtag: %r", tag_tuple(dtag))
+
+        # check to see it round-tripped
+        assert dtag == tag
+
+    def test_boolean_application_to_object(self):
+        if _debug: TestApplicationTag._debug("test_boolean_application_to_object")
+
+        # null
+        obj_endec(Null(), '00')
+
+        # boolean
+        obj_endec(Boolean(True), '11')
+        obj_endec(Boolean(False), '10')
+
+        # unsigned
+        obj_endec(Unsigned(0), '2100')
+        obj_endec(Unsigned(1), '2101')
+        obj_endec(Unsigned(127), '217F')
+        obj_endec(Unsigned(128), '2180')
+
+        # integer
+        obj_endec(Integer(0), '3100')
+        obj_endec(Integer(1), '3101')
+        obj_endec(Integer(-1), '31FF')
+        obj_endec(Integer(128), '320080')
+        obj_endec(Integer(-128), '3180')
+
+        # real
+        obj_endec(Real(0), '4400000000')
+        obj_endec(Real(1), '443F800000')
+        obj_endec(Real(-1), '44BF800000')
+        obj_endec(Real(73.5), '4442930000')
+
+        # double
+        obj_endec(Double(0), '55080000000000000000')
+        obj_endec(Double(1), '55083FF0000000000000')
+        obj_endec(Double(-1), '5508BFF0000000000000')
+        obj_endec(Double(73.5), '55084052600000000000')
+
+        # octet string
+        obj_endec(OctetString(xtob('')), '60')
+        obj_endec(OctetString(xtob('01')), '6101')
+        obj_endec(OctetString(xtob('0102')), '620102')
+        obj_endec(OctetString(xtob('010203040506')), '6506010203040506')
+
+        # character string
+        obj_endec(CharacterString(''), '7100')
+        obj_endec(CharacterString('a'), '720061')
+        obj_endec(CharacterString('abcde'), '7506006162636465')
+
+        # bit string
+        obj_endec(BitString([]), '8100')
+        obj_endec(BitString([0]), '820700')
+        obj_endec(BitString([1]), '820780')
+        obj_endec(BitString([1, 1, 1, 1, 1]), '8203F8')
+        obj_endec(BitString([1] * 10), '8306FFC0')
+
+        # enumerated
+        obj_endec(Enumerated(0), '9100')
+        obj_endec(Enumerated(1), '9101')
+        obj_endec(Enumerated(127), '917F')
+        obj_endec(Enumerated(128), '9180')
+
+        # date
+        obj_endec(Date((1,2,3,4)), 'A401020304')
+        obj_endec(Date((255,2,3,4)), 'A4FF020304')
+        obj_endec(Date((1,255,3,4)), 'A401FF0304')
+        obj_endec(Date((1,2,255,4)), 'A40102FF04')
+        obj_endec(Date((1,2,3,255)), 'A4010203FF')
+
+        # time
+        obj_endec(Time((1,2,3,4)), 'B401020304')
+        obj_endec(Time((255,2,3,4)), 'B4FF020304')
+        obj_endec(Time((1,255,3,4)), 'B401FF0304')
+        obj_endec(Time((1,2,255,4)), 'B40102FF04')
+        obj_endec(Time((1,2,3,255)), 'B4010203FF')
+
+        # object identifier
+        obj_endec(ObjectIdentifier(0,0), 'C400000000')
+        obj_endec(ObjectIdentifier(1,0), 'C400400000')
+        obj_endec(ObjectIdentifier(0,2), 'C400000002')
+        obj_endec(ObjectIdentifier(3,4), 'C400C00004')
+
+
+@bacpypes_debugging
+class TestContextTag(unittest.TestCase):
+
+    def test_context_tag(self):
+        if _debug: TestContextTag._debug("test_context_tag")
+
+        # test context tag construction
+        tag = ContextTag(0, xtob(''))
+        with self.assertRaises(ValueError):
+            tag = ContextTag()
+
+        # test encoding and decoding
+        context_endec(0, '', '08')
+        context_endec(1, '01', '1901')
+        context_endec(2, '0102', '2A0102')
+        context_endec(3, '010203', '3B010203')
+        context_endec(14, '010203', 'EB010203')
+        context_endec(15, '010203', 'FB0F010203')
+
+@bacpypes_debugging
+class TestOpeningTag(unittest.TestCase):
+
+    def test_opening_tag(self):
+        if _debug: TestOpeningTag._debug("test_opening_tag")
+
+        # test opening tag construction
+        tag = OpeningTag(0)
+        with self.assertRaises(TypeError):
+            tag = OpeningTag()
+
+        # test encoding, and decoding
+        opening_endec(0, '0E')
+        opening_endec(1, '1E')
+        opening_endec(2, '2E')
+        opening_endec(3, '3E')
+        opening_endec(14, 'EE')
+#       opening_endec(15, 'FE0F')
+
+
+@bacpypes_debugging
+class TestClosingTag(unittest.TestCase):
+
+    def test_closing_tag(self):
+        if _debug: TestClosingTag._debug("test_closing_tag")
+
+        # test closing tag construction
+        tag = ClosingTag(0)
+        with self.assertRaises(TypeError):
+            tag = ClosingTag()
+
+        # test encoding, and decoding
+        closing_endec(0, '0F')
+        closing_endec(1, '1F')
+        closing_endec(2, '2F')
+        closing_endec(3, '3F')
+        closing_endec(14, 'EF')
+#       closing_endec(15, 'FE0F')
+
+
+@bacpypes_debugging
+class TestTagList(unittest.TestCase):
+
+    def test_tag_list(self):
+        if _debug: TestTagList._debug("test_tag_list")
+
+        # test tag list construction
+        tag_list = TagList()
+        tag_list = TagList([])
+
+    def test_peek(self):
+        if _debug: TestTagList._debug("test_peek")
+
+        tag0 = integer_tag('00')
+        taglist = TagList([tag0])
+
+        # peek at the first tag
+        assert tag0 == taglist.Peek()
+
+        # pop of the front
+        tag1 = taglist.Pop()
+        assert taglist.tagList == []
+
+        # push it back on the front
+        taglist.push(tag1)
+        assert taglist.tagList == [tag1]
+
+    def test_get_context(self):
+        """Test extracting specific context encoded content.
+        """
+        if _debug: TestTagList._debug("test_get_context")
+
+        tag_list_data = [
+            ContextTag(0, xtob('00')),
+            ContextTag(1, xtob('01')),
+            OpeningTag(2),
+            integer_tag('03'),
+            OpeningTag(0),
+            integer_tag('04'),
+            ClosingTag(0),
+            ClosingTag(2),
+        ]
+        taglist = TagList(tag_list_data)
+
+        # known to be a simple context encoded element
+        context_0 = taglist.get_context(0)
+        if _debug: TestTagList._debug("    - context_0: %r", context_0)
+        assert context_0 == tag_list_data[0]
+
+        # known to be a simple context encoded list of element(s)
+        context_2 = taglist.get_context(2)
+        if _debug: TestTagList._debug("    - context_2: %r", context_2)
+        assert context_2.tagList == tag_list_data[3:7]
+
+        # known missing context
+        context_3 = taglist.get_context(3)
+        if _debug: TestTagList._debug("    - context_3: %r", context_3)
+        assert taglist.get_context(3) is None
+
+    def test_endec_0(self):
+        """Test empty tag list encoding and decoding.
+        """
+        if _debug: TestTagList._debug("test_endec_0")
+
+        taglist = TagList([])
+
+        data = PDUData()
+        taglist.encode(data)
+        assert data.pduData == xtob('')
+
+        taglist = TagList()
+        taglist.decode(data)
+        assert taglist.tagList == []
+
+    def test_endec_1(self):
+        """Test short tag list encoding and decoding, application tags.
+        """
+        if _debug: TestTagList._debug("test_endec_1")
+
+        tag0 = integer_tag('00')
+        tag1 = integer_tag('01')
+        taglist = TagList([tag0, tag1])
+
+        data = PDUData()
+        taglist.encode(data)
+        assert data.pduData == xtob('31003101')
+
+        taglist = TagList()
+        taglist.decode(data)
+        assert taglist.tagList == [tag0, tag1]
+
+    def test_endec_2(self):
+        """Test short tag list encoding and decoding, context tags.
+        """
+        if _debug: TestTagList._debug("test_endec_2")
+
+        tag0 = ContextTag(0, xtob('00'))
+        tag1 = ContextTag(1, xtob('01'))
+        taglist = TagList([tag0, tag1])
+
+        data = PDUData()
+        taglist.encode(data)
+        assert data.pduData == xtob('09001901')
+
+        taglist = TagList()
+        taglist.decode(data)
+        assert taglist.tagList == [tag0, tag1]
+
+    def test_endec_3(self):
+        """Test bracketed application tagged integer encoding and decoding."""
+        if _debug: TestTagList._debug("test_endec_2")
+
+        tag0 = OpeningTag(0)
+        tag1 = integer_tag('0102')
+        tag2 = ClosingTag(0)
+        taglist = TagList([tag0, tag1, tag2])
+
+        data = PDUData()
+        taglist.encode(data)
+        assert data.pduData == xtob('0E3201020F')
+
+        taglist = TagList()
+        taglist.decode(data)
+        assert taglist.tagList == [tag0, tag1, tag2]

tests/test_primitive_data/test_time.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Test Primitive Data Time
+---------------------------
+"""
+
+import unittest
+
+from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
+from bacpypes.primitivedata import Time, Tag
+
+# some debugging
+_debug = 0
+_log = ModuleLogger(globals())
+
+
+@bacpypes_debugging
+def time_tag(x):
+    """Convert a hex string to an time application tag."""
+    if _debug: time_tag._debug("time_tag %r", x)
+
+    b = xtob(x)
+    tag = Tag(Tag.applicationTagClass, Tag.timeAppTag, len(b), b)
+    if _debug: time_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+@bacpypes_debugging
+def time_encode(obj):
+    """Encode an Time object into a tag."""
+    if _debug: time_encode._debug("time_encode %r", obj)
+
+    tag = Tag()
+    obj.encode(tag)
+    if _debug: time_endec._debug("    - tag: %r", tag)
+
+    return tag
+
+
+@bacpypes_debugging
+def time_decode(tag):
+    """Decode an time application tag into an time."""
+    if _debug: time_decode._debug("time_decode %r", tag)
+
+    obj = Time(tag)
+    if _debug: time_decode._debug("    - obj: %r", obj)
+
+    return obj
+
+
+@bacpypes_debugging
+def time_endec(v, x):
+    """Pass the value to Time, construct a tag from the hex string,
+    and compare results of encode and decoding each other."""
+    if _debug: time_endec._debug("time_endec %r %r", v, x)
+
+    tag = time_tag(x)
+    if _debug: time_endec._debug("    - tag: %r, %r", tag, tag.tagData)
+
+    obj = Time(v)
+    if _debug: time_endec._debug("    - obj: %r, %r", obj, obj.value)
+
+    assert time_encode(obj) == tag
+    assert time_decode(tag) == obj
+
+
+@bacpypes_debugging
+class TestTime(unittest.TestCase):
+
+    def test_time(self):
+        if _debug: TestTime._debug("test_time")
+
+        # default values is all dont care
+        obj = Time()
+        assert obj.value == (255, 255, 255, 255)
+
+        with self.assertRaises(ValueError):
+            Time("some string")
+        with self.assertRaises(TypeError):
+            Time(1.0)
+
+    def test_time_tuple(self):
+        if _debug: TestTime._debug("test_time_tuple")
+
+        obj = Time((1,2,3,4))
+        assert obj.value == (1, 2, 3, 4)
+        assert str(obj) == "Time(01:02:03.04)"
+
+        ### issue-47
+        # obj = Time("01:02:03.04")
+        # assert obj.value == (1, 2, 3, 4)
+
+    def test_time_tag(self):
+        if _debug: TestTime._debug("test_time_tag")
+
+        tag = Tag(Tag.applicationTagClass, Tag.timeAppTag, 1, xtob('01020304'))
+        obj = Time(tag)
+        assert obj.value == (1, 2, 3, 4)
+
+        tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 0, xtob(''))
+        with self.assertRaises(ValueError):
+            Time(tag)
+
+        tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
+        with self.assertRaises(ValueError):
+            Time(tag)
+
+        tag = Tag(Tag.openingTagClass, 0)
+        with self.assertRaises(ValueError):
+            Time(tag)
+
+    def test_time_copy(self):
+        if _debug: TestTime._debug("test_time_copy")
+
+        time_value = (2, 3, 4, 5)
+        obj1 = Time(time_value)
+        obj2 = Time(obj1)
+        assert obj2.value == time_value
+
+    def test_time_now(self):
+        if _debug: TestTime._debug("test_time_now")
+
+        # obj = Time().now()
+        ### how to test?
+
+    def test_time_endec(self):
+        if _debug: TestTime._debug("test_time_endec")
+
+        ### this should raise a decoding error
+        # with self.assertRaises(IndexError):
+        #    obj = Time(time_tag(''))
+
+        time_endec((0, 0, 0, 0), '00000000')
+        time_endec((1, 0, 0, 0), '01000000')
+        time_endec((0, 2, 0, 0), '00020000')
+        time_endec((0, 0, 3, 0), '00000300')
+        time_endec((0, 0, 0, 4), '00000004')

tests/test_primitive_data/test_unsigned.py

@@ -9,7 +9,7 @@ Test Primitive Data Unsigned
 import unittest
 
 from bacpypes.debugging import bacpypes_debugging, ModuleLogger, xtob
-from bacpypes.primitivedata import Unsigned, Tag
+from bacpypes.primitivedata import Unsigned, Tag, DecodingError
 
 # some debugging
 _debug = 0
@@ -119,7 +119,7 @@ class TestUnsigned(unittest.TestCase):
     def test_unsigned_endec(self):
         if _debug: TestUnsigned._debug("test_unsigned_endec")
 
-#       with self.assertRaises(IndexError):
+#       with self.assertRaises(DecodingError):
 #           obj = Unsigned(unsigned_tag(''))
 
         unsigned_endec(0, '00')