Boost/C++11 shared pointers.

15 files changed, 178 insertions, 174 deletions

diff --git a/tests/parser/attachmentHelperTest.cpp b/tests/parser/attachmentHelperTest.cpp
index 0ddf2448..4d4a2623 100644
--- a/tests/parser/attachmentHelperTest.cpp
+++ b/tests/parser/attachmentHelperTest.cpp
@@ -39,9 +39,9 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 	VMIME_TEST_LIST_END
 
 
-	static const vmime::string getStructure(vmime::ref <vmime::bodyPart> part)
+	static const vmime::string getStructure(vmime::shared_ptr <vmime::bodyPart> part)
 	{
-		vmime::ref <vmime::body> bdy = part->getBody();
+		vmime::shared_ptr <vmime::body> bdy = part->getBody();
 
 		vmime::string res = part->getBody()->getContentType().generate();
 
@@ -52,7 +52,7 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 
 		for (size_t i = 0 ; i < bdy->getPartCount() ; ++i)
 		{
-			vmime::ref <vmime::bodyPart> subPart = bdy->getPartAt(i);
+			vmime::shared_ptr <vmime::bodyPart> subPart = bdy->getPartAt(i);
 
 			if (i != 0)
 				res += ",";
@@ -63,9 +63,9 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 		return res + "]";
 	}
 
-	static const vmime::string extractBodyContents(vmime::ref <const vmime::bodyPart> part)
+	static const vmime::string extractBodyContents(vmime::shared_ptr <const vmime::bodyPart> part)
 	{
-		vmime::ref <const vmime::contentHandler> cth = part->getBody()->getContents();
+		vmime::shared_ptr <const vmime::contentHandler> cth = part->getBody()->getContents();
 
 		vmime::string data;
 		vmime::utility::outputStreamStringAdapter os(data);
@@ -83,11 +83,11 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 "The text\r\n"
 "";
 
-		vmime::ref <vmime::message> msg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 		msg->parse(data);
 
-		vmime::ref <vmime::attachment> att = vmime::create <vmime::defaultAttachment>
-			(vmime::create <vmime::stringContentHandler>("test"),
+		vmime::shared_ptr <vmime::attachment> att = vmime::make_shared <vmime::defaultAttachment>
+			(vmime::make_shared <vmime::stringContentHandler>("test"),
 				vmime::mediaType("image/jpeg"));
 
 		vmime::attachmentHelper::addAttachment(msg, att);
@@ -112,11 +112,11 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 "--foo--\r\n"
 "";
 
-		vmime::ref <vmime::message> msg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 		msg->parse(data);
 
-		vmime::ref <vmime::attachment> att = vmime::create <vmime::defaultAttachment>
-			(vmime::create <vmime::stringContentHandler>("test"),
+		vmime::shared_ptr <vmime::attachment> att = vmime::make_shared <vmime::defaultAttachment>
+			(vmime::make_shared <vmime::stringContentHandler>("test"),
 				vmime::mediaType("image/jpeg"));
 
 		vmime::attachmentHelper::addAttachment(msg, att);
@@ -136,11 +136,11 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 "\r\n"
 "TWVzc2FnZSBib2R5";
 
-		vmime::ref <vmime::message> msg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 		msg->parse(data);
 
-		vmime::ref <vmime::attachment> att = vmime::create <vmime::defaultAttachment>
-			(vmime::create <vmime::stringContentHandler>("test"),
+		vmime::shared_ptr <vmime::attachment> att = vmime::make_shared <vmime::defaultAttachment>
+			(vmime::make_shared <vmime::stringContentHandler>("test"),
 				vmime::mediaType("image/jpeg"));
 
 		vmime::attachmentHelper::addAttachment(msg, att);
@@ -155,7 +155,7 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 	{
 		vmime::string data = "Content-Disposition: attachment\r\n\r\nFoo\r\n";
 
-		vmime::ref <vmime::bodyPart> p = vmime::create <vmime::bodyPart>();
+		vmime::shared_ptr <vmime::bodyPart> p = vmime::make_shared <vmime::bodyPart>();
 		p->parse(data);
 
 		VASSERT_EQ("1", true, vmime::attachmentHelper::isBodyPartAnAttachment(p));
@@ -167,7 +167,7 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 	{
 		vmime::string data = "Content-Type: multipart/*\r\n\r\nFoo\r\n";
 
-		vmime::ref <vmime::bodyPart> p = vmime::create <vmime::bodyPart>();
+		vmime::shared_ptr <vmime::bodyPart> p = vmime::make_shared <vmime::bodyPart>();
 		p->parse(data);
 
 		VASSERT_EQ("1", false, vmime::attachmentHelper::isBodyPartAnAttachment(p));
@@ -184,7 +184,7 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 	{
 		vmime::string data = "Content-Type: application/octet-stream\r\n\r\nFoo\r\n";
 
-		vmime::ref <vmime::bodyPart> p = vmime::create <vmime::bodyPart>();
+		vmime::shared_ptr <vmime::bodyPart> p = vmime::make_shared <vmime::bodyPart>();
 		p->parse(data);
 
 		VASSERT_EQ("1", true, vmime::attachmentHelper::isBodyPartAnAttachment(p));
@@ -199,7 +199,7 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 			"Content-Id: bar\r\n"
 			"\r\nFoo\r\n";
 
-		vmime::ref <vmime::bodyPart> p = vmime::create <vmime::bodyPart>();
+		vmime::shared_ptr <vmime::bodyPart> p = vmime::make_shared <vmime::bodyPart>();
 		p->parse(data);
 
 		VASSERT_EQ("1", false, vmime::attachmentHelper::isBodyPartAnAttachment(p));
@@ -215,10 +215,10 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 			"\r\n"
 			"Foo bar baz";
 
-		vmime::ref <vmime::bodyPart> part = vmime::create <vmime::bodyPart>();
+		vmime::shared_ptr <vmime::bodyPart> part = vmime::make_shared <vmime::bodyPart>();
 		part->parse(data);
 
-		vmime::ref <const vmime::attachment> att =
+		vmime::shared_ptr <const vmime::attachment> att =
 			vmime::attachmentHelper::getBodyPartAttachment(part);
 
 		VASSERT_EQ("1", "image/jpeg", att->getType().generate());
@@ -233,7 +233,7 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 		VASSERT_EQ("5", "Foo bar baz", attData);
 
 		//VASSERT_EQ("6", part, att->getPart());
-		VASSERT_EQ("6", part->generate(), att->getPart().dynamicCast <const vmime::component>()->generate());
+		VASSERT_EQ("6", part->generate(), vmime::dynamicCast <const vmime::component>(att->getPart())->generate());
 		//VASSERT_EQ("7", part->getHeader(), att->getHeader());
 		VASSERT_EQ("7", part->getHeader()->generate(), att->getHeader()->generate());
 	}
@@ -246,7 +246,7 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 "\r\n"
 "Message body";
 
-		vmime::ref <vmime::message> msg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 		msg->parse(data);
 
 		const vmime::string attData =
@@ -256,7 +256,7 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 "\r\n"
 "QXR0YWNoZWQgbWVzc2FnZSBib2R5";
 
-		vmime::ref <vmime::message> amsg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> amsg = vmime::make_shared <vmime::message>();
 		amsg->parse(attData);
 
 		vmime::attachmentHelper::addAttachment(msg, amsg);
@@ -265,20 +265,20 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 		VASSERT_EQ("2", "Message body", extractBodyContents(msg->getBody()->getPartAt(0)));
 
 		// Ensure message has been encoded properly
-		vmime::ref <const vmime::bodyPart> attPart = msg->getBody()->getPartAt(1);
-		vmime::ref <const vmime::contentHandler> attCth = attPart->getBody()->getContents();
+		vmime::shared_ptr <const vmime::bodyPart> attPart = msg->getBody()->getPartAt(1);
+		vmime::shared_ptr <const vmime::contentHandler> attCth = attPart->getBody()->getContents();
 
 		vmime::string attDataOut;
 		vmime::utility::outputStreamStringAdapter attDataOutOs(attDataOut);
 
 		attCth->extract(attDataOutOs);
 
-		vmime::ref <vmime::message> amsgOut = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> amsgOut = vmime::make_shared <vmime::message>();
 		amsgOut->parse(attDataOut);
 
-		vmime::ref <vmime::header> hdr = amsgOut->getHeader();
+		vmime::shared_ptr <vmime::header> hdr = amsgOut->getHeader();
 
-		VASSERT_EQ("3", "Attached message", hdr->Subject()->getValue().dynamicCast <vmime::text>()->generate());
+		VASSERT_EQ("3", "Attached message", hdr->Subject()->getValue <vmime::text>()->generate());
 		VASSERT_EQ("4", "Attached message body", extractBodyContents(amsgOut));
 	}
 
@@ -300,25 +300,25 @@ VMIME_TEST_SUITE_BEGIN(attachmentHelperTest)
 "FooBar\r\n"
 "--foo--\r\n";
 
-		vmime::ref <vmime::message> msg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 		msg->parse(data);
 
 		VASSERT_EQ("0", 2, msg->getBody()->getPartCount());
 
-		vmime::ref <const vmime::attachment> att = vmime::attachmentHelper::
+		vmime::shared_ptr <const vmime::attachment> att = vmime::attachmentHelper::
 			getBodyPartAttachment(msg->getBody()->getPartAt(0));
 
 		VASSERT("1", att != NULL);
 
-		vmime::ref <const vmime::messageAttachment> msgAtt =
-			att.dynamicCast <const vmime::messageAttachment>();
+		vmime::shared_ptr <const vmime::messageAttachment> msgAtt =
+			vmime::dynamicCast <const vmime::messageAttachment>(att);
 
 		VASSERT("2", msgAtt != NULL);
 
-		vmime::ref <vmime::message> amsg = msgAtt->getMessage();
-		vmime::ref <vmime::header> hdr = amsg->getHeader();
+		vmime::shared_ptr <vmime::message> amsg = msgAtt->getMessage();
+		vmime::shared_ptr <vmime::header> hdr = amsg->getHeader();
 
-		VASSERT_EQ("3", "Attached message", hdr->Subject()->getValue().dynamicCast <vmime::text>()->generate());
+		VASSERT_EQ("3", "Attached message", hdr->Subject()->getValue <vmime::text>()->generate());
 		VASSERT_EQ("4", "Attached message body", extractBodyContents(amsg));
 	}
 
diff --git a/tests/parser/bodyPartTest.cpp b/tests/parser/bodyPartTest.cpp
index 453982e0..f6f82f75 100644
--- a/tests/parser/bodyPartTest.cpp
+++ b/tests/parser/bodyPartTest.cpp
@@ -49,7 +49,7 @@ VMIME_TEST_SUITE_BEGIN(bodyPartTest)
 		                     buffer.begin() + c.getParsedOffset() + c.getParsedLength());
 	}
 
-	static const vmime::string extractContents(const vmime::ref <const vmime::contentHandler> cts)
+	static const vmime::string extractContents(const vmime::shared_ptr <const vmime::contentHandler> cts)
 	{
 		std::ostringstream oss;
 		vmime::utility::outputStreamAdapter os(oss);
@@ -105,7 +105,7 @@ VMIME_TEST_SUITE_BEGIN(bodyPartTest)
 	{
 		vmime::bodyPart p1;
 		p1.getHeader()->getField("Foo")->setValue(vmime::string("bar"));
-		p1.getBody()->setContents(vmime::create <vmime::stringContentHandler>("Baz"));
+		p1.getBody()->setContents(vmime::make_shared <vmime::stringContentHandler>("Baz"));
 
 		VASSERT_EQ("1", "Foo: bar\r\n\r\nBaz", p1.generate());
 	}
@@ -162,7 +162,7 @@ VMIME_TEST_SUITE_BEGIN(bodyPartTest)
 			"--=_+ZWjySayKqSf2CyrfnNpaAcO6-G1HpoXdHZ4YyswAWqEY39Q--\r\n"
 			"Epilog text";
 
-		vmime::ref<vmime::message> msg = vmime::create<vmime::message>();
+		vmime::shared_ptr<vmime::message> msg = vmime::make_shared<vmime::message>();
 
 		std::string istr(testmail);
 
@@ -223,26 +223,26 @@ VMIME_TEST_SUITE_BEGIN(bodyPartTest)
 	/** Ensure '7bit' encoding is used when body is 7-bit only. */
 	void testGenerate7bit()
 	{
-		vmime::ref <vmime::plainTextPart> p1 = vmime::create <vmime::plainTextPart>();
-		p1->setText(vmime::create <vmime::stringContentHandler>("Part1 is US-ASCII only."));
+		vmime::shared_ptr <vmime::plainTextPart> p1 = vmime::make_shared <vmime::plainTextPart>();
+		p1->setText(vmime::make_shared <vmime::stringContentHandler>("Part1 is US-ASCII only."));
 
-		vmime::ref <vmime::message> msg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 		p1->generateIn(msg, msg);
 
-		vmime::ref <vmime::header> header1 = msg->getBody()->getPartAt(0)->getHeader();
+		vmime::shared_ptr <vmime::header> header1 = msg->getBody()->getPartAt(0)->getHeader();
 		VASSERT_EQ("1", "7bit", header1->ContentTransferEncoding()->getValue()->generate());
 	}
 
 	void testTextUsageForQPEncoding()
 	{
-		vmime::ref <vmime::plainTextPart> part = vmime::create <vmime::plainTextPart>();
-		part->setText(vmime::create <vmime::stringContentHandler>("Part1-line1\r\nPart1-line2\r\n\x89"));
+		vmime::shared_ptr <vmime::plainTextPart> part = vmime::make_shared <vmime::plainTextPart>();
+		part->setText(vmime::make_shared <vmime::stringContentHandler>("Part1-line1\r\nPart1-line2\r\n\x89"));
 
-		vmime::ref <vmime::message> msg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 		part->generateIn(msg, msg);
 
-		vmime::ref <vmime::body> body = msg->getBody()->getPartAt(0)->getBody();
-		vmime::ref <vmime::header> header = msg->getBody()->getPartAt(0)->getHeader();
+		vmime::shared_ptr <vmime::body> body = msg->getBody()->getPartAt(0)->getBody();
+		vmime::shared_ptr <vmime::header> header = msg->getBody()->getPartAt(0)->getHeader();
 
 		std::ostringstream oss;
 		vmime::utility::outputStreamAdapter os(oss);
@@ -339,30 +339,30 @@ VMIME_TEST_SUITE_BEGIN(bodyPartTest)
 		oss << "\r\n"
 		    << "--MY-BOUNDARY--\r\n";
 
-		vmime::ref <vmime::utility::inputStreamStringAdapter> is =
-			vmime::create <vmime::utility::inputStreamStringAdapter>(oss.str());
+		vmime::shared_ptr <vmime::utility::inputStreamStringAdapter> is =
+			vmime::make_shared <vmime::utility::inputStreamStringAdapter>(oss.str());
 
-		vmime::ref <vmime::message> msg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 		msg->parse(is, oss.str().length());
 
-		vmime::ref <vmime::body> body1 = msg->getBody()->getPartAt(0)->getBody();
-		vmime::ref <const vmime::contentHandler> body1Cts = body1->getContents();
+		vmime::shared_ptr <vmime::body> body1 = msg->getBody()->getPartAt(0)->getBody();
+		vmime::shared_ptr <const vmime::contentHandler> body1Cts = body1->getContents();
 
-		vmime::ref <vmime::body> body2 = msg->getBody()->getPartAt(1)->getBody();
-		vmime::ref <const vmime::contentHandler> body2Cts = body2->getContents();
+		vmime::shared_ptr <vmime::body> body2 = msg->getBody()->getPartAt(1)->getBody();
+		vmime::shared_ptr <const vmime::contentHandler> body2Cts = body2->getContents();
 
 		vmime::string body1CtsExtracted;
 		vmime::utility::outputStreamStringAdapter body1CtsExtractStream(body1CtsExtracted);
 		body1Cts->extract(body1CtsExtractStream);
 
 		VASSERT_EQ("1.1", BODY1_LENGTH, body1Cts->getLength());
-		VASSERT("1.2", body1Cts.dynamicCast <const vmime::streamContentHandler>() != NULL);
+		VASSERT("1.2", vmime::dynamicCast <const vmime::streamContentHandler>(body1Cts) != NULL);
 		VASSERT_EQ("1.3", BODY1_LENGTH, body1CtsExtracted.length());
 		VASSERT_EQ("1.4", BODY1_BEGIN, body1CtsExtracted.substr(0, BODY1_BEGIN.length()));
 		VASSERT_EQ("1.5", BODY1_END, body1CtsExtracted.substr(BODY1_LENGTH - BODY1_END.length(), BODY1_END.length()));
 
 		VASSERT_EQ("2.1", BODY2_LINE.length() * BODY2_REPEAT, body2Cts->getLength());
-		VASSERT("2.2", body2Cts.dynamicCast <const vmime::streamContentHandler>() != NULL);
+		VASSERT("2.2", vmime::dynamicCast <const vmime::streamContentHandler>(body2Cts) != NULL);
 	}
 
 VMIME_TEST_SUITE_END
diff --git a/tests/parser/bodyTest.cpp b/tests/parser/bodyTest.cpp
index bb4d966b..92a4575e 100644
--- a/tests/parser/bodyTest.cpp
+++ b/tests/parser/bodyTest.cpp
@@ -40,7 +40,7 @@ VMIME_TEST_SUITE_BEGIN(bodyTest)
 		// Quoted-Printable encoding
 
 		vmime::bodyPart p;
-		p.getBody()->setContents(vmime::create <vmime::stringContentHandler>
+		p.getBody()->setContents(vmime::make_shared <vmime::stringContentHandler>
 			("Foo éé\r\né bar\r\nbaz"), vmime::mediaType("text", "plain"),
 			 vmime::charset("utf-8"), vmime::encoding("quoted-printable"));
 
@@ -54,7 +54,7 @@ VMIME_TEST_SUITE_BEGIN(bodyTest)
 	void testGenerate_NonText()
 	{
 		vmime::bodyPart p;
-		p.getBody()->setContents(vmime::create <vmime::stringContentHandler>
+		p.getBody()->setContents(vmime::make_shared <vmime::stringContentHandler>
 			("Binary\xfa\xfb\r\ndata\r\n\r\n\xfc"), vmime::mediaType("application", "octet-stream"),
 			 vmime::charset("utf-8"), vmime::encoding("quoted-printable"));
 
diff --git a/tests/parser/charsetFilteredOutputStreamTest.cpp b/tests/parser/charsetFilteredOutputStreamTest.cpp
index 32c4c5f3..4c91a71c 100644
--- a/tests/parser/charsetFilteredOutputStreamTest.cpp
+++ b/tests/parser/charsetFilteredOutputStreamTest.cpp
@@ -42,12 +42,12 @@ VMIME_TEST_SUITE_BEGIN(charsetFilteredOutputStreamTest)
 
 	void testInputBufferUnderflow()
 	{
-		vmime::ref <vmime::charsetConverter> cc =
+		vmime::shared_ptr <vmime::charsetConverter> cc =
 			vmime::charsetConverter::create("utf-8", "iso-8859-1");
 
 		vmime::string output;
 		vmime::utility::outputStreamStringAdapter os(output);
-		vmime::ref <vmime::utility::filteredOutputStream> cfos = cc->getFilteredOutputStream(os);
+		vmime::shared_ptr <vmime::utility::filteredOutputStream> cfos = cc->getFilteredOutputStream(os);
 
 		VASSERT_NOT_NULL("filteredOutputStream availability", cfos);
 
@@ -73,12 +73,12 @@ VMIME_TEST_SUITE_BEGIN(charsetFilteredOutputStreamTest)
 		vmime::string actualOut;
 		vmime::utility::outputStreamStringAdapter osa(actualOut);
 
-		vmime::ref <vmime::charsetConverter> conv =
+		vmime::shared_ptr <vmime::charsetConverter> conv =
 			vmime::charsetConverter::create
 				(vmime::charset("utf-8"),
 				 vmime::charset("iso-8859-1"));
 
-		vmime::ref <vmime::utility::charsetFilteredOutputStream> os =
+		vmime::shared_ptr <vmime::utility::charsetFilteredOutputStream> os =
 			conv->getFilteredOutputStream(osa);
 
 		VASSERT_NOT_NULL("filteredOutputStream availability", os);
@@ -114,10 +114,10 @@ VMIME_TEST_SUITE_BEGIN(charsetFilteredOutputStreamTest)
 			vmime::string actualOut;
 			vmime::utility::outputStreamStringAdapter osa(actualOut);
 
-			vmime::ref <vmime::charsetConverter> conv =
+			vmime::shared_ptr <vmime::charsetConverter> conv =
 				vmime::charsetConverter::create(entry.fromCharset, entry.toCharset);
 
-			vmime::ref <vmime::utility::charsetFilteredOutputStream> os =
+			vmime::shared_ptr <vmime::utility::charsetFilteredOutputStream> os =
 				conv->getFilteredOutputStream(osa);
 
 			VASSERT_NOT_NULL("filteredOutputStream availability", os);
@@ -151,10 +151,10 @@ VMIME_TEST_SUITE_BEGIN(charsetFilteredOutputStreamTest)
 			vmime::string actualOut;
 			vmime::utility::outputStreamStringAdapter osa(actualOut);
 
-			vmime::ref <vmime::charsetConverter> conv =
+			vmime::shared_ptr <vmime::charsetConverter> conv =
 				vmime::charsetConverter::create(entry.fromCharset, entry.toCharset);
 
-			vmime::ref <vmime::utility::charsetFilteredOutputStream> os =
+			vmime::shared_ptr <vmime::utility::charsetFilteredOutputStream> os =
 				conv->getFilteredOutputStream(osa);
 
 			VASSERT_NOT_NULL("filteredOutputStream availability", os);
@@ -191,10 +191,10 @@ VMIME_TEST_SUITE_BEGIN(charsetFilteredOutputStreamTest)
 			vmime::string actualOut;
 			vmime::utility::outputStreamStringAdapter osa(actualOut);
 
-			vmime::ref <vmime::charsetConverter> conv =
+			vmime::shared_ptr <vmime::charsetConverter> conv =
 				vmime::charsetConverter::create(entry.fromCharset, entry.toCharset);
 
-			vmime::ref <vmime::utility::charsetFilteredOutputStream> os =
+			vmime::shared_ptr <vmime::utility::charsetFilteredOutputStream> os =
 				conv->getFilteredOutputStream(osa);
 
 			VASSERT_NOT_NULL("filteredOutputStream availability", os);
diff --git a/tests/parser/fileContentHandlerTest.cpp b/tests/parser/fileContentHandlerTest.cpp
index b7373959..9d1459db 100644
--- a/tests/parser/fileContentHandlerTest.cpp
+++ b/tests/parser/fileContentHandlerTest.cpp
@@ -38,7 +38,7 @@ VMIME_TEST_SUITE_BEGIN(fileContentHandlerTest)
 	VMIME_TEST_LIST_END
 
 
-	vmime::ref <vmime::utility::file> testFile;
+	vmime::shared_ptr <vmime::utility::file> testFile;
 	vmime::string testDataEncoded, testDataDecoded;
 
 
@@ -50,7 +50,7 @@ VMIME_TEST_SUITE_BEGIN(fileContentHandlerTest)
 		std::ostringstream testFilePath;
 		testFilePath << "/tmp/vmime_test_" << (rand() % 999999999);
 
-		vmime::ref <vmime::utility::fileSystemFactory> fsf =
+		vmime::shared_ptr <vmime::utility::fileSystemFactory> fsf =
 			vmime::platform::getHandler()->getFileSystemFactory();
 
 		testFile = fsf->create(fsf->stringToPath(testFilePath.str()));
@@ -61,7 +61,7 @@ VMIME_TEST_SUITE_BEGIN(fileContentHandlerTest)
 	void tearDown()
 	{
 		testFile->remove();
-		testFile = NULL;
+		testFile = vmime::null;
 	}
 
 
diff --git a/tests/parser/headerFieldTest.cpp b/tests/parser/headerFieldTest.cpp
index b551c781..5281a3a2 100644
--- a/tests/parser/headerFieldTest.cpp
+++ b/tests/parser/headerFieldTest.cpp
@@ -35,16 +35,17 @@ VMIME_TEST_SUITE_BEGIN(headerFieldTest)
 
 	void testBadValueType()
 	{
-		vmime::headerFieldFactory *hfactory = vmime::headerFieldFactory::getInstance();
+		vmime::shared_ptr <vmime::headerFieldFactory> hfactory =
+			vmime::headerFieldFactory::getInstance();
 
 		// "To" header field accepts values of type "addressList"
-		vmime::ref <vmime::headerField> to = hfactory->create(vmime::fields::TO);
+		vmime::shared_ptr <vmime::headerField> to = hfactory->create(vmime::fields::TO);
 		VASSERT_THROW("to",
 			to->setValue(vmime::mailbox("[email protected]")),
 			vmime::exceptions::bad_field_value_type);
 
 		// Unregistered header field accepts any value type
-		vmime::ref <vmime::headerField> custom = hfactory->create("X-MyCustomHeader");
+		vmime::shared_ptr <vmime::headerField> custom = hfactory->create("X-MyCustomHeader");
 		VASSERT_NO_THROW("custom/1",
 			custom->setValue(vmime::mailbox("[email protected]")));
 		VASSERT_NO_THROW("custom/2",
@@ -57,11 +58,11 @@ VMIME_TEST_SUITE_BEGIN(headerFieldTest)
 
 		const vmime::string buffer = "Field: \r\n\tfield data";
 
-		vmime::ref <vmime::headerField> hfield =
+		vmime::shared_ptr <vmime::headerField> hfield =
 			vmime::headerField::parseNext(ctx, buffer, 0, buffer.size());
 
-		vmime::ref <vmime::text> hvalue =
-			hfield->getValue().dynamicCast <vmime::text>();
+		vmime::shared_ptr <vmime::text> hvalue =
+			hfield->getValue <vmime::text>();
 
 		VASSERT_EQ("Field name", "Field", hfield->getName());
 		VASSERT_EQ("Field value", "field data", hvalue->getWholeBuffer());
@@ -73,11 +74,11 @@ VMIME_TEST_SUITE_BEGIN(headerFieldTest)
 
 		const vmime::string buffer = "Field: \r\n\tfield data   ";
 
-		vmime::ref <vmime::headerField> hfield =
+		vmime::shared_ptr <vmime::headerField> hfield =
 			vmime::headerField::parseNext(ctx, buffer, 0, buffer.size());
 
-		vmime::ref <vmime::text> hvalue =
-			hfield->getValue().dynamicCast <vmime::text>();
+		vmime::shared_ptr <vmime::text> hvalue =
+			hfield->getValue <vmime::text>();
 
 		VASSERT_EQ("Field name", "Field", hfield->getName());
 		VASSERT_EQ("Field value", toHex("field data"), toHex(hvalue->getWholeBuffer()));
diff --git a/tests/parser/headerTest.cpp b/tests/parser/headerTest.cpp
index 91eb03df..959fc631 100644
--- a/tests/parser/headerTest.cpp
+++ b/tests/parser/headerTest.cpp
@@ -100,10 +100,10 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("");
 
-		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("A", "a");
+		vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("A", "a");
 		hdr.appendField(hf);
 
-		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.getFieldList();
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(1), res.size());
 		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
@@ -114,10 +114,10 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("A: a\r\n");
 
-		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
+		vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
 		hdr.appendField(hf);
 
-		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.getFieldList();
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(2), res.size());
 		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
@@ -130,10 +130,10 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("A: a\r\nC: c\r\n");
 
-		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
+		vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
 		hdr.insertFieldBefore(hdr.getField("C"), hf);
 
-		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.getFieldList();
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(3), res.size());
 		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
@@ -146,10 +146,10 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("A: a\r\nC: c\r\n");
 
-		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
+		vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
 		hdr.insertFieldBefore(1, hf);
 
-		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.getFieldList();
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(3), res.size());
 		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
@@ -163,10 +163,10 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("A: a\r\nC: c\r\n");
 
-		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
+		vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
 		hdr.insertFieldAfter(hdr.getField("A"), hf);
 
-		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.getFieldList();
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(3), res.size());
 		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
@@ -179,10 +179,10 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("A: a\r\nC: c\r\n");
 
-		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
+		vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("B", "b");
 		hdr.insertFieldAfter(0, hf);
 
-		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.getFieldList();
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(3), res.size());
 		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
@@ -196,10 +196,10 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("A: a\r\nB: b\r\nC: c\r\n");
 
-		vmime::ref <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("Z", "z");
+		vmime::shared_ptr <vmime::headerField> hf = vmime::headerFieldFactory::getInstance()->create("Z", "z");
 		hdr.replaceField(hdr.getField("B"), hf);
 
-		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.getFieldList();
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(3), res.size());
 		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
@@ -217,13 +217,13 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		hdr1.removeField(hdr1.getField("B"));
 		hdr2.removeField(1);
 
-		std::vector <vmime::ref <vmime::headerField> > res1 = hdr1.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res1 = hdr1.getFieldList();
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(2), res1.size());
 		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res1[0]));
 		VASSERT_EQ("Second value", "C: c", headerTest::getFieldValue(*res1[1]));
 
