--- a/modules/unicode/test/main.cpp	Wed Jun 15 11:59:17 2016 +0200
+++ b/modules/unicode/test/main.cpp	Wed Jun 15 13:13:26 2016 +0200
@@ -33,34 +33,34 @@
 
 TEST(Conversion32to8, ascii)
 {
-	try {
-		std::u32string u32{'a', 'b', 'c'};
-		std::string s = unicode::toUtf8(u32);
+    try {
+        std::u32string u32{'a', 'b', 'c'};
+        std::string s = unicode::toUtf8(u32);
 
-		ASSERT_EQ("abc", s);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ("abc", s);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 TEST(Conversion32to8, valid)
 {
-	try {
-		std::u32string u32{'a', U'é', 'c', U'𠀀'};
-		std::string s = unicode::toUtf8(u32);
-		std::string expected = u8"aéc𠀀";
+    try {
+        std::u32string u32{'a', U'é', 'c', U'𠀀'};
+        std::string s = unicode::toUtf8(u32);
+        std::string expected = u8"aéc𠀀";
 
-		ASSERT_EQ(expected, s);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ(expected, s);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 TEST(Conversion32to8, invalid)
 {
-	std::u32string u32{'a', 0xFFFFFFFF, 'c'};
+    std::u32string u32{'a', 0xFFFFFFFF, 'c'};
 
-	ASSERT_ANY_THROW(unicode::toUtf8(u32));
+    ASSERT_ANY_THROW(unicode::toUtf8(u32));
 }
 
 /*
@@ -70,28 +70,28 @@
 
 TEST(Conversion8to32, ascii)
 {
-	try {
-		std::string s{"abc"};
-		std::u32string expected{'a', 'b', 'c'};
-		std::u32string result = unicode::toUtf32(s);
+    try {
+        std::string s{"abc"};
+        std::u32string expected{'a', 'b', 'c'};
+        std::u32string result = unicode::toUtf32(s);
 
-		ASSERT_EQ(expected, result);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ(expected, result);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 TEST(Conversion8to32, valid)
 {
-	try {
-		std::string s{u8"aéc𠀀"};
-		std::u32string expected{'a', U'é', 'c', U'𠀀'};
-		std::u32string result = unicode::toUtf32(s);
+    try {
+        std::string s{u8"aéc𠀀"};
+        std::u32string expected{'a', U'é', 'c', U'𠀀'};
+        std::u32string result = unicode::toUtf32(s);
 
-		ASSERT_EQ(expected, result);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ(expected, result);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 /*
@@ -101,41 +101,41 @@
 
 TEST(Toupper32, ascii)
 {
-	try {
-		std::u32string u32{'a', 'b', 'c'};
-		std::u32string expected{'A', 'B', 'C'};
-		std::u32string result = unicode::toupper(u32);
+    try {
+        std::u32string u32{'a', 'b', 'c'};
+        std::u32string expected{'A', 'B', 'C'};
+        std::u32string result = unicode::toupper(u32);
 
-		ASSERT_EQ(expected, result);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ(expected, result);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 TEST(Toupper32, valid)
 {
-	try {
-		std::u32string u32{U'ä', U'ç', U'ë'};
-		std::u32string expected{U'Ä', U'Ç', U'Ë'};
-		std::u32string result = unicode::toupper(u32);
+    try {
+        std::u32string u32{U'ä', U'ç', U'ë'};
+        std::u32string expected{U'Ä', U'Ç', U'Ë'};
+        std::u32string result = unicode::toupper(u32);
 
-		ASSERT_EQ(expected, result);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ(expected, result);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 TEST(Toupper32, invalid)
 {
-	try {
-		std::u32string u32{'a', 0xFFFFFFFF, 'b'};
-		std::u32string expected{'A', 0xFFFFFFFF, 'B'};
-		std::u32string result = unicode::toupper(u32);
+    try {
+        std::u32string u32{'a', 0xFFFFFFFF, 'b'};
+        std::u32string expected{'A', 0xFFFFFFFF, 'B'};
+        std::u32string result = unicode::toupper(u32);
 
-		ASSERT_EQ(expected, result);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ(expected, result);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 /*
@@ -145,41 +145,41 @@
 
 TEST(Tolower32, ascii)
 {
-	try {
-		std::u32string u32{'A', 'B', 'C'};
-		std::u32string expected{'a', 'b', 'c'};
-		std::u32string result = unicode::tolower(u32);
+    try {
+        std::u32string u32{'A', 'B', 'C'};
+        std::u32string expected{'a', 'b', 'c'};
+        std::u32string result = unicode::tolower(u32);
 
-		ASSERT_EQ(expected, result);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ(expected, result);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 TEST(Tolower32, valid)
 {
-	try {
-		std::u32string u32{U'Ä', U'Ç', U'Ë'};
-		std::u32string expected{U'ä', U'ç', U'ë'};
-		std::u32string result = unicode::tolower(u32);
+    try {
+        std::u32string u32{U'Ä', U'Ç', U'Ë'};
+        std::u32string expected{U'ä', U'ç', U'ë'};
+        std::u32string result = unicode::tolower(u32);
 
-		ASSERT_EQ(expected, result);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ(expected, result);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 TEST(Tolower32, invalid)
 {
-	try {
-		std::u32string u32{'A', 0xFFFFFFFF, 'B'};
-		std::u32string expected{'a', 0xFFFFFFFF, 'b'};
-		std::u32string result = unicode::tolower(u32);
+    try {
+        std::u32string u32{'A', 0xFFFFFFFF, 'B'};
+        std::u32string expected{'a', 0xFFFFFFFF, 'b'};
+        std::u32string result = unicode::tolower(u32);
 
-		ASSERT_EQ(expected, result);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ(expected, result);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 /*
@@ -189,33 +189,33 @@
 
 TEST(Toupper8, ascii)
 {
-	try {
-		std::string s{"abc"};
-		std::string r = unicode::toupper(s);
+    try {
+        std::string s{"abc"};
+        std::string r = unicode::toupper(s);
 
-		ASSERT_EQ("ABC", r);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ("ABC", r);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 TEST(Toupper8, valid)
 {
-	try {
-		std::string s{u8"aéc"};
-		std::string r = unicode::toupper(s);
+    try {
+        std::string s{u8"aéc"};
+        std::string r = unicode::toupper(s);
 
-		ASSERT_EQ(u8"AÉC", r);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ(u8"AÉC", r);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 TEST(Toupper8, invalid)
 {
-	std::string s{"a" "\xFF""b"};
+    std::string s{"a" "\xFF""b"};
 
-	ASSERT_ANY_THROW(unicode::toupper(s));
+    ASSERT_ANY_THROW(unicode::toupper(s));
 }
 
 /*
@@ -225,33 +225,33 @@
 
 TEST(Tolower8, ascii)
 {
-	try {
-		std::string s{"ABC"};
-		std::string r = unicode::tolower(s);
+    try {
+        std::string s{"ABC"};
+        std::string r = unicode::tolower(s);
 
-		ASSERT_EQ("abc", r);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ("abc", r);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 TEST(Tolower8, valid)
 {
-	try {
-		std::string s{u8"AÉC"};
-		std::string r = unicode::tolower(s);
+    try {
+        std::string s{u8"AÉC"};
+        std::string r = unicode::tolower(s);
 
-		ASSERT_EQ(u8"aéc", r);
-	} catch (const std::exception &ex) {
-		FAIL() << ex.what();
-	}
+        ASSERT_EQ(u8"aéc", r);
+    } catch (const std::exception &ex) {
+        FAIL() << ex.what();
+    }
 }
 
 TEST(Tolower8, invalid)
 {
-	std::string s{"A" "\xFF""B"};
+    std::string s{"A" "\xFF""B"};
 
-	ASSERT_ANY_THROW(unicode::tolower(s));
+    ASSERT_ANY_THROW(unicode::tolower(s));
 }
 
 /*
@@ -261,30 +261,30 @@
 
 TEST(Check, isspace)
 {
-	ASSERT_TRUE(unicode::isspace(' '));
-	ASSERT_FALSE(unicode::isspace(/* é */ 233));
+    ASSERT_TRUE(unicode::isspace(' '));
+    ASSERT_FALSE(unicode::isspace(/* é */ 233));
 }
 
 TEST(Check, isalpha)
 {
-	ASSERT_TRUE(unicode::isalpha(U'é'));
-	ASSERT_FALSE(unicode::isalpha(U'€'));
+    ASSERT_TRUE(unicode::isalpha(U'é'));
+    ASSERT_FALSE(unicode::isalpha(U'€'));
 }
 
 TEST(Check, isupper)
 {
-	ASSERT_FALSE(unicode::isupper('a'));
-	ASSERT_FALSE(unicode::isupper(U'é'));
-	ASSERT_TRUE(unicode::isupper('A'));
-	ASSERT_TRUE(unicode::isupper(U'É'));
+    ASSERT_FALSE(unicode::isupper('a'));
+    ASSERT_FALSE(unicode::isupper(U'é'));
+    ASSERT_TRUE(unicode::isupper('A'));
+    ASSERT_TRUE(unicode::isupper(U'É'));
 }
 
 TEST(Check, islower)
 {
-	ASSERT_TRUE(unicode::islower('a'));
-	ASSERT_TRUE(unicode::islower(U'é'));
-	ASSERT_FALSE(unicode::islower('A'));
-	ASSERT_FALSE(unicode::islower(U'É'));
+    ASSERT_TRUE(unicode::islower('a'));
+    ASSERT_TRUE(unicode::islower(U'é'));
+    ASSERT_FALSE(unicode::islower('A'));
+    ASSERT_FALSE(unicode::islower(U'É'));
 }
 
 /*
@@ -294,56 +294,56 @@
 
 TEST(Misc, nbytesPoint)
 {
-	ASSERT_EQ(1, unicode::nbytesPoint('a'));
-	ASSERT_EQ(2, unicode::nbytesPoint(U'é'));
-	ASSERT_EQ(3, unicode::nbytesPoint(U'€'));
-	ASSERT_EQ(4, unicode::nbytesPoint(U'𠀀'));
+    ASSERT_EQ(1, unicode::nbytesPoint('a'));
+    ASSERT_EQ(2, unicode::nbytesPoint(U'é'));
+    ASSERT_EQ(3, unicode::nbytesPoint(U'€'));
+    ASSERT_EQ(4, unicode::nbytesPoint(U'𠀀'));
 }
 
 TEST(Misc, nbytesUtf8)
 {
-	std::string s1{u8"a"};
-	std::string s2{u8"é"};
-	std::string s3{u8"€"};
-	std::string s4{u8"𠀀"};
+    std::string s1{u8"a"};
+    std::string s2{u8"é"};
+    std::string s3{u8"€"};
+    std::string s4{u8"𠀀"};
 
-	ASSERT_EQ(1, unicode::nbytesUtf8(s1[0]));
-	ASSERT_EQ(2, unicode::nbytesUtf8(s2[0]));
-	ASSERT_EQ(3, unicode::nbytesUtf8(s3[0]));
-	ASSERT_EQ(4, unicode::nbytesUtf8(s4[0]));
+    ASSERT_EQ(1, unicode::nbytesUtf8(s1[0]));
+    ASSERT_EQ(2, unicode::nbytesUtf8(s2[0]));
+    ASSERT_EQ(3, unicode::nbytesUtf8(s3[0]));
+    ASSERT_EQ(4, unicode::nbytesUtf8(s4[0]));
 }
 
 TEST(Misc, forEach)
 {
-	std::string s{u8"aé€𠀀"};
-	int current = 0;
+    std::string s{u8"aé€𠀀"};
+    int current = 0;
 
-	unicode::forEach(s, [&] (char32_t code) {
-		if (current == 0)
-			ASSERT_EQ(U'a', code);
-		else if (current == 1)
-			ASSERT_EQ(U'é', code);
-		else if (current == 2)
-			ASSERT_EQ(U'€', code);
-		else if (current == 3)
-			ASSERT_EQ(U'𠀀', code);
+    unicode::forEach(s, [&] (char32_t code) {
+        if (current == 0)
+            ASSERT_EQ(U'a', code);
+        else if (current == 1)
+            ASSERT_EQ(U'é', code);
+        else if (current == 2)
+            ASSERT_EQ(U'€', code);
+        else if (current == 3)
+            ASSERT_EQ(U'𠀀', code);
 
-		current++;
-	});
+        current++;
+    });
 
-	ASSERT_EQ(4, current);
+    ASSERT_EQ(4, current);
 }
 
 TEST(Misc, forEachInvalid)
 {
-	std::string s{"a" "\xFF" "b"};
+    std::string s{"a" "\xFF" "b"};
 
-	ASSERT_ANY_THROW(unicode::forEach(s, [&] (char32_t) { }));
+    ASSERT_ANY_THROW(unicode::forEach(s, [&] (char32_t) { }));
 }
 
 int main(int argc, char **argv)
 {
-	InitGoogleTest(&argc, argv);
+    InitGoogleTest(&argc, argv);
 
-	return RUN_ALL_TESTS();
+    return RUN_ALL_TESTS();
 }