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_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(InvalidTag):
BitString(tag)
tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
with self.assertRaises(InvalidTag):
BitString(tag)
tag = Tag(Tag.openingTagClass, 0)
with self.assertRaises(InvalidTag):
BitString(tag)
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
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
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
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
def tag_encode(obj, context=None):
"""Encode an atomic object into a tag."""
if _debug: tag_encode._debug("tag_encode %r", obj)
# encode it normally
tag = Tag()
obj.encode(tag)
# check for context encoding
if context is not None:
tag = tag.app_to_context(context)
if _debug: tag_encode._debug(" - tag: %r", tag)
return tag
def IntegerTag(v):
"""Return an application encoded integer tag with the appropriate value.
"""
obj = Integer(v)
tag = Tag()
obj.encode(tag)
return tag
def boolean_tag(value):
"""Convert an integer to an boolean application tag."""
if _debug: boolean_tag._debug("boolean_tag %r", value)
tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, int(value), xtob(''))
if _debug: boolean_endec._debug(" - tag: %r", tag)
return tag
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(InvalidTag):
CharacterString(tag)
tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
with self.assertRaises(InvalidTag):
CharacterString(tag)
tag = Tag(Tag.openingTagClass, 0)
with self.assertRaises(InvalidTag):
CharacterString(tag)
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
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
def test_boolean_tag(self):
if _debug: TestBoolean._debug("test_boolean_tag")
tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 1, xtob('01'))
obj = Boolean(tag)
assert obj.value == 1
tag = Tag(Tag.applicationTagClass, Tag.integerAppTag, 0, xtob(''))
with self.assertRaises(InvalidTag):
Boolean(tag)
tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
with self.assertRaises(InvalidTag):
Boolean(tag)
tag = Tag(Tag.openingTagClass, 0)
with self.assertRaises(InvalidTag):
Boolean(tag)
def boolean_encode(obj):
"""Encode an Boolean object into a tag."""
if _debug: boolean_encode._debug("boolean_encode %r", obj)
tag = Tag()
obj.encode(tag)
if _debug: boolean_endec._debug(" - tag: %r", tag)
return tag
def octet_string_encode(obj):
"""Encode an OctetString object into a tag."""
if _debug: octet_string_encode._debug("octet_string_encode %r", obj)
tag = Tag()
obj.encode(tag)
if _debug: octet_string_endec._debug(" - tag: %r", tag)
return tag
def test_date_tag(self):
if _debug: TestDate._debug("test_date_tag")
tag = Tag(Tag.applicationTagClass, Tag.dateAppTag, 4, xtob('01020304'))
obj = Date(tag)
assert obj.value == (1, 2, 3, 4)
tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 0, xtob(''))
with self.assertRaises(InvalidTag):
Date(tag)
tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
with self.assertRaises(InvalidTag):
Date(tag)
tag = Tag(Tag.openingTagClass, 0)
with self.assertRaises(InvalidTag):
Date(tag)
def unsigned_encode(obj):
"""Encode an Unsigned object into a tag."""
if _debug: unsigned_encode._debug("unsigned_encode %r", obj)
tag = Tag()
obj.encode(tag)
if _debug: unsigned_endec._debug(" - tag: %r", tag)
return tag
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
def test_unsigned_tag(self):
if _debug: TestUnsigned._debug("test_unsigned_tag")
tag = Tag(Tag.applicationTagClass, Tag.unsignedAppTag, 1, xtob('01'))
obj = Unsigned(tag)
assert obj.value == 1
tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 0, xtob(''))
with self.assertRaises(InvalidTag):
Unsigned(tag)
tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
with self.assertRaises(InvalidTag):
Unsigned(tag)
tag = Tag(Tag.openingTagClass, 0)
with self.assertRaises(InvalidTag):
Unsigned(tag)
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(InvalidTag):
ObjectIdentifier(tag)
tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
with self.assertRaises(InvalidTag):
ObjectIdentifier(tag)
tag = Tag(Tag.openingTagClass, 0)
with self.assertRaises(InvalidTag):
ObjectIdentifier(tag)
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
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
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
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(InvalidTag):
ObjectType(tag)
tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
with self.assertRaises(InvalidTag):
ObjectType(tag)
tag = Tag(Tag.openingTagClass, 0)
with self.assertRaises(InvalidTag):
ObjectType(tag)
def null_tag(x):
"""Convert a hex string to an integer application tag."""
if _debug: null_tag._debug("null_tag %r", x)
b = xtob(x)
tag = Tag(Tag.applicationTagClass, Tag.nullAppTag, len(b), b)
if _debug: integer_endec._debug(" - tag: %r", tag)
return tag
def double_tag(x):
"""Convert a hex string to an double application tag."""
if _debug: double_tag._debug("double_tag %r", x)
b = xtob(x)
tag = Tag(Tag.applicationTagClass, Tag.doubleAppTag, len(b), b)
if _debug: double_endec._debug(" - tag: %r", tag)
return tag
def double_encode(obj):
"""Encode an Double object into a tag."""
if _debug: double_encode._debug("double_encode %r", obj)
tag = Tag()
obj.encode(tag)
if _debug: double_endec._debug(" - tag: %r", tag)
return tag
def test_double_tag(self):
if _debug: TestDouble._debug("test_double_tag")
tag = Tag(Tag.applicationTagClass, Tag.doubleAppTag, 8, xtob('3ff0000000000000'))
obj = Double(tag)
assert obj.value == 1.0
tag = Tag(Tag.applicationTagClass, Tag.booleanAppTag, 0, xtob(''))
with self.assertRaises(InvalidTag):
Double(tag)
tag = Tag(Tag.contextTagClass, 0, 1, xtob('ff'))
with self.assertRaises(InvalidTag):
Double(tag)
tag = Tag(Tag.openingTagClass, 0)
with self.assertRaises(InvalidTag):
Double(tag)
def octet_string_tag(x):
"""Convert a hex string to an octet_string application tag."""
if _debug: octet_string_tag._debug("octet_string_tag %r", x)
b = xtob(x)
tag = Tag(Tag.applicationTagClass, Tag.octetStringAppTag, len(b), b)
if _debug: octet_string_endec._debug(" - tag: %r", tag)
return tag
def null_encode(obj):
"""Encode an Integer object into a tag."""
if _debug: null_encode._debug("null_encode %r", obj)
tag = Tag()
obj.encode(tag)
if _debug: null_encode._debug(" - tag: %r", tag)
return tag
def unsigned_tag(x):
"""Convert a hex string to an unsigned application tag."""
if _debug: unsigned_tag._debug("unsigned_tag %r", x)
b = xtob(x)
tag = Tag(Tag.applicationTagClass, Tag.unsignedAppTag, len(b), b)
if _debug: unsigned_endec._debug(" - tag: %r", tag)
return tag
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
def statement_to_tag(line):
"""Parse a line of text and return the appropriate tag."""
if _debug: statement_to_tag._debug("statement_to_tag %r", line)
# look for a matching statement pattern
for stmt_fn, stmt_re in statements:
match = stmt_re.match(line)
if match:
break
else:
raise SyntaxError("syntax error: %r" % (line,))
# extract the pieces captured by the pattern
match_groups = match.groupdict()
value = match_groups.get('value', None)
context = match_groups.get('context', None)
if _debug: statement_to_tag._debug(" - value: %r", value)
if _debug: statement_to_tag._debug(" - context: %r", context)
# let the function work on the value, skip blank lines
element = stmt_fn(value)
if not element:
return None
# check for element already a tag
if isinstance(element, Tag):
tag = element
if context is not None:
raise SyntaxError("syntax error: %r" % (line,))
elif isinstance(element, Atomic):
tag = Tag()
element.encode(tag)
if _debug: statement_to_tag._debug(" - encoded tag: %r", tag)
if context is not None:
tag = tag.app_to_context(int(context))
if _debug: statement_to_tag._debug(" - with context: %r", tag)
else:
raise TypeError("element must be a tag or atomic")
if _debug: statement_to_tag._debug(" - tag: %r", tag)
return 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