-		std::vector <vmime::ref <vmime::headerField> > res2 = hdr2.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res2 = hdr2.getFieldList();
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(2), res2.size());
 		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res2[0]));
@@ -239,10 +239,10 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		hdr1.removeField(hdr1.getField("A"));
 		hdr2.removeField(0);
 
-		std::vector <vmime::ref <vmime::headerField> > res1 = hdr1.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res1 = hdr1.getFieldList();
 		VASSERT_EQ("Count", static_cast <unsigned int>(0), res1.size());
 
-		std::vector <vmime::ref <vmime::headerField> > res2 = hdr2.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res2 = hdr2.getFieldList();
 		VASSERT_EQ("Count", static_cast <unsigned int>(0), res2.size());
 	}
 
@@ -256,10 +256,10 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		hdr1.removeAllFields();
 		hdr2.removeAllFields();
 
-		std::vector <vmime::ref <vmime::headerField> > res1 = hdr1.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res1 = hdr1.getFieldList();
 		VASSERT_EQ("Count", static_cast <unsigned int>(0), res1.size());
 
-		std::vector <vmime::ref <vmime::headerField> > res2 = hdr2.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res2 = hdr2.getFieldList();
 		VASSERT_EQ("Count", static_cast <unsigned int>(0), res2.size());
 	}
 
