18 files changed, 200 insertions, 108 deletions
diff --git a/Swiften/StringCodecs/Base64.cpp b/Swiften/StringCodecs/Base64.cpp
index 795d982..4ec2e16 100644
--- a/Swiften/StringCodecs/Base64.cpp
+++ b/Swiften/StringCodecs/Base64.cpp
@@ -5,9 +5,11 @@
  */
 
 #include <boost/numeric/conversion/cast.hpp>
+
 #include <algorithm>
 
-#include "Swiften/StringCodecs/Base64.h"
+#include <Swiften/StringCodecs/Base64.h>
+#include <Swiften/Base/Algorithm.h>
 
 namespace Swift {
 
@@ -15,7 +17,7 @@ namespace Swift {
 
 std::string Base64::encode(const ByteArray &s) {
 	int i;
-	int len = s.getSize();
+	int len = s.size();
 	char tbl[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 	int a, b, c;
 
@@ -48,7 +50,7 @@ std::string Base64::encode(const ByteArray &s) {
 
 ByteArray Base64::decode(const std::string& input) {
 	std::string inputWithoutNewlines(input);
-	inputWithoutNewlines.erase(std::remove(inputWithoutNewlines.begin(), inputWithoutNewlines.end(), '\n'), inputWithoutNewlines.end());
+	erase(inputWithoutNewlines, '\n');
 
 	const std::string& s = inputWithoutNewlines;
 	ByteArray p;
diff --git a/Swiften/StringCodecs/Base64.h b/Swiften/StringCodecs/Base64.h
index 4b19a9f..3b14595 100644
--- a/Swiften/StringCodecs/Base64.h
+++ b/Swiften/StringCodecs/Base64.h
@@ -9,7 +9,7 @@
 #include <vector>
 
 #include <string>
-#include "Swiften/Base/ByteArray.h"
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 	class Base64 {
diff --git a/Swiften/StringCodecs/HMACSHA1.cpp b/Swiften/StringCodecs/HMACSHA1.cpp
index 6ae5513..e583e3b 100644
--- a/Swiften/StringCodecs/HMACSHA1.cpp
+++ b/Swiften/StringCodecs/HMACSHA1.cpp
@@ -4,19 +4,20 @@
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
-#include "Swiften/StringCodecs/HMACSHA1.h"
+#include <Swiften/StringCodecs/HMACSHA1.h>
 
 #include <cassert>
 
-#include "Swiften/StringCodecs/SHA1.h"
-#include "Swiften/Base/ByteArray.h"
+#include <Swiften/StringCodecs/SHA1.h>
+#include <Swiften/Base/ByteArray.h>
+#include <Swiften/Base/Algorithm.h>
 
 namespace Swift {
 
 static const unsigned int B = 64;
 
 ByteArray HMACSHA1::getResult(const ByteArray& key, const ByteArray& data) {
-	assert(key.getSize() <= B);
+	assert(key.size() <= B);
 
 	// Create the padded key
 	ByteArray paddedKey(key);
@@ -24,17 +25,17 @@ ByteArray HMACSHA1::getResult(const ByteArray& key, const ByteArray& data) {
 
 	// Create the first value
 	ByteArray x(paddedKey);
-	for (unsigned int i = 0; i < x.getSize(); ++i) {
+	for (unsigned int i = 0; i < x.size(); ++i) {
 		x[i] ^= 0x36;
 	}
-	x += data;
+	append(x, data);
 
 	// Create the second value
 	ByteArray y(paddedKey);
-	for (unsigned int i = 0; i < y.getSize(); ++i) {
+	for (unsigned int i = 0; i < y.size(); ++i) {
 		y[i] ^= 0x5c;
 	}
-	y += SHA1::getHash(x);
+	append(y, SHA1::getHash(x));
 
 	return SHA1::getHash(y);
 }
@@ -53,19 +54,19 @@ ByteArray HMACSHA1::getResult(const ByteArray& key, const ByteArray& data) {
 
 void HMACSHA1::getResult(const ByteArray& key, const ByteArray& data, ByteArray& result) {
 	// Create first value
-	size_t xSize = B + data.getSize();
+	size_t xSize = B + data.size();
 	unsigned char* x = (unsigned char*) malloc(xSize * sizeof(unsigned char));
 	memset(x, 0, B);
-	memcpy(x, key.getData(), key.getSize());
+	memcpy(x, key.getData(), key.size());
 	for (unsigned int i = 0; i < (B>>32); ++i) {
 		x[i<<32] ^= 0x36363636;
 	}
-	memcpy(x + B, data.getData(), data.getSize());
+	memcpy(x + B, data.getData(), data.size());
 
 	// Create the second value
 	unsigned char y[B + 20];
 	memset(y, 0, B);
-	memcpy(y, key.getData(), key.getSize());
+	memcpy(y, key.getData(), key.size());
 	for (unsigned int i = 0; i < (B>>32); ++i) {
 		y[i<<32] ^= 0x5c5c5c5c;
 	}
diff --git a/Swiften/StringCodecs/HMACSHA1.h b/Swiften/StringCodecs/HMACSHA1.h
index cc6cb04..39c6e4e 100644
--- a/Swiften/StringCodecs/HMACSHA1.h
+++ b/Swiften/StringCodecs/HMACSHA1.h
@@ -6,9 +6,9 @@
 
 #pragma once
 
-namespace Swift {
-	class ByteArray;
+#include <Swiften/Base/ByteArray.h>
 
+namespace Swift {
 	class HMACSHA1 {
 		public:
 			static ByteArray getResult(const ByteArray& key, const ByteArray& data);
diff --git a/Swiften/StringCodecs/Hexify.cpp b/Swiften/StringCodecs/Hexify.cpp
index 61732b0..367743c 100644
--- a/Swiften/StringCodecs/Hexify.cpp
+++ b/Swiften/StringCodecs/Hexify.cpp
@@ -4,14 +4,14 @@
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
-#include "Swiften/StringCodecs/Hexify.h"
+#include <Swiften/StringCodecs/Hexify.h>
 
 #include <sstream>
 #include <iomanip>
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <string>
-#include "Swiften/Base/ByteArray.h"
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 
@@ -25,7 +25,7 @@ std::string Hexify::hexify(const ByteArray& data) {
 	std::ostringstream result;
 	result << std::hex;
 
-	for (unsigned int i = 0; i < data.getSize(); ++i) {
+	for (unsigned int i = 0; i < data.size(); ++i) {
 		result << std::setw(2) << std::setfill('0') << boost::numeric_cast<unsigned int>(static_cast<unsigned char>(data[i]));
 	}
 	return std::string(result.str());
diff --git a/Swiften/StringCodecs/Hexify.h b/Swiften/StringCodecs/Hexify.h
index f85db15..9815e21 100644
--- a/Swiften/StringCodecs/Hexify.h
+++ b/Swiften/StringCodecs/Hexify.h
@@ -6,12 +6,9 @@
 
 #pragma once
 
-#include <string>
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
-	
-	class ByteArray;
-
 	class Hexify {
 		public:
 			static std::string hexify(unsigned char byte);
diff --git a/Swiften/StringCodecs/MD5.cpp b/Swiften/StringCodecs/MD5.cpp
index 718f52e..9e69172 100644
--- a/Swiften/StringCodecs/MD5.cpp
+++ b/Swiften/StringCodecs/MD5.cpp
@@ -33,12 +33,13 @@
 
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 
-#include "Swiften/StringCodecs/MD5.h"
+#include <Swiften/StringCodecs/MD5.h>
 
 #include <cassert>
+#include <string.h>
 
-#include "Swiften/Base/ByteArray.h"
-#include "Swiften/Base/Platform.h"
+#include <Swiften/Base/ByteArray.h>
+#include <Swiften/Base/Platform.h>
 
 namespace Swift {
 
@@ -356,8 +357,8 @@ ByteArray MD5::getHash(const ByteArray& data) {
 
 	md5_state_t state;
 	md5_init(&state);
-	md5_append(&state, reinterpret_cast<const md5_byte_t*>(data.getData()), data.getSize());
-	md5_finish(&state, reinterpret_cast<md5_byte_t*>(digest.getData()));
+	md5_append(&state, reinterpret_cast<const md5_byte_t*>(vecptr(data)), data.size());
+	md5_finish(&state, reinterpret_cast<md5_byte_t*>(vecptr(digest)));
 
 	return digest;
 }
diff --git a/Swiften/StringCodecs/MD5.h b/Swiften/StringCodecs/MD5.h
index b896529..93c48e9 100644
--- a/Swiften/StringCodecs/MD5.h
+++ b/Swiften/StringCodecs/MD5.h
@@ -6,9 +6,9 @@
 
 #pragma once
 
-namespace Swift {
-	class ByteArray;
+#include <Swiften/Base/ByteArray.h>
 
+namespace Swift {
 	class MD5 {
 		public:
 			static ByteArray getHash(const ByteArray& data);
diff --git a/Swiften/StringCodecs/PBKDF2.cpp b/Swiften/StringCodecs/PBKDF2.cpp
index a652242..c4a5a7f 100644
--- a/Swiften/StringCodecs/PBKDF2.cpp
+++ b/Swiften/StringCodecs/PBKDF2.cpp
@@ -4,18 +4,19 @@
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
-#include "Swiften/StringCodecs/PBKDF2.h"
-#include "Swiften/StringCodecs/HMACSHA1.h"
+#include <Swiften/StringCodecs/PBKDF2.h>
+#include <Swiften/StringCodecs/HMACSHA1.h>
+#include <Swiften/Base/Concat.h>
 
 namespace Swift {
 
 ByteArray PBKDF2::encode(const ByteArray& password, const ByteArray& salt, int iterations) {
-	ByteArray u = HMACSHA1::getResult(password, salt + ByteArray("\0\0\0\1", 4));
-	ByteArray result = u;
+	ByteArray u = HMACSHA1::getResult(password, concat(salt, createByteArray("\0\0\0\1", 4)));
+	ByteArray result(u);
 	int i = 1;
 	while (i < iterations) {
 		u = HMACSHA1::getResult(password, u);
-		for (unsigned int j = 0; j < u.getSize(); ++j) {
+		for (unsigned int j = 0; j < u.size(); ++j) {
 			result[j] ^= u[j];
 		}
 		++i;
diff --git a/Swiften/StringCodecs/PBKDF2.h b/Swiften/StringCodecs/PBKDF2.h
index 7f87af7..dd31921 100644
--- a/Swiften/StringCodecs/PBKDF2.h
+++ b/Swiften/StringCodecs/PBKDF2.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include "Swiften/Base/ByteArray.h"
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 	class PBKDF2 {
diff --git a/Swiften/StringCodecs/SHA1.cpp b/Swiften/StringCodecs/SHA1.cpp
index 9882f70..5001fb2 100644
--- a/Swiften/StringCodecs/SHA1.cpp
+++ b/Swiften/StringCodecs/SHA1.cpp
@@ -4,10 +4,14 @@
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
-#include "Swiften/Base/Platform.h"
+#include <Swiften/StringCodecs/SHA1.h>
+
+#include <Swiften/Base/Platform.h>
 
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 
+using namespace Swift;
+
 /*
 SHA-1 in C
 By Steve Reid <steve@edmweb.com>
@@ -25,21 +29,9 @@ A million repetitions of "a"
 /* #define LITTLE_ENDIAN * This should be #define'd if true. */
 /* #define SHA1HANDSOFF * Copies data before messing with it. */
 
-#include <boost/cstdint.hpp>
 #include <stdio.h>
 #include <string.h>
 
-typedef struct {
-		boost::uint32_t state[5];
-		boost::uint32_t count[2];
-		boost::uint8_t buffer[64];
-} SHA1_CTX;
-
-void SHA1Transform(boost::uint32_t state[5], boost::uint8_t buffer[64]);
-void SHA1Init(SHA1_CTX* context);
-void SHA1Update(SHA1_CTX* context, boost::uint8_t* data, unsigned int len);
-void SHA1Final(boost::uint8_t digest[20], SHA1_CTX* context);
-
 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
 
 /* blk0() and blk() perform the initial expand. */
@@ -63,7 +55,7 @@ void SHA1Final(boost::uint8_t digest[20], SHA1_CTX* context);
 
 /* Hash a single 512-bit block. This is the core of the algorithm. */
 
-void SHA1Transform(boost::uint32_t state[5], boost::uint8_t buffer[64])
+void SHA1::Transform(boost::uint32_t state[5], boost::uint8_t buffer[64])
 {
 boost::uint32_t a, b, c, d, e;
 typedef union {
@@ -118,7 +110,7 @@ static boost::uint8_t workspace[64];
 
 /* SHA1Init - Initialize new context */
 
-void SHA1Init(SHA1_CTX* context)
+void SHA1::Init(SHA1::CTX* context)
 {
 		/* SHA1 initialization constants */
 		context->state[0] = 0x67452301;
@@ -132,7 +124,7 @@ void SHA1Init(SHA1_CTX* context)
 
 /* Run your data through this. */
 
-void SHA1Update(SHA1_CTX* context, boost::uint8_t* data, unsigned int len)
+void SHA1::Update(SHA1::CTX* context, boost::uint8_t* data, unsigned int len)
 {
 unsigned int i, j;
 
@@ -141,9 +133,9 @@ unsigned int i, j;
 		context->count[1] += (len >> 29);
 		if ((j + len) > 63) {
 				memcpy(&context->buffer[j], data, (i = 64-j));
-				SHA1Transform(context->state, context->buffer);
+				Transform(context->state, context->buffer);
 				for ( ; i + 63 < len; i += 64) {
-						SHA1Transform(context->state, &data[i]);
+						Transform(context->state, &data[i]);
 				}
 				j = 0;
 		}
@@ -154,7 +146,7 @@ unsigned int i, j;
 
 /* Add padding and return the message digest. */
 
-void SHA1Final(boost::uint8_t digest[20], SHA1_CTX* context)
+void SHA1::Final(boost::uint8_t digest[20], SHA1::CTX* context)
 {
 boost::uint32_t i, j;
 boost::uint8_t finalcount[8];
@@ -163,11 +155,11 @@ boost::uint8_t finalcount[8];
 				finalcount[i] = (boost::uint8_t) ((context->count[(i >= 4 ? 0 : 1)]
 				 >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
 		}
-		SHA1Update(context, (boost::uint8_t *)("\200"), 1);
+		Update(context, (boost::uint8_t *)("\200"), 1);
 		while ((context->count[0] & 504) != 448) {
-				SHA1Update(context, (boost::uint8_t *)("\0"), 1);
+				Update(context, (boost::uint8_t *)("\0"), 1);
 		}
-		SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
+		Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
 		for (i = 0; i < 20; i++) {
 				digest[i] = (boost::uint8_t)
 				 ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
@@ -179,24 +171,43 @@ boost::uint8_t finalcount[8];
 		memset(context->count, 0, 8);
 		memset(&finalcount, 0, 8);
 #ifdef SHA1HANDSOFF  /* make SHA1Transform overwrite it's own static vars */
-		SHA1Transform(context->state, context->buffer);
+		Transform(context->state, context->buffer);
 #endif
 }
 
 // -----------------------------------------------------------------------------
 
-#include "Swiften/StringCodecs/SHA1.h"
-
 namespace Swift {
 
+SHA1::SHA1() {
+	Init(&context);
+}
+
+SHA1& SHA1::update(const std::vector<unsigned char>& input) {
+	std::vector<unsigned char> inputCopy(input);
+	Update(&context, (boost::uint8_t*) vecptr(inputCopy), inputCopy.size());
+	return *this;
+}
+
+std::vector<unsigned char> SHA1::getHash() const {
+	std::vector<unsigned char> digest;
+	digest.resize(20);
+	CTX contextCopy(context);
+	Final((boost::uint8_t*) vecptr(digest), &contextCopy);
+	return digest;
+}
+
 ByteArray SHA1::getHash(const ByteArray& input) {
-	ByteArray inputCopy(input);
+	CTX context;
+	Init(&context);
+
+	std::vector<unsigned char> inputCopy(input);
+	Update(&context, (boost::uint8_t*) vecptr(inputCopy), inputCopy.size());
+
 	ByteArray digest;
 	digest.resize(20);
-	SHA1_CTX context;
-	SHA1Init(&context);
-	SHA1Update(&context, (boost::uint8_t*) inputCopy.getData(), inputCopy.getSize());
-	SHA1Final((boost::uint8_t*) digest.getData(), &context);
+	Final((boost::uint8_t*) vecptr(digest), &context);
+
 	return digest;
 }
 
diff --git a/Swiften/StringCodecs/SHA1.h b/Swiften/StringCodecs/SHA1.h
index fc5ba0e..671d890 100644
--- a/Swiften/StringCodecs/SHA1.h
+++ b/Swiften/StringCodecs/SHA1.h
@@ -6,11 +6,38 @@
 
 #pragma once
 
-#include "Swiften/Base/ByteArray.h"
+#include <vector>
+#include <boost/cstdint.hpp>
+
+#include <Swiften/Base/ByteArray.h>
 
 namespace Swift {
 	class SHA1 {
 		public:
+			SHA1();
+
+			SHA1& update(const std::vector<unsigned char>& data);
+			std::vector<unsigned char> getHash() const;
+
+			/**
+			 * Equivalent of:
+			 *	SHA1().update(data),getHash(), but slightly more efficient and
+			 *	convenient.
+			 */
 			static ByteArray getHash(const ByteArray& data);
+
+		private:
+			typedef struct {
+					boost::uint32_t state[5];
+					boost::uint32_t count[2];
+					boost::uint8_t buffer[64];
+			} CTX;
+			static void Init(CTX* context);
+			static void Transform(boost::uint32_t state[5], boost::uint8_t buffer[64]);
+			static void Update(CTX* context, boost::uint8_t* data, unsigned int len);
+			static void Final(boost::uint8_t digest[20], CTX* context);
+
+		private:
+			CTX context;
 	};
 }
diff --git a/Swiften/StringCodecs/UnitTest/Base64Test.cpp b/Swiften/StringCodecs/UnitTest/Base64Test.cpp
index b263050..d1ad5d7 100644
--- a/Swiften/StringCodecs/UnitTest/Base64Test.cpp
+++ b/Swiften/StringCodecs/UnitTest/Base64Test.cpp
@@ -4,12 +4,13 @@
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
-#include "Swiften/Base/ByteArray.h"
+#include <Swiften/Base/ByteArray.h>
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
-#include "Swiften/StringCodecs/Base64.h"
+#include <QA/Checker/IO.h>
+#include <Swiften/StringCodecs/Base64.h>
 
 using namespace Swift;
 
@@ -24,12 +25,12 @@ class Base64Test : public CppUnit::TestFixture {
 
 	public:
 		void testEncode() {
-			std::string result(Base64::encode("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"));
+			std::string result(Base64::encode(createByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890")));
 			CPPUNIT_ASSERT_EQUAL(std::string("QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejEyMzQ1Njc4OTA="), result);
 		}
 
 		void testEncode_NonAscii() {
-			std::string result(Base64::encode(ByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed")));
+			std::string result(Base64::encode(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed")));
 			CPPUNIT_ASSERT_EQUAL(std::string("QgayPKawpkPSDYmwT/WM94uAlu0="), result);
 		}
 
@@ -40,7 +41,7 @@ class Base64Test : public CppUnit::TestFixture {
 
 		void testDecode() {
 			ByteArray result(Base64::decode("QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejEyMzQ1Njc4OTA="));
-			CPPUNIT_ASSERT_EQUAL(ByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"), result);
 		}
 
 		void testDecode_NoData() {
diff --git a/Swiften/StringCodecs/UnitTest/HMACSHA1Test.cpp b/Swiften/StringCodecs/UnitTest/HMACSHA1Test.cpp
index 44bd5b7..efb613f 100644
--- a/Swiften/StringCodecs/UnitTest/HMACSHA1Test.cpp
+++ b/Swiften/StringCodecs/UnitTest/HMACSHA1Test.cpp
@@ -4,13 +4,14 @@
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
-#include "Swiften/Base/ByteArray.h"
+#include <Swiften/Base/ByteArray.h>
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
-#include "Swiften/Base/ByteArray.h"
-#include "Swiften/StringCodecs/HMACSHA1.h"
+#include <QA/Checker/IO.h>
+#include <Swiften/Base/ByteArray.h>
+#include <Swiften/StringCodecs/HMACSHA1.h>
 
 using namespace Swift;
 
@@ -21,8 +22,8 @@ class HMACSHA1Test : public CppUnit::TestFixture {
 
 	public:
 		void testGetResult() {
-			ByteArray result(HMACSHA1::getResult("foo", "foobar"));
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\xa4\xee\xba\x8e\x63\x3d\x77\x88\x69\xf5\x68\xd0\x5a\x1b\x3d\xc7\x2b\xfd\x4\xdd"), result);
+			ByteArray result(HMACSHA1::getResult(createByteArray("foo"), createByteArray("foobar")));
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\xa4\xee\xba\x8e\x63\x3d\x77\x88\x69\xf5\x68\xd0\x5a\x1b\x3d\xc7\x2b\xfd\x4\xdd"), result);
 		}
 };
 
diff --git a/Swiften/StringCodecs/UnitTest/HexifyTest.cpp b/Swiften/StringCodecs/UnitTest/HexifyTest.cpp
index 0f267bf..9cbd0d4 100644
--- a/Swiften/StringCodecs/UnitTest/HexifyTest.cpp
+++ b/Swiften/StringCodecs/UnitTest/HexifyTest.cpp
@@ -7,9 +7,9 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
-#include "Swiften/StringCodecs/Hexify.h"
+#include <Swiften/StringCodecs/Hexify.h>
 #include <string>
-#include "Swiften/Base/ByteArray.h"
+#include <Swiften/Base/ByteArray.h>
 
 using namespace Swift;
 
@@ -21,7 +21,7 @@ class HexifyTest : public CppUnit::TestFixture {
 
 	public:
 		void testHexify() {
-			CPPUNIT_ASSERT_EQUAL(std::string("4206b23ca6b0a643d20d89b04ff58cf78b8096ed"), Hexify::hexify(ByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed")));
+			CPPUNIT_ASSERT_EQUAL(std::string("4206b23ca6b0a643d20d89b04ff58cf78b8096ed"), Hexify::hexify(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed")));
 		}
 
 		void testHexify_Byte() {
diff --git a/Swiften/StringCodecs/UnitTest/MD5Test.cpp b/Swiften/StringCodecs/UnitTest/MD5Test.cpp
index b76af48..c66d422 100644
--- a/Swiften/StringCodecs/UnitTest/MD5Test.cpp
+++ b/Swiften/StringCodecs/UnitTest/MD5Test.cpp
@@ -4,13 +4,14 @@
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
-#include "Swiften/Base/ByteArray.h"
+#include <Swiften/Base/ByteArray.h>
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
-#include "Swiften/StringCodecs/MD5.h"
-#include "Swiften/Base/ByteArray.h"
+#include <QA/Checker/IO.h>
+#include <Swiften/StringCodecs/MD5.h>
+#include <Swiften/Base/ByteArray.h>
 
 using namespace Swift;
 
@@ -22,15 +23,15 @@ class MD5Test : public CppUnit::TestFixture {
 
 	public:
 		void testGetHash_Empty() {
-			ByteArray result(MD5::getHash(""));
+			ByteArray result(MD5::getHash(createByteArray("")));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\x09\x98\xec\xf8\x42\x7e", 16), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\x09\x98\xec\xf8\x42\x7e", 16), result);
 		}
 
 		void testGetHash_Alphabet() {
-			ByteArray result(MD5::getHash("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"));
+			ByteArray result(MD5::getHash(createByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\xd1\x74\xab\x98\xd2\x77\xd9\xf5\xa5\x61\x1c\x2c\x9f\x41\x9d\x9f", 16), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\xd1\x74\xab\x98\xd2\x77\xd9\xf5\xa5\x61\x1c\x2c\x9f\x41\x9d\x9f", 16), result);
 		}
 };
 
diff --git a/Swiften/StringCodecs/UnitTest/PBKDF2Test.cpp b/Swiften/StringCodecs/UnitTest/PBKDF2Test.cpp
index 092fe31..ae55ac8 100644
--- a/Swiften/StringCodecs/UnitTest/PBKDF2Test.cpp
+++ b/Swiften/StringCodecs/UnitTest/PBKDF2Test.cpp
@@ -4,13 +4,14 @@
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
-#include "Swiften/Base/ByteArray.h"
+#include <Swiften/Base/ByteArray.h>
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
-#include "Swiften/Base/ByteArray.h"
-#include "Swiften/StringCodecs/PBKDF2.h"
+#include <QA/Checker/IO.h>
+#include <Swiften/Base/ByteArray.h>
+#include <Swiften/StringCodecs/PBKDF2.h>
 
 using namespace Swift;
 
@@ -23,21 +24,21 @@ class PBKDF2Test : public CppUnit::TestFixture {
 
 	public:
 		void testGetResult_I1() {
-			ByteArray result(PBKDF2::encode("password", "salt", 1));
+			ByteArray result(PBKDF2::encode(createByteArray("password"), createByteArray("salt"), 1));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\x0c\x60\xc8\x0f\x96\x1f\x0e\x71\xf3\xa9\xb5\x24\xaf\x60\x12\x06\x2f\xe0\x37\xa6"), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x0c\x60\xc8\x0f\x96\x1f\x0e\x71\xf3\xa9\xb5\x24\xaf\x60\x12\x06\x2f\xe0\x37\xa6"), result);
 		}
 
 		void testGetResult_I2() {
-			ByteArray result(PBKDF2::encode("password", "salt", 2));
+			ByteArray result(PBKDF2::encode(createByteArray("password"), createByteArray("salt"), 2));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\xea\x6c\x1\x4d\xc7\x2d\x6f\x8c\xcd\x1e\xd9\x2a\xce\x1d\x41\xf0\xd8\xde\x89\x57"), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\xea\x6c\x1\x4d\xc7\x2d\x6f\x8c\xcd\x1e\xd9\x2a\xce\x1d\x41\xf0\xd8\xde\x89\x57"), result);
 		}
 
 		void testGetResult_I4096() {
-			ByteArray result(PBKDF2::encode("password", "salt", 4096));
+			ByteArray result(PBKDF2::encode(createByteArray("password"), createByteArray("salt"), 4096));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\x4b\x00\x79\x1\xb7\x65\x48\x9a\xbe\xad\x49\xd9\x26\xf7\x21\xd0\x65\xa4\x29\xc1", 20), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x4b\x00\x79\x1\xb7\x65\x48\x9a\xbe\xad\x49\xd9\x26\xf7\x21\xd0\x65\xa4\x29\xc1", 20), result);
 		}
 };
 
diff --git a/Swiften/StringCodecs/UnitTest/SHA1Test.cpp b/Swiften/StringCodecs/UnitTest/SHA1Test.cpp
index 9434235..004b646 100644
--- a/Swiften/StringCodecs/UnitTest/SHA1Test.cpp
+++ b/Swiften/StringCodecs/UnitTest/SHA1Test.cpp
@@ -4,41 +4,89 @@
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
-#include "Swiften/Base/ByteArray.h"
+#include <Swiften/Base/ByteArray.h>
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
-#include "Swiften/StringCodecs/SHA1.h"
+#include <QA/Checker/IO.h>
+#include <Swiften/StringCodecs/SHA1.h>
 
 using namespace Swift;
 
 class SHA1Test : public CppUnit::TestFixture {
 		CPPUNIT_TEST_SUITE(SHA1Test);
 		CPPUNIT_TEST(testGetHash);
-		CPPUNIT_TEST(testGetHash_Twice);
+		CPPUNIT_TEST(testGetHash_TwoUpdates);
+		CPPUNIT_TEST(testGetHash_TwoGetHash);
 		CPPUNIT_TEST(testGetHash_NoData);
+		CPPUNIT_TEST(testGetHash_InterleavedUpdate);
+		CPPUNIT_TEST(testGetHashStatic);
+		CPPUNIT_TEST(testGetHashStatic_Twice);
+		CPPUNIT_TEST(testGetHashStatic_NoData);
 		CPPUNIT_TEST_SUITE_END();
 
 	public:
 		void testGetHash() {
-			ByteArray result(SHA1::getHash("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), result);
+			SHA1 sha;
+			sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
+
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());
+		}
+
+		void testGetHash_TwoUpdates() {
+			SHA1 sha;
+			sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<"));
+			sha.update(createByteArray("http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
+
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());
+		}
+
+		void testGetHash_TwoGetHash() {
+			SHA1 sha;
+			sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
+
+			sha.getHash();
+
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());
+		}
+
+		void testGetHash_InterleavedUpdate() {
+			SHA1 sha;
+
+			sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<"));
+			sha.getHash();
+			sha.update(createByteArray("http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
+
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());
+		}
+
+
+		void testGetHash_NoData() {
+			SHA1 sha;
+			sha.update(std::vector<unsigned char>());
+
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90\xaf\xd8\x07\x09"), sha.getHash());
 		}
 
+		void testGetHashStatic() {
+			ByteArray result(SHA1::getHash(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<")));
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), result);
+		}
 
-		void testGetHash_Twice() {
-			ByteArray input("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<");
+
+		void testGetHashStatic_Twice() {
+			ByteArray input(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));
 			SHA1::getHash(input);
 			ByteArray result(SHA1::getHash(input));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), result);
 		}
 
-		void testGetHash_NoData() {
+		void testGetHashStatic_NoData() {
 			ByteArray result(SHA1::getHash(ByteArray()));
 
-			CPPUNIT_ASSERT_EQUAL(ByteArray("\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90\xaf\xd8\x07\x09"), result);
+			CPPUNIT_ASSERT_EQUAL(createByteArray("\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18\x90\xaf\xd8\x07\x09"), result);
 		}
 };