run unit tests with full debugging enabled (and ignored)

Also fixed a couple of crashes in debug messages

7 files changed, 146 insertions, 72 deletions

diff --git a/tests/type/test_char.py b/tests/type/test_char.py
index dcdbbd2..74550c0 100644
--- a/tests/type/test_char.py
+++ b/tests/type/test_char.py
@@ -5,23 +5,28 @@
 # License: http://pyasn1.sf.net/license.html
 #
 import sys
-from pyasn1.type import char, univ, constraint
-from pyasn1.compat.octets import ints2octs
-from pyasn1.error import PyAsn1Error
 
 try:
     import unittest2 as unittest
 except ImportError:
     import unittest
 
+from tests.base import BaseTestCase
+
+from pyasn1.type import char, univ, constraint
+from pyasn1.compat.octets import ints2octs
+from pyasn1.error import PyAsn1Error
 
-class AbstractStringTestCase:
+
+class AbstractStringTestCase(object):
 
     initializer = ()
     encoding = 'us-ascii'
     asn1Type = None
 
     def setUp(self):
+        BaseTestCase.setUp(self)
+
         self.asn1String = self.asn1Type(ints2octs(self.initializer), encoding=self.encoding)
         self.pythonString = ints2octs(self.initializer).decode(self.encoding)
 
@@ -107,28 +112,28 @@ class AbstractStringTestCase:
             assert list(reversed(self.asn1String)) == list(reversed(self.pythonString))
 
 
-class VisibleStringTestCase(AbstractStringTestCase, unittest.TestCase):
+class VisibleStringTestCase(AbstractStringTestCase, BaseTestCase):
 
     initializer = (97, 102)
     encoding = 'us-ascii'
     asn1Type = char.VisibleString
 
 
-class GeneralStringTestCase(AbstractStringTestCase, unittest.TestCase):
+class GeneralStringTestCase(AbstractStringTestCase, BaseTestCase):
 
     initializer = (169, 174)
     encoding = 'iso-8859-1'
     asn1Type = char.GeneralString
 
 
-class UTF8StringTestCase(AbstractStringTestCase, unittest.TestCase):
+class UTF8StringTestCase(AbstractStringTestCase, BaseTestCase):
 
     initializer = (209, 132, 208, 176)
     encoding = 'utf-8'
     asn1Type = char.UTF8String
 
 
-class BMPStringTestCase(AbstractStringTestCase, unittest.TestCase):
+class BMPStringTestCase(AbstractStringTestCase, BaseTestCase):
 
     initializer = (4, 48, 4, 68)
     encoding = 'utf-16-be'
@@ -139,7 +144,7 @@ if sys.version_info[0] > 2:
 
     # Somehow comparison of UTF-32 encoded strings does not work in Py2
 
-    class UniversalStringTestCase(AbstractStringTestCase, unittest.TestCase):
+    class UniversalStringTestCase(AbstractStringTestCase, BaseTestCase):
         initializer = (0, 0, 4, 48, 0, 0, 4, 68)
         encoding = 'utf-32-be'
         asn1Type = char.UniversalString
diff --git a/tests/type/test_constraint.py b/tests/type/test_constraint.py
index 0ea4ed4..1dbffb1 100644
--- a/tests/type/test_constraint.py
+++ b/tests/type/test_constraint.py
@@ -5,17 +5,21 @@
 # License: http://pyasn1.sf.net/license.html
 #
 import sys
+
 try:
     import unittest2 as unittest
 
 except ImportError:
     import unittest
 
+from tests.base import BaseTestCase
+
 from pyasn1.type import constraint, error
 
 
-class SingleValueConstraintTestCase(unittest.TestCase):
+class SingleValueConstraintTestCase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.c1 = constraint.SingleValueConstraint(1, 2)
         self.c2 = constraint.SingleValueConstraint(3, 4)
 
