ooxml_crypt 0.1.0

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

@@ -0,0 +1,49 @@
+#include <cybozu/atomic.hpp>
+#include <cybozu/test.hpp>
+
+CYBOZU_TEST_AUTO(atomic_not_in_thread)
+{
+	int a, b, c;
+	int64_t ia, ib;
+
+	a = 2, b = 5;
+	cybozu::AtomicAdd(&a, b);
+	CYBOZU_TEST_EQUAL(a, 7);
+
+#if (CYBOZU_OS_BIT == 64)
+	ia = 4, ib = 9;
+	cybozu::AtomicAdd(&ia, ib);
+	CYBOZU_TEST_EQUAL(ia, 13);
+#endif
+
+	a = 4;
+	c = cybozu::AtomicCompareExchange(&a, 9, 4);
+	CYBOZU_TEST_EQUAL(c, 4);
+	CYBOZU_TEST_EQUAL(a, 9);
+
+	a = 4;
+	c = cybozu::AtomicCompareExchange(&a, 9, 5);
+	CYBOZU_TEST_EQUAL(c, 4);
+	CYBOZU_TEST_EQUAL(a, 4);
+
+	ia = 10;
+	ib = cybozu::AtomicCompareExchange<int64_t>(&ia, 0x123456789012LL, 10);
+	CYBOZU_TEST_EQUAL(ib, 10);
+	CYBOZU_TEST_EQUAL(ia, 0x123456789012LL);
+
+	ia = 10;
+	ib = cybozu::AtomicCompareExchange<int64_t>(&ia, 0x123456789012LL, 11);
+	CYBOZU_TEST_EQUAL(ib, 10);
+	CYBOZU_TEST_EQUAL(ia, 10);
+
+	a = 3;
+	b = cybozu::AtomicExchange(&a, 4);
+	CYBOZU_TEST_EQUAL(b, 3);
+	CYBOZU_TEST_EQUAL(a, 4);
+
+	size_t ua, ub;
+	ua = 5;
+	ub = cybozu::AtomicExchange<size_t>(&ua, 4);
+	CYBOZU_TEST_EQUAL(ua, 4ULL);
+	CYBOZU_TEST_EQUAL(ub, 5ULL);
+}

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

