partest.tar

partest/ 40777      0      0           0 12401571210   5550 5partest/CMakeLists.txt100777      0      0        1631 12401571210  10411 0project (project_partest)

file(GLOB_RECURSE PARTEST_CPP_SOURCES "src/*.cc" "src/*.h")
file(GLOB_RECURSE PARTEST_CPP_HEADERS "include/partest/*.h")
file(GLOB_RECURSE PARTEST_TEST_SOURCES "test/*.cc" "test/*.h")

# Execute the GroupSources macro
include(../../CMakeCommon/GroupSourcesMSVC.cmake)
GroupSourcesMSVC(partest)
GroupSourcesMSVC(src)
GroupSourcesMSVC(test)

if(CMAKE_COMPILER_IS_GNUCXX)
  if (use_exceptions STREQUAL ON)
  else()
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPARTEST_DISABLE_EXCEPTIONS")
  endif()
endif()
if(MSVC)
  if (use_exceptions STREQUAL ON)
  else()
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /DPARTEST_DISABLE_EXCEPTIONS")
  endif()
endif()

include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)

add_library (partest ${PARTEST_CPP_SOURCES} ${PARTEST_CPP_HEADERS} )
add_executable (partest_test ${PARTEST_TEST_SOURCES})

target_link_libraries(partest_test partest ${compiler_libs})
partest/include/ 40777      0      0           0 12401571161   7200 5partest/include/partest/ 40777      0      0           0 12401571161  10662 5partest/include/partest/internal/ 40777      0      0           0 12401571161  12476 5partest/include/partest/internal/allocate.h100777      0      0        5031 12377315321  14540 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_ALLOCATE_H_
#define PARTEST_INTERNAL_ALLOCATE_H_

#include <cstdlib>

// Size of cache lines (usually at most 64 Bytes)
#define CACHE_LINE_SIZE 64

namespace partest {
namespace internal {
/** Create cache-aligned object.
 * This function is used to avoid false sharing, since it guarantees
 * that two different objects never share the same cache line.
 * \tparam T Type of object
 * \param init Initial value
 * \return Pointer to newly created object
 * \see aligned_delete
 */
template<typename T>
inline T* aligned_new(const T& init) {
#if _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600
  void *ptr;
  if(posix_memalign(&ptr, CACHE_LINE_SIZE, sizeof(T)) != 0)
    throw;
  return new(ptr) T(init);
#else
  return new T(init);
#endif
}

/** Delete cache-aligned object.
 * Destroys a cache-aligned object and frees the memory.
 * \tparam T Type of object
 * \param ptr Pointer to object
 * \see aligned_new
 */
template<typename T>
inline void aligned_delete(T* ptr) {
#if _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600
  ptr->~T();
  free(static_cast<void*>(ptr));
#else
  delete ptr;
#endif
}

}  // namespace internal
}  // namespace partest
#endif  // PARTEST_INTERNAL_ALLOCATE_H_
partest/include/partest/internal/exceptions.h100777      0      0        6233 12377315321  15142 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_EXCEPTIONS_H_
#define PARTEST_INTERNAL_EXCEPTIONS_H_

#include <string>
#include <exception>

namespace partest {
namespace internal {

/**
 * Abstract base class for any exception in PARTEST.
 */
class Exception : public std::exception {
 public:
  /**
   * Constructs an exception with a custom message.
   */
  Exception(const char* message) : message_(message) {}

  /**
   * Destructor.
   */
  virtual ~Exception() throw() {}

  /**
   * Copy constructor.
   */
  Exception(const Exception& e) : message_(e.message_) {}

  /**
   * Assignment operator.
   */
  Exception& operator=(const Exception& e) {
    message_ = e.message_;
    return *this;
  }

  /**
   * Returns exception message.
   */
  virtual const char* what() const throw() { return message_; }

 private:
  /**
   * Holds exception message.
   */
  const char* message_;
};

/**
 * Indicates a lack of memory neccessary to allocate a resource.
 */
class NoMemoryException : public Exception {
 public:
  NoMemoryException(const char* message) : Exception(message) {}
};

/**
 * Indicates the busyness and, hence, unavailability of a required resource.
 */
class ResourceBusyException : public Exception {
 public:
  ResourceBusyException(const char* message) : Exception(message) {}
};

/**
 * Indicates a numeric underflow.
 */
class UnderflowException : public Exception {
 public:
  UnderflowException(const char* message) : Exception(message) {}
};

/**
 * Indicates a numeric overflow.
 */
class OverflowException : public Exception {
 public:
  OverflowException(const char* message) : Exception(message) {}
};

/**
 * Indicates a general error.
 */
class ErrorException : public Exception {
 public:
  ErrorException(const char* message) : Exception(message) {}
};

} // namespace internal
} // namespace partest

#endif /* PARTEST_INTERNAL_EXCEPTIONS_H_ */
partest/include/partest/internal/function.h100777      0      0       11570 12377315322  14627 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_FUNCTION_H_
#define PARTEST_INTERNAL_FUNCTION_H_

#include <iostream>
#include <cstddef>
#include <cstdlib>

namespace partest {
namespace internal {
/**
 * Base class for functions.
 * An object of this class represents an executable piece of code, e.g.,
 * an ordinary function, a member function or a function object / functor.
 * Only functions with \c void return type and zero parameters are supported.
 * Each object also contains a reference counter for memory management.
 */

class FunctionBase {
 public:
  /**
   * Default constructor.
   * Creates a new object and initializes the reference counter with one.
   */
  FunctionBase() {
  }

  /**
   *  Destructor.
   *  Destroys the object
   */
  virtual ~FunctionBase() {
  }

  /**
   *  Function operator.
   *  Calls the function.
   */
  virtual void operator()() = 0;

 private:
  /**
   * Disallow copy constructor and assignment.
   */
  FunctionBase(const FunctionBase&);
  FunctionBase& operator=(const FunctionBase&);
};

/**
 *  Subclass for functions.
 *  An object of this class represents an ordinary function.
 */
class Function: public FunctionBase {
public:
  /**
   *  Constructor.
   *  Creates a new object from a function pointer.
   *  \param function_ptr Pointer to function
   */
  Function(void (*function_ptr)()) :
      fn_ptr(function_ptr) {
    if (function_ptr == NULL) {
      std::cerr << "Invalid function pointer" << std::endl;
      exit(EXIT_FAILURE);
    }
  }

  /** Function operator.
   * Calls the function.
   */
  void operator()() {
    (*fn_ptr)();
  }

private:
  void (*fn_ptr)();
  /**
   * Disallow copy constructor and assignment.
   */
  Function(const Function&);
  Function& operator=(const Function&);
};

/**
 * Subclass for member functions.
 * An object of this class represents a member function.
 * \tparam F Class of member function
 */
template<typename F>
class MemberFunction: public FunctionBase {
public:
  /**
   * Constructor.
   * Creates a new object from a pointer to a member function and a
   * Pointer to the associated object.
   * \param member_function_ptr Pointer to member function
   * \param object_ptr Pointer to object
   */
  MemberFunction(void (F::*member_function_ptr)(), F* object_ptr) :
      mem_fn_ptr(member_function_ptr), obj_ptr(object_ptr) {
    if (member_function_ptr == NULL || object_ptr == NULL) {
      std::cerr << "Invalid pointer to member function or object" << std::endl;
      exit(EXIT_FAILURE);
    }
  }

  /**
   * Function operator.
   * Calls the member function.
   */
  void operator()() {
    (obj_ptr->*mem_fn_ptr)();
  }

private:
  void (F::*mem_fn_ptr)();
  F* obj_ptr;
  /**
   * Disallow copy constructor and assignment.
   */
  MemberFunction(const MemberFunction&);
  MemberFunction& operator=(const MemberFunction&);
};

/**
 *  Subclass for function objects.
 *  An object of this class represents a function object.
 *  \param F Class of function object.
 */
template<typename F>
class FunctionObject: public FunctionBase {
public:
  /**
   * Constructor.
   * Creates a new object from a function object.
   * \param function_obj Function object
   */
  explicit FunctionObject(F function_obj) :
      fn_obj(function_obj) {
  }

  /**
   * Function operator.
   * Calls the function object.
   */
  void operator()() {
    fn_obj();
  }
private:
  F fn_obj;
  /**
   * Disallow copy constructor and assignment.
   */
  FunctionObject(const FunctionObject&);
  FunctionObject& operator=(const FunctionObject&);
};

}  // namespace internal
}  // namespace partest

#endif  // PARTEST_INTERNAL_FUNCTION_H_
partest/include/partest/internal/mutex-inl.h100777      0      0        4043 12377315322  14701 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_MUTEX_INL_H_
#define PARTEST_INTERNAL_MUTEX_INL_H_

namespace partest {
namespace internal {

template<typename Mutex>
UniqueLock<Mutex>::~UniqueLock() {
  if ((mutex_ != NULL) && locked_) {
    mutex_->Unlock();
  }
}

template<typename Mutex>
void UniqueLock<Mutex>::Lock() {
  mutex_->Lock();
}

template<typename Mutex>
bool UniqueLock<Mutex>::TryLock() {
  return mutex_->TryLock();
}

template<typename Mutex>
void UniqueLock<Mutex>::Unlock() {
  mutex_->Unlock();
}

template<typename Mutex>
Mutex* UniqueLock<Mutex>::Release() {
  Mutex* toRelease = mutex_;
  mutex_ = NULL;
  return toRelease;
}

} // namespace internal
} // namespace mutex

#endif /* PARTEST_INTERNAL_MUTEX_INL_H_ */
partest/include/partest/internal/mutex.h100777      0      0       12233 12377315322  14141 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_MUTEX_H_
#define PARTEST_INTERNAL_MUTEX_H_

#include <partest/internal/partestThreads/mutex_implementation.h>

namespace partest {
namespace internal {

/**
 * Abstraction for non-recursive, exclusive mutex.
 */
class Mutex {
 public:
  /**
   * Creates a mutex which is in unlocked state.
   */
  Mutex();

  /**
   * Frees used resources.
   */
  ~Mutex();

  /**
   * Waits until mutex is unlocked and locks it.
   *
   * Precondition: Mutex has not been locked by this thread. Otherwise undefined
   *   behavior.
   */
  void Lock();

  /**
   * Locks the mutex if unlocked and returns true in that case. Does not wait.
   *
   * Precondition: Mutex has not been locked by this thread. Otherwise undefined
   *   behavior.
   */
  bool TryLock();

  /**
   * Unlocks a locked mutex by the thread that locked it.
   *
   * Precondition: This thread has previously locked the mutex. Otherwise,
   * undefined behavior.
   */
  void Unlock();

 private:
  /**
   * Holds the actual mutex.
   */
  partestthreads::MutexImplementation mutex_;

  /**
   * Disables copy construction and assignment.
   */
  Mutex(const Mutex&);
  Mutex& operator=(const Mutex&);
};

/**
 * Realizes a scoped lock (according to the RAII principle) using a mutex.
 *
 * The mutex is locked on construction and unlocked on leaving the scope of
 * definition of the lock guard, in its constructor.
 */
template<typename Mutex>
class LockGuard {
public:
  /**
   * Creates the lock and locks the mutex.
   */
  LockGuard(Mutex& mutex) :
      mutex_(mutex) {
    mutex_.Lock();
  }