@@ -28,6 +32,7 @@ class SingleValueConstraintTestCase(unittest.TestCase):
     def testGoodVal(self):
         try:
             self.c1(1)
+
         except error.ValueConstraintError:
             assert 0, 'constraint check fails'
 
@@ -40,8 +45,9 @@ class SingleValueConstraintTestCase(unittest.TestCase):
             assert 0, 'constraint check fails'
 
 
-class ContainedSubtypeConstraintTestCase(unittest.TestCase):
+class ContainedSubtypeConstraintTestCase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.c1 = constraint.ContainedSubtypeConstraint(
             constraint.SingleValueConstraint(12)
         )
@@ -61,8 +67,9 @@ class ContainedSubtypeConstraintTestCase(unittest.TestCase):
             assert 0, 'constraint check fails'
 
 
-class ValueRangeConstraintTestCase(unittest.TestCase):
+class ValueRangeConstraintTestCase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.c1 = constraint.ValueRangeConstraint(1, 4)
 
     def testGoodVal(self):
@@ -80,8 +87,9 @@ class ValueRangeConstraintTestCase(unittest.TestCase):
             assert 0, 'constraint check fails'
 
 
-class ValueSizeConstraintTestCase(unittest.TestCase):
+class ValueSizeConstraintTestCase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.c1 = constraint.ValueSizeConstraint(1, 2)
 
     def testGoodVal(self):
@@ -119,8 +127,9 @@ class PermittedAlphabetConstraintTestCase(SingleValueConstraintTestCase):
             assert 0, 'constraint check fails'
 
 