@@ -0,0 +1,113 @@
+#include <cybozu/test.hpp>
+#include <cybozu/base64.hpp>
+#include <string>
+
+CYBOZU_TEST_AUTO(base64)
+{
+	const struct {
+		std::string in;
+		std::string out;
+		size_t maxLineSize;
+	} tbl[] = {
+		{ "", "", 76 },
+		{ "1", "MQ==\r\n", 8 },
+		{ "12", "MTI=\r\n", 8 },
+		{ "123", "MTIz\r\n", 8 },
+		{ "1234", "MTIzNA==\r\n", 8 },
+		{ "12345", "MTIzNDU=\r\n", 8 },
+		{ "123456", "MTIzNDU2\r\n", 8 },
+		{ "1234567", "MTIzNDU2\r\nNw==\r\n", 8 },
+		{ "12345678", "MTIzNDU2\r\nNzg=\r\n", 8 },
+		{ "123456789", "MTIzNDU2\r\nNzg5\r\n", 8 },
+		{ "123456789a", "MTIzNDU2\r\nNzg5YQ==\r\n", 8 },
+		{ "123456789ab", "MTIzNDU2\r\nNzg5YWI=\r\n", 8 },
+		{ "123456789abc", "MTIzNDU2\r\nNzg5YWJj\r\n", 8 },
+		{ "123456789abcd", "MTIzNDU2\r\nNzg5YWJj\r\nZA==\r\n", 8 },
+
+		{ "1", "MQ==", 0 },
+		{ "12", "MTI=", 0 },
+		{ "123", "MTIz", 0 },
+		{ "1234", "MTIzNA==", 0 },
+		{ "12345", "MTIzNDU=", 0 },
+		{ "123456", "MTIzNDU2", 0 },
+		{ "1234567", "MTIzNDU2Nw==", 0 },
+		{ "12345678", "MTIzNDU2Nzg=", 0 },
+		{ "123456789", "MTIzNDU2Nzg5", 0 },
+		{ "123456789a", "MTIzNDU2Nzg5YQ==", 0 },
+		{ "123456789ab", "MTIzNDU2Nzg5YWI=", 0 },
+		{ "123456789abc", "MTIzNDU2Nzg5YWJj", 0 },
+		{ "123456789abcd", "MTIzNDU2Nzg5YWJjZA==", 0 },
+
+		{ "123456789012345678901234567890123456789012345678901234567",
+		  "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3\r\n", 76 },
+		{ "123456789012345678901234567890123456789012345678901234567"
+		  "890123456789012345678901234567890123456789012345678901234"
+		  "567890123456789012345678901234567890123456789012345678901"
+		  "23456789012345678901234567890",
+		  "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3\r\n"
+		  "ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0\r\n"
+		  "NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAx\r\n"
+		  "MjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTA=\r\n", 76},
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		cybozu::StringInputStream is(tbl[i].in);
+		std::string str;
+		cybozu::StringOutputStream os(str);
+		cybozu::EncodeToBase64(os, is, tbl[i].maxLineSize);
+		CYBOZU_TEST_EQUAL(str.size(), tbl[i].out.size());
+		CYBOZU_TEST_EQUAL(str, tbl[i].out);
+	}
+
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		cybozu::StringInputStream is(tbl[i].out);
+		std::string str;
+		cybozu::StringOutputStream os(str);
+		cybozu::DecodeFromBase64(os, is);
+		CYBOZU_TEST_EQUAL(str.size(), tbl[i].in.size());
+		CYBOZU_TEST_EQUAL(str, tbl[i].in);
+	}
+}
+
+CYBOZU_TEST_AUTO(decodeSkip)
+{
+	const struct {
+		std::string in;
+		std::string out;
+	} tbl[] = {
+		{ "123456789a", "MTIzNDU2\r\n$$Nz%%~~!!g5YQ==\r\n" },
+		{ "123456789ab", "MTIzNDU>>2<<\r\nNzg5YWI=!!\r\n" },
+
+		{ "123", "MTIz" },
+		{ "1234", "MT	I z NA==" },
+		{ "12345", "MTIzNDU=" },
+		{ "123456", "MTIzNDU2" },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		cybozu::StringInputStream is(tbl[i].out);
+		std::string str;
+		cybozu::StringOutputStream os(str);
+		cybozu::DecodeFromBase64(os, is);
+		CYBOZU_TEST_EQUAL(str.size(), tbl[i].in.size());
+		CYBOZU_TEST_EQUAL(str, tbl[i].in);
+	}
+}
+
+CYBOZU_TEST_AUTO(ignoreAllEqual)
+{
+	/* we verify the number of '=' */
+	const struct {
+		std::string in;
+		std::string out;
+	} tbl[] = {
+		{ "123", "M=T===Iz=" },
+		{ "123", "M====TIz==" },
+		{ "123", "MT===Iz===" },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		cybozu::StringInputStream is(tbl[i].out);
+		std::string str;
+		cybozu::StringOutputStream os(str);
+		cybozu::DecodeFromBase64(os, is);
+		CYBOZU_TEST_EQUAL(str, tbl[i].in);
+	}
+}

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

