"""

  import os

  from lib389.topologies import topology_m1 as topo

  from lib389.idm.organizationalunit import OrganizationalUnits

  from lib389.idm.domain import Domain

  from lib389.backend import Backends

  from lib389.config import Config

  from lib389._constants import DEFAULT_SUFFIX

  from lib389.idm.group import Groups, Group, UniqueGroup, nsAdminGroups, nsAdminGroup

  pytestmark = pytest.mark.tier1

      """

      Will create entries with nsAdminGroup objectclass

      """

      user = nsAdminGroups(topo.ms["master1"], suffix, rdn=None).create(properties={

          'cn': user_id,

          'sn': user_id,

          'loginShell': '/bin/bash',

          'uidNumber': uid_no,

          'gidNumber': gid_no,

          'nsAdminGroupName': role_usr,

          'seeAlso': 'uid={},{}'.format(user_id, suffix),

          'entrydn': 'uid={},{}'.format(user_id, suffix)

                   (['+'], 'nsUniqueId', True),

                   (['*'], 'cn', True),

                   (['cn'], 'cn', True)]

  @pytest.mark.parametrize("attrs, attr, present", search_params)

  def test_search_req_attrs(topology_st, add_test_entry, attrs, attr, present):

      """Test requested attributes in search operations.

      return inst

                      reason="This test is only required with new admin cli, and requires root.")

  @pytest.mark.bz1748016

  @pytest.mark.ds50581

      cachesize = '33333333'

      cachenensize_val = userroot_ldbm.get_attr_val('nsslapd-cachememsize')

      dncachenensize_val = userroot_ldbm.get_attr_val('nsslapd-dncachememsize')

      log.info("Check nsslapd-dbcachesize and nsslapd-cachememsize before the test")

      log.info("nsslapd-dbcachesize == {}".format(dbcachesize_val))

          config_ldbm.set('nsslapd-dbcachesize ', cachesize)

      topo.standalone.restart()

      cachenensize_val = userroot_ldbm.get_attr_val('nsslapd-cachememsize')

      dncachenensize_val = userroot_ldbm.get_attr_val('nsslapd-dncachememsize')

      log.info("Check nsslapd-dbcachesize and nsslapd-cachememsize in the appropriate range.")

      log.info("nsslapd-dbcachesize == {}".format(dbcachesize_val))

      # Test with caches with both real values and 0

      for cachesize in ('0', '33333333'):

          cachenensize_val = userroot_ldbm.get_attr_val('nsslapd-cachememsize')

          dncachenensize_val = userroot_ldbm.get_attr_val('nsslapd-dncachememsize')

          log.info("Check nsslapd-dbcachesize and nsslapd-cachememsize before the test")

          log.info("nsslapd-dbcachesize == {}".format(dbcachesize_val))

          userroot_ldbm.set('nsslapd-cachememsize', cachesize)

          topo.standalone.restart()

          cachenensize_val = userroot_ldbm.get_attr_val('nsslapd-cachememsize')

          dncachenensize_val = userroot_ldbm.get_attr_val('nsslapd-dncachememsize')

          log.info("Check nsslapd-dbcachesize and nsslapd-cachememsize in the appropriate range.")

          log.info("nsslapd-dbcachesize == {}".format(dbcachesize_val))

      config_ldbm = DSLdapObject(topo.standalone, DN_CONFIG_LDBM)

      bdb_config_ldbm = DSLdapObject(topo.standalone, DN_CONFIG_LDBM_BDB)

      log.info("Set nsslapd-cache-autosize-split to {}".format(invalid_value))

      with pytest.raises(ldap.UNWILLING_TO_PERFORM):

      ldbmconfig = LDBMConfig(topology_m2.ms["master1"])

      bdbconfig = BDB_LDBMConfig(topology_m2.ms["master1"])

      assert deadlock_policy == default_val

      # Try a range of valid values

      for val in (b'0', b'5', b'9'):

          ldbmconfig.replace('nsslapd-db-deadlock-policy', val)

          assert deadlock_policy == val

      # Try a range of invalid values

      assert topo.ds_access_log.match(r'.*conn=Internal\([0-9]+\) op=[0-9]+\([0-9]+\)\([0-9]+\).*')

  @pytest.mark.bz1358706

  @pytest.mark.ds49232

  def test_access_log_truncated_search_message(topology_st, clean_access_logs):

  @pytest.mark.bz1732053

  @pytest.mark.ds50510

  def test_etime_at_border_of_second(topology_st, clean_access_logs):

  pytestmark = pytest.mark.tier1

  def test_referral_during_tot(topology_m2):

      master1 = topology_m2.ms["master1"]

  import pytest

  from lib389.topologies import topology_st

  from lib389.password_plugins import PBKDF2Plugin

  pytestmark = pytest.mark.tier1

  def test_pbkdf2_upgrade(topology_st):

      """On upgrade pbkdf2 doesn't ship. We need to be able to

      provide this on upgrade to make sure default hashes work.

  from lib389 import Entry

  from lib389.topologies import topology_m1 as topo_master

  from lib389.idm.user import UserAccounts

  from lib389.topologies import topology_st as topo

  from lib389.idm.organizationalunit import OrganizationalUnits

      'CN12pwtest31', 'SN3pwtest231', 'UID1pwtest123', 'MAIL2pwtest12@redhat.com', '2GN1pwtest123', 'People123')

  def _check_unhashed_userpw(inst, user_dn, is_present=False):

      unhashed_pwd_attribute = 'unhashed#user#password'

      changelog_dbdir = os.path.join(os.path.dirname(inst.dbdir), DEFAULT_CHANGELOG_DB)

              log.fatal('Failed to add user (%s): error %s' % (USER_DN, e.message['desc']))

              assert False

      user = "uid=member1,%s" % (PEOPLE_DN)

      inst.modify_s(user, [(ldap.MOD_REPLACE,

                                            'userpassword',

                                            PASSWORD.encode())])

      inst.stop()

      #  Check with nolog that unhashed#user#password is not logged

      inst.modify_s(DN_CONFIG,

  FD_ATTR = "nsslapd-maxdescriptors"

  GLOBAL_LIMIT = resource.getrlimit(resource.RLIMIT_NOFILE)[1]

  CUSTOM_VAL = str(int(SYSTEMD_LIMIT) - 10)

  TOO_HIGH_VAL = str(GLOBAL_LIMIT * 2)

  TOO_HIGH_VAL2 = str(int(SYSTEMD_LIMIT) * 2)

  import shlex

  import operator

  import subprocess

  from socket import getfqdn

  from ldapurl import LDAPUrl

  from contextlib import closing

      if len(ver) > 1:

          for cmp_ver in ver:

              if cmp_ver.startswith(ds_ver[:3]):

      else:

  def ds_is_older(*ver):