changeset 18:bdc4fde21426

Style
author David Demelier <markand@malikania.fr>
date Fri, 05 Oct 2018 19:32:09 +0200
parents 0b524d7b7669
children 436f5c3243bf
files CMakeLists.txt base64.hpp doc/mainpage.cpp test/main.cpp
diffstat 4 files changed, 230 insertions(+), 230 deletions(-) [+]
line wrap: on
line diff
--- a/CMakeLists.txt	Thu Jun 28 22:05:49 2018 +0200
+++ b/CMakeLists.txt	Fri Oct 05 19:32:09 2018 +0200
@@ -32,12 +32,12 @@
 
 enable_testing()
 add_executable(
-    base64
-    ${base64_SOURCE_DIR}/base64.hpp
-    ${base64_SOURCE_DIR}/test/main.cpp
-    ${base64_SOURCE_DIR}/INSTALL.md
-    ${base64_SOURCE_DIR}/LICENSE.md
-    ${base64_SOURCE_DIR}/README.md
+	base64
+	${base64_SOURCE_DIR}/base64.hpp
+	${base64_SOURCE_DIR}/test/main.cpp
+	${base64_SOURCE_DIR}/INSTALL.md
+	${base64_SOURCE_DIR}/LICENSE.md
+	${base64_SOURCE_DIR}/README.md
 )
 target_link_libraries(base64 Boost::unit_test_framework)
 target_include_directories(base64 PRIVATE ${base64_SOURCE_DIR})
@@ -45,19 +45,19 @@
 add_test(NAME base64 COMMAND base64)
 
 if (DOXYGEN_FOUND)
-    set(DOXYGEN_PROJECT_NAME base64)
-    set(DOXYGEN_PROJECT_NUMBER ${BASE64_VERSION})
-    set(DOXYGEN_STRIP_FROM_PATH ${base64_SOURCE_DIR})
-    set(DOXYGEN_WARN_NO_PARAMDOC YES)
-    set(DOXYGEN_WARN_AS_ERROR YES)
-    set(DOXYGEN_QUIET YES)
+	set(DOXYGEN_PROJECT_NAME base64)
+	set(DOXYGEN_PROJECT_NUMBER ${BASE64_VERSION})
+	set(DOXYGEN_STRIP_FROM_PATH ${base64_SOURCE_DIR})
+	set(DOXYGEN_WARN_NO_PARAMDOC YES)
+	set(DOXYGEN_WARN_AS_ERROR YES)
+	set(DOXYGEN_QUIET YES)
 
-    doxygen_add_docs(
-        doxygen
-        ${base64_SOURCE_DIR}/doc/mainpage.cpp
-        ${base64_SOURCE_DIR}/base64.hpp
-        WORKING_DIRECTORY ${base64_SOURCE_DIR}
-    ) 
+	doxygen_add_docs(
+		doxygen
+		${base64_SOURCE_DIR}/doc/mainpage.cpp
+		${base64_SOURCE_DIR}/base64.hpp
+		WORKING_DIRECTORY ${base64_SOURCE_DIR}
+	)
 
-    add_dependencies(base64 doxygen)
+	add_dependencies(base64 doxygen)
 endif ()
--- a/base64.hpp	Thu Jun 28 22:05:49 2018 +0200
+++ b/base64.hpp	Fri Oct 05 19:32:09 2018 +0200
@@ -47,9 +47,9 @@
  *
  * ````
  * try {
- *  std::string text = base64::decode(msg);
+ * 	std::string text = base64::decode(msg);
  * } catch (const std::exception &ex) {
- *  std::cerr << ex.what() << std::endl;
+ * 	std::cerr << ex.what() << std::endl;
  * }
  * ````
  */
@@ -71,9 +71,9 @@
  * \param ch the character to test
  * \return true if valid
  */
-inline bool is_base64(char ch) noexcept
+inline auto is_base64(char ch) noexcept -> bool
 {
-    return std::isalnum(ch) != 0 || ch == '+' || ch == '/';
+	return std::isalnum(ch) != 0 || ch == '+' || ch == '/';
 }
 
 /**
@@ -83,9 +83,9 @@
  * \param ch the character
  * \return true if the character is valid
  */
-inline bool is_valid(char ch) noexcept
+inline auto is_valid(char ch) noexcept -> bool
 {
-    return is_base64(ch) || ch == '=';
+	return is_base64(ch) || ch == '=';
 }
 
 /**
@@ -95,13 +95,13 @@
  * \param value the value
  * \return the %base64 character for value
  */