-class ConstraintsIntersectionTestCase(unittest.TestCase):
+class ConstraintsIntersectionTestCase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.c1 = constraint.ConstraintsIntersection(
             constraint.SingleValueConstraint(4),
             constraint.ValueRangeConstraint(2, 4)
@@ -161,7 +170,7 @@ class ConstraintsIntersectionTestCase(unittest.TestCase):
             assert 0, 'constraint check fails'
 
 
-class InnerTypeConstraintTestCase(unittest.TestCase):
+class InnerTypeConstraintTestCase(BaseTestCase):
     def testConst1(self):
         c = constraint.InnerTypeConstraint(
             constraint.SingleValueConstraint(4)
@@ -203,8 +212,9 @@ class InnerTypeConstraintTestCase(unittest.TestCase):
         # Constraints compositions
 
 
-class ConstraintsIntersectionRangeTestCase(unittest.TestCase):
+class ConstraintsIntersectionRangeTestCase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.c1 = constraint.ConstraintsIntersection(
             constraint.ValueRangeConstraint(1, 9),
             constraint.ValueRangeConstraint(2, 5)
@@ -225,8 +235,9 @@ class ConstraintsIntersectionRangeTestCase(unittest.TestCase):
             assert 0, 'constraint check fails'
 
 
-class ConstraintsUnionTestCase(unittest.TestCase):
+class ConstraintsUnionTestCase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.c1 = constraint.ConstraintsUnion(
             constraint.SingleValueConstraint(5),
             constraint.ValueRangeConstraint(1, 3)
@@ -248,8 +259,9 @@ class ConstraintsUnionTestCase(unittest.TestCase):
             assert 0, 'constraint check fails'
 
 
-class ConstraintsExclusionTestCase(unittest.TestCase):
+class ConstraintsExclusionTestCase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.c1 = constraint.ConstraintsExclusion(
             constraint.ValueRangeConstraint(2, 4)
         )
@@ -271,9 +283,12 @@ class ConstraintsExclusionTestCase(unittest.TestCase):
 
 # Constraints derivations
 
-class DirectDerivationTestCase(unittest.TestCase):
+class DirectDerivationTestCase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
+
         self.c1 = constraint.SingleValueConstraint(5)
+
         self.c2 = constraint.ConstraintsUnion(
             self.c1, constraint.ValueRangeConstraint(1, 3)
         )
@@ -287,14 +302,18 @@ class DirectDerivationTestCase(unittest.TestCase):
         assert self.c2.isSubTypeOf(self.c1), 'isSubTypeOf failed'
 
 
-class IndirectDerivationTestCase(unittest.TestCase):
+class IndirectDerivationTestCase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.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)
         )
@@ -307,7 +326,7 @@ class IndirectDerivationTestCase(unittest.TestCase):
         assert not self.c2.isSuperTypeOf(self.c1), 'isSuperTypeOf failed'
         assert self.c2.isSubTypeOf(self.c1), 'isSubTypeOf failed'
 
-# TODO: how to apply size constriants to constructed types?
+# TODO: how to apply size constraints to constructed types?
 
 suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
 
diff --git a/tests/type/test_namedtype.py b/tests/type/test_namedtype.py
index 4991876..65f9d65 100644
--- a/tests/type/test_namedtype.py
+++ b/tests/type/test_namedtype.py
@@ -5,17 +5,22 @@
 # License: http://pyasn1.sf.net/license.html
 #
 import sys
+
 try:
     import unittest2 as unittest
+
 except ImportError:
     import unittest
 
+from tests.base import BaseTestCase
+
 from pyasn1.type import namedtype, univ
 from pyasn1.error import PyAsn1Error
 
 
-class NamedTypeCaseBase(unittest.TestCase):
+class NamedTypeCaseBase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.e = namedtype.NamedType('age', univ.Integer(0))
 
     def testIter(self):
@@ -26,8 +31,10 @@ class NamedTypeCaseBase(unittest.TestCase):
         assert eval(repr(self.e), {'NamedType': namedtype.NamedType, 'Integer': univ.Integer}) == self.e, 'repr() fails'
 
 
-class NamedTypesCaseBase(unittest.TestCase):
+class NamedTypesCaseBase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
+
         self.e = namedtype.NamedTypes(
             namedtype.NamedType('first-name', univ.OctetString('')),
             namedtype.OptionalNamedType('age', univ.Integer(0)),
@@ -35,9 +42,15 @@ class NamedTypesCaseBase(unittest.TestCase):
         )
 
     def testRepr(self):
-        assert eval(repr(self.e), {'NamedTypes': namedtype.NamedTypes, 'NamedType': namedtype.NamedType,
-                                   'OptionalNamedType': namedtype.OptionalNamedType, 'Integer': univ.Integer,
-                                   'OctetString': univ.OctetString}) == self.e, 'repr() fails'
+        assert eval(
+            repr(self.e), {
+                'NamedTypes': namedtype.NamedTypes,
+                'NamedType': namedtype.NamedType,
+                'OptionalNamedType': namedtype.OptionalNamedType,
+                'Integer': univ.Integer,
+                'OctetString': univ.OctetString
+            }
+        ) == self.e, 'repr() fails'
 
     def testContains(self):
         assert 'first-name' in self.e
@@ -104,8 +117,10 @@ class NamedTypesCaseBase(unittest.TestCase):
         assert self.e.getPositionNearType(univ.OctetString.tagSet, 2) == 2
 
 
-class OrderedNamedTypesCaseBase(unittest.TestCase):
+class OrderedNamedTypesCaseBase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
+
         self.e = namedtype.NamedTypes(
             namedtype.NamedType('first-name', univ.OctetString('')),
             namedtype.NamedType('age', univ.Integer(0))
@@ -116,7 +131,7 @@ class OrderedNamedTypesCaseBase(unittest.TestCase):
             'getTypeByPosition() fails'
 
 
-class DuplicateNamedTypesCaseBase(unittest.TestCase):
+class DuplicateNamedTypesCaseBase(BaseTestCase):
     def testDuplicateDefaultTags(self):
         nt = namedtype.NamedTypes(
             namedtype.NamedType('first-name', univ.Any()),
diff --git a/tests/type/test_namedval.py b/tests/type/test_namedval.py
index 6504b34..215a3a1 100644
--- a/tests/type/test_namedval.py
+++ b/tests/type/test_namedval.py
@@ -5,17 +5,21 @@
 # License: http://pyasn1.sf.net/license.html
 #
 import sys
+
 try:
     import unittest2 as unittest
 
 except ImportError:
     import unittest
 
+from tests.base import BaseTestCase
+
 from pyasn1.type import namedval
 
 
-class NamedValuesCaseBase(unittest.TestCase):
+class NamedValuesCaseBase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.e = namedval.NamedValues(('off', 0), ('on', 1))
 
     def testDict(self):
diff --git a/tests/type/test_tag.py b/tests/type/test_tag.py
index fac9783..57121e8 100644
--- a/tests/type/test_tag.py
+++ b/tests/type/test_tag.py
@@ -5,17 +5,21 @@
 # License: http://pyasn1.sf.net/license.html
 #
 import sys
+
 try:
     import unittest2 as unittest
 
 except ImportError:
     import unittest
 
+from tests.base import BaseTestCase
+
 from pyasn1.type import tag
 
 
-class TagTestCaseBase(unittest.TestCase):
+class TagTestCaseBase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.t1 = tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 3)
         self.t2 = tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 3)
 
@@ -38,11 +42,14 @@ class TagCmpTestCase(TagTestCaseBase):
                self.t1[2] == self.t2[2], 'tag sequence protocol fails'
 
 
-class TagSetTestCaseBase(unittest.TestCase):
+class TagSetTestCaseBase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
+
         self.ts1 = tag.initTagSet(
             tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12)
         )
+
         self.ts2 = tag.initTagSet(
             tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12)
         )