@@ -0,0 +1,134 @@
+#include <cybozu/test.hpp>
+#include <cybozu/bit_operation.hpp>
+
+CYBOZU_TEST_AUTO(bsf)
+{
+	const struct {
+		uint32_t x;
+		int val;
+	} tbl[] = {
+		{ 1, 0 },
+		{ 2, 1 },
+		{ 3, 0 },
+		{ 4, 2 },
+		{ 0xffffffff, 0 },
+		{ 0x80000000, 31 },
+		{ 0x80000010, 4 },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		CYBOZU_TEST_EQUAL(cybozu::bsf(tbl[i].x), tbl[i].val);
+	}
+}
+
+CYBOZU_TEST_AUTO(bsr)
+{
+	const struct {
+		uint32_t x;
+		int val;
+	} tbl[] = {
+		{ 1, 0 },
+		{ 2, 1 },
+		{ 3, 1 },
+		{ 4, 2 },
+		{ 0xfff, 11 },
+		{ 0xfffff, 19 },
+		{ 0xffffffff, 31 },
+		{ 0x80000000, 31 },
+		{ 0x80000010, 31 },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		CYBOZU_TEST_EQUAL(cybozu::bsr(tbl[i].x), tbl[i].val);
+	}
+}
+
+CYBOZU_TEST_AUTO(bsf64)
+{
+	const struct {
+		uint64_t x;
+		int val;
+	} tbl[] = {
+		{ 1, 0 },
+		{ 2, 1 },
+		{ 3, 0 },
+		{ 4, 2 },
+		{ 0xffffffff, 0 },
+		{ 0x80000000, 31 },
+		{ 0x100000000ULL, 32 },
+		{ 0xffffffffffffffffULL, 0 },
+		{ 0x8000000000000000ULL, 63 },
+		{ 0x8000000000000010ULL, 4 },
+		{ 0x8000001000000000ULL, 36 },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		CYBOZU_TEST_EQUAL(cybozu::bsf(tbl[i].x), tbl[i].val);
+	}
+}
+
+CYBOZU_TEST_AUTO(bsr64)
+{
+	const struct {
+		uint64_t x;
+		int val;
+	} tbl[] = {
+		{ 1, 0 },
+		{ 2, 1 },
+		{ 3, 1 },
+		{ 4, 2 },
+		{ 0xfff, 11 },
+		{ 0xfffff, 19 },
+		{ 0xffffffff, 31 },
+		{ 0x80000000, 31 },
+		{ 0x100000000ULL, 32 },
+		{ 0x1100000000ULL, 36 },
+		{ 0xffffffffffffffffULL, 63 },
+		{ 0x8000000000000000ULL, 63 },
+		{ 0x8000001000000000ULL, 63 },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		CYBOZU_TEST_EQUAL(cybozu::bsr(tbl[i].x), tbl[i].val);
+	}
+}
+
+CYBOZU_TEST_AUTO(popcnt)
+{
+	const struct {
+		uint32_t x;
+		uint32_t val;
+	} tbl[] = {
+		{ 0, 0 },
+		{ 1, 1 },
+		{ 2, 1 },
+		{ 3, 2 },
+		{ 4, 1 },
+		{ 5, 2 },
+		{ 0xfff, 12 },
+		{ 0xf0000000, 4 },
+		{ 0xffffffff, 32 },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		CYBOZU_TEST_EQUAL(cybozu::popcnt(tbl[i].x), tbl[i].val);
+	}
+}
+
+CYBOZU_TEST_AUTO(popcnt64)
+{
+	const struct {
+		uint64_t x;
+		uint32_t val;
+	} tbl[] = {
+		{ 0, 0 },
+		{ 1, 1 },
+		{ 2, 1 },
+		{ 3, 2 },
+		{ 4, 1 },
+		{ 5, 2 },
+		{ 0xfff, 12 },
+		{ 0xffffffff, 32 },
+		{ 0xfffffffffull, 36 },
+		{ 0xf000000000000000ull, 4 },
+		{ 0xffffffffffffffffull, 64 },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		CYBOZU_TEST_EQUAL(cybozu::popcnt(tbl[i].x), tbl[i].val);
+	}
+}

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

