log.info('parse the access logs')

      access_log_lines = topology_st.standalone.ds_access_log.readlines()

      assert len(access_log_lines) > 0

  @pytest.mark.bz1273549

      log.info('check access log that microseconds are not present')

      access_log_lines = topology_st.standalone.ds_access_log.readlines()

      assert len(access_log_lines) > 0

  @pytest.mark.bz1358706

           1. Add a test user with an '*' in its attribute value

              i.e. 'cn=test * me'

           2. Add another similar test user without '*' in its attribute value

      :expectedresults:

           1. This should pass

           2. This should pass

          assert False

      try:

          if not entry or len(entry) > 1:

              assert False

      except ldap.LDAPError as e:

          log.fatal('test_filter_escaped: Failed to search for user(%s), error: %s' %

      """

      if os.geteuid() != 0:

          return

      os.system('setenforce 0')

      try:

          shutil.copy('%s/libwhoami-plugin.la' % plugin_dir, tmp_dir)

      except IOError as e:

                   '/libwhoami-plugin.la to the tmp directory, error: '

                   + e.strerror)

  log = logging.getLogger(__name__)

  def _user_get_dn(no):

      uid = '%s%d' % (ESCAPED_RDN_BASE, no)

      dn = 'uid=%s,%s' % (uid, SUFFIX)

      assert master_schema_csn == consumer_schema_csn

      # Check the error log of the supplier does not contain an error

      res = pattern_errorlog(topology_m1c1.ms["master1"].errorlog_file, regex)

      if res is not None:

          assert False

      # Check the error log of the supplier does not contain an error

      # This message may happen during the learning phase

      res = pattern_errorlog(topology_m1c1.ms["master1"].errorlog_file, regex)

      assert master_schema_csn == consumer_schema_csn

      # Check the error log of the supplier does not contain an error

      res = pattern_errorlog(topology_m1c1.ms["master1"].errorlog_file, regex)

      if res is not None:

          assert False

      assert master_schema_csn == consumer_schema_csn

      # Check the error log of the supplier does not contain an error

      res = pattern_errorlog(topology_m1c1.ms["master1"].errorlog_file, regex)

      if res is not None:

          assert False

      # Check the error log of the supplier does not contain an error

      # This message may happen during the learning phase

      res = pattern_errorlog(topology_m1c1.ms["master1"].errorlog_file, regex)

      # Check the error log of the supplier does not contain an error

      # This message may happen during the learning phase

      res = pattern_errorlog(topology_m1c1.ms["master1"].errorlog_file, regex)

      if res is not None:

          assert False

      assert master_schema_csn == consumer_schema_csn

      # Check the error log of the supplier does not contain an error

      res = pattern_errorlog(topology_m1c1.ms["master1"].errorlog_file, regex)

      if res is not None:

          assert False

      # Check the error log of the supplier does not contain an error

      # This message may happen during the learning phase

      res = pattern_errorlog(topology_m1c1.ms["master1"].errorlog_file, regex)

      assert master_schema_csn == consumer_schema_csn

      # Check the error log of the supplier does not contain an error

      res = pattern_errorlog(topology_m1c1.ms["master1"].errorlog_file, regex)

      if res is not None:

          assert False

              if fschema is None:

                  raise Exception("Empty schema file %s" % fn)

          except:

              continue

          log.info("Parsed %s as a schema file - checking" % fn)

          for oid in fschema.listall(occlass):

      try:

          topology_st.standalone.add_s(entry_2)

      except:

          pass

      topology_st.standalone.log.info("\n\n######################### IS SERVER UP? ######################\n")

  import glob

  import tarfile

  import subprocess

  import signal

  import errno

  import pwd

          wrap entries in an Entry class that provides some useful methods"""

          for name in dir(self.__class__.__bases__[0]):

              attr = getattr(self, name)

                  setattr(self, name, wrapper(attr, name))

      def addLDIF(self, input_file, cont=False):

          try:

              self.add_s(ent)

          except ldap.ALREADY_EXISTS:

          try:

              entry = self._test_entry(binddn, ldap.SCOPE_BASE)

          except ldap.NO_SUCH_OBJECT:

              entry = None

          if entry:

              self.suffixes.setdefault(nsuffix, {})[str(consumer)] = dn_agreement

              return dn_agreement

          if (nsuffix in self.agmt) and (consumer in self.agmt[nsuffix]):

              return dn_agreement

          # In a separate function in this scope?

                  })

              self.setupBindDN(*attrs)

          except ldap.ALREADY_EXISTS:

          # setup replica

          # map old style args to new style replica args

          try:

              self.add_s(ent)

          except ldap.ALREADY_EXISTS:

          try:

              entry = self._test_entry(entry_dn, ldap.SCOPE_BASE)

          # we can just raise ALREADY_EXISTS

          try:

              entry = self.conn.getEntry(dn_agreement, ldap.SCOPE_BASE)

              return dn_agreement

          except ldap.NO_SUCH_OBJECT:

              entry = None

          try:

              self.conn.add_s(entry)

          except ldap.ALREADY_EXISTS:

          return dn

      def delete(self):

  import os

  import re

  import sys

  class DSDecorator(object):

                  # for each function from module create decorated one

                  for attr in dir(module):

                      fun = getattr(module, attr)

                          decorated = DSDecorator(fun, ds)

                          setattr(proxy, attr, decorated)

                  setattr(obj, item, proxy)

                       'passwordExpirationTime': '20381010000000Z'}

              self.conn.setupBindDN(repl_manager_dn, repl_manager_pw, attrs)

          except ldap.ALREADY_EXISTS:

                            repl_manager_dn)

      def list(self, suffix=None, replica_dn=None):

          dn_replica = ','.join((RDN_REPLICA, mtent.dn))

          try:

              entry = self.conn.getEntry(dn_replica, ldap.SCOPE_BASE)

              self.conn.suffixes.setdefault(nsuffix, {})

              self.conn.replica.setProperties(replica_dn=dn_replica,

                                              properties=properties)

          if ents and (len(ents) > 0):

              ent = ents[0]

          elif tryrepl:

                            " trying cn=replica", suffix)

              ensuffix = escapeDNValue(normalizeDN(suffix))

              dn = ','.join(("cn=replica", "cn=%s" % ensuffix, DN_MAPPING_TREE))

              for inst in all_replicas:

                  replObj = inst.replicas.get(suffix)

                  if replObj is None:

                                     (inst.serverid, suffix))

                      continue

                  ctime = _getCSNTime(inst, csnstr)

          try:

              conn.delete_s(e)

          except ldap.NO_SUCH_OBJECT:

  def bind_test():