  /**
   * Unlocks the mutex.
   */
  ~LockGuard() {
    mutex_.Unlock();
  }

private:
  /**
   * Holds reference to mutex realizing the lock.
   */
  Mutex& mutex_;

  /**
   * Disable copy construction and assignment.
   */
  LockGuard(const LockGuard<Mutex>&);
  LockGuard<Mutex>& operator=(const LockGuard<Mutex>&);
};

/**
 * Flexible ownership wrapper for a mutex.
 *
 * Unlocks an owned mutex on destruction.
 */
template<typename Mutex>
class UniqueLock {
public:
  /**
   * Creates the lock without a mutex.
   */
  UniqueLock() :
      mutex_(NULL) {
  }

  /**
   * Creates the lock with a mutex.
   */
  UniqueLock(Mutex& mutex) :
      mutex_(&mutex) {
  }

  /**
   * Unlocks the mutex, if owned.
   */
  ~UniqueLock();

  /**
   * Waits until mutex is unlocked and locks it.
   *
   * Throws an exception if there is no associated mutex or the associated mutex
   * has already been locked by the unique lock.
   */
  void Lock();

  /**
   * Locks the mutex if unlocked and returns true in that case.
   *        Does not wait.
   *
   * Throws an exception if there is no associated mutex.
   *
   * @return True, if the mutex could be locked. False, otherwise.
   */
  bool TryLock();

  /**
   * Unlocks a locked mutex by the thread that locked it.
   *
   * Throws an exception if the mutex was not locked by the unique lock.
   */
  void Unlock();

  /**
   * Gives up ownership to the mutex and returns the mutex.
   *
   * @return A pointer to the owned mutex or NULL, if no mutex was owned.
   */
  Mutex* Release();

  /**
   * Returns the mutex or NULL, if none is owned.
   *
   * @return Pointer to owned mutex or NULL, if none is owned.
   */
  Mutex* mutex() {
    return mutex_;
  }

  /**
   * Returns true, if a mutex is associated and owned.
   */
  bool ownsLock() {
    return (mutex_ != NULL) && locked_;
  }

private:
  /**
   * Holds reference to mutex realizing the lock.
   */
  Mutex* mutex_;

  /**
   * Stores information about whether the unique lock as locked the mutex.
   */
  bool locked_;

  /**
   * Disable copy construction and assignment.
   */
  UniqueLock(const UniqueLock<Mutex>&);
  UniqueLock<Mutex>& operator=(const UniqueLock<Mutex>&);
};

} // namespace internal
} // namespace partest

#include <partest/internal/mutex-inl.h>

#endif // PARTEST_INTERNAL_MUTEX_H_
partest/include/partest/internal/partestThreads/ 40777      0      0           0 12401571161  15473 5partest/include/partest/internal/partestThreads/config.h100777      0      0        5107 12377315322  17223 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_PARTEST_THREADS_CONFIG_H_
#define PARTEST_INTERNAL_PARTEST_THREADS_CONFIG_H_

/* Define names:
 * - threading platforms: PARTEST_THREADING_
 * - compilers: PARTEST_COMPILER_
 * - oprating systems: PARTEST_OS_
 */

#if __GNUC__
#define PARTEST_INLINE static inline
#define PARTEST_COMPILER_GNUC
#elif _MSC_VER
#define PARTEST_INLINE __inline
#define PARTEST_COMPILER_MSVC
#else
#define PARTEST_INLINE inline
#define PARTEST_COMPILER_UNKNOWN
#endif

#if defined(__x86_64__) || defined(_M_X64)
#define PARTEST_ARCH_X86_64
#define PARTEST_ARCH_X86
#define PARTEST_HAS_CAS_64
#elif defined(__i386) || defined(_M_IX86)
#define PARTEST_ARCH_X86_32
#define PARTEST_ARCH_X86
#else
#define PARTEST_ARCH_UNKNOWN
#endif

/*#define PARTEST_THREADING_CXX11*//* Enables C++11 implementation */

#if defined(PARTEST_COMPILER_MSVC)
#define PARTEST_THREADING_WINTHREADS
#elif defined(PARTEST_COMPILER_GNUC)
#define PARTEST_THREADING_POSIXTHREADS
#else
#error "No thread implementation could be determined"
#endif

/* Disable exceptions in STL of MSVC. Leads to errors when used like this!!! */
/*#if defined(PARTEST_COMPILER_MSVC) && !defined(PARTEST_USE_EXCEPTIONS)
 #define _HAS_EXCEPTIONS 0
 #endif*/

#endif /* PARTEST_INTERNAL_PARTEST_THREADS_CONFIG_H_ */
partest/include/partest/internal/partestThreads/mutex_implementation.h100777      0      0        5464 12377315322  22233 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_PARTEST_THREADS_MUTEX_IMPLEMENTATION_H_
#define PARTEST_INTERNAL_PARTEST_THREADS_MUTEX_IMPLEMENTATION_H_

#include <partest/internal/partestThreads/platform.h>

namespace partest {
namespace internal {
namespace partestthreads {
/**
 * Implementation for non-recursive, exclusive mutex.
 */
class MutexImplementation {
 public:
  /**
   * Creates a mutex which is in unlocked state.
   */
  MutexImplementation();

  /**
   * Frees used resources.
   */
  ~MutexImplementation();

  /**
   * Waits until mutex is unlocked and locks it.
   *
   * Precondition: Mutex has not been locked by this thread. Otherwise undefined
   *   behavior.
   */
  void Lock();

  /**
   * Locks the mutex if unlocked and returns true in that case. Does not wait.
   *
   * Precondition: Mutex has not been locked by this thread. Otherwise undefined
   *   behavior.
   */
  bool TryLock();

  /**
   * Unlocks a locked mutex by the thread that locked it.
   *
   * Precondition: This thread has previously locked the mutex. Otherwise,
   * undefined behavior.
   */
  void Unlock();

 private:
  /**
   * Holds the actual mutex.
   */
  PartestInternalMutexImpl mutex_;

  /**
   * Disables copy construction and assignment.
   */
  MutexImplementation(const MutexImplementation&);
  MutexImplementation& operator=(const MutexImplementation&);
};
}  // namespace partestthreads
}  // namespace internal
}  // namespace partest
#endif /* PARTEST_INTERNAL_PARTEST_THREADS_MUTEX_IMPLEMENTATION_H_ */
partest/include/partest/internal/partestThreads/platform.h100777      0      0        5614 12377315322  17605 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_PARTEST_THREADS_PLATFORM_H_
#define PARTEST_INTERNAL_PARTEST_THREADS_PLATFORM_H_

/**
 * @file Contains threading platform specific includes, typedefs, and defines.
 */
#include <partest/internal/partestThreads/config.h>

#include <limits.h>

#ifdef PARTEST_THREADING_WINTHREADS


#define NOMINMAX
#include <windows.h>

namespace partest {
namespace internal {
namespace partestthreads {

typedef struct PartestInternalThreadArgs {
  int(*func)(void*);
  void* arg;
  int result;
} PartestInternalThreadArgs;


typedef HANDLE PartestInternalThreadImpl;
typedef CRITICAL_SECTION PartestInternalMutexImpl;
typedef DWORD PartestInternalTSSImpl;
} // namespace partestthreads
} // namespace internal
} // namespace partest


#elif defined PARTEST_THREADING_POSIXTHREADS // PARTEST_THREADING_WINTHREADS

#include <pthread.h>
#include <errno.h>
#include <time.h>

namespace partest {
namespace internal {
namespace partestthreads {


typedef pthread_t PartestInternalThreadImpl;
typedef pthread_mutex_t PartestInternalMutexImpl;
typedef pthread_key_t PartestInternalTSSImpl;

/**
 * Used to wrap client thread start function and argument when calling internal
 * thread start function Partest_InternalThreadStart.
 */
typedef struct PartestInternalThreadArgs {
  int(*func)(void*);
  void* arg;
  int result;
} PartestInternalThreadArgs;

} // namespace partestthreads
} // namespace internal
} // namespace partest

#else // PARTEST_THREADING_POSIXTHREADS

#error "No threading platform defined!"

#endif // else


#endif /* PARTEST_INTERNAL_PARTEST_THREADS_PLATFORM_H_ */
partest/include/partest/internal/partestThreads/thread_closures.h100777      0      0        6532 12377315322  21147 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_PARTEST_THREADS_THREAD_CLOSURES_H_
#define PARTEST_INTERNAL_PARTEST_THREADS_THREAD_CLOSURES_H_

namespace partest {
namespace internal {
namespace partestthreads {

/**
 * Thread closure for thread start function with no arguments.
 *
 * Provides a thread start function calling a callable entity such as a function
 * pointer or functor.
 */
template<typename Function>
struct ThreadClosure {
  Function function_;

  static int ThreadStart(void* arg) {
    ThreadClosure *self = static_cast<ThreadClosure*>(arg);
    self->function_();
    delete self;
    return 0;
  }

  ThreadClosure(const Function& function) :
      function_(function) {
  }
};

/**
 * Thread closure for thread start function with one argument.
 *
 * Provides a thread start function calling a callable entity such as a function
 * pointer or functor.
 */
template<typename Function, typename Arg1>
struct ThreadClosureArg1 {
  Function function_;
  Arg1 arg1_;

  static int ThreadStart(void* arg) {
    ThreadClosureArg1 *self = static_cast<ThreadClosureArg1*>(arg);
    self->function_(self->arg1_);
    delete self;
    return 0;
  }

  ThreadClosureArg1(const Function& function, const Arg1& arg1) :
      function_(function), arg1_(arg1) {
  }
};

/**
 * Thread closure for thread start function with two arguments.
 *
 * Provides a thread start function calling a callable entity such as a function
 * pointer or functor.
 */
template<typename Function, typename Arg1, typename Arg2>
struct ThreadClosureArg2 {
  Function function_;
  Arg1 arg1_;
  Arg2 arg2_;

  static int ThreadStart(void* arg) {
    ThreadClosureArg2 *self = static_cast<ThreadClosureArg2*>(arg);
    self->function_(self->arg1_, self->arg2_);
    delete self;
    return 0;
  }

  ThreadClosureArg2(const Function& function, const Arg1& arg1,
      const Arg2& arg2) :
      function_(function), arg1_(arg1), arg2_(arg2) {
  }
};

}  // namespace partestthreads
} // namespace internal
} // namespace partest

#endif /* PARTEST_INTERNAL_PARTEST_THREADS_THREAD_CLOSURES_H_ */
partest/include/partest/internal/partestThreads/thread_implementation-inl.h100777      0      0        6437 12377315322  23121 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_PARTEST_THREADS_THREAD_IMPLEMENTATION_INL_H_
#define PARTEST_INTERNAL_PARTEST_THREADS_THREAD_IMPLEMENTATION_INL_H_

#include <partest/internal/partestThreads/thread_closures.h>
#include <partest/internal/exceptions.h>

