Subversion Repositories NedoOS

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;

typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

                        // <tr1/functional> if they choose to.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

namespace testing {

 

class Message;

 

using GTEST_TUPLE_NAMESPACE_::get;

using GTEST_TUPLE_NAMESPACE_::make_tuple;

using GTEST_TUPLE_NAMESPACE_::tuple;

using GTEST_TUPLE_NAMESPACE_::tuple_size;

using GTEST_TUPLE_NAMESPACE_::tuple_element;

 

namespace internal {

 

class Secret;

 

 

template <bool>

  struct CompileAssert {

 

 

 

template <typename T1, typename T2>

struct StaticAssertTypeEqHelper;

 

template <typename T>

struct StaticAssertTypeEqHelper<T, T> {

  enum { value = true };

 

template <typename T, typename U>

struct IsSame {

  enum { value = false };

template <typename T>

struct IsSame<T, T> {

  enum { value = true };

 

 

typedef ::string string;

typedef ::std::string string;

 

typedef ::wstring wstring;

typedef ::std::wstring wstring;

 

GTEST_API_ bool IsTrue(bool condition);

 

 

template <typename T>

class scoped_ptr {

 public:

  typedef T element_type;

 

  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}

  ~scoped_ptr() { reset(); }

 

  T& operator*() const { return *ptr_; }

  T* operator->() const { return ptr_; }

  T* get() const { return ptr_; }

 

  T* release() {

    T* const ptr = ptr_;

    ptr_ = NULL;

    return ptr;

  }

 

  void reset(T* p = NULL) {

    if (p != ptr_) {

      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.

        delete ptr_;

      }

      ptr_ = p;

    }

  }

 

  friend void swap(scoped_ptr& a, scoped_ptr& b) {

    using std::swap;

    swap(a.ptr_, b.ptr_);

  }

 

 private:

  T* ptr_;

 

  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);

 

 

 

class GTEST_API_ RE {

 public:

  // A copy constructor is required by the Standard to initialize object

  // references from r-values.

  RE(const RE& other) { Init(other.pattern()); }

 

  // Constructs an RE from a string.

  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT

 

 

  RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT

 

 

  RE(const char* regex) { Init(regex); }  // NOLINT

  ~RE();

 

  // Returns the string representation of the regex.

  const char* pattern() const { return pattern_; }

 

  // FullMatch(str, re) returns true iff regular expression re matches

  // the entire str.

  // PartialMatch(str, re) returns true iff regular expression re

  // matches a substring of str (including str itself).

  //

  // FIXME: make FullMatch() and PartialMatch() work

  // when str contains NUL characters.

  static bool FullMatch(const ::std::string& str, const RE& re) {

    return FullMatch(str.c_str(), re);

  }

  static bool PartialMatch(const ::std::string& str, const RE& re) {

    return PartialMatch(str.c_str(), re);

  }

 

 

  static bool FullMatch(const ::string& str, const RE& re) {

    return FullMatch(str.c_str(), re);

  }

  static bool PartialMatch(const ::string& str, const RE& re) {

    return PartialMatch(str.c_str(), re);

  }

 

 

  static bool FullMatch(const char* str, const RE& re);

  static bool PartialMatch(const char* str, const RE& re);

 

 private:

  void Init(const char* regex);

 

  // We use a const char* instead of an std::string, as Google Test used to be

  // used where std::string is not available.  FIXME: change to

  // std::string.

  const char* pattern_;

  bool is_valid_;

 

 

  regex_t full_regex_;     // For FullMatch().

  regex_t partial_regex_;  // For PartialMatch().

 

 

  const char* full_pattern_;  // For FullMatch();

 

 

  GTEST_DISALLOW_ASSIGN_(RE);

 

 

GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);

 

GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,

                                                               int line);

 

 

enum GTestLogSeverity {

  GTEST_INFO,

  GTEST_WARNING,

  GTEST_ERROR,

  GTEST_FATAL

 

class GTEST_API_ GTestLog {

 public:

  GTestLog(GTestLogSeverity severity, const char* file, int line);

 

  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.

  ~GTestLog();

 

  ::std::ostream& GetStream() { return ::std::cerr; }

 

 private:

  const GTestLogSeverity severity_;

 

  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);

 

 

 

inline void LogToStderr() {}

inline void FlushInfoLog() { fflush(NULL); }

 

 

 

 

template <typename T>

struct AddReference { typedef T& type; };  // NOLINT

template <typename T>

struct AddReference<T&> { typedef T& type; };  // NOLINT

 

 

template <typename T>

struct ConstRef { typedef const T& type; };

template <typename T>

struct ConstRef<T&> { typedef T& type; };

 

 

using std::forward;

using std::move;

 

template <typename T>

struct RvalueRef {

