//
namespace tt_align_ns {
struct __declspec(align(8)) a8 { 
   char m[8]; 
   typedef a8 type;
};
struct __declspec(align(16)) a16 { 
   char m[16]; 
   typedef a16 type;

            

Reported by FlawFinder.

                 typedef a8 type;
};
struct __declspec(align(16)) a16 { 
   char m[16]; 
   typedef a16 type;
};
struct __declspec(align(32)) a32 { 
   char m[32]; 
   typedef a32 type;

            

Reported by FlawFinder.

                 typedef a16 type;
};
struct __declspec(align(32)) a32 { 
   char m[32]; 
   typedef a32 type;
};
struct __declspec(align(64)) a64 
{ 
   char m[64]; 

            

Reported by FlawFinder.

              };
struct __declspec(align(64)) a64 
{ 
   char m[64]; 
   typedef a64 type;
};
struct __declspec(align(128)) a128 { 
   char m[128]; 
   typedef a128 type;

            

Reported by FlawFinder.

                 typedef a64 type;
};
struct __declspec(align(128)) a128 { 
   char m[128]; 
   typedef a128 type;
};
}

template<> struct type_with_alignment<8>  

            

Reported by FlawFinder.

              // This is the motivating case for SharedStateBase::isJustForContinuation. Without that logic, there
// would be a long chain of SharedStates, growing longer with each recursion. That logic exists to
// limit it to a fixed-size chain.
TEST(Future_EdgeCases, looping_onError) {
    int tries = 10;
    std::function<Future<int>()> read = [&] {
        return async([&] {
                   uassert(ErrorCodes::BadValue, "", --tries == 0);
                   return tries;

            

Reported by Cppcheck.

                                 uassert(ErrorCodes::BadValue, "", --tries == 0);
                   return tries;
               })
            .onError([&](Status) { return read(); });
    };
    ASSERT_EQ(read().get(), 0);
}

// This tests for a bug in an earlier implementation of isJustForContinuation. Due to an off-by-one,

            

Reported by FlawFinder.

                             })
            .onError([&](Status) { return read(); });
    };
    ASSERT_EQ(read().get(), 0);
}

// This tests for a bug in an earlier implementation of isJustForContinuation. Due to an off-by-one,
// it would replace the "then" continuation's SharedState. A different type is used for the return
// from then to cause it to fail a checked_cast close to the bug in debug builds.

            

Reported by FlawFinder.

                                 uassert(ErrorCodes::BadValue, "", --tries == 0);
                   return tries;
               })
            .onError([&](Status) { return read(); });
    };
    ASSERT_EQ(read().then([](int x) { return x + 0.5; }).get(), 0.5);
}

TEST(Future_EdgeCases, interrupted_wait_then_get) {

            

Reported by FlawFinder.

                             })
            .onError([&](Status) { return read(); });
    };
    ASSERT_EQ(read().then([](int x) { return x + 0.5; }).get(), 0.5);
}

TEST(Future_EdgeCases, interrupted_wait_then_get) {
    DummyInterruptible dummyInterruptible;


            

Reported by FlawFinder.

                  return 0;
}

