ooxml_crypt 0.1.0

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

@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include <memory.h>
+#include <cybozu/endian.hpp>
+#include <cybozu/test.hpp>
+
+#ifdef _WIN32
+	#pragma warning(disable : 4309) /* trivial cast */
+#endif
+
+CYBOZU_TEST_AUTO(endian_test)
+{
+	uint8_t buf[] = { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xff };
+	{
+		uint64_t x;
+		x = cybozu::Get64bitAsLE(buf);
+		CYBOZU_TEST_EQUAL(x, uint64_t(0xffdebc9a78563412LL));
+
+		x = cybozu::Get64bitAsBE(buf);
+		CYBOZU_TEST_EQUAL(x, uint64_t(0x123456789abcdeffLL));
+	}
+	{
+		uint32_t x;
+		x = cybozu::Get32bitAsLE(buf);
+		CYBOZU_TEST_EQUAL(x, 0x78563412U);
+
+		x = cybozu::Get32bitAsBE(buf);
+		CYBOZU_TEST_EQUAL(x, 0x12345678U);
+	}
+	char buf2[8];
+	cybozu::Set32bitAsLE(buf2, 0x78563412);
+	CYBOZU_TEST_ASSERT(memcmp(buf2, buf, 4) == 0);
+
+	cybozu::Set32bitAsBE(buf2, 0x12345678);
+	CYBOZU_TEST_ASSERT(memcmp(buf2, buf, 4) == 0);
+
+	cybozu::Set64bitAsLE(buf2, uint64_t(0xffdebc9a78563412LL));
+	CYBOZU_TEST_ASSERT(memcmp(buf2, buf, 8) == 0);
+
+	cybozu::Set64bitAsBE(buf2, uint64_t(0x123456789abcdeffLL));
+	CYBOZU_TEST_ASSERT(memcmp(buf2, buf, 8) == 0);
+
+	{
+		unsigned short x;
+		x = cybozu::Get16bitAsLE(buf);
+		CYBOZU_TEST_EQUAL(x, 0x3412);
+		x = cybozu::Get16bitAsBE(buf);
+		CYBOZU_TEST_EQUAL(x, 0x1234);
+	}
+	{
+		char buf3[2];
+		cybozu::Set16bitAsLE(buf3, 0x3456);
+		CYBOZU_TEST_ASSERT(memcmp(buf3, "\x56\x34", 2) == 0);
+		cybozu::Set16bitAsBE(buf3, 0x3456);
+		CYBOZU_TEST_ASSERT(memcmp(buf3, "\x34\x56", 2) == 0);
+	}
+}

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

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <cybozu/env.hpp>
+#include <cybozu/test.hpp>
+
+CYBOZU_TEST_AUTO(env)
+{
+	std::string val;
+	CYBOZU_TEST_ASSERT(!cybozu::QueryEnv(val, "aw3vraw3vasv"));
+#ifdef _WIN32
+	const char *key = "SystemDrive";
+	const char *assumeVal = "C:";
+#elif defined(__APPLE__)
+	const char *key = "OSTYPE";
+	const char *assumeVal = "darwin";
+#else
+	const char *key = "OSTYPE";
+	const char *assumeVal = "linux";
+#endif
+	val = cybozu::GetEnv(key);
+	CYBOZU_TEST_EQUAL(val, assumeVal);
+	CYBOZU_TEST_EQUAL(cybozu::GetEnv("asvrifansevjase", "default"), "default");
+}

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

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <cybozu/thread.hpp>
+#include <cybozu/event.hpp>
+#include <cybozu/test.hpp>
+
+class Thread : public cybozu::ThreadBase {
+	cybozu::Event& ev_;
+public:
+	bool done_;
+	Thread(cybozu::Event& ev)
+		: ev_(ev)
+		, done_(false)
+	{
+	}
+
+	void threadEntry()
+	{
+		puts("thread");
+		puts("sleep 100msec");
+		cybozu::Sleep(100);
+		puts("wakeup");
+		ev_.wakeup();
+		cybozu::Sleep(100);
+		ev_.wakeup();
+	}
+};
+
+CYBOZU_TEST_AUTO(event_test)
+{
+	cybozu::Event ev;
+
+	Thread th(ev);
+	th.beginThread();
+
+	ev.wait();
+	puts("done");
+	ev.wait();
+	puts("done");
+
+	th.joinThread();
+}

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

