changeset 393:875b5ce19fda

Base64: remove class, use namespace
author David Demelier <markand@malikania.fr>
date Mon, 28 Sep 2015 15:16:31 +0200
parents e2cefd0ee511
children fdceef4be88b
files C++/modules/Base64/Base64.cpp C++/modules/Base64/Base64.h C++/tests/Base64/main.cpp
diffstat 3 files changed, 232 insertions(+), 231 deletions(-) [+]
line wrap: on
line diff
--- a/C++/modules/Base64/Base64.cpp	Mon Sep 28 13:18:14 2015 +0200
+++ b/C++/modules/Base64/Base64.cpp	Mon Sep 28 15:16:31 2015 +0200
@@ -21,14 +21,16 @@
 
 #include "Base64.h"
 
-char Base64::lookup(int value) noexcept
+namespace base64 {
+
+char lookup(int value) noexcept
 {
 	static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 	return table[value];
 }
 
-int Base64::rlookup(char ch)
+int rlookup(char ch)
 {
 	if (ch == '+')
 		return 62;
@@ -45,7 +47,7 @@
 	throw std::invalid_argument("not a valid base64 string");
 }
 
-std::string Base64::encode(const std::string &input)
+std::string encode(const std::string &input)
 {
 	std::string result;
 	std::istringstream iss(input, std::istringstream::in);
@@ -55,7 +57,7 @@
 	return result;
 }
 
-std::string Base64::decode(const std::string &input)
+std::string decode(const std::string &input)
 {
 	std::string result;
 	std::istringstream iss(input, std::istringstream::in);
@@ -63,4 +65,6 @@
 	decode(std::istreambuf_iterator<char>(iss), std::istreambuf_iterator<char>(), std::back_inserter(result));
 
 	return result;
-}
\ No newline at end of file
+}
+
+} // !base64
--- a/C++/modules/Base64/Base64.h	Mon Sep 28 13:18:14 2015 +0200
+++ b/C++/modules/Base64/Base64.h	Mon Sep 28 15:16:31 2015 +0200
@@ -27,108 +27,105 @@
 #include <stdexcept>
 #include <string>
 