  typedef T&& type;

template <typename T>

const T& move(const T& t) {

  return t;

template <typename T>

GTEST_ADD_REFERENCE_(T) forward(GTEST_ADD_REFERENCE_(T) t) { return t; }

 

template <typename T>

struct RvalueRef {

  typedef const T& type;

 

template<typename To>

inline To ImplicitCast_(To x) { return x; }

 

template<typename To, typename From>  // use like this: DownCast_<T*>(foo);

inline To DownCast_(From* f) {  // so we only accept pointers

  // Ensures that To is a sub-type of From *.  This test is here only

  // for compile-time type checking, and has no overhead in an

  // optimized build at run-time, as it will be optimized away

  // completely.

  GTEST_INTENTIONAL_CONST_COND_PUSH_()

  if (false) {

  GTEST_INTENTIONAL_CONST_COND_POP_()

    const To to = NULL;

    ::testing::internal::ImplicitCast_<From*>(to);

  }

 

  // RTTI: debug mode only!

  GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);

  return static_cast<To>(f);

 

template <class Derived, class Base>

Derived* CheckedDowncastToActualType(Base* base) {

  GTEST_CHECK_(typeid(*base) == typeid(Derived));

 

  return ::down_cast<Derived*>(base);

  return dynamic_cast<Derived*>(base);  // NOLINT

  return static_cast<Derived*>(base);  // Poor man's downcast.

 

 

GTEST_API_ void CaptureStdout();

GTEST_API_ std::string GetCapturedStdout();

GTEST_API_ void CaptureStderr();

GTEST_API_ std::string GetCapturedStderr();

 

GTEST_API_ size_t GetFileSize(FILE* file);

 

GTEST_API_ std::string ReadEntireFile(FILE* file);

 

GTEST_API_ std::vector<std::string> GetArgvs();

 

 

std::vector<std::string> GetInjectableArgvs();

void SetInjectableArgvs(const std::vector<std::string>* new_argvs);

void SetInjectableArgvs(const std::vector<std::string>& new_argvs);

void SetInjectableArgvs(const std::vector< ::string>& new_argvs);

void ClearInjectableArgvs();

 

 

inline void SleepMilliseconds(int n) {

  const timespec time = {

    0,                  // 0 seconds.

    n * 1000L * 1000L,  // And n ms.

  };

  nanosleep(&time, NULL);

 

 

class Notification {

 public:

  Notification() : notified_(false) {

    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));

  }

  ~Notification() {

    pthread_mutex_destroy(&mutex_);

  }

 

  // Notifies all threads created with this notification to start. Must

  // be called from the controller thread.

  void Notify() {

    pthread_mutex_lock(&mutex_);

    notified_ = true;

    pthread_mutex_unlock(&mutex_);

  }

 

  // Blocks until the controller thread notifies. Must be called from a test

  // thread.

  void WaitForNotification() {

    for (;;) {

      pthread_mutex_lock(&mutex_);

      const bool notified = notified_;

      pthread_mutex_unlock(&mutex_);

      if (notified)

        break;

      SleepMilliseconds(10);

    }

  }

 

 private:

  pthread_mutex_t mutex_;

  bool notified_;

 

  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);

 

 

GTEST_API_ void SleepMilliseconds(int n);

 

class GTEST_API_ AutoHandle {

 public:

  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to

  // avoid including <windows.h> in this header file. Including <windows.h> is

  // undesirable because it defines a lot of symbols and macros that tend to

  // conflict with client code. This assumption is verified by

  // WindowsTypesTest.HANDLEIsVoidStar.

  typedef void* Handle;

  AutoHandle();

  explicit AutoHandle(Handle handle);

 

  ~AutoHandle();

 

  Handle Get() const;

  void Reset();

  void Reset(Handle handle);

 

 private:

  // Returns true iff the handle is a valid handle object that can be closed.

  bool IsCloseable() const;

 

  Handle handle_;

 

  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);

 

class GTEST_API_ Notification {

 public:

  Notification();

  void Notify();

  void WaitForNotification();

 

 private:

  AutoHandle event_;

 

  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);

 

 

class ThreadWithParamBase {

 public:

  virtual ~ThreadWithParamBase() {}

  virtual void Run() = 0;

 

extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {

  static_cast<ThreadWithParamBase*>(thread)->Run();

  return NULL;

 

template <typename T>

class ThreadWithParam : public ThreadWithParamBase {

 public:

  typedef void UserThreadFunc(T);

 

  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)

      : func_(func),

        param_(param),

        thread_can_start_(thread_can_start),

        finished_(false) {

    ThreadWithParamBase* const base = this;

    // The thread can be created only after all fields except thread_

    // have been initialized.

    GTEST_CHECK_POSIX_SUCCESS_(

        pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));

  }

  ~ThreadWithParam() { Join(); }

 

  void Join() {

    if (!finished_) {

      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));

      finished_ = true;

    }

  }

 

  virtual void Run() {

    if (thread_can_start_ != NULL)

      thread_can_start_->WaitForNotification();

    func_(param_);

  }

 

 private:

  UserThreadFunc* const func_;  // User-supplied thread function.

  const T param_;  // User-supplied parameter to the thread function.

  // When non-NULL, used to block execution until the controller thread

  // notifies.

  Notification* const thread_can_start_;

  bool finished_;  // true iff we know that the thread function has finished.

  pthread_t thread_;  // The native thread object.

 

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);

         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_

 

 

 

class GTEST_API_ Mutex {

