def testCount(self):
     self.s1.clear()
     for x in ['abc', 'def', 'abc']:
         self.s1.append(x)
     assert self.s1.count(str2octs('abc')) == 2
     assert self.s1.count(str2octs('def')) == 1
     assert self.s1.count(str2octs('ghi')) == 0

 def testSort(self):
     self.s1.clear()
     self.s1[0] = 'b'
     self.s1[1] = 'a'
     assert list(self.s1) == [str2octs('b'), str2octs('a')]
     self.s1.sort()
     assert list(self.s1) == [str2octs('a'), str2octs('b')]

 def testIndex(self):
     self.s1.clear()
     for x in ['abc', 'def', 'abc']:
         self.s1.append(x)
     assert self.s1.index(str2octs('abc')) == 0
     assert self.s1.index(str2octs('def')) == 1
     assert self.s1.index(str2octs('abc'), 1) == 2

 def testUpdate(self):
     self.s1.clear()
     assert list(self.s1.values()) == [str2octs(''), str2octs(''), 34]
     self.s1.update(**{'name': 'abc', 'nick': 'def', 'age': 123})
     assert list(self.s1.items()) == [(x[0], str2octs(x[1])) for x in [('name', 'abc'), ('nick', 'def')]] + [('age', 123)]
     self.s1.update(('name', 'ABC'))
     assert list(self.s1.items()) == [(x[0], str2octs(x[1])) for x in [('name', 'ABC'), ('nick', 'def')]] + [('age', 123)]
     self.s1.update(name='CBA')
     assert list(self.s1.items()) == [(x[0], str2octs(x[1])) for x in [('name', 'CBA'), ('nick', 'def')]] + [('age', 123)]

 def testExtend(self):
     self.s1.clear()
     self.s1.setComponentByPosition(0, univ.OctetString('abc'))
     assert len(self.s1) == 1
     self.s1.extend(['def', 'ghi'])
     assert len(self.s1) == 3
     assert list(self.s1) == [str2octs(x) for x in ['abc', 'def', 'ghi']]

 def testOuterByTypeWithInstanceValue(self):
     self.s1.setComponentByType(
         univ.OctetString.tagSet, univ.OctetString('abc')
     )
     assert self.s1.getComponentByType(
         univ.OctetString.tagSet
     ) == str2octs('abc')