@@ -0,0 +1,204 @@
+#include <cybozu/test.hpp>
+#include <cybozu/bitvector.hpp>
+#include <cybozu/xorshift.hpp>
+
+CYBOZU_TEST_AUTO(set)
+{
+	cybozu::BitVector cv;
+	std::vector<bool> sv;
+	cybozu::XorShift rg;
+	const size_t size = 100;
+	cv.resize(size);
+	sv.resize(size);
+	for (int j = 0; j < 2; j++) {
+		for (size_t i = 0; i < size; i++) {
+			bool b = (rg.get32() & 1) != 0;
+			cv.set(i, b);
+			sv[i] = b;
+		}
+		for (size_t i = 0; i < size; i++) {
+			CYBOZU_TEST_EQUAL(cv.get(i), sv[i]);
+		}
+	}
+}
+
+CYBOZU_TEST_AUTO(resize)
+{
+	uint16_t x[] = { 0x1234, 0x5678, 0x9abc };
+	cybozu::BitVectorT<uint16_t> v;
+	v.append(x, 48);
+	CYBOZU_TEST_EQUAL(v.size(), 48);
+	CYBOZU_TEST_EQUAL(v.getBlock()[2], x[2]);
+	uint16_t val = x[2];
+	for (size_t i = 47; i >= 33; i--) {
+		v.resize(i);
+		CYBOZU_TEST_EQUAL(v.size(), i);
+		CYBOZU_TEST_EQUAL(v.getBlock()[2], val & cybozu::GetMaskBit<uint16_t>(i - 32));
+	}
+}
+
+struct StdVec : std::vector<bool> {
+	template<class T>
+	void append(const T*src, size_t bitLen)
+	{
+		for (size_t i = 0; i < bitLen; i++) {
+			bool b = cybozu::GetBlockBit(src, i);
+			push_back(b);
+		}
+	}
+	void append(size_t src, size_t bitLen)
+	{
+		for (size_t i = 0; i < bitLen; i++) {
+			bool b = (src & (size_t(1) << i)) != 0;
+			push_back(b);
+		}
+	}
+};
+
+template<class T>
+void verifyVec(const T& v1, const StdVec& v2)
+{
+	CYBOZU_TEST_EQUAL(v1.size(), v2.size());
+	int sum = 0;
+	for (size_t i = 0; i < v1.size(); i++) {
+		sum += v1.get(i) ^ v2[i];
+	}
+	CYBOZU_TEST_EQUAL(sum, 0);
+}
+
+CYBOZU_TEST_AUTO(shiftLeftBit)
+{
+	const struct {
+		uint32_t x[4];
+		size_t bitLen;
+		size_t shift;
+		uint32_t z0;
+		uint32_t z[5];
+	} tbl[] = {
+		{ { 1, 0, 0, 0 }, 1, 1, 0xfffffff, { 3, 0, 0, 0 } },
+		{ { 0x12345678, 0, 0, 0 }, 16, 16, 0xabcd1234, { 0x56781234, 0, 0, 0 } },
+		{ { 0x12345678, 0, 0, 0 }, 16, 17, 0xabcd1234, { 0xacf11234, 0x0, 0, 0 } },
+		{ { 0x12345678, 0, 0, 0 }, 16, 18, 0xabcd1234, { 0x59e11234, 0x1, 0, 0 } },
+		{ { 0x12345678, 0, 0, 0 }, 32, 31, 0xabcd1234, { 0x2bcd1234, 0x91a2b3c, 0, 0 } },
+		{ { 0x12345678, 0x9abcdef0, 0x11112222, 0xffccaaee }, 128, 19, 0x983a4ba, { 0xb3c3a4ba, 0xf78091a2, 0x1114d5e6, 0x57708889, 0x7fe65 } },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		const size_t bitLen = tbl[i].bitLen;
+		const size_t shift = tbl[i].shift;
+		uint32_t z[5];
+		z[0] = tbl[i].z0;
+		cybozu::bitvector_local::shiftLeftBit(z, tbl[i].x, bitLen, shift);
+		const size_t n = cybozu::RoundupBit<uint32_t>(bitLen + shift);
+		CYBOZU_TEST_EQUAL_ARRAY(z, tbl[i].z, n);
+	}
+}
+
+CYBOZU_TEST_AUTO(shiftRightBit)
+{
+	const struct {
+		uint32_t x[5];
+		size_t bitLen;
+		size_t shift;
+		uint32_t z[4];
+	} tbl[] = {
+		{ { 0x12345678, 0, 0, 0 }, 1, 1, { 0, 0, 0, 0 } },
+		{ { 0x12345678, 0, 0, 0 }, 1, 3, { 1, 0, 0, 0 } },
+		{ { 0x12345678, 0xaaaabbbb, 0, 0 }, 10, 31, { 0x376, 0, 0, 0 } },
+		{ { 0x12345678, 0, 0, 0 }, 1, 1, { 0, 0, 0, 0 } },
+		{ { 0x12345678, 0, 0, 0 }, 13, 5, { 0x2b3, 0, 0, 0 } },
+		{ { 0x12345678, 0xaaaabbbb, 0xffeebbcc, 0xfeba9874, 1 }, 128, 1, { 0x891a2b3c, 0x55555ddd, 0x7ff75de6, 0xff5d4c3a } },
+		{ { 0x12345678, 0xaaaabbbb, 0xffeebbcc, 0xfeba9874, 0 }, 128, 1, { 0x891a2b3c, 0x55555ddd, 0x7ff75de6, 0x7f5d4c3a } },
+		{ { 0x12345678, 0xaaaabbbb, 0xffeebbcc, 0xfeba9874, 0 }, 128, 18, { 0xaeeec48d, 0xaef32aaa, 0xa61d3ffb, 0x3fae } },
+		{ { 0x12345678, 0xaaaabbbb, 0xffeebbcc, 0xfeba9874, 0 }, 96, 18, { 0xaeeec48d, 0xaef32aaa, 0xa61d3ffb, 0 } },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		uint32_t z[4];
+		cybozu::bitvector_local::shiftRightBit(z, tbl[i].x, tbl[i].bitLen, tbl[i].shift);
+		const size_t n = cybozu::RoundupBit<uint32_t>(tbl[i].bitLen);
+		CYBOZU_TEST_EQUAL_ARRAY(z, tbl[i].z, n);
+	}
+}
+
+CYBOZU_TEST_AUTO(append)
+{
+	const uint16_t src1[] = { 0x3210, 0x7654, 0xba98 };
+	const uint16_t src2[] = { 0xabcd, 0xfebd, 0xffff };
+	typedef cybozu::BitVectorT<uint16_t> Vec;
+	{
+		Vec v1;
+		StdVec v2;
+		v1.append(src1, 2);
+		v2.append(src1, 2);
+		v1.append(src2, 16);
+		v2.append(src2, 16);
+		verifyVec(v1, v2);
+		Vec v3, v4;
+		v3.append(src1, 2);
+		v4.append(src2, 16);
+		v3.append(v4);
+		CYBOZU_TEST_ASSERT(v1 == v3);
+	}
+	for (size_t i = 0; i < 48; i++) {
+		for (size_t j = 0; j < 48; j++) {
+			Vec v1;
+			StdVec v2;
+			v1.append(src1, i);
+			v2.append(src1, i);
+			v1.append(src2, j);
+			v2.append(src2, j);
+			verifyVec(v1, v2);
+			Vec v3, v4;
+			v3.append(src1, i);
+			v4.append(src2, j);
+			v3.append(v4);
+			CYBOZU_TEST_ASSERT(v1 == v3);
+		}
+	}
+	for (size_t i = 0; i < 16; i++) {
+		for (size_t j = 0; j < 16; j++) {
+			Vec v1;
+			StdVec v2;
+			v1.append(src1[0], i);
+			v2.append(src1[0], i);
+			v1.append(src2[0], j);
+			v2.append(src2[0], j);
+			verifyVec(v1, v2);
+		}
+	}
+}
+
+CYBOZU_TEST_AUTO(extract)
+{
+	const uint16_t src1[] = { 0x3210, 0x7654, 0xba98, 0xabcd, 0x98db };
+	typedef cybozu::BitVectorT<uint16_t> Vec;
+	Vec v;
+	v.append(src1, sizeof(src1) * 8);
+	for (size_t pos = 0; pos <= 33; pos++) {
+		int sum = 0;
+		for (size_t bitLen = 0; bitLen <= 33; bitLen++) {
+			uint16_t dst[3];
+			v.extract(dst, pos, bitLen);
+			for (size_t i = 0; i < bitLen; i++) {
+				sum += v.get(pos + i) ^ cybozu::GetBlockBit(dst, i);
+			}
+		}
+		CYBOZU_TEST_EQUAL(sum, 0);
+		sum = 0;
+		for (size_t bitLen = 0; bitLen <= 33; bitLen++) {
+			Vec v2;
+			v.extract(v2, pos, bitLen);
+			for (size_t i = 0; i < bitLen; i++) {
+				sum += v.get(pos + i) ^ v2.get(i);
+			}
+		}
+		CYBOZU_TEST_EQUAL(sum, 0);
+		sum = 0;
+		for (size_t bitLen = 0; bitLen <= 16; bitLen++) {
+			uint16_t r = v.extract(pos, bitLen);
+			for (size_t i = 0; i < bitLen; i++) {
+				sum += v.get(pos + i) ^ cybozu::GetBlockBit(&r, i);
+			}
+		}
+		CYBOZU_TEST_EQUAL(sum, 0);
+	}
+}

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