namespace partest {
namespace internal {
namespace partestthreads {

template<typename Callable>
ThreadImplementation::ThreadImplementation(Callable function) :
    threadHandle_() {
  ThreadClosure<Callable>* closure = new ThreadClosure<Callable>(function);
  bool result = Create_thread(ThreadClosure<Callable>::ThreadStart,
      static_cast<void*>(closure));
  CheckThreadCreationErrors(result, closure);
}

template<typename Callable, typename Arg1>
ThreadImplementation::ThreadImplementation(Callable function, Arg1 arg1) :
    threadHandle_() {
  ThreadClosureArg1<Callable, Arg1>* closure = new ThreadClosureArg1<Callable,
      Arg1>(function, arg1);
  bool result = Create_thread(ThreadClosureArg1<Callable, Arg1>::ThreadStart,
      static_cast<void*>(closure));
  CheckThreadCreationErrors(result, closure);
}

template<typename Callable, typename Arg1, typename Arg2>
ThreadImplementation::ThreadImplementation(Callable function, Arg1 arg1,
    Arg2 arg2) :
    threadHandle_() {
  ThreadClosureArg2<Callable, Arg1, Arg2>* closure = new ThreadClosureArg2<
      Callable, Arg1, Arg2>(function, arg1, arg2);
  bool result = Create_thread(
      ThreadClosureArg2<Callable, Arg1, Arg2>::ThreadStart,
      static_cast<void*>(closure));
  CheckThreadCreationErrors(result, closure);
}

template<typename ThreadClosure>
void ThreadImplementation::CheckThreadCreationErrors(bool result,
    ThreadClosure* closure) {
  if (result != true) {
    if (closure != NULL) {
      delete closure;
    }
    const char* message = "Could not create thread.";
    throw ErrorException(message);
  }
}
} // namespace partestthreads
} // namespace internal
} // namespace partest

#endif /* PARTEST_INTERNAL_PARTEST_THREADS_THREAD_IMPLEMENTATION_INL_H_ */
partest/include/partest/internal/partestThreads/thread_implementation.h100777      0      0       10642 12377315322  22352 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_PARTEST_THREADS_THREAD_IMPLEMENTATION_H_
#define PARTEST_INTERNAL_PARTEST_THREADS_THREAD_IMPLEMENTATION_H_

#include <partest/internal/partestThreads/platform.h>
#include <partest/internal/partestThreads/thread_closures.h>

namespace partest {
namespace internal {
namespace partestthreads {
/**
 * An object of this class represents a thread of execution.
 *
 */
class ThreadImplementation {

 public:
  /**
   * Creates and runs a thread with zero-argument thread start function.
   *
   * Pitfall: If function is constructed as temporary when creating a thread,
   * this might be interpreted as function definition. This is defined by the
   * standard and known as "most vexing parse". C++11 resolves this by using
   * curly braces for initialization.
   */
  template<typename Callable>
  ThreadImplementation(Callable function); /**<
   [IN] Callable (with no arguments) and copyable entity. */

  /**
   * Creates and runs a thread with one-argument thread start function.
   *
   * Pitfall: If function and arg are constructed as temporaries when creating
   * a thread, this might be interpreted as function definition. This is defined
   * by the standard and known as "most vexing parse". C++11 resolves this by using
   * curly braces for initialization.
   */
  template<typename Callable, typename Arg>
  ThreadImplementation(Callable function, /**<
   [IN] Callable (with one argument) and copyable entity. */
  Arg arg /**<
   [IN] Copyable argument for function. */
  );

  /**
   * Creates and runs a thread with two-argument thread start function.
   *
   * Pitfall: If function, arg1, and arg2 are constructed as temporaries when
   * creating a thread, this might be interpreted as function definition. This
   * is defined by the standard and known as "most vexing parse". C++11 resolves
   * this by using curly braces for initialization.
   */
  template<typename Callable, typename Arg1, typename Arg2>
  ThreadImplementation(Callable function, /**<
   [IN] Callable (with one argument) and copyable entity. */
  Arg1 arg1, /**<
   [IN] Copyable first argument for function. */
  Arg2 arg2 /**<
   [IN] Copyable second argument for function. */
  );

  /**
   * Join thread
   * Waits until the thread is completed (\c *this must not be empty).
   */
  bool Join();

 private:
  PartestInternalThreadImpl threadHandle_;
  PartestInternalThreadArgs *threadArgs_;

  bool Create_thread(int (*function)(void*), void * args);

  /**
   * Performs error checks and frees resources from thread constructor.
   */
  template<typename ThreadClosure>
  void CheckThreadCreationErrors(bool result, /**< [IN] Result value of creating thread with C API */
  ThreadClosure* closure /**< [IN] Closure used when creating thread */
  );

  ThreadImplementation();
  ThreadImplementation(const ThreadImplementation& thr);
  ThreadImplementation& operator=(const ThreadImplementation& thr);
};
}  // namespace partestthreads
}  // namespace internal
}  // namespace partest

#include<partest/internal/partestThreads/thread_implementation-inl.h>

#endif /* PARTEST_INTERNAL_PARTEST_THREADS_THREAD_IMPLEMENTATION_H_ */
partest/include/partest/internal/partestThreads/thread_specific_storage_implementation.h100777      0      0        5071 12377315322  25723 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_PARTEST_THREADS__TSS_IMPLEMENTATION_H_
#define PARTEST_INTERNAL_PARTEST_THREADS__TSS_IMPLEMENTATION_H_

#include <partest/internal/partestThreads/platform.h>

namespace partest {
namespace internal {
namespace partestthreads {
/**
 * An object of this class represents a TSS Object
 */
class ThreadSpecificStorageImplementation {
 public:
  /**
   * Creates a TSS storage with NULL pointer as initial value.
   */
  ThreadSpecificStorageImplementation();

  /**
   * Destructs a TSS value, if not NULL.
   */
  ~ThreadSpecificStorageImplementation();

  /**
   * Returns a pointer to the value, by default NULL.
   */
  void set(void* newValue) const;

  /**
   * Returns a pointer to the value, by default NULL.
   */
  void* get() const;

 private:
  /**
   * Handle for the threading API.
   */
  PartestInternalTSSImpl handle_;

  /**
   * Disables copy construction and assignment.
   */
  ThreadSpecificStorageImplementation(const ThreadSpecificStorageImplementation&);
  ThreadSpecificStorageImplementation& operator=(
      const ThreadSpecificStorageImplementation&);
};
}  // namespace partestthreads
}  // namespace internal
}  // namespace partest
#endif /* PARTEST_INTERNAL_PARTEST_THREADS__TSS_IMPLEMENTATION_H_ */
partest/include/partest/internal/test_case-inl.h100777      0      0        4013 12377315322  15506 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_TEST_CASE_INL_H_
#define PARTEST_INTERNAL_TEST_CASE_INL_H_

namespace partest {

template<typename Unit>
Unit& TestCase::CreateUnit() {
  Unit *testUnit = new Unit();
  test_units_.push_back(testUnit);
  return *testUnit;
}

template<typename Unit, typename Arg1>
Unit& TestCase::CreateUnit(Arg1 arg1) {
  Unit *testUnit = new Unit(arg1);
  test_units_.push_back(testUnit);
  return *testUnit;
}

template<typename Unit, typename Arg1, typename Arg2>
Unit& TestCase::CreateUnit(Arg1 arg1, Arg2 arg2) {
  Unit *testUnit = new Unit(arg1, arg2);
  test_units_.push_back(testUnit);
  return *testUnit;
}

}  // namespace partest

#endif  // PARTEST_INTERNAL_TEST_CASE_INL_H_
partest/include/partest/internal/test_method-inl.h100777      0      0        3743 12377315322  16064 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_TEST_METHOD_INL_H_
#define PARTEST_INTERNAL_TEST_METHOD_INL_H_

namespace partest {

template<typename F>
inline TestMethod::TestMethod(void (F::*member_function)(), F* object,
    size_t instances, size_t iterations) :
    fn_base_(new partest::internal::MemberFunction<F>(member_function, object)) {
  Init(instances, iterations);
}

template<typename F>
inline TestMethod::TestMethod(F function_object, size_t instances,
    size_t iterations) :
    fn_base_(new partest::internal::FunctionObject<F>(function_object)) {
  Init(instances, iterations);
}

}  // namespace partest

#endif /* PARTEST_INTERNAL_TEST_METHOD_INL_H_ */
partest/include/partest/internal/test_unit-inl.h100777      0      0        4764 12377315323  15570 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_TEST_UNIT_INL_H_
#define PARTEST_INTERNAL_TEST_UNIT_INL_H_

namespace partest {

template<typename F>
TestUnit& TestUnit::Add(void (F::*member_function)(), F* object,
    size_t instances, size_t iterations) {
  Add(new TestMethod(member_function, object, instances, iterations));
  return *this;
}

template<typename F>
TestUnit& TestUnit::Add(F function_object, size_t instances,
    size_t iterations) {
  Add(new TestMethod(function_object, instances, iterations));
  return *this;
}

template<typename F>
TestUnit& TestUnit::Pre(void (F::*member_function)(), F* object) {
  AddPre(new TestMethod(member_function, object, 1, 1));
  return *this;
}

template<typename F>
TestUnit& TestUnit::Pre(F function_object) {
  AddPre(new TestMethod(function_object, 1, 1));
  return *this;
}

template<typename F>
TestUnit& TestUnit::Post(void (F::*member_function)(), F* object) {
  AddPost(new TestMethod(member_function, object, 1, 1));
  return *this;
}

template<typename F>
TestUnit& TestUnit::Post(F function_object) {
  AddPost(new TestMethod(function_object, 1, 1));
  return *this;
}

} // namespace partest

#endif /* PARTEST_INTERNAL_TEST_UNIT_INL_H_ */
partest/include/partest/internal/thread.h100777      0      0        6253 12377315323  14234 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_THREAD_H_
#define PARTEST_INTERNAL_THREAD_H_

#include<partest/internal/partestThreads/thread_implementation.h>

namespace partest {
class TestInstanceInfo;
namespace internal {
/**
 * Wrapper class for threads.
 * An object of this class represents a thread of execution.
 */
class Thread {
 public:

  /**
   * Creates and runs a thread with one-argument thread start function.
   *
   * Pitfall: If function and arg are constructed as temporaries when creating
   * a thread, this might be interpreted as function definition. This is defined
   * by the standard and known as "most vexing parse". C++11 resolves this by using
   * curly braces for initialization.
   */
  Thread(int (*function)(partest::TestInstanceInfo*), /**<
   [IN] Callable (with one argument) and copyable entity. */
   partest::TestInstanceInfo* args /**<
   [IN] Copyable argument for function. */
  );


  /**
   * Creates and runs a thread with one-argument thread start function.
   *
   * Pitfall: If function and arg are constructed as temporaries when creating
   * a thread, this might be interpreted as function definition. This is defined
   * by the standard and known as "most vexing parse". C++11 resolves this by using
   * curly braces for initialization.
   */
  Thread(int (*function)(void*), /**<
   [IN] Callable (with one argument) and copyable entity. */
   void * args /**<
   [IN] Copyable argument for function. */
  );

  /**
   * Join thread
   * Waits until the thread is completed (\c *this must not be empty).
   */
  void Join();

