ooxml_crypt 0.1.0

data/vendor/cybozulib/test/base/sucvector_test.cpp

@@ -0,0 +1,312 @@
+#include <cybozu/test.hpp>
+#include <cybozu/sucvector.hpp>
+#include <cybozu/xorshift.hpp>
+#include <cybozu/benchmark.hpp>
+#include <sstream>
+#include <time.h>
+
+uint64_t select64n(uint64_t v, uint64_t n)
+{
+	size_t count = 0;
+	for (int i = 0; i < 64; i++) {
+		if (v & (uint64_t(1) << i))
+			count++;
+		if (count == n)
+			return i;
+	}
+	return 64;
+}
+
+uint64_t rank(const cybozu::SucVector& v, bool b, size_t n)
+{
+	uint64_t ret = 0;
+	for (size_t i = 0; i < n; i++) {
+		if (v.get(i) == b) {
+			ret++;
+		}
+	}
+	return ret;
+}
+
+uint64_t select(const cybozu::SucVector& v, bool b, size_t n)
+{
+	n++;
+	for (size_t i = 0; i < v.size(); i++) {
+		if (v.get(i) == b) n--;
+		if (n == 0) return i;
+	}
+	return cybozu::NotFound;
+}
+
+/*
+	compare speed
+	from https://code.google.com/p/shellinford/source/browse/trunk/src/shellinford_bit_vector.cc
+*/
+inline uint64_t select64C(uint64_t x, uint64_t i)
+{
+	uint64_t x1 = ((x  & 0xaaaaaaaaaaaaaaaaULL) >>  1) + (x  & 0x5555555555555555ULL);
+	uint64_t x2 = ((x1 & 0xccccccccccccccccULL) >>  2) + (x1 & 0x3333333333333333ULL);
+	uint64_t x3 = ((x2 & 0xf0f0f0f0f0f0f0f0ULL) >>  4) + (x2 & 0x0f0f0f0f0f0f0f0fULL);
+	uint64_t x4 = ((x3 & 0xff00ff00ff00ff00ULL) >>  8) + (x3 & 0x00ff00ff00ff00ffULL);
+	uint64_t x5 = ((x4 & 0xffff0000ffff0000ULL) >> 16) + (x4 & 0x0000ffff0000ffffULL);
+//	i++;
+	uint64_t pos = 0;
+	uint64_t v5 = x5 & 0xffffffffULL;
+	if (i > v5) { i -= v5; pos += 32; }
+	uint64_t v4 = (x4 >> pos) & 0x0000ffffULL;
+	if (i > v4) { i -= v4; pos += 16; }
+	uint64_t v3 = (x3 >> pos) & 0x000000ffULL;
+	if (i > v3) { i -= v3; pos +=  8; }
+	uint64_t v2 = (x2 >> pos) & 0x0000000fULL;
+	if (i > v2) { i -= v2; pos +=  4; }
+	uint64_t v1 = (x1 >> pos) & 0x00000003ULL;
+	if (i > v1) { i -= v1; pos +=  2; }
+	uint64_t v0 = (x  >> pos) & 0x00000001ULL;
+	if (i > v0) { i -= v0; pos +=  1; }
+	return pos;
+}
+
+CYBOZU_TEST_AUTO(testall)
+{
+	cybozu::XorShift rg;
+	const size_t N = 30;
+	std::vector<uint64_t> v;
+	v.resize(N);
+	for (size_t i = 0; i < N; i++) {
+		v[i] = rg.get64();
+	}
+	cybozu::SucVector sv;
+	sv.init(&v[0], v.size() * 64);
+	for (size_t i = 0; i < sv.size(); i++) {
+		CYBOZU_TEST_EQUAL(sv.rank(true, i), rank(sv, true, i));
+		CYBOZU_TEST_EQUAL(sv.rank(false, i), rank(sv, false, i));
+		CYBOZU_TEST_EQUAL(sv.select(true, i), select(sv, true, i));
+		CYBOZU_TEST_EQUAL(sv.select(false, i), select(sv, false, i));
+	}
+}
+
+CYBOZU_TEST_AUTO(test0)
+{
+	cybozu::SucVector sv;
+	uint64_t blk = 722;
+	sv.init(&blk, 64); // 0100101101
+	CYBOZU_TEST_EQUAL(sv.rank(1, 6), 2u);
+	CYBOZU_TEST_EQUAL(sv.select(0, 4), 8u);
+}
+
+CYBOZU_TEST_AUTO(select)
+{
+	const uint64_t v[] = {
+		0xdca345ea1b5116e6ULL,
+		0x951049aad88d00b0ULL,
+		0x1ec7825e8db24146ULL,
+		0x9af814432ac00f2cULL,
+		0xffffffffffffffffULL,
+		0x242342afecbfe4aaULL,
+		0xffffffffffffffffULL,
+		0xf324987abcef3242ULL
+	};
+	const size_t bitLen = sizeof(v) * 8;
+	cybozu::SucVector sv;
+	sv.init(v, bitLen);
+	for (int s = 0; s < 2; s++) {
+		const bool b = s == 0;
+		const uint64_t max = sv.rank(b, bitLen);
+		for (size_t r = 0; r < max; r++) {
+			CYBOZU_TEST_EQUAL(sv.select(b, r), select(sv, b, r));
+			CYBOZU_TEST_EQUAL(sv.rank(b, sv.select(b, r) + 1), r + 1);
+		}
+	}
+}
+
+CYBOZU_TEST_AUTO(relation)
+{
+	const uint64_t v = 0x242342afecbfe4aaULL;
+	const size_t max = cybozu::popcnt<uint64_t>(v);
+	for (size_t r = 0; r < max; r++) {
+		CYBOZU_TEST_EQUAL(cybozu::sucvector_util::rank64(v, cybozu::sucvector_util::select64(v, r) + 1), r);
+		CYBOZU_TEST_EQUAL(cybozu::sucvector_util::rank64(v, cybozu::sucvector_util::select64(v, r + 1) + 1), r + 1);
+	}
+}
+
+CYBOZU_TEST_AUTO(rank)
+{
+	cybozu::SucVector sv;
+	uint64_t blk = 6;
+	sv.init(&blk, 64); // 0b0110
+	const struct {
+		bool val;
+		uint32_t rank0;
+		uint32_t rank1;
+	} tbl [] = {
+		{ 0, 1, 0 },
+		{ 1, 1, 1 },
+		{ 1, 1, 2 },
+		{ 0, 2, 2 },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		CYBOZU_TEST_EQUAL(sv.rank0(i + 1), tbl[i].rank0);
+		CYBOZU_TEST_EQUAL(sv.rank1(i + 1), tbl[i].rank1);
+		CYBOZU_TEST_EQUAL(sv.get(i), tbl[i].val);
+	}
+}
+
+bool get(const uint64_t *blk, size_t pos)
+{
+	size_t q = pos / 64;
+	size_t r = pos & 63;
+	return ((blk[q] >> r) & 1) != 0;
+}
+
+uint32_t count(const uint64_t *blk, size_t pos)
+{
+	uint32_t ret = 0;
+	for (size_t i = 0; i < pos; i++) {
+		if (get(blk, i)) ret++;
+	}
+	return ret;
+}
+
+void testSub(const cybozu::SucVector& sv, const uint64_t *tbl, size_t tblNum)
+{
+	for (size_t i = 0; i < tblNum * 64; i++) {
+		CYBOZU_TEST_EQUAL(sv.get(i), get(tbl, i));
+		CYBOZU_TEST_EQUAL(sv.rank1(i), count(tbl, i));
+	}
+	CYBOZU_TEST_EQUAL(sv.rank0(tblNum * 64), sv.size(0));
+	CYBOZU_TEST_EQUAL(sv.rank1(tblNum * 64), sv.size(1));
+}
+
+CYBOZU_TEST_AUTO(get_load_save)
+{
+	uint64_t tbl[] = {
+		0x1234567812345678ULL, 0xffffffffffffffffULL, 0x1020304050607080ULL,
+		0x3172039874192874ULL, 0x0000000000000000ULL, 0xfeabcbfeacbefaaeULL,
+		0xfefefefefefefeefULL, 0x1864192836419823ULL, 0xaaaaaaaaaaaaaaaaULL,
+	};
+	const size_t tblNum = CYBOZU_NUM_OF_ARRAY(tbl);
+	cybozu::SucVector sv;
+	sv.init(tbl, tblNum * 64);
+
+	testSub(sv, tbl, tblNum);
+	std::string data;
+	{
+		std::ostringstream os;
+		sv.save(os);
+		data = os.str();
+	}
+	{
+		std::istringstream is(data);
+		cybozu::SucVector sv2;
+		sv2.load(is);
+		testSub(sv2, tbl, tblNum);
+	}
+}
+
+CYBOZU_TEST_AUTO(select8)
+{
+	const uint32_t s = 13;
+	for (uint32_t v = 0; v < (1 << s); v++) {
+		for (uint32_t x = 0; x < s; x++) {
+			uint64_t a = cybozu::sucvector_util::select64(v, x);
+//			uint64_t a = select64n(v, x);
+			uint64_t b = select64C(v, x);
+			if (a < 64) {
+				CYBOZU_TEST_EQUAL(a, b);
+			}
+		}
+	}
+}
+
+CYBOZU_TEST_AUTO(select64)
+{
+	uint64_t tbl[] = {
+		0xf0f0f0f0f0f030eeULL,
+		0x0000000000000006ULL,
+		0x0000000000000000ULL,
+		0x0000000000000001ULL,
+		0x9190751837459273ULL,
+		0xffffffffffffffffULL,
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		uint64_t v = tbl[i];
+		for (size_t x = 0; x < 64; x++) {
+//			uint64_t a = select64C(v, x);
+			uint64_t a = cybozu::sucvector_util::select64(v, x);
+			uint64_t b = select64n(v, x);
+			if (a < 64) {
+				CYBOZU_TEST_EQUAL(a, b);
+			}
+		}
+	}
+}
+
+#ifdef NDEBUG
+
+template<class R, class P1, class P2>
+struct BenchSelect {
+	cybozu::XorShift rg_;
+	uint64_t ret_;
+	R (*f_)(P1, P2);
+	BenchSelect(const char *msg, R (*f)(P1, P2))
+		: ret_(0)
+		, f_(f)
+	{
+		printf("%s", msg);
+		CYBOZU_BENCH("", run);
+		printf(" %x\n", (int)ret_);
+	}
+	void run()
+	{
+		uint64_t v = rg_.get64();
+		int x = rg_.get32() % 64;
+		ret_ += f_(v, x);
+	}
+};
+
+template<class T, class F>
+void bench(const T& sv, const F& f, size_t N)
+{
+	const uint64_t M = sv.size();
+	cybozu::XorShift rg;
+	uint64_t ret = 0;
+	clock_t begin = clock();
+	for (size_t i = 0; i < N; i++) {
+		uint64_t x = rg() & (M - 1);
+		ret += (sv.*f)((x & 1) != 0, x);
+	}
+	double t = (clock() - begin) / double(CLOCKS_PER_SEC) / N * 1e9;
+	printf("ret=%x, %.2fnsec\n", (int)ret, t);
+}
+
+template<class Suc>
+void benchAll(size_t bitN)
+{
+	cybozu::XorShift rg;
+	const size_t N = size_t(1) << bitN;
+	std::vector<uint64_t> v(N / 64);
+	for (size_t i = 0, n = v.size(); i < n; i++) {
+		v[i] = rg.get64();
+	}
+	Suc sv;
+	sv.init(&v[0], N);
+	puts("bench");
+	puts("rank");
+	bench(sv, &Suc::rank, 10000000);
+	puts("select");
+	bench(sv, &Suc::select, 1000000);
+}
+
+CYBOZU_TEST_AUTO(select64Bench)
+{
+	BenchSelect<uint64_t, uint64_t, uint64_t>("select64C  ", select64C);
+	BenchSelect<uint32_t, uint64_t, size_t>  ("cy:select64", cybozu::sucvector_util::select64);
+	BenchSelect<uint64_t, uint64_t, uint64_t>("select64n  ", select64n);
+
+	puts("SucVectorLt4G");
+	benchAll<cybozu::SucVectorLt4G>(31);
+	puts("SucVector");
+	benchAll<cybozu::SucVector>(31);
+}
+#endif
+