+namespace base64 {
+
 /**
- * @class Base64
- * @brief Encode and decode Base64 data
+ * Get the base 64 character from the 6-bits value.
+ *
+ * @param value the value
  */
-class Base64 {
-public:
-	/**
-	 * Get the base 64 character from the 6-bits value.
-	 *
-	 * @param value the value
-	 */
-	static char lookup(int value) noexcept;
+char lookup(int value) noexcept;
 
-	/**
-	 * Get the integer value from the base 64 character.
-	 *
-	 * @param ch the base64 character
-	 */
-	static int rlookup(char ch);
+/**
+ * Get the integer value from the base 64 character.
+ *
+ * @param ch the base64 character
+ */
+int rlookup(char ch);
 
-	/**
-	 * Encode the input to the output. Requirements:
-	 *	InputIt	must be InputIterator
-	 *	OutputIt must be OutputIterator
-	 *
-	 * @param input the beginning
-	 * @param end the end of the data
-	 * @param output the output destination
-	 * @return output
-	 */
-	template <typename InputIt, typename OutputIt>
-	static OutputIt encode(InputIt input, InputIt end, OutputIt output)
-	{
-		while (input != end) {
-			char inputbuf[3] = { 0, 0, 0 };
-			int count;
+/**
+ * Encode the input to the output. Requirements:
+ *	InputIt	must be InputIterator
+ *	OutputIt must be OutputIterator
+ *
+ * @param input the beginning
+ * @param end the end of the data
+ * @param output the output destination
+ * @return output
+ */
+template <typename InputIt, typename OutputIt>
+OutputIt encode(InputIt input, InputIt end, OutputIt output)
+{
+	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);
-		}
-
-		return output;
+		*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);
 	}
 
-	/**
-	 * Decode the input to the output. Requirements:
-	 *	InputIt must be InputIterator
-	 *	OutputIt must be OutputIterator
-	 *
-	 * @param input the beginning
-	 * @param end the end of the data
-	 * @param output the output destination
-	 * @return output
-	 * @throw std::invalid_argument on bad base64 string
-	 */
-	template <typename InputIt, typename OutputIt>
-	static OutputIt decode(InputIt input, InputIt end, OutputIt output)
-	{
-		while (input != end) {
-			char inputbuf[4] = { 0, 0, 0, 0 };
-			int count;
+	return output;
+}
 
-			for (count = 0; count < 4 && input != end; ++count) {
-				inputbuf[count] = (*input == '=') ? '=' : rlookup(*input);
-				input++;
-			}
+/**
+ * Decode the input to the output. Requirements:
+ *	InputIt must be InputIterator
+ *	OutputIt must be OutputIterator
+ *
+ * @param input the beginning
+ * @param end the end of the data
+ * @param output the output destination
+ * @return output
+ * @throw std::invalid_argument on bad base64 string
+ */
+template <typename InputIt, typename OutputIt>
+OutputIt decode(InputIt input, InputIt end, OutputIt output)
+{
+	while (input != end) {
+		char inputbuf[4] = { 0, 0, 0, 0 };
+		int count;
 
-			if (count != 4)
-				throw std::invalid_argument("truncated string");
-
-			*output++ = (inputbuf[0] << 2 & 0xfc) | (inputbuf[1] >> 4 & 0x03);
-
-			if (inputbuf[2] != '=')
-				*output++ = (inputbuf[1] << 4 & 0xf0) | (inputbuf[2] >> 2 & 0x0f);
-			if (inputbuf[3] != '=')
-				*output++ = (inputbuf[2] << 6 & 0xc0) | (inputbuf[3] & 0x3f);
+		for (count = 0; count < 4 && input != end; ++count) {
+			inputbuf[count] = (*input == '=') ? '=' : rlookup(*input);
+			input++;
 		}
 
-		return output;
+		if (count != 4)
+			throw std::invalid_argument("truncated string");
+
+		*output++ = (inputbuf[0] << 2 & 0xfc) | (inputbuf[1] >> 4 & 0x03);
+
+		if (inputbuf[2] != '=')
+			*output++ = (inputbuf[1] << 4 & 0xf0) | (inputbuf[2] >> 2 & 0x0f);
+		if (inputbuf[3] != '=')
+			*output++ = (inputbuf[2] << 6 & 0xc0) | (inputbuf[3] & 0x3f);
 	}
 
-	/**
-	 * Encode a string.
-	 *
-	 * @param input the input string
-	 * @return the base64 formatted string
-	 */
-	static std::string encode(const std::string &input);
+	return output;
+}
+
+/**
+ * Encode a string.
+ *
+ * @param input the input string
+ * @return the base64 formatted string
+ */
+std::string encode(const std::string &input);
 
-	/**
-	 * Decode a string.
-	 *
-	 * @param input the base64 formatted string
-	 * @return the original string
-	 * @throw std::invalid_argument on bad base64 string
-	 */
-	static std::string decode(const std::string &input);
-};
+/**
+ * Decode a string.
+ *
+ * @param input the base64 formatted string
+ * @return the original string
+ * @throw std::invalid_argument on bad base64 string
+ */
+std::string decode(const std::string &input);
+
+} // !base64
 
 #endif // !_BASE_64_H_