void File::open(const char* filename, bool readOnly, bool direct) {
    _name = filename;
    _handle = CreateFileW(toNativeString(filename).c_str(),               // filename
                          (readOnly ? 0 : GENERIC_WRITE) | GENERIC_READ,  // desired access
                          FILE_SHARE_WRITE | FILE_SHARE_READ,             // share mode
                          nullptr,                                        // security

            

Reported by FlawFinder.

              #define O_NOATIME 0
#endif

void File::open(const char* filename, bool readOnly, bool direct) {
    _name = filename;
    _fd = ::open(filename,
                 (readOnly ? O_RDONLY : (O_CREAT | O_RDWR | O_NOATIME))
#if defined(O_DIRECT)
                     | (direct ? O_DIRECT : 0)

            

Reported by FlawFinder.

              
void File::open(const char* filename, bool readOnly, bool direct) {
    _name = filename;
    _fd = ::open(filename,
                 (readOnly ? O_RDONLY : (O_CREAT | O_RDWR | O_NOATIME))
#if defined(O_DIRECT)
                     | (direct ? O_DIRECT : 0)
#endif
                     ,

            

Reported by FlawFinder.

                  }
}

void File::read(fileofs o, char* data, unsigned len) {
    LARGE_INTEGER li;
    li.QuadPart = o;
    if (SetFilePointerEx(_handle, li, nullptr, FILE_BEGIN) == 0) {
        _bad = true;
        DWORD dosError = GetLastError();

            

Reported by FlawFinder.

                  }
}

void File::read(fileofs o, char* data, unsigned len) {
    ssize_t bytesRead = ::pread(_fd, data, len, o);
    if (bytesRead == -1) {
        _bad = true;
        LOGV2(23154,
              "In File::read(), ::pread for '{fileName}' failed with {error}",

            

Reported by FlawFinder.

              MONGO_FAIL_POINT_DEFINE(dummy2);
}  // namespace

TEST(FailPoint, InitialState) {
    FailPoint failPoint("testFP");
    ASSERT_FALSE(failPoint.shouldFail());
}

TEST(FailPoint, AlwaysOn) {

            

Reported by Cppcheck.

              }

TEST(FailPoint, RandomActivationP0) {
    ASSERT_EQUALS(0, runParallelFailPointTest(FailPoint::random, 0, 1, 1000000));
}

TEST(FailPoint, RandomActivationP5) {
    ASSERT_APPROX_EQUAL(500000,
                        runParallelFailPointTest(

            

Reported by FlawFinder.

              TEST(FailPoint, RandomActivationP5) {
    ASSERT_APPROX_EQUAL(500000,
                        runParallelFailPointTest(
                            FailPoint::random, std::numeric_limits<int32_t>::max() / 2, 10, 100000),
                        1000);
}

TEST(FailPoint, RandomActivationP01) {
    ASSERT_APPROX_EQUAL(

            

Reported by FlawFinder.

                  ASSERT_APPROX_EQUAL(
        10000,
        runParallelFailPointTest(
            FailPoint::random, std::numeric_limits<int32_t>::max() / 100, 10, 100000),
        500);
}

TEST(FailPoint, RandomActivationP001) {
    ASSERT_APPROX_EQUAL(

            

Reported by FlawFinder.

                  ASSERT_APPROX_EQUAL(
        1000,
        runParallelFailPointTest(
            FailPoint::random, std::numeric_limits<int32_t>::max() / 1000, 10, 100000),
        500);
}

TEST(FailPoint, parseBSONEmptyFails) {
    auto swTuple = FailPoint::parseBSON(BSONObj());

            

Reported by FlawFinder.

                  while ((ret = cursor->next(cursor)) == 0) {
        error_check(cursor->get_key(cursor, &recno));
        error_check(cursor->get_value(cursor, &country, &year, &population));
        printf("ID %" PRIu64, recno);
        printf(
          ": country %s, year %" PRIu16 ", population %" PRIu64 "\n", country, year, population);
    }
    scan_end_check(ret == WT_NOTFOUND);
    error_check(cursor->close(cursor));

            

Reported by FlawFinder.

              
        error_check(cursor->get_key(cursor, &key));
        error_check(wiredtiger_struct_unpack(session, key.data, key.size, "r", &recno));
        printf("ID %" PRIu64, recno);

        error_check(cursor->get_value(cursor, &value));
        error_check(wiredtiger_struct_unpack(
          session, value.data, value.size, "5sHQ", &country, &year, &population));
        printf(

            

Reported by FlawFinder.

                  while ((ret = join_cursor->next(join_cursor)) == 0) {
        error_check(join_cursor->get_key(join_cursor, &recno));
        error_check(join_cursor->get_value(join_cursor, &country, &year, &population));
        printf("ID %" PRIu64, recno);
        printf(
          ": country %s, year %" PRIu16 ", population %" PRIu64 "\n", country, year, population);
    }
    scan_end_check(ret == WT_NOTFOUND);
    /*! [Join cursors] */

            

Reported by FlawFinder.

                  while ((ret = join_cursor->next(join_cursor)) == 0) {
        error_check(join_cursor->get_key(join_cursor, &recno));
        error_check(join_cursor->get_value(join_cursor, &country, &year, &population));
        printf("ID %" PRIu64, recno);
        printf(
          ": country %s, year %" PRIu16 ", population %" PRIu64 "\n", country, year, population);
    }
    scan_end_check(ret == WT_NOTFOUND);
    /*! [Complex join cursors] */

            

Reported by FlawFinder.

              /*! [schema declaration] */
/* The C struct for the data we are storing in a WiredTiger table. */
typedef struct {
    char country[5];
    uint16_t year;
    uint64_t population;
} POP_RECORD;

static POP_RECORD pop_data[] = {{"AU", 1900, 4000000}, {"AU", 1950, 8267337},

            

Reported by FlawFinder.

                        "path=/dev/loop,page_size=1024,log=(archive=true,file_max=20MB)";

        error_check(
          wiredtiger_config_parser_open(NULL, config_string, strlen(config_string), &parser));
        error_check(parser->close(parser));
        /*! [Create a configuration parser] */

        error_check(
          wiredtiger_config_parser_open(NULL, config_string, strlen(config_string), &parser));

            

Reported by FlawFinder.

                      /*! [Create a configuration parser] */

        error_check(
          wiredtiger_config_parser_open(NULL, config_string, strlen(config_string), &parser));

        {
            /*! [get] */
            int64_t my_page_size;
            /*

            

Reported by FlawFinder.

              
        {
            error_check(
              wiredtiger_config_parser_open(NULL, config_string, strlen(config_string), &parser));
            /*! [next] */
            /*
             * Retrieve and print the values of the configuration strings.
             */
            while ((ret = parser->next(parser, &k, &v)) == 0) {

            

Reported by FlawFinder.

                      }

        error_check(
          wiredtiger_config_parser_open(NULL, config_string, strlen(config_string), &parser));

        /*! [nested get] */
        /*
         * Retrieve the value of the nested log file_max configuration string using dot shorthand.
         * Utilize the configuration parsing automatic conversion of value strings into an integer.

            

Reported by FlawFinder.

                      error_check(parser->close(parser));

        error_check(
          wiredtiger_config_parser_open(NULL, config_string, strlen(config_string), &parser));
        /*! [nested traverse] */
        {
            WT_CONFIG_PARSER *sub_parser;
            while ((ret = parser->next(parser, &k, &v)) == 0) {
                if (v.type == WT_CONFIG_ITEM_STRUCT) {

            

Reported by FlawFinder.

              # This file is a python script that describes the cpp test framework test configuration options.

class Method:
    def __init__(self, config):
        # Deal with duplicates: with complex configurations (like
        # WT_SESSION::create), it's simpler to deal with duplicates once than
        # manually as configurations are defined
        self.config = []
        lastname = None

            

Reported by Pylint.

              # This file is a python script that describes the cpp test framework test configuration options.

class Method:
    def __init__(self, config):
        # Deal with duplicates: with complex configurations (like
        # WT_SESSION::create), it's simpler to deal with duplicates once than
        # manually as configurations are defined
        self.config = []
        lastname = None

            

Reported by Pylint.

              # This file is a python script that describes the cpp test framework test configuration options.

class Method:
    def __init__(self, config):
        # Deal with duplicates: with complex configurations (like
        # WT_SESSION::create), it's simpler to deal with duplicates once than
        # manually as configurations are defined
        self.config = []
        lastname = None

            

Reported by Pylint.

                      # manually as configurations are defined
        self.config = []
        lastname = None
        for c in sorted(config):
            if '.' in c.name:
                raise "Bad config key '%s'" % c.name
            if c.name == lastname:
                continue
            lastname = c.name

            

Reported by Pylint.

                          lastname = c.name
            self.config.append(c)

class Config:
    def __init__(self, name, default, desc, subconfig=None, **flags):
        self.name = name
        self.default = default
        self.desc = desc
        self.subconfig = subconfig

            

Reported by Pylint.

              
extern "C" void execCallback(int) {
    launchDebugger([](char* pidToDebug) {
        execlp("gdbserver", "gdbserver", "--attach", ":0", pidToDebug, nullptr);
    });
}

#elif defined(USE_LLDB_SERVER)


            

Reported by FlawFinder.

              extern "C" void execCallback(int) {
    launchDebugger([](char* pidToDebug) {
#ifdef __linux__
        execlp("lldb-server", "lldb-server", "g", "--attach", pidToDebug, "*:12345", nullptr);
#else
        execlp("debugserver", "debugserver", "*:12345", "--attach", pidToDebug, nullptr);
#endif
    });
}

            

Reported by FlawFinder.

              #ifdef __linux__
        execlp("lldb-server", "lldb-server", "g", "--attach", pidToDebug, "*:12345", nullptr);
#else
        execlp("debugserver", "debugserver", "*:12345", "--attach", pidToDebug, nullptr);
#endif
    });
}

#endif

            

Reported by FlawFinder.

                  // Don't come back here
    signal(SIGTRAP, SIG_IGN);

    char pidToDebug[16];
    int pidRet = snprintf(pidToDebug, sizeof(pidToDebug), "%d", getpid());
    if (!(pidRet >= 0 && size_t(pidRet) < sizeof(pidToDebug)))
        std::abort();

    char msg[128];

            

Reported by FlawFinder.

                  if (!(pidRet >= 0 && size_t(pidRet) < sizeof(pidToDebug)))
        std::abort();

    char msg[128];
    int msgRet = snprintf(msg,
                          sizeof(msg),
                          "\n\n\t**** Launching debugging server (ensure binary is in PATH, use "
                          "lsof to find port) ****\n\n");
    if (!(msgRet >= 0 && size_t(msgRet) < sizeof(msg)))

            

Reported by FlawFinder.

              	  std::size_t lenSourceWithNull = std::strlen(strSource) + 1;
	  if (lenSourceWithNull > sizeInBytes)
         return 1;
	  std::memcpy(strDestination, strSource, lenSourceWithNull);
      return 0;
   }
   inline std::size_t strcat_s(
      char *strDestination,
      std::size_t sizeInBytes,

            

Reported by FlawFinder.

              	  std::size_t lenDestination = std::strlen(strDestination);
	  if (lenSourceWithNull + lenDestination > sizeInBytes)
         return 1;
	  std::memcpy(strDestination + lenDestination, strSource, lenSourceWithNull);
      return 0;
   }

#endif


            

Reported by FlawFinder.

                    const char *strSource 
   )
   {
	  std::size_t lenSourceWithNull = std::strlen(strSource) + 1;
	  if (lenSourceWithNull > sizeInBytes)
         return 1;
	  std::memcpy(strDestination, strSource, lenSourceWithNull);
      return 0;
   }

            

Reported by FlawFinder.

                    const char *strSource 
   )
   {
	  std::size_t lenSourceWithNull = std::strlen(strSource) + 1;
	  std::size_t lenDestination = std::strlen(strDestination);
	  if (lenSourceWithNull + lenDestination > sizeInBytes)
         return 1;
	  std::memcpy(strDestination + lenDestination, strSource, lenSourceWithNull);
      return 0;

            

Reported by FlawFinder.

                 )
   {
	  std::size_t lenSourceWithNull = std::strlen(strSource) + 1;
	  std::size_t lenDestination = std::strlen(strDestination);
	  if (lenSourceWithNull + lenDestination > sizeInBytes)
         return 1;
	  std::memcpy(strDestination + lenDestination, strSource, lenSourceWithNull);
      return 0;
   }

            

Reported by FlawFinder.

              struct _fi_find_data
{
   unsigned dwFileAttributes;
   char cFileName[MAX_PATH];
};

struct _fi_priv_data;

typedef _fi_priv_data* _fi_find_handle;

            

Reported by FlawFinder.

                 typedef const char* iterator;

   mapfile(){ hfile = hmap = 0; _first = _last = 0; }
   mapfile(const char* file){ hfile = hmap = 0; _first = _last = 0; open(file); }
   ~mapfile(){ close(); }
   void open(const char* file);
   void close();
   const char* begin(){ return _first; }
   const char* end(){ return _last; }

            

Reported by FlawFinder.

                 mapfile(){ hfile = hmap = 0; _first = _last = 0; }
   mapfile(const char* file){ hfile = hmap = 0; _first = _last = 0; open(file); }
   ~mapfile(){ close(); }
   void open(const char* file);
   void close();
   const char* begin(){ return _first; }
   const char* end(){ return _last; }
   size_t size(){ return _last - _first; }
   bool valid(){ return (hfile != 0) && (hfile != INVALID_HANDLE_VALUE); }

            

Reported by FlawFinder.

                 typedef mapfile_iterator iterator;

   mapfile(){ hfile = 0; _size = 0; _first = _last = 0; }
   mapfile(const char* file){ hfile = 0; _size = 0; _first = _last = 0; open(file); }
   ~mapfile(){ close(); }
   void open(const char* file);
   void close();
   iterator begin()const;
   iterator end()const;

            

Reported by FlawFinder.

                 mapfile(){ hfile = 0; _size = 0; _first = _last = 0; }
   mapfile(const char* file){ hfile = 0; _size = 0; _first = _last = 0; open(file); }
   ~mapfile(){ close(); }
   void open(const char* file);
   void close();
   iterator begin()const;
   iterator end()const;
   unsigned long size()const{ return _size; }
   bool valid()const{ return hfile != 0; }

            

Reported by FlawFinder.