@@ -0,0 +1,233 @@
+#include <cybozu/file.hpp>
+#include <cybozu/test.hpp>
+#include <memory.h>
+#include <stdlib.h>
+#include <vector>
+
+static const std::string fileName = "test.tmp";
+static const std::string fileName2 = "test2.tmp";
+static const char testBuf[] = { 1, 2, 5, 4, 3, 2, 1 };
+
+CYBOZU_TEST_AUTO(open_and_write)
+{
+	cybozu::File f;
+	CYBOZU_TEST_ASSERT(!f.isOpen());
+	f.open(fileName, std::ios::out | std::ios::trunc);
+	CYBOZU_TEST_ASSERT(f.isOpen());
+	f.write(testBuf, sizeof(testBuf));
+	f.close();
+}
+
+CYBOZU_TEST_AUTO(read)
+{
+	cybozu::File f;
+	f.open(fileName, std::ios::in);
+	CYBOZU_TEST_ASSERT(f.isOpen());
+	char buf[sizeof(testBuf)] = {};
+	f.read(buf, sizeof(buf));
+	CYBOZU_TEST_ASSERT(memcmp(buf, testBuf, sizeof(buf)) == 0);
+	CYBOZU_TEST_EQUAL(f.getSize(), sizeof(testBuf));
+}
+
+CYBOZU_TEST_AUTO(readSome)
+{
+	cybozu::File f;
+	f.open(fileName, std::ios::in);
+	CYBOZU_TEST_ASSERT(f.isOpen());
+	char buf[1024] = {};
+	size_t readSize = f.readSome(buf, sizeof(buf));
+	CYBOZU_TEST_EQUAL(f.getSize(), readSize);
+	CYBOZU_TEST_ASSERT(memcmp(buf, testBuf, readSize) == 0);
+}
+
+CYBOZU_TEST_AUTO(size)
+{
+	CYBOZU_TEST_EQUAL(cybozu::GetFileSize(fileName), sizeof(testBuf));
+}
+
+CYBOZU_TEST_AUTO(append)
+{
+	cybozu::File f;
+	CYBOZU_TEST_ASSERT(!f.isOpen());
+	f.open(fileName, std::ios::out | std::ios::app);
+	CYBOZU_TEST_ASSERT(f.isOpen());
+	f.write(testBuf, sizeof(testBuf));
+}
+
+CYBOZU_TEST_AUTO(read2)
+{
+	cybozu::File f;
+	f.open(fileName, std::ios::in);
+	const size_t size = sizeof(testBuf);
+	char buf[size * 2];
+	f.read(buf, size * 2);
+	CYBOZU_TEST_ASSERT(memcmp(buf, testBuf, size) == 0);
+	CYBOZU_TEST_ASSERT(memcmp(buf + size, testBuf, size) == 0);
+	CYBOZU_TEST_EQUAL(f.getSize(), size * 2);
+}
+
+CYBOZU_TEST_AUTO(badmode)
+{
+	cybozu::File f;
+	CYBOZU_TEST_EXCEPTION(f.open("test", std::ios::in | std::ios::out), cybozu::Exception);
+	CYBOZU_TEST_EXCEPTION(f.open("test", std::ios::in | std::ios::trunc), cybozu::Exception);
+	CYBOZU_TEST_EXCEPTION(f.open("test", std::ios::in | std::ios::app), cybozu::Exception);
+	CYBOZU_TEST_EXCEPTION(f.open("test", std::ios::out | std::ios::trunc | std::ios::app), cybozu::Exception);
+}
+
+CYBOZU_TEST_AUTO(move_and_remove)
+{
+	{
+		cybozu::File f;
+		f.open(fileName, std::ios::out | std::ios::trunc);
+		CYBOZU_TEST_ASSERT(f.isOpen());
+		f.write(testBuf, sizeof(testBuf));
+	}
+	{
+		/*
+			remove fileName2 if exists and move fileName to fileName2
+		*/
+		if (cybozu::DoesFileExist(fileName2)) {
+			cybozu::RemoveFile(fileName2);
+		}
+		CYBOZU_TEST_ASSERT(!cybozu::DoesFileExist(fileName2));
+		cybozu::RenameFile(fileName, fileName2);
+		CYBOZU_TEST_ASSERT(cybozu::DoesFileExist(fileName2));
+		cybozu::RemoveFile(fileName2);
+	}
+	{
+		CYBOZU_TEST_EXCEPTION_MESSAGE(cybozu::RemoveFile(fileName2), cybozu::Exception, fileName2);
+		CYBOZU_TEST_EXCEPTION_MESSAGE(cybozu::RenameFile(fileName, fileName2), cybozu::Exception, fileName2);
+	}
+}
+
+CYBOZU_TEST_AUTO(path)
+{
+	{
+		std::string a = "abc\\def\\defg\\\\";
+		std::string b = "abc/def/defg//";
+		cybozu::ReplaceBackSlash(a);
+		CYBOZU_TEST_EQUAL(a, b);
+	}
+
+	std::string path, baseName;
+	path = cybozu::GetExePath(&baseName);
+#ifdef NDEBUG
+	const std::string cBaseName = "file_test";
+#else
+	const std::string cBaseName = "file_testd";
+#endif
+	CYBOZU_TEST_EQUAL(baseName, cBaseName);
+	std::string cPath = "/cybozulib/bin/";
+	if (path.size() >= cPath.size()) path = path.substr(path.size() - cPath.size(), std::string::npos);
+	CYBOZU_TEST_EQUAL(path, cPath);
+}
+
+template<size_t N>
+bool findIn(const std::string& name, const char (&tbl)[N][16])
+{
+	for (size_t i = 0; i < N; i++) {
+		if (name == tbl[i]) return true;
+	}
+	return false;
+}
+
+CYBOZU_TEST_AUTO(GetFilesInDir1)
+{
+	std::string path = cybozu::GetExePath() + "../include/cybozu/";
+	cybozu::FileList list;
+	CYBOZU_TEST_ASSERT(cybozu::GetFileList(list, path, "hpp"));
+
+	const char fileTbl[][16] = {
+		"inttype.hpp",
+		"file.hpp",
+		"exception.hpp",
+		"atoi.hpp",
+		"stacktrace.hpp",
+		"mutex.hpp",
+	};
+	size_t foundFileNum = 0;
+	for (size_t i = 0; i < list.size(); i++) {
+		const std::string& name = list[i].name;
+		if (findIn(name, fileTbl)) {
+			CYBOZU_TEST_ASSERT(list[i].isFile());
+			foundFileNum++;
+		}
+	}
+	CYBOZU_TEST_EQUAL(CYBOZU_NUM_OF_ARRAY(fileTbl), foundFileNum);
+}
+
+CYBOZU_TEST_AUTO(GetFilesInDir2)
+{
+	std::string path = cybozu::GetExePath() + "../include/cybozu/";
+	cybozu::FileList list = cybozu::GetFileList(path);
+
+	const char fileTbl[][16] = {
+		"inttype.hpp",
+		"file.hpp",
+		"exception.hpp",
+		"atoi.hpp",
+		"stacktrace.hpp",
+		"mutex.hpp",
+	};
+	const char dirTbl[][16] = {
+		"nlp",
+	};
+
+	size_t foundFileNum = 0;
+	size_t foundDirNum = 0;
+	for (size_t i = 0; i < list.size(); i++) {
+		const std::string& name = list[i].name;
+		if (findIn(name, fileTbl)) {
+			CYBOZU_TEST_ASSERT(list[i].isFile());
+			foundFileNum++;
+		}
+		if (findIn(name, dirTbl)) {
+			CYBOZU_TEST_ASSERT(list[i].isDirectory());
+			foundDirNum++;
+		}
+	}
+	CYBOZU_TEST_EQUAL(CYBOZU_NUM_OF_ARRAY(fileTbl), foundFileNum);
+	CYBOZU_TEST_EQUAL(CYBOZU_NUM_OF_ARRAY(dirTbl), foundDirNum);
+}
+
+CYBOZU_TEST_AUTO(GetBaseName)
+{
+	const struct {
+		const char *name;
+		const char *base;
+		const char *suf;
+	} tbl[] = {
+		{ "test", "test", "" },
+		{ "test.abc", "test", "abc" },
+		{ "test.abc.def", "test.abc", "def" },
+		{ ".abc", "", "abc" },
+		{ "abc.", "abc", "" },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		const std::string name = tbl[i].name;
+		CYBOZU_TEST_EQUAL(cybozu::GetBaseName(name), tbl[i].base);
+		std::string suf;
+		CYBOZU_TEST_EQUAL(cybozu::GetBaseName(name, &suf), tbl[i].base);
+		CYBOZU_TEST_EQUAL(suf, tbl[i].suf);
+
+	}
+}
+
+CYBOZU_TEST_AUTO(HasExtension)
+{
+	const struct {
+		const char *name;
+		const char *suf;
+		bool has;
+	} tbl[] = {
+		{ "test.txt", "txt", true },
+		{ "test.txa", "txt", false },
+		{ ".txt", "txt", true },
+		{ "asbc", "", true },
+		{ "", "a", false },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		CYBOZU_TEST_EQUAL(cybozu::HasExtension(tbl[i].name, tbl[i].suf), tbl[i].has);
+	}
+}

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