def searchRecordByOid(oid, fileObj, textParser, eol=str2octs('\n')):
    lo = mid = 0; prev_mid = -1
    fileObj.seek(0, 2)
    hi = sz = fileObj.tell()
    while lo < hi:
        mid = (lo+hi)//2
        fileObj.seek(mid)
        while mid:
            c = fileObj.read(1)
            if c == eol:
                mid = mid + 1
                break
            mid = mid - 1    # pivot stepping back in search for full line
            fileObj.seek(mid)
        if mid == prev_mid:  # loop condition due to stepping back pivot
            break
        if mid >= sz:
            return sz
        line, _, skippedOffset = getRecord(fileObj)
        if not line:
            return hi
        midval, _ = textParser.evaluate(line, oidOnly=True)
        if midval < oid:
            lo = mid + skippedOffset + len(line)
        elif midval > oid:
            hi = mid
        else:
            return mid
        prev_mid = mid
    if lo == mid:
        return lo
    else:
        return hi

 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, str2octs(''))
     ) == (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)), str2octs(''))

 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 __searchOid(self, oid, eol=str2octs('\n')):
     lo = mid = 0; prev_mid = -1;
     self.__text.seek(0, 2)
     hi = sz = self.__text.tell()
     while lo < hi:
         mid = (lo+hi)//2
         self.__text.seek(mid)
         while mid:
             c = self.__text.read(1)
             if c == eol:
                 mid = mid + 1
                 break
             mid = mid - 1    # pivot stepping back in search for full line
             self.__text.seek(mid)
         if mid == prev_mid:  # loop condition due to stepping back pivot
             break
         if mid >= sz:
             return sz
         line = self.__text.readline()
         midval, _ = self.__textParser.evaluate(line, oidOnly=True)
         if midval < oid:
             lo = mid + len(line)
         elif midval > oid:
             hi = mid
         else:
             return mid
         prev_mid = mid
     if lo == mid:
         return lo
     else:
         return hi

 def testAppend(self):
     self.s1.clear()
     self.s1.setComponentByPosition(0, univ.OctetString('abc'))
     assert len(self.s1) == 1
     self.s1.append('def')
     assert len(self.s1) == 2
     assert list(self.s1) == [str2octs(x) for x in ['abc', 'def']]

 def testWithoutSchema(self):
     s = univ.SequenceOf().subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 3))
     s2, r = decoder.decode(
         ints2octs((163, 15, 48, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
     )
     assert not r
     assert s2 == [str2octs('quick brown')]
     assert s.tagSet == s2.tagSet

    def testTypeCheckOnAssignment(self):

        self.s.clear()

        self.s['blob'] = univ.Any(str2octs('xxx'))

        # this should succeed because Any is untagged and unconstrained
        self.s['blob'] = univ.Integer(123)

    def testStaticDef(self):

        class SequenceOf(univ.SequenceOf):
            componentType = univ.OctetString('')

        s = SequenceOf()
        s[0] = 'abc'
        assert len(s) == 1
        assert s == [str2octs('abc')]

def getRecord(fileObj, lineNo=None, offset=0):
    line = fileObj.readline()
    if lineNo is not None and line: lineNo += 1
    while line:
        tline = line.strip()
        # skip comment or blank line
        if not tline or tline.startswith(str2octs('#')):
            offset += len(line)
            line = fileObj.readline()
            if lineNo is not None and line: lineNo += 1
        else:
            break
    return line, lineNo, offset

 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 lookup(self, oid):
        """ Returns the record which oid is exactly the given one or None if the record doesn't exist """

        # Issue #4: Synchronizes access to the database
        self.__lock.acquire(True);
        try:
            oid, is_subtree, tag, val = self.__db[oid].split(str2octs(','), 3)
        finally:
            self.__lock.release();

        try:
            tag_class = self.str2class(tag);
        except Exception:
            logger.error ( 'Could not interpret tag %s', tag, exc_info=True );
            raise
        return univ.ObjectIdentifier(oid), is_subtree, tag_class, tag_class(val)

 def encodeValue(self, encodeFun, value, defMode, maxChunkSize):
     if value.isPlusInfinity():
         return int2oct(0x40), 0
     if value.isMinusInfinity():
         return int2oct(0x41), 0
     m, b, e = value
     if not m:
         return null, 0
     if b == 10:
         return str2octs('\x03%dE%s%d' % (m, e == 0 and '+' or '', e)), 0
     elif b == 2:
         fo = 0x80                 # binary enoding
         if m < 0:
             fo = fo | 0x40  # sign bit
             m = -m
         while int(m) != m: # drop floating point
             m *= 2
             e -= 1
         while m & 0x1 == 0: # mantissa normalization
             m >>= 1
             e += 1
         eo = null
         while e not in (0, -1):
             eo = int2oct(e&0xff) + eo
             e >>= 8
         if e == 0 and eo and oct2int(eo[0]) & 0x80:
             eo = int2oct(0) + eo
         n = len(eo)
         if n > 0xff:
             raise error.PyAsn1Error('Real exponent overflow')
         if n == 1:
             pass
         elif n == 2:
             fo |= 1
         elif n == 3:
             fo |= 2
         else:
             fo |= 3
             eo = int2oct(n//0xff+1) + eo
         po = null
         while m:
             po = int2oct(m&0xff) + po
             m >>= 8
         substrate = int2oct(fo) + eo + po
         return substrate, 0
     else:
         raise error.PyAsn1Error('Prohibited Real base %s' % b)

 def testComponentConstraintsMatching(self):
     s = self.s1.clone()
     o = univ.OctetString().subtype(
         subtypeSpec=constraint.ConstraintsUnion(constraint.SingleValueConstraint(str2octs('cba'))))
     s.strictConstraints = True
     try:
         s.setComponentByName('name', o.clone('cba'))
     except PyAsn1Error:
         pass
     else:
         assert 0, 'inner supertype constraint allowed'
     s.strictConstraints = False
     try:
         s.setComponentByName('name', o.clone('cba'))
     except PyAsn1Error:
         assert 0, 'inner supertype constraint disallowed'
     else:
         pass

 def testSubtypeSpec(self):
     s = self.s1.clone(subtypeSpec=constraint.ConstraintsUnion(
         constraint.SingleValueConstraint(str2octs('abc'))
     ))
     try:
         s.setComponentByPosition(0, univ.OctetString('abc'))
     except PyAsn1Error:
         assert 0, 'constraint fails'
     try:
         s.setComponentByPosition(1, univ.OctetString('Abc'))
     except PyAsn1Error:
         try:
             s.setComponentByPosition(1, univ.OctetString('Abc'),
                                      verifyConstraints=False)
         except PyAsn1Error:
             assert 0, 'constraint failes with verifyConstraints=True'
     else:
         assert 0, 'constraint fails'