@@ -0,0 +1,92 @@
+#ifdef _WIN32
+	#undef _WIN32_WINNT
+	#define _WIN32_WINNT 0x600
+#endif
+#include <stdio.h>
+#include <cybozu/thread.hpp>
+#include <cybozu/condition_variable_cs.hpp>
+#include <cybozu/test.hpp>
+
+class Thread : public cybozu::ThreadBase {
+	cybozu::CriticalSection& cs_;
+	cybozu::ConditionVariableCs& cv_;
+	bool done_;
+public:
+	Thread(cybozu::CriticalSection& cs, cybozu::ConditionVariableCs& cv)
+		: cs_(cs)
+		, cv_(cv)
+		, done_(false)
+	{
+	}
+
+	void threadEntry()
+	{
+		cs_.lock();
+		cv_.wait(cs_);
+		cs_.unlock();
+		done_ = true;
+	}
+	bool done() const { return done_; }
+};
+
+CYBOZU_TEST_AUTO(notifyOne)
+{
+	cybozu::CriticalSection cs;
+	cybozu::ConditionVariableCs cv;
+
+	Thread t1(cs, cv);
+	Thread t2(cs, cv);
+	Thread t3(cs, cv);
+
+	t1.beginThread();
+	t2.beginThread();
+	t3.beginThread();
+	cybozu::Sleep(100);
+
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 0);
+
+	cv.notifyOne();
+	cybozu::Sleep(100);
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 1);
+
+	cv.notifyOne();
+	cybozu::Sleep(100);
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 2);
+
+	cv.notifyOne();
+	cybozu::Sleep(100);
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 3);
+
+	t1.joinThread();
+	t2.joinThread();
+	t3.joinThread();
+}
+
+CYBOZU_TEST_AUTO(broadcast)
+{
+	cybozu::CriticalSection cs;
+	cybozu::ConditionVariableCs cv;
+
+	Thread t1(cs, cv);
+	Thread t2(cs, cv);
+	Thread t3(cs, cv);
+
+	t1.beginThread();
+	t2.beginThread();
+	t3.beginThread();
+	cybozu::Sleep(100);
+
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 0);
+
+	cv.notifyOne();
+	cybozu::Sleep(100);
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 1);
+
+	cv.notifyAll();
+	cybozu::Sleep(100);
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 3);
+
+	t1.joinThread();
+	t2.joinThread();
+	t3.joinThread();
+}

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

