def testFractionOfSecond(self):
     try:
         assert encoder.encode(
             useful.UTCTime('150501120112.10Z')
         )
     except PyAsn1Error:
         pass
     else:
         assert 0, 'Decimal point tolerated'

 def testLocalTimezone(self):
     try:
         assert encoder.encode(
             useful.UTCTime('150501120112+0200')
         )
     except PyAsn1Error:
         pass
     else:
         assert 0, 'Local timezone tolerated'

 def testMissingTimezone(self):
     try:
         assert encoder.encode(
             useful.GeneralizedTime('20150501120112.1')
         )
     except PyAsn1Error:
         pass
     else:
         assert 0, 'Missing timezone tolerated'

 def testMissingTimezone(self):
     try:
         assert encoder.encode(
             useful.UTCTime('150501120112')
         ) == ints2octs((23, 13, 49, 53, 48, 53, 48, 49, 49, 50, 48, 49, 49, 50, 90))
     except PyAsn1Error:
         pass
     else:
         assert 0, 'Missing timezone tolerated'

 def testDecimalCommaPoint(self):
     try:
         assert encoder.encode(
                 useful.GeneralizedTime('20150501120112,1Z')
          )
     except PyAsn1Error:
         pass
     else:
         assert 0, 'Decimal comma tolerated'

    def testWithUntaggedChoice(self):

        c = univ.Choice(
            componentType=namedtype.NamedTypes(
                namedtype.NamedType('premium', univ.Boolean())
            )
        )

        s = univ.Set(
            componentType=namedtype.NamedTypes(
                namedtype.NamedType('name', univ.OctetString()),
                namedtype.NamedType('customer', c)
            )
        )

        s.setComponentByName('name', 'A')
        s.getComponentByName('customer').setComponentByName('premium', True)

        assert encoder.encode(s) == ints2octs((49, 128, 1, 1, 255, 4, 1, 65, 0, 0))

    def testWithTaggedChoice(self):

        c = univ.Choice(
            componentType=namedtype.NamedTypes(
                namedtype.NamedType('premium', univ.Boolean())
            )
        ).subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 7))

        s = univ.Set(
            componentType=namedtype.NamedTypes(
                namedtype.NamedType('name', univ.OctetString()),
                namedtype.NamedType('customer', c)
            )
        )

        s.setComponentByName('name', 'A')
        s.getComponentByName('customer').setComponentByName('premium', True)

        assert encoder.encode(s) == ints2octs((49, 128, 4, 1, 65, 167, 128, 1, 1, 255, 0, 0, 0, 0))

 def testTrue(self):
     assert encoder.encode(univ.Boolean(1)) == ints2octs((1, 1, 255))

 def testEmpty(self):
     self.s.clear()
     assert encoder.encode(self.s) == ints2octs((49, 128, 0, 0))

    def testIndefMode4(self):
        self.s.clear()
        self.s.append('a')
        self.s.append('b')

        assert encoder.encode(self.s) == ints2octs((49, 128, 4, 1, 97, 4, 1, 98, 0, 0))

 def testWithDefaultedIndefMode(self):
     assert encoder.encode(
         self.s
     ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))

 def testIndefMode(self):
     self.__init()
     assert encoder.encode(self.s) == ints2octs((49, 128, 5, 0, 0, 0))

 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 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))

 def testOptional(self):
     s = self.__initOptional()
     assert encoder.encode(s) == ints2octs((48, 128, 0, 0))

 def testOptionalWithValue(self):
     s = self.__initOptionalWithValue()
     assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 4, 4, 116, 101, 115, 116, 0, 0, 0, 0))

 def testOptionalWithDefault(self):
     s = self.__initOptionalWithDefault()
     assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 2, 1, 123, 0, 0, 0, 0))

 def testOptionalWithDefaultAndOptional(self):
     s = self.__initOptionalWithDefaultAndOptional()
     assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 4, 4, 116, 101, 115, 116, 2, 1, 123, 0, 0, 0, 0))

 def testDefaultWithDefault(self):
     s = self.__initDefaultWithDefault()
     assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 4, 4, 116, 101, 115, 116, 0, 0, 0, 0))

 def testWithOptionalIndefMode(self):
     self.__initWithOptional()
     assert encoder.encode(
         self.s
     ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))