 private:
  partestthreads::ThreadImplementation threadHandle_;

  /*
   * Disable empty constructor, copy constructor and assignment
   * */
  Thread();
  Thread(const Thread& thr);
  Thread& operator=(const Thread& thr);
};

}  // namespace internal
}  // namespace partest

#endif /* PARTEST_INTERNAL_THREAD_H_ */
partest/include/partest/internal/thread_specific_storage-inl.h100777      0      0        5136 12377315323  20404 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_THREAD_SPECIFIC_STORAGE_INL_H_
#define PARTEST_INTERNAL_THREAD_SPECIFIC_STORAGE_INL_H_

namespace partest {
namespace internal {

template<typename Type>
ThreadSpecificStorage<Type>::ThreadSpecificStorage() :
    handle_() {
}

template<typename Type>
ThreadSpecificStorage<Type>::~ThreadSpecificStorage() {
  void* value = handle_.get();
  if (value != NULL) {
    delete static_cast<Type*>(value);
  }
}

template<typename Type>
Type* ThreadSpecificStorage<Type>::get() const {
  return static_cast<Type*>(handle_.get());
}

template<typename Type>
Type* ThreadSpecificStorage<Type>::operator->() const {
  return static_cast<Type*>(handle_.get());
}

template<typename Type>
Type& ThreadSpecificStorage<Type>::operator*() {
  return *static_cast<Type*>(handle_.get());
}

template<typename Type>
Type* ThreadSpecificStorage<Type>::Release() {
  Type* value = static_cast<Type*>(handle_.get());
  handle_.set(NULL);
  return value;
}

template<typename Type>
void ThreadSpecificStorage<Type>::Reset(Type* newValue) {
  Type* value = static_cast<Type*>(handle_.get());
  if (value != NULL)
    delete value;
  handle_.set(static_cast<void*>(newValue));
}

} // namespace internal
} // namespace partest

#endif /* PARTEST_INTERNAL_THREAD_SPECIFIC_STORAGE_INL_H_ */
partest/include/partest/internal/thread_specific_storage.h100777      0      0        6344 12377315323  17626 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_INTERNAL_THREAD_SPECIFIC_STORAGE_H_
#define PARTEST_INTERNAL_THREAD_SPECIFIC_STORAGE_H_

#include <partest/internal/partestThreads/thread_specific_storage_implementation.h>

namespace partest {
namespace internal {

/**
 * Provides a thread specific (or local) storage (TSS) abstraction.
 *
 * The TSS acts as a pointer and provides a similar interface. In order to add
 * a value to the TSS, the method Reset has to be used with a user allocated
 * memory for the value. The TSS takes care of deleting the memory then, or the
 * user (thread) can take over again by calling Release.
 */
template<typename Type>
class ThreadSpecificStorage {
 public:
  /**
   * Creates a TSS storage with NULL pointer as initial value.
   */
  ThreadSpecificStorage();

  /**
   * Destructs a TSS value, if not NULL.
   */
  ~ThreadSpecificStorage();

  /**
   * Returns a pointer to the value, by default NULL.
   */
  Type* get() const;

  /**
   * Returns pointer to value, enabling access to member of Type via ->.
   */
  Type* operator->() const;

  /**
   * Returns dereferenced pointer to value.
   *
   * Pre-condition: value needs to be unequal NULL.
   */
  Type& operator*();

  /**
   * Returns a pointer to the value and sets the value to be NULL.
   *
   * Does not delete the memory of the value.
   */
  Type* Release();

  /**
   * Replaces value by new one and deletes the previous value (if not NULL).
   */
  void Reset(Type* newValue = NULL);

 private:
  /**
   * Handle for the threading API.
   */
  partestthreads::ThreadSpecificStorageImplementation handle_;

  /**
    * Disallow copy constructor and assignment.
    */
  ThreadSpecificStorage(const ThreadSpecificStorage&);
  ThreadSpecificStorage& operator=(const ThreadSpecificStorage&);
};

} // namespace internal
} // namespace partest

#include <partest/internal/thread_specific_storage-inl.h>

#endif /* PARTEST_INTERNAL_THREAD_SPECIFIC_STORAGE_H_ */
partest/include/partest/partest.h100777      0      0       17573 12377315323  12662 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_PARTEST_H_
#define PARTEST_PARTEST_H_

#include <partest/test_unit.h>
#include <partest/test_case.h>
#include <partest/test_suite.h>
#include <partest/test_instance_info.h>

// For some versions of Sun CC, __func__ is only defined if the option -features=extensions is specified.
#if defined(__GNUC__) || defined(__INTEL_COMPILER)
#define PT_FUNCTION __PRETTY_FUNCTION__
#elif defined(_MSC_VER)
#define PT_FUNCTION __FUNCSIG__
#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
#define PT_FUNCTION __func__
#else
#define PT_FUNCTION "<unknown>"
#endif

// Internal macros (should not be used by developers or testers)

#define PT_STR(STR) #STR

#define PT_CHECK(EXPR, MSG, TERM) \
  partest::TestSuite::Check(EXPR, PT_STR(EXPR), __FILE__, PT_FUNCTION, __LINE__, MSG, TERM);

#define PT_CHECK_OP(EXPR1, EXPR2, REL_OP, MSG, TERM) \
  partest::TestSuite::Check(EXPR1, REL_OP(), EXPR2, PT_STR(EXPR1), PT_STR(EXPR2), __FILE__, PT_FUNCTION, __LINE__, MSG, TERM);