data/vendor/cybozulib/test/base/thread_test.cpp

@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include <cybozu/thread.hpp>
+#include <cybozu/mutex.hpp>
+#include <cybozu/test.hpp>
+#include <cybozu/atomic.hpp>
+
+const int N = 1000000;
+int s_count = 0;
+
+class ThreadTest : public cybozu::ThreadBase {
+	cybozu::Mutex& mutex_;
+	int num_;
+public:
+	ThreadTest(cybozu::Mutex& mutex, int num)
+		: mutex_(mutex)
+		, num_(num)
+	{
+		printf("make %d\n", num_);
+	}
+
+	void threadEntry()
+	{
+		printf("start %d\n", num_);
+		for (int i = 0; i < N; i++) {
+			cybozu::AutoLock al(mutex_);
+			s_count++;
+		}
+		printf("end %d\n", num_);
+	}
+};
+
+CYBOZU_TEST_AUTO(cpuNum)
+{
+	int num = cybozu::GetProcessorNum();
+	CYBOZU_TEST_ASSERT(num > 0);
+	printf("cpu num=%d\n", num);
+}
+
+CYBOZU_TEST_AUTO(autoLock)
+{
+	cybozu::Mutex mutex_;
+	ThreadTest t1(mutex_, 1);
+	ThreadTest t2(mutex_, 2);
+	if (!t1.beginThread()) puts("err thread 1");
+	if (!t2.beginThread()) puts("err thread 2");
+	cybozu::Sleep(1000);
+	/*
+		verity number of increment
+	*/
+	puts("start main");
+	for (int i = 0; i < N; i++) {
+		cybozu::AutoLock al(mutex_);
+		s_count++;
+	}
+	puts("end main");
+
+	if (!t1.joinThread()) puts("err join 1");
+	if (!t2.joinThread()) puts("err join 2");
+	cybozu::mfence();
+	CYBOZU_TEST_EQUAL(s_count, N * 3);
+}
+