diff --git a/tests/type/test_univ.py b/tests/type/test_univ.py
index c9da0b2..23f269e 100644
--- a/tests/type/test_univ.py
+++ b/tests/type/test_univ.py
@@ -6,17 +6,21 @@
 #
 import sys
 import math
-from pyasn1.type import univ, tag, constraint, namedtype, namedval, error
-from pyasn1.compat.octets import str2octs, ints2octs, octs2ints
-from pyasn1.error import PyAsn1Error
 
 try:
     import unittest2 as unittest
+
 except ImportError:
     import unittest
 
+from tests.base import BaseTestCase
 
-class NoValueTestCase(unittest.TestCase):
+from pyasn1.type import univ, tag, constraint, namedtype, namedval, error
+from pyasn1.compat.octets import str2octs, ints2octs, octs2ints
+from pyasn1.error import PyAsn1Error
+
+
+class NoValueTestCase(BaseTestCase):
     def testSingleton(self):
         assert univ.NoValue() is univ.NoValue(), 'NoValue is not a singleton'
 
@@ -144,7 +148,7 @@ class NoValueTestCase(unittest.TestCase):
             assert False, 'sizeof failed for NoValue object'
 
 
-class IntegerTestCase(unittest.TestCase):
+class IntegerTestCase(BaseTestCase):
     def testStr(self):
         assert str(univ.Integer(1)) in ('1', '1L'), 'str() fails'
 
@@ -292,7 +296,7 @@ class IntegerTestCase(unittest.TestCase):
         )
 
 
-class BooleanTestCase(unittest.TestCase):
+class BooleanTestCase(BaseTestCase):
     def testTruth(self):
         assert univ.Boolean(True) and univ.Boolean(1), 'Truth initializer fails'
 
@@ -324,8 +328,10 @@ class BooleanTestCase(unittest.TestCase):
             assert 0, 'constraint fail'
 
 
