ooxml_crypt 0.1.0

data/vendor/cybozulib/include/cybozu/test.hpp

@@ -0,0 +1,373 @@
+#pragma once
+/**
+	@file
+	@brief unit test class
+
+	@author MITSUNARI Shigeo(@herumi)
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#include <list>
+#include <iostream>
+#include <utility>
+#if defined(_MSC_VER) && (MSC_VER <= 1500)
+	#include <cybozu/inttype.hpp>
+#else
+	#include <stdint.h>
+#endif
+
+namespace cybozu { namespace test {
+
+class AutoRun {
+	typedef void (*Func)();
+	typedef std::list<std::pair<const char*, Func> > UnitTestList;
+public:
+	AutoRun()
+		: init_(0)
+		, term_(0)
+		, okCount_(0)
+		, ngCount_(0)
+		, exceptionCount_(0)
+	{
+	}
+	void setup(Func init, Func term)
+	{
+		init_ = init;
+		term_ = term;
+	}
+	void append(const char *name, Func func)
+	{
+		list_.push_back(std::make_pair(name, func));
+	}
+	void set(bool isOK)
+	{
+		if (isOK) {
+			okCount_++;
+		} else {
+			ngCount_++;
+		}
+	}
+	std::string getBaseName(const std::string& name) const
+	{
+#ifdef _WIN32
+		const char sep = '\\';
+#else
+		const char sep = '/';
+#endif
+		size_t pos = name.find_last_of(sep);
+		std::string ret = name.substr(pos + 1);
+		pos = ret.find('.');
+		return ret.substr(0, pos);
+	}
+	int run(int, char *argv[])
+	{
+		std::string msg;
+		try {
+			if (init_) init_();
+			for (UnitTestList::const_iterator i = list_.begin(), ie = list_.end(); i != ie; ++i) {
+				std::cout << "ctest:module=" << i->first << std::endl;
+				try {
+					(i->second)();
+				} catch (std::exception& e) {
+					exceptionCount_++;
+					std::cout << "ctest:  " << i->first << " is stopped by exception " << e.what() << std::endl;
+				} catch (...) {
+					exceptionCount_++;
+					std::cout << "ctest:  " << i->first << " is stopped by unknown exception" << std::endl;
+				}
+			}
+			if (term_) term_();
+		} catch (std::exception& e) {
+			msg = std::string("ctest:err:") + e.what();
+		} catch (...) {
+			msg = "ctest:err: catch unknown exception";
+		}
+		fflush(stdout);
+		if (msg.empty()) {
+			int err = ngCount_ + exceptionCount_;
+			int total = okCount_ + err;
+			std::cout << "ctest:name=" << getBaseName(*argv)
+					  << ", module=" << list_.size()
+					  << ", total=" << total
+					  << ", ok=" << okCount_
+					  << ", ng=" << ngCount_
+					  << ", exception=" << exceptionCount_ << std::endl;
+			return err > 0 ? 1 : 0;
+		} else {
+			std::cout << msg << std::endl;
+			return 1;
+		}
+	}
+	static inline AutoRun& getInstance()
+	{
+		static AutoRun instance;
+		return instance;
+	}
+private:
+	Func init_;
+	Func term_;
+	int okCount_;
+	int ngCount_;
+	int exceptionCount_;
+	UnitTestList list_;
+};
+
+static AutoRun& autoRun = AutoRun::getInstance();
+
+inline void test(bool ret, const std::string& msg, const std::string& param, const char *file, int line)
+{
+	autoRun.set(ret);
+	if (!ret) {
+		printf("%s(%d):ctest:%s(%s);\n", file, line, msg.c_str(), param.c_str());
+	}
+}
+
+template<typename T, typename U>
+bool isEqual(const T& lhs, const U& rhs)
+{
+	return lhs == rhs;
+}
+
+// avoid warning of comparision of integers of different signs
+inline bool isEqual(size_t lhs, int rhs)
+{
+	return lhs == size_t(rhs);
+}
+inline bool isEqual(int lhs, size_t rhs)
+{
+	return size_t(lhs) == rhs;
+}
+inline bool isEqual(const char *lhs, const char *rhs)
+{
+	return strcmp(lhs, rhs) == 0;
+}
+inline bool isEqual(char *lhs, const char *rhs)
+{
+	return strcmp(lhs, rhs) == 0;
+}
+inline bool isEqual(const char *lhs, char *rhs)
+{
+	return strcmp(lhs, rhs) == 0;
+}
+inline bool isEqual(char *lhs, char *rhs)
+{
+	return strcmp(lhs, rhs) == 0;
+}
+// avoid to compare float directly
+inline bool isEqual(float lhs, float rhs)
+{
+	union fi {
+		float f;
+		uint32_t i;
+	} lfi, rfi;
+	lfi.f = lhs;
+	rfi.f = rhs;
+	return lfi.i == rfi.i;
+}
+// avoid to compare double directly
+inline bool isEqual(double lhs, double rhs)
+{
+	union di {
+		double d;
+		uint64_t i;
+	} ldi, rdi;
+	ldi.d = lhs;
+	rdi.d = rhs;
+	return ldi.i == rdi.i;
+}
+
+} } // cybozu::test
+
+#ifndef CYBOZU_TEST_DISABLE_AUTO_RUN
+int main(int argc, char *argv[])
+{
+	return cybozu::test::autoRun.run(argc, argv);
+}
+#endif
+
+/**
+	alert if !x
+	@param x [in]
+*/
+#define CYBOZU_TEST_ASSERT(x) cybozu::test::test(!!(x), "CYBOZU_TEST_ASSERT", #x, __FILE__, __LINE__)
+
+/**
+	alert if x != y
+	@param x [in]
+	@param y [in]
+*/
+#define CYBOZU_TEST_EQUAL(x, y) { \
+	bool _cybozu_eq = cybozu::test::isEqual(x, y); \
+	cybozu::test::test(_cybozu_eq, "CYBOZU_TEST_EQUAL", #x ", " #y, __FILE__, __LINE__); \
+	if (!_cybozu_eq) { \
+		std::cout << "ctest:  lhs=" << (x) << std::endl; \
+		std::cout << "ctest:  rhs=" << (y) << std::endl; \
+	} \
+}
+/**
+	alert if fabs(x, y) >= eps
+	@param x [in]
+	@param y [in]
+*/
+#define CYBOZU_TEST_NEAR(x, y, eps) { \
+	bool _cybozu_isNear = fabs((x) - (y)) < eps; \
+	cybozu::test::test(_cybozu_isNear, "CYBOZU_TEST_NEAR", #x ", " #y, __FILE__, __LINE__); \
+	if (!_cybozu_isNear) { \
+		std::cout << "ctest:  lhs=" << (x) << std::endl; \
+		std::cout << "ctest:  rhs=" << (y) << std::endl; \
+	} \
+}
+
+#define CYBOZU_TEST_EQUAL_POINTER(x, y) { \
+	bool _cybozu_eq = x == y; \
+	cybozu::test::test(_cybozu_eq, "CYBOZU_TEST_EQUAL_POINTER", #x ", " #y, __FILE__, __LINE__); \
+	if (!_cybozu_eq) { \
+		std::cout << "ctest:  lhs=" << static_cast<const void*>(x) << std::endl; \
+		std::cout << "ctest:  rhs=" << static_cast<const void*>(y) << std::endl; \
+	} \
+}
+/**
+	alert if x[] != y[]
+	@param x [in]
+	@param y [in]
+	@param n [in]
+*/
+#define CYBOZU_TEST_EQUAL_ARRAY(x, y, n) { \
+	for (size_t _cybozu_test_i = 0, _cybozu_ie = (size_t)(n); _cybozu_test_i < _cybozu_ie; _cybozu_test_i++) { \
+		bool _cybozu_eq = cybozu::test::isEqual((x)[_cybozu_test_i], (y)[_cybozu_test_i]); \
+		cybozu::test::test(_cybozu_eq, "CYBOZU_TEST_EQUAL_ARRAY", #x ", " #y ", " #n, __FILE__, __LINE__); \
+		if (!_cybozu_eq) { \
+			std::cout << "ctest:  i=" << _cybozu_test_i << std::endl; \
+			std::cout << "ctest:  lhs=" << (x)[_cybozu_test_i] << std::endl; \
+			std::cout << "ctest:  rhs=" << (y)[_cybozu_test_i] << std::endl; \
+		} \
+	} \
+}
+
+/**
+	always alert
+	@param msg [in]
+*/
+#define CYBOZU_TEST_FAIL(msg) cybozu::test::test(false, "CYBOZU_TEST_FAIL", msg, __FILE__, __LINE__)
+
+/**
+	verify message in exception
+*/
+#define CYBOZU_TEST_EXCEPTION_MESSAGE(statement, Exception, msg) \
+{ \
+	int _cybozu_ret = 0; \
+	std::string _cybozu_errMsg; \
+	try { \
+		statement; \
+		_cybozu_ret = 1; \
+	} catch (const Exception& _cybozu_e) { \
+		_cybozu_errMsg = _cybozu_e.what(); \
+		if (_cybozu_errMsg.find(msg) == std::string::npos) { \
+			_cybozu_ret = 2; \
+		} \
+	} catch (...) { \
+		_cybozu_ret = 3; \
+	} \
+	if (_cybozu_ret) { \
+		cybozu::test::test(false, "CYBOZU_TEST_EXCEPTION_MESSAGE", #statement ", " #Exception ", " #msg, __FILE__, __LINE__); \
+		if (_cybozu_ret == 1) { \
+			std::cout << "ctest:  no exception" << std::endl; \
+		} else if (_cybozu_ret == 2) { \
+			std::cout << "ctest:  bad exception msg:" << _cybozu_errMsg << std::endl; \
+		} else { \
+			std::cout << "ctest:  unexpected exception" << std::endl; \
+		} \
+	} else { \
+		cybozu::test::autoRun.set(true); \
+	} \
+}
+
+#define CYBOZU_TEST_EXCEPTION(statement, Exception) \
+{ \
+	int _cybozu_ret = 0; \
+	try { \
+		statement; \
+		_cybozu_ret = 1; \
+	} catch (const Exception&) { \
+	} catch (...) { \
+		_cybozu_ret = 2; \
+	} \
+	if (_cybozu_ret) { \
+		cybozu::test::test(false, "CYBOZU_TEST_EXCEPTION", #statement ", " #Exception, __FILE__, __LINE__); \
+		if (_cybozu_ret == 1) { \
+			std::cout << "ctest:  no exception" << std::endl; \
+		} else { \
+			std::cout << "ctest:  unexpected exception" << std::endl; \
+		} \
+	} else { \
+		cybozu::test::autoRun.set(true); \
+	} \
+}
+
+/**
+	verify statement does not throw
+*/
+#define CYBOZU_TEST_NO_EXCEPTION(statement) \
+try { \
+	statement; \
+	cybozu::test::autoRun.set(true); \
+} catch (...) { \
+	cybozu::test::test(false, "CYBOZU_TEST_NO_EXCEPTION", #statement, __FILE__, __LINE__); \
+}
+
+/**
+	append auto unit test
+	@param name [in] module name
+*/
+#define CYBOZU_TEST_AUTO(name) \
+void cybozu_test_ ## name(); \
+struct cybozu_test_local_ ## name { \
+	cybozu_test_local_ ## name() \
+	{ \
+		cybozu::test::autoRun.append(#name, cybozu_test_ ## name); \
+	} \
+} cybozu_test_local_instance_ ## name; \
+void cybozu_test_ ## name()
+
+/**
+	append auto unit test with fixture
+	@param name [in] module name
+*/
+#define CYBOZU_TEST_AUTO_WITH_FIXTURE(name, Fixture) \
+void cybozu_test_ ## name(); \
+void cybozu_test_real_ ## name() \
+{ \
+	Fixture f; \
+	cybozu_test_ ## name(); \
+} \
+struct cybozu_test_local_ ## name { \
+	cybozu_test_local_ ## name() \
+	{ \
+		cybozu::test::autoRun.append(#name, cybozu_test_real_ ## name); \
+	} \
+} cybozu_test_local_instance_ ## name; \
+void cybozu_test_ ## name()
+
+/**
+	setup fixture
+	@param Fixture [in] class name of fixture
+	@note cstr of Fixture is called before test and dstr of Fixture is called after test
+*/
+#define CYBOZU_TEST_SETUP_FIXTURE(Fixture) \
+Fixture *cybozu_test_local_fixture; \
+void cybozu_test_local_init() \
+{ \
+	cybozu_test_local_fixture = new Fixture(); \
+} \
+void cybozu_test_local_term() \
+{ \
+	delete cybozu_test_local_fixture; \
+} \
+struct cybozu_test_local_fixture_setup_ { \
+	cybozu_test_local_fixture_setup_() \
+	{ \
+		cybozu::test::autoRun.setup(cybozu_test_local_init, cybozu_test_local_term); \
+	} \
+} cybozu_test_local_fixture_setup_instance_;

data/vendor/cybozulib/include/cybozu/thread.hpp

@@ -0,0 +1,229 @@
+#pragma once
+/**
+	@file
+	@brief tiny thread class
+
+	@author MITSUNARI Shigeo(@herumi)
+	@author MITSUNARI Shigeo
+*/
+
+#include <cybozu/atomic.hpp>
+#include <assert.h>
+#ifdef _WIN32
+	#ifndef WIN32_LEAN_AND_MEAN
+		#define WIN32_LEAN_AND_MEAN
+	#endif
+	#include <windows.h>
+	#include <process.h>
+	#ifdef _MSC_VER
+		#pragma warning(push)
+		#pragma warning(disable : 4127)
+	#endif
+#else
+	#include <unistd.h>
+	#include <pthread.h>
+	#include <time.h>
+	#include <errno.h>
+	#include <stdio.h>
+#endif
+
+namespace cybozu {
+
+/**
+	sleep
+	@param [in] msec time out(msec)
+*/
+inline void Sleep(int msec)
+{
+#ifdef _WIN32
+	::Sleep(msec);
+#else
+	struct timespec req;
+	req.tv_sec = msec / 1000;
+	req.tv_nsec = (msec % 1000) * 1000000;
+	for (;;) {
+		struct timespec rem;
+		int ret = nanosleep(&req, &rem);
+		if (ret == 0) break;
+		if (errno != EINTR) {
+			printf("Sleep errno %d\n", errno);
+			break;
+		}
+		req = rem;
+	}
+#endif
+}
+
+/**
+	get pid
+*/
+inline unsigned int GetProcessId()
+{
+#ifdef _WIN32
+	return GetCurrentProcessId();
+#else
+	assert(sizeof(pid_t) == 4);
+	return getpid();
+#endif
+}
+/*
+	number of processor
+	@note include hyperthread
+	@return 0 if error
+*/
+inline int GetProcessorNum()
+{
+#ifdef _WIN32
+	SYSTEM_INFO systemInfo;
+	::GetSystemInfo(&systemInfo);
+	return (int)systemInfo.dwNumberOfProcessors;
+#else
+	long ret = sysconf(_SC_NPROCESSORS_ONLN);
+	if (ret < 0) return 0;
+	return static_cast<int>(ret);
+#endif
+}
+
+namespace thread {
+
+#ifdef _WIN32
+	typedef HANDLE ThreadHandle;
+	const int Infinite = INFINITE;
+	typedef unsigned __stdcall ThreadEntryCallback(void*);
+#else
+	typedef pthread_t ThreadHandle;
+	const int Infinite = 0x7fffffff;
+	typedef void* ThreadEntryCallback(void*);
+#endif
+
+/**
+	generate thread handle
+	@param hdl [out] thread handle
+	@param entryFct [in] thread entry
+	@param arg [in] thread parameter
+*/
+inline bool Begin(ThreadHandle& hdl, ThreadEntryCallback entryFct, void *arg, int stackSize = 0)
+{
+#ifdef _WIN32
+	unsigned int threadId = 0;
+	hdl = reinterpret_cast<ThreadHandle>(_beginthreadex(0, stackSize, entryFct, arg, 0, &threadId));
+	return hdl != 0;
+#else
+	pthread_attr_t attr;
+	if (pthread_attr_init(&attr)) {
+		perror("pthread_attr_init");
+		return false;
+	}
+	int ret = 0;
+	if (stackSize) {
+		ret = pthread_attr_setstacksize(&attr, stackSize);
+		if (ret) {
+			perror("pthread_attr_setstacksize");
+			goto EXIT;
+		}
+	}
+	ret = pthread_create(&hdl, &attr, entryFct, arg);
+EXIT:
+	if (pthread_attr_destroy(&attr)) {
+		perror("pthread_attr_destroy");
+		return false;
+	}
+	return ret == 0;
+#endif
+}
+
+inline bool Detach(ThreadHandle hdl)
+{
+#ifdef _WIN32
+	int ret = CloseHandle(hdl);
+	return ret != 0;
+#else
+	int ret = pthread_detach(hdl);
+	return ret == 0;
+#endif
+}
+
+/**
+	join thread
+	@param hdl [in] thread handle
+	@param timeoutMsec [in] time out(msec)
+*/
+inline bool Join(ThreadHandle hdl, int timeoutMsec)
+{
+#ifdef _WIN32
+	bool waitRet = WaitForSingleObject(hdl, timeoutMsec) == WAIT_OBJECT_0;
+	bool closeRet = CloseHandle(hdl) != 0;
+	return waitRet && closeRet;
+#else
+	if (timeoutMsec != Infinite) {
+		fprintf(stderr, "not support timeout\n");
+	}
+	return pthread_join(hdl, NULL) == 0;
+#endif
+}
+
+} // cybozu::thread
+
+/**
+	thread generator class
+*/
+class ThreadBase {
+private:
+	ThreadBase(const ThreadBase&);
+	void operator=(const ThreadBase&);
+	virtual void threadEntry() = 0;
+protected:
+	thread::ThreadHandle threadHdl_;
+
+	/*
+		thread loop interface
+	*/
+#ifdef _WIN32
+	static unsigned __stdcall threadLoopIF(void *arg)
+#else
+	static void* threadLoopIF(void *arg)
+#endif
+	{
+		ThreadBase* main = static_cast<ThreadBase*>(arg);
+		main->threadEntry();
+		return 0;
+	}
+public:
+	ThreadBase()
+		: threadHdl_(0)
+	{
+	}
+	virtual ~ThreadBase()
+	{
+		joinThread();
+	}
+
+	bool beginThread(int stackSize = 0)
+	{
+		return thread::Begin(threadHdl_, threadLoopIF, this, stackSize);
+	}
+
+	bool detachThread()
+	{
+		thread::ThreadHandle hdl = cybozu::AtomicExchange<thread::ThreadHandle>(&threadHdl_, 0);
+		if (hdl) {
+			return thread::Detach(hdl);
+		}
+		return false;
+	}
+
+	bool joinThread(int waitMsec = thread::Infinite)
+	{
+		thread::ThreadHandle hdl = cybozu::AtomicExchange<thread::ThreadHandle>(&threadHdl_, 0);
+		if (hdl) {
+			return thread::Join(hdl, waitMsec);
+		}
+		return true;
+	}
+};
+
+} // cybozu
+
+#ifdef _MSC_VER
+	#pragma warning(pop)
+#endif