 public:

  enum MutexType { kStatic = 0, kDynamic = 1 };

  // We rely on kStaticMutex being 0 as it is to what the linker initializes

  // type_ in static mutexes.  critical_section_ will be initialized lazily

  // in ThreadSafeLazyInit().

  enum StaticConstructorSelector { kStaticMutex = 0 };

 

  // This constructor intentionally does nothing.  It relies on type_ being

  // statically initialized to 0 (effectively setting it to kStatic) and on

  // ThreadSafeLazyInit() to lazily initialize the rest of the members.

  explicit Mutex(StaticConstructorSelector /*dummy*/) {}

 

  Mutex();

  ~Mutex();

 

  void Lock();

 

  void Unlock();

 

  // Does nothing if the current thread holds the mutex. Otherwise, crashes

  // with high probability.

  void AssertHeld();

 

 private:

  // Initializes owner_thread_id_ and critical_section_ in static mutexes.

  void ThreadSafeLazyInit();

 

  // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503,

  // we assume that 0 is an invalid value for thread IDs.

  unsigned int owner_thread_id_;

 

  // For static mutexes, we rely on these members being initialized to zeros

  // by the linker.

  MutexType type_;

  long critical_section_init_phase_;  // NOLINT

  GTEST_CRITICAL_SECTION* critical_section_;

 

  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);

 

 

 

class GTestMutexLock {

 public:

  explicit GTestMutexLock(Mutex* mutex)

      : mutex_(mutex) { mutex_->Lock(); }

 

  ~GTestMutexLock() { mutex_->Unlock(); }

 

 private:

  Mutex* const mutex_;

 

  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);

 

typedef GTestMutexLock MutexLock;

 

class ThreadLocalValueHolderBase {

 public:

  virtual ~ThreadLocalValueHolderBase() {}

 

class ThreadLocalBase {

 public:

  // Creates a new ValueHolder<T> object holding a default value passed to

  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's

  // responsibility not to call this when the ThreadLocal<T> instance already

  // has a value on the current thread.

  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;

 

 protected:

  ThreadLocalBase() {}

  virtual ~ThreadLocalBase() {}

 

 private:

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);

 

class GTEST_API_ ThreadLocalRegistry {

 public:

  // Registers thread_local_instance as having value on the current thread.

  // Returns a value that can be used to identify the thread from other threads.

  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(

      const ThreadLocalBase* thread_local_instance);

 

  // Invoked when a ThreadLocal instance is destroyed.

  static void OnThreadLocalDestroyed(

      const ThreadLocalBase* thread_local_instance);

 

class GTEST_API_ ThreadWithParamBase {

 public:

  void Join();

 

 protected:

  class Runnable {

   public:

    virtual ~Runnable() {}

    virtual void Run() = 0;

  };

 

  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);

  virtual ~ThreadWithParamBase();

 

 private:

  AutoHandle thread_;

 

template <typename T>

class ThreadWithParam : public ThreadWithParamBase {

 public:

  typedef void UserThreadFunc(T);

 

  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)

      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {

  }

  virtual ~ThreadWithParam() {}

 

 private:

  class RunnableImpl : public Runnable {

   public:

    RunnableImpl(UserThreadFunc* func, T param)

        : func_(func),

          param_(param) {

    }

    virtual ~RunnableImpl() {}

    virtual void Run() {

      func_(param_);

    }

 

   private:

    UserThreadFunc* const func_;

    const T param_;

 

    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);

  };

 

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);

 

template <typename T>

class ThreadLocal : public ThreadLocalBase {

 public:

  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}

  explicit ThreadLocal(const T& value)

      : default_factory_(new InstanceValueHolderFactory(value)) {}

 

  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }

 

  T* pointer() { return GetOrCreateValue(); }

  const T* pointer() const { return GetOrCreateValue(); }

  const T& get() const { return *pointer(); }

  void set(const T& value) { *pointer() = value; }

 

 private:

  // Holds a value of T.  Can be deleted via its base class without the caller

  // knowing the type of T.

  class ValueHolder : public ThreadLocalValueHolderBase {