@@ -0,0 +1,88 @@
+#include <stdio.h>
+#include <cybozu/thread.hpp>
+#include <cybozu/condition_variable.hpp>
+#include <cybozu/test.hpp>
+
+class Thread : public cybozu::ThreadBase {
+	cybozu::Mutex& mutex_;
+	cybozu::ConditionVariable& cv_;
+	bool done_;
+public:
+	Thread(cybozu::Mutex& mutex, cybozu::ConditionVariable& cv)
+		: mutex_(mutex)
+		, cv_(cv)
+		, done_(false)
+	{
+	}
+
+	void threadEntry()
+	{
+		mutex_.lock();
+		cv_.wait(mutex_);
+		mutex_.unlock();
+		done_ = true;
+	}
+	bool done() const { return done_; }
+};
+
+CYBOZU_TEST_AUTO(notifyOne)
+{
+	cybozu::Mutex mutex;
+	cybozu::ConditionVariable cv;
+
+	Thread t1(mutex, cv);
+	Thread t2(mutex, cv);
+	Thread t3(mutex, cv);
+
+	t1.beginThread();
+	t2.beginThread();
+	t3.beginThread();
+	cybozu::Sleep(100);
+
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 0);
+
+	cv.notifyOne();
+	cybozu::Sleep(100);
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 1);
+
+	cv.notifyOne();
+	cybozu::Sleep(100);
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 2);
+
+	cv.notifyOne();
+	cybozu::Sleep(100);
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 3);
+
+	t1.joinThread();
+	t2.joinThread();
+	t3.joinThread();
+}
+
+CYBOZU_TEST_AUTO(broadcast)
+{
+	cybozu::Mutex mutex;
+	cybozu::ConditionVariable cv;
+
+	Thread t1(mutex, cv);
+	Thread t2(mutex, cv);
+	Thread t3(mutex, cv);
+
+	t1.beginThread();
+	t2.beginThread();
+	t3.beginThread();
+	cybozu::Sleep(100);
+
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 0);
+
+	cv.notifyOne();
+	cybozu::Sleep(100);
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 1);
+
+	cv.notifyAll();
+	cybozu::Sleep(100);
+	CYBOZU_TEST_EQUAL(t1.done() + t2.done() + t3.done(), 3);
+
+	t1.joinThread();
+	t2.joinThread();
+	t3.joinThread();
+}