@@ -0,0 +1,118 @@
+/*
+	don't remove the top of BOM for VC
+*/
+#include <cybozu/test.hpp>
+#include <cybozu/fmindex.hpp>
+#include <cybozu/file.hpp>
+#include <cybozu/mmap.hpp>
+#include <cybozu/string.hpp>
+#include <set>
+
+typedef std::set<int> Set;
+
+std::string g_textTbl[] = {
+	"",
+	"abracatabra",
+	"cybozuabcabcintint}}",
+};
+
+struct Init {
+	Init()
+	{
+		std::string path = cybozu::GetExePath();
+		size_t pos = path.find("cybozulib");
+		CYBOZU_TEST_ASSERT(pos != std::string::npos);
+		path = path.substr(0, pos + 9) + "/include/cybozu/fmindex.hpp";
+		cybozu::Mmap mmap(path);
+		g_textTbl[0].assign(mmap.get(), (size_t)mmap.size());
+	}
+} init;
+
+//	f.getPrevString(out, 0, f.wm.size() - 1);
+
+template<class FMINDEX, class STRING>
+Set searchPos1(const FMINDEX& f, const STRING& key)
+{
+	Set ret;
+	size_t begin, end = 0;
+	if (f.getRange(&begin, &end, key)) {
+		while (begin != end) {
+			ret.insert((int)f.convertPosition(begin));
+			++begin;
+		}
+	}
+	return ret;
+}
+
+// standard search
+template<class STRING>
+Set searchPos2(const STRING& text, const STRING& key)
+{
+	Set ret;
+	size_t pos = 0;
+	for (;;) {
+		size_t q = text.find(key, pos);
+		if (q == std::string::npos) break;
+		ret.insert((int)q);
+		pos = q + 1;
+	}
+	return ret;
+}
+
+template<class FMINDEX, class STRING>
+void compareText(const FMINDEX& f, const STRING& text, const STRING *keyTbl, size_t keySize)
+{
+	for (size_t i = 0; i < keySize; i++) {
+		const STRING& key = keyTbl[i];
+		Set a = searchPos1(f, key);
+		Set b = searchPos2(text, key);
+		CYBOZU_TEST_EQUAL(a.size(), b.size());
+		if (a.size() == b.size()) {
+			size_t pos = 0;
+			for (Set::const_iterator ia = a.begin(), ib = b.begin(); pos < a.size(); ++ia, ++ib, ++pos) {
+				CYBOZU_TEST_EQUAL(*ia, *ib);
+			}
+		}
+	}
+	// recover string
+	STRING org;
+	f.getPrevString(org, 0, f.wm.size() - 1);
+	CYBOZU_TEST_EQUAL(org.size(), text.size());
+	CYBOZU_TEST_ASSERT(org == text);
+}
+
+template<class FMINDEX, class STRING>
+void searchTest(const STRING& text, const STRING *keyTbl, size_t keySize)
+{
+	FMINDEX f;
+	f.init(text.begin(), text.end());
+	compareText(f, text, keyTbl, keySize);
+	std::stringstream ss;
+	f.save(ss);
+	{
+		FMINDEX ff;
+		ff.load(ss);
+		compareText(ff, text, keyTbl, keySize);
+	}
+}
+
+CYBOZU_TEST_AUTO(string)
+{
+	static const std::string tbl[] = {
+		"double", "int", "cybozu", "std", "}", "\t", "xxx",
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(g_textTbl); i++) {
+		searchTest<cybozu::FMindex, std::string>(g_textTbl[i], tbl, CYBOZU_NUM_OF_ARRAY(tbl));
+	}
+}
+
+CYBOZU_TEST_AUTO(wstring)
+{
+	static const cybozu::String text(CYBOZU_STR_W("あいうえおabcあいうえおaaabあああうえabうえあいう"));
+	static const cybozu::String tbl[] = {
+		CYBOZU_STR_W("あいう"),
+		CYBOZU_STR_W("ab"),
+		CYBOZU_STR_W("うえ"),
+	};
+	searchTest<cybozu::FMindexT<cybozu::Char>, cybozu::String>(text, tbl, CYBOZU_NUM_OF_ARRAY(tbl));
+}

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