@@ -295,7 +295,7 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("B: b\r\nA: a\r\nC: c\r\n");
 
-		vmime::ref <vmime::headerField> res = hdr.getFieldAt(2);
+		vmime::shared_ptr <vmime::headerField> res = hdr.getFieldAt(2);
 
 		VASSERT_EQ("Value", "C: c", getFieldValue(*res));
 	}
@@ -306,7 +306,7 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("A: a\r\nB: b1\r\nC: c\r\nB: b2\r\n");
 
-		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.getFieldList();
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(4), res.size());
 		VASSERT_EQ("First value", "A: a", headerTest::getFieldValue(*res[0]));
@@ -320,7 +320,7 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("\r\n");
 
-		std::vector <vmime::ref <vmime::headerField> > res = hdr.getFieldList();
+		std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.getFieldList();
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(0), res.size());
 	}
@@ -331,7 +331,7 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("A: a\r\nB: b\r\nC: c\r\nB: d\r\n");
 
-		vmime::ref <vmime::headerField> res = hdr.findField("B");
+		vmime::shared_ptr <vmime::headerField> res = hdr.findField("B");
 
 		VASSERT_EQ("Value", "B: b", getFieldValue(*res));
 	}
@@ -342,7 +342,7 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("A: a1\nC: c1\n");
 
