From: Mikko Rasa <tdb@tdb.fi>
Date: Mon, 25 Jul 2011 14:46:24 +0000 (+0300)
Subject: Add unit tests
X-Git-Url: http://git.tdb.fi/?a=commitdiff_plain;h=120023d8da0aabcb803a87111608ce84c94661f8;p=libs%2Fcore.git

Add unit tests
---

diff --git a/tests/Build b/tests/Build
new file mode 100644
index 0000000..982059e
--- /dev/null
+++ b/tests/Build
@@ -0,0 +1,15 @@
+package "mspcore-tests"
+{
+	require "mspcore";
+	require "msptest";
+
+	program "test"
+	{
+		source ".";
+	};
+
+	program "consoletest"
+	{
+		source "console/console.cpp";
+	};
+};
diff --git a/tests/codec.cpp b/tests/codec.cpp
new file mode 100644
index 0000000..896ce5d
--- /dev/null
+++ b/tests/codec.cpp
@@ -0,0 +1,41 @@
+#include <msp/stringcodec/ascii.h>
+#include <msp/stringcodec/utf8.h>
+#include <msp/test/test.h>
+
+using namespace std;
+using namespace Msp;
+
+class CodecTests: public Test::RegisteredTest<CodecTests>
+{
+public:
+	CodecTests();
+
+	static const char *get_name() { return "Codec"; }
+
+private:
+	void invalid_character();
+	void invalid_sequence();
+};
+
+
+CodecTests::CodecTests()
+{
+	add(&CodecTests::invalid_character, "invalid_character").expect_throw<StringCodec::invalid_character>();
+	add(&CodecTests::invalid_sequence, "invalid_sequence").expect_throw<StringCodec::invalid_sequence>();
+}
+
+void CodecTests::invalid_character()
+{
+	StringCodec::unichar ch = 0xE4;
+	StringCodec::Ascii::Encoder enc;
+	string buf;
+	enc.encode_char(ch, buf);
+}
+
+void CodecTests::invalid_sequence()
+{
+	string str = "\343\201";
+	string::const_iterator iter = str.begin();
+	StringCodec::Utf8::Decoder dec;
+	dec.decode_char(str, iter);
+}
diff --git a/tests/console/console.cpp b/tests/console/console.cpp
new file mode 100644
index 0000000..04ad4ac
--- /dev/null
+++ b/tests/console/console.cpp
@@ -0,0 +1,26 @@
+#include <msp/io/console.h>
+#include <msp/io/poll.h>
+#include <msp/io/print.h>
+
+using namespace Msp;
+
+int main()
+{
+	IO::cin.set_local_echo(false);
+	IO::cin.set_line_buffer(false);
+	while(1)
+	{
+		if(IO::poll(IO::cin, IO::P_INPUT)==IO::P_INPUT)
+		{
+			char c = IO::cin.get();
+			IO::print("Got character '%c' (%02X)\n", c, c);
+		}
+		else
+		{
+			IO::print("EOF\n");
+			break;
+		}
+	}
+
+	return 0;
+}
diff --git a/tests/datetime.cpp b/tests/datetime.cpp
new file mode 100644
index 0000000..45a8699
--- /dev/null
+++ b/tests/datetime.cpp
@@ -0,0 +1,118 @@
+#include <msp/time/datetime.h>
+#include <msp/time/timestamp.h>
+#include <msp/time/timezone.h>
+#include <msp/time/units.h>
+#include <msp/test/test.h>
+
+using namespace std;
+using namespace Msp;
+
+class DateTimeTests: public Test::RegisteredTest<DateTimeTests>
+{
+public:
+	DateTimeTests();
+
+	static const char *get_name() { return "DateTime"; }
+
+private:
+	void add_days();
+	void add_timedelta();
+	void leap_year();
+	void format();
+	void timestamp();
+	void timezone();
+};
+
+
+DateTimeTests::DateTimeTests()
+{
+	add(&DateTimeTests::add_days, "add_days");
+	add(&DateTimeTests::add_timedelta, "+= TimeDelta");
+	add(&DateTimeTests::leap_year, "Leap years");
+	add(&DateTimeTests::format, "Formatting");
+	add(&DateTimeTests::timestamp, "Timestamp conversion");
+	add(&DateTimeTests::timezone, "Timezone conversion");
+}
+
+void DateTimeTests::add_days()
+{
+	Time::DateTime dt(2010, 1, 1);
+	dt.add_days(1);
+	EXPECT_EQUAL(dt, Time::DateTime(2010, 1, 2));
+	dt.add_days(57);
+	EXPECT_EQUAL(dt, Time::DateTime(2010, 2, 28));
+	dt.add_days(307);
+	EXPECT_EQUAL(dt, Time::DateTime(2011, 1, 1));
+	dt.add_days(-366);
+	EXPECT_EQUAL(dt, Time::DateTime(2009, 12, 31));
+}
+
+void DateTimeTests::add_timedelta()
+{
+	Time::DateTime dt(2010, 1, 1, 23, 50, 0);
+	dt += 20*Time::min;
+	EXPECT_EQUAL(dt, Time::DateTime(2010, 1, 2, 0, 10, 0));
+	dt += 23*Time::hour+50*Time::min;
+	EXPECT_EQUAL(dt, Time::DateTime(2010, 1, 3));
+	dt += 52*Time::week;
+	EXPECT_EQUAL(dt, Time::DateTime(2011, 1, 2));
+}
+
+void DateTimeTests::leap_year()
+{
+	Time::DateTime dt(1996, 2, 1);
+	dt.add_days(29);
+	EXPECT_EQUAL(dt, Time::DateTime(1996, 3, 1));
+
+	dt = Time::DateTime(2000, 2, 1);
+	dt.add_days(29);
+	EXPECT_EQUAL(dt, Time::DateTime(2000, 3, 1));
+
+	dt = Time::DateTime(2100, 2, 1);
+	dt.add_days(29);
+	EXPECT_EQUAL(dt, Time::DateTime(2100, 3, 2));
+
+	dt = Time::DateTime(1996, 2, 1);
+	dt.add_days(8*365);
+	EXPECT_EQUAL(dt, Time::DateTime(2004, 1, 30));
+
+	dt = Time::DateTime(2096, 2, 1);
+	dt.add_days(8*365);
+	EXPECT_EQUAL(dt, Time::DateTime(2104, 1, 31));
+
+	dt = Time::DateTime(2010, 2, 1);
+	dt.add_days(400*365+96);
+	EXPECT_EQUAL(dt, Time::DateTime(2410, 1, 31));
+}
+
+void DateTimeTests::format()
+{
+	Time::DateTime dt(2010, 4, 27, 13, 57, 12);
+	EXPECT_EQUAL(dt.format("%Y-%m-%d"), "2010-04-27");
+	EXPECT_EQUAL(dt.format("%d%m%y"), "270410");
+	EXPECT_EQUAL(dt.format("%H:%M:%S"), "13:57:12");
+	EXPECT_EQUAL(dt.format("%I:%M %p"), "01:57 PM");
+	EXPECT_EQUAL(Time::DateTime(2010, 4, 27, 12, 0, 0).format("%p"), "PM");
+	EXPECT_EQUAL(dt.format_rfc3339(), "2010-04-27T13:57:12Z");
+	dt.set_timezone(Time::TimeZone(120));
+	EXPECT_EQUAL(dt.format_rfc3339(), "2010-04-27T13:57:12+02:00");
+}
+
+void DateTimeTests::timestamp()
+{
+	Time::DateTime dt(2010, 1, 1);
+	Time::TimeStamp ts = dt.get_timestamp();
+	Time::DateTime dt2(ts);
+	EXPECT_EQUAL(dt, dt2);
+}
+
+void DateTimeTests::timezone()
+{
+	Time::DateTime dt(2010, 1, 1, 2, 0, 0);
+	dt.convert_timezone(Time::TimeZone(120));
+	EXPECT_EQUAL(dt, Time::DateTime(2010, 1, 1, 4, 0, 0));
+	dt.convert_timezone(Time::TimeZone(-300));
+	EXPECT_EQUAL(dt, Time::DateTime(2009, 12, 31, 21, 0, 0));
+	dt.convert_timezone(Time::TimeZone::utc());
+	EXPECT_EQUAL(dt, Time::DateTime(2010, 1, 1, 2, 0, 0));
+}
diff --git a/tests/file.cpp b/tests/file.cpp
new file mode 100644
index 0000000..ccd2eb5
--- /dev/null
+++ b/tests/file.cpp
@@ -0,0 +1,87 @@
+#include <msp/core/systemerror.h>
+#include <msp/io/file.h>
+#include <msp/test/test.h>
+
+using namespace std;
+using namespace Msp;
+
+class FileTests: public Test::RegisteredTest<FileTests>
+{
+public:
+	FileTests();
+
+	static const char *get_name() { return "File"; }
+
+private:
+	void write();
+	void read();
+	void seek();
+	void file_not_found();
+	void invalid_access();
+};
+
+
+FileTests::FileTests()
+{
+	add(&FileTests::write,          "Writing");
+	add(&FileTests::read,           "Reading");
+	add(&FileTests::seek,           "Seeking");
+	add(&FileTests::file_not_found, "file_not_found").expect_throw<IO::file_not_found>();
+	add(&FileTests::invalid_access, "invalid_access").expect_throw<IO::invalid_access>();
+}
+
+void FileTests::write()
+{
+	IO::File out("test.txt", IO::M_WRITE);
+	out.write("foobar\n");
+	out.write("quux\n");
+}
+
+void FileTests::read()
+{
+	IO::File in("test.txt");
+
+	string line;
+	EXPECT(in.getline(line));
+	EXPECT_EQUAL(line, "foobar");
+
+	char buf[128];
+	unsigned len = in.read(buf, sizeof(buf));
+	EXPECT_EQUAL(len, 5U);
+	EXPECT_EQUAL(string(buf, len), "quux\n");
+
+	len = in.read(buf, sizeof(buf));
+	EXPECT_EQUAL(len, 0U);
+	EXPECT(in.eof());
+}
+
+void FileTests::seek()
+{
+	IO::File in("test.txt");
+
+	IO::SeekOffset pos = in.seek(3, IO::S_BEG);
+	EXPECT_EQUAL(pos, 3);
+	char c = in.get();
+	EXPECT_EQUAL(c, 'b');
+
+	pos = in.seek(1, IO::S_CUR);
+	EXPECT_EQUAL(pos, 5);
+	c = in.get();
+	EXPECT_EQUAL(c, 'r');
+
+	pos = in.seek(-2, IO::S_END);
+	EXPECT_EQUAL(pos, 10);
+	c = in.get();
+	EXPECT_EQUAL(c, 'x');
+}
+
+void FileTests::file_not_found()
+{
+	IO::File in("does.not.exist");
+}
+
+void FileTests::invalid_access()
+{
+	IO::File in("test.txt");
+	in.write("foo\n");
+}
diff --git a/tests/getopt.cpp b/tests/getopt.cpp
new file mode 100644
index 0000000..cb5df62
--- /dev/null
+++ b/tests/getopt.cpp
@@ -0,0 +1,141 @@
+#include <msp/core/getopt.h>
+#include <msp/test/test.h>
+
+using namespace std;
+using namespace Msp;
+
+class GetOptTests: public Test::RegisteredTest<GetOptTests>
+{
+public:
+	GetOptTests();
+
+	static const char *get_name() { return "GetOpt"; }
+
+private:
+	void short_options();
+	void long_options();
+	void arguments();
+	void non_options();
+	void help();
+	void invalid_option();
+	void invalid_arg();
+	void missing_arg();
+};
+
+GetOptTests::GetOptTests()
+{
+	add(&GetOptTests::short_options, "Short options");
+	add(&GetOptTests::long_options, "Long options");
+	add(&GetOptTests::arguments, "Option arguments");
+	add(&GetOptTests::non_options, "Non-options");
+	add(&GetOptTests::help, "Help").expect_throw<usage_error>();
+	add(&GetOptTests::invalid_option, "Invalid option").expect_throw<usage_error>();
+	add(&GetOptTests::invalid_arg, "Invalid argument").expect_throw<usage_error>();
+	add(&GetOptTests::missing_arg, "Missing argument").expect_throw<usage_error>();
+}
+
+void GetOptTests::short_options()
+{
+	static const char *argv[] = { "test", "-a", "-bc", 0 };
+
+	bool a = false;
+	bool b = false;
+	bool c = false;
+
+	GetOpt getopt;
+	getopt.add_option('a', "a", a, GetOpt::NO_ARG);
+	getopt.add_option('b', "b", b, GetOpt::NO_ARG);
+	getopt.add_option('c', "c", c, GetOpt::NO_ARG);
+	getopt(3, argv);
+
+	EXPECT(a && b && c);
+}
+
+void GetOptTests::long_options()
+{
+	static const char *argv[] = { "test", "--foo", "--bar", 0 };
+
+	bool foo = false;
+	bool bar = false;
+
+	GetOpt getopt;
+	getopt.add_option("foo", foo, GetOpt::NO_ARG);
+	getopt.add_option("bar", bar, GetOpt::NO_ARG);
+	getopt(3, argv);
+
+	EXPECT(foo && bar);
+}
+
+void GetOptTests::arguments()
+{
+	static const char *argv[] = { "test", "-aabc", "-b", "x y z", "--foo=42", "--bar", "69", 0 };
+
+	string a;
+	string b;
+	int foo = 0;
+	int bar = 0;
+
+	GetOpt getopt;
+	getopt.add_option('a', "a", a, GetOpt::REQUIRED_ARG);
+	getopt.add_option('b', "b", b, GetOpt::REQUIRED_ARG);
+	getopt.add_option("foo", foo, GetOpt::REQUIRED_ARG);
+	getopt.add_option("bar", bar, GetOpt::REQUIRED_ARG);
+	getopt(7, argv);
+
+	EXPECT_EQUAL(a, "abc");
+	EXPECT_EQUAL(b, "x y z");
+	EXPECT_EQUAL(foo, 42);
+	EXPECT_EQUAL(bar, 69);
+}
+
+void GetOptTests::non_options()
+{
+	static const char *argv[] = { "test", "-a", "foo", "-b", "bar", "baz", 0 };
+
+	bool a = false;
+	bool b = false;
+
+	GetOpt getopt;
+	getopt.add_option('a', "a", a, GetOpt::NO_ARG);
+	getopt.add_option('b', "b", b, GetOpt::NO_ARG);
+	getopt(6, argv);
+
+	EXPECT(a && b);
+	EXPECT_EQUAL(getopt.get_args().size(), 3U);
+}
+
+void GetOptTests::help()
+{
+	static const char *argv[] = { "test", "--help", 0 };
+
+	GetOpt getopt;
+	getopt(2, argv);
+}
+
+void GetOptTests::invalid_option()
+{
+	static const char *argv[] = { "test", "--invalid", 0 };
+
+	GetOpt getopt;
+	getopt(2, argv);
+}
+
+void GetOptTests::invalid_arg()
+{
+	static const char *argv[] = { "test", "--intval=foo", 0 };
+
+	int value;
+	GetOpt getopt;
+	getopt.add_option("intval", value, GetOpt::REQUIRED_ARG);
+	getopt(2, argv);
+}
+
+void GetOptTests::missing_arg()
+{
+	static const char *argv[] = { "test", "--value", 0 };
+
+	string value;
+	GetOpt getopt;
+	getopt.add_option("value", value, GetOpt::REQUIRED_ARG);
+	getopt(2, argv);
+}
diff --git a/tests/maputils.cpp b/tests/maputils.cpp
new file mode 100644
index 0000000..78cdaad
--- /dev/null
+++ b/tests/maputils.cpp
@@ -0,0 +1,40 @@
+#include <map>
+#include <msp/core/maputils.h>
+#include <msp/test/test.h>
+
+using namespace std;
+using namespace Msp;
+
+class MapUtilTests: public Test::RegisteredTest<MapUtilTests>
+{
+public:
+	MapUtilTests();
+
+	static const char *get_name() { return "maputils"; }
+
+private:
+	void success();
+	void error();
+};
+
+
+MapUtilTests::MapUtilTests()
+{
+	add(&MapUtilTests::success, "success");
+	add(&MapUtilTests::error, "error").expect_throw<key_error>();
+}
+
+void MapUtilTests::success()
+{
+	map<int, string> m;
+	m[1] = "foo";
+	m[3] = "bar";
+	EXPECT_EQUAL(get_item(m, 1), "foo");
+	EXPECT_EQUAL(get_item(m, 3), "bar");
+}
+
+void MapUtilTests::error()
+{
+	map<int, string> m;
+	get_item(m, 0);
+}
diff --git a/tests/memory.cpp b/tests/memory.cpp
new file mode 100644
index 0000000..5c3fa69
--- /dev/null
+++ b/tests/memory.cpp
@@ -0,0 +1,73 @@
+#include <msp/io/memory.h>
+#include <msp/test/test.h>
+
+using namespace std;
+using namespace Msp;
+
+class MemoryTests: public Test::RegisteredTest<MemoryTests>
+{
+public:
+	MemoryTests();
+
+	static const char *get_name() { return "Memory"; }
+
+private:
+	void write();
+	void read();
+	void getline();
+	void invalid_access();
+};
+
+
+MemoryTests::MemoryTests()
+{
+	add(&MemoryTests::write,          "write");
+	add(&MemoryTests::read,           "read");
+	add(&MemoryTests::getline,        "getline");
+	add(&MemoryTests::invalid_access, "invalid_access").expect_throw<IO::invalid_access>();
+}
+
+void MemoryTests::write()
+{
+	char buf[64] = { };
+	IO::Memory mem(buf, sizeof(buf));
+	mem.write("foobar");
+	EXPECT(equal(buf, buf+6, "foobar"));
+	for(unsigned i=6; i<sizeof(buf); ++i)
+		if(buf[i]!=0)
+			fail("Garbage in buffer");
+}
+
+void MemoryTests::read()
+{
+	static const char buf[] = "foobar";
+
+	IO::Memory mem(buf, 6);
+	char rbuf[16];
+	unsigned len = mem.read(rbuf, sizeof(rbuf));
+	EXPECT_EQUAL(len, 6);
+	EXPECT(equal(rbuf, rbuf+6, buf));
+}
+
+void MemoryTests::getline()
+{
+	static const char buf[] = "foobar\n\nquux\n";
+
+	IO::Memory mem(buf, sizeof(buf)-1);
+	string line;
+	EXPECT(mem.getline(line));
+	EXPECT_EQUAL(line, "foobar");
+	EXPECT(mem.getline(line));
+	EXPECT_EQUAL(line, "");
+	EXPECT(mem.getline(line));
+	EXPECT_EQUAL(line, "quux");
+	EXPECT(!mem.getline(line));
+}
+
+void MemoryTests::invalid_access()
+{
+	static const char buf[] = "foobar";
+
+	IO::Memory mem(buf, sizeof(buf));
+	mem.write("quux", 4);
+}
diff --git a/tests/pipe.cpp b/tests/pipe.cpp
new file mode 100644
index 0000000..0310bdf
--- /dev/null
+++ b/tests/pipe.cpp
@@ -0,0 +1,81 @@
+#include <msp/core/thread.h>
+#include <msp/io/pipe.h>
+#include <msp/io/poll.h>
+#include <msp/time/units.h>
+#include <msp/test/test.h>
+
+using namespace Msp;
+
+class PipeTests: public Test::RegisteredTest<PipeTests>
+{
+public:
+	PipeTests();
+
+	static const char *get_name() { return "Pipe"; }
+
+private:
+	void readwrite();
+	void poll();
+};
+
+
+class PipeWriter: public Thread
+{
+private:
+	IO::Pipe &pipe;
+
+public:
+	PipeWriter(IO::Pipe &);
+
+private:
+	virtual void main();
+};
+
+
+PipeTests::PipeTests()
+{
+	add(&PipeTests::readwrite, "Read/write");
+	add(&PipeTests::poll, "Poll");
+}
+
+void PipeTests::readwrite()
+{
+	IO::Pipe pipe;
+	PipeWriter writer(pipe);
+
+	for(unsigned i=0; i<256; ++i)
+	{
+		unsigned char c = pipe.get();
+		if(c!=i)
+			fail("Invalid data");
+	}
+
+	writer.join();
+}
+
+void PipeTests::poll()
+{
+	IO::Pipe pipe;
+
+	pipe.put(1);
+	IO::PollEvent ev = IO::poll(pipe, IO::P_INPUT);
+	EXPECT_EQUAL(ev, IO::P_INPUT);
+
+	pipe.get();
+
+	ev = IO::poll(pipe, IO::P_INPUT, 100*Time::msec);
+	EXPECT_EQUAL(ev, IO::P_NONE);
+}
+
+
+PipeWriter::PipeWriter(IO::Pipe &p):
+	pipe(p)
+{
+	launch();
+}
+
+void PipeWriter::main()
+{
+	for(unsigned i=0; i<256; ++i)
+		pipe.put(i);
+}
diff --git a/tests/thread.cpp b/tests/thread.cpp
new file mode 100644
index 0000000..9529af8
--- /dev/null
+++ b/tests/thread.cpp
@@ -0,0 +1,129 @@
+#include <list>
+#include <vector>
+#include <msp/core/thread.h>
+#include <msp/time/units.h>
+#include <msp/time/utils.h>
+#include <msp/test/test.h>
+
+using namespace std;
+using namespace Msp;
+
+class ThreadTests: public Test::RegisteredTest<ThreadTests>
+{
+private:
+	std::vector<int> data;
+
+public:
+	ThreadTests();
+
+	static const char *get_name() { return "Thread"; }
+
+private:
+	void single();
+	void multiple();
+};
+
+
+class TestThread: public Thread
+{
+private:
+	int *start;
+	unsigned count;
+	unsigned step;
+	int value;
+	bool done;
+
+public:
+	TestThread(int *, unsigned, unsigned, int);
+
+private:
+	virtual void main();
+
+public:
+	bool is_done() const { return done; }
+};
+
+
+ThreadTests::ThreadTests():
+	data(1000000)
+{
+	add(&ThreadTests::single, "Single thread");
+	add(&ThreadTests::multiple, "Multiple threads");
+}
+
+void ThreadTests::single()
+{
+	fill(data.begin(), data.end(), -1);
+
+	TestThread thread(&data[0], data.size(), 1, 1);
+	unsigned wait = 100;
+	while(wait && !thread.is_done())
+	{
+		Time::sleep(100*Time::msec);
+		--wait;
+	}
+
+	if(!wait)
+		fail("Thread did not finish");
+
+	thread.join();
+
+	for(vector<int>::iterator i=data.begin(); i!=data.end(); ++i)
+		if(*i!=1)
+			fail("Invalid data");
+}
+
+void ThreadTests::multiple()
+{
+	fill(data.begin(), data.end(), -1);
+
+	list<TestThread *> threads;
+	for(unsigned i=0; i<10; ++i)
+		threads.push_back(new TestThread(&data[i], data.size()/10, 10, i+1));
+	unsigned wait = 100;
+	while(wait && !threads.empty())
+	{
+		Time::sleep(100*Time::msec);
+		for(list<TestThread *>::iterator i=threads.begin(); i!=threads.end();)
+		{
+			if((*i)->is_done())
+			{
+				(*i)->join();
+				delete *i;
+				threads.erase(i++);
+			}
+			else
+				++i;
+		}
+		--wait;
+	}
+
+	if(!wait)
+		fail("Threads did not finish");
+
+	for(unsigned i=0; i<data.size(); ++i)
+		if(data[i]!=static_cast<int>(i%10+1))
+			fail("Invalid data");
+}
+
+
+TestThread::TestThread(int *s, unsigned c, unsigned t, int v):
+	start(s),
+	count(c),
+	step(t),
+	value(v),
+	done(false)
+{
+	launch();
+}
+
+void TestThread::main()
+{
+	int *ptr = start;
+	for(unsigned i=0; i<count; ++i)
+	{
+		*ptr = value;
+		ptr += step;
+	}
+	done = true;
+}
diff --git a/tests/timezone.cpp b/tests/timezone.cpp
new file mode 100644
index 0000000..c59cdd3
--- /dev/null
+++ b/tests/timezone.cpp
@@ -0,0 +1,48 @@
+#include <msp/time/units.h>
+#include <msp/time/timezone.h>
+#include <msp/test/test.h>
+
+using namespace std;
+using namespace Msp;
+
+class TimeZoneTests: public Test::RegisteredTest<TimeZoneTests>
+{
+public:
+	TimeZoneTests();
+
+	static const char *get_name() { return "TimeZone"; }
+
+private:
+	void utc();
+	void local();
+	void custom();
+};
+
+
+TimeZoneTests::TimeZoneTests()
+{
+	add(&TimeZoneTests::utc, "UTC");
+	add(&TimeZoneTests::local, "Local");
+	add(&TimeZoneTests::custom, "Custom");
+}
+
+void TimeZoneTests::utc()
+{
+	Time::TimeZone tz = Time::TimeZone::utc();
+	EXPECT_EQUAL(tz.get_name(), "UTC");
+	EXPECT_EQUAL(tz.get_offset(), Time::zero);
+}
+
+void TimeZoneTests::local()
+{
+	Time::TimeZone tz = Time::TimeZone::local();
+	info(format("'%s' %s", tz.get_name(), tz.get_offset()));
+}
+
+void TimeZoneTests::custom()
+{
+	Time::TimeZone tz1(120);
+	EXPECT_EQUAL(tz1.get_name(), "UTC+2");
+	Time::TimeZone tz2(345);
+	EXPECT_EQUAL(tz2.get_name(), "UTC+5:45");
+}
diff --git a/tests/variant.cpp b/tests/variant.cpp
new file mode 100644
index 0000000..99cacdf
--- /dev/null
+++ b/tests/variant.cpp
@@ -0,0 +1,113 @@
+#include <msp/core/variant.h>
+#include <msp/test/test.h>
+
+using namespace std;
+using namespace Msp;
+
+class VariantTests: public Test::RegisteredTest<VariantTests>
+{
+public:
+	VariantTests();
+
+	static const char *get_name() { return "Variant"; }
+
+private:
+	void integer();
+	void stdstring();
+	void pointer();
+	void ref_into();
+	void copying();
+	void destruction();
+	void types();
+	void mismatch();
+};
+
+class Counter
+{
+private:
+	int &count;
+
+public:
+	Counter(int &c): count(c) { ++count; }
+	Counter(const Counter &c): count(c.count) { ++count; }
+	~Counter() { --count; }
+};
+
+VariantTests::VariantTests()
+{
+	add(&VariantTests::integer, "Integer");
+	add(&VariantTests::stdstring, "std::string");
+	add(&VariantTests::pointer, "Pointer");
+	add(&VariantTests::ref_into, "Reference into");
+	add(&VariantTests::copying, "Copying");
+	add(&VariantTests::destruction, "Destruction");
+	add(&VariantTests::types, "Type checks");
+	add(&VariantTests::mismatch, "Mismatch").expect_throw<type_mismatch>();
+}
+
+void VariantTests::integer()
+{
+	Variant var = 42;
+	EXPECT_EQUAL(var.value<int>(), 42);
+}
+
+void VariantTests::stdstring()
+{
+	Variant var = string("foobar");
+	EXPECT_EQUAL(var.value<string>(), "foobar");
+}
+
+void VariantTests::pointer()
+{
+	int i = 7;
+	Variant var = &i;
+	*var.value<int *>() = 42;
+	EXPECT_EQUAL(i, 42);
+}
+
+void VariantTests::ref_into()
+{
+	Variant var = 7;
+	int &r = var.value<int>();
+	r = 42;
+	EXPECT_EQUAL(var.value<int>(), 42);
+}
+
+void VariantTests::copying()
+{
+	Variant var = 42;
+	Variant var2 = var;
+	EXPECT_EQUAL(var2.value<int>(), 42);
+}
+
+void VariantTests::destruction()
+{
+	int count = 0;
+	{
+		Variant var = Counter(count);
+		Variant var2 = var;
+		EXPECT_EQUAL(count, 2);
+		Variant var3;
+		var3 = var;
+		EXPECT_EQUAL(count, 3);
+		var2 = Variant();
+		EXPECT_EQUAL(count, 2);
+	}
+	EXPECT_EQUAL(count, 0);
+}
+
+void VariantTests::types()
+{
+	Variant var = 42U;
+	EXPECT(!var.check_type<int>());
+	EXPECT(var.check_type<unsigned>());
+	EXPECT(!var.check_type<float>());
+	EXPECT(!var.check_type<bool>());
+	EXPECT(!var.check_type<string>());
+}
+
+void VariantTests::mismatch()
+{
+	Variant var = 1;
+	var.value<string>();
+}