   public:

    ValueHolder() : value_() {}

    explicit ValueHolder(const T& value) : value_(value) {}

 

    T* pointer() { return &value_; }

 

   private:

    T value_;

    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);

  };

 

 

  T* GetOrCreateValue() const {

    return static_cast<ValueHolder*>(

        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();

  }

 

  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {

    return default_factory_->MakeNewHolder();

  }

 

  class ValueHolderFactory {

   public:

    ValueHolderFactory() {}

    virtual ~ValueHolderFactory() {}

    virtual ValueHolder* MakeNewHolder() const = 0;

 

   private:

    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);

  };

 

  class DefaultValueHolderFactory : public ValueHolderFactory {

   public:

    DefaultValueHolderFactory() {}

    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }

 

   private:

    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);

  };

 

  class InstanceValueHolderFactory : public ValueHolderFactory {

   public:

    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}

    virtual ValueHolder* MakeNewHolder() const {

      return new ValueHolder(value_);

    }

 

   private:

    const T value_;  // The value for each thread.

 

    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);

  };

 

  scoped_ptr<ValueHolderFactory> default_factory_;

 

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);

 

 

class MutexBase {

 public:

  // Acquires this mutex.

  void Lock() {

    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));

    owner_ = pthread_self();

    has_owner_ = true;

  }

 

  // Releases this mutex.

  void Unlock() {

    // Since the lock is being released the owner_ field should no longer be

    // considered valid. We don't protect writing to has_owner_ here, as it's

    // the caller's responsibility to ensure that the current thread holds the

    // mutex when this is called.

    has_owner_ = false;

    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));

  }

 

  // Does nothing if the current thread holds the mutex. Otherwise, crashes

  // with high probability.

  void AssertHeld() const {

    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))

        << "The current thread is not holding the mutex @" << this;

  }

 

  // A static mutex may be used before main() is entered.  It may even

  // be used before the dynamic initialization stage.  Therefore we

  // must be able to initialize a static mutex object at link time.

  // This means MutexBase has to be a POD and its member variables

  // have to be public.

 public:

  pthread_mutex_t mutex_;  // The underlying pthread mutex.

  // has_owner_ indicates whether the owner_ field below contains a valid thread

  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All

  // accesses to the owner_ field should be protected by a check of this field.

  // An alternative might be to memset() owner_ to all zeros, but there's no

  // guarantee that a zero'd pthread_t is necessarily invalid or even different

  // from pthread_self().

  bool has_owner_;

  pthread_t owner_;  // The thread holding the mutex.

 

 

 

class Mutex : public MutexBase {

 public:

  Mutex() {

    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));

    has_owner_ = false;

  }

  ~Mutex() {

    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));

  }

 

 private:

  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);

 

class GTestMutexLock {

 public:

  explicit GTestMutexLock(MutexBase* mutex)

      : mutex_(mutex) { mutex_->Lock(); }

 

  ~GTestMutexLock() { mutex_->Unlock(); }

 

 private:

  MutexBase* const mutex_;

 

  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);

 

typedef GTestMutexLock MutexLock;

 

 

class ThreadLocalValueHolderBase {

 public:

  virtual ~ThreadLocalValueHolderBase() {}

 

extern "C" inline void DeleteThreadLocalValue(void* value_holder) {

  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);

 

template <typename T>

class GTEST_API_ ThreadLocal {

 public:

  ThreadLocal()

      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}

  explicit ThreadLocal(const T& value)

      : key_(CreateKey()),

        default_factory_(new InstanceValueHolderFactory(value)) {}

 

  ~ThreadLocal() {

    // Destroys the managed object for the current thread, if any.

    DeleteThreadLocalValue(pthread_getspecific(key_));

 

    // Releases resources associated with the key.  This will *not*

    // delete managed objects for other threads.

    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));

  }

 

  T* pointer() { return GetOrCreateValue(); }

  const T* pointer() const { return GetOrCreateValue(); }

  const T& get() const { return *pointer(); }

  void set(const T& value) { *pointer() = value; }

 

 private:

  // Holds a value of type T.

  class ValueHolder : public ThreadLocalValueHolderBase {

   public:

    ValueHolder() : value_() {}

    explicit ValueHolder(const T& value) : value_(value) {}

 

    T* pointer() { return &value_; }

 

   private:

    T value_;

    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);

  };

 

  static pthread_key_t CreateKey() {

    pthread_key_t key;

    // When a thread exits, DeleteThreadLocalValue() will be called on

    // the object managed for that thread.

    GTEST_CHECK_POSIX_SUCCESS_(

        pthread_key_create(&key, &DeleteThreadLocalValue));

    return key;

  }

 

  T* GetOrCreateValue() const {

    ThreadLocalValueHolderBase* const holder =

        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));