# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.

import wiredtiger, wttest
from wtscenario import make_scenarios

# test_prepare03.py
#    Prepare: Cursor API usage generates expected error in prepared state.


            

Reported by Pylint.

                          cursor.set_value(self.genvalue(i))
            self.session.prepare_transaction("prepare_timestamp=2a")
            self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda:cursor.insert(), preparemsg)
            self.session.timestamp_transaction("commit_timestamp=2b")
            self.session.timestamp_transaction("durable_timestamp=2b")
            self.session.commit_transaction()
            cursor.insert()


            

Reported by Pylint.

                          self.session.begin_transaction()
            self.session.prepare_transaction("prepare_timestamp=2a")
            self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda:cursor.next(), preparemsg)
            self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda:cursor.get_key(), preparemsg)
            self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda:cursor.get_value(), preparemsg)
            self.session.timestamp_transaction("commit_timestamp=2b")

            

Reported by Pylint.

                          self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda:cursor.next(), preparemsg)
            self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda:cursor.get_key(), preparemsg)
            self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda:cursor.get_value(), preparemsg)
            self.session.timestamp_transaction("commit_timestamp=2b")
            self.session.timestamp_transaction("durable_timestamp=2b")
            self.session.commit_transaction()

            

Reported by Pylint.

                          self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda:cursor.get_key(), preparemsg)
            self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda:cursor.get_value(), preparemsg)
            self.session.timestamp_transaction("commit_timestamp=2b")
            self.session.timestamp_transaction("durable_timestamp=2b")
            self.session.commit_transaction()
            nextret = cursor.next()
            if nextret != 0:

            

Reported by Pylint.

                          self.session.begin_transaction()
            self.session.prepare_transaction("prepare_timestamp=2a")
            self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
                lambda:cursor.prev(), preparemsg)
            self.session.timestamp_transaction("commit_timestamp=2b")
            self.session.timestamp_transaction("durable_timestamp=2b")
            self.session.commit_transaction()
            prevret = cursor.prev()
            if prevret != 0:

            

Reported by Pylint.

                      self.session.begin_transaction()
        self.session.prepare_transaction("prepare_timestamp=2a")
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.search(), preparemsg)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.update(), preparemsg)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.remove(), preparemsg)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,

            

Reported by Pylint.

                      self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.search(), preparemsg)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.update(), preparemsg)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.remove(), preparemsg)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.reserve(), preparemsg)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,

            

Reported by Pylint.

                      self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.update(), preparemsg)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.remove(), preparemsg)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.reserve(), preparemsg)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.reconfigure(), preparemsg)
        self.session.timestamp_transaction("commit_timestamp=2b")

            

Reported by Pylint.

                      self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.remove(), preparemsg)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.reserve(), preparemsg)
        self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
            lambda:cursor.reconfigure(), preparemsg)
        self.session.timestamp_transaction("commit_timestamp=2b")
        self.session.timestamp_transaction("durable_timestamp=2b")
        self.session.commit_transaction()

            

Reported by Pylint.

              }

typedef struct {
    char keyword[ULOC_KEYWORD_BUFFER_LEN];
    int32_t keywordLen;
    const char *valueStart;
    int32_t valueLen;
} KeywordStruct;


            