#define PT_RUN(PT_TEST) \
( \
  (std::cout << "Running " << #PT_TEST << " ..." << std::endl), \
  (PT_TEST().Run()), \
  (std::cout << "Running " << #PT_TEST << " ..." << " done" << std::endl) \
)

#define PT_MAIN(component) \
void PartestRunTests(); \
int main(int argc, char** argv) { \
  std::cout << "Running "<< component <<" tests ..." << std::endl; \
  if (argc > 1) { \
    size_t num_threads = static_cast<size_t>(atoi(argv[1])); \
    partest::TestSuite::SetDefaultNumThreads(num_threads); \
  } \
  if (argc > 2) { \
    size_t num_iterations = static_cast<size_t>(atoi(argv[2])); \
    partest::TestSuite::SetDefaultNumIterations(num_iterations); \
  } \
  PartestRunTests(); \
  std::cout << "Running "<< component <<" tests ... done" << std::endl; \
  std::cout << "Failed checks: " << partest::TestSuite::GetFailedExpects() << \
  " out of " << partest::TestSuite::GetFailedExpects() + \
  partest::TestSuite::GetPassedExpects() + \
  partest::TestSuite::GetPassedAsserts() << " total checks" <<std::endl; \
  return static_cast<int>(partest::TestSuite::GetFailedExpects()); \
} \
void PartestRunTests()


namespace partest {
namespace internal {
  struct REL_EQ;
  struct REL_NE;
  struct REL_LT;
  struct REL_LE;
  struct REL_GT;
  struct REL_GE;

/** Comparison (equal).
 *
 */
struct REL_EQ {
  template<typename T1, typename T2>
  bool operator()(T1 value1, T2 value2) const {
    return value1 == value2;
  }
  const char* get_op() const {
    return "==";
  }
  typedef REL_NE inverse_t;
};

/** Comparison (not equal)
 *
 */
struct REL_NE {
  template<typename T1, typename T2>
  bool operator()(T1 value1, T2 value2) const {
    return value1 != value2;
  }
  const char* get_op() const {
    return "!=";
  }
  typedef REL_EQ inverse_t;
};

/** Comparison (less than)
 *
 */
struct REL_LT {
  template<typename T1, typename T2>
  bool operator()(T1 value1, T2 value2) const {
    return value1 < value2;
  }
  const char* get_op() const {
    return "<";
  }
  typedef REL_GE inverse_t;
};

/** Comparison (less than or equal)
 *
 */
struct REL_LE {
  template<typename T1, typename T2>
  bool operator()(T1 value1, T2 value2) const {
    return value1 <= value2;
  }
  const char* get_op() const {
    return "<=";
  }
  typedef REL_GT inverse_t;
};

/** Comparison (greater than)
 *
 */
struct REL_GT {
  template<typename T1, typename T2>
  bool operator()(T1 value1, T2 value2) const {
    return value1 > value2;
  }
  const char* get_op() const {
    return ">";
  }
  typedef REL_LE inverse_t;
};

/** Comparison (greater than or equal)
 *
 */
struct REL_GE {
  template<typename T1, typename T2>
  bool operator()(T1 value1, T2 value2) const {
    return value1 >= value2;
  }
  const char* get_op() const {
    return ">=";
  }
  typedef REL_LT inverse_t;
};

}  // namespace internal
}  // namespace partest

// Unary predicates

#define PT_ASSERT(EXPR) PT_CHECK(EXPR, NULL, true)
#define PT_EXPECT(EXPR) PT_CHECK(EXPR, NULL, false)

#define PT_ASSERT_MSG(EXPR, MSG) PT_CHECK(EXPR, MSG, true)
#define PT_EXPECT_MSG(EXPR, MSG) PT_CHECK(EXPR, MSG, false)

// Binary predicates (general)

#define PT_ASSERT_EQ(EXPR1, EXPR2) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_EQ, NULL, true)
#define PT_ASSERT_NE(EXPR1, EXPR2) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_NE, NULL, true)
#define PT_ASSERT_LT(EXPR1, EXPR2) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_LT, NULL, true)
#define PT_ASSERT_LE(EXPR1, EXPR2) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_LE, NULL, true)
#define PT_ASSERT_GT(EXPR1, EXPR2) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_GT, NULL, true)
#define PT_ASSERT_GE(EXPR1, EXPR2) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_GE, NULL, true)

#define PT_EXPECT_EQ(EXPR1, EXPR2) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_EQ, NULL, false)
#define PT_EXPECT_NE(EXPR1, EXPR2) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_NE, NULL, false)
#define PT_EXPECT_LT(EXPR1, EXPR2) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_LT, NULL, false)
#define PT_EXPECT_LE(EXPR1, EXPR2) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_LE, NULL, false)
#define PT_EXPECT_GT(EXPR1, EXPR2) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_GT, NULL, false)
#define PT_EXPECT_GE(EXPR1, EXPR2) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_GE, NULL, false)

// Binary predicates (general with messages)

#define PT_ASSERT_EQ_MSG(EXPR1, EXPR2, MSG) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_EQ, MSG, true)
#define PT_ASSERT_NE_MSG(EXPR1, EXPR2, MSG) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_NE, MSG, true)
#define PT_ASSERT_LT_MSG(EXPR1, EXPR2, MSG) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_LT, MSG, true)
#define PT_ASSERT_LE_MSG(EXPR1, EXPR2, MSG) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_LE, MSG, true)
#define PT_ASSERT_GT_MSG(EXPR1, EXPR2, MSG) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_GT, MSG, true)
#define PT_ASSERT_GE_MSG(EXPR1, EXPR2, MSG) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_GE, MSG, true)

#define PT_EXPECT_EQ_MSG(EXPR1, EXPR2, MSG) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_EQ, MSG, false)
#define PT_EXPECT_NE_MSG(EXPR1, EXPR2, MSG) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_NE, MSG, false)
#define PT_EXPECT_LT_MSG(EXPR1, EXPR2, MSG) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_LT, MSG, false)
#define PT_EXPECT_LE_MSG(EXPR1, EXPR2, MSG) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_LE, MSG, false)
#define PT_EXPECT_GT_MSG(EXPR1, EXPR2, MSG) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_GT, MSG, false)
#define PT_EXPECT_GE_MSG(EXPR1, EXPR2, MSG) PT_CHECK_OP(EXPR1, EXPR2, partest::internal::REL_GE, MSG, false)

#endif  // PARTEST_PARTEST_H_
partest/include/partest/test_case.h100777      0      0        6533 12377315323  13124 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_TEST_CASE_H_
#define PARTEST_TEST_CASE_H_

#include <vector>
#include <string>

namespace partest {

class TestUnit;

/** Creates, manages, and sequentially runs (related) test units.
 *
 * A test case can be either created as empty test case, or can be used to
 * derive a user test case by inheriting from it.
 *
 * Default (empty) test units or user defined test units can be created by a
 * test case and are managed and run by it in a sequential manner. The test
 * units of a test case can be run several times and are destructed on
 * destruction of the test case only.
 */
class TestCase {
 public:
  /** Constructs an empty test case.
   */
  TestCase();

  /** Deletes created test units.
   */
  virtual ~TestCase();

  /** Runs all created test units in a sequentialized order.
   */
  void Run();

  /** Creates a default (empty) test unit.
   *  @return Reference to created test unit.
   */
  TestUnit& CreateUnit(const std::string& name /**<
   [IN] Name or short description of test unit */
  );

  /** Creates a subclass of TestUnit using its default constructor.
   * Can be used to create user defined test units.
   */
  template<typename Unit>
  Unit& CreateUnit();

  /** Creates a subclass of TestUnit using its one argument constructor.
   *  Can be used to create user defined test units.
   */
  template<typename Unit, typename Arg1>
  Unit& CreateUnit(Arg1 arg1 /**<
   [IN] Copyable argument for the constructor of Unit */
  );

  /** Creates a subclass of TestUnit using its two arguments constructor.
   * Can be used to create user defined test units.
   */
  template<typename Unit, typename Arg1, typename Arg2>
  Unit& CreateUnit(Arg1 arg1, /**<
   [IN] Copyable first argument for the constructor of Unit */
  Arg2 arg2 /**<
   [IN] Copyable second argument for the constructor of Unit */
  );

 private:
  /** Contains all created test units.
   */
  std::vector<partest::TestUnit*> test_units_;
};

}  // namespace partest

#include <partest/internal/test_case-inl.h>

#endif  // PARTEST_TEST_CASE_H_
partest/include/partest/test_instance_info.h100777      0      0       11742 12377315323  15046 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_TEST_INSTANCE_INFO_H_
#define PARTEST_TEST_INSTANCE_INFO_H_

#include <cstddef>

#include <partest/test_method.h>

namespace partest {

/** Test instance Information.
 * A test instance represents an instance of a running test method. It contains all the information identifying the
 * instance (Testmethod,thread_num, instance_num, iteration_num, Affinity ).
 * Multiple instances of a test method may be executed in parallel.
 */

class TestInstanceInfo {
 public:
  /** Constructor.
   * Creates an instance of the specified test method.
   */
  TestInstanceInfo(const std::string& unit_name_,/**<
   [IN] Name of the test unit */
  TestMethod *ptr /**<
   [IN] Pointer to test instance */
  );

  /** Copy constructor.
   *  Creates a copy of the specified test instance.
   */
  TestInstanceInfo(const TestInstanceInfo& arguments /**<
   [IN] Test instance to be copied */
  );

  /** Destructor.
   * Destroys the test instance.
   */
  ~TestInstanceInfo();

  /** Returns name of test unit executing the test.
   */
  const std::string& GetUnitName() const {
    return unit_name_;
  }

  /** Get test method.
   * Returns a pointer to the corresponding test method.
   * @return Pointer to test method
   */
  TestMethod* GetTestMethod() const;

  /** Get thread number.
   * Returns the number of the thread executing the test instance.
   * Given \c n threads, the threads are numbered from \c 0 to \c n-1.
   * Hence, thread numbers can be used to access arrays of user defined data.
   * @return Number of thread
   */
  size_t GetThreadNum() const;

  /** Get instance number.
   * Returns the number of the test instance. Given \c n instances,
   * the instances are numbered from \c 0 to \c n-1. Hence, instance
   * numbers can be used to access arrays of user defined data.
   * Unlike thread numbers, however, instance numbers are not unique,
   * i.e., instances of different test methods might have the same numbers.
   * @return Number of instance
   */
  size_t GetInstanceNum() const;

  /** Get iteration number.
   * Returns the number of the iteration (starting with \c 0).
   * @return Number of iteration
   */
  size_t GetIterationNum() const;

  /** Set thread number.
   * Sets the the thread number this instance represents.
   */
  void SetThreadNum(size_t thread_num /**<
   [IN] Number of thread of iteration to be set. */
  );

  /**Set instance number.
   * Sets the the instance number this instance represents.
   */
  void SetInstanceNum(size_t instance_num /**<
   [IN] Number of the instance to be set.*/
  );

  /** Set iteration number.
   * Sets the the current iteration number.
   */
  void SetIterationNum(size_t iteration_num/**<
   [IN] Number of current iteration to be set */
  );

  /** Get test instance
   * Returns a pointer to the test instance executed by the calling thread.
   * Fails if there is no active test instance.
   * @return Pointer to test instance
   */
  static TestInstanceInfo* GetTestInstanceInfo();

 private:

  /** Disallow empty constructor
   */
  TestInstanceInfo();

  /** Disable assignment.
   */
  TestInstanceInfo& operator=(const TestInstanceInfo&);

  /** Name of the test unit assosiated with test instance*
   */
  std::string unit_name_;

  /** Pointer to test method this test instance is running.
   */
  TestMethod *test_method_ptr_;

  /** Thread number that represents this instance.
   */
  size_t thread_num_;

  /** Instance number of this instance, this is relative to the instances running the same test method.
   */
  size_t instance_num_;

  /** Current iteration number for running assigned test method.
   */
  size_t iteration_num_;
};

}  // namespace partest

#endif  // PARTEST_TEST_INSTANCE_INFO_H_
partest/include/partest/test_method.h100777      0      0       15536 12377315323  13514 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_TEST_METHOD_H_
#define PARTEST_TEST_METHOD_H_

#include <cstddef>

#include <partest/internal/thread_specific_storage.h>
#include <partest/internal/function.h>

namespace partest {

class TestInstanceInfo;

/** Test Method.
 * An object of class TestMethod specifies the method to be tested, e.g.
 * a function, and related parameters such as the number of instances.
 */
class TestMethod {
 public:
  /** Constructor (for functions).
   * Creates a test method for the specified function.
   */
  TestMethod(
      void (*function)(), /**<
      [IN] Pointer to function. */
      size_t instances = 1,/**<
      [IN] Number of instances to be created. */
      size_t iterations = 1/**<
      [IN] Number of iterations to be performed.*/
      );

   /** Constructor (for member functions).
    * Creates a test method for the specified member function.
    */
  template <typename F>
  TestMethod(
      void (F::*member_function)(),/**<
      [IN] Pointer to member function */
      F* object, /**<
      [IN] Pointer to object */
      size_t instances = 1, /**<
      [IN] Number of instances to be created */
      size_t iterations = 1/**<
      [IN] Number of iterations to be performed */
      );


  /** Constructor (for function objects).
   *  Creates a test method for the specified function object.
   *  @note Function objects are copied. If a function object
   *  stores data and you want to access this data later on, wrap
   *  it into a reference using \c ref. Large objects may be
   *  passed as a constant reference using \c cref.
   */
  template <typename F>
  TestMethod(
      F function_object,/**<
      [IN] Function object */
      size_t instances = 1,/**<
      [IN] Number of instances to be created */
      size_t iterations = 1/**<
      [IN] Number of iterations to be performed */
      );


  /** Destructor.
   * Destroys the test method.
   */
  ~TestMethod();

  /** Get number of instances.
   * Returns the number of instances to be created.
   * @return Number of instances
   */
  size_t GetNumInstances() const;

  /** Get number of iterations.
   * Returns the number of iterations to be performed.
   * @return Number of iterations
   */
  size_t GetNumIterations() const;

  /** Get maximum number of instances.
   * Returns the maximum number of instances to be created.
   * @return Maximum number of instances
   * @see set_max_instances
   */
  static size_t GetMaxInstances();

  /** Set max. number of instances.
   * Sets the maximum number of instances to be created (0 = unlimited).
   * This function is useful if you want to perform both stress tests
   * and dynamic analysis of threading errors. For the latter, it
   * usually suffices to create only a small number of instances, since
   * the results of the tools are largely independent of the load.
   * Moreover, reducing the number of instances significantly speeds
   * up the analysis process. To sum up, set the value to 0 (no limit)
   * in case of stress tests, otherwise to a small value.
   * \see get_max_instances
   */
  static void SetMaxInstances(size_t max_instances); /**<
  [IN] Maximum number of instances */


  /** Get max. number of iterations.
   * Returns the maximum number of iterations to be performed.
   * @return Maximum number of iterations
   * @see set_max_iterations
   */
  static size_t GetMaxIterations();

  /** Set maximum number of iterations.
   * Sets the maximum number of iterations to be performed (0 = unlimited).
   * This function is useful if you want to perform both stress tests
   * and dynamic analysis of threading errors. For the latter, it
   * usually suffices to perform only a small number of iterations, since
   * the results of the tools are largely independent of the load.
   * Moreover, reducing the number of iterations significantly speeds
   * up the analysis process. To sum up, set the value to 0 (no limit)
   * in case of stress tests, otherwise to a small value.
   * \see get_max_iterations
  */
  static void SetMaxIterations(size_t max_iterations); /**<
  [IN] Maximum number of iterations */

   /** Get test instance.
    * Returns a pointer to the test instance executed by the calling thread.
    * @return Pointer to test instance
    */
  static TestInstanceInfo* GetTestInstanceInfo();

  /** Runs the test method.
   * Runs the test method for the specified number of iterations and instances.
   * Creates instances_ threads each running the method iterations_ times.
   */
  static int Run(TestInstanceInfo* ptr); /**<
  [IN] Pointer to the test instance to be run */

 private:
  /** Disallow empty constructor.
   */
  TestMethod();

  /** Disallow copy constructor and assingment.
   */
  TestMethod(const TestMethod& method);
  TestMethod& operator=(const TestMethod& method);

  /** Init method used in the constructor.
   */
  void Init(size_t instances, size_t iterations);

  /** Pointer to function this test method represents.
   */
  partest::internal::FunctionBase *fn_base_;

  /** number of instances and iterations for this test method.
   *  It will run instances_ threads, each running the test method iterations_times
   */
  size_t instances_, iterations_;

  /** maximum number of instances and iterations for all test methods.
   *  If it is set to 0 it represents INFINITE
   */
  static size_t max_inst, max_iter;

  /** Get the information for a running instance of this test method, depends on the running thread.
   */
  static internal::ThreadSpecificStorage<TestInstanceInfo> tls;

};

}  // namespace partest

#include <partest/internal/test_method-inl.h>

#endif  // PARTEST_TEST_METHOD_H_
partest/include/partest/test_suite.h100777      0      0       21740 12377315364  13364 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_TEST_SUITE_H_
#define PARTEST_TEST_SUITE_H_

#include <iostream>
#include <cstdlib>
#include <string>
#include <sstream>

#include <partest/test_instance_info.h>

#include <partest/internal/mutex.h>

namespace partest {
/**
 * Test suite.
 * This class provides global functions and settings for all test cases.
 */
class TestSuite {
public:
  /**
   * Get output stream.
   * Returns the output stream for warnings and error messages (by default \c cerr).
   * @return Reference to the stream
   * @see set_stream
   */
  static std::ostream& GetStream();

  /**
   * Set output stream.
   * Sets the output stream for warnings and error messages.
   * @see get_stream
   */
  static void SetStream(std::ostream& output_stream); /**<
   [IN] Output stream for assertion messages */

  /**
   * Get passed expects.
   * Returns the number of expects that were passed successfully.
   * @return Number of passed expects
   * @see get_failed_expects
   */
  static size_t GetPassedExpects();

  /**
   * Get failed expects.
   * Returns the number of expects that were not passed successfully.
   * Unlike assertions, a failed expect does not cause the whole test to be aborted.
   * @return Number of failed expects
   * @see get_passed_expects
   */
  static size_t GetFailedExpects();

  /** Get passed asserts.
   * Returns the number of asserts that were passed successfully.
   * @return Number of passed asserts
   */
  static size_t GetPassedAsserts();

  /**
   * Get maximum failed expects.
   * Returns the maximum number of expects that may fail before the test is aborted.
   * @return Number of passed asserts
   * @see set_max_failed_expects
   */
  static size_t GetMaxFailedExpects();

  /**
   * Set maximum failed expects.
   * Sets the maximum number of expects that may fail before the test is aborted.
   * @see get_max_failed_expects
   */
  static void SetMaxFailedExpects(size_t max_failed_exp); /**<
   [IN] Maximum number of failed expects */

  /**
   * Report an exception.
   * This function is called when an exception is thrown but not caught by
   * the application.
   * @note This function is automatically called by the test framework.
   */
  static void ReportException(const char* what); /**<
   [IN] Error message */

  /**
   * Check result of Boolean assert/expect expression.
   * If \c result is \c false, emits an error/warning message and
   * terminates the program in case \c terminate is \c true.
   * @note Do not call this function directly. Use the PT macros instead.
   */
  static void Check(bool result,/**<
   [IN]  Result of assert/expect expression */
  const char* expr,/**<
   [IN] Pointer to string representing the expression */
  const char* file,/**<
   [IN] Name of file which contains the assert/expect expression */
  const char* func,/**<
   [IN] Name of function which contains the assert/expect expression */
  size_t line,/**<
   [IN] Number of line which contains the assert/expect expression */
  const char* message,/**<
   [IN] Optional user-defined message */
  bool terminate/**<
   [IN]  Boolean value indicating whether program should be terminated */
  );

  /* \briefCheck result of relational assert/expect expression.
   * If \c pred(value1,value2) is \c false, emits an error/warning message and
   * terminates the program in case \c terminate is \c true.
   * @note Do not call this function directly. Use the PT macros instead.
   */
  template<typename T1, typename P, typename T2>
  static void Check(T1 value1,/**<
   [IN] Left-hand side of expression */
  P pred,/**<
   [IN] Binary predicate */
  T2 value2,/**<
   [IN]  Right-hand side of expression */
  const char* expr1,/**<
   [IN] Pointer to string representing left-hand side of expression */
  const char* expr2,/**<
   [IN] Pointer to string representing right-hand side of expression */
  const char* file,/**<
   [IN]  Name of file which contains the assert/expect expression */
  const char* func,/**<
   [IN] Name of function which contains the assert/expect expression */
  size_t line,/**<
   [IN] Number of line which contains the assert/expect expression */
  const char* message,/**<
   [IN] Optional user-defined message */
  bool terminate/**<
   [IN] Boolean value indicating whether program should be terminated */
  );

  /**
   * Returns the default number of iterations.
   * The default number of iterations is set to 10.
   * */
  static size_t GetDefaultNumIterations() {
    return DefaultNumberIterations();
  }

  /**
   * Returns the default number of threads.
   * The default number of threads is set to 10.
   * */
  static size_t GetDefaultNumThreads() {
    return DefaultNumberThreads();
  }

  /**
   * Sets the default number of iterations.
   * The default number of iterations is set to 10.
   * */
  static void SetDefaultNumIterations(size_t num_iterations) {
    DefaultNumberIterations() = num_iterations;
  }

  /**
   * Sets the default number of threads.
   * The default number of threads is set to 10.
   * */
  static void SetDefaultNumThreads(size_t num_threads) {
    DefaultNumberThreads() = num_threads;
  }


  /**
   * Gets the current thread id.
   * The thread id is assigned by the test framework.
   */
  static size_t GetCurrentThreadID() {
    return TestInstanceInfo::GetTestInstanceInfo()->GetThreadNum();
  }

  /**
   * Gets the current instance ID.
   * Instance IDs are unique only within the same method.
   */
  static size_t GetCurrentTestInstanceID() {
    return TestInstanceInfo::GetTestInstanceInfo()->GetInstanceNum();
  }

private:
  /**
   * Disallow constructing Test Suite objects.
   */
  TestSuite();
  TestSuite(const TestSuite&);
  TestSuite& operator=(const TestSuite&);

  /**
   * No destructor defined.
   */
  ~TestSuite();

  /**
   * prints assertion message and updates assert and expect counters uppon error.
   */
  static void Emit(std::string string, const char* message, bool terminate);

  /**
   * Output stream for messages printed by test suite.
   */
  static std::ostream *ostr_;

  /**
   * Number of passed assrts, passed and failed expects.
   * Number of max failed expects, more than max failed expects are encountered the test terminates.
   */
  static size_t passed_expects_, failed_expects_, passed_asserts_,
      max_failed_expects_;

  /**
   * Helper variable set to true in case that the test terminates.
   */
  static bool stopped_;

  /**
   * Mutex to synchronize output stream and counters.
   */
  static internal::Mutex mtx_;

  /**
   * Returns a reference to the default number of iterations
   * */
  static size_t& DefaultNumberIterations() {
    static size_t default_num_iterations=10;
    return default_num_iterations;
  }

  /**
   * Returns a reference to the default number of threads
   * */
  static size_t& DefaultNumberThreads() {
    static size_t default_num_threads=10;
    return default_num_threads;
  }

};

template<typename T1, typename P, typename T2>
void TestSuite::Check(T1 value1, P pred, T2 value2, const char* expr1,
    const char* expr2, const char* file, const char* func, size_t line,
    const char* message, bool terminate) {
  if (pred(value1, value2)) {
    internal::LockGuard<internal::Mutex> lock(mtx_);
    if (terminate)
      passed_asserts_++;
    else
      passed_expects_++;
    return;
  }
  std::stringstream ss;
  ss << "CHECK FAILED" << std::endl;
  ss << "Expression: " << expr1 << " " << pred.get_op() << " " << expr2
      << std::endl;
  ss << "Values    : " << value1 << " " << typename P::inverse_t().get_op()
      << " " << value2 << std::endl;
  ss << "File      : " << file << std::endl;
  ss << "Method    : " << func << std::endl;
  ss << "Line      : " << line << std::endl;
  Emit(ss.str(), message, terminate);
}

}  // namespace partest

#endif  // PARTEST_TEST_SUITE_H_
partest/include/partest/test_unit.h100777      0      0       12553 12377315323  13207 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PARTEST_TEST_UNIT_H_
#define PARTEST_TEST_UNIT_H_

#include <partest/test_unit.h>
#include <partest/test_instance_info.h>
#include <vector>

namespace partest {

/** Gathers and executes (in parallel) all methods of one test.
 * A test unit defines one test, usually belonging to a test case. It can
 * consist of several methods that are executed in parallel by different threads.
 * In addition, a pre- and post-method can be set, which are executed before and
 * after the parallel test methods are executed.
 */
class TestUnit {
 public:
  /** Constructs an empty test unit.
   * Test methods, as well as pre- and post-methods have to be added.
   */
  TestUnit(const std::string& name);

  /** Destroys the test unit.
   */
  virtual ~TestUnit();

  /** Executes the added test methods in parallel by using threads.
   */
  void Run();

  /** Adds a test method for execution.
   */
  TestUnit& Add(void (*function)(), /**<
   [IN] Function pointer to method */
  size_t instances = 1, /**<
   [IN] Number of threads executing the method at the same time */
  size_t iterations = 1 /**<
   [IN] Number of times each thread calls the method */
  );

  /** Adds a member test method with calling object for execution.
   */
  template<typename F>
  TestUnit& Add(void (F::*member_function)(), /**<
   [IN] Member function pointer to method */
  F* object, /**<
   [IN] Object calling the member function */
  size_t instances = 1, /**<
   [IN] Number of threads executing the method at the same time */
  size_t iterations = 1 /**<
   [IN] Number of times each thread calls the method */
  );

  /** Adds a test functor for execution.
   */
  template<typename F>
  TestUnit& Add(F function_object, /**<
   [IN] Copyable functor defining the test method in operator() */
  size_t instances = 1, /**<
   [IN] Number of threads executing the method at the same time */
  size_t iterations = 1 /**<
   [IN] Number of times each thread calls the method */
  );

  /** Sets a method to be executed before the test methods.
   */
  TestUnit& Pre(void (*function)()); /**< [IN] Function pointer to method */

  /** Sets a member method to be executed before the test methods.
   */
  template<typename F>
  TestUnit& Pre(void (F::*member_function)(), /**<
   [IN] Member function pointer to method */
  F* object /**<
   [IN] Object calling the member function */
  );

  /** Sets a functor to be executed before the test methods.
   */
  template<typename F>
  TestUnit& Pre(F function_object); /**<
   [IN] Copyable functor defining operator() */

  /** Sets a method to be executed after the test methods.
   */
  TestUnit& Post(void (*function)());

  /** Sets a member method to be executed after the test methods.
   */
  template<typename F>
  TestUnit& Post(void (F::*member_function)(), /**<
   [IN] Member function pointer to method */
  F* object /**<
   [IN] Object calling the member function */
  );

  /** Sets a functor to be executed after the test methods.
   */
  template<typename F>
  TestUnit& Post(F function_object); /**<
   [IN] Copyable functor defining operator() */

 private:
  /** Disallow copy constructor and assignment.
   */
  TestUnit(const TestUnit&);
  TestUnit& operator=(const TestUnit&);

  /** Adds the provided test method to the set of test methods to be tested.
   * @param method Method to be added.
   */
  void Add(TestMethod* method);
  void AddPre(TestMethod* method);
  void AddPost(TestMethod* method);

  /** Name of the test unit
   */
  std::string name_;

  /** Method to be run before any other method is run
   Only when pre_method_ method terminates the rest of the methods will be executed
   */
  partest::TestMethod* pre_method_;

  /** Method to be run after all other methods are run
   Only when all other methods terminate the post method will be executed
   */
  partest::TestMethod* post_method_;

  /** All the test methods to be executed in parallel between the pre and post methods
   */
  std::vector<partest::TestMethod*> test_methods_;

};

}  // namespace partest

#include <partest/internal/test_unit-inl.h>

#endif  // PARTEST_TEST_UNIT_H_
partest/src/ 40777      0      0           0 12401571175   6351 5partest/src/internal/ 40777      0      0           0 12401571161  10160 5partest/src/internal/mutex.cc100777      0      0        3225 12377315323  11743 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <partest/internal/mutex.h>

namespace partest {
namespace internal {

Mutex::Mutex() :
    mutex_() {
}

Mutex::~Mutex() {
}

void Mutex::Lock() {
  mutex_.Lock();
}

bool Mutex::TryLock() {
  return mutex_.TryLock();
}

void Mutex::Unlock() {
  mutex_.Unlock();
}

} // namespace internal
} // namespace partest
partest/src/internal/partestThreads/ 40777      0      0           0 12401571161  13155 5partest/src/internal/partestThreads/mutex_implementation.cc100777      0      0        5226 12377315323  20050 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include<partest/internal/partestThreads/mutex_implementation.h>

namespace partest {
namespace internal {
namespace partestthreads {

#ifdef PARTEST_THREADING_WINTHREADS
MutexImplementation::MutexImplementation() {
  InitializeCriticalSection(&mutex_);
}

MutexImplementation::~MutexImplementation() {
  DeleteCriticalSection(&mutex_);
}

void MutexImplementation::Lock() {
  EnterCriticalSection(&mutex_);
}

bool MutexImplementation::TryLock() {
  BOOL success;
  success = TryEnterCriticalSection(&mutex_);
  if (success == FALSE) return false;
  return true;
}

void MutexImplementation::Unlock() {
  LeaveCriticalSection(&mutex_);
}

#endif /* PARTEST_THREADING_WINTHREADS */

#ifdef PARTEST_THREADING_POSIXTHREADS

MutexImplementation::MutexImplementation() {
  pthread_mutex_init(&mutex_, NULL);
}

MutexImplementation::~MutexImplementation() {
  pthread_mutex_destroy(&mutex_);
}

void MutexImplementation::Lock() {
  pthread_mutex_lock(&mutex_);
}

bool MutexImplementation::TryLock() {
  int result = pthread_mutex_trylock(&mutex_);
  if (result == 0) {
    return true;
  }
  if (result == EBUSY) {
    return false;
  }
  return false;
}

void MutexImplementation::Unlock() {
  pthread_mutex_unlock(&mutex_);
}

#endif /* PARTEST_THREADING_POSIXTHREADS */

} // namespace partestthreads
} // namespace internal
} // namespace partest
partest/src/internal/partestThreads/thread_implementation.cc100777      0      0       10421 12377315324  20167 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include<partest/internal/partestThreads/thread_implementation.h>

namespace partest {
namespace internal {
namespace partestthreads {

#ifdef PARTEST_THREADING_WINTHREADS

/**
 * Is used to offer a consistent thread start function signature. Windows threads
 * have a different signature than Pthreads and C11. This internal start
 * function for Windows threads just calls the client start function with given
 * argument.
 */
DWORD WINAPI InternalThreadStart(LPVOID internalArg) {
  int result = ((PartestInternalThreadArgs*)internalArg)->func(
      ((PartestInternalThreadArgs*)internalArg)->arg);
#if ! defined(__cplusplus)
  ExitThread((DWORD)result); /* In C, the return of result code doesn't work */
#endif
  return (DWORD)result;
}

bool ThreadImplementation::Create_thread(int(*function)(void*),void * args) {
  threadArgs_ = new PartestInternalThreadArgs;

  threadArgs_->func = function;
  threadArgs_->arg = args;

  threadHandle_ = CreateThread(
      0, /* no security */
      0, /* default stack size */
      InternalThreadStart, /* entry function */
      (LPVOID)threadArgs_, /* parameters */
      0, /* no creation arguments */
      0); /* no system thread ID */
  if (threadHandle_ == NULL) {
    return false;
  }
  return true;
}

bool ThreadImplementation::Join() {
  BOOL success;
  DWORD result;
  result = WaitForSingleObject(threadHandle_, INFINITE);
  delete threadArgs_;
  if (result != WAIT_OBJECT_0) { /* WAIT_OBJECT_0 indicates successful waiting */
    return false;
  }
  success = CloseHandle(threadHandle_);
  if (success == FALSE) {
    return false;
  }

  return true;
}

#endif /* PARTEST_THREADING_WINTHREADS */

#ifdef PARTEST_THREADING_POSIXTHREADS

/**
 * Is used to offer a consistent thread start function signature. POSIX threads
 * have a different signature than C11 threads. This internal start
 * function for POSIX threads just calls the client start function with given
 * argument.
 */
void* InternalThreadStart(void* internalArg) {
  ((PartestInternalThreadArgs*) internalArg)->result =
      ((PartestInternalThreadArgs*) internalArg)->func(
          ((PartestInternalThreadArgs*) internalArg)->arg);
  return NULL;
}

bool ThreadImplementation::Create_thread(int (*function)(void*), void * args) {
  /* Dynamic allocation of thread arguments. Freed on call of join. */
  threadArgs_ = new PartestInternalThreadArgs;
  threadArgs_->func = function;
  threadArgs_->arg = args;

  int status = pthread_create(&threadHandle_, /* pthread handle */
  NULL, /* not used */
  InternalThreadStart, /* thread start function */
  (void*) (threadArgs_)); /* arguments to thread start fct */

  if (status != 0)
    return false;
  return true;
}

bool ThreadImplementation::Join() {
  int status = 0;
  status = pthread_join(threadHandle_, NULL);

  delete threadArgs_;
  if (status != 0) {
    return false;
  }

  return true;
}

#endif /* PARTEST_THREADING_POSIXTHREADS */

} // namespace partestthreads
} // namespace internal
} // namespace partest
partest/src/internal/partestThreads/thread_specific_storage_implementation.cc100777      0      0        5117 12377315324  23546 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <partest/internal/partestThreads/thread_specific_storage_implementation.h>

namespace partest {
namespace internal {
namespace partestthreads {

#ifdef PARTEST_THREADING_WINTHREADS

ThreadSpecificStorageImplementation::ThreadSpecificStorageImplementation() {
  handle_ = TlsAlloc();
}

ThreadSpecificStorageImplementation::~ThreadSpecificStorageImplementation() {
  TlsFree(handle_);
}

void ThreadSpecificStorageImplementation::set(void* newValue) const {
  TlsSetValue(handle_, (LPVOID*)newValue);
}

void* ThreadSpecificStorageImplementation::get() const {
  return (void*)TlsGetValue(handle_);
}

#endif /* PARTEST_THREADING_WINTHREADS */

#ifdef PARTEST_THREADING_POSIXTHREADS

ThreadSpecificStorageImplementation::ThreadSpecificStorageImplementation() :
    handle_() {
  pthread_key_create(&handle_, NULL);
}

ThreadSpecificStorageImplementation::~ThreadSpecificStorageImplementation() {
  pthread_key_delete(handle_);
}

void ThreadSpecificStorageImplementation::set(void* newValue) const {
  pthread_setspecific(handle_, newValue);
}

void* ThreadSpecificStorageImplementation::get() const {
  return pthread_getspecific(handle_);
}
#endif /* PARTEST_THREADING_POSIXTHREADS */

}  // namespace partestthreads
}  // namespace internal
}  // namespace partest
partest/src/internal/thread.cc100777      0      0        3353 12377315324  12053 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <partest/internal/thread.h>

namespace partest {
namespace internal {

Thread::Thread(int (*function)(partest::TestInstanceInfo*),
    partest::TestInstanceInfo* args) :
    threadHandle_(function, args) {

}

Thread::Thread(int (*function)(void*), void * args) :
    threadHandle_(function, args) {
}

void Thread::Join() {
  threadHandle_.Join();
}

} // namespace internal
} // namespace partest
partest/src/test_case.cc100777      0      0        3525 12377315324  10743 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <partest/test_case.h>
#include <partest/test_unit.h>

namespace partest {

TestCase::TestCase() {
}

TestCase::~TestCase() {
  for (size_t i = 0; i < test_units_.size(); i++) {
    delete (test_units_[i]);
  }
}

TestUnit& TestCase::CreateUnit(const std::string& name) {
  TestUnit *testUnit = new TestUnit(name);
  test_units_.push_back(testUnit);
  return *testUnit;
}

void TestCase::Run() {
  for (size_t i = 0; i < test_units_.size(); i++) {
    test_units_[i]->Run();
  }
}

}  // namespace partest
partest/src/test_instance_info.cc100777      0      0        5720 12377315324  12646 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <partest/test_instance_info.h>
#include <partest/test_unit.h>
#include <partest/test_case.h>
#include <iostream>

namespace partest {

TestInstanceInfo::TestInstanceInfo(const std::string& unit_name,
    TestMethod *ptr) :
    unit_name_(unit_name), test_method_ptr_(ptr), thread_num_(0), instance_num_(
        0), iteration_num_(0) {
}

TestInstanceInfo::TestInstanceInfo(const TestInstanceInfo& test_case_arguments) :
    unit_name_(test_case_arguments.unit_name_), test_method_ptr_(
        test_case_arguments.test_method_ptr_), thread_num_(
        test_case_arguments.thread_num_), instance_num_(
        test_case_arguments.instance_num_), iteration_num_(
        test_case_arguments.iteration_num_) {
}

TestInstanceInfo::~TestInstanceInfo() {
}

TestMethod* TestInstanceInfo::GetTestMethod() const {
  return test_method_ptr_;
}

size_t TestInstanceInfo::GetThreadNum() const {
  return thread_num_;
}

size_t TestInstanceInfo::GetInstanceNum() const {
  return instance_num_;
}

size_t TestInstanceInfo::GetIterationNum() const {
  return iteration_num_;
}

void TestInstanceInfo::SetThreadNum(size_t thread_num) {
  this->thread_num_ = thread_num;
}

void TestInstanceInfo::SetInstanceNum(size_t instance_num) {
  this->instance_num_ = instance_num;
}

void TestInstanceInfo::SetIterationNum(size_t iteration_num) {
  this->iteration_num_ = iteration_num;
}

TestInstanceInfo* TestInstanceInfo::GetTestInstanceInfo() {
  TestInstanceInfo* instance(TestMethod::GetTestInstanceInfo());
  if (instance == NULL) {
    std::cerr << "No active test instance" << std::endl;
    exit(EXIT_FAILURE);
  }
  return instance;
}
}  // namespace partest
partest/src/test_method.cc100777      0      0        7767 12401571175  11320 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <partest/test_method.h>
#include <partest/test_instance_info.h>
#include <partest/test_suite.h>

#include <partest/internal/thread_specific_storage.h>

#include <algorithm>

namespace partest {

TestMethod::TestMethod(void (*function)(), size_t instances, size_t iterations) :
    fn_base_(new internal::Function(function)) {
  Init(instances, iterations);
}

TestMethod::TestMethod(const TestMethod& method) :
    fn_base_(method.fn_base_), instances_(method.instances_), iterations_(
        method.iterations_) {
}

TestMethod::~TestMethod() {
  delete fn_base_;
}

TestMethod& TestMethod::operator=(const TestMethod& method) {
  fn_base_ = method.fn_base_;
  instances_ = method.instances_;
  iterations_ = method.iterations_;
  return *this;
}

size_t TestMethod::GetNumInstances() const {
  return instances_;
}

size_t TestMethod::GetNumIterations() const {
  return iterations_;
}

size_t TestMethod::GetMaxInstances() {
  return max_inst;
}

void TestMethod::SetMaxInstances(size_t max_instances) {
  max_inst = max_instances;
}

size_t TestMethod::GetMaxIterations() {
  return max_iter;
}

void TestMethod::SetMaxIterations(size_t max_iterations) {
  max_iter = max_iterations;
}

void TestMethod::Init(size_t instances, size_t iterations) {
  if (instances == 0) {
    std::cerr << "Number of instances must be greater than zero" << std::endl;
    exit(EXIT_FAILURE);
  }
  instances_ = instances;

  if (iterations == 0) {
    std::cerr << "Number of iterations must be greater than zero" << std::endl;
    exit(EXIT_FAILURE);
  }
  iterations_ = iterations;
}

int TestMethod::Run(TestInstanceInfo* info) {
  TestMethod* method = info->GetTestMethod();
  size_t iterations =
      TestMethod::GetMaxIterations() > 0 ?
          std::min(method->GetNumIterations(), TestMethod::GetMaxIterations()) :
          method->GetNumIterations();
  tls.Reset(info);
#ifndef PARTEST_DISABLE_EXCEPTIONS
  try {
#endif
    for (info->SetIterationNum(0); info->GetIterationNum() < iterations;
        info->SetIterationNum((info->GetIterationNum() + 1))) {
      method->fn_base_->operator()();
    }
#ifndef PARTEST_DISABLE_EXCEPTIONS
  } catch (std::exception& e) {
    TestSuite::ReportException(e.what());
  } catch (...) {
    TestSuite::ReportException("unknown");
  }
#endif
  tls.Release(); // Tell tls to not to delete resources
  return 0;
}

internal::ThreadSpecificStorage<TestInstanceInfo> TestMethod::tls;

TestInstanceInfo* TestMethod::GetTestInstanceInfo() {
  return tls.get();
}

size_t TestMethod::max_inst(0);
size_t TestMethod::max_iter(0);
}  // namespace partest
partest/src/test_suite.cc100777      0      0       10053 12377315324  11173 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <partest/test_suite.h>
#include <partest/test_unit.h>
#include <partest/test_instance_info.h>
#include <partest/test_case.h>

#include <partest/internal/mutex.h>

namespace partest {

void TestSuite::SetStream(std::ostream& output_stream) {
  ostr_ = &output_stream;
}

std::ostream& TestSuite::GetStream() {
  return *ostr_;
}

size_t TestSuite::GetPassedExpects() {
  return passed_expects_;
}

size_t TestSuite::GetFailedExpects() {
  return failed_expects_;
}

size_t TestSuite::GetPassedAsserts() {
  return passed_asserts_;
}

size_t TestSuite::GetMaxFailedExpects() {
  return max_failed_expects_;
}

void TestSuite::SetMaxFailedExpects(size_t max_failed_exp) {
  max_failed_expects_ = max_failed_exp;
}

void TestSuite::ReportException(const char* what) {
  Emit(std::string("Uncaught exception: ") + what, NULL, true);
}

void TestSuite::Check(bool result, const char* expr, const char* file,
    const char* func, size_t line, const char* message, bool terminate) {
  if (result) {
    internal::LockGuard<internal::Mutex> lock(mtx_);
    if (terminate)
      passed_asserts_++;
    else
      passed_expects_++;
    return;
  }
  std::stringstream ss;
  ss << "CHECK FAILED" << std::endl;
  ss << "Expression: " << expr << std::endl;
  ss << "File      : " << file << std::endl;
  ss << "Method    : " << func << std::endl;
  ss << "Line      : " << line << std::endl;
  Emit(ss.str(), message, terminate);
}

void TestSuite::Emit(std::string string, const char* message, bool terminate) {
  {
    internal::LockGuard<internal::Mutex> lock(mtx_);
    if (stopped_) {
      return;
    }
    if (failed_expects_ > 0) {
      *ostr_
          << "--------------------------------------------------------------------------------"
          << std::endl;
    }
    *ostr_ << string << std::endl;
    if (message != NULL) {
      *ostr_ << message << std::endl;
    }
    TestInstanceInfo* instance = TestMethod::GetTestInstanceInfo();
    if (instance != NULL) {
      *ostr_ << "Test unit: " << instance->GetUnitName() << std::endl;
      *ostr_ << "Method thread num: " << instance->GetInstanceNum() << std::endl;
      *ostr_ << "Method iteration num: " << instance->GetIterationNum()
          << std::endl;
    }
    if (!terminate) {
      failed_expects_++;
    }
    if (terminate
        || ((max_failed_expects_ > 0)
            && (failed_expects_ >= max_failed_expects_))) {
      stopped_ = true;
    }
  }
  if (stopped_) {
    exit(EXIT_FAILURE);
  }
}

std::ostream* TestSuite::ostr_(&std::cerr);
size_t TestSuite::passed_expects_(0);
size_t TestSuite::failed_expects_(0);
size_t TestSuite::passed_asserts_(0);
size_t TestSuite::max_failed_expects_(0);
bool TestSuite::stopped_(false);
internal::Mutex TestSuite::mtx_;

}  // namespace partest
partest/src/test_unit.cc100777      0      0       11167 12377315324  11030 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <partest/test_unit.h>

#include <utility>
#include <cassert>
#include <algorithm>
#include <iostream>

#include <partest/partest.h>
#include <partest/test_instance_info.h>
#include <partest/test_method.h>
#include <partest/internal/allocate.h>

#include <partest/internal/thread.h>

namespace partest {

TestUnit::TestUnit(const std::string& name) :
    name_(name), pre_method_(NULL), post_method_(NULL) {
}

TestUnit::~TestUnit() {
  if (pre_method_ != NULL) {
    delete pre_method_;
  }
  if (post_method_ != NULL) {
    delete post_method_;
  }
  for (size_t i = 0; i < test_methods_.size(); i++) {
    delete (test_methods_[i]);
  }
}

void TestUnit::Add(TestMethod* unit) {
  test_methods_.push_back(unit);
}

void TestUnit::AddPre(TestMethod* unit) {
  PT_ASSERT_EQ_MSG(pre_method_, (partest::TestMethod*)NULL,
      "Can only add precondition once");
  pre_method_ = unit;
}

void TestUnit::AddPost(TestMethod* unit) {
  PT_ASSERT_EQ_MSG(post_method_, (partest::TestMethod*)NULL,
      "Can only add postcondition once");
  post_method_ = unit;
}

TestUnit& TestUnit::Add(void (*function)(), size_t instances,
    size_t iterations) {
  Add(new TestMethod(function, instances, iterations));
  return *this;
}

TestUnit& TestUnit::Pre(void (*function)()) {
  AddPre(new TestMethod(function, 1, 1));
  return *this;
}

TestUnit& TestUnit::Post(void (*function)()) {
  AddPost(new TestMethod(function, 1, 1));
  return *this;
}

void TestUnit::Run() {
  size_t thread_num = 0;
  typedef std::pair<TestInstanceInfo*, internal::Thread*> context_t;
  std::vector<context_t> context_vector;

  if (pre_method_ != NULL) { // Run pre method
    TestInstanceInfo* instance = internal::aligned_new(
        TestInstanceInfo(name_, pre_method_));
    instance->SetThreadNum(thread_num++);
    instance->SetInstanceNum(0);
    internal::Thread thread(&TestMethod::Run, instance);
    thread.Join();
    internal::aligned_delete(instance);
  }

  // Run test methods in parallel
  thread_num = 0;
  for (size_t i = 0; i < test_methods_.size(); i++) {
    TestMethod* method = test_methods_[i];
    size_t instances = method->GetNumInstances();
    if (TestMethod::GetMaxInstances() > 0) { // Larger zero means limit set
      instances = std::min(method->GetNumInstances(),
          TestMethod::GetMaxInstances());
    }
    for (size_t j = 0; j < instances; j++) {
      TestInstanceInfo* instance = internal::aligned_new(
          TestInstanceInfo(name_, method));
      instance->SetThreadNum(thread_num++);
      instance->SetInstanceNum(j);
      context_vector.push_back(
          context_t(instance,
              new internal::Thread(&TestMethod::Run, instance)));
    }
  }
  // Join test method threads and free memory
  for (size_t i = 0; i < context_vector.size(); i++) {
    context_vector[i].second->Join();
    assert(context_vector[i].first != NULL);
    internal::aligned_delete(context_vector[i].first);
    delete context_vector[i].second;
  }

  thread_num = 0;
  if (post_method_ != NULL) { // Run post method
    TestInstanceInfo* instance = internal::aligned_new(
        TestInstanceInfo(name_, post_method_));
    instance->SetThreadNum(thread_num++);
    instance->SetInstanceNum(0);
    internal::Thread thread(&TestMethod::Run, instance);
    thread.Join();
    internal::aligned_delete(instance);
  }
}

}  // namespace partest
partest/test/ 40777      0      0           0 12401571161   6534 5partest/test/main.cc100777      0      0        4705 12377315324  10106 0/*
 * Copyright (c) 2014, Siemens AG. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <iostream>
#include <cassert>
#include <functional>

#include <partest/partest.h>

using namespace std;

void foo() {
  //cout << "foo" << endl;
  PT_EXPECT(true);
}

class bar {
public:
  bar() :
      cnt(0) {
  }
  void operator()() {
    //  cout << "bar" << endl;
    PT_EXPECT_MSG(1 == 0, "Not really true");
    PT_EXPECT_EQ(1 + 1, 0);
    cnt++;
  }
  int cnt;
};

bar b;

class test_incdec: public partest::TestUnit {

private:

  int counter;

  void inc() {
    volatile int i;
    for (i = 1; i < 10000; i++)
      ;
    PT_EXPECT_LT(string("cd"), string("cc"));
    counter++;
  }

  void dec() {
    volatile int i;
    for (i = 1; i < 10000; i++)
      ;
    PT_EXPECT(counter < 0);
    counter--;
  }

public:

  test_incdec() :
      partest::TestUnit("indec"), counter(0) {

    Add(&test_incdec::inc, this, 2, 3);
    Add(&test_incdec::dec, this, 2, 3);
    Add(&foo, 2);
    Add(b, 2);
    // add(test_unit("Bar2", bar(), 2));
    // add(test_unit("Lambda", [] {cout << "lambda" << endl;}));
  }

  ~test_incdec() {
    PT_ASSERT_EQ(counter, 1); // TODO
  }

};

PT_MAIN("Partest") {
  PT_RUN(test_incdec);
}