-class BitStringTestCase(unittest.TestCase):
+class BitStringTestCase(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
+
         self.b = univ.BitString(
             namedValues=namedval.NamedValues(('Active', 0), ('Urgent', 1))
         )
@@ -465,17 +471,17 @@ class OctetStringWithUnicodeMixIn(object):
            assert list(reversed(univ.OctetString(self.encodedPythonString))) == list(reversed(self.encodedPythonString))
 
 
-class OctetStringWithAsciiTestCase(OctetStringWithUnicodeMixIn, unittest.TestCase):
+class OctetStringWithAsciiTestCase(OctetStringWithUnicodeMixIn, BaseTestCase):
     initializer = (97, 102)
     encoding = 'us-ascii'
 
 
-class OctetStringWithUtf8TestCase(OctetStringWithUnicodeMixIn, unittest.TestCase):
+class OctetStringWithUtf8TestCase(OctetStringWithUnicodeMixIn, BaseTestCase):
     initializer = (208, 176, 208, 177, 208, 178)
     encoding = 'utf-8'
 
 
-class OctetStringWithUtf16TestCase(OctetStringWithUnicodeMixIn, unittest.TestCase):
+class OctetStringWithUtf16TestCase(OctetStringWithUnicodeMixIn, BaseTestCase):
     initializer = (4, 48, 4, 49, 4, 50)
     encoding = 'utf-16-be'
 
@@ -484,12 +490,12 @@ if sys.version_info[0] > 2:
 
     # Somehow comparison of UTF-32 encoded strings does not work in Py2
 
-    class OctetStringWithUtf32TestCase(OctetStringWithUnicodeMixIn, unittest.TestCase):
+    class OctetStringWithUtf32TestCase(OctetStringWithUnicodeMixIn, BaseTestCase):
         initializer = (0, 0, 4, 48, 0, 0, 4, 49, 0, 0, 4, 50)
         encoding = 'utf-32-be'
 
 
-class OctetStringTestCase(unittest.TestCase):
+class OctetStringTestCase(BaseTestCase):
 
     def testBinDefault(self):
 
@@ -539,7 +545,7 @@ class OctetStringTestCase(unittest.TestCase):
         assert OctetString(hexValue="FA9823C43E43510DE3422") == ints2octs((250, 152, 35, 196, 62, 67, 81, 13, 227, 66, 32))
 
 
-class Null(unittest.TestCase):
+class Null(BaseTestCase):
     def testStr(self):
         assert str(univ.Null('')) == '', 'str() fails'
 
@@ -568,7 +574,7 @@ class Null(unittest.TestCase):
         assert not Null()
 
 
-class RealTestCase(unittest.TestCase):
+class RealTestCase(BaseTestCase):
     def testFloat4BinEnc(self):
         assert univ.Real((0.25, 2, 3)) == 2.0, 'float initializer for binary encoding fails'
 
@@ -701,7 +707,7 @@ class RealTestCase(unittest.TestCase):
         assert Real(1.0) == 1.0
 
 
-class ObjectIdentifier(unittest.TestCase):
+class ObjectIdentifier(BaseTestCase):
     def testStr(self):
         assert str(univ.ObjectIdentifier((1, 3, 6))) == '1.3.6', 'str() fails'
 
@@ -761,8 +767,9 @@ class ObjectIdentifier(unittest.TestCase):
         assert str(ObjectIdentifier((1, 3, 6))) == '1.3.6'
 
 
-class SequenceOf(unittest.TestCase):
+class SequenceOf(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.s1 = univ.SequenceOf(
             componentType=univ.OctetString('')
         )
@@ -954,20 +961,28 @@ class SequenceOf(unittest.TestCase):
 
         assert n == o
 
-class Sequence(unittest.TestCase):
+class Sequence(BaseTestCase):
     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))