Reported by FlawFinder.

              { 
    const char* startSearchHere = NULL;
    const char* nextSeparator = NULL;
    char keywordNameBuffer[ULOC_KEYWORD_BUFFER_LEN];
    char localeKeywordNameBuffer[ULOC_KEYWORD_BUFFER_LEN];
    int32_t i = 0;
    int32_t result = 0;

    if(status && U_SUCCESS(*status) && localeID) {

            

Reported by FlawFinder.

                  const char* startSearchHere = NULL;
    const char* nextSeparator = NULL;
    char keywordNameBuffer[ULOC_KEYWORD_BUFFER_LEN];
    char localeKeywordNameBuffer[ULOC_KEYWORD_BUFFER_LEN];
    int32_t i = 0;
    int32_t result = 0;

    if(status && U_SUCCESS(*status) && localeID) {
      char tempBuffer[ULOC_FULLNAME_CAPACITY];

            

Reported by FlawFinder.

                  int32_t result = 0;

    if(status && U_SUCCESS(*status) && localeID) {
      char tempBuffer[ULOC_FULLNAME_CAPACITY];
      const char* tmpLocaleID;

      if (_hasBCP47Extension(localeID)) {
          _ConvertBCP47(tmpLocaleID, localeID, tempBuffer, sizeof(tempBuffer), status);
      } else {

            

Reported by FlawFinder.

                  int32_t needLen = 0;
    int32_t foundValueLen;
    int32_t keywordAtEnd = 0; /* is the keyword at the end of the string? */
    char keywordNameBuffer[ULOC_KEYWORD_BUFFER_LEN];
    char localeKeywordNameBuffer[ULOC_KEYWORD_BUFFER_LEN];
    int32_t i = 0;
    int32_t rc;
    char* nextSeparator = NULL;
    char* nextEqualsign = NULL;

            

Reported by FlawFinder.

                  int32_t foundValueLen;
    int32_t keywordAtEnd = 0; /* is the keyword at the end of the string? */
    char keywordNameBuffer[ULOC_KEYWORD_BUFFER_LEN];
    char localeKeywordNameBuffer[ULOC_KEYWORD_BUFFER_LEN];
    int32_t i = 0;
    int32_t rc;
    char* nextSeparator = NULL;
    char* nextEqualsign = NULL;
    char* startSearchHere = NULL;

            

Reported by FlawFinder.

                                  const char **pEnd) {
    int32_t i=0;
    int32_t offset;
    char lang[4]={ 0, 0, 0, 0 }; /* temporary buffer to hold language code for searching */

    /* if it starts with i- or x- then copy that prefix */
    if(_isIDPrefix(localeID)) {
        if(i<languageCapacity) {
            language[i]=(char)uprv_tolower(*localeID);

            

Reported by FlawFinder.

                                 const char **pEnd)
{
    int32_t idLen=0;
    char cnty[ULOC_COUNTRY_CAPACITY]={ 0, 0, 0, 0 };
    int32_t offset;

    /* copy the country as far as possible and count its length */
    while(!_isTerminator(localeID[idLen]) && !_isIDSeparator(localeID[idLen])) {
        if(idLen<(ULOC_COUNTRY_CAPACITY-1)) {   /*CWB*/

            

Reported by FlawFinder.

                                      UErrorCode* status) 
{
    int32_t i=0;
    char keywords[256];
    int32_t keywordsCapacity = 256;
    char tempBuffer[ULOC_FULLNAME_CAPACITY];
    const char* tmpLocaleID;

    if(status==NULL || U_FAILURE(*status)) {

            

Reported by FlawFinder.

                  int32_t i=0;
    char keywords[256];
    int32_t keywordsCapacity = 256;
    char tempBuffer[ULOC_FULLNAME_CAPACITY];
    const char* tmpLocaleID;

    if(status==NULL || U_FAILURE(*status)) {
        return 0;
    }

            

Reported by FlawFinder.

              # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.

import wiredtiger, wttest

# test_index01.py
#    basic tests for indices
class test_index01(wttest.WiredTigerTestCase):
    '''Test basic operations for indices'''

            

Reported by Pylint.

                  NUM_INDICES = 6

    def create_table(self):
        self.index = ['%s:index%d' % (self.indexbase, i) \
            for i in range(self.NUM_INDICES)]
        self.pr('create table')
        self.session.create(self.tablename, 'key_format=Si,value_format=SSii,columns=(name,ID,dept,job,salary,year)')
        self.session.create(self.index[0], 'columns=(dept)')
        self.session.create(self.index[1], 'columns=(name,year)')

            

Reported by Pylint.

                      cursor = self.cursor(config='overwrite=false')
        cursor.set_key(*cols[:2])
        cursor.set_value(*cols[2:])
        self.assertRaises(wiredtiger.WiredTigerError, lambda: cursor.insert())
        cursor.close()

    def insert_overwrite(self, *cols):
        self.pr('insert')
        cursor = self.cursor(config='overwrite=true')

            

Reported by Pylint.

              #!/usr/bin/env python
#
# Public Domain 2014-present MongoDB, Inc.
# Public Domain 2008-2014 WiredTiger, Inc.
#
# This is free and unencumbered software released into the public domain.
#
# Anyone is free to copy, modify, publish, use, compile, sell, or
# distribute this software, either in source code form or as a compiled

            

Reported by Pylint.

              # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.

import wiredtiger, wttest

# test_index01.py
#    basic tests for indices
class test_index01(wttest.WiredTigerTestCase):
    '''Test basic operations for indices'''

            

Reported by Pylint.

              
# test_index01.py
#    basic tests for indices
class test_index01(wttest.WiredTigerTestCase):
    '''Test basic operations for indices'''

    basename = 'test_index01'
    tablename = 'table:' + basename
    indexbase = 'index:' + basename

            

Reported by Pylint.

                  indexbase = 'index:' + basename
    NUM_INDICES = 6

    def create_table(self):
        self.index = ['%s:index%d' % (self.indexbase, i) \
            for i in range(self.NUM_INDICES)]
        self.pr('create table')
        self.session.create(self.tablename, 'key_format=Si,value_format=SSii,columns=(name,ID,dept,job,salary,year)')
        self.session.create(self.index[0], 'columns=(dept)')

            

Reported by Pylint.

                      self.index = ['%s:index%d' % (self.indexbase, i) \
            for i in range(self.NUM_INDICES)]
        self.pr('create table')
        self.session.create(self.tablename, 'key_format=Si,value_format=SSii,columns=(name,ID,dept,job,salary,year)')
        self.session.create(self.index[0], 'columns=(dept)')
        self.session.create(self.index[1], 'columns=(name,year)')
        self.session.create(self.index[2], 'columns=(salary)')
        self.session.create(self.index[3], 'columns=(dept,job,name)')
        self.session.create(self.index[4], 'columns=(name,ID)')

            

Reported by Pylint.

                      self.session.create(self.index[4], 'columns=(name,ID)')
        self.session.create(self.index[5], 'columns=(ID,name)')

    def drop_table(self):
        self.pr('drop table')
        self.session.drop(self.tablename, None)

    def cursor(self, config=None):
        self.pr('open cursor')

            

Reported by Pylint.

                      self.pr('drop table')
        self.session.drop(self.tablename, None)

    def cursor(self, config=None):
        self.pr('open cursor')
        c = self.session.open_cursor(self.tablename, None, config)
        self.assertNotEqual(c, None)
        return c


            

Reported by Pylint.

              # OTHER DEALINGS IN THE SOFTWARE.

import os
import wiredtiger, wttest, run

# test_join04.py
#    Join operations
# Joins with a custom extractor, using equality joins
class test_join04(wttest.WiredTigerTestCase):

            

Reported by Pylint.

              # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.

import os
import wiredtiger, wttest, run

# test_join04.py
#    Join operations
# Joins with a custom extractor, using equality joins

            

Reported by Pylint.

              # OTHER DEALINGS IN THE SOFTWARE.

import os
import wiredtiger, wttest, run

# test_join04.py
#    Join operations
# Joins with a custom extractor, using equality joins
class test_join04(wttest.WiredTigerTestCase):

            

Reported by Pylint.

              # OTHER DEALINGS IN THE SOFTWARE.

import os
import wiredtiger, wttest, run

# test_join04.py
#    Join operations
# Joins with a custom extractor, using equality joins
class test_join04(wttest.WiredTigerTestCase):

            

Reported by Pylint.

              #!/usr/bin/env python
#
# Public Domain 2014-present MongoDB, Inc.
# Public Domain 2008-2014 WiredTiger, Inc.
#
# This is free and unencumbered software released into the public domain.
#
# Anyone is free to copy, modify, publish, use, compile, sell, or
# distribute this software, either in source code form or as a compiled

            

Reported by Pylint.

              # OTHER DEALINGS IN THE SOFTWARE.

import os
import wiredtiger, wttest, run

# test_join04.py
#    Join operations
# Joins with a custom extractor, using equality joins
class test_join04(wttest.WiredTigerTestCase):

            

Reported by Pylint.

              # test_join04.py
#    Join operations
# Joins with a custom extractor, using equality joins
class test_join04(wttest.WiredTigerTestCase):
    table_name1 = 'test_join04'
    nentries = 100

    def conn_extensions(self, extlist):
        extlist.skip_if_missing = True

            

Reported by Pylint.

              # test_join04.py
#    Join operations
# Joins with a custom extractor, using equality joins
class test_join04(wttest.WiredTigerTestCase):
    table_name1 = 'test_join04'
    nentries = 100

    def conn_extensions(self, extlist):
        extlist.skip_if_missing = True

            

Reported by Pylint.

                  table_name1 = 'test_join04'
    nentries = 100

    def conn_extensions(self, extlist):
        extlist.skip_if_missing = True
        extlist.extension('extractors', 'csv')

    # JIRA WT-2308:
    # Test extractors with equality joins

            

Reported by Pylint.

                  table_name1 = 'test_join04'
    nentries = 100

    def conn_extensions(self, extlist):
        extlist.skip_if_missing = True
        extlist.extension('extractors', 'csv')

    # JIRA WT-2308:
    # Test extractors with equality joins

            

Reported by Pylint.

              """

from __future__ import print_function
import re
import sys

import os
sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)))
import opcode

            

Reported by Pylint.

                  flags = map(lambda x: x.replace('JOF_', ''), flags)
    return ' ({flags})'.format(flags=', '.join(flags))

def print_opcode(opcode):
    names_template = '{name} [-{nuses}, +{ndefs}]{flags}'
    opcodes = sorted([opcode] + opcode.group,
                     key=lambda opcode: opcode.name)
    names = map(lambda code: names_template.format(name=escape(code.name),
                                                   nuses=override(code.nuses,

            

Reported by Pylint.

              id_cache = dict()
id_count = dict()

def make_element_id(category, type=''):
    key = '{}:{}'.format(category, type)
    if key in id_cache:
        return id_cache[key]

    if type == '':

            

Reported by Pylint.

                      return id_cache[key]

    if type == '':
        id = category.replace(' ', '_')
    else:
        id = type.replace(' ', '_')

    if id in id_count:
        id_count[id] += 1

            

Reported by Pylint.

                  id_cache[key] = id
    return id

def print_doc(index):
    print("""<div>{{{{SpiderMonkeySidebar("Internals")}}}}</div>

<h2 id="Bytecode_Listing">Bytecode Listing</h2>

<p>This document is automatically generated from

            

Reported by Pylint.

                              print('<h4 id="{id}">{name}</h4>'.format(name=type_name,
                                                         id=make_element_id(category_name, type_name)))
            print('<dl>')
            for opcode in sorted(opcodes,
                                 key=lambda opcode: opcode.sort_key):
                print_opcode(opcode)
            print('</dl>')

if __name__ == '__main__':

            

Reported by Pylint.

                      print("Usage: make_opcode_doc.py PATH_TO_MOZILLA_CENTRAL",
              file=sys.stderr)
        sys.exit(1)
    dir = sys.argv[1]

    try:
        index, _ = opcode.get_opcodes(dir)
    except Exception as e:
        print("Error: {}".format(e.args[0]), file=sys.stderr)

            

Reported by Pylint.

              
    try:
        index, _ = opcode.get_opcodes(dir)
    except Exception as e:
        print("Error: {}".format(e.args[0]), file=sys.stderr)
        sys.exit(1)

    print_doc(index)

            

Reported by Pylint.

              
import os
sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)))
import opcode

from xml.sax.saxutils import escape

SOURCE_BASE = 'http://dxr.mozilla.org/mozilla-central/source'


            

Reported by Pylint.

              sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)))
import opcode

from xml.sax.saxutils import escape

SOURCE_BASE = 'http://dxr.mozilla.org/mozilla-central/source'

def override(value, override_value):
    if override_value != '':

            

Reported by Bandit.

                  pass

class ExplicitExit(Exception):
    def __init__(self, node=None, status=None, *args):
        self.node = node
        self.status = status
        self.exitstatus = status
        Exception.__init__(self, *args)


            

Reported by Pylint.

              #
# Copyright (c) 2001 - 2019 The SCons Foundation
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to

            

Reported by Pylint.

              
"""

__revision__ = "src/engine/SCons/Errors.py bee7caf9defd6e108fc2998a2520ddb36a967691 2019-12-17 02:07:09 bdeegan"

import shutil
import SCons.Util



            

Reported by Pylint.

              import SCons.Util


class BuildError(Exception):
    """ Errors occurring while building.

    BuildError have the following attributes:
    =========================================


            

Reported by Pylint.

                            is not due to the an action failure)
    """

    def __init__(self,
                 node=None, errstr="Unknown error", status=2, exitstatus=2,
                 filename=None, executor=None, action=None, command=None,
                 exc_info=(None, None, None)):

        # py3: errstr should be string and not bytes.

            

Reported by Pylint.

                                         executor, action, command, exc_info)

    def __str__(self):
        if self.filename:
            return self.filename + ': ' + self.errstr
        else:
            return self.errstr

class InternalError(Exception):

            

Reported by Pylint.

                      else:
            return self.errstr

class InternalError(Exception):
    pass

class UserError(Exception):
    pass


            

Reported by Pylint.

              class InternalError(Exception):
    pass

class UserError(Exception):
    pass

class StopError(Exception):
    pass


            

Reported by Pylint.

              class UserError(Exception):
    pass

class StopError(Exception):
    pass

class SConsEnvironmentError(Exception):
    pass


            

Reported by Pylint.

              class StopError(Exception):
    pass

class SConsEnvironmentError(Exception):
    pass

class MSVCError(IOError):
    pass


            

Reported by Pylint.

              #

import os, run, random
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtscenario import make_scenarios

# Test basic encryption
class test_encrypt02(wttest.WiredTigerTestCase, suite_subprocess):

            

Reported by Pylint.

                  nrecords = 5000
    bigvalue = "abcdefghij" * 1001    # len(bigvalue) = 10010

    def conn_config(self):
        secretarg = ''
        if self.secret_arg != None:
            secretarg = ',secretkey=' + self.secret_arg
        return 'encryption=({0}{1})'.format(self.encrypt_args, secretarg)


            

Reported by Pylint.

              #   Encryption using passwords
#

import os, run, random
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtscenario import make_scenarios

# Test basic encryption

            

Reported by Pylint.

              #   Encryption using passwords
#

import os, run, random
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtscenario import make_scenarios

# Test basic encryption

            

Reported by Pylint.

              #

import os, run, random
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtscenario import make_scenarios

# Test basic encryption
class test_encrypt02(wttest.WiredTigerTestCase, suite_subprocess):

            

Reported by Pylint.

                          val = self.bigvalue[start:r.randint(0,10000)] + str(idx)
            cursor.set_key(key)
            self.assertEqual(cursor.search(), 0)
            self.assertEquals(cursor.get_value(), val)
        cursor.close()

        wtargs = []
        if self.secret_arg != None:
            wtargs += ['-E', self.secret_arg]

            

Reported by Pylint.

              #!/usr/bin/env python
#
# Public Domain 2014-present MongoDB, Inc.
# Public Domain 2008-2014 WiredTiger, Inc.
#
# This is free and unencumbered software released into the public domain.
#
# Anyone is free to copy, modify, publish, use, compile, sell, or
# distribute this software, either in source code form or as a compiled

            

Reported by Pylint.

              #   Encryption using passwords
#

import os, run, random
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtscenario import make_scenarios

# Test basic encryption

            

Reported by Pylint.

              #   Encryption using passwords
#

import os, run, random
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtscenario import make_scenarios

# Test basic encryption

            

Reported by Pylint.

              #

import os, run, random
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtscenario import make_scenarios

# Test basic encryption
class test_encrypt02(wttest.WiredTigerTestCase, suite_subprocess):

            

Reported by Pylint.

              import os
import sys

from testtools import ExtendedToStreamDecorator
from testtools.testsuite import iterate_tests

from subunit import StreamResultToBytes, get_default_formatter
from subunit.test_results import AutoTimingTestResultDecorator
from testtools.run import (

            

Reported by Pylint.

              import sys

from testtools import ExtendedToStreamDecorator
from testtools.testsuite import iterate_tests

from subunit import StreamResultToBytes, get_default_formatter
from subunit.test_results import AutoTimingTestResultDecorator
from testtools.run import (
    BUFFEROUTPUT,

            

Reported by Pylint.

              
from subunit import StreamResultToBytes, get_default_formatter
from subunit.test_results import AutoTimingTestResultDecorator
from testtools.run import (
    BUFFEROUTPUT,
    CATCHBREAK,
    FAILFAST,
    list_test,
    TestProgram,

            

Reported by Pylint.

              import sys

from testtools import ExtendedToStreamDecorator
from testtools.testsuite import iterate_tests

from subunit import StreamResultToBytes, get_default_formatter
from subunit.test_results import AutoTimingTestResultDecorator
from testtools.run import (
    BUFFEROUTPUT,

            

Reported by Pylint.

              

class SubunitTestRunner(object):
    def __init__(self, verbosity=None, failfast=None, buffer=None, stream=None):
        """Create a TestToolsTestRunner.

        :param verbosity: Ignored.
        :param failfast: Stop running tests at the first failure.
        :param buffer: Ignored.

            

Reported by Pylint.

              

class SubunitTestRunner(object):
    def __init__(self, verbosity=None, failfast=None, buffer=None, stream=None):
        """Create a TestToolsTestRunner.

        :param verbosity: Ignored.
        :param failfast: Stop running tests at the first failure.
        :param buffer: Ignored.

            

Reported by Pylint.

                      test_ids, errors = list_test(test)
        try:
            fileno = self.stream.fileno()
        except:
            fileno = None
        if fileno is not None:
            stream = os.fdopen(fileno, 'wb', 0)
        else:
            stream = self.stream

            

Reported by Pylint.

              def main():
    # Disable the default buffering, for Python 2.x where pdb doesn't do it
    # on non-ttys.
    stream = get_default_formatter()
    runner = SubunitTestRunner
    # Patch stdout to be unbuffered, so that pdb works well on 2.6/2.7.
    binstdout = io.open(sys.stdout.fileno(), 'wb', 0)
    if sys.version_info[0] > 2:
        sys.stdout = io.TextIOWrapper(binstdout, encoding=sys.stdout.encoding)

            

Reported by Pylint.

              #
# Simple subunit testrunner for python
# Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007
#   
#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
#  license at the users choice. A copy of both licenses are available in the
#  project source as Apache-2.0 and BSD. You may not use this file except in
#  compliance with one of these two licences.
#  

            

Reported by Pylint.

              #  license at the users choice. A copy of both licenses are available in the
#  project source as Apache-2.0 and BSD. You may not use this file except in
#  compliance with one of these two licences.
#  
#  Unless required by applicable law or agreed to in writing, software
#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
#  license you chose for the specific language governing permissions and
#  limitations under that license.

            

Reported by Pylint.

              # Check compatibility API

import fnmatch, os
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtdataset import SimpleDataSet, simple_key
from wtscenario import make_scenarios

class test_compat02(wttest.WiredTigerTestCase, suite_subprocess):

            

Reported by Pylint.

                  scenarios = make_scenarios(compat_create, compat_release, compat_min, compat_max, base_config,
                               prune=100, prunelong=100000)

    def conn_config(self):
        # Set archive false on the home directory.
        config_str = 'config_base=%s,' % self.basecfg
        log_str = 'log=(archive=false,enabled,file_max=%s),' % self.logmax
        compat_str = ''
        if (self.create_rel != 'none'):

            

Reported by Pylint.

              # test_compat02.py
# Check compatibility API

import fnmatch, os
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtdataset import SimpleDataSet, simple_key
from wtscenario import make_scenarios


            

Reported by Pylint.

              # test_compat02.py
# Check compatibility API

import fnmatch, os
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtdataset import SimpleDataSet, simple_key
from wtscenario import make_scenarios


            

Reported by Pylint.

              import fnmatch, os
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtdataset import SimpleDataSet, simple_key
from wtscenario import make_scenarios

class test_compat02(wttest.WiredTigerTestCase, suite_subprocess):
    # Add enough entries and use a small log size to generate more than
    # one log file.

            

Reported by Pylint.

              import fnmatch, os
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtdataset import SimpleDataSet, simple_key
from wtscenario import make_scenarios

class test_compat02(wttest.WiredTigerTestCase, suite_subprocess):
    # Add enough entries and use a small log size to generate more than
    # one log file.

            

Reported by Pylint.

              #!/usr/bin/env python
#
# Public Domain 2014-present MongoDB, Inc.
# Public Domain 2008-2014 WiredTiger, Inc.
#
# This is free and unencumbered software released into the public domain.
#
# Anyone is free to copy, modify, publish, use, compile, sell, or
# distribute this software, either in source code form or as a compiled

            

Reported by Pylint.

              # test_compat02.py
# Check compatibility API

import fnmatch, os
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtdataset import SimpleDataSet, simple_key
from wtscenario import make_scenarios


            

Reported by Pylint.

              # Check compatibility API

import fnmatch, os
import wiredtiger, wttest
from suite_subprocess import suite_subprocess
from wtdataset import SimpleDataSet, simple_key
from wtscenario import make_scenarios

class test_compat02(wttest.WiredTigerTestCase, suite_subprocess):

            

Reported by Pylint.

              from wtdataset import SimpleDataSet, simple_key
from wtscenario import make_scenarios

class test_compat02(wttest.WiredTigerTestCase, suite_subprocess):
    # Add enough entries and use a small log size to generate more than
    # one log file.
    entries = 2000
    logmax = "100K"
    tablename = 'test_compat02'

            

Reported by Pylint.

                  MDefinition* base = ins->base();
    MOZ_ASSERT(base->type() == MIRType::Int32);

    if (ins->access().type() == Scalar::Int64 && ins->access().isAtomic()) {
        auto* lir = new(alloc()) LWasmAtomicLoadI64(useRegisterAtStart(base));
        defineInt64Fixed(lir, ins, LInt64Allocation(LAllocation(AnyRegister(IntArgReg1)),
                                                    LAllocation(AnyRegister(IntArgReg0))));
        return;
    }

            

Reported by FlawFinder.

                  MDefinition* base = ins->base();
    MOZ_ASSERT(base->type() == MIRType::Int32);

    if (ins->access().type() == Scalar::Int64 && ins->access().isAtomic()) {
        auto* lir = new(alloc()) LWasmAtomicLoadI64(useRegisterAtStart(base));
        defineInt64Fixed(lir, ins, LInt64Allocation(LAllocation(AnyRegister(IntArgReg1)),
                                                    LAllocation(AnyRegister(IntArgReg0))));
        return;
    }

            

Reported by FlawFinder.

              
    LAllocation ptr = useRegisterAtStart(base);

    if (IsUnaligned(ins->access())) {
        MOZ_ASSERT(!ins->access().isAtomic());

        // Unaligned access expected! Revert to a byte load.
        LDefinition ptrCopy = tempCopy(base, 0);


            

Reported by FlawFinder.

                  LAllocation ptr = useRegisterAtStart(base);

    if (IsUnaligned(ins->access())) {
        MOZ_ASSERT(!ins->access().isAtomic());

        // Unaligned access expected! Revert to a byte load.
        LDefinition ptrCopy = tempCopy(base, 0);

        LDefinition noTemp = LDefinition::BogusTemp();

            

Reported by FlawFinder.

              
    if (ins->type() == MIRType::Int64) {
        auto* lir = new(alloc()) LWasmLoadI64(ptr);
        if (ins->access().offset() || ins->access().type() == Scalar::Int64)
            lir->setTemp(0, tempCopy(base, 0));
        defineInt64(lir, ins);
        return;
    }


            

Reported by FlawFinder.

              
    if (ins->type() == MIRType::Int64) {
        auto* lir = new(alloc()) LWasmLoadI64(ptr);
        if (ins->access().offset() || ins->access().type() == Scalar::Int64)
            lir->setTemp(0, tempCopy(base, 0));
        defineInt64(lir, ins);
        return;
    }


            

Reported by FlawFinder.

                  }

    auto* lir = new(alloc()) LWasmLoad(ptr);
    if (ins->access().offset())
        lir->setTemp(0, tempCopy(base, 0));

    define(lir, ins);
}


            

Reported by FlawFinder.

                  MDefinition* base = ins->base();
    MOZ_ASSERT(base->type() == MIRType::Int32);

    if (ins->access().type() == Scalar::Int64 && ins->access().isAtomic()) {
        auto* lir = new(alloc()) LWasmAtomicStoreI64(useRegister(base),
                                                     useInt64Fixed(ins->value(),
                                                                   Register64(IntArgReg1,
                                                                              IntArgReg0)),
                                                     tempFixed(IntArgReg2),

            

Reported by FlawFinder.

                  MDefinition* base = ins->base();
    MOZ_ASSERT(base->type() == MIRType::Int32);

    if (ins->access().type() == Scalar::Int64 && ins->access().isAtomic()) {
        auto* lir = new(alloc()) LWasmAtomicStoreI64(useRegister(base),
                                                     useInt64Fixed(ins->value(),
                                                                   Register64(IntArgReg1,
                                                                              IntArgReg0)),
                                                     tempFixed(IntArgReg2),

            

Reported by FlawFinder.

              
    LAllocation ptr = useRegisterAtStart(base);

    if (IsUnaligned(ins->access())) {
        MOZ_ASSERT(!ins->access().isAtomic());

        // Unaligned access expected! Revert to a byte store.
        LDefinition ptrCopy = tempCopy(base, 0);


            

Reported by FlawFinder.