data/vendor/cybozulib/test/base/time_test.cpp

@@ -0,0 +1,164 @@
+#include <stdio.h>
+#include <memory.h>
+#include <cybozu/time.hpp>
+#include <cybozu/test.hpp>
+
+#ifdef _WIN32
+	#define MK_GMT_TIME(x) _mkgmtime64(x)
+#else
+	#define MK_GMT_TIME(x) timegm(x)
+#endif
+
+std::string timeToStr(std::time_t & time, int year, int month, int day, int hour, int minute, int second, int msec, int mode)
+{
+	struct tm tm;
+	tm.tm_year = year - 1900;
+	tm.tm_mon = month - 1;
+	tm.tm_mday = day;
+	tm.tm_hour = hour;
+	tm.tm_min = minute;
+	tm.tm_sec = second;
+	tm.tm_isdst = 0;
+	time = MK_GMT_TIME(&tm);
+
+	char buf[64];
+	if (mode & 1) {
+		// "2009-01-23 02:53:44"
+		strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm);
+	} else {
+		// "2009-Jan-23 02:53:44"
+		strftime(buf, sizeof(buf), "%Y-%b-%d %H:%M:%S", &tm);
+	}
+	std::string str = buf;
+	if (mode & 2) {
+		char buf2[64];
+		CYBOZU_SNPRINTF(buf2, 5, ".%03d", msec);
+		str += buf2;
+	}
+	return str;
+}
+
+CYBOZU_TEST_AUTO(fromString1)
+{
+	std::string str;
+	std::time_t time;
+	for (int mode = 0; mode < 4; mode++) {
+		int year = 2009;
+		int day = 23;
+		int hour = 2;
+		int minute = 53;
+		int second = 41;
+		int msec = 72;
+		for (int month = 1; month <= 12; month++) {
+			str = timeToStr(time, year, month, day, hour, minute, second, msec, mode);
+			cybozu::Time tm(str);
+			CYBOZU_TEST_EQUAL(tm.getTime(), time);
+			if (mode & 2) {
+				CYBOZU_TEST_EQUAL(tm.getMsec(), msec);
+			}
+		}
+	}
+}
+
+CYBOZU_TEST_AUTO(fromString2)
+{
+	const struct Data {
+		const char *str;
+		int year;
+		int month;
+		int day;
+		int hour;
+		int minute;
+		int second;
+		int msec;
+	} tbl[] = {
+		{ "2009-Jan-23T02:53:44Z", 2009, 1, 23, 2, 53, 44, 0 },
+		{ "2009-Jan-23T02:53:44.078Z", 2009, 1, 23, 2, 53, 44, 78 },
+		{ "2009-Jan-23T02:53:44", 2009, 1, 23, 2, 53, 44, 0 },
+		{ "2009-Jan-23T02:53:44.078", 2009, 1, 23, 2, 53, 44, 78 },
+		{ "2009-Jan-23 02:53:44", 2009, 1, 23, 2, 53, 44, 0 },
+		{ "2009-Jan-23 02:53:44.078", 2009, 1, 23, 2, 53, 44, 78 },
+		{ "2009/Jan/23 02:53:44", 2009, 1, 23, 2, 53, 44, 0 },
+		{ "2009/Jan/23 02:53:44.078", 2009, 1, 23, 2, 53, 44, 78 },
+		{ "2009/01/23 02:53:44", 2009, 1, 23, 2, 53, 44, 0 },
+		{ "2009/01/23 02:53:44.078", 2009, 1, 23, 2, 53, 44, 78 },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		const Data& d = tbl[i];
+		std::time_t time;
+		timeToStr(time, d.year, d.month, d.day, d.hour, d.minute, d.second, d.msec, 0);
+		{
+			cybozu::Time t;
+			t.fromString(std::string(d.str));
+			CYBOZU_TEST_EQUAL(t.getTime(), time);
+		}
+		cybozu::Time tm(d.str);
+		CYBOZU_TEST_EQUAL(tm.getTime(), time);
+		CYBOZU_TEST_EQUAL(tm.getMsec(), d.msec);
+		uint32_t high, low;
+		tm.getFILETIME(low, high);
+		cybozu::Time tm2;
+		tm2.setByFILETIME(low, high);
+		CYBOZU_TEST_EQUAL(tm, tm2);
+	}
+	bool b;
+	cybozu::Time t;
+	t.fromString(&b, "2009-01-23T02:53:44Z");
+	CYBOZU_TEST_ASSERT(b);
+	t.fromString(&b, "2009-01-23T02:53:44x");
+	CYBOZU_TEST_ASSERT(!b);
+}
+
+CYBOZU_TEST_AUTO(toString)
+{
+	const struct Data {
+		const char *str;
+		const char *strMsec;
+		int year;
+		int month;
+		int day;
+		int hour;
+		int minute;
+		int second;
+		int msec;
+	} tbl[] = {
+		{ "2013-11-05 12:23:56", ".123", 2013, 11, 5, 12, 23, 56, 123 },
+		{ "1970-01-01 00:00:00", ".000", 1970, 1, 1, 0, 0, 0, 0 },
+		{ "2040-02-05 12:30:20", ".999", 2040, 2, 5, 12, 30, 20, 999 },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		const Data& d = tbl[i];
+		std::time_t time;
+		timeToStr(time, d.year, d.month, d.day, d.hour, d.minute, d.second, d.msec, 0);
+		cybozu::Time tm(time, d.msec);
+		std::string s;
+		tm.toString(s);
+		CYBOZU_TEST_EQUAL(s, std::string(tbl[i].str) + tbl[i].strMsec);
+		tm.toString(s, false);
+		CYBOZU_TEST_EQUAL(s, tbl[i].str);
+	}
+}
+#ifdef _WIN32
+#include <sstream>
+
+CYBOZU_TEST_AUTO(filetime_win)
+{
+	SYSTEMTIME st;
+	GetSystemTime(&st);
+	// 2009-01-23 02:53:44.078
+	char buf[256];
+	CYBOZU_SNPRINTF(buf, sizeof(buf) - 1, "%04d-%02d-%02d %02d:%02d:%02d.%03d", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
+	std::string t1 = buf;
+
+	FILETIME ft;
+	SystemTimeToFileTime(&st, &ft);
+	cybozu::Time time;
+	time.setByFILETIME(ft.dwLowDateTime, ft.dwHighDateTime);
+	std::string t2 = time.toString();
+	CYBOZU_TEST_EQUAL(t1, t2);
+	FILETIME ft2;
+	time.getFILETIME(ft2.dwLowDateTime, ft2.dwHighDateTime);
+	CYBOZU_TEST_EQUAL(ft.dwLowDateTime, ft2.dwLowDateTime);
+	CYBOZU_TEST_EQUAL(ft.dwHighDateTime, ft2.dwHighDateTime);
+}
+#endif

data/vendor/cybozulib/test/base/tls_test.cpp

@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <cybozu/thread.hpp>
+#include <cybozu/tls.hpp>
+#include <cybozu/test.hpp>
+
+static CYBOZU_TLS int s_x;
+
+class Test : public cybozu::ThreadBase {
+	int a_;
+	cybozu::Tls *tls_;
+public:
+	Test()
+		: a_(0)
+		, tls_(0)
+	{
+	}
+	void set(int a, cybozu::Tls& tls)
+	{
+		a_ = a;
+		tls_ = &tls;
+	}
+	void threadEntry()
+	{
+		printf("start %d\n", a_);
+		s_x = a_;
+		tls_->set(&a_);
+		cybozu::Sleep(500);
+		printf("tls=%d, s_x=%d, %p\n", *static_cast<const int*>(tls_->get()), s_x, &s_x);
+		CYBOZU_TEST_EQUAL(a_, s_x);
+		CYBOZU_TEST_EQUAL(a_, *static_cast<const int*>(tls_->get()));
+	}
+};
+
+CYBOZU_TEST_AUTO(tls)
+{
+	cybozu::Tls tls;
+	{
+		const int n = 10;
+		Test t[n];
+		for (int i = 0; i < n; i++) {
+			t[i].set(i, tls);
+		}
+		for (int i = 0; i < n; i++) {
+			t[i].beginThread();
+		}
+		for (int i = 0; i < n; i++) {
+			t[i].joinThread();
+		}
+	}
+}