-        ))
+        BaseTestCase.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 testRepr(self):
-        assert eval(repr(self.s1.clone().setComponents('a', 'b')),
-                    {'Sequence': univ.Sequence, 'OctetString': univ.OctetString, 'Integer': univ.Integer,
-                     'NamedTypes': namedtype.NamedTypes, 'NamedType': namedtype.NamedType,
-                     'OptionalNamedType': namedtype.OptionalNamedType,
-                     'DefaultedNamedType': namedtype.DefaultedNamedType}) == self.s1.clone().setComponents('a', 'b'), 'repr() fails'
+        assert eval(
+            repr(self.s1.clone().setComponents('a', 'b')),
+            {'Sequence': univ.Sequence,
+             'OctetString': univ.OctetString,
+             'Integer': univ.Integer,
+             'NamedTypes': namedtype.NamedTypes,
+             'NamedType': namedtype.NamedType,
+             'OptionalNamedType': namedtype.OptionalNamedType,
+             'DefaultedNamedType': namedtype.DefaultedNamedType}
+        ) == self.s1.clone().setComponents('a', 'b'), 'repr() fails'
 
     def testTag(self):
         assert self.s1.tagSet == tag.TagSet(
@@ -1101,7 +1116,7 @@ class Sequence(unittest.TestCase):
         assert s['name'] == str2octs('abc')
 
 
-class SequenceWithoutSchema(unittest.TestCase):
+class SequenceWithoutSchema(BaseTestCase):
 
     def testIter(self):
         s = univ.Sequence()
@@ -1151,8 +1166,9 @@ class SequenceWithoutSchema(unittest.TestCase):
         assert 'field-0' not in s
 
 
-class SetOf(unittest.TestCase):
+class SetOf(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
         self.s1 = univ.SetOf(componentType=univ.OctetString(''))
 
     def testTag(self):
@@ -1178,13 +1194,17 @@ class SetOf(unittest.TestCase):
         assert s == [str2octs('abc')]
 
 
-class Set(unittest.TestCase):
+class Set(BaseTestCase):
     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))
-        ))
+        BaseTestCase.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):
@@ -1241,8 +1261,10 @@ class Set(unittest.TestCase):
         assert s['name'] == str2octs('abc')
 
 
-class Choice(unittest.TestCase):
+class Choice(BaseTestCase):
     def setUp(self):
+        BaseTestCase.setUp(self)
+
         innerComp = univ.Choice(
             componentType=namedtype.NamedTypes(
                 namedtype.NamedType('count', univ.Integer()),
diff --git a/tests/type/test_useful.py b/tests/type/test_useful.py
index dbd6fe0..717eede 100644
--- a/tests/type/test_useful.py
+++ b/tests/type/test_useful.py
@@ -6,14 +6,16 @@
 #
 import sys
 import datetime
-from pyasn1.type import useful
-from pyasn1.error import PyAsn1Error
 
 try:
     import unittest2 as unittest
+
 except ImportError:
     import unittest
 
+from tests.base import BaseTestCase
+
+from pyasn1.type import useful
 
 class FixedOffset(datetime.tzinfo):
     def __init__(self, offset, name):
@@ -34,11 +36,11 @@ UTC = FixedOffset(0, 'UTC')
 UTC2 = FixedOffset(120, 'UTC')
 
 
-class ObjectDescriptorTestCase(unittest.TestCase):
+class ObjectDescriptorTestCase(BaseTestCase):
     pass
 
 
-class GeneralizedTimeTestCase(unittest.TestCase):
+class GeneralizedTimeTestCase(BaseTestCase):
 
     def testFromDateTime(self):
         assert useful.GeneralizedTime.fromDateTime(datetime.datetime(2017, 7, 11, 0, 1, 2, 30000, tzinfo=UTC)) == '20170711000102.3Z'
@@ -71,7 +73,7 @@ class GeneralizedTimeTestCase(unittest.TestCase):
         assert datetime.datetime(2017, 7, 11, 0) == useful.GeneralizedTime('2017071100').asDateTime
 
 
-class UTCTimeTestCase(unittest.TestCase):
+class UTCTimeTestCase(BaseTestCase):
 
     def testFromDateTime(self):
         assert useful.UTCTime.fromDateTime(datetime.datetime(2017, 7, 11, 0, 1, 2, tzinfo=UTC)) == '170711000102Z'