-		std::vector <vmime::ref <vmime::headerField> > res = hdr.findAllFields("B");
+		std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.findAllFields("B");
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(0), res.size());
 	}
@@ -352,7 +352,7 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("A: a1\nB: b1\nB: b2\nC: c1\n");
 
-		std::vector <vmime::ref <vmime::headerField> > res = hdr.findAllFields("B");
+		std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.findAllFields("B");
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(2), res.size());
 		VASSERT_EQ("First value", "B: b1", headerTest::getFieldValue(*res[0]));
@@ -364,7 +364,7 @@ VMIME_TEST_SUITE_BEGIN(headerTest)
 		vmime::header hdr;
 		hdr.parse("A: a1\nB: b1\nB: b2\nC: c1\nC: c3\nC: c2\n");
 
-		std::vector <vmime::ref <vmime::headerField> > res = hdr.findAllFields("C");
+		std::vector <vmime::shared_ptr <vmime::headerField> > res = hdr.findAllFields("C");
 
 		VASSERT_EQ("Count", static_cast <unsigned int>(3), res.size());
 		VASSERT_EQ("First value", "C: c1", headerTest::getFieldValue(*res[0]));
diff --git a/tests/parser/htmlTextPartTest.cpp b/tests/parser/htmlTextPartTest.cpp
index 0eb7bbaf..278a87c1 100644
--- a/tests/parser/htmlTextPartTest.cpp
+++ b/tests/parser/htmlTextPartTest.cpp
@@ -35,7 +35,7 @@ VMIME_TEST_SUITE_BEGIN(htmlTextPartTest)
 
 
 	static const vmime::string extractContent