-inline char lookup(unsigned char value) noexcept
+inline auto lookup(unsigned char value) noexcept -> char
 {
-    static std::string_view table("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
+	static std::string_view table("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
 
-    assert(value < 64);
+	assert(value < 64);
 
-    return table[value];
+	return table[value];
 }
 
 /**
@@ -114,18 +114,18 @@
  * auto b64 = base64::rlookup('D') // 3
  * ````
  */
-inline unsigned char rlookup(char ch) noexcept
+inline auto rlookup(char ch) noexcept -> unsigned char
 {
-    assert(is_base64(ch));
+	assert(is_base64(ch));
 
-    if (ch >= '0' && ch <= '9')
-        return static_cast<unsigned char>(ch + 4);
-    if (ch >= 'A' && ch <= 'Z')
-        return static_cast<unsigned char>(ch - 65);
-    if (ch >= 'a' && ch <= 'z')
-        return static_cast<unsigned char>(ch - 71);
+	if (ch >= '0' && ch <= '9')
+		return static_cast<unsigned char>(ch + 4);
+	if (ch >= 'A' && ch <= 'Z')
+		return static_cast<unsigned char>(ch - 65);
+	if (ch >= 'a' && ch <= 'z')
+		return static_cast<unsigned char>(ch - 71);
 
-    return (ch == '+') ? 62U : 63U;
+	return (ch == '+') ? 62U : 63U;
 }
 
 /**
@@ -141,22 +141,22 @@
  * \return output
  */
 template <typename InputIt, typename OutputIt>
-OutputIt encode(InputIt input, InputIt end, OutputIt output)
+auto encode(InputIt input, InputIt end, OutputIt output) -> OutputIt
 {
-    while (input != end) {
-        char inputbuf[3] = { 0, 0, 0 };
-        int count;
+	while (input != end) {
+		char inputbuf[3] = { 0, 0, 0 };
+		int count;
 
-        for (count = 0; count < 3 && input != end; ++count)
-            inputbuf[count] = *input++;
+		for (count = 0; count < 3 && input != end; ++count)
+			inputbuf[count] = *input++;
 
-        *output++ = lookup(inputbuf[0] >> 2 & 0x3f);
-        *output++ = lookup((inputbuf[0] << 4 & 0x3f) | (inputbuf[1] >> 4 & 0x0f));
-        *output++ = (count < 2) ? '=' : lookup((inputbuf[1] << 2 & 0x3c) | (inputbuf[2] >> 6 & 0x03));
-        *output++ = (count < 3) ? '=' : lookup(inputbuf[2] & 0x3f);
-    }
+		*output++ = lookup(inputbuf[0] >> 2 & 0x3f);
+		*output++ = lookup((inputbuf[0] << 4 & 0x3f) | (inputbuf[1] >> 4 & 0x0f));
+		*output++ = (count < 2) ? '=' : lookup((inputbuf[1] << 2 & 0x3c) | (inputbuf[2] >> 6 & 0x03));
+		*output++ = (count < 3) ? '=' : lookup(inputbuf[2] & 0x3f);
+	}
 
-    return output;
+	return output;
 }
 
 /**
@@ -173,39 +173,39 @@
  * \throw std::invalid_argument on bad %base64 string
  */
 template <typename InputIt, typename OutputIt>
-OutputIt decode(InputIt input, InputIt end, OutputIt output)
+auto decode(InputIt input, InputIt end, OutputIt output) -> OutputIt
 {
-    while (input != end) {
-        char inputbuf[4] = { -1, -1, -1, -1 };
-        int count;
+	while (input != end) {
+		char inputbuf[4] = { -1, -1, -1, -1 };
+		int count;
 
-        for (count = 0; count < 4 && input != end; ++count) {
-            // Check if the character is valid and get its value.
-            if ((*input == '=' && count <= 1) || !is_valid(*input))
-                throw std::invalid_argument("invalid base64 string");
-            if (is_base64(*input))
-                inputbuf[count] = static_cast<char>(rlookup(*input));
+		for (count = 0; count < 4 && input != end; ++count) {
+			// Check if the character is valid and get its value.
+			if ((*input == '=' && count <= 1) || !is_valid(*input))
+				throw std::invalid_argument("invalid base64 string");
+			if (is_base64(*input))
+				inputbuf[count] = static_cast<char>(rlookup(*input));
 
-            input++;
-        }
+			input++;
+		}
 
-        if (count != 4)
-            throw std::invalid_argument("truncated string");
+		if (count != 4)
+			throw std::invalid_argument("truncated string");
 
-        *output++ = static_cast<char>(((inputbuf[0] << 2) & 0xfc) | ((inputbuf[1] >> 4) & 0x03));
+		*output++ = static_cast<char>(((inputbuf[0] << 2) & 0xfc) | ((inputbuf[1] >> 4) & 0x03));
 
-        if (inputbuf[2] != -1)
-            *output++ = static_cast<char>(((inputbuf[1] << 4) & 0xf0) | ((inputbuf[2] >> 2) & 0x0f));
-        if (inputbuf[3] != -1) {
-            // "XY=Z" is not allowed.
-            if (inputbuf[2] == -1)
-                throw std::invalid_argument("invalid base64 string");
+		if (inputbuf[2] != -1)
+			*output++ = static_cast<char>(((inputbuf[1] << 4) & 0xf0) | ((inputbuf[2] >> 2) & 0x0f));
+		if (inputbuf[3] != -1) {
+			// "XY=Z" is not allowed.
+			if (inputbuf[2] == -1)
+				throw std::invalid_argument("invalid base64 string");
 
-            *output++ = static_cast<char>(((inputbuf[2] << 6) & 0xc0) | (inputbuf[3] & 0x3f));
-        }
-    }
+			*output++ = static_cast<char>(((inputbuf[2] << 6) & 0xc0) | (inputbuf[3] & 0x3f));
+		}
+	}
 
-    return output;
+	return output;
 }
 
 /**
@@ -214,13 +214,13 @@
  * \param input the input string
  * \return the %base64 formatted string
  */
-inline std::string encode(std::string_view input)
+inline auto encode(std::string_view input) -> std::string
 {
-    std::string result;
+	std::string result;
 
-    encode(input.begin(), input.end(), std::back_inserter(result));
+	encode(input.begin(), input.end(), std::back_inserter(result));
 
-    return result;
+	return result;
 }
 
 /**
@@ -230,13 +230,13 @@
  * \return the original string
  * \throw std::invalid_argument on bad %base64 string
  */
-inline std::string decode(std::string_view input)
+inline auto decode(std::string_view input) -> std::string
 {
-    std::string result;
+	std::string result;
 
-    decode(input.begin(), input.end(), std::back_inserter(result));
+	decode(input.begin(), input.end(), std::back_inserter(result));
 
-    return result;
+	return result;
 }
 
 } // !base64
--- a/doc/mainpage.cpp	Thu Jun 28 22:05:49 2018 +0200
+++ b/doc/mainpage.cpp	Fri Oct 05 19:32:09 2018 +0200
@@ -19,9 +19,9 @@
  *
  * int main(void)
  * {
- *  base64::encode("Hello World!");
+ * 	base64::encode("Hello World!");
  *
- *  return 0;
+ * 	return 0;
  * }
  * ````
  */
--- a/test/main.cpp	Thu Jun 28 22:05:49 2018 +0200
+++ b/test/main.cpp	Fri Oct 05 19:32:09 2018 +0200
@@ -23,185 +23,185 @@
 
 BOOST_AUTO_TEST_CASE(lookup)
 {
-    BOOST_TEST(base64::lookup(0b000000) == 'A');
-    BOOST_TEST(base64::lookup(0b000001) == 'B');
-    BOOST_TEST(base64::lookup(0b000010) == 'C');
-    BOOST_TEST(base64::lookup(0b000011) == 'D');
-    BOOST_TEST(base64::lookup(0b000100) == 'E');
-    BOOST_TEST(base64::lookup(0b000101) == 'F');
-    BOOST_TEST(base64::lookup(0b000110) == 'G');
-    BOOST_TEST(base64::lookup(0b000111) == 'H');
-    BOOST_TEST(base64::lookup(0b001000) == 'I');
-    BOOST_TEST(base64::lookup(0b001001) == 'J');
-    BOOST_TEST(base64::lookup(0b001010) == 'K');
-    BOOST_TEST(base64::lookup(0b001011) == 'L');
-    BOOST_TEST(base64::lookup(0b001100) == 'M');
-    BOOST_TEST(base64::lookup(0b001101) == 'N');
-    BOOST_TEST(base64::lookup(0b001110) == 'O');
-    BOOST_TEST(base64::lookup(0b001111) == 'P');
-    BOOST_TEST(base64::lookup(0b010000) == 'Q');
-    BOOST_TEST(base64::lookup(0b010001) == 'R');
-    BOOST_TEST(base64::lookup(0b010010) == 'S');
-    BOOST_TEST(base64::lookup(0b010011) == 'T');
-    BOOST_TEST(base64::lookup(0b010100) == 'U');
-    BOOST_TEST(base64::lookup(0b010101) == 'V');
-    BOOST_TEST(base64::lookup(0b010110) == 'W');
-    BOOST_TEST(base64::lookup(0b010111) == 'X');
-    BOOST_TEST(base64::lookup(0b011000) == 'Y');
-    BOOST_TEST(base64::lookup(0b011001) == 'Z');
-    BOOST_TEST(base64::lookup(0b011010) == 'a');
-    BOOST_TEST(base64::lookup(0b011011) == 'b');
-    BOOST_TEST(base64::lookup(0b011100) == 'c');
-    BOOST_TEST(base64::lookup(0b011101) == 'd');
-    BOOST_TEST(base64::lookup(0b011110) == 'e');
-    BOOST_TEST(base64::lookup(0b011111) == 'f');
-    BOOST_TEST(base64::lookup(0b100000) == 'g');
-    BOOST_TEST(base64::lookup(0b100001) == 'h');
-    BOOST_TEST(base64::lookup(0b100010) == 'i');
-    BOOST_TEST(base64::lookup(0b100011) == 'j');
-    BOOST_TEST(base64::lookup(0b100100) == 'k');
-    BOOST_TEST(base64::lookup(0b100101) == 'l');
-    BOOST_TEST(base64::lookup(0b100110) == 'm');
-    BOOST_TEST(base64::lookup(0b100111) == 'n');
-    BOOST_TEST(base64::lookup(0b101000) == 'o');
-    BOOST_TEST(base64::lookup(0b101001) == 'p');
-    BOOST_TEST(base64::lookup(0b101010) == 'q');
-    BOOST_TEST(base64::lookup(0b101011) == 'r');
-    BOOST_TEST(base64::lookup(0b101100) == 's');
-    BOOST_TEST(base64::lookup(0b101101) == 't');
-    BOOST_TEST(base64::lookup(0b101110) == 'u');
-    BOOST_TEST(base64::lookup(0b101111) == 'v');
-    BOOST_TEST(base64::lookup(0b110000) == 'w');
-    BOOST_TEST(base64::lookup(0b110001) == 'x');
-    BOOST_TEST(base64::lookup(0b110010) == 'y');
-    BOOST_TEST(base64::lookup(0b110011) == 'z');
-    BOOST_TEST(base64::lookup(0b110100) == '0');
-    BOOST_TEST(base64::lookup(0b110101) == '1');
-    BOOST_TEST(base64::lookup(0b110110) == '2');
-    BOOST_TEST(base64::lookup(0b110111) == '3');
-    BOOST_TEST(base64::lookup(0b111000) == '4');
-    BOOST_TEST(base64::lookup(0b111001) == '5');
-    BOOST_TEST(base64::lookup(0b111010) == '6');
-    BOOST_TEST(base64::lookup(0b111011) == '7');
-    BOOST_TEST(base64::lookup(0b111100) == '8');
-    BOOST_TEST(base64::lookup(0b111101) == '9');
-    BOOST_TEST(base64::lookup(0b111110) == '+');
-    BOOST_TEST(base64::lookup(0b111111) == '/');
+	BOOST_TEST(base64::lookup(0b000000) == 'A');
+	BOOST_TEST(base64::lookup(0b000001) == 'B');
+	BOOST_TEST(base64::lookup(0b000010) == 'C');
+	BOOST_TEST(base64::lookup(0b000011) == 'D');
+	BOOST_TEST(base64::lookup(0b000100) == 'E');
+	BOOST_TEST(base64::lookup(0b000101) == 'F');
+	BOOST_TEST(base64::lookup(0b000110) == 'G');
+	BOOST_TEST(base64::lookup(0b000111) == 'H');
+	BOOST_TEST(base64::lookup(0b001000) == 'I');
+	BOOST_TEST(base64::lookup(0b001001) == 'J');
+	BOOST_TEST(base64::lookup(0b001010) == 'K');
+	BOOST_TEST(base64::lookup(0b001011) == 'L');
+	BOOST_TEST(base64::lookup(0b001100) == 'M');
+	BOOST_TEST(base64::lookup(0b001101) == 'N');
+	BOOST_TEST(base64::lookup(0b001110) == 'O');
+	BOOST_TEST(base64::lookup(0b001111) == 'P');
+	BOOST_TEST(base64::lookup(0b010000) == 'Q');
+	BOOST_TEST(base64::lookup(0b010001) == 'R');
+	BOOST_TEST(base64::lookup(0b010010) == 'S');
+	BOOST_TEST(base64::lookup(0b010011) == 'T');
+	BOOST_TEST(base64::lookup(0b010100) == 'U');
+	BOOST_TEST(base64::lookup(0b010101) == 'V');
+	BOOST_TEST(base64::lookup(0b010110) == 'W');
+	BOOST_TEST(base64::lookup(0b010111) == 'X');
+	BOOST_TEST(base64::lookup(0b011000) == 'Y');
+	BOOST_TEST(base64::lookup(0b011001) == 'Z');
+	BOOST_TEST(base64::lookup(0b011010) == 'a');
+	BOOST_TEST(base64::lookup(0b011011) == 'b');
+	BOOST_TEST(base64::lookup(0b011100) == 'c');
+	BOOST_TEST(base64::lookup(0b011101) == 'd');
+	BOOST_TEST(base64::lookup(0b011110) == 'e');
+	BOOST_TEST(base64::lookup(0b011111) == 'f');
+	BOOST_TEST(base64::lookup(0b100000) == 'g');
+	BOOST_TEST(base64::lookup(0b100001) == 'h');
+	BOOST_TEST(base64::lookup(0b100010) == 'i');
+	BOOST_TEST(base64::lookup(0b100011) == 'j');
+	BOOST_TEST(base64::lookup(0b100100) == 'k');
+	BOOST_TEST(base64::lookup(0b100101) == 'l');
+	BOOST_TEST(base64::lookup(0b100110) == 'm');
+	BOOST_TEST(base64::lookup(0b100111) == 'n');
+	BOOST_TEST(base64::lookup(0b101000) == 'o');
+	BOOST_TEST(base64::lookup(0b101001) == 'p');
+	BOOST_TEST(base64::lookup(0b101010) == 'q');
+	BOOST_TEST(base64::lookup(0b101011) == 'r');
+	BOOST_TEST(base64::lookup(0b101100) == 's');
+	BOOST_TEST(base64::lookup(0b101101) == 't');
+	BOOST_TEST(base64::lookup(0b101110) == 'u');
+	BOOST_TEST(base64::lookup(0b101111) == 'v');
+	BOOST_TEST(base64::lookup(0b110000) == 'w');
+	BOOST_TEST(base64::lookup(0b110001) == 'x');
+	BOOST_TEST(base64::lookup(0b110010) == 'y');
+	BOOST_TEST(base64::lookup(0b110011) == 'z');
+	BOOST_TEST(base64::lookup(0b110100) == '0');
+	BOOST_TEST(base64::lookup(0b110101) == '1');
+	BOOST_TEST(base64::lookup(0b110110) == '2');
+	BOOST_TEST(base64::lookup(0b110111) == '3');
+	BOOST_TEST(base64::lookup(0b111000) == '4');
+	BOOST_TEST(base64::lookup(0b111001) == '5');
+	BOOST_TEST(base64::lookup(0b111010) == '6');
+	BOOST_TEST(base64::lookup(0b111011) == '7');
+	BOOST_TEST(base64::lookup(0b111100) == '8');
+	BOOST_TEST(base64::lookup(0b111101) == '9');
+	BOOST_TEST(base64::lookup(0b111110) == '+');
+	BOOST_TEST(base64::lookup(0b111111) == '/');
 }
 
 BOOST_AUTO_TEST_CASE(rlookup)
 {
-    BOOST_TEST(base64::rlookup('A') == 0b000000U);
-    BOOST_TEST(base64::rlookup('B') == 0b000001U);
-    BOOST_TEST(base64::rlookup('C') == 0b000010U);
-    BOOST_TEST(base64::rlookup('D') == 0b000011U);
-    BOOST_TEST(base64::rlookup('E') == 0b000100U);
-    BOOST_TEST(base64::rlookup('F') == 0b000101U);
-    BOOST_TEST(base64::rlookup('G') == 0b000110U);
-    BOOST_TEST(base64::rlookup('H') == 0b000111U);
-    BOOST_TEST(base64::rlookup('I') == 0b001000U);
-    BOOST_TEST(base64::rlookup('J') == 0b001001U);
-    BOOST_TEST(base64::rlookup('K') == 0b001010U);
-    BOOST_TEST(base64::rlookup('L') == 0b001011U);
-    BOOST_TEST(base64::rlookup('M') == 0b001100U);
-    BOOST_TEST(base64::rlookup('N') == 0b001101U);
-    BOOST_TEST(base64::rlookup('O') == 0b001110U);
-    BOOST_TEST(base64::rlookup('P') == 0b001111U);
-    BOOST_TEST(base64::rlookup('Q') == 0b010000U);
-    BOOST_TEST(base64::rlookup('R') == 0b010001U);
-    BOOST_TEST(base64::rlookup('S') == 0b010010U);
-    BOOST_TEST(base64::rlookup('T') == 0b010011U);
-    BOOST_TEST(base64::rlookup('U') == 0b010100U);
-    BOOST_TEST(base64::rlookup('V') == 0b010101U);
-    BOOST_TEST(base64::rlookup('W') == 0b010110U);
-    BOOST_TEST(base64::rlookup('X') == 0b010111U);
-    BOOST_TEST(base64::rlookup('Y') == 0b011000U);
-    BOOST_TEST(base64::rlookup('Z') == 0b011001U);
-    BOOST_TEST(base64::rlookup('a') == 0b011010U);
-    BOOST_TEST(base64::rlookup('b') == 0b011011U);
-    BOOST_TEST(base64::rlookup('c') == 0b011100U);
-    BOOST_TEST(base64::rlookup('d') == 0b011101U);
-    BOOST_TEST(base64::rlookup('e') == 0b011110U);
-    BOOST_TEST(base64::rlookup('f') == 0b011111U);
-    BOOST_TEST(base64::rlookup('g') == 0b100000U);
-    BOOST_TEST(base64::rlookup('h') == 0b100001U);
-    BOOST_TEST(base64::rlookup('i') == 0b100010U);
-    BOOST_TEST(base64::rlookup('j') == 0b100011U);
-    BOOST_TEST(base64::rlookup('k') == 0b100100U);
-    BOOST_TEST(base64::rlookup('l') == 0b100101U);
-    BOOST_TEST(base64::rlookup('m') == 0b100110U);
-    BOOST_TEST(base64::rlookup('n') == 0b100111U);
-    BOOST_TEST(base64::rlookup('o') == 0b101000U);
-    BOOST_TEST(base64::rlookup('p') == 0b101001U);
-    BOOST_TEST(base64::rlookup('q') == 0b101010U);
-    BOOST_TEST(base64::rlookup('r') == 0b101011U);
-    BOOST_TEST(base64::rlookup('s') == 0b101100U);
-    BOOST_TEST(base64::rlookup('t') == 0b101101U);
-    BOOST_TEST(base64::rlookup('u') == 0b101110U);
-    BOOST_TEST(base64::rlookup('v') == 0b101111U);
-    BOOST_TEST(base64::rlookup('w') == 0b110000U);
-    BOOST_TEST(base64::rlookup('x') == 0b110001U);
-    BOOST_TEST(base64::rlookup('y') == 0b110010U);
-    BOOST_TEST(base64::rlookup('z') == 0b110011U);
-    BOOST_TEST(base64::rlookup('0') == 0b110100U);
-    BOOST_TEST(base64::rlookup('1') == 0b110101U);
-    BOOST_TEST(base64::rlookup('2') == 0b110110U);
-    BOOST_TEST(base64::rlookup('3') == 0b110111U);
-    BOOST_TEST(base64::rlookup('4') == 0b111000U);
-    BOOST_TEST(base64::rlookup('5') == 0b111001U);
-    BOOST_TEST(base64::rlookup('6') == 0b111010U);
-    BOOST_TEST(base64::rlookup('7') == 0b111011U);
-    BOOST_TEST(base64::rlookup('8') == 0b111100U);
-    BOOST_TEST(base64::rlookup('9') == 0b111101U);
-    BOOST_TEST(base64::rlookup('+') == 0b111110U);
-    BOOST_TEST(base64::rlookup('/') == 0b111111U);
+	BOOST_TEST(base64::rlookup('A') == 0b000000U);
+	BOOST_TEST(base64::rlookup('B') == 0b000001U);
+	BOOST_TEST(base64::rlookup('C') == 0b000010U);
+	BOOST_TEST(base64::rlookup('D') == 0b000011U);
+	BOOST_TEST(base64::rlookup('E') == 0b000100U);
+	BOOST_TEST(base64::rlookup('F') == 0b000101U);
+	BOOST_TEST(base64::rlookup('G') == 0b000110U);
+	BOOST_TEST(base64::rlookup('H') == 0b000111U);
+	BOOST_TEST(base64::rlookup('I') == 0b001000U);
+	BOOST_TEST(base64::rlookup('J') == 0b001001U);
+	BOOST_TEST(base64::rlookup('K') == 0b001010U);
+	BOOST_TEST(base64::rlookup('L') == 0b001011U);
+	BOOST_TEST(base64::rlookup('M') == 0b001100U);
+	BOOST_TEST(base64::rlookup('N') == 0b001101U);
+	BOOST_TEST(base64::rlookup('O') == 0b001110U);
+	BOOST_TEST(base64::rlookup('P') == 0b001111U);
+	BOOST_TEST(base64::rlookup('Q') == 0b010000U);
+	BOOST_TEST(base64::rlookup('R') == 0b010001U);
+	BOOST_TEST(base64::rlookup('S') == 0b010010U);
+	BOOST_TEST(base64::rlookup('T') == 0b010011U);
+	BOOST_TEST(base64::rlookup('U') == 0b010100U);
+	BOOST_TEST(base64::rlookup('V') == 0b010101U);
+	BOOST_TEST(base64::rlookup('W') == 0b010110U);
+	BOOST_TEST(base64::rlookup('X') == 0b010111U);
+	BOOST_TEST(base64::rlookup('Y') == 0b011000U);
+	BOOST_TEST(base64::rlookup('Z') == 0b011001U);
+	BOOST_TEST(base64::rlookup('a') == 0b011010U);
+	BOOST_TEST(base64::rlookup('b') == 0b011011U);
+	BOOST_TEST(base64::rlookup('c') == 0b011100U);
+	BOOST_TEST(base64::rlookup('d') == 0b011101U);
+	BOOST_TEST(base64::rlookup('e') == 0b011110U);
+	BOOST_TEST(base64::rlookup('f') == 0b011111U);
+	BOOST_TEST(base64::rlookup('g') == 0b100000U);
+	BOOST_TEST(base64::rlookup('h') == 0b100001U);
+	BOOST_TEST(base64::rlookup('i') == 0b100010U);
+	BOOST_TEST(base64::rlookup('j') == 0b100011U);
+	BOOST_TEST(base64::rlookup('k') == 0b100100U);
+	BOOST_TEST(base64::rlookup('l') == 0b100101U);
+	BOOST_TEST(base64::rlookup('m') == 0b100110U);
+	BOOST_TEST(base64::rlookup('n') == 0b100111U);
+	BOOST_TEST(base64::rlookup('o') == 0b101000U);
+	BOOST_TEST(base64::rlookup('p') == 0b101001U);
+	BOOST_TEST(base64::rlookup('q') == 0b101010U);
+	BOOST_TEST(base64::rlookup('r') == 0b101011U);
+	BOOST_TEST(base64::rlookup('s') == 0b101100U);
+	BOOST_TEST(base64::rlookup('t') == 0b101101U);
+	BOOST_TEST(base64::rlookup('u') == 0b101110U);
+	BOOST_TEST(base64::rlookup('v') == 0b101111U);
+	BOOST_TEST(base64::rlookup('w') == 0b110000U);
+	BOOST_TEST(base64::rlookup('x') == 0b110001U);
+	BOOST_TEST(base64::rlookup('y') == 0b110010U);
+	BOOST_TEST(base64::rlookup('z') == 0b110011U);
+	BOOST_TEST(base64::rlookup('0') == 0b110100U);
+	BOOST_TEST(base64::rlookup('1') == 0b110101U);
+	BOOST_TEST(base64::rlookup('2') == 0b110110U);
+	BOOST_TEST(base64::rlookup('3') == 0b110111U);
+	BOOST_TEST(base64::rlookup('4') == 0b111000U);
+	BOOST_TEST(base64::rlookup('5') == 0b111001U);
+	BOOST_TEST(base64::rlookup('6') == 0b111010U);
+	BOOST_TEST(base64::rlookup('7') == 0b111011U);
+	BOOST_TEST(base64::rlookup('8') == 0b111100U);
+	BOOST_TEST(base64::rlookup('9') == 0b111101U);
+	BOOST_TEST(base64::rlookup('+') == 0b111110U);
+	BOOST_TEST(base64::rlookup('/') == 0b111111U);
 }
 
 BOOST_AUTO_TEST_CASE(encode)
 {
-    BOOST_TEST(base64::encode("a") == "YQ==");
-    BOOST_TEST(base64::encode("ab") == "YWI=");
-    BOOST_TEST(base64::encode("abc") == "YWJj");
-    BOOST_TEST(base64::encode("hello") == "aGVsbG8=");
-    BOOST_TEST(base64::encode("this is a long sentence") == "dGhpcyBpcyBhIGxvbmcgc2VudGVuY2U=");
+	BOOST_TEST(base64::encode("a") == "YQ==");
+	BOOST_TEST(base64::encode("ab") == "YWI=");
+	BOOST_TEST(base64::encode("abc") == "YWJj");
+	BOOST_TEST(base64::encode("hello") == "aGVsbG8=");
+	BOOST_TEST(base64::encode("this is a long sentence") == "dGhpcyBpcyBhIGxvbmcgc2VudGVuY2U=");
 }
 
 BOOST_AUTO_TEST_CASE(decode)
 {
-    BOOST_TEST(base64::decode("YQ==") == "a");
-    BOOST_TEST(base64::decode("YWI=") == "ab");
-    BOOST_TEST(base64::decode("YWJj") == "abc");
-    BOOST_TEST(base64::decode("aGVsbG8=") == "hello");
-    BOOST_TEST(base64::decode("dGhpcyBpcyBhIGxvbmcgc2VudGVuY2U=") == "this is a long sentence");
-    BOOST_TEST(base64::decode("V2VsY29tZSB0byBvdXIgc2VydmVyIGR1ZGU=") == "Welcome to our server dude");
+	BOOST_TEST(base64::decode("YQ==") == "a");
+	BOOST_TEST(base64::decode("YWI=") == "ab");
+	BOOST_TEST(base64::decode("YWJj") == "abc");
+	BOOST_TEST(base64::decode("aGVsbG8=") == "hello");
+	BOOST_TEST(base64::decode("dGhpcyBpcyBhIGxvbmcgc2VudGVuY2U=") == "this is a long sentence");
+	BOOST_TEST(base64::decode("V2VsY29tZSB0byBvdXIgc2VydmVyIGR1ZGU=") == "Welcome to our server dude");
 }
 
 BOOST_AUTO_TEST_CASE(truncated)
 {
-    BOOST_REQUIRE_THROW(base64::decode("YW="), std::invalid_argument);
+	BOOST_REQUIRE_THROW(base64::decode("YW="), std::invalid_argument);
 }
 
 BOOST_AUTO_TEST_CASE(invalid)
 {
-    BOOST_REQUIRE_THROW(base64::decode("?!"), std::invalid_argument);
+	BOOST_REQUIRE_THROW(base64::decode("?!"), std::invalid_argument);
 }
 
 BOOST_AUTO_TEST_CASE(wrong1)
 {
-    BOOST_REQUIRE_THROW(base64::decode("=ABC"), std::invalid_argument);
+	BOOST_REQUIRE_THROW(base64::decode("=ABC"), std::invalid_argument);
 }
 
 BOOST_AUTO_TEST_CASE(wrong2)
 {
-    BOOST_REQUIRE_THROW(base64::decode("A=BC"), std::invalid_argument);
+	BOOST_REQUIRE_THROW(base64::decode("A=BC"), std::invalid_argument);
 }
 
 BOOST_AUTO_TEST_CASE(wrong3)
 {
-    BOOST_REQUIRE_THROW(base64::decode("==BC"), std::invalid_argument);
+	BOOST_REQUIRE_THROW(base64::decode("==BC"), std::invalid_argument);
 }
 
 BOOST_AUTO_TEST_CASE(wrong4)
 {
-    BOOST_REQUIRE_THROW(base64::decode("AB=C"), std::invalid_argument);
+	BOOST_REQUIRE_THROW(base64::decode("AB=C"), std::invalid_argument);
 }