def test_multi_create(self):
        self.conn = wiredtiger.wiredtiger_open('.', 'create')
        self.session = self.conn.open_session(None)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda: wiredtiger.wiredtiger_open('.', 'create'),
            '/WiredTiger database is already being managed by another thread\
 in this process/')

 def test_multi_create(self):
     self.conn = wiredtiger.wiredtiger_open(".", "create")
     self.session = self.conn.open_session(None)
     self.assertRaisesWithMessage(
         wiredtiger.WiredTigerError,
         lambda: wiredtiger.wiredtiger_open(".", "create"),
         "/WiredTiger database is already being managed/",
     )

 def test_exclusive_create(self):
     self.conn = wiredtiger.wiredtiger_open(".", "create,exclusive")
     self.conn.close()
     self.assertRaisesWithMessage(
         wiredtiger.WiredTigerError,
         lambda: wiredtiger.wiredtiger_open(".", "exclusive"),
         "/WiredTiger database already exists/",
     )

    def setUpConnectionOpen(self, dir):
        args = ''
        # add names to args, e.g. args += ',session_max=30'
        for var in self.config_vars:
            value = getattr(self, 's_' + var)
            if value != None:
                if var == 'verbose':
                    value = '[' + str(value) + ']'
                if value == True:
                    value = 'true'
                if value == False:
                    value = 'false'
                args += ',' + var + '=' + str(value)
        args += ','
        self.pr('wiredtiger_open with args: ' + args)

        expect_fail = False
        successargs = args
        if self.s_create == False:
            successargs = successargs.replace(',create=false,',',create,')
            expect_fail = True
            fail_msg = '/(No such file or directory|The system cannot find the file specified)/'
        elif self.s_create == None:
            successargs = successargs + 'create=true,'
            expect_fail = True
            fail_msg = '/(No such file or directory|The system cannot find the file specified)/'

        if self.s_eviction_target >= self.s_eviction_trigger:
            # construct args that guarantee that target < trigger
            # we know that trigger >= 1
            repfrom = ',eviction_target=' + str(self.s_eviction_target)
            repto = ',eviction_target=' + str(self.s_eviction_trigger - 1)
            successargs = successargs.replace(repfrom, repto)
            if not expect_fail:
                expect_fail = True
                fail_msg = \
                    '/eviction target must be lower than the eviction trigger/'

        if expect_fail:
            self.verbose(3, 'wiredtiger_open (should fail) with args: ' + args)
            self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda: wiredtiger.wiredtiger_open(dir, args), fail_msg)
            args = successargs

        self.verbose(3, 'wiredtiger_open with args: ' + args)
        conn = wiredtiger.wiredtiger_open(dir, args)
        self.pr(`conn`)
        return conn

 def setUpConnectionOpen(self, dir):
     self.home = dir
     # Cycle through the different transaction_sync values in a
     # deterministic manner.
     self.txn_sync = self.sync_list[
         self.scenario_number % len(self.sync_list)]
     #
     # We don't want to run zero fill with only the same settings, such
     # as archive or sync, which are an even number of options.
     #
     freq = 3
     zerofill = 'false'
     if self.scenario_number % freq == 0:
         zerofill = 'true'
     self.backup_dir = os.path.join(self.home, "WT_BACKUP")
     conn_params = \
             'log=(archive=false,enabled,file_max=%s),' % self.logmax + \
             'log=(zero_fill=%s),' % zerofill + \
             'create,error_prefix="%s: ",' % self.shortid() + \
             'transaction_sync="%s",' % self.txn_sync
     # print "Creating conn at '%s' with config '%s'" % (dir, conn_params)
     conn = wiredtiger_open(dir, conn_params)
     self.pr(`conn`)
     self.session2 = conn.open_session()
     return conn

 def test_too_many_sessions(self):
     self.conn = wiredtiger.wiredtiger_open(".", "create,session_max=1")
     self.assertRaisesWithMessage(
         wiredtiger.WiredTigerError,
         lambda: [self.conn.open_session(None) for i in range(100)],
         "/configured to support/",
     )

 def test_stat_cursor_conn_error(self):
     args = ['none', 'all', 'fast']
     for i in list(itertools.permutations(args, 2)):
         config = 'create,statistics=(' + i[0] + ',' + i[1] + ')'
         msg = '/only one statistics configuration value/'
         self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
             lambda: wiredtiger.wiredtiger_open('.', config), msg)

 def setUpConnectionOpen(self, dir):
     self.home = dir
     conn_params = 'create,cache_size=10MB,' \
                   'hazard_max=' + str(self.ntables / 2)
     conn = wiredtiger.wiredtiger_open(dir, conn_params)
     self.pr(`conn`)
     return conn

 def setUpConnectionOpen(self, dir):
     wtopen_args = 'create'
     if hasattr(self, 'cache_size'):
         wtopen_args += ',cache_size=' + str(self.cache_size)
     conn = wiredtiger.wiredtiger_open(dir, wtopen_args)
     self.pr(`conn`)
     return conn

 def setUpConnectionOpen(self, dir):
     conn = wiredtiger.wiredtiger_open(dir, 'create,' +
             ('error_prefix="%s: ",' % self.shortid()) +
             'transactional,')
     self.pr(`conn`)
     self.session2 = conn.open_session()
     return conn

 def test_stats_log_on_close_and_log(self):
     self.conn = wiredtiger.wiredtiger_open(None,
         "create,statistics=(fast),statistics_log=(on_close=true,wait=1)")
     # Wait for the default interval, to ensure stats have been written.
     time.sleep(2)
     self.close_conn()
     self.check_stats_file("WiredTigerStat")

    def __init__(self, path, logging=False):
        # init wiredtiger
        config = 'create,log=(enabled=true)' if logging else 'create'
        self._wiredtiger = wiredtiger_open(path, config)
        session = self._wiredtiger.open_session()

        # sequence table of uids
        session.create('table:uids', 'key_format=r,value_format=u')
        self._uids = session.open_cursor('table:uids', None, 'append')

        # tuples
        session.create('table:tuples', 'key_format=QS,value_format=S,columns=(uid,key,value)')
        self._tuples = session.open_cursor('table:tuples')

        # reversed index for (key, value) querying
        session.create('index:tuples:index', 'columns=(key,value)')
        self._reversed = session.open_cursor('index:tuples:index(uid)')

        # fuzzy search
        config = 'key_format=r,value_format=SQS,columns=(x,trigram,uid,string)'
        session.create('table:trigrams', config)
        self._trigrams = session.open_cursor('table:trigrams', None, 'append')
        session.create('index:trigrams:index', 'columns=(trigram)')
        self._trigrams_index = session.open_cursor('index:trigrams:index(uid,string)')

        self._session = session

 def test_home_not_writeable(self):
     dir = 'subdir'
     os.mkdir(dir)
     os.chmod(dir, 0555)
     self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
         lambda: wiredtiger.wiredtiger_open(dir, 'create'),
         '/Permission denied/')

 def setUpConnectionOpen(self, dir):
     wtopen_args = "create"
     if hasattr(self, "cache_size"):
         wtopen_args += ",cache_size=" + str(self.cache_size)
     conn = wiredtiger.wiredtiger_open(dir, wtopen_args)
     self.pr(` conn `)
     return conn

 def test_home_does_not_exist(self):
     dir = "nondir"
     self.assertRaisesWithMessage(
         wiredtiger.WiredTigerError,
         lambda: wiredtiger.wiredtiger_open(dir, "create"),
         "wiredtiger_open: WiredTiger: No such file or directory\n",
     )

 def setUpConnectionOpen(self, dir):
     wtopen_args = \
         'create,cache_size=1G,log=(archive=false,enabled,file_max=%s)' % \
         self.logmax
     conn = wiredtiger.wiredtiger_open(dir, wtopen_args)
     self.pr(`conn`)
     return conn

 def setUpConnectionOpen(self, dir):
     extarg = self.extensionArg([('extractors', 'csv', 'csv_extractor')])
     connarg = 'create,error_prefix="{0}: ",{1}'.format(
         self.shortid(), extarg)
     conn = wiredtiger.wiredtiger_open(dir, connarg)
     self.pr(`conn`)
     return conn

 def setUpConnectionOpen(self, dir):
     self.home = dir
     # Disable checkpoint sync, to make checkpoints faster and
     # increase the likelyhood of triggering the symptom
     conn_params = ',create,checkpoint_sync=false'
     conn = wiredtiger.wiredtiger_open(dir, conn_params)
     return conn

    def test_baseconfig(self):
        # Open up another database and modify the baseconfig
        os.mkdir("A")
        conn = wiredtiger.wiredtiger_open("A", 'create')
        self.assertTrue(os.path.exists("A/WiredTiger.basecfg"))
        with open("A/WiredTiger.basecfg", "a") as basecfg_file:
            basecfg_file.write("foo!")
        conn.close()

        # Open a database, we should assert here as the basecfg is invalid
        self.assertRaisesWithMessage(
            wiredtiger.WiredTigerError,
            lambda: wiredtiger.wiredtiger_open("A", ''),
            '/unknown configuration key/')

        conn = wiredtiger.wiredtiger_open("A", "create,config_base=false")
        conn.close()

 def test_stat_cursor_conn_error(self):
     args = ["none", "all", "fast"]
     for i in list(itertools.permutations(args, 2)):
         config = "create,statistics=(" + i[0] + "," + i[1] + ")"
         msg = "/only one statistics configuration value/"
         self.assertRaisesWithMessage(
             wiredtiger.WiredTigerError, lambda: wiredtiger.wiredtiger_open(".", config), msg
         )