--- a/C++/tests/Base64/main.cpp	Mon Sep 28 13:18:14 2015 +0200
+++ b/C++/tests/Base64/main.cpp	Mon Sep 28 15:16:31 2015 +0200
@@ -22,158 +22,158 @@
 
 TEST(Lookup, lookup)
 {
-	ASSERT_EQ('A', Base64::lookup(0b000000));
-	ASSERT_EQ('B', Base64::lookup(0b000001));
-	ASSERT_EQ('C', Base64::lookup(0b000010));
-	ASSERT_EQ('D', Base64::lookup(0b000011));
-	ASSERT_EQ('E', Base64::lookup(0b000100));
-	ASSERT_EQ('F', Base64::lookup(0b000101));
-	ASSERT_EQ('G', Base64::lookup(0b000110));
-	ASSERT_EQ('H', Base64::lookup(0b000111));
-	ASSERT_EQ('I', Base64::lookup(0b001000));
-	ASSERT_EQ('J', Base64::lookup(0b001001));
-	ASSERT_EQ('K', Base64::lookup(0b001010));
-	ASSERT_EQ('L', Base64::lookup(0b001011));
-	ASSERT_EQ('M', Base64::lookup(0b001100));
-	ASSERT_EQ('N', Base64::lookup(0b001101));
-	ASSERT_EQ('O', Base64::lookup(0b001110));
-	ASSERT_EQ('P', Base64::lookup(0b001111));
-	ASSERT_EQ('Q', Base64::lookup(0b010000));
-	ASSERT_EQ('R', Base64::lookup(0b010001));
-	ASSERT_EQ('S', Base64::lookup(0b010010));
-	ASSERT_EQ('T', Base64::lookup(0b010011));
-	ASSERT_EQ('U', Base64::lookup(0b010100));
-	ASSERT_EQ('V', Base64::lookup(0b010101));
-	ASSERT_EQ('W', Base64::lookup(0b010110));
-	ASSERT_EQ('X', Base64::lookup(0b010111));
-	ASSERT_EQ('Y', Base64::lookup(0b011000));
-	ASSERT_EQ('Z', Base64::lookup(0b011001));
-	ASSERT_EQ('a', Base64::lookup(0b011010));
-	ASSERT_EQ('b', Base64::lookup(0b011011));
-	ASSERT_EQ('c', Base64::lookup(0b011100));
-	ASSERT_EQ('d', Base64::lookup(0b011101));
-	ASSERT_EQ('e', Base64::lookup(0b011110));
-	ASSERT_EQ('f', Base64::lookup(0b011111));
-	ASSERT_EQ('g', Base64::lookup(0b100000));
-	ASSERT_EQ('h', Base64::lookup(0b100001));
-	ASSERT_EQ('i', Base64::lookup(0b100010));
-	ASSERT_EQ('j', Base64::lookup(0b100011));
-	ASSERT_EQ('k', Base64::lookup(0b100100));
-	ASSERT_EQ('l', Base64::lookup(0b100101));
-	ASSERT_EQ('m', Base64::lookup(0b100110));
-	ASSERT_EQ('n', Base64::lookup(0b100111));
-	ASSERT_EQ('o', Base64::lookup(0b101000));
-	ASSERT_EQ('p', Base64::lookup(0b101001));
-	ASSERT_EQ('q', Base64::lookup(0b101010));
-	ASSERT_EQ('r', Base64::lookup(0b101011));
-	ASSERT_EQ('s', Base64::lookup(0b101100));
-	ASSERT_EQ('t', Base64::lookup(0b101101));
-	ASSERT_EQ('u', Base64::lookup(0b101110));
-	ASSERT_EQ('v', Base64::lookup(0b101111));
-	ASSERT_EQ('w', Base64::lookup(0b110000));
-	ASSERT_EQ('x', Base64::lookup(0b110001));
-	ASSERT_EQ('y', Base64::lookup(0b110010));
-	ASSERT_EQ('z', Base64::lookup(0b110011));
-	ASSERT_EQ('0', Base64::lookup(0b110100));
-	ASSERT_EQ('1', Base64::lookup(0b110101));
-	ASSERT_EQ('2', Base64::lookup(0b110110));
-	ASSERT_EQ('3', Base64::lookup(0b110111));
-	ASSERT_EQ('4', Base64::lookup(0b111000));
-	ASSERT_EQ('5', Base64::lookup(0b111001));
-	ASSERT_EQ('6', Base64::lookup(0b111010));
-	ASSERT_EQ('7', Base64::lookup(0b111011));
-	ASSERT_EQ('8', Base64::lookup(0b111100));
-	ASSERT_EQ('9', Base64::lookup(0b111101));
-	ASSERT_EQ('+', Base64::lookup(0b111110));
-	ASSERT_EQ('/', Base64::lookup(0b111111));
+	ASSERT_EQ('A', base64::lookup(0b000000));
+	ASSERT_EQ('B', base64::lookup(0b000001));
+	ASSERT_EQ('C', base64::lookup(0b000010));
+	ASSERT_EQ('D', base64::lookup(0b000011));
+	ASSERT_EQ('E', base64::lookup(0b000100));
+	ASSERT_EQ('F', base64::lookup(0b000101));
+	ASSERT_EQ('G', base64::lookup(0b000110));
+	ASSERT_EQ('H', base64::lookup(0b000111));
+	ASSERT_EQ('I', base64::lookup(0b001000));
+	ASSERT_EQ('J', base64::lookup(0b001001));
+	ASSERT_EQ('K', base64::lookup(0b001010));
+	ASSERT_EQ('L', base64::lookup(0b001011));
+	ASSERT_EQ('M', base64::lookup(0b001100));
+	ASSERT_EQ('N', base64::lookup(0b001101));
+	ASSERT_EQ('O', base64::lookup(0b001110));
+	ASSERT_EQ('P', base64::lookup(0b001111));
+	ASSERT_EQ('Q', base64::lookup(0b010000));
+	ASSERT_EQ('R', base64::lookup(0b010001));
+	ASSERT_EQ('S', base64::lookup(0b010010));
+	ASSERT_EQ('T', base64::lookup(0b010011));
+	ASSERT_EQ('U', base64::lookup(0b010100));
+	ASSERT_EQ('V', base64::lookup(0b010101));
+	ASSERT_EQ('W', base64::lookup(0b010110));
+	ASSERT_EQ('X', base64::lookup(0b010111));
+	ASSERT_EQ('Y', base64::lookup(0b011000));
+	ASSERT_EQ('Z', base64::lookup(0b011001));
+	ASSERT_EQ('a', base64::lookup(0b011010));
+	ASSERT_EQ('b', base64::lookup(0b011011));
+	ASSERT_EQ('c', base64::lookup(0b011100));
+	ASSERT_EQ('d', base64::lookup(0b011101));
+	ASSERT_EQ('e', base64::lookup(0b011110));
+	ASSERT_EQ('f', base64::lookup(0b011111));
+	ASSERT_EQ('g', base64::lookup(0b100000));
+	ASSERT_EQ('h', base64::lookup(0b100001));
+	ASSERT_EQ('i', base64::lookup(0b100010));
+	ASSERT_EQ('j', base64::lookup(0b100011));
+	ASSERT_EQ('k', base64::lookup(0b100100));
+	ASSERT_EQ('l', base64::lookup(0b100101));
+	ASSERT_EQ('m', base64::lookup(0b100110));
+	ASSERT_EQ('n', base64::lookup(0b100111));
+	ASSERT_EQ('o', base64::lookup(0b101000));
+	ASSERT_EQ('p', base64::lookup(0b101001));
+	ASSERT_EQ('q', base64::lookup(0b101010));
+	ASSERT_EQ('r', base64::lookup(0b101011));
+	ASSERT_EQ('s', base64::lookup(0b101100));
+	ASSERT_EQ('t', base64::lookup(0b101101));
+	ASSERT_EQ('u', base64::lookup(0b101110));
+	ASSERT_EQ('v', base64::lookup(0b101111));
+	ASSERT_EQ('w', base64::lookup(0b110000));
+	ASSERT_EQ('x', base64::lookup(0b110001));
+	ASSERT_EQ('y', base64::lookup(0b110010));
+	ASSERT_EQ('z', base64::lookup(0b110011));
+	ASSERT_EQ('0', base64::lookup(0b110100));
+	ASSERT_EQ('1', base64::lookup(0b110101));
+	ASSERT_EQ('2', base64::lookup(0b110110));
+	ASSERT_EQ('3', base64::lookup(0b110111));
+	ASSERT_EQ('4', base64::lookup(0b111000));
+	ASSERT_EQ('5', base64::lookup(0b111001));
+	ASSERT_EQ('6', base64::lookup(0b111010));
+	ASSERT_EQ('7', base64::lookup(0b111011));
+	ASSERT_EQ('8', base64::lookup(0b111100));
+	ASSERT_EQ('9', base64::lookup(0b111101));
+	ASSERT_EQ('+', base64::lookup(0b111110));
+	ASSERT_EQ('/', base64::lookup(0b111111));
 }
 
 TEST(Lookup, rlookup)
 {
-	ASSERT_EQ(0b000000, Base64::rlookup('A'));
-	ASSERT_EQ(0b000001, Base64::rlookup('B'));
-	ASSERT_EQ(0b000010, Base64::rlookup('C'));
-	ASSERT_EQ(0b000011, Base64::rlookup('D'));
-	ASSERT_EQ(0b000100, Base64::rlookup('E'));
-	ASSERT_EQ(0b000101, Base64::rlookup('F'));
-	ASSERT_EQ(0b000110, Base64::rlookup('G'));
-	ASSERT_EQ(0b000111, Base64::rlookup('H'));
-	ASSERT_EQ(0b001000, Base64::rlookup('I'));
-	ASSERT_EQ(0b001001, Base64::rlookup('J'));
-	ASSERT_EQ(0b001010, Base64::rlookup('K'));
-	ASSERT_EQ(0b001011, Base64::rlookup('L'));
-	ASSERT_EQ(0b001100, Base64::rlookup('M'));
-	ASSERT_EQ(0b001101, Base64::rlookup('N'));
-	ASSERT_EQ(0b001110, Base64::rlookup('O'));
-	ASSERT_EQ(0b001111, Base64::rlookup('P'));
-	ASSERT_EQ(0b010000, Base64::rlookup('Q'));
-	ASSERT_EQ(0b010001, Base64::rlookup('R'));
-	ASSERT_EQ(0b010010, Base64::rlookup('S'));
-	ASSERT_EQ(0b010011, Base64::rlookup('T'));
-	ASSERT_EQ(0b010100, Base64::rlookup('U'));
-	ASSERT_EQ(0b010101, Base64::rlookup('V'));
-	ASSERT_EQ(0b010110, Base64::rlookup('W'));
-	ASSERT_EQ(0b010111, Base64::rlookup('X'));
-	ASSERT_EQ(0b011000, Base64::rlookup('Y'));
-	ASSERT_EQ(0b011001, Base64::rlookup('Z'));
-	ASSERT_EQ(0b011010, Base64::rlookup('a'));
-	ASSERT_EQ(0b011011, Base64::rlookup('b'));
-	ASSERT_EQ(0b011100, Base64::rlookup('c'));
-	ASSERT_EQ(0b011101, Base64::rlookup('d'));
-	ASSERT_EQ(0b011110, Base64::rlookup('e'));
-	ASSERT_EQ(0b011111, Base64::rlookup('f'));
-	ASSERT_EQ(0b100000, Base64::rlookup('g'));
-	ASSERT_EQ(0b100001, Base64::rlookup('h'));
-	ASSERT_EQ(0b100010, Base64::rlookup('i'));
-	ASSERT_EQ(0b100011, Base64::rlookup('j'));
-	ASSERT_EQ(0b100100, Base64::rlookup('k'));
-	ASSERT_EQ(0b100101, Base64::rlookup('l'));
-	ASSERT_EQ(0b100110, Base64::rlookup('m'));
-	ASSERT_EQ(0b100111, Base64::rlookup('n'));
-	ASSERT_EQ(0b101000, Base64::rlookup('o'));
-	ASSERT_EQ(0b101001, Base64::rlookup('p'));
-	ASSERT_EQ(0b101010, Base64::rlookup('q'));
-	ASSERT_EQ(0b101011, Base64::rlookup('r'));
-	ASSERT_EQ(0b101100, Base64::rlookup('s'));
-	ASSERT_EQ(0b101101, Base64::rlookup('t'));
-	ASSERT_EQ(0b101110, Base64::rlookup('u'));
-	ASSERT_EQ(0b101111, Base64::rlookup('v'));
-	ASSERT_EQ(0b110000, Base64::rlookup('w'));
-	ASSERT_EQ(0b110001, Base64::rlookup('x'));
-	ASSERT_EQ(0b110010, Base64::rlookup('y'));
-	ASSERT_EQ(0b110011, Base64::rlookup('z'));
-	ASSERT_EQ(0b110100, Base64::rlookup('0'));
-	ASSERT_EQ(0b110101, Base64::rlookup('1'));
-	ASSERT_EQ(0b110110, Base64::rlookup('2'));
-	ASSERT_EQ(0b110111, Base64::rlookup('3'));
-	ASSERT_EQ(0b111000, Base64::rlookup('4'));
-	ASSERT_EQ(0b111001, Base64::rlookup('5'));
-	ASSERT_EQ(0b111010, Base64::rlookup('6'));
-	ASSERT_EQ(0b111011, Base64::rlookup('7'));
-	ASSERT_EQ(0b111100, Base64::rlookup('8'));
-	ASSERT_EQ(0b111101, Base64::rlookup('9'));
-	ASSERT_EQ(0b111110, Base64::rlookup('+'));
-	ASSERT_EQ(0b111111, Base64::rlookup('/'));
+	ASSERT_EQ(0b000000, base64::rlookup('A'));
+	ASSERT_EQ(0b000001, base64::rlookup('B'));
+	ASSERT_EQ(0b000010, base64::rlookup('C'));
+	ASSERT_EQ(0b000011, base64::rlookup('D'));
+	ASSERT_EQ(0b000100, base64::rlookup('E'));
+	ASSERT_EQ(0b000101, base64::rlookup('F'));
+	ASSERT_EQ(0b000110, base64::rlookup('G'));
+	ASSERT_EQ(0b000111, base64::rlookup('H'));
+	ASSERT_EQ(0b001000, base64::rlookup('I'));
+	ASSERT_EQ(0b001001, base64::rlookup('J'));
+	ASSERT_EQ(0b001010, base64::rlookup('K'));
+	ASSERT_EQ(0b001011, base64::rlookup('L'));
+	ASSERT_EQ(0b001100, base64::rlookup('M'));
+	ASSERT_EQ(0b001101, base64::rlookup('N'));
+	ASSERT_EQ(0b001110, base64::rlookup('O'));
+	ASSERT_EQ(0b001111, base64::rlookup('P'));
+	ASSERT_EQ(0b010000, base64::rlookup('Q'));
+	ASSERT_EQ(0b010001, base64::rlookup('R'));
+	ASSERT_EQ(0b010010, base64::rlookup('S'));
+	ASSERT_EQ(0b010011, base64::rlookup('T'));
+	ASSERT_EQ(0b010100, base64::rlookup('U'));
+	ASSERT_EQ(0b010101, base64::rlookup('V'));
+	ASSERT_EQ(0b010110, base64::rlookup('W'));
+	ASSERT_EQ(0b010111, base64::rlookup('X'));
+	ASSERT_EQ(0b011000, base64::rlookup('Y'));
+	ASSERT_EQ(0b011001, base64::rlookup('Z'));
+	ASSERT_EQ(0b011010, base64::rlookup('a'));
+	ASSERT_EQ(0b011011, base64::rlookup('b'));
+	ASSERT_EQ(0b011100, base64::rlookup('c'));
+	ASSERT_EQ(0b011101, base64::rlookup('d'));
+	ASSERT_EQ(0b011110, base64::rlookup('e'));
+	ASSERT_EQ(0b011111, base64::rlookup('f'));
+	ASSERT_EQ(0b100000, base64::rlookup('g'));
+	ASSERT_EQ(0b100001, base64::rlookup('h'));
+	ASSERT_EQ(0b100010, base64::rlookup('i'));
+	ASSERT_EQ(0b100011, base64::rlookup('j'));
+	ASSERT_EQ(0b100100, base64::rlookup('k'));
+	ASSERT_EQ(0b100101, base64::rlookup('l'));
+	ASSERT_EQ(0b100110, base64::rlookup('m'));
+	ASSERT_EQ(0b100111, base64::rlookup('n'));
+	ASSERT_EQ(0b101000, base64::rlookup('o'));
+	ASSERT_EQ(0b101001, base64::rlookup('p'));
+	ASSERT_EQ(0b101010, base64::rlookup('q'));
+	ASSERT_EQ(0b101011, base64::rlookup('r'));
+	ASSERT_EQ(0b101100, base64::rlookup('s'));
+	ASSERT_EQ(0b101101, base64::rlookup('t'));
+	ASSERT_EQ(0b101110, base64::rlookup('u'));
+	ASSERT_EQ(0b101111, base64::rlookup('v'));
+	ASSERT_EQ(0b110000, base64::rlookup('w'));
+	ASSERT_EQ(0b110001, base64::rlookup('x'));
+	ASSERT_EQ(0b110010, base64::rlookup('y'));
+	ASSERT_EQ(0b110011, base64::rlookup('z'));
+	ASSERT_EQ(0b110100, base64::rlookup('0'));
+	ASSERT_EQ(0b110101, base64::rlookup('1'));
+	ASSERT_EQ(0b110110, base64::rlookup('2'));
+	ASSERT_EQ(0b110111, base64::rlookup('3'));
+	ASSERT_EQ(0b111000, base64::rlookup('4'));
+	ASSERT_EQ(0b111001, base64::rlookup('5'));
+	ASSERT_EQ(0b111010, base64::rlookup('6'));
+	ASSERT_EQ(0b111011, base64::rlookup('7'));
+	ASSERT_EQ(0b111100, base64::rlookup('8'));
+	ASSERT_EQ(0b111101, base64::rlookup('9'));
+	ASSERT_EQ(0b111110, base64::rlookup('+'));
+	ASSERT_EQ(0b111111, base64::rlookup('/'));
 }
 
 TEST(Encode, basic)
 {
-	ASSERT_EQ("YQ==", Base64::encode("a"));
-	ASSERT_EQ("YWI=", Base64::encode("ab"));
-	ASSERT_EQ("YWJj", Base64::encode("abc"));
+	ASSERT_EQ("YQ==", base64::encode("a"));
+	ASSERT_EQ("YWI=", base64::encode("ab"));
+	ASSERT_EQ("YWJj", base64::encode("abc"));
 
-	ASSERT_EQ("aGVsbG8=", Base64::encode("hello"));
-	ASSERT_EQ("dGhpcyBpcyBhIGxvbmcgc2VudGVuY2U=", Base64::encode("this is a long sentence"));
+	ASSERT_EQ("aGVsbG8=", base64::encode("hello"));
+	ASSERT_EQ("dGhpcyBpcyBhIGxvbmcgc2VudGVuY2U=", base64::encode("this is a long sentence"));
 }
 
 TEST(Decode, basic)
 {
-	ASSERT_EQ("a", Base64::decode("YQ=="));
-	ASSERT_EQ("ab", Base64::decode("YWI="));
-	ASSERT_EQ("abc", Base64::decode("YWJj"));
+	ASSERT_EQ("a", base64::decode("YQ=="));
+	ASSERT_EQ("ab", base64::decode("YWI="));
+	ASSERT_EQ("abc", base64::decode("YWJj"));
 
-	ASSERT_EQ("hello", Base64::decode("aGVsbG8="));
-	ASSERT_EQ("this is a long sentence", Base64::decode("dGhpcyBpcyBhIGxvbmcgc2VudGVuY2U="));
+	ASSERT_EQ("hello", base64::decode("aGVsbG8="));
+	ASSERT_EQ("this is a long sentence", base64::decode("dGhpcyBpcyBhIGxvbmcgc2VudGVuY2U="));
 }
 
 int main(int argc, char **argv)