import logging
import os.path
import shlex
import subprocess
import sys
from abc import ABC, abstractmethod
from collections import defaultdict
from typing import Optional, Set, Tuple, List, Dict, NamedTuple


            

Reported by Bandit.

                      new_resmoke_cmd.extend(tests_by_task[task].tests)
        log.debug("starting execution of task")
        try:
            subprocess.check_call(new_resmoke_cmd, shell=False)
        except subprocess.CalledProcessError as err:
            log.warning("Resmoke returned an error with task", error=err.returncode)
            sys.exit(err.returncode)



            

Reported by Bandit.

                return p;
}

TEST(ExponentialBiasedTest, CoinTossDemoWithGetSkipCount) {
  ExponentialBiased eb;
  for (int runs = 0; runs < 10; ++runs) {
    for (int flips = eb.GetSkipCount(1); flips > 0; --flips) {
      printf("head...");
    }

            

Reported by Cppcheck.

              namespace base_internal {

MATCHER_P2(IsBetween, a, b,
           absl::StrCat(std::string(negation ? "isn't" : "is"), " between ", a,
                        " and ", b)) {
  return a <= arg && arg <= b;
}

// Tests of the quality of the random numbers generated

            

Reported by FlawFinder.

              template <>
struct stream_u128_helper<absl::uint128> {
  template <typename IStream>
  inline absl::uint128 read(IStream& in) {
    uint64_t h = 0;
    uint64_t l = 0;
    in >> h >> l;
    return absl::MakeUint128(h, l);
  }

            

Reported by FlawFinder.

              template <>
struct stream_u128_helper<__uint128_t> {
  template <typename IStream>
  inline __uint128_t read(IStream& in) {
    uint64_t h = 0;
    uint64_t l = 0;
    in >> h >> l;
    return (static_cast<__uint128_t>(h) << 64) | l;
  }

            

Reported by FlawFinder.

              
namespace mongo {

typedef unsigned char md5digest[16];

inline void md5(const void* buf, int nbytes, md5digest digest) {
    md5_state_t st;
    md5_init(&st);
    md5_append(&st, (const md5_byte_t*)buf, nbytes);

            

Reported by FlawFinder.

              }

inline void md5(const char* str, md5digest digest) {
    md5(str, strlen(str), digest);
}

inline std::string digestToString(md5digest digest) {
    static const char* letters = "0123456789abcdef";
    std::stringstream ss;

            

Reported by FlawFinder.

              }

std::string BrandString() {
  char brand_string[49];
  uint32_t abcd[4];

  // Check if brand string is supported (it is on all reasonable Intel/AMD)
  Cpuid(0x80000000U, 0, abcd);
  if (abcd[0] < 0x80000004U) {

            

Reported by FlawFinder.

              
  for (int i = 0; i < 3; ++i) {
    Cpuid(0x80000002U + i, 0, abcd);
    memcpy(brand_string + i * 16, &abcd, sizeof(abcd));
  }
  brand_string[48] = 0;
  return brand_string;
}


            

Reported by FlawFinder.

                      // Insert a mix of the various types of data.
        insertVarietyOfObjects(ws.get(), queuedDataStage.get(), coll);

        auto sortPattern = BSON("foo" << direction);
        auto keyGenStage = std::make_unique<SortKeyGeneratorStage>(
            _expCtx, std::move(queuedDataStage), ws.get(), sortPattern);

        auto sortStage = std::make_unique<SortStageDefault>(_expCtx,
                                                            ws.get(),

            

Reported by Cppcheck.

                          }
        }

        auto sortPattern = BSON("b" << -1 << "c" << 1 << "a" << 1);

        auto keyGenStage = std::make_unique<SortKeyGeneratorStage>(
            _expCtx, std::move(queuedDataStage), ws.get(), sortPattern);

        auto sortStage = std::make_unique<SortStageDefault>(_expCtx,

            

Reported by Cppcheck.

                  return _children[0]->getAccessor(ctx, slot);
}

void CheckBoundsStage::open(bool reOpen) {
    auto optTimer(getOptTimer(_opCtx));

    _commonStats.opens++;
    _children[0]->open(reOpen);
    _isEOF = false;

            

Reported by FlawFinder.

                  auto optTimer(getOptTimer(_opCtx));

    _commonStats.opens++;
    _children[0]->open(reOpen);
    _isEOF = false;
}

PlanState CheckBoundsStage::getNext() {
    auto optTimer(getOptTimer(_opCtx));

            

Reported by FlawFinder.

              from buildscripts.resmokelib.testing.fixtures import replicaset
from buildscripts.resmokelib.testing.fixtures import shardedcluster

from . import interface
from . import jsfile


class HelloDelays(interface.Hook):
    """Sets Hello fault injections."""

            

Reported by Pylint.

              from buildscripts.resmokelib.testing.fixtures import shardedcluster

from . import interface
from . import jsfile


class HelloDelays(interface.Hook):
    """Sets Hello fault injections."""


            

Reported by Pylint.

              // memcpy when allowed.
template <>
inline void MemcpyIfAllowed<true>(void* dst, const void* src, size_t n) {
  memcpy(dst, src, n);
}

// Do nothing for types that are not memcpy-able. This function is only
// called from non-reachable branches.
template <>

            

Reported by FlawFinder.

                };

  struct Inlined {
    alignas(value_type) char inlined_data[sizeof(value_type[N])];
  };

  union Data {
    Allocated allocated;
    Inlined inlined;

            

Reported by FlawFinder.

              #include <boost/config.hpp>
#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std{
    using ::memcpy;
    using ::size_t;
} // namespace std
#endif

#include <boost/cstdint.hpp>

            

Reported by FlawFinder.

                          boost::serialization::throw_exception(
                archive_exception(archive_exception::input_stream_error)
            );
        std::memcpy(static_cast<char*>(address) + (count - s), &t, static_cast<std::size_t>(s));
    }
}

} // namespace archive
} // namespace boost

            

Reported by FlawFinder.