@@ -0,0 +1,12 @@
+#include <cybozu/format.hpp>
+#include <cybozu/test.hpp>
+
+CYBOZU_TEST_AUTO(format)
+{
+	std::string a;
+	cybozu::format(a, "%d", 1234567);
+	CYBOZU_TEST_EQUAL(a, "1234567");
+	CYBOZU_TEST_EQUAL(cybozu::format("%d", 123), "123");
+	a = cybozu::format("%s%c%d%s", "abcdefg", 0, 123, "xxx");
+	CYBOZU_TEST_EQUAL(a, std::string("abcdefg" "\x00" "123xxx", 14));
+}

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

@@ -0,0 +1,104 @@
+#include <cybozu/test.hpp>
+#include <cybozu/frequency.hpp>
+#include <sstream>
+
+template<class Element>
+struct Tbl {
+	Element c;
+	size_t n;
+};
+
+template<class Freq, class T, size_t N>
+void verify(const Freq& freq, const T (&tbl)[N])
+{
+	CYBOZU_TEST_EQUAL(freq.size(), N);
+	for (size_t i = 0; i < N; i++) {
+		CYBOZU_TEST_EQUAL(freq.getFrequency(tbl[i].c), tbl[i].n);
+		CYBOZU_TEST_EQUAL(freq.getIndex(tbl[i].c), i);
+		CYBOZU_TEST_EQUAL(freq.getElement(i), tbl[i].c);
+	}
+}
+
+CYBOZU_TEST_AUTO(char)
+{
+	std::string a = "abcaaab\x80\x80\xff\xff\xff";
+	typedef cybozu::freq_local::FrequencyVec<char> Freq;
+	std::stringstream ss;
+	Freq freq;
+	{
+		Freq freqTmp(a.begin(), a.end());
+		freqTmp.save(ss);
+	}
+	freq.load(ss);
+	const Tbl<char> tbl[] = {
+		{ 'a', 4 },
+		{ '\xff', 3 },
+		{ '\x80', 2 },
+		{ 'b', 2 },
+		{ 'c', 1 },
+	};
+	verify(freq, tbl);
+	Freq freq2;
+	for (size_t i = 0; i < a.size(); i++) {
+		freq2.append(a[i]);
+	}
+	freq2.ready();
+	verify(freq2, tbl);
+}
+
+CYBOZU_TEST_AUTO(int)
+{
+	const int inTbl[] = {
+		3, 5, 2, 3, 5, 2, 9, 5, 2, 2, 0,
+	};
+	typedef cybozu::Frequency<int> Freq;
+	std::stringstream ss;
+	Freq freq;
+	{
+		Freq freqTmp(inTbl, inTbl + CYBOZU_NUM_OF_ARRAY(inTbl));
+		freqTmp.save(ss);
+	}
+	freq.load(ss);
+	const Tbl<int> tbl[] = {
+		{ 2, 4 },
+		{ 5, 3 },
+		{ 3, 2 },
+		{ 9, 1 },
+		{ 0, 1 },
+	};
+	verify(freq, tbl);
+	Freq freq2;
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(inTbl); i++) {
+		freq2.append(inTbl[i]);
+	}
+	freq2.ready();
+	verify(freq2, tbl);
+}
+
+CYBOZU_TEST_AUTO(string)
+{
+	const std::string inTbl[] = {
+		"abc", "123", "a", "abc", "abc", "x", "123", "x",
+	};
+	typedef cybozu::Frequency<std::string> Freq;
+	std::stringstream ss;
+	Freq freq;
+	{
+		Freq freqTmp(inTbl, inTbl + CYBOZU_NUM_OF_ARRAY(inTbl));
+		freqTmp.save(ss);
+	}
+	freq.load(ss);
+	const Tbl<std::string> tbl[] = {
+		{ "abc", 3 },
+		{ "x", 2 },
+		{ "123", 2 },
+		{ "a", 1 },
+	};
+	verify(freq, tbl);
+	Freq freq2;
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(inTbl); i++) {
+		freq2.append(inTbl[i]);
+	}
+	freq2.ready();
+	verify(freq2, tbl);
+}