Add m-esr52 at 52.6.0

22 files changed, 2175 insertions, 0 deletions

diff --git a/python/pyasn1/test/__init__.py b/python/pyasn1/test/__init__.py
new file mode 100644
index 000000000..8c3066b2e
--- /dev/null
+++ b/python/pyasn1/test/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/python/pyasn1/test/codec/__init__.py b/python/pyasn1/test/codec/__init__.py
new file mode 100644
index 000000000..8c3066b2e
--- /dev/null
+++ b/python/pyasn1/test/codec/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/python/pyasn1/test/codec/ber/__init__.py b/python/pyasn1/test/codec/ber/__init__.py
new file mode 100644
index 000000000..8c3066b2e
--- /dev/null
+++ b/python/pyasn1/test/codec/ber/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/python/pyasn1/test/codec/ber/suite.py b/python/pyasn1/test/codec/ber/suite.py
new file mode 100644
index 000000000..796c526b4
--- /dev/null
+++ b/python/pyasn1/test/codec/ber/suite.py
@@ -0,0 +1,22 @@
+from sys import path, version_info
+from os.path import sep
+path.insert(1, path[0]+sep+'ber')
+import test_encoder, test_decoder
+from pyasn1.error import PyAsn1Error
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+suite = unittest.TestSuite()
+loader = unittest.TestLoader()
+for m in (test_encoder, test_decoder):
+    suite.addTest(loader.loadTestsFromModule(m))
+
+def runTests(): unittest.TextTestRunner(verbosity=2).run(suite)
+
+if __name__ == '__main__': runTests()
diff --git a/python/pyasn1/test/codec/ber/test_decoder.py b/python/pyasn1/test/codec/ber/test_decoder.py
new file mode 100644
index 000000000..36999e84d
--- /dev/null
+++ b/python/pyasn1/test/codec/ber/test_decoder.py
@@ -0,0 +1,535 @@
+from pyasn1.type import tag, namedtype, univ
+from pyasn1.codec.ber import decoder
+from pyasn1.compat.octets import ints2octs, str2octs, null
+from pyasn1.error import PyAsn1Error
+from sys import version_info
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+class LargeTagDecoderTestCase(unittest.TestCase):
+    def testLargeTag(self):
+        assert decoder.decode(ints2octs((127, 141, 245, 182, 253, 47, 3, 2, 1, 1))) == (1, null)
+
+class IntegerDecoderTestCase(unittest.TestCase):
+    def testPosInt(self):
+        assert decoder.decode(ints2octs((2, 1, 12))) == (12, null)
+    def testNegInt(self):
+        assert decoder.decode(ints2octs((2, 1, 244))) == (-12, null)
+    def testZero(self):
+        assert decoder.decode(ints2octs((2, 0))) == (0, null)
+    def testZeroLong(self):
+        assert decoder.decode(ints2octs((2, 1, 0))) == (0, null)
+    def testMinusOne(self):
+        assert decoder.decode(ints2octs((2, 1, 255))) == (-1, null)
+    def testPosLong(self):
+        assert decoder.decode(
+            ints2octs((2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255))
+            ) == (0xffffffffffffffff, null)
+    def testNegLong(self):
+        assert decoder.decode(
+            ints2octs((2, 9, 255, 0, 0, 0, 0, 0, 0, 0, 1))
+            ) == (-0xffffffffffffffff, null)
+    def testSpec(self):
+        try:
+            decoder.decode(
+                ints2octs((2, 1, 12)), asn1Spec=univ.Null()
+                ) == (12, null)
+        except PyAsn1Error:
+            pass
+        else:
+            assert 0, 'wrong asn1Spec worked out'
+        assert decoder.decode(
+            ints2octs((2, 1, 12)), asn1Spec=univ.Integer()
+            ) == (12, null)
+    def testTagFormat(self):
+        try:
+            decoder.decode(ints2octs((34, 1, 12)))
+        except PyAsn1Error:
+            pass
+        else:
+            assert 0, 'wrong tagFormat worked out'
+
+class BooleanDecoderTestCase(unittest.TestCase):
+    def testTrue(self):
+        assert decoder.decode(ints2octs((1, 1, 1))) == (1, null)
+    def testTrueNeg(self):
+        assert decoder.decode(ints2octs((1, 1, 255))) == (1, null)
+    def testExtraTrue(self):
+        assert decoder.decode(ints2octs((1, 1, 1, 0, 120, 50, 50))) == (1, ints2octs((0, 120, 50, 50)))
+    def testFalse(self):
+        assert decoder.decode(ints2octs((1, 1, 0))) == (0, null)
+    def testTagFormat(self):
+        try:
+            decoder.decode(ints2octs((33, 1, 1)))
+        except PyAsn1Error:
+            pass
+        else:
+            assert 0, 'wrong tagFormat worked out'
+
+class BitStringDecoderTestCase(unittest.TestCase):
+    def testDefMode(self):
+        assert decoder.decode(
+            ints2octs((3, 3, 1, 169, 138))
+            ) == ((1,0,1,0,1,0,0,1,1,0,0,0,1,0,1), null)
+    def testIndefMode(self):
+        assert decoder.decode(
+            ints2octs((3, 3, 1, 169, 138))
+            ) == ((1,0,1,0,1,0,0,1,1,0,0,0,1,0,1), null)
+    def testDefModeChunked(self):
+        assert decoder.decode(
+            ints2octs((35, 8, 3, 2, 0, 169, 3, 2, 1, 138))
+            ) == ((1,0,1,0,1,0,0,1,1,0,0,0,1,0,1), null)
+    def testIndefModeChunked(self):
+        assert decoder.decode(
+            ints2octs((35, 128, 3, 2, 0, 169, 3, 2, 1, 138, 0, 0))
+            ) == ((1,0,1,0,1,0,0,1,1,0,0,0,1,0,1), null)
+    def testDefModeChunkedSubst(self):
+        assert decoder.decode(
+            ints2octs((35, 8, 3, 2, 0, 169, 3, 2, 1, 138)),
+            substrateFun=lambda a,b,c: (b,c)
+            ) == (ints2octs((3, 2, 0, 169, 3, 2, 1, 138)), 8)
+    def testIndefModeChunkedSubst(self):
+        assert decoder.decode(
+            ints2octs((35, 128, 3, 2, 0, 169, 3, 2, 1, 138, 0, 0)),
+            substrateFun=lambda a,b,c: (b,c)
+            ) == (ints2octs((3, 2, 0, 169, 3, 2, 1, 138, 0, 0)), -1)
+        
+class OctetStringDecoderTestCase(unittest.TestCase):
+    def testDefMode(self):
+        assert decoder.decode(
+            ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
+            ) == (str2octs('Quick brown fox'), null)
+    def testIndefMode(self):
+        assert decoder.decode(
+            ints2octs((36, 128, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 0, 0))
+            ) == (str2octs('Quick brown fox'), null)
+    def testDefModeChunked(self):
+        assert decoder.decode(
+            ints2octs((36, 23, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120))
+            ) == (str2octs('Quick brown fox'), null)
+    def testIndefModeChunked(self):
+        assert decoder.decode(
+            ints2octs((36, 128, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120, 0, 0))
+            ) == (str2octs('Quick brown fox'), null)
+    def testDefModeChunkedSubst(self):
+        assert decoder.decode(
+            ints2octs((36, 23, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120)),
+            substrateFun=lambda a,b,c: (b,c)
+            ) == (ints2octs((4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120)), 23)
+    def testIndefModeChunkedSubst(self):
+        assert decoder.decode(
+            ints2octs((36, 128, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120, 0, 0)),
+            substrateFun=lambda a,b,c: (b,c)
+            ) == (ints2octs((4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120, 0, 0)), -1)
+        
+class ExpTaggedOctetStringDecoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.o = univ.OctetString(
+            'Quick brown fox',
+            tagSet=univ.OctetString.tagSet.tagExplicitly(
+            tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 5)
+            ))
+
+    def testDefMode(self):
+        assert self.o.isSameTypeWith(decoder.decode(
+            ints2octs((101, 17, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
+            )[0])
+
+    def testIndefMode(self):
+        v, s = decoder.decode(ints2octs((101, 128, 36, 128, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 0, 0, 0, 0)))
+        assert self.o.isSameTypeWith(v)
+        assert not s
+
+    def testDefModeChunked(self):
+        v, s = decoder.decode(ints2octs((101, 25, 36, 23, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120)))
+        assert self.o.isSameTypeWith(v)
+        assert not s
+
+    def testIndefModeChunked(self):
+        v, s = decoder.decode(ints2octs((101, 128, 36, 128, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120, 0, 0, 0, 0)))
+        assert self.o.isSameTypeWith(v)
+        assert not s
+
+    def testDefModeSubst(self):
+        assert decoder.decode(
+            ints2octs((101, 17, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120)),
+            substrateFun=lambda a,b,c: (b,c)
+            ) == (ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120)), 17)
+
+    def testIndefModeSubst(self):
+        assert decoder.decode(
+            ints2octs((101, 128, 36, 128, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 0, 0, 0, 0)),
+            substrateFun=lambda a,b,c: (b,c)
+            ) == (ints2octs((36, 128, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 0, 0, 0, 0)), -1)
+  
+class NullDecoderTestCase(unittest.TestCase):
+    def testNull(self):
+        assert decoder.decode(ints2octs((5, 0))) == (null, null)
+    def testTagFormat(self):
+        try:
+            decoder.decode(ints2octs((37, 0)))
+        except PyAsn1Error:
+            pass
+        else:
+            assert 0, 'wrong tagFormat worked out'
+
+class ObjectIdentifierDecoderTestCase(unittest.TestCase):
+    def testOID(self):
+        assert decoder.decode(
+            ints2octs((6, 6, 43, 6, 0, 191, 255, 126))
+            ) == ((1,3,6,0,0xffffe), null)
+
+    def testEdges1(self):
+        assert decoder.decode(
+            ints2octs((6, 1, 255))
+            ) == ((6,15), null)
+
+    def testEdges2(self):
+        assert decoder.decode(
+            ints2octs((6, 1, 239))
+            ) == ((5,39), null)
+
+    def testEdges3(self):
+        assert decoder.decode(
+            ints2octs((6, 7, 43, 6, 143, 255, 255, 255, 127))
+            ) == ((1, 3, 6, 4294967295), null)
+
+    def testNonLeading0x80(self):
+        assert decoder.decode(
+            ints2octs((6, 5, 85, 4, 129, 128, 0)),
+            ) == ((2, 5, 4, 16384), null)
+
+    def testLeading0x80(self):
+        try:
+            decoder.decode(
+                ints2octs((6, 5, 85, 4, 128, 129, 0))
+            )
+        except PyAsn1Error:
+            pass
+        else:
+            assert 1, 'Leading 0x80 tolarated'
+
+    def testTagFormat(self):
+        try:
+            decoder.decode(ints2octs((38, 1, 239)))
+        except PyAsn1Error:
+            pass
+        else:
+            assert 0, 'wrong tagFormat worked out'
+
+class RealDecoderTestCase(unittest.TestCase):
+    def testChar(self):
+        assert decoder.decode(
+            ints2octs((9, 7, 3, 49, 50, 51, 69, 49, 49))
+        ) == (univ.Real((123, 10, 11)), null)
+
+    def testBin1(self):
+        assert decoder.decode(
+            ints2octs((9, 4, 128, 245, 4, 77))
+        ) == (univ.Real((1101, 2, -11)), null)
+
+    def testBin2(self):
+        assert decoder.decode(
+            ints2octs((9, 4, 128, 11, 4, 77))
+        ) == (univ.Real((1101, 2, 11)), null)
+
+    def testBin3(self):
+        assert decoder.decode(
+            ints2octs((9, 3, 192, 10, 123))
+        ) == (univ.Real((-123, 2, 10)), null)
+
+
+    def testPlusInf(self):
+        assert decoder.decode(
+            ints2octs((9, 1, 64))
+        ) == (univ.Real('inf'), null)
+ 
+    def testMinusInf(self):
+        assert decoder.decode(
+            ints2octs((9, 1, 65))
+        ) == (univ.Real('-inf'), null)
+
+    def testEmpty(self):
+        assert decoder.decode(
+            ints2octs((9, 0))
+        ) == (univ.Real(0.0), null)
+ 
+    def testTagFormat(self):
+        try:
+            decoder.decode(ints2octs((41, 0)))
+        except PyAsn1Error:
+            pass
+        else:
+            assert 0, 'wrong tagFormat worked out'
+
+class SequenceDecoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.s = univ.Sequence(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('place-holder', univ.Null(null)),
+            namedtype.NamedType('first-name', univ.OctetString(null)),
+            namedtype.NamedType('age', univ.Integer(33)),
+            ))
+        self.s.setComponentByPosition(0, univ.Null(null))
+        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
+        self.s.setComponentByPosition(2, univ.Integer(1))
+        self.s.setDefaultComponents()
+        
+    def testWithOptionalAndDefaultedDefMode(self):
+        assert decoder.decode(
+            ints2octs((48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
+            ) == (self.s, null)
+        
+    def testWithOptionalAndDefaultedIndefMode(self):
+        assert decoder.decode(
+            ints2octs((48, 128, 5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
+            ) == (self.s, null)
+
+    def testWithOptionalAndDefaultedDefModeChunked(self):
+        assert decoder.decode(
+            ints2octs((48, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
+            ) == (self.s, null)
+
+    def testWithOptionalAndDefaultedIndefModeChunked(self):
+        assert decoder.decode(
+            ints2octs((48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
+            ) == (self.s, null)
+
+    def testWithOptionalAndDefaultedDefModeSubst(self):
+        assert decoder.decode(
+            ints2octs((48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1)),
+            substrateFun=lambda a,b,c: (b,c)
+            ) == (ints2octs((5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1)), 18)
+        
+    def testWithOptionalAndDefaultedIndefModeSubst(self):
+        assert decoder.decode(
+            ints2octs((48, 128, 5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0)),
+            substrateFun=lambda a,b,c: (b,c)
+            ) == (ints2octs((5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0)), -1)
+
+    def testTagFormat(self):
+        try:
+            decoder.decode(
+                ints2octs((16, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
+            )
+        except PyAsn1Error:
+            pass
+        else:
+            assert 0, 'wrong tagFormat worked out'
+
+class GuidedSequenceDecoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.s = univ.Sequence(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('place-holder', univ.Null(null)),
+            namedtype.OptionalNamedType('first-name', univ.OctetString(null)),
+            namedtype.DefaultedNamedType('age', univ.Integer(33)),
+            ))
+
+    def __init(self):
+        self.s.clear()
+        self.s.setComponentByPosition(0, univ.Null(null))
+        self.s.setDefaultComponents()
+        
+    def __initWithOptional(self):
+        self.s.clear()
+        self.s.setComponentByPosition(0, univ.Null(null))
+        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
+        self.s.setDefaultComponents()
+
+    def __initWithDefaulted(self):
+        self.s.clear()
+        self.s.setComponentByPosition(0, univ.Null(null))
+        self.s.setComponentByPosition(2, univ.Integer(1))
+        self.s.setDefaultComponents()
+        
+    def __initWithOptionalAndDefaulted(self):
+        self.s.clear()
+        self.s.setComponentByPosition(0, univ.Null(null))
+        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
+        self.s.setComponentByPosition(2, univ.Integer(1))
+        self.s.setDefaultComponents()
+        
+    def testDefMode(self):
+        self.__init()
+        assert decoder.decode(
+            ints2octs((48, 128, 5, 0, 0, 0)), asn1Spec=self.s
+            ) == (self.s, null)
+        
+    def testIndefMode(self):
+        self.__init()
+        assert decoder.decode(
+            ints2octs((48, 128, 5, 0, 0, 0)), asn1Spec=self.s
+            ) == (self.s, null)
+
+    def testDefModeChunked(self):
+        self.__init()
+        assert decoder.decode(
+            ints2octs((48, 2, 5, 0)), asn1Spec=self.s
+            ) == (self.s, null)
+
+    def testIndefModeChunked(self):
+        self.__init()
+        assert decoder.decode(
+            ints2octs((48, 128, 5, 0, 0, 0)), asn1Spec=self.s
+            ) == (self.s, null)
+
+    def testWithOptionalDefMode(self):
+        self.__initWithOptional()
+        assert decoder.decode(
+            ints2octs((48, 15, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110)), asn1Spec=self.s
+            ) == (self.s, null)
+        
+    def testWithOptionaIndefMode(self):
+        self.__initWithOptional()
+        assert decoder.decode(
+            ints2octs((48, 128, 5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0, 0, 0)),
+            asn1Spec=self.s
+            ) == (self.s, null)
+
+    def testWithOptionalDefModeChunked(self):
+        self.__initWithOptional()
+        assert decoder.decode(
+            ints2octs((48, 21, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110)),
+            asn1Spec=self.s
+            ) == (self.s, null)
+
+    def testWithOptionalIndefModeChunked(self):
+        self.__initWithOptional()
+        assert decoder.decode(
+            ints2octs((48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0)),
+            asn1Spec=self.s
+            ) == (self.s, null)
+
+    def testWithDefaultedDefMode(self):
+        self.__initWithDefaulted()
+        assert decoder.decode(
+            ints2octs((48, 5, 5, 0, 2, 1, 1)), asn1Spec=self.s
+            ) == (self.s, null)
+        
+    def testWithDefaultedIndefMode(self):
+        self.__initWithDefaulted()
+        assert decoder.decode(
+            ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0)), asn1Spec=self.s
+            ) == (self.s, null)
+
+    def testWithDefaultedDefModeChunked(self):
+        self.__initWithDefaulted()
+        assert decoder.decode(
+            ints2octs((48, 5, 5, 0, 2, 1, 1)), asn1Spec=self.s
+            ) == (self.s, null)
+
+    def testWithDefaultedIndefModeChunked(self):
+        self.__initWithDefaulted()
+        assert decoder.decode(
+            ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0)), asn1Spec=self.s
+            ) == (self.s, null)
+
+    def testWithOptionalAndDefaultedDefMode(self):
+        self.__initWithOptionalAndDefaulted()
+        assert decoder.decode(
+            ints2octs((48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1)), asn1Spec=self.s
+            ) == (self.s, null)
+        
+    def testWithOptionalAndDefaultedIndefMode(self):
+        self.__initWithOptionalAndDefaulted()
+        assert decoder.decode(
+            ints2octs((48, 128, 5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0)), asn1Spec=self.s
+            ) == (self.s, null)
+
+    def testWithOptionalAndDefaultedDefModeChunked(self):
+        self.__initWithOptionalAndDefaulted()
+        assert decoder.decode(
+            ints2octs((48, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1)), asn1Spec=self.s
+            ) == (self.s, null)
+
+    def testWithOptionalAndDefaultedIndefModeChunked(self):
+        self.__initWithOptionalAndDefaulted()
+        assert decoder.decode(
+            ints2octs((48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0)), asn1Spec=self.s
+            ) == (self.s, null)
+
+class ChoiceDecoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.s = univ.Choice(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('place-holder', univ.Null(null)),
+            namedtype.NamedType('number', univ.Integer(0)),
+            namedtype.NamedType('string', univ.OctetString())
+            ))
+
+    def testBySpec(self):
+        self.s.setComponentByPosition(0, univ.Null(null))
+        assert decoder.decode(
+            ints2octs((5, 0)), asn1Spec=self.s
+            ) == (self.s, null)
+
+    def testWithoutSpec(self):
+        self.s.setComponentByPosition(0, univ.Null(null))
+        assert decoder.decode(ints2octs((5, 0))) == (self.s, null)
+        assert decoder.decode(ints2octs((5, 0))) == (univ.Null(null), null)
+
+    def testUndefLength(self):
+        self.s.setComponentByPosition(2, univ.OctetString('abcdefgh'))
+        assert decoder.decode(ints2octs((36, 128, 4, 3, 97, 98, 99, 4, 3, 100, 101, 102, 4, 2, 103, 104, 0, 0)), asn1Spec=self.s) == (self.s, null)
+
+    def testExplicitTag(self):
+        s = self.s.subtype(explicitTag=tag.Tag(tag.tagClassContext,
+                           tag.tagFormatConstructed, 4))
+        s.setComponentByPosition(0, univ.Null(null))
+        assert decoder.decode(ints2octs((164, 2, 5, 0)), asn1Spec=s) == (s, null)
+
+    def testExplicitTagUndefLength(self):
+        s = self.s.subtype(explicitTag=tag.Tag(tag.tagClassContext,
+                           tag.tagFormatConstructed, 4))
+        s.setComponentByPosition(0, univ.Null(null))
+        assert decoder.decode(ints2octs((164, 128, 5, 0, 0, 0)), asn1Spec=s) == (s, null)
+
+class AnyDecoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.s = univ.Any()
+
+    def testByUntagged(self):
+        assert decoder.decode(
+            ints2octs((4, 3, 102, 111, 120)), asn1Spec=self.s
+            ) == (univ.Any('\004\003fox'), null)
+
+    def testTaggedEx(self):
+        s = univ.Any('\004\003fox').subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4))
+        assert decoder.decode(ints2octs((164, 5, 4, 3, 102, 111, 120)), asn1Spec=s) == (s, null)
+                
+    def testTaggedIm(self):
+        s = univ.Any('\004\003fox').subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4))
+        assert decoder.decode(ints2octs((132, 5, 4, 3, 102, 111, 120)), asn1Spec=s) == (s, null)
+
+    def testByUntaggedIndefMode(self):
+        assert decoder.decode(
+            ints2octs((4, 3, 102, 111, 120)), asn1Spec=self.s
+            ) == (univ.Any('\004\003fox'), null)
+
+    def testTaggedExIndefMode(self):
+        s = univ.Any('\004\003fox').subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4))
+        assert decoder.decode(ints2octs((164, 128, 4, 3, 102, 111, 120, 0, 0)), asn1Spec=s) == (s, null)
+                
+    def testTaggedImIndefMode(self):
+        s = univ.Any('\004\003fox').subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4))
+        assert decoder.decode(ints2octs((164, 128, 4, 3, 102, 111, 120, 0, 0)), asn1Spec=s) == (s, null)
+
+    def testByUntaggedSubst(self):
+        assert decoder.decode(
+            ints2octs((4, 3, 102, 111, 120)),
+            asn1Spec=self.s,
+            substrateFun=lambda a,b,c: (b,c)
+            ) == (ints2octs((4, 3, 102, 111, 120)), 5)
+
+    def testTaggedExSubst(self):
+        assert decoder.decode(
+            ints2octs((164, 5, 4, 3, 102, 111, 120)),
+            asn1Spec=self.s,
+            substrateFun=lambda a,b,c: (b,c)
+        ) == (ints2octs((164, 5, 4, 3, 102, 111, 120)), 7)
+
+if __name__ == '__main__': unittest.main()
diff --git a/python/pyasn1/test/codec/ber/test_encoder.py b/python/pyasn1/test/codec/ber/test_encoder.py
new file mode 100644
index 000000000..bfb3f618c
--- /dev/null
+++ b/python/pyasn1/test/codec/ber/test_encoder.py
@@ -0,0 +1,338 @@
+from pyasn1.type import tag, namedtype, univ
+from pyasn1.codec.ber import encoder
+from pyasn1.compat.octets import ints2octs
+from pyasn1.error import PyAsn1Error
+from sys import version_info
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+class LargeTagEncoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.o = univ.Integer().subtype(
+            value=1, explicitTag=tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 0xdeadbeaf)
+            )
+    def testEncoder(self):
+        assert encoder.encode(self.o) == ints2octs((127, 141, 245, 182, 253, 47, 3, 2, 1, 1))
+        
+class IntegerEncoderTestCase(unittest.TestCase):
+    def testPosInt(self):
+        assert encoder.encode(univ.Integer(12)) == ints2octs((2, 1, 12))
+        
+    def testNegInt(self):
+        assert encoder.encode(univ.Integer(-12)) == ints2octs((2, 1, 244))
+        
+    def testZero(self):
+        assert encoder.encode(univ.Integer(0)) == ints2octs((2, 1, 0))
+
+    def testCompactZero(self):
+        encoder.IntegerEncoder.supportCompactZero = True
+        substrate = encoder.encode(univ.Integer(0))
+        encoder.IntegerEncoder.supportCompactZero = False
+        assert substrate == ints2octs((2, 0))
+        
+    def testMinusOne(self):
+        assert encoder.encode(univ.Integer(-1)) == ints2octs((2, 1, 255))
+        
+    def testPosLong(self):
+        assert encoder.encode(
+            univ.Integer(0xffffffffffffffff)
+            ) == ints2octs((2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255))
+        
+    def testNegLong(self):
+        assert encoder.encode(
+            univ.Integer(-0xffffffffffffffff)
+            ) == ints2octs((2, 9, 255, 0, 0, 0, 0, 0, 0, 0, 1))
+
+class BooleanEncoderTestCase(unittest.TestCase):
+    def testTrue(self):
+        assert encoder.encode(univ.Boolean(1)) == ints2octs((1, 1, 1))
+        
+    def testFalse(self):
+        assert encoder.encode(univ.Boolean(0)) == ints2octs((1, 1, 0))
+
+class BitStringEncoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.b = univ.BitString((1,0,1,0,1,0,0,1,1,0,0,0,1,0,1))
+        
+    def testDefMode(self):
+        assert encoder.encode(self.b) == ints2octs((3, 3, 1, 169, 138))
+        
+    def testIndefMode(self):
+        assert encoder.encode(
+            self.b, defMode=0
+            ) == ints2octs((3, 3, 1, 169, 138))
+        
+    def testDefModeChunked(self):
+        assert encoder.encode(
+            self.b, maxChunkSize=1
+            ) == ints2octs((35, 8, 3, 2, 0, 169, 3, 2, 1, 138))
+        
+    def testIndefModeChunked(self):
+        assert encoder.encode(
+            self.b, defMode=0, maxChunkSize=1
+            ) == ints2octs((35, 128, 3, 2, 0, 169, 3, 2, 1, 138, 0, 0))
+        
+    def testEmptyValue(self):
+        assert encoder.encode(univ.BitString(())) == ints2octs((3, 1, 0))
+        
+class OctetStringEncoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.o = univ.OctetString('Quick brown fox')
+        
+    def testDefMode(self):
+        assert encoder.encode(self.o) == ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
+        
+    def testIndefMode(self):
+        assert encoder.encode(
+            self.o, defMode=0
+            ) == ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
+
+    def testDefModeChunked(self):
+        assert encoder.encode(
+            self.o, maxChunkSize=4
+            ) == ints2octs((36, 23, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120))
+
+    def testIndefModeChunked(self):
+        assert encoder.encode(
+            self.o, defMode=0, maxChunkSize=4
+            ) == ints2octs((36, 128, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120, 0, 0))
+        
+class ExpTaggedOctetStringEncoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.o = univ.OctetString().subtype(
+            value='Quick brown fox',
+            explicitTag=tag.Tag(tag.tagClassApplication,tag.tagFormatSimple,5)
+            )
+    def testDefMode(self):
+        assert encoder.encode(self.o) == ints2octs((101, 17, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
+
+    def testIndefMode(self):
+        assert encoder.encode(
+            self.o, defMode=0
+            ) == ints2octs((101, 128, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 0, 0))
+        
+    def testDefModeChunked(self):
+        assert encoder.encode(
+            self.o, defMode=1, maxChunkSize=4
+            ) == ints2octs((101, 25, 36, 23, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120))
+        
+    def testIndefModeChunked(self):
+        assert encoder.encode(
+            self.o, defMode=0, maxChunkSize=4
+            ) == ints2octs((101, 128, 36, 128, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120, 0, 0, 0, 0))
+
+class NullEncoderTestCase(unittest.TestCase):
+    def testNull(self):
+        assert encoder.encode(univ.Null('')) == ints2octs((5, 0))
+
+class ObjectIdentifierEncoderTestCase(unittest.TestCase):
+    def testNull(self):
+        assert encoder.encode(
+            univ.ObjectIdentifier((1,3,6,0,0xffffe))
+            ) == ints2octs((6, 6, 43, 6, 0, 191, 255, 126))
+
+class RealEncoderTestCase(unittest.TestCase):
+    def testChar(self):
+        assert encoder.encode(
+            univ.Real((123, 10, 11))
+            ) == ints2octs((9, 7, 3, 49, 50, 51, 69, 49, 49))
+
+    def testBin1(self):
+        assert encoder.encode(
+            univ.Real((1101, 2, 11))
+            ) == ints2octs((9, 4, 128, 11, 4, 77))
+
+    def testBin2(self):
+        assert encoder.encode(
+            univ.Real((1101, 2, -11))
+            ) == ints2octs((9, 4, 128, 245, 4, 77))
+
+    def testPlusInf(self):
+        assert encoder.encode(univ.Real('inf')) == ints2octs((9, 1, 64))
+
+    def testMinusInf(self):
+        assert encoder.encode(univ.Real('-inf')) == ints2octs((9, 1, 65))
+        
+    def testZero(self):
+        assert encoder.encode(univ.Real(0)) == ints2octs((9, 0))
+        
+class SequenceEncoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.s = univ.Sequence(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('place-holder', univ.Null('')),
+            namedtype.OptionalNamedType('first-name', univ.OctetString('')),
+            namedtype.DefaultedNamedType('age', univ.Integer(33)),
+            ))
+
+    def __init(self):
+        self.s.clear()
+        self.s.setComponentByPosition(0)
+        
+    def __initWithOptional(self):
+        self.s.clear()
+        self.s.setComponentByPosition(0)
+        self.s.setComponentByPosition(1, 'quick brown')
+        
+    def __initWithDefaulted(self):
+        self.s.clear()
+        self.s.setComponentByPosition(0)
+        self.s.setComponentByPosition(2, 1)
+        
+    def __initWithOptionalAndDefaulted(self):
+        self.s.clear()
+        self.s.setComponentByPosition(0, univ.Null(''))
+        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
+        self.s.setComponentByPosition(2, univ.Integer(1))
+        
+    def testDefMode(self):
+        self.__init()
+        assert encoder.encode(self.s) == ints2octs((48, 2, 5, 0))
+        
+    def testIndefMode(self):
+        self.__init()
+        assert encoder.encode(
+            self.s, defMode=0
+            ) == ints2octs((48, 128, 5, 0, 0, 0))
+
+    def testDefModeChunked(self):
+        self.__init()
+        assert encoder.encode(
+            self.s, defMode=1, maxChunkSize=4
+            ) == ints2octs((48, 2, 5, 0))
+
+    def testIndefModeChunked(self):
+        self.__init()
+        assert encoder.encode(
+            self.s, defMode=0, maxChunkSize=4
+            ) == ints2octs((48, 128, 5, 0, 0, 0))
+
+    def testWithOptionalDefMode(self):
+        self.__initWithOptional()
+        assert encoder.encode(self.s) == ints2octs((48, 15, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
+        
+    def testWithOptionalIndefMode(self):
+        self.__initWithOptional()
+        assert encoder.encode(
+            self.s, defMode=0
+            ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
+
+    def testWithOptionalDefModeChunked(self):
+        self.__initWithOptional()
+        assert encoder.encode(
+            self.s, defMode=1, maxChunkSize=4
+            ) == ints2octs((48, 21, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
+
+    def testWithOptionalIndefModeChunked(self):
+        self.__initWithOptional()
+        assert encoder.encode(
+            self.s, defMode=0, maxChunkSize=4
+            ) == ints2octs((48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
+
+    def testWithDefaultedDefMode(self):
+        self.__initWithDefaulted()
+        assert encoder.encode(self.s) == ints2octs((48, 5, 5, 0, 2, 1, 1))
+        
+    def testWithDefaultedIndefMode(self):
+        self.__initWithDefaulted()
+        assert encoder.encode(
+            self.s, defMode=0
+            ) == ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0))
+
+    def testWithDefaultedDefModeChunked(self):
+        self.__initWithDefaulted()
+        assert encoder.encode(
+            self.s, defMode=1, maxChunkSize=4
+            ) == ints2octs((48, 5, 5, 0, 2, 1, 1))
+
+    def testWithDefaultedIndefModeChunked(self):
+        self.__initWithDefaulted()
+        assert encoder.encode(
+            self.s, defMode=0, maxChunkSize=4
+            ) == ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0))
+
+    def testWithOptionalAndDefaultedDefMode(self):
+        self.__initWithOptionalAndDefaulted()
+        assert encoder.encode(self.s) == ints2octs((48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
+        
+    def testWithOptionalAndDefaultedIndefMode(self):
+        self.__initWithOptionalAndDefaulted()
+        assert encoder.encode(
+            self.s, defMode=0
+            ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
+
+    def testWithOptionalAndDefaultedDefModeChunked(self):
+        self.__initWithOptionalAndDefaulted()
+        assert encoder.encode(
+            self.s, defMode=1, maxChunkSize=4
+            ) == ints2octs((48, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
+
+    def testWithOptionalAndDefaultedIndefModeChunked(self):
+        self.__initWithOptionalAndDefaulted()
+        assert encoder.encode(
+            self.s, defMode=0, maxChunkSize=4
+            ) == ints2octs((48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
+
+class ChoiceEncoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.s = univ.Choice(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('place-holder', univ.Null('')),
+            namedtype.NamedType('number', univ.Integer(0)),
+            namedtype.NamedType('string', univ.OctetString())
+            ))
+
+    def testEmpty(self):
+        try:
+            encoder.encode(self.s)
+        except PyAsn1Error:
+            pass
+        else:
+            assert 0, 'encoded unset choice'
+        
+    def testFilled(self):
+        self.s.setComponentByPosition(0, univ.Null(''))
+        assert encoder.encode(self.s) == ints2octs((5, 0))
+
+    def testTagged(self):
+        s = self.s.subtype(
+            explicitTag=tag.Tag(tag.tagClassContext,tag.tagFormatConstructed,4)
+        )
+        s.setComponentByPosition(0, univ.Null(''))
+        assert encoder.encode(s) == ints2octs((164, 2, 5, 0))
+
+    def testUndefLength(self):
+        self.s.setComponentByPosition(2, univ.OctetString('abcdefgh'))
+        assert encoder.encode(self.s, defMode=False, maxChunkSize=3) == ints2octs((36, 128, 4, 3, 97, 98, 99, 4, 3, 100, 101, 102, 4, 2, 103, 104, 0, 0))
+
+    def testTaggedUndefLength(self):
+        s = self.s.subtype(
+            explicitTag=tag.Tag(tag.tagClassContext,tag.tagFormatConstructed,4)
+        )
+        s.setComponentByPosition(2, univ.OctetString('abcdefgh'))
+        assert encoder.encode(s, defMode=False, maxChunkSize=3) == ints2octs((164, 128, 36, 128, 4, 3, 97, 98, 99, 4, 3, 100, 101, 102, 4, 2, 103, 104, 0, 0, 0, 0))
+
+class AnyEncoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.s = univ.Any(encoder.encode(univ.OctetString('fox')))
+        
+    def testUntagged(self):
+        assert encoder.encode(self.s) == ints2octs((4, 3, 102, 111, 120))
+            
+    def testTaggedEx(self):
+        s = self.s.subtype(
+            explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4)
+            )
+        assert encoder.encode(s) == ints2octs((164, 5, 4, 3, 102, 111, 120))
+
+    def testTaggedIm(self):
+        s = self.s.subtype(
+            implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4)
+            )
+        assert encoder.encode(s) == ints2octs((132, 5, 4, 3, 102, 111, 120))
+                    
+if __name__ == '__main__': unittest.main()
diff --git a/python/pyasn1/test/codec/cer/__init__.py b/python/pyasn1/test/codec/cer/__init__.py
new file mode 100644
index 000000000..8c3066b2e
--- /dev/null
+++ b/python/pyasn1/test/codec/cer/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/python/pyasn1/test/codec/cer/suite.py b/python/pyasn1/test/codec/cer/suite.py
new file mode 100644
index 000000000..49d682918
--- /dev/null
+++ b/python/pyasn1/test/codec/cer/suite.py
@@ -0,0 +1,22 @@
+from sys import path, version_info
+from os.path import sep
+path.insert(1, path[0]+sep+'cer')
+import test_encoder, test_decoder
+from pyasn1.error import PyAsn1Error
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+suite = unittest.TestSuite()
+loader = unittest.TestLoader()
+for m in (test_encoder, test_decoder):
+    suite.addTest(loader.loadTestsFromModule(m))
+
+def runTests(): unittest.TextTestRunner(verbosity=2).run(suite)
+
+if __name__ == '__main__': runTests()
diff --git a/python/pyasn1/test/codec/cer/test_decoder.py b/python/pyasn1/test/codec/cer/test_decoder.py
new file mode 100644
index 000000000..7195b72e0
--- /dev/null
+++ b/python/pyasn1/test/codec/cer/test_decoder.py
@@ -0,0 +1,31 @@
+from pyasn1.type import univ
+from pyasn1.codec.cer import decoder
+from pyasn1.compat.octets import ints2octs, str2octs, null
+from pyasn1.error import PyAsn1Error
+from sys import version_info
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+class BooleanDecoderTestCase(unittest.TestCase):
+    def testTrue(self):
+        assert decoder.decode(ints2octs((1, 1, 255))) == (1, null)
+    def testFalse(self):
+        assert decoder.decode(ints2octs((1, 1, 0))) == (0, null)
+        
+class OctetStringDecoderTestCase(unittest.TestCase):
+    def testShortMode(self):
+        assert decoder.decode(
+            ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120)),
+            ) == (str2octs('Quick brown fox'), null)
+    def testLongMode(self):
+        assert decoder.decode(
+            ints2octs((36, 128, 4, 130, 3, 232) + (81,)*1000 + (4, 1, 81, 0, 0))
+            ) == (str2octs('Q'*1001), null)
+
+if __name__ == '__main__': unittest.main()
diff --git a/python/pyasn1/test/codec/cer/test_encoder.py b/python/pyasn1/test/codec/cer/test_encoder.py
new file mode 100644
index 000000000..a4f80aa20
--- /dev/null
+++ b/python/pyasn1/test/codec/cer/test_encoder.py
@@ -0,0 +1,107 @@
+from pyasn1.type import namedtype, univ
+from pyasn1.codec.cer import encoder
+from pyasn1.compat.octets import ints2octs
+from pyasn1.error import PyAsn1Error
+from sys import version_info
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+class BooleanEncoderTestCase(unittest.TestCase):
+    def testTrue(self):
+        assert encoder.encode(univ.Boolean(1)) == ints2octs((1, 1, 255))
+    def testFalse(self):
+        assert encoder.encode(univ.Boolean(0)) == ints2octs((1, 1, 0))
+
+class BitStringEncoderTestCase(unittest.TestCase):
+    def testShortMode(self):
+        assert encoder.encode(
+            univ.BitString((1,0)*501)
+            ) == ints2octs((3, 127, 6) + (170,) * 125 + (128,))
+
+    def testLongMode(self):
+        assert encoder.encode(
+            univ.BitString((1,0)*501)
+            ) == ints2octs((3, 127, 6) + (170,) * 125 + (128,))
+        
+class OctetStringEncoderTestCase(unittest.TestCase):
+    def testShortMode(self):
+        assert encoder.encode(
+            univ.OctetString('Quick brown fox')
+            ) == ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
+    def testLongMode(self):
+        assert encoder.encode(
+            univ.OctetString('Q'*1001)
+            ) == ints2octs((36, 128, 4, 130, 3, 232) + (81,)*1000 + (4, 1, 81, 0, 0))
+        
+class SetEncoderTestCase(unittest.TestCase):
+    def setUp(self):
+        self.s = univ.Set(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('place-holder', univ.Null('')),
+            namedtype.OptionalNamedType('first-name', univ.OctetString('')),
+            namedtype.DefaultedNamedType('age', univ.Integer(33))
+            ))
+
+    def __init(self):
+        self.s.clear()
+        self.s.setComponentByPosition(0)
+    def __initWithOptional(self):
+        self.s.clear()
+        self.s.setComponentByPosition(0)
+        self.s.setComponentByPosition(1, 'quick brown')
+        
+    def __initWithDefaulted(self):
+        self.s.clear()
+        self.s.setComponentByPosition(0)
+        self.s.setComponentByPosition(2, 1)
+        
+    def __initWithOptionalAndDefaulted(self):
+        self.s.clear()
+        self.s.setComponentByPosition(0, univ.Null(''))
+        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
+        self.s.setComponentByPosition(2, univ.Integer(1))
+        
+    def testIndefMode(self):
+        self.__init()
+        assert encoder.encode(self.s) == ints2octs((49, 128, 5, 0, 0, 0))
+
+    def testWithOptionalIndefMode(self):
+        self.__initWithOptional()
+        assert encoder.encode(
+            self.s
+            ) == ints2octs((49, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 5, 0, 0, 0))
+
+    def testWithDefaultedIndefMode(self):
+        self.__initWithDefaulted()
+        assert encoder.encode(
+            self.s
+            ) == ints2octs((49, 128, 2, 1, 1, 5, 0, 0, 0))
+
+    def testWithOptionalAndDefaultedIndefMode(self):
+        self.__initWithOptionalAndDefaulted()
+        assert encoder.encode(
+            self.s
+            ) == ints2octs((49, 128, 2, 1, 1, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 5, 0, 0, 0))
+
+class SetWithChoiceEncoderTestCase(unittest.TestCase):
+    def setUp(self):
+        c = univ.Choice(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('actual', univ.Boolean(0))
+            ))
+        self.s = univ.Set(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('place-holder', univ.Null('')),
+            namedtype.NamedType('status', c)
+            ))
+
+    def testIndefMode(self):
+        self.s.setComponentByPosition(0)
+        self.s.setComponentByName('status')
+        self.s.getComponentByName('status').setComponentByPosition(0, 1)
+        assert encoder.encode(self.s) == ints2octs((49, 128, 1, 1, 255, 5, 0, 0, 0))
+
+if __name__ == '__main__': unittest.main()
diff --git a/python/pyasn1/test/codec/der/__init__.py b/python/pyasn1/test/codec/der/__init__.py
new file mode 100644
index 000000000..8c3066b2e
--- /dev/null
+++ b/python/pyasn1/test/codec/der/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/python/pyasn1/test/codec/der/suite.py b/python/pyasn1/test/codec/der/suite.py
new file mode 100644
index 000000000..7af83bf94
--- /dev/null
+++ b/python/pyasn1/test/codec/der/suite.py
@@ -0,0 +1,22 @@
+from sys import path, version_info
+from os.path import sep
+path.insert(1, path[0]+sep+'der')
+import test_encoder, test_decoder
+from pyasn1.error import PyAsn1Error
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+suite = unittest.TestSuite()
+loader = unittest.TestLoader()
+for m in (test_encoder, test_decoder):
+    suite.addTest(loader.loadTestsFromModule(m))
+
+def runTests(): unittest.TextTestRunner(verbosity=2).run(suite)
+
+if __name__ == '__main__': runTests()
diff --git a/python/pyasn1/test/codec/der/test_decoder.py b/python/pyasn1/test/codec/der/test_decoder.py
new file mode 100644
index 000000000..5c9a1948b
--- /dev/null
+++ b/python/pyasn1/test/codec/der/test_decoder.py
@@ -0,0 +1,20 @@
+from pyasn1.type import univ
+from pyasn1.codec.der import decoder
+from pyasn1.error import PyAsn1Error
+from sys import version_info
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+class OctetStringDecoderTestCase(unittest.TestCase):
+    def testShortMode(self):
+        assert decoder.decode(
+            '\004\017Quick brown fox'.encode()
+            ) == ('Quick brown fox'.encode(), ''.encode())
+
+if __name__ == '__main__': unittest.main()
diff --git a/python/pyasn1/test/codec/der/test_encoder.py b/python/pyasn1/test/codec/der/test_encoder.py
new file mode 100644
index 000000000..787da7bec
--- /dev/null
+++ b/python/pyasn1/test/codec/der/test_encoder.py
@@ -0,0 +1,44 @@
+from pyasn1.type import namedtype, univ
+from pyasn1.codec.der import encoder
+from pyasn1.compat.octets import ints2octs
+from pyasn1.error import PyAsn1Error
+from sys import version_info
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+class OctetStringEncoderTestCase(unittest.TestCase):
+    def testShortMode(self):
+        assert encoder.encode(
+            univ.OctetString('Quick brown fox')
+            ) == ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
+
+class BitStringEncoderTestCase(unittest.TestCase):
+    def testShortMode(self):
+        assert encoder.encode(
+            univ.BitString((1,))
+            ) == ints2octs((3, 2, 7, 128))
+        
+class SetWithChoiceEncoderTestCase(unittest.TestCase):
+    def setUp(self):
+        c = univ.Choice(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('name', univ.OctetString('')),
+            namedtype.NamedType('amount', univ.Integer(0))
+            ))
+        self.s = univ.Set(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('place-holder', univ.Null('')),
+            namedtype.NamedType('status', c)
+            ))
+
+    def testDefMode(self):
+        self.s.setComponentByPosition(0)
+        self.s.setComponentByName('status')
+        self.s.getComponentByName('status').setComponentByPosition(0, 'ann')
+        assert encoder.encode(self.s) == ints2octs((49, 7, 4, 3, 97, 110, 110, 5, 0))
+
+if __name__ == '__main__': unittest.main()
diff --git a/python/pyasn1/test/codec/suite.py b/python/pyasn1/test/codec/suite.py
new file mode 100644
index 000000000..93ff06381
--- /dev/null
+++ b/python/pyasn1/test/codec/suite.py
@@ -0,0 +1,29 @@
+from sys import path, version_info
+from os.path import sep
+path.insert(1, path[0]+sep+'codec'+sep+'ber')
+import ber.suite
+path.insert(1, path[0]+sep+'codec'+sep+'cer')
+import cer.suite
+path.insert(1, path[0]+sep+'codec'+sep+'der')
+import der.suite
+from pyasn1.error import PyAsn1Error
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+suite = unittest.TestSuite()
+for m in (
+    ber.suite,
+    cer.suite,
+    der.suite
+    ):
+    suite.addTest(getattr(m, 'suite'))
+
+def runTests(): unittest.TextTestRunner(verbosity=2).run(suite)
+
+if __name__ == '__main__': runTests()
diff --git a/python/pyasn1/test/suite.py b/python/pyasn1/test/suite.py
new file mode 100644
index 000000000..b4d80e864
--- /dev/null
+++ b/python/pyasn1/test/suite.py
@@ -0,0 +1,26 @@
+from sys import path, version_info
+from os.path import sep
+path.insert(1, path[0]+sep+'type')
+import type.suite
+path.insert(1, path[0]+sep+'codec')
+import codec.suite
+from pyasn1.error import PyAsn1Error
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+suite = unittest.TestSuite()
+for m in (
+    type.suite,
+    codec.suite
+    ):
+    suite.addTest(getattr(m, 'suite'))
+
+def runTests(): unittest.TextTestRunner(verbosity=2).run(suite)
+
+if __name__ == '__main__': runTests()
diff --git a/python/pyasn1/test/type/__init__.py b/python/pyasn1/test/type/__init__.py
new file mode 100644
index 000000000..8c3066b2e
--- /dev/null
+++ b/python/pyasn1/test/type/__init__.py
@@ -0,0 +1 @@
+# This file is necessary to make this directory a package.
diff --git a/python/pyasn1/test/type/suite.py b/python/pyasn1/test/type/suite.py
new file mode 100644
index 000000000..bc4b48685
--- /dev/null
+++ b/python/pyasn1/test/type/suite.py
@@ -0,0 +1,20 @@
+import test_tag, test_constraint, test_namedtype, test_univ
+from pyasn1.error import PyAsn1Error
+from sys import version_info
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+suite = unittest.TestSuite()
+loader = unittest.TestLoader()
+for m in (test_tag, test_constraint, test_namedtype, test_univ):
+    suite.addTest(loader.loadTestsFromModule(m))
+
+def runTests(): unittest.TextTestRunner(verbosity=2).run(suite)
+
+if __name__ == '__main__': runTests()
diff --git a/python/pyasn1/test/type/test_constraint.py b/python/pyasn1/test/type/test_constraint.py
new file mode 100644
index 000000000..3457c0fc3
--- /dev/null
+++ b/python/pyasn1/test/type/test_constraint.py
@@ -0,0 +1,280 @@
+from pyasn1.type import constraint, error
+from pyasn1.error import PyAsn1Error
+from sys import version_info
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+class SingleValueConstraintTestCase(unittest.TestCase):
+    def setUp(self):
+        self.c1 = constraint.SingleValueConstraint(1,2)
+        self.c2 = constraint.SingleValueConstraint(3,4)
+
+    def testCmp(self): assert self.c1 == self.c1, 'comparation fails'
+    def testHash(self): assert hash(self.c1) != hash(self.c2), 'hash() fails'
+    def testGoodVal(self):
+        try:
+            self.c1(1)
+        except error.ValueConstraintError:
+            assert 0, 'constraint check fails'
+    def testBadVal(self):
+        try:
+            self.c1(4)
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint check fails'
+
+class ContainedSubtypeConstraintTestCase(unittest.TestCase):
+    def setUp(self):
+        self.c1 = constraint.ContainedSubtypeConstraint(
+            constraint.SingleValueConstraint(12)
+            )
+
+    def testGoodVal(self):
+        try:
+            self.c1(12)
+        except error.ValueConstraintError:
+            assert 0, 'constraint check fails'
+    def testBadVal(self):
+        try:
+            self.c1(4)
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint check fails'
+
+class ValueRangeConstraintTestCase(unittest.TestCase):
+    def setUp(self):
+        self.c1 = constraint.ValueRangeConstraint(1,4)
+
+    def testGoodVal(self):
+        try:
+            self.c1(1)
+        except error.ValueConstraintError:
+            assert 0, 'constraint check fails'
+    def testBadVal(self):
+        try:
+            self.c1(-5)
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint check fails'
+
+class ValueSizeConstraintTestCase(unittest.TestCase):
+    def setUp(self):
+        self.c1 = constraint.ValueSizeConstraint(1,2)
+
+    def testGoodVal(self):
+        try:
+            self.c1('a')
+        except error.ValueConstraintError:
+            assert 0, 'constraint check fails'
+    def testBadVal(self):
+        try:
+            self.c1('abc')
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint check fails'
+
+class PermittedAlphabetConstraintTestCase(SingleValueConstraintTestCase):
+    def setUp(self):
+        self.c1 = constraint.PermittedAlphabetConstraint('A', 'B', 'C')
+        self.c2 = constraint.PermittedAlphabetConstraint('DEF')
+
+    def testGoodVal(self):
+        try:
+            self.c1('A')
+        except error.ValueConstraintError:
+            assert 0, 'constraint check fails'
+    def testBadVal(self):
+        try:
+            self.c1('E')
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint check fails'
+
+class ConstraintsIntersectionTestCase(unittest.TestCase):
+    def setUp(self):
+        self.c1 = constraint.ConstraintsIntersection(
+            constraint.SingleValueConstraint(4),
+            constraint.ValueRangeConstraint(2, 4)
+            )
+
+    def testCmp1(self):
+        assert constraint.SingleValueConstraint(4) in self.c1, '__cmp__() fails'
+
+    def testCmp2(self):
+        assert constraint.SingleValueConstraint(5) not in self.c1, \
+               '__cmp__() fails'
+
+    def testCmp3(self):
+        c = constraint.ConstraintsUnion(constraint.ConstraintsIntersection(
+            constraint.SingleValueConstraint(4),
+            constraint.ValueRangeConstraint(2, 4)
+            ))
+        assert self.c1 in c, '__cmp__() fails'
+    def testCmp4(self):
+        c = constraint.ConstraintsUnion(
+            constraint.ConstraintsIntersection(constraint.SingleValueConstraint(5))
+            )
+        assert self.c1 not in c, '__cmp__() fails'
+        
+    def testGoodVal(self):
+        try:
+            self.c1(4)
+        except error.ValueConstraintError:
+            assert 0, 'constraint check fails'
+    def testBadVal(self):
+        try:
+            self.c1(-5)
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint check fails'
+
+class InnerTypeConstraintTestCase(unittest.TestCase):
+    def testConst1(self):
+        c = constraint.InnerTypeConstraint(
+            constraint.SingleValueConstraint(4)
+            )
+        try:
+            c(4, 32)
+        except error.ValueConstraintError:
+            assert 0, 'constraint check fails'
+        try:
+            c(5, 32)
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint check fails'
+    def testConst2(self):
+        c = constraint.InnerTypeConstraint(
+            (0, constraint.SingleValueConstraint(4), 'PRESENT'),
+            (1, constraint.SingleValueConstraint(4), 'ABSENT')
+            )
+        try:
+            c(4, 0)
+        except error.ValueConstraintError:
+            raise
+            assert 0, 'constraint check fails'            
+        try:
+            c(4, 1)
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint check fails'            
+        try:
+            c(3, 0)
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint check fails'            
+
+# Constraints compositions
+
+class ConstraintsIntersectionTestCase(unittest.TestCase):
+    def setUp(self):
+        self.c1 = constraint.ConstraintsIntersection(
+            constraint.ValueRangeConstraint(1, 9),
+            constraint.ValueRangeConstraint(2, 5)
+            )
+
+    def testGoodVal(self):
+        try:
+            self.c1(3)
+        except error.ValueConstraintError:
+            assert 0, 'constraint check fails'
+    def testBadVal(self):
+        try:
+            self.c1(0)
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint check fails'
+
+class ConstraintsUnionTestCase(unittest.TestCase):
+    def setUp(self):
+        self.c1 = constraint.ConstraintsUnion(
+            constraint.SingleValueConstraint(5),
+            constraint.ValueRangeConstraint(1, 3)
+            )
+
+    def testGoodVal(self):
+        try:
+            self.c1(2)
+            self.c1(5)
+        except error.ValueConstraintError:
+            assert 0, 'constraint check fails'
+    def testBadVal(self):
+        try:
+            self.c1(-5)
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint check fails'
+
+class ConstraintsExclusionTestCase(unittest.TestCase):
+    def setUp(self):
+        self.c1 = constraint.ConstraintsExclusion(
+            constraint.ValueRangeConstraint(2, 4)
+            )
+
+    def testGoodVal(self):
+        try:
+            self.c1(6)
+        except error.ValueConstraintError:
+            assert 0, 'constraint check fails'
+    def testBadVal(self):
+        try:
+            self.c1(2)
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint check fails'
+
+# Constraints derivations
+
+class DirectDerivationTestCase(unittest.TestCase):
+    def setUp(self):
+        self.c1 = constraint.SingleValueConstraint(5)
+        self.c2 = constraint.ConstraintsUnion(
+            self.c1, constraint.ValueRangeConstraint(1, 3)
+            )
+
+    def testGoodVal(self):
+        assert self.c1.isSuperTypeOf(self.c2), 'isSuperTypeOf failed'
+        assert not self.c1.isSubTypeOf(self.c2) , 'isSubTypeOf failed'
+    def testBadVal(self):
+        assert not self.c2.isSuperTypeOf(self.c1) , 'isSuperTypeOf failed'
+        assert self.c2.isSubTypeOf(self.c1) , 'isSubTypeOf failed'
+
+class IndirectDerivationTestCase(unittest.TestCase):
+    def setUp(self):
+        self.c1 = constraint.ConstraintsIntersection(
+            constraint.ValueRangeConstraint(1, 30)
+            )
+        self.c2 = constraint.ConstraintsIntersection(
+            self.c1, constraint.ValueRangeConstraint(1, 20)
+            )
+        self.c2 = constraint.ConstraintsIntersection(
+            self.c2, constraint.ValueRangeConstraint(1, 10)
+            )
+
+    def testGoodVal(self):
+        assert self.c1.isSuperTypeOf(self.c2), 'isSuperTypeOf failed'
+        assert not self.c1.isSubTypeOf(self.c2) , 'isSubTypeOf failed'
+    def testBadVal(self):
+        assert not self.c2.isSuperTypeOf(self.c1) , 'isSuperTypeOf failed'
+        assert self.c2.isSubTypeOf(self.c1) , 'isSubTypeOf failed'
+        
+if __name__ == '__main__': unittest.main()
+
+# how to apply size constriants to constructed types?
diff --git a/python/pyasn1/test/type/test_namedtype.py b/python/pyasn1/test/type/test_namedtype.py
new file mode 100644
index 000000000..3a4f30599
--- /dev/null
+++ b/python/pyasn1/test/type/test_namedtype.py
@@ -0,0 +1,87 @@
+from pyasn1.type import namedtype, univ
+from pyasn1.error import PyAsn1Error
+from sys import version_info
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+class NamedTypeCaseBase(unittest.TestCase):
+    def setUp(self):
+        self.e = namedtype.NamedType('age', univ.Integer())
+    def testIter(self):
+        n, t = self.e
+        assert n == 'age' or t == univ.Integer(), 'unpack fails'
+
+class NamedTypesCaseBase(unittest.TestCase):
+    def setUp(self):
+        self.e = namedtype.NamedTypes(
+            namedtype.NamedType('first-name', univ.OctetString('')),
+            namedtype.OptionalNamedType('age', univ.Integer(0)),
+            namedtype.NamedType('family-name', univ.OctetString(''))
+            )
+    def testIter(self):
+        for t in self.e:
+            break
+        else:
+            assert 0, '__getitem__() fails'
+            
+    def testGetTypeByPosition(self):
+        assert self.e.getTypeByPosition(0) == univ.OctetString(''), \
+               'getTypeByPosition() fails'
+
+    def testGetNameByPosition(self):
+        assert self.e.getNameByPosition(0) == 'first-name', \
+               'getNameByPosition() fails'
+
+    def testGetPositionByName(self):
+        assert self.e.getPositionByName('first-name') == 0, \
+               'getPositionByName() fails'
+
+    def testGetTypesNearPosition(self):
+        assert self.e.getTagMapNearPosition(0).getPosMap() == {
+            univ.OctetString.tagSet: univ.OctetString('')
+            }
+        assert self.e.getTagMapNearPosition(1).getPosMap() == {
+            univ.Integer.tagSet: univ.Integer(0),
+            univ.OctetString.tagSet: univ.OctetString('')
+            }
+        assert self.e.getTagMapNearPosition(2).getPosMap() == {
+            univ.OctetString.tagSet: univ.OctetString('')
+            }
+
+    def testGetTagMap(self):
+        assert self.e.getTagMap().getPosMap() == {
+            univ.OctetString.tagSet: univ.OctetString(''),
+            univ.Integer.tagSet: univ.Integer(0)
+            }
+
+    def testGetTagMapWithDups(self):
+        try:
+            self.e.getTagMap(1)
+        except PyAsn1Error:
+            pass
+        else:
+            assert 0, 'Duped types not noticed'
+        
+    def testGetPositionNearType(self):
+        assert self.e.getPositionNearType(univ.OctetString.tagSet, 0) == 0
+        assert self.e.getPositionNearType(univ.Integer.tagSet, 1) == 1
+        assert self.e.getPositionNearType(univ.OctetString.tagSet, 2) == 2
+
+class OrderedNamedTypesCaseBase(unittest.TestCase):
+    def setUp(self):
+        self.e = namedtype.NamedTypes(
+            namedtype.NamedType('first-name', univ.OctetString('')),
+            namedtype.NamedType('age', univ.Integer(0))
+            )
+            
+    def testGetTypeByPosition(self):
+        assert self.e.getTypeByPosition(0) == univ.OctetString(''), \
+               'getTypeByPosition() fails'
+
+if __name__ == '__main__': unittest.main()
diff --git a/python/pyasn1/test/type/test_tag.py b/python/pyasn1/test/type/test_tag.py
new file mode 100644
index 000000000..78146dca2
--- /dev/null
+++ b/python/pyasn1/test/type/test_tag.py
@@ -0,0 +1,107 @@
+from pyasn1.type import tag
+from pyasn1.error import PyAsn1Error
+from sys import version_info
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+class TagTestCaseBase(unittest.TestCase):
+    def setUp(self):
+        self.t1 = tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 3)
+        self.t2 = tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 3)
+    
+class TagCmpTestCase(TagTestCaseBase):
+    def testCmp(self):
+        assert self.t1 == self.t2, 'tag comparation fails'
+
+    def testHash(self):
+        assert hash(self.t1) == hash(self.t2), 'tag hash comparation fails'
+
+    def testSequence(self):
+        assert self.t1[0] == self.t2[0] and \
+               self.t1[1] == self.t2[1] and \
+               self.t1[2] == self.t2[2], 'tag sequence protocol fails'
+
+class TagSetTestCaseBase(unittest.TestCase):
+    def setUp(self):
+        self.ts1 = tag.initTagSet(
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12)
+            )
+        self.ts2 = tag.initTagSet(
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12)
+            )
+
+class TagSetCmpTestCase(TagSetTestCaseBase):
+    def testCmp(self):
+        assert self.ts1 == self.ts2, 'tag set comparation fails'
+
+    def testHash(self):
+        assert hash(self.ts1) == hash(self.ts2), 'tag set hash comp. fails'
+
+    def testLen(self):
+        assert len(self.ts1) == len(self.ts2), 'tag length comparation fails'
+
+class TaggingTestSuite(TagSetTestCaseBase):
+    def testImplicitTag(self):
+        t = self.ts1.tagImplicitly(
+            tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 14)
+            )
+        assert t == tag.TagSet(
+            tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 12),
+            tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 14)
+            ), 'implicit tagging went wrong'
+
+    def testExplicitTag(self):
+        t = self.ts1.tagExplicitly(
+            tag.Tag(tag.tagClassPrivate, tag.tagFormatSimple, 32)
+            )
+        assert t == tag.TagSet(
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
+            tag.Tag(tag.tagClassPrivate, tag.tagFormatConstructed, 32)
+            ), 'explicit tagging went wrong'
+
+class TagSetAddTestSuite(TagSetTestCaseBase):
+    def testAdd(self):
+        t = self.ts1 + tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 2)
+        assert t == tag.TagSet(
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
+            tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 2)
+            ), 'TagSet.__add__() fails'
+
+    def testRadd(self):
+        t = tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 2) + self.ts1
+        assert t == tag.TagSet(
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
+            tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 2),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12)
+            ), 'TagSet.__radd__() fails'
+
+class SuperTagSetTestCase(TagSetTestCaseBase):
+    def testSuperTagCheck1(self):
+        assert self.ts1.isSuperTagSetOf(
+            tag.TagSet(
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12)
+            )), 'isSuperTagSetOf() fails'
+
+    def testSuperTagCheck2(self):
+        assert not self.ts1.isSuperTagSetOf(
+            tag.TagSet(
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 13)
+            )), 'isSuperTagSetOf() fails'
+
+    def testSuperTagCheck3(self):
+        assert self.ts1.isSuperTagSetOf(
+            tag.TagSet((), tag.Tag(tag.tagClassUniversal,
+                                   tag.tagFormatSimple, 12))
+            ), 'isSuperTagSetOf() fails'
+    
+if __name__ == '__main__': unittest.main()
diff --git a/python/pyasn1/test/type/test_univ.py b/python/pyasn1/test/type/test_univ.py
new file mode 100644
index 000000000..3eedcf26a
--- /dev/null
+++ b/python/pyasn1/test/type/test_univ.py
@@ -0,0 +1,479 @@
+from pyasn1.type import univ, tag, constraint, namedtype, namedval, error
+from pyasn1.compat.octets import str2octs, ints2octs
+from pyasn1.error import PyAsn1Error
+from sys import version_info
+if version_info[0:2] < (2, 7) or \
+   version_info[0:2] in ( (3, 0), (3, 1) ):
+    try:
+        import unittest2 as unittest
+    except ImportError:
+        import unittest
+else:
+    import unittest
+
+class IntegerTestCase(unittest.TestCase):
+    def testStr(self): assert str(univ.Integer(1)) in ('1','1L'),'str() fails'
+    def testAnd(self): assert univ.Integer(1) & 0 == 0, '__and__() fails'
+    def testOr(self): assert univ.Integer(1) | 0 == 1, '__or__() fails'
+    def testXor(self): assert univ.Integer(1) ^ 0 == 1, '__xor__() fails'
+    def testRand(self): assert 0 & univ.Integer(1) == 0, '__rand__() fails'
+    def testRor(self): assert 0 | univ.Integer(1) == 1, '__ror__() fails'
+    def testRxor(self): assert 0 ^ univ.Integer(1) == 1, '__rxor__() fails'    
+    def testAdd(self): assert univ.Integer(-4) + 6 == 2, '__add__() fails'
+    def testRadd(self): assert 4 + univ.Integer(5) == 9, '__radd__() fails'
+    def testSub(self): assert univ.Integer(3) - 6 == -3, '__sub__() fails'
+    def testRsub(self): assert 6 - univ.Integer(3) == 3, '__rsub__() fails'
+    def testMul(self): assert univ.Integer(3) * -3 == -9, '__mul__() fails'
+    def testRmul(self): assert 2 * univ.Integer(3) == 6, '__rmul__() fails'
+    def testDiv(self): assert univ.Integer(3) / 2 == 1, '__div__() fails'
+    def testRdiv(self): assert 6 / univ.Integer(3) == 2, '__rdiv__() fails'
+    def testMod(self): assert univ.Integer(3) % 2 == 1, '__mod__() fails'
+    def testRmod(self): assert 4 % univ.Integer(3) == 1, '__rmod__() fails'
+    def testPow(self): assert univ.Integer(3) ** 2 == 9, '__pow__() fails'
+    def testRpow(self): assert 2 ** univ.Integer(2) == 4, '__rpow__() fails'
+    def testLshift(self): assert univ.Integer(1) << 1 == 2, '<< fails'
+    def testRshift(self): assert univ.Integer(2) >> 1 == 1, '>> fails'
+    def testInt(self): assert int(univ.Integer(3)) == 3, '__int__() fails'
+    def testLong(self): assert int(univ.Integer(8)) == 8, '__long__() fails'
+    def testFloat(self): assert float(univ.Integer(4))==4.0,'__float__() fails'
+    def testPrettyIn(self): assert univ.Integer('3') == 3, 'prettyIn() fails'
+    def testTag(self):
+        assert univ.Integer().getTagSet() == tag.TagSet(
+            (),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x02)
+            )
+    def testNamedVals(self):
+        i = univ.Integer(
+            'asn1', namedValues=univ.Integer.namedValues.clone(('asn1', 1))
+            )
+        assert i == 1, 'named val fails'
+        assert str(i) != 'asn1', 'named val __str__() fails'
+
+class BooleanTestCase(unittest.TestCase):
+    def testTruth(self):
+        assert univ.Boolean(True) and univ.Boolean(1), 'Truth initializer fails'
+    def testFalse(self):
+        assert not univ.Boolean(False) and not univ.Boolean(0), 'False initializer fails'
+    def testStr(self):
+        assert str(univ.Boolean(1)) in ('1', '1L'), 'str() fails'
+    def testTag(self):
+        assert univ.Boolean().getTagSet() == tag.TagSet(
+            (),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x01)
+            )
+    def testConstraints(self):
+        try:
+            univ.Boolean(2)
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint fail'
+    def testSubtype(self):
+        assert univ.Integer().subtype(
+            value=1,
+            implicitTag=tag.Tag(tag.tagClassPrivate,tag.tagFormatSimple,2),
+            subtypeSpec=constraint.SingleValueConstraint(1,3)
+            ) == univ.Integer(
+            value=1,
+            tagSet=tag.TagSet(tag.Tag(tag.tagClassPrivate,
+                                        tag.tagFormatSimple,2)),
+            subtypeSpec=constraint.ConstraintsIntersection(constraint.SingleValueConstraint(1,3))
+            )
+
+class BitStringTestCase(unittest.TestCase):
+    def setUp(self):
+        self.b = univ.BitString(
+            namedValues=namedval.NamedValues(('Active', 0), ('Urgent', 1))
+            )
+    def testSet(self):
+        assert self.b.clone('Active') == (1,)
+        assert self.b.clone("'1010100110001010'B") == (1,0,1,0,1,0,0,1,1,0,0,0,1,0,1,0)
+        assert self.b.clone("'A98A'H") == (1,0,1,0,1,0,0,1,1,0,0,0,1,0,1,0)
+        assert self.b.clone((1,0,1)) == (1,0,1)
+    def testStr(self):
+        assert str(self.b.clone('Urgent,Active')) == '(1, 1)'
+    def testRepr(self):
+        assert repr(self.b.clone('Urgent,Active')) == 'BitString("\'11\'B")'
+    def testTag(self):
+        assert univ.BitString().getTagSet() == tag.TagSet(
+            (),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x03)
+            )
+    def testLen(self): assert len(self.b.clone("'A98A'H")) == 16
+    def testIter(self):
+        assert self.b.clone("'A98A'H")[0] == 1
+        assert self.b.clone("'A98A'H")[1] == 0
+        assert self.b.clone("'A98A'H")[2] == 1
+        
+class OctetStringTestCase(unittest.TestCase):
+    def testInit(self):
+        assert univ.OctetString(str2octs('abcd')) == str2octs('abcd'), '__init__() fails'
+    def testBinStr(self):
+        assert univ.OctetString(binValue="1000010111101110101111000000111011") == ints2octs((133, 238, 188, 14, 192)), 'bin init fails'
+    def testHexStr(self):
+        assert univ.OctetString(hexValue="FA9823C43E43510DE3422") == ints2octs((250, 152, 35, 196, 62, 67, 81, 13, 227, 66, 32)), 'hex init fails'
+    def testTuple(self):
+        assert univ.OctetString((1,2,3,4,5)) == ints2octs((1,2,3,4,5)), 'tuple init failed'
+    def testStr(self):
+        assert str(univ.OctetString('q')) == 'q', '__str__() fails'
+    def testSeq(self):
+        assert univ.OctetString('q')[0] == str2octs('q')[0],'__getitem__() fails'
+    def testAsOctets(self):
+        assert univ.OctetString('abcd').asOctets() == str2octs('abcd'), 'testAsOctets() fails'
+    def testAsInts(self):
+        assert univ.OctetString('abcd').asNumbers() == (97, 98, 99, 100), 'testAsNumbers() fails'
+
+    def testEmpty(self):
+        try:
+            str(univ.OctetString())
+        except PyAsn1Error:
+            pass
+        else:
+            assert 0, 'empty OctetString() not reported'
+            
+    def testAdd(self):
+        assert univ.OctetString('') + 'q' == str2octs('q'), '__add__() fails'
+    def testRadd(self):
+        assert 'b' + univ.OctetString('q') == str2octs('bq'), '__radd__() fails'
+    def testMul(self):
+        assert univ.OctetString('a') * 2 == str2octs('aa'), '__mul__() fails'
+    def testRmul(self):
+        assert 2 * univ.OctetString('b') == str2octs('bb'), '__rmul__() fails'
+    def testTag(self):
+        assert univ.OctetString().getTagSet() == tag.TagSet(
+            (),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x04)
+            )
+
+class Null(unittest.TestCase):
+    def testStr(self): assert str(univ.Null('')) == '', 'str() fails'
+    def testTag(self):
+        assert univ.Null().getTagSet() == tag.TagSet(
+            (),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x05)
+            )
+    def testConstraints(self):
+        try:
+            univ.Null(2)
+        except error.ValueConstraintError:
+            pass
+        else:
+            assert 0, 'constraint fail'
+
+class RealTestCase(unittest.TestCase):
+    def testStr(self): assert str(univ.Real(1.0)) == '1.0','str() fails'
+    def testRepr(self): assert repr(univ.Real(-4.1)) == 'Real((-41, 10, -1))','repr() fails'
+    def testAdd(self): assert univ.Real(-4.1) + 1.4 == -2.7, '__add__() fails'
+    def testRadd(self): assert 4 + univ.Real(0.5) == 4.5, '__radd__() fails'
+    def testSub(self): assert univ.Real(3.9) - 1.7 == 2.2, '__sub__() fails'
+    def testRsub(self): assert 6.1 - univ.Real(0.1) == 6, '__rsub__() fails'
+    def testMul(self): assert univ.Real(3.0) * -3 == -9, '__mul__() fails'
+    def testRmul(self): assert 2 * univ.Real(3.0) == 6, '__rmul__() fails'
+    def testDiv(self): assert univ.Real(3.0) / 2 == 1.5, '__div__() fails'
+    def testRdiv(self): assert 6 / univ.Real(3.0) == 2, '__rdiv__() fails'
+    def testMod(self): assert univ.Real(3.0) % 2 == 1, '__mod__() fails'
+    def testRmod(self): assert 4 % univ.Real(3.0) == 1, '__rmod__() fails'
+    def testPow(self): assert univ.Real(3.0) ** 2 == 9, '__pow__() fails'
+    def testRpow(self): assert 2 ** univ.Real(2.0) == 4, '__rpow__() fails'
+    def testInt(self): assert int(univ.Real(3.0)) == 3, '__int__() fails'
+    def testLong(self): assert int(univ.Real(8.0)) == 8, '__long__() fails'
+    def testFloat(self): assert float(univ.Real(4.0))==4.0,'__float__() fails'
+    def testPrettyIn(self): assert univ.Real((3,10,0)) == 3, 'prettyIn() fails'
+    # infinite float values
+    def testStrInf(self):
+        assert str(univ.Real('inf')) == 'inf','str() fails'
+    def testReprInf(self):
+        assert repr(univ.Real('inf')) == 'Real(\'inf\')','repr() fails'
+    def testAddInf(self):
+        assert univ.Real('inf') + 1 == float('inf'), '__add__() fails'
+    def testRaddInf(self):
+        assert 1 + univ.Real('inf') == float('inf'), '__radd__() fails'
+    def testIntInf(self):
+        try:
+            assert int(univ.Real('inf'))
+        except OverflowError:
+            pass
+        else:
+            assert 0, '__int__() fails'
+    def testLongInf(self):
+        try:
+            assert int(univ.Real('inf'))
+        except OverflowError:
+            pass
+        else:
+            assert 0, '__long__() fails'        
+        assert int(univ.Real(8.0)) == 8, '__long__() fails'
+    def testFloatInf(self):
+        assert float(univ.Real('-inf')) == float('-inf'),'__float__() fails'
+    def testPrettyInInf(self):
+        assert univ.Real(float('inf')) == float('inf'), 'prettyIn() fails'
+    def testPlusInf(self):
+        assert univ.Real('inf').isPlusInfinity(), 'isPlusInfinity failed'
+    def testMinusInf(self):
+        assert univ.Real('-inf').isMinusInfinity(), 'isMinusInfinity failed'
+
+    def testTag(self):
+        assert univ.Real().getTagSet() == tag.TagSet(
+            (),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x09)
+            )
+
+class ObjectIdentifier(unittest.TestCase):
+    def testStr(self):
+        assert str(univ.ObjectIdentifier((1,3,6))) == '1.3.6'
+    def testEq(self):
+        assert univ.ObjectIdentifier((1,3,6)) == (1,3,6), '__cmp__() fails'
+    def testAdd(self):
+        assert univ.ObjectIdentifier((1,3)) + (6,)==(1,3,6),'__add__() fails'
+    def testRadd(self):
+        assert (1,) + univ.ObjectIdentifier((3,6))==(1,3,6),'__radd__() fails'
+    def testLen(self):
+        assert len(univ.ObjectIdentifier((1,3))) == 2,'__len__() fails'
+    def testPrefix(self):
+        o = univ.ObjectIdentifier('1.3.6')
+        assert o.isPrefixOf((1,3,6)), 'isPrefixOf() fails'
+        assert o.isPrefixOf((1,3,6,1)), 'isPrefixOf() fails'
+        assert not o.isPrefixOf((1,3)), 'isPrefixOf() fails'        
+    def testInput(self):
+        assert univ.ObjectIdentifier('1.3.6')==(1,3,6),'prettyIn() fails'
+    def testTag(self):
+        assert univ.ObjectIdentifier().getTagSet() == tag.TagSet(
+            (),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x06)
+            )
+
+class SequenceOf(unittest.TestCase):
+    def setUp(self):
+        self.s1 = univ.SequenceOf(
+            componentType=univ.OctetString('')
+            )
+        self.s2 = self.s1.clone()
+    def testTag(self):
+        assert self.s1.getTagSet() == tag.TagSet(
+            (),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x10)
+            ), 'wrong tagSet'
+    def testSeq(self):
+        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
+        assert self.s1[0] == str2octs('abc'), 'set by idx fails'
+        self.s1[0] = 'cba'
+        assert self.s1[0] == str2octs('cba'), 'set by idx fails'
+    def testCmp(self):
+        self.s1.clear()
+        self.s1.setComponentByPosition(0, 'abc')
+        self.s2.clear()
+        self.s2.setComponentByPosition(0, univ.OctetString('abc'))
+        assert self.s1 == self.s2, '__cmp__() fails'
+    def testSubtypeSpec(self):
+        s = self.s1.clone(subtypeSpec=constraint.ConstraintsUnion(
+            constraint.SingleValueConstraint(str2octs('abc'))
+            ))
+        try:
+            s.setComponentByPosition(0, univ.OctetString('abc'))
+        except:
+            assert 0, 'constraint fails'
+        try:
+            s.setComponentByPosition(1, univ.OctetString('Abc'))
+        except:
+            pass
+        else:
+            assert 0, 'constraint fails'
+    def testSizeSpec(self):
+        s = self.s1.clone(sizeSpec=constraint.ConstraintsUnion(
+            constraint.ValueSizeConstraint(1,1)
+            ))
+        s.setComponentByPosition(0, univ.OctetString('abc'))
+        try:
+            s.verifySizeSpec()
+        except:
+            assert 0, 'size spec fails'
+        s.setComponentByPosition(1, univ.OctetString('abc'))
+        try:
+            s.verifySizeSpec()
+        except:
+            pass
+        else:
+            assert 0, 'size spec fails'
+    def testGetComponentTagMap(self):
+        assert self.s1.getComponentTagMap().getPosMap() == {
+            univ.OctetString.tagSet: univ.OctetString('')
+            }
+    def testSubtype(self):
+        self.s1.clear()
+        assert self.s1.subtype(
+            implicitTag=tag.Tag(tag.tagClassPrivate,tag.tagFormatSimple,2),
+            subtypeSpec=constraint.SingleValueConstraint(1,3),
+            sizeSpec=constraint.ValueSizeConstraint(0,1)
+            ) == self.s1.clone(
+            tagSet=tag.TagSet(tag.Tag(tag.tagClassPrivate,
+                                        tag.tagFormatSimple,2)),
+            subtypeSpec=constraint.ConstraintsIntersection(constraint.SingleValueConstraint(1,3)),
+            sizeSpec=constraint.ValueSizeConstraint(0,1)
+            )
+    def testClone(self):
+        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
+        s = self.s1.clone()
+        assert len(s) == 0
+        s = self.s1.clone(cloneValueFlag=1)
+        assert len(s) == 1
+        assert s.getComponentByPosition(0) == self.s1.getComponentByPosition(0)
+        
+class Sequence(unittest.TestCase):
+    def setUp(self):
+        self.s1 = univ.Sequence(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('name', univ.OctetString('')),
+            namedtype.OptionalNamedType('nick', univ.OctetString('')),
+            namedtype.DefaultedNamedType('age', univ.Integer(34))
+            ))
+    def testTag(self):
+        assert self.s1.getTagSet() == tag.TagSet(
+            (),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x10)
+            ), 'wrong tagSet'
+    def testById(self):
+        self.s1.setComponentByName('name', univ.OctetString('abc'))
+        assert self.s1.getComponentByName('name') == str2octs('abc'), 'set by name fails'
+    def testByKey(self):
+        self.s1['name'] = 'abc'
+        assert self.s1['name'] == str2octs('abc'), 'set by key fails'
+    def testGetNearPosition(self):
+        assert self.s1.getComponentTagMapNearPosition(1).getPosMap() == {
+            univ.OctetString.tagSet: univ.OctetString(''),
+            univ.Integer.tagSet: univ.Integer(34)
+            }
+        assert self.s1.getComponentPositionNearType(
+            univ.OctetString.tagSet, 1
+            ) == 1
+    def testGetDefaultComponentByPosition(self):
+        self.s1.clear()
+        assert self.s1.getDefaultComponentByPosition(0) == None
+        assert self.s1.getDefaultComponentByPosition(2) == univ.Integer(34)
+    def testSetDefaultComponents(self):
+        self.s1.clear()
+        assert self.s1.getComponentByPosition(2) == None
+        self.s1.setComponentByPosition(0, univ.OctetString('Ping'))
+        self.s1.setComponentByPosition(1, univ.OctetString('Pong'))
+        self.s1.setDefaultComponents()
+        assert self.s1.getComponentByPosition(2) == 34
+    def testClone(self):
+        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
+        self.s1.setComponentByPosition(1, univ.OctetString('def'))
+        self.s1.setComponentByPosition(2, univ.Integer(123))
+        s = self.s1.clone()
+        assert s.getComponentByPosition(0) != self.s1.getComponentByPosition(0)
+        assert s.getComponentByPosition(1) != self.s1.getComponentByPosition(1)
+        assert s.getComponentByPosition(2) != self.s1.getComponentByPosition(2)
+        s = self.s1.clone(cloneValueFlag=1)
+        assert s.getComponentByPosition(0) == self.s1.getComponentByPosition(0)
+        assert s.getComponentByPosition(1) == self.s1.getComponentByPosition(1)
+        assert s.getComponentByPosition(2) == self.s1.getComponentByPosition(2)
+
+class SetOf(unittest.TestCase):
+    def setUp(self):
+        self.s1 = univ.SetOf(componentType=univ.OctetString(''))
+    def testTag(self):
+        assert self.s1.getTagSet() == tag.TagSet(
+            (),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x11)
+            ), 'wrong tagSet'
+    def testSeq(self):
+        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
+        assert self.s1[0] == str2octs('abc'), 'set by idx fails'
+        self.s1.setComponentByPosition(0, self.s1[0].clone('cba'))
+        assert self.s1[0] == str2octs('cba'), 'set by idx fails'
+
+class Set(unittest.TestCase):
+    def setUp(self):
+        self.s1 = univ.Set(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('name', univ.OctetString('')),
+            namedtype.OptionalNamedType('null', univ.Null('')),
+            namedtype.DefaultedNamedType('age', univ.Integer(34))
+            ))
+        self.s2 = self.s1.clone()
+    def testTag(self):
+        assert self.s1.getTagSet() == tag.TagSet(
+            (),
+            tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x11)
+            ), 'wrong tagSet'
+    def testByTypeWithPythonValue(self):
+        self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
+        assert self.s1.getComponentByType(
+            univ.OctetString.tagSet
+            ) == str2octs('abc'), 'set by name fails'
+    def testByTypeWithInstance(self):
+        self.s1.setComponentByType(univ.OctetString.tagSet, univ.OctetString('abc'))
+        assert self.s1.getComponentByType(
+            univ.OctetString.tagSet
+            ) == str2octs('abc'), 'set by name fails'
+    def testGetTagMap(self):
+        assert self.s1.getTagMap().getPosMap() == {
+            univ.Set.tagSet: univ.Set()
+            }
+    def testGetComponentTagMap(self):
+        assert self.s1.getComponentTagMap().getPosMap() == {
+            univ.OctetString.tagSet: univ.OctetString(''),
+            univ.Null.tagSet: univ.Null(''),
+            univ.Integer.tagSet: univ.Integer(34)
+            }
+    def testGetPositionByType(self):
+        assert self.s1.getComponentPositionByType(
+            univ.Null().getTagSet()
+            ) == 1
+
+class Choice(unittest.TestCase):
+    def setUp(self):
+        innerComp = univ.Choice(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('count', univ.Integer()),
+            namedtype.NamedType('flag', univ.Boolean())
+            ))
+        self.s1 = univ.Choice(componentType=namedtype.NamedTypes(
+            namedtype.NamedType('name', univ.OctetString()),
+            namedtype.NamedType('sex', innerComp)
+            ))
+    def testTag(self):
+        assert self.s1.getTagSet() == tag.TagSet(), 'wrong tagSet'
+    def testOuterByTypeWithPythonValue(self):
+        self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
+        assert self.s1.getComponentByType(
+            univ.OctetString.tagSet
+            ) == str2octs('abc')
+    def testOuterByTypeWithInstanceValue(self):
+        self.s1.setComponentByType(
+            univ.OctetString.tagSet, univ.OctetString('abc')
+            )
+        assert self.s1.getComponentByType(
+            univ.OctetString.tagSet
+            ) == str2octs('abc')
+    def testInnerByTypeWithPythonValue(self):
+        self.s1.setComponentByType(univ.Integer.tagSet, 123, 1)
+        assert self.s1.getComponentByType(
+            univ.Integer.tagSet, 1
+            ) == 123
+    def testInnerByTypeWithInstanceValue(self):
+        self.s1.setComponentByType(
+            univ.Integer.tagSet, univ.Integer(123), 1
+            )
+        assert self.s1.getComponentByType(
+            univ.Integer.tagSet, 1
+            ) == 123
+    def testCmp(self):
+        self.s1.setComponentByName('name', univ.OctetString('abc'))
+        assert self.s1 == str2octs('abc'), '__cmp__() fails'
+    def testGetComponent(self):
+        self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
+        assert self.s1.getComponent() == str2octs('abc'), 'getComponent() fails'
+    def testGetName(self):
+        self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
+        assert self.s1.getName() == 'name', 'getName() fails'
+    def testSetComponentByPosition(self):
+        self.s1.setComponentByPosition(0, univ.OctetString('Jim'))
+        assert self.s1 == str2octs('Jim')
+    def testClone(self):
+        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
+        s = self.s1.clone()
+        assert len(s) == 0
+        s = self.s1.clone(cloneValueFlag=1)
+        assert len(s) == 1
+        assert s.getComponentByPosition(0) == self.s1.getComponentByPosition(0)
+        
+if __name__ == '__main__': unittest.main()