-		(vmime::ref <const vmime::contentHandler> cth)
+		(vmime::shared_ptr <const vmime::contentHandler> cth)
 	{
 		std::ostringstream oss;
 		vmime::utility::outputStreamAdapter osa(oss);
@@ -74,7 +74,7 @@ VMIME_TEST_SUITE_BEGIN(htmlTextPartTest)
 "--LEVEL1--\r\n"
 "";
 
-		vmime::ref <vmime::message> msg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 		msg->parse(msgString);
 
 		// Sanity checks
@@ -129,7 +129,7 @@ VMIME_TEST_SUITE_BEGIN(htmlTextPartTest)
 "--LEVEL1--\r\n"
 "";
 
-		vmime::ref <vmime::message> msg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 		msg->parse(msgString);
 
 		// Sanity checks
@@ -153,7 +153,7 @@ VMIME_TEST_SUITE_BEGIN(htmlTextPartTest)
 		VASSERT_EQ("has-obj2-pre", true, htmlPart.hasObject("cid:image2@test"));
 
 		// Check data in objects
-		vmime::ref <const vmime::htmlTextPart::embeddedObject> obj;
+		vmime::shared_ptr <const vmime::htmlTextPart::embeddedObject> obj;
 
 		obj = htmlPart.findObject("image1@test");
 
@@ -201,7 +201,7 @@ VMIME_TEST_SUITE_BEGIN(htmlTextPartTest)
 "--LEVEL1--\r\n"
 "";
 
-		vmime::ref <vmime::message> msg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 		msg->parse(msgString);
 
 		// Sanity checks
@@ -221,7 +221,7 @@ VMIME_TEST_SUITE_BEGIN(htmlTextPartTest)
 		VASSERT_EQ("has-obj-cid", false, htmlPart.hasObject("image1@test"));
 
 		// Check data
-		vmime::ref <const vmime::htmlTextPart::embeddedObject> obj;
+		vmime::shared_ptr <const vmime::htmlTextPart::embeddedObject> obj;
 
 		obj = htmlPart.findObject("http://www.vmime.org/test/image1.png");
 
diff --git a/tests/parser/mailboxGroupTest.cpp b/tests/parser/mailboxGroupTest.cpp
index 49d22658..6c1319da 100644
--- a/tests/parser/mailboxGroupTest.cpp
+++ b/tests/parser/mailboxGroupTest.cpp
@@ -57,8 +57,8 @@ VMIME_TEST_SUITE_BEGIN(mailboxGroupTest)
 		VASSERT_EQ("count", 1, addrs.getAddressCount());
 		VASSERT_TRUE("is group", addrs.getAddressAt(0)->isGroup());
 
-		vmime::ref <vmime::mailboxGroup> mgrp =
-			addrs.getAddressAt(0).dynamicCast <vmime::mailboxGroup>();
+		vmime::shared_ptr <vmime::mailboxGroup> mgrp =
+			vmime::dynamicCast <vmime::mailboxGroup>(addrs.getAddressAt(0));
 
 		VASSERT_EQ("name", "group", mgrp->getName().getWholeBuffer());
 		VASSERT_EQ("count", 2, mgrp->getMailboxCount());
diff --git a/tests/parser/mailboxTest.cpp b/tests/parser/mailboxTest.cpp
index e6e4a608..6bf6670c 100644
--- a/tests/parser/mailboxTest.cpp
+++ b/tests/parser/mailboxTest.cpp
@@ -119,7 +119,8 @@ VMIME_TEST_SUITE_BEGIN(mailboxTest)
 		VASSERT_EQ("count", 1, addrList.getAddressCount());
 		VASSERT_EQ("!group", false, addrList.getAddressAt(0)->isGroup());
 
-		vmime::ref <vmime::mailbox> mbox = addrList.getAddressAt(0).dynamicCast <vmime::mailbox>();
+		vmime::shared_ptr <vmime::mailbox> mbox =
+			vmime::dynamicCast <vmime::mailbox>(addrList.getAddressAt(0));
 
 		VASSERT_EQ("name", "Full Name", mbox->getName());
 		VASSERT_EQ("email", "", mbox->getEmail());
@@ -132,8 +133,10 @@ VMIME_TEST_SUITE_BEGIN(mailboxTest)
 
 		VASSERT_EQ("count", 2, addrList.getAddressCount());
 
-		vmime::ref <vmime::mailbox> mbox1 = addrList.getAddressAt(0).dynamicCast <vmime::mailbox>();
-		vmime::ref <vmime::mailbox> mbox2 = addrList.getAddressAt(1).dynamicCast <vmime::mailbox>();
+		vmime::shared_ptr <vmime::mailbox> mbox1 =
+			vmime::dynamicCast <vmime::mailbox>(addrList.getAddressAt(0));
+		vmime::shared_ptr <vmime::mailbox> mbox2 =
+			vmime::dynamicCast <vmime::mailbox>(addrList.getAddressAt(1));
 
 		VASSERT_EQ("name1", vmime::text(), mbox1->getName());
 		VASSERT_EQ("email1", "[email protected]", mbox1->getEmail());
diff --git a/tests/parser/messageIdSequenceTest.cpp b/tests/parser/messageIdSequenceTest.cpp
index ed6d0be3..bc5c7617 100644
--- a/tests/parser/messageIdSequenceTest.cpp
+++ b/tests/parser/messageIdSequenceTest.cpp
@@ -64,13 +64,13 @@ VMIME_TEST_SUITE_BEGIN(messageIdSequenceTest)
 	void testGenerate()
 	{
 		vmime::messageIdSequence s1;
-		s1.appendMessageId(vmime::create <vmime::messageId>("a", "b"));
+		s1.appendMessageId(vmime::make_shared <vmime::messageId>("a", "b"));
 
 		VASSERT_EQ("1", "<a@b>", s1.generate());
 
 		vmime::messageIdSequence s2;
-		s2.appendMessageId(vmime::create <vmime::messageId>("a", "b"));
-		s2.appendMessageId(vmime::create <vmime::messageId>("c", "d"));
+		s2.appendMessageId(vmime::make_shared <vmime::messageId>("a", "b"));
+		s2.appendMessageId(vmime::make_shared <vmime::messageId>("c", "d"));
 
 		VASSERT_EQ("2", "<a@b> <c@d>", s2.generate());
 	}
diff --git a/tests/parser/messageTest.cpp b/tests/parser/messageTest.cpp
index 56605e39..a7a16813 100644
--- a/tests/parser/messageTest.cpp
+++ b/tests/parser/messageTest.cpp
@@ -35,12 +35,12 @@ VMIME_TEST_SUITE_BEGIN(messageTest)
 	{
 		vmime::generationContext ctx;
 
-		vmime::ref <vmime::message> msg = vmime::create <vmime::message>();
+		vmime::shared_ptr <vmime::message> msg = vmime::make_shared <vmime::message>();
 		msg->getHeader()->getField("Foo")->setValue(vmime::string("bar"));
 
 		vmime::htmlTextPart textPart;
-		textPart.setPlainText(vmime::create <vmime::stringContentHandler>("Foo bar bazé foo foo foo"));
-		textPart.setText(vmime::create <vmime::stringContentHandler>("Foo bar <strong>bazé</strong> foo foo foo"));
+		textPart.setPlainText(vmime::make_shared <vmime::stringContentHandler>("Foo bar bazé foo foo foo"));
+		textPart.setText(vmime::make_shared <vmime::stringContentHandler>("Foo bar <strong>bazé</strong> foo foo foo"));
 		textPart.generateIn(msg, msg);
 
 		// Estimated/computed generated size must be greater than the actual generated size
diff --git a/tests/parser/parameterTest.cpp b/tests/parser/parameterTest.cpp
index 3ebd6e35..3b0edebf 100644
--- a/tests/parser/parameterTest.cpp
+++ b/tests/parser/parameterTest.cpp
@@ -197,19 +197,19 @@ VMIME_TEST_SUITE_BEGIN(parameterTest)
 	{
 		// Simple parameter/value
 		parameterizedHeaderField p1;
-		p1.appendParameter(vmime::create <vmime::parameter>("param1", "value1"));
+		p1.appendParameter(vmime::make_shared <vmime::parameter>("param1", "value1"));
 
 		VASSERT_EQ("1", "F: X; param1=value1", p1.generate());
 
 		// Value that needs quoting (1/2)
 		parameterizedHeaderField p2a;
-		p2a.appendParameter(vmime::create <vmime::parameter>("param1", "value1a;value1b"));
+		p2a.appendParameter(vmime::make_shared <vmime::parameter>("param1", "value1a;value1b"));
 
 		VASSERT_EQ("2a", "F: X; param1=\"value1a;value1b\"", p2a.generate());
 
 		// Value that needs quoting (2/2)
 		parameterizedHeaderField p2b;
-		p2b.appendParameter(vmime::create <vmime::parameter>("param1", "va\\lue\"1"));
+		p2b.appendParameter(vmime::make_shared <vmime::parameter>("param1", "va\\lue\"1"));
 
 		VASSERT_EQ("2b", "F: X; param1=\"va\\\\lue\\\"1\"", p2b.generate());
 	}
@@ -218,7 +218,7 @@ VMIME_TEST_SUITE_BEGIN(parameterTest)
 	{
 		// Extended parameter with charset specifier
 		parameterizedHeaderField p1;
-		p1.appendParameter(vmime::create <vmime::parameter>("param1",
+		p1.appendParameter(vmime::make_shared <vmime::parameter>("param1",
 			vmime::word("value 1\xe9", vmime::charset("charset"))));
 
 #if VMIME_ALWAYS_GENERATE_7BIT_PARAMETER
@@ -229,7 +229,7 @@ VMIME_TEST_SUITE_BEGIN(parameterTest)
 
 		// Value that spans on multiple lines
 		parameterizedHeaderField p2;
-		p2.appendParameter(vmime::create <vmime::parameter>("param1",
+		p2.appendParameter(vmime::make_shared <vmime::parameter>("param1",
 			vmime::word("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
 				    vmime::charset("charset"))));
 
@@ -256,7 +256,7 @@ VMIME_TEST_SUITE_BEGIN(parameterTest)
 
 		// Non-ASCII parameter value
 		parameterizedHeaderField p3;
-		p3.appendParameter(vmime::create <vmime::parameter>("param1",
+		p3.appendParameter(vmime::make_shared <vmime::parameter>("param1",
 			vmime::word("δσσσσσσσσσσσσσσσσσσσσδσδα δσαδσδσαδσαδασδασ δσαδασδσα δσαδασδσα δασδασδασ δασαχφδδσα 2008.doc",
 				vmime::charset("utf-8"))));
 
@@ -325,28 +325,28 @@ VMIME_TEST_SUITE_BEGIN(parameterTest)
 	// Encode "tspecials"
 	void testEncodeTSpecials()
 	{
-		VASSERT_EQ(" 1", "p=\"val(ue\"",  vmime::create <vmime::parameter>("p", "val(ue")->generate());
-		VASSERT_EQ(" 2", "p=\"val)ue\"",  vmime::create <vmime::parameter>("p", "val)ue")->generate());
-		VASSERT_EQ(" 3", "p=\"val<ue\"",  vmime::create <vmime::parameter>("p", "val<ue")->generate());
-		VASSERT_EQ(" 4", "p=\"val>ue\"",  vmime::create <vmime::parameter>("p", "val>ue")->generate());
-		VASSERT_EQ(" 5", "p=\"val@ue\"",  vmime::create <vmime::parameter>("p", "val@ue")->generate());
-		VASSERT_EQ(" 6", "p=\"val,ue\"",  vmime::create <vmime::parameter>("p", "val,ue")->generate());
-		VASSERT_EQ(" 7", "p=\"val;ue\"",  vmime::create <vmime::parameter>("p", "val;ue")->generate());
-		VASSERT_EQ(" 8", "p=\"val:ue\"",  vmime::create <vmime::parameter>("p", "val:ue")->generate());
-		VASSERT_EQ(" 9", "p=\"val/ue\"",  vmime::create <vmime::parameter>("p", "val/ue")->generate());
-		VASSERT_EQ("10", "p=\"val[ue\"",  vmime::create <vmime::parameter>("p", "val[ue")->generate());
-		VASSERT_EQ("11", "p=\"val]ue\"",  vmime::create <vmime::parameter>("p", "val]ue")->generate());
-		VASSERT_EQ("12", "p=\"val?ue\"",  vmime::create <vmime::parameter>("p", "val?ue")->generate());
-		VASSERT_EQ("13", "p=\"val=ue\"",  vmime::create <vmime::parameter>("p", "val=ue")->generate());
-		VASSERT_EQ("14", "p=\"val ue\"",  vmime::create <vmime::parameter>("p", "val ue")->generate());
-		VASSERT_EQ("15", "p=\"val\tue\"", vmime::create <vmime::parameter>("p", "val\tue")->generate());
+		VASSERT_EQ(" 1", "p=\"val(ue\"",  vmime::make_shared <vmime::parameter>("p", "val(ue")->generate());
+		VASSERT_EQ(" 2", "p=\"val)ue\"",  vmime::make_shared <vmime::parameter>("p", "val)ue")->generate());
+		VASSERT_EQ(" 3", "p=\"val<ue\"",  vmime::make_shared <vmime::parameter>("p", "val<ue")->generate());
+		VASSERT_EQ(" 4", "p=\"val>ue\"",  vmime::make_shared <vmime::parameter>("p", "val>ue")->generate());
+		VASSERT_EQ(" 5", "p=\"val@ue\"",  vmime::make_shared <vmime::parameter>("p", "val@ue")->generate());
+		VASSERT_EQ(" 6", "p=\"val,ue\"",  vmime::make_shared <vmime::parameter>("p", "val,ue")->generate());
+		VASSERT_EQ(" 7", "p=\"val;ue\"",  vmime::make_shared <vmime::parameter>("p", "val;ue")->generate());
+		VASSERT_EQ(" 8", "p=\"val:ue\"",  vmime::make_shared <vmime::parameter>("p", "val:ue")->generate());
+		VASSERT_EQ(" 9", "p=\"val/ue\"",  vmime::make_shared <vmime::parameter>("p", "val/ue")->generate());
+		VASSERT_EQ("10", "p=\"val[ue\"",  vmime::make_shared <vmime::parameter>("p", "val[ue")->generate());
+		VASSERT_EQ("11", "p=\"val]ue\"",  vmime::make_shared <vmime::parameter>("p", "val]ue")->generate());
+		VASSERT_EQ("12", "p=\"val?ue\"",  vmime::make_shared <vmime::parameter>("p", "val?ue")->generate());
+		VASSERT_EQ("13", "p=\"val=ue\"",  vmime::make_shared <vmime::parameter>("p", "val=ue")->generate());
+		VASSERT_EQ("14", "p=\"val ue\"",  vmime::make_shared <vmime::parameter>("p", "val ue")->generate());
+		VASSERT_EQ("15", "p=\"val\tue\"", vmime::make_shared <vmime::parameter>("p", "val\tue")->generate());
 	}
 
 	// http://sourceforge.net/projects/vmime/forums/forum/237356/topic/3812278
 	void testEncodeTSpecialsInRFC2231()
 	{
 		VASSERT_EQ("1", "filename*=UTF-8''my_file_name_%C3%B6%C3%A4%C3%BC_%281%29.txt",
-			vmime::create <vmime::parameter>("filename", "my_file_name_\xc3\xb6\xc3\xa4\xc3\xbc_(1).txt")->generate());
+			vmime::make_shared <vmime::parameter>("filename", "my_file_name_\xc3\xb6\xc3\xa4\xc3\xbc_(1).txt")->generate());
 	}
 
 	void testWhitespaceBreaksTheValue()
diff --git a/tests/parser/streamContentHandlerTest.cpp b/tests/parser/streamContentHandlerTest.cpp
index 75b3d4d4..55680c93 100644
--- a/tests/parser/streamContentHandlerTest.cpp
+++ b/tests/parser/streamContentHandlerTest.cpp
@@ -51,8 +51,8 @@ VMIME_TEST_SUITE_BEGIN(streamContentHandlerTest)
 	void testGetLength()
 	{
 		vmime::string data("Test Data");
-		vmime::ref <vmime::utility::inputStream> stream =
-			vmime::create <vmime::utility::inputStreamStringAdapter>(data);
+		vmime::shared_ptr <vmime::utility::inputStream> stream =
+			vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);
 
 		vmime::streamContentHandler cth(stream, data.length());
 
@@ -63,8 +63,8 @@ VMIME_TEST_SUITE_BEGIN(streamContentHandlerTest)
 	void testIsEncoded()
 	{
 		vmime::string data("Test Data");
-		vmime::ref <vmime::utility::inputStream> stream =
-			vmime::create <vmime::utility::inputStreamStringAdapter>(data);
+		vmime::shared_ptr <vmime::utility::inputStream> stream =
+			vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);
 
 		vmime::streamContentHandler cth(stream, data.length());
 
@@ -73,8 +73,8 @@ VMIME_TEST_SUITE_BEGIN(streamContentHandlerTest)
 
 
 		vmime::string data2("Zm9vEjRWYmFy=");
-		vmime::ref <vmime::utility::inputStream> stream2 =
-			vmime::create <vmime::utility::inputStreamStringAdapter>(data2);
+		vmime::shared_ptr <vmime::utility::inputStream> stream2 =
+			vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data2);
 
 		vmime::streamContentHandler cth2(stream2, data2.length(), vmime::encoding("base64"));
 
@@ -85,8 +85,8 @@ VMIME_TEST_SUITE_BEGIN(streamContentHandlerTest)
 	void testGetLength_Encoded()
 	{
 		vmime::string data("foo=12=34=56bar");
-		vmime::ref <vmime::utility::inputStream> stream =
-			vmime::create <vmime::utility::inputStreamStringAdapter>(data);
+		vmime::shared_ptr <vmime::utility::inputStream> stream =
+			vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);
 
 		vmime::streamContentHandler cth(stream, data.length(), vmime::encoding("quoted-printable"));
 
@@ -97,8 +97,8 @@ VMIME_TEST_SUITE_BEGIN(streamContentHandlerTest)
 	void testExtract()
 	{
 		vmime::string data("Test Data");
-		vmime::ref <vmime::utility::inputStream> stream =
-			vmime::create <vmime::utility::inputStreamStringAdapter>(data);
+		vmime::shared_ptr <vmime::utility::inputStream> stream =
+			vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);
 
 		vmime::streamContentHandler cth(stream, data.length());
 
@@ -114,8 +114,8 @@ VMIME_TEST_SUITE_BEGIN(streamContentHandlerTest)
 	{
 		vmime::string data
 			("QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODk=");
-		vmime::ref <vmime::utility::inputStream> stream =
-			vmime::create <vmime::utility::inputStreamStringAdapter>(data);
+		vmime::shared_ptr <vmime::utility::inputStream> stream =
+			vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);
 
 		vmime::streamContentHandler cth(stream, data.length(), vmime::encoding("base64"));
 
@@ -133,8 +133,8 @@ VMIME_TEST_SUITE_BEGIN(streamContentHandlerTest)
 	{
 		vmime::string data
 			("QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODk=");
-		vmime::ref <vmime::utility::inputStream> stream =
-			vmime::create <vmime::utility::inputStreamStringAdapter>(data);
+		vmime::shared_ptr <vmime::utility::inputStream> stream =
+			vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);
 
 		vmime::streamContentHandler cth(stream, data.length(), vmime::encoding("base64"));
 
@@ -151,8 +151,8 @@ VMIME_TEST_SUITE_BEGIN(streamContentHandlerTest)
 	void testGenerate()
 	{
 		vmime::string data("foo\x12\x34\x56 bar");
-		vmime::ref <vmime::utility::inputStream> stream =
-			vmime::create <vmime::utility::inputStreamStringAdapter>(data);
+		vmime::shared_ptr <vmime::utility::inputStream> stream =
+			vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);
 
 		vmime::streamContentHandler cth(stream, data.length());
 
@@ -168,8 +168,8 @@ VMIME_TEST_SUITE_BEGIN(streamContentHandlerTest)
 	void testGenerate_Encoded()
 	{
 		vmime::string data("foo=12=34=56bar");
-		vmime::ref <vmime::utility::inputStream> stream =
-			vmime::create <vmime::utility::inputStreamStringAdapter>(data);
+		vmime::shared_ptr <vmime::utility::inputStream> stream =
+			vmime::make_shared <vmime::utility::inputStreamStringAdapter>(data);
 
 		vmime::streamContentHandler cth(stream, data.length(), vmime::encoding("quoted-printable"));
 
diff --git a/tests/parser/textTest.cpp b/tests/parser/textTest.cpp
index f4f30b1b..274687a5 100644
--- a/tests/parser/textTest.cpp
+++ b/tests/parser/textTest.cpp
@@ -104,7 +104,7 @@ VMIME_TEST_SUITE_BEGIN(textTest)
 		VASSERT_EQ("4.3", w1.getCharset(), t4.getWordAt(0)->getCharset());
 
 		vmime::word w2("Other", vmime::charset(vmime::charsets::US_ASCII));
-		t4.appendWord(vmime::create <vmime::word>(w2));
+		t4.appendWord(vmime::make_shared <vmime::word>(w2));
 
 		vmime::text t5(t4);
 
@@ -296,8 +296,8 @@ VMIME_TEST_SUITE_BEGIN(textTest)
 
 		// White-space between two encoded words
 		vmime::text txt;
-		txt.appendWord(vmime::create <vmime::word>("\xc3\x89t\xc3\xa9", "utf-8"));
-		txt.appendWord(vmime::create <vmime::word>("Fran\xc3\xa7ois", "utf-8"));
+		txt.appendWord(vmime::make_shared <vmime::word>("\xc3\x89t\xc3\xa9", "utf-8"));
+		txt.appendWord(vmime::make_shared <vmime::word>("Fran\xc3\xa7ois", "utf-8"));
 
 		const vmime::string decoded = "\xc3\x89t\xc3\xa9""Fran\xc3\xa7ois";
 		const vmime::string encoded = "=?utf-8?B?w4l0w6k=?= =?utf-8?Q?Fran=C3=A7ois?=";
@@ -319,11 +319,11 @@ VMIME_TEST_SUITE_BEGIN(textTest)
 	{
 		// White-space between two encoded words (#2)
 		vmime::text txt;
-		txt.appendWord(vmime::create <vmime::word>("Facture ", "utf-8"));
-		txt.appendWord(vmime::create <vmime::word>("\xc3\xa0", "utf-8"));
-		txt.appendWord(vmime::create <vmime::word>(" envoyer ", "utf-8"));
-		txt.appendWord(vmime::create <vmime::word>("\xc3\xa0", "utf-8"));
-		txt.appendWord(vmime::create <vmime::word>(" Martine", "utf-8"));
+		txt.appendWord(vmime::make_shared <vmime::word>("Facture ", "utf-8"));
+		txt.appendWord(vmime::make_shared <vmime::word>("\xc3\xa0", "utf-8"));
+		txt.appendWord(vmime::make_shared <vmime::word>(" envoyer ", "utf-8"));
+		txt.appendWord(vmime::make_shared <vmime::word>("\xc3\xa0", "utf-8"));
+		txt.appendWord(vmime::make_shared <vmime::word>(" Martine", "utf-8"));
 
 		const vmime::string decoded = "Facture ""\xc3\xa0"" envoyer ""\xc3\xa0"" Martine";
 		const vmime::string encoded = "Facture =?utf-8?B?w6A=?= envoyer =?utf-8?B?w6A=?= Martine";
@@ -422,8 +422,8 @@ VMIME_TEST_SUITE_BEGIN(textTest)
 		VASSERT_EQ("generate1", "=?us-ascii?Q?Achim_?= =?utf-8?Q?Br=C3=A4ndt?= <[email protected]>", mbox.generate());
 
 		vmime::text txt;
-		txt.appendWord(vmime::create <vmime::word>("Achim ", "us-ascii"));
-		txt.appendWord(vmime::create <vmime::word>("Br\xc3\xa4ndt", "utf-8"));
+		txt.appendWord(vmime::make_shared <vmime::word>("Achim ", "us-ascii"));
+		txt.appendWord(vmime::make_shared <vmime::word>("Br\xc3\xa4ndt", "utf-8"));
 		mbox = vmime::mailbox(txt, "[email protected]");
 		VASSERT_EQ("generate2", "=?us-ascii?Q?Achim_?= =?utf-8?Q?Br=C3=A4ndt?= <